CSCI 4500/6500 Programming Languages

Project 2: Scheme - L-System Fractals

Collaboration Policy - Read Carefully

You must work on this project individually, but you may discuss this assignment with other students in the class and ask and provide help in useful ways, preferable over our email list so we can all benefit from your great ideas. You may consult (but not copy) any outside resources you including books, papers, web sites and people.

If you use resources other than the class materials, indicate what you used along with your answer.

Objective

• Practice programming with recursive definitions and procedures
• Explore the power of rewrite rules
• Write recursive functions that manipulate lists
• Make our course logo better than "The Great Lambda Tree of Infinite Knowledge and Ultimate Power" (created by Professor David Evans, UVa). Best tree will be selected in class and will be next to the wise sage.

Background

In this problem set, you will explore a method of creating fractals known as the Lindenmayer system (or L-system). Aristid Lindenmayer, a theoretical biologist at the University of Utrecht, developed the L-system in 1968 as a mathematical theory of plant development. In the late 1980s, he collaborated with Przemyslaw Prusinkiewicz, a computer scientist at the University of Regina, to explore computational properties of the L-system and developed many of the ideas on which this problem set is based.

The idea behind L-system fractals is that we can describe a curve as a list of lines and turns, and create new curves by rewriting old curves. Everything in an L-system curve is either a forward line (denoted by F), or a right turn (denoted by Ra where a is an angle in degrees clockwise). We can denote left turns by using negative angles.

We create fractals by recursively replacing all forward lines in a curve list with the original curve list. Lindemayer found that many objects in nature could be described using regularly repeating patterns. For example, the way some tree branches sprout from a trunk can be described using the pattern: F O(R30 F) F O(R-60 F) F. This is interpreted as: the trunk goes up one unit distance, a branch sprouts at an angle 30 degrees to the trunk and grows for one unit. The O means an offshoot — we draw the curve in the following parentheses, and then return to where we started before the offshoot. The trunk grows another unit and now another branch, this time at -60 degrees relative to the trunk grows for one units. Finally the trunk grows for one more unit. The branches continue to sprout in this manner as they get smaller and smaller, and eventually we reach the leaves.

We can describe this process using replacement rules:

Start: (F)
Rule: F ::= (F O(R30 F) F O(R-60 F) F)

Iteration 0: (F)
Iteration 1: (F O(R30 F) F O(R-60 F) F)
Iteration 2: (F O(R30 F) F O(R-60 F) F O(R30 F O(R30 F) F O(R-60 F) F) F O(R30 F) F O(R-60 F) F O(R-60 F O(R30 F) F O(R-60 F) F) F O(R30 F) F O(R-60 F) F)

Here's what that looks like:

Iteration 0

Iteration 1

Iteration 2

Iteration 5

The Great Lambda Tree of Infinite Knowledge and Ultimate Power

Note that L-system command rewriting is similar to the replacement rules in a BNF grammar. The important difference is that with L-system rewriting, each iteration replaces all instances of F in the initial string instead of just picking one to replace.

We can divide the problem of producing an L-system fractal into two main parts:

1. Produce a list of L-system commands that represents the fractal by rewriting according to the L-system rule; and
2. Drawing a list of L-system commands.

Representing L-System Commands

Here is a BNF grammar for L-system commands:

1. CommandSequence ::= ( CommandList )
   
2. CommandList ::= Command CommandList
   
3. CommandList ::=
   
4. Command ::= F
   
5. Command ::= RAngle
   
6. Command ::= OCommandSequence
   
7. Angle ::= Number
   

We need to find a way to turn strings in this grammar into objects we can manipulate in a Scheme program. We can do this by looking at the BNF grammar, and converting the non-terminals into Scheme objects.

;;; CommandSequence ::= ( CommandList )
(define make-lsystem-command list)

;;; We represent the different commands as pairs where the first item in the
;;; pair is a tag that indicates the type of command: 'f for forward, 'r for
;;; rotate and 'o for offshoot.  We use quoted letters to make tags, which 
;;; evaluate to the quoted letter.  The tag 'f is short for (quote f).

