Assignment 7: Producing Playful Polygons

Write a procedure, (turtle-polygon! turtle side-length sides), that uses a turtle to draw a regular polygon with the specified number of sides, with each side of the specified length.

Important: Your procedure must return the turtle to its original position and angle. Your procedure must not change the turtle's brush or color.

Hint: Use repeat. The turtle must turn a total of 360 degrees to return to its original angle.

For example,

(turtle-polygon! t 100 3)

(turtle-polygon! t 100 4)

(turtle-polygon! t 60 5)

(turtle-polygon! t 40 6)

Write a procedure, (turtle-spin-polygon! turtle side-length sides angle copies), that draws the given number of copies of the specified polygon by calling your turtle-polygon! procedure, with the turtle turned an angle of angle between polygons.

Important: As in problem one, your procedure must return the turtle to its original position and orientation.

For example,

(turtle-spin-polygon! t 50 4 15 10)

(turtle-spin-polygon! t 50 4 20 5)

(turtle-spin-polygon! t 50 4 5 20)

(turtle-spin-polygon! t 50 4 -30 5)

A potential deficiency of each of the prior two procedures is that multiple polygons are joined at a vertex. The problem is, of course, that our basic polygon procedure draws polygons starting at a particular point, rather than centered at a certain point.

Copy the following procedure to your definitions pane.

(define turtle-centered-polygon! 
  (lambda (turtle radius sides)
    (let ([interior-angle (/ (* 180 (- sides 2)) sides)])
      (turtle-up! turtle)
      (turtle-forward! turtle radius)
      (turtle-down! turtle)
      (turtle-turn! turtle (- 180 (/ interior-angle 2)))
      (turtle-polygon! turtle (* 2 radius (sin (/ pi sides))) sides)
      (turtle-turn! turtle (/ interior-angle 2))
      (turtle-up! turtle)
      (turtle-forward! turtle radius)
      (turtle-turn! turtle 180)
      (turtle-down! turtle))))    

Experiment with this procedure to learn what it does. (Hint: Note that this procedure assumes your turtle-polygon! draws the first side of the polygon before turning.)

a. Document this procedure using the six-P style of documentation.

b. Explain why each expression in the procedure's body is necessary to achieve the result that you see. That is, explain each step of the algorithm in English.

Hint: You may find it useful to comment out each expression using a semicolon, one at a time, to see how the result of leaving out that expression differs from the desired result.)

Write a procedure, (turtle-spin-centered-polygon! turtle radius sides angle copies).

This procedure should be very similar to turtle-spin-polygon!, from above, except that it will call the turtle-centered-polygon! procedure from above instead of your turtle-polygon! procedure from Problem 1.

Some folks have noted that there are multiple paths from one point to another. Right now, turtle-forward! simply has the turtle go forward the appropriate distance, such as the following image, in which the turtle moves forward 100 units.

However, the turtle could arrive at the same point by using a different path. For example, the turtle might go forward 1/3 of the distance, turn left 60 degress, go forward 1/3 of the distance, turn right 120 degrees, go forward 1/3 of the distance, turn left 60 degrees, and go forward the remaining 1/3 of the distance, as we see in the following image.

We can implement that process as follows.

(define turtle-forward-alt!
  (lambda (turtle distance)
    (turtle-forward! turtle (/ distance 3))
    (turtle-turn! turtle -60)
    (turtle-forward! turtle (/ distance 3))
    (turtle-turn! turtle 120)
    (turtle-forward! turtle (/ distance 3))
    (turtle-turn! turtle -60)
    (turtle-forward! turtle (/ distance 3))))

But wait! If turtle-forward-alt! moves the turtle forward the appropriate distance, can't we use the same mechanism for each of those four forward steps?

(define turtle-forward-alt2!
  (lambda (turtle distance)
    (turtle-forward-alt! turtle (/ distance 3))
    (turtle-turn! turtle -60)
    (turtle-forward-alt! turtle (/ distance 3))
    (turtle-turn! turtle 120)
    (turtle-forward-alt! turtle (/ distance 3))
    (turtle-turn! turtle -60)
    (turtle-forward-alt! turtle (/ distance 3))))

Hmmm. We're starting to get an interesting image, aren't we? In fact, the image we see is related to a famous figure called the Koch Star or snowflake. It will get more snowflake-like if we do the same process again, this time using turtle-forward-alt2

However, there's a problem with our code. We've written two nearly identical procedures that differ only in what subprocedure they call (the first calls turtle-forward!, the second calls turtle-forward-alt2!. If we want to go another step, we'll need to write yet another nearly-identical procedure, this time one that calls >turtle-forward-alt2!.

Is there a better solution? Certainly. Whenever we find that we're writing nearly identical code, we try to find a way to write a common procedure. In this case, we can achieve that goal by adding an extra parameter, n, to the procedure and make the procedure recur on n. Let's call that procedure (turtle-forward-new! turtle distance n). When n is 0, it simply moves forward the given amount. When n is greater than 0, it uses the “forward, turn, forward, turn, forward, turn, forward” approach, using the same procedure to move forward, but with with n decreased by 1. That is, if we call (turtle-forward-new! turtle 90 2), that call will spawn four recursive calls to (turtle-forward-new! turtle 30 1). Each of those, in turn, will spawn four recursive calls to (turtle-forward-new! turtle 10 0). Each of those will simply call (turtle-forward! turtle 10).

For those of you who want a more formal description of this process, look at the appendices to this assignment.

a. Implement, but do not document, turtle-forward-new!.

b. Write a procedure, (turtle-fractal-centered-polygon! turtle radius sides n), that makes a polygon-like object, using turtle-forward-new! to draw the sides.

Here are an interesting pair of paths.

Path A: Turn right 60 degrees, go forward half the distance, turn left 60 degrees, go forward half the distance, turn left 60 degrees, go forward half the distance, turn right 60 degrees.

Path B: Turn left 60 degrees, go forward half the distance, turn right 60 degrees, go forward half the distance, turn right 60 degrees, go forward half the distance, turn left 60 degrees.

Once again, we can take a fractal approach and, when moving forward, we can use one of the two paths, rather than just turtle-forward!.

Let's make it interesting though. For path A, let's make the first forward use path B, the second forward use path A, and the third forward use path B. Similarly, for path B, let's make the first forward use path A, the second forward use path B, and the third use path A.

What happens? For one level of recursion, We get something like the following. (We show the normal path A in grey and the recursive BAB in black.)

Without the grey, we see the figure we actually get.

With an additional level of recursion, we get the following image.

And with one more level, we get this image.

These mutually recursive procedures generate the path-based form of a figure called “Sierpinski's triangle”.

Implement the procedures (sierpinski-a! turtle distance n) and (sierpinski-b! turtle distance n), using the paths described above.

Write a program that systematically generates an interesting image composed of a series of polygons and/or fractals. In addition to using some (or all) of the ideas in problems 1 through 6, you should incorporate at least one additional element, such as changing the elements' positions, size, colors or brushes, or even changing the number of sides between different polygons.