CS 257 Project 1: From the Ridiculous to the Sublime*

You may choose to do either Project A, Project B or Project C. Project A consists of three relatively straightforward small projects. Projects B and C are more challenging and open-ended, i.e., if you think you are a macho hacker (or want to be one) choose B or C.

Project A

Problem 1 (The Ridiculous)
Write a Scheme program which creates a graphics object which is a reasonable likeness of Cartman, Stan, Kyle, or Kenny. It does not have to be perfect, just recognizable. I got these depictions off the web. You may be able to find better ones. If you are a person with good taste and find Southpark offensive, then you are welcome to draw Snoopy, Charlie Brown, Linus, or Lucy instead. Hint: Figuring out how to draw an ellipse (or a portion thereof) at an arbitrary position and orientation will get you 90% of the way there. The following code will return an ellipse with width-to-height-ratio, r,
```
(define pi (acos -1))

(define rad->deg
  (lambda (rad)
    (* rad (/ 360 (* 2 pi)))))

(define deg->rad
  (lambda (deg)
    (* deg (/ (* 2 pi) 360))))

(define ellipse
  (lambda (r)
    (ellipse-helper r 360)))

(define ellipse-helper
  (lambda (r t)
    (if (= t 0)
      (adjoin)
      (adjoin
        (straight 1)
        (bend (- (rad->deg (atan (cos (deg->rad t)) 
                                 (* (- r) (sin (deg->rad t)))))
                 (rad->deg (atan (cos (deg->rad (sub1 t))) 
                                 (* (- r) (sin (deg->rad (sub1 t))))))))
        (ellipse-helper r (sub1 t))))))
```
Problem 2
Write a Scheme program which, given an s-expression, draws the corresponding cons-tree. Hint: This is a typical "cons" recursion, i.e., the same recursion on car and cdr. You might find a function similiar to the following helpful for assembling the tree,
```
(define tree-step
  (lambda (trunk left-branch right-branch)
    (adorn trunk
	   (adjoin (bend -20) left-branch)
	   (adjoin (bend 20) right-branch))))
```
If you want to make your trees as nice looking as possible, you will probably have to decrease the trunk length and branch angle as the recursion depth increases. To do this, it is useful to know the maximum depth of the s-expression prior to building the graphic object depicting its cons-tree.

Problem 3 (The Sublime)

Write a Scheme program which draws either the Gosper-Peano Curve (more challenging) or the Sierpinski Arrowhead (less challenging). The generators for these curves can be found on p. 70 and p. 142 (respectively) of Benoit Mandelbrot's The Fractal Geometry of Nature. Hint: You may use my code for the Monkey Tree as a model for the Peano-Gosper Curve and Barak Pearlmutter's code for the Koch Snowflake as a model for the Sierpinski Arrowhead,

The Monkey Tree (The Fractal Geometry of Nature, p. 31)

(define d (/ (sqrt 3) 3))

(define monkey-step
  (lambda (side rside)
    (adjoin
     (bend -60)
     (mirror side)
     (mirror rside)
     (bend 60)
     side
     (bend 60)
     (mirror rside)
     (bend 150)
     (scale-size d (mirror rside))
     (scale-size d (mirror side))
     (bend -60)
     (scale-size d rside)
     (bend -60)
     (scale-size d rside)
     (scale-size d side)
     (bend -90)
     rside
     side)))

(define rmonkey-step
  (lambda (side rside)
    (adjoin
     rside
     side
     (bend 90)
     (scale-size d rside)
     (scale-size d side)
     (bend 60)
     (scale-size d side)
     (bend 60)
     (scale-size d (mirror rside))
     (scale-size d (mirror side))
     (bend -150)
     (mirror side)
     (bend -60)
     rside
     (bend -60)
     (mirror side)
     (mirror rside)
     (bend 60))))

(define monkey-tree
  (lambda (n len)
    (if (= n 0) 
	(straight len)
        (monkey-step (monkey-tree (sub1 n) len)
	             (rmonkey-tree (sub1 n) len)))))

(define rmonkey-tree
  (lambda (n len)
    (if (= n 0) 
	(straight len)
        (rmonkey-step (monkey-tree (sub1 n) len)
	              (rmonkey-tree (sub1 n) len)))))

The Koch Snowflake (The Fractal Geometry of Nature, p. 43)

(define koch-step 
  (lambda (side angle)
    (adjoin side
            (bend (- angle))
            side
            (bend (* 2 angle))
            side
            (bend (- angle))
            side)))

(define koch 
  (lambda (n len angle)
    (if (= n 0)
        (straight len)
        (koch-step (koch (- n 1) len angle)
                   angle))))

Project B

Write a Scheme program which, given an s-expression, draws the corresponding box-and-pointer diagram (see p. 360 of Scheme and the Art of Programming). Boxes and pointers depicting s-expressions (or parts thereof) which are proper lists should be aligned on a single (horizontal) line. Sub-lists should be drawn on lower lines. Care should be taken so that different parts of the drawing don't overlap.

Project C

Write a Scheme program which will draw one of the four patterns from p. 103 of Abelson's Turtle Geometry. Hint: Find the smallest part of the pattern which is not mirror symmetric. Build up the rest of the pattern recursively using mirror copies. If you find a similiar arabesque pattern that you would like to use instead, bring it in and show it to me. The same goes for you dressed-in-black neo-Goths who want to experiment with Celtic interlace.

What You Should Hand In

Listings of all your code.
Representative graphic output.

When You Should Hand It In

The above should be handed in at the beginning of class on Fri. Oct. 9.

* This webpage is located at http://cs.unm.edu/~williams/cs257/project1.html