;;; Command ::= F
(define (make-forward-command) (cons 'f #f)) ;; No value, just use false.

;;; Command ::= RAngle
(define (make-rotate-command angle) (cons 'r angle))

;;; Command ::= OCommandSequence
(define (make-offshoot-command commandsequence) (cons 'o commandsequence))

You will find the following procedures useful:

• (car lst) — evaluates to the first part of the pair
• (cdr lst) — evaluates to the second part of the pair
• (eq? v1 v2) — evaluates to #t if v1 and v2 are exactly the same; otherwise evaluates to false. For example, (eq? 's 's) evaluates to #t and (eq? 's 't) evaluates to #f.
• (error message) — produces an error with message a string given as the first parameter. For example, (error "Yikes! Attempt to get-angle for a command that is not an angle command") would display the message in red and stop execution. It is useful to use error in your code so you will more easily identify bugs.

> (is-forward? (make-forward-command))

#t

> (is-forward? (make-rotate-command 90))

#f

> (get-angle (make-rotate-command 90))

90

> (get-angle (make-forward-command))

Yikes! Attempt to get-angle for a command that is not an angle command

Rewriting Curves

Start: (F)
Rule: F ::= (F O(R30 F) F O(R-60 F) F)

So, for every command in the list:

• If the command is an F command, replace it with the replacement commands
• If the command is an RAngle command, keep it unchanged
• If the command is an OCommandSequence command, recursively rewrite every command in the offshoot's command list the same way

For example, consider a simple L-System rewriting:

Start: (F)
Rule: F ::= (F R30 F)

Iteration1: (F R30 F)
Iteration2: (F R30 F R30 F R30 F)

Iteration1: ((F R30 F))
Iteration2: ((F R30 F) R30 (F R30 F))

(define (flatten-commands ll)
  (if (null? ll) ll
      (if (is-lsystem-command? (car ll))
	  (cons (car ll) (flatten-commands (cdr ll)))
	  (flat-append (car ll) (flatten-commands (cdr ll))))))

(define (flat-append lst ll)
  (if (null? lst) ll
      (cons (car lst) (flat-append (cdr lst) ll))))

To make interesting L-system curves, we will need to apply rewrite-lcommands many times. We will leave that until the last question. Next, we will work on turning sequences of L-system commands into curves we can draw.

Drawing L-System Fractals

Points

We will use a coordinate system from (0, 0) to (1, 1):

Points have x and y coordinates. To represent points we would like to define procedures make-point, x-of-point and y-of-point. Our pictures will be more interesting if points can have color too. So, we represent a colored point using a list of three values: x, y and color:

(define (make-point x y) (list x y))
(define (make-colored-point x y c) (list x y c))
(define (is-colored-point? (= (length point) 3)

(define (x-of-point point) (car point))
(define (y-of-point point) (cadr point)) ;; (cadr x) = (car (cdr x))

;;; Regular points are black.  Colored points have a color.
(define (color-of-point point)
  (if (is-colored-point? point)
      (caddr point) ;; == (car (cdr (cdr point)))
      (make-color 0 0 0)))

We have provided some procedures for drawing on the window in graphics.ss:

• (window-draw-point point) — Draw the point on the window. For example, (window-draw-point (make-point 0.5 0.5)) will place a black dot in the center of the window. (The point is only one pixel, so it is hard to see.)
• (window-draw-line point0 point1) — Draw a black line from point0 to point1. For example, (window-draw-line (make-point 0.0 0.0) (make-point 1.0 1.0)) will draw a diagonal line from the bottom left corner to the top right corner.

Drawing Curves

   (define (mid-line t)
      (make-point t 0.5))

Predict what (x-of-point (mid-line 0.7)) and (y-of-point (mid-line 0.7)) should evaluate to. Try them in your Interactions window.

Of course, there are infinitely many values between 0.0 and 1.0, so we can't apply the curve function to all of them. Instead, we select enough values to show the curve well. To draw a curve, we need to apply the curve procedure to many values in the range from 0.0 to 1.0 and draw each point it evaluates to. Here's a procedure that does that:

  (define (draw-curve-points curve n)
    (define (draw-curve-worker curve t step)
      (if (<= t 1.0)
	   (begin
	     (window-draw-point (curve t))
	     (draw-curve-worker curve (+ t step) step))))
    (draw-curve-worker curve 0.0 (/ 1 n)))

The draw-curve-worker procedure is defined recursively: if t is less than or equal to 1.0, we draw the current point using (window-draw-point (curve t)) and draw the rest of the points by evaluating (draw-curve-worker curve (+ t step) step)).

The draw-curve-worker code uses the special form begin. The evaluation rule for begin is:

Evaluation Rule 4 - begin. To evaluate (begin Expression₁ Expression₂ ... Expression_k), evaluate each sub-expression in order from left to right. The value of the begin expression is the value of Expression_k.

Manipulating Curves

For example, the procedure rotate-ccw takes a curve and rotates it 90 degrees counter-clockwise by swapping the x and y points:

(define (rotate-ccw curve)
  (lambda (t)
    (let ((ct (curve t)))
      (make-colored-point
       (- (y-of-point ct)) (x-of-point ct)
       (color-of-point ct)))))

Note that (rotate-ccw c) evaluates to a curve. The function rotate-ccw is a procedure that takes a procedure (a curve) and returns a procedure that is a curve.

Predict what (draw-curve-points (rotate-ccw mid-line) 1000) and (draw-curve-points (rotate-ccw (rotate-ccw mid-line)) 1000) will do. Confirm your predictions by trying them in your Interactions window.

Here's another example:

(define (shrink curve scale)
  (lambda (t)
    (let ((ct (curve t)))
      (make-colored-point
       (* scale (x-of-point ct))
       (* scale (y-of-point ct))
       (color-of-point ct)))))

The shrink procedure doesn't produce quite what we want because in addition to changing the size of the curve, it moves it around. Why does this happen? Try shrinking a few different curves to make sure you understand why the curve moves.

One way to fix this problem is to center our curves around (0,0) and then translate them to the middle of the screen. We can do this by adding or subtracting constants to the points they produce:

(define (translate curve x y)
  (lambda (t)
    (let ((ct (curve t)))
      (make-colored-point
       (+ x (x-of-point ct)) (+ y (y-of-point ct))
       (color-of-point ct)))))

   (define (horiz-line t) (make-point t 0))
   (define mid-line (translate horiz-line 0 0.5))

In addition to altering the points a curve produces, we can alter a curve by changing the t values it will see. For example,

(define (first-half curve)
   (lambda (t) (curve (/ t 2))))

Predict what each of these expressions will do:

• (draw-curve-points (first-half mid-line) 1000)
• (draw-curve-points (first-half (first-half mid-line)) 1000))

The provided code includes several other functions that transform curves including:

• (scale-x-y curve x-scale y-scale) — evaluates to curve stretched along the x and y axis by using the scale factors given
• (scale curve scale) — evaluates to curve stretched along the x and y axis by using the same scale factor
• (rotate-around-origin curve degrees) — evaluates to curve rotated counterclockwise by the given number of degrees.

It is also useful to have curve transforms where curves may be combined. An example is (connect-rigidly curve1 curve2) which evaluates to a curve that consists of curve1 followed by curve2. The starting point of the new curve is the starting point of curve1 and the end point of curve2 is the ending point of the new curve. Here's how connect-rigidly is defined:

(define (connect-rigidly curve1 curve2)
    (lambda (t)
      (if (< t (/ 1 2))
          (curve1 (* 2 t))
          (curve2 (- (* 2 t) 1)))))

Distributing t Values

The way connect-rigidly is defined above, we use all the t-values below 0.5 on the first curve, and use the t-values between 0.5 and 1.0 on the second curve. If the second curve is the result of connecting two other curves, like (connect-rigidly c1 (connect-rigidly c2 c3)) then 50% of the points will be used to draw c1, 25% to draw c2 and 25% to draw c3.

   (connect-rigidly c1 (connect-rigidly c2 (connect-rigidly curve3 (... cn))))

Your num-points procedure should produce results similar to:

> (exact->inexact (num-points 1000 10))

1.95

> (exact->inexact (num-points 1000 20))

0.0019073486328125

> (exact->inexact (num-points 1000000 20))

1.9073486328125

To fix this, we need to distribute the t-values between our curves more fairly. We have provided a procedure connect-curves-evenly in graphics.ss that connects a list of curves in a way that distributes the range of t values evenly between the curves.

The definition is a bit complicated, so don't worry if you don't understand it completely. You should, however, be able to figure out the basic idea for how it distributed the t-values evenly between every curve in a list of curves.

(define (connect-curves-evenly curvelist)
  (lambda (t)
    (let ((which-curve
	   (if (>= t 1.0) (- (length curvelist) 1)
	       (inexact->exact (floor (* t (length curvelist)))))))
      ((get-nth curvelist which-curve)
       (* (length curvelist)
	  (- t (* (/ 1 (length curvelist)) which-curve)))))))

(define (cons-to-curvelist curve curvelist)
  (let ((endpoint (curve 1.0))) ;; The last point in curve
    (cons curve
	  (map (lambda (thiscurve)
		 (translate thiscurve 
                            (x-of-point endpoint) (y-of-point endpoint)))
	       curvelist))))

Drawing L-System Curves

Here is the code for converting a list of L-System commands with some parts missing (it is explained below, but try to understand it yourself before reading further; if you don't understand cond, review SICP 1.1.6.):

(define (convert-lcommands-to-curvelist lcommands)
  (cond ((null? lcommands)
	 (list 
	  ;;; We make a leaf with just a single point of green:
	  (lambda (t) 
	    (make-colored-point 0.0 0.0 (make-color 0 255 0))) 
	  ))
	((is-forward? (car lcommands))
	 (cons-to-curvelist
	  vertical-line
	  (convert-lcommands-to-curvelist (cdr lcommands))))
	((is-rotate? (car lcommands))
	      ;;; If this command is a rotate, every curve in the rest 
	      ;;; of the list should should be rotated by the rotate angle
	 (let
	     ;; L-system turns are clockwise, so we need to use - angle
	     ((rotate-angle (- (get-angle (car lcommands)))))
	   (map
	    (lambda (curve)
              ;;; Question 7: fill this in
	      )
	     ;;; Question 7: fill this in
	    )))
	((is-offshoot? (car lcommands))
	 (append
  	  ;;; Question 8: fill this in
	  ))
	(#t (error "Bad lcommand!"))))

Otherwise, we need to do something different depending on what the first command in the command list is. If it is a forward command we draw a vertical line. The rest of the fractal is connected to the end of the vertical line using cons-to-curvelist. The recursive call to convert-lcommands-to-curve produces the curve list corresponding to the rest of the L-system commands. Note how we pass (cdr lcommands) in the recursive call to get the rest of the command list.

You can test your code by drawing the curve that results from any list of L-system commands that does not use offshoots. For example, evaluating

(draw-curve-points
   (position-curve
    (translate
     (connect-curves-evenly
      (convert-lcommands-to-curvelist
       (make-lsystem-command (make-rotate-command 150)
                             (make-forward-command)
                             (make-rotate-command -120)
                             (make-forward-command))))
     0.3 0.7)
    0 .5)
   10000)

We have provided the position-curve procedure to make it easier to fit fractals onto the graphics window:

(position-curve curve startx starty) — evaluates to a curve that translates curve to start at (startx, starty) and scales it to fit into the graphics window maintaining the aspect ratio (the x and y dimensions are both scaled the same amount)

Now, you should be able to draw any l-system command list using position-curve and the convert-lcommands-to-curvelist function you completed in Questions 7 and 8. Try drawing a few simple L-system command lists before moving on to the next part.

(define (make-tree-fractal level)
  (make-lsystem-fractal tree-commands 
			(make-lsystem-command (make-forward-command)) level))

(define (draw-lsystem-fractal lcommands)
  (draw-curve-points 
   (position-curve 
    (connect-curves-evenly (convert-lcommands-to-curvelist lcommands)) 
    0.5 0.1) 
   50000))

For example, (draw-lsystem-fractal (make-tree-fractal 3)) will create a tree fractal with 3 levels of branching.

Grading:

• Answers to each question above
• A 'most beautiful tree' & image