HONR 300/CMSC 491: L-Systems Lab / Fractals Exploration AssignmentWed 2/16/11 (Fractals Exploration due Mon 2/28/11)

You may do the lab individually or in pairs. As with all assignments, you may work in small groups to discuss the fractals exploration assignment, but the final assignment that you turn in should be your own. If you work with another student on the “scavenger hunt,” that’s fine; but by turning in the answer, you are asserting that you fully understand the answer yourself and are not just blindly submitting what another student figured out.

In-Lab Activity:

Getting Started

  • Start NetLogo using the Windows Program menu.
  • Open the L-Systems model: File -> Models Library -> Mathematics -> Fractals -> L-System Fractals
  • Click the Swirl button, then click Go to create the Swirl fractal. Click Go again to stop the model. (Depending on how long you let the model run, it may take a few seconds for the model to stop. Caution: you should always stop the model before trying to start a different model.)
  • Experiment with restarting the Swirl model (click Swirl again, then Go again—don’t use the Setupbutton just yet, since that changes to the default model). Let the system run longer this time. You will probably notice that the system slow down a lot, because the model is creating new turtles at an exponential rate.
  • Try creating each of the built-in fractals listed at the bottom of the control panel (Swirl, Ball, Tree1…). After selecting a fractal, you can click Go to let the model run indefinitely, or Go Once repeatedly to see how the fractal is constructed one step at a time.

Examining a Simple Fractal

  • Let’s look at how one of the L-systems is written more carefully.
  • Click on Setup, then Go Once a few times to see how this fractals grows.
  • Go to the Procedures tab and look at the line of code just below the commented region that says “write your own rules here.” The line reads:
    fd 3 rt 15 spawn fd 3 lt 30 fd 3
  • This is a simple “turtle program” that is applied on each iteration to every turtle in the system. Initially there is just one turtle, at (init-x, inity) (which defaults to (0, 0), as you can see in the Interface sliders). Breaking it down, when you click Go Once, each turtle will:
  • Move forward three pixels.
  • Turn right 15 degrees.
  • Create another turtle at the current location (which, on the next iteration, will start running the same program from that location and orientation).
  • Move forward another three pixels.
  • Turn left 30 degrees.
  • Move forward three more pixels.
  • Every turtle also changes its color slightly after each “round,” so you can see the age of each turtle visually in the display.
  • Go to the Interfacetab, restart this model (using Setup), and see if you can get an intuition for how this program builds a tree-like fractal. After the first iteration, you’ll see a white vertical line (the turtle’s forward movement), capped by a white dot (the spawned turtle), followed by a pink line that bends right, then left, and is capped by a pink dot (the original turtle). Make sure you understand this fractal thoroughly before moving on.

Examining Recursive Fractals

  • In the book, Flake creates recursion with bracketed grammar expansions, in which each successive “generation” is decremented in size by a fixed ratio (given as a switch to the commands).
  • In NetLogo, the recursive Tree1 fractal rule looks like this:
    fd 4 rt 15 fd 8 spawn rt 180 skip 8 rt 180 lt 15 fd 4 lt 15 spawn fd 8 die

Note that the NetLogo model creates a recursive fractal by spawning, backtracking over the turtle’s path, then spawning again—and in this case, stopping the original turtle at the end of the cycle.

  • Look at the NetLogo model for Sierpinski’s Tree. It implements the Chaos Game that I showed you in class on Monday. Work back and forth between the code and the model interface to understand what’s happening as each point generates a new midpoint between itself and a vertex.
  • Koch’s Snowflake builds the simplest snowflake first; on each subsequent iteration, every edge of the snowflake becomes a new Koch curve with edges that themselves become Koch curves. Again, spend some time tracing through and understanding this more complex model.
  • Note that both the Sierpinski and Koch models leave behind “traces” of the process that was used to build them (e.g., instead of peaks along the edges of the Koch snowflake, there are filled triangles).

Building a New Fractal

  • Go back into the Procedures tab, and scroll to the bottom.
  • Copy the to setup-koch code block and the to koch code block below it.
  • Paste this copy below the existing code.
  • Change setup-koch to setup-mykoch, and set rule-set “koch” to set rule-set “mykoch”.
  • Change to koch to tomykoch.
  • In your new mykoch procedure, delete the first part of the ifelse ticks=0block, leaving only the last line (from which you need to remove the square brackets):
    spawnfdlenlt 60 spawn fdlenrt 120 spawn fdlenlt 60 spawn fdlenrt 120
  • Return to the Interface window and create a button to run your new procedure:
  • Click the + ADDbutton at the top, then choose Button from the drop-down slider to the right of +ADD.
  • Click where you want the new button to appear.
  • You’ll see a popup dialog window; type setup-mykoch in the Commandstext box.
  • Close the dialog window.
  • Click your new setup-koch button, then Go or Go Once. You should see a (vertical) Koch curve grow itself.
  • Congratulations—you’ve written your first NetLogo model!

Fractals Exploration Assignment

Getting Started

You will need to install NetLogo on your own machine. It’s very straightforward: just visit and download the appropriate version for your machine. (NetLogo runs under Mac, Windows, and Linux.)

You may want to use the NetLogo manual to help you with this assignment; it’s available on the NetLogo website and is linked under the Help menu in the NetLogo interface.

To save models, use the File…Save As command. You can open models from the File window, or by double-clicking on the saved model in a directory window.

To save a screen capture, use File… Export… View (to export just the display window containing the fractal drawing), or File… Export… Interface (to export the entire interface window, including the buttons and sliders). Be sure you name this file with a name ending in “.png” – NetLogo creates a PNG file but won’t put the file extension on automatically.

1. Fractal Scavenger Hunt (40 points)

Here are six fractals that I created by replacing the line of code in the apply-rules procedure in the NetLogo L-Systems model. Use your understanding of fractals to determine the code that will generate each of these fractals. (You should submit your answers in hardcopy; your answer here is just the line or lines of code to replace apply-rules with to generate the fractal. Feel free to add additional remarks or observations if you want.)

You may want to look at the full-size pictures in color to see the details more clearly; I’ve posted them on the course website.

HONR 300 students: You only need to identify the first four fractals. Each fractal requires just a single line of code.

CMSC 491 students (and HONR 300 students who want the extra challenge): To generate the last two fractals, I also modified the setupprocedure to set the turtles’ initial len parameter, using this code:

ask turtles [ set len 1 ]

(len is set to 1 for Fractal 5, and to 5 for Fractal #6.) These fractals also require multiple lines of code that modify the length on each iteration, as well as moving the turtle. The code includes a stopping condition to cause the turtle to die when a maximum length is exceeded. The fractal in the picture is the final view, and you should include the stopping condition in your code.

Fractal #1: Circle (Note: I changed init-x to -50 in the interface ; init-y is still 0.)

Fractal #2: Dodecahedron (I changed init-x to -50; init-y is still 0.)

Fractal #3: Shrubbery (Here, init-x is 0; init-y is -50. I applied “Go Once” ten times to generate the 10th level of this fractal.)

Fractal #4(Init-x is 0; init-y is -50. I applied “Go Once” ten times to generate the 10th level of this fractal.)

Fractal #5

Fractal #6(Init-x is 0; init-y is -100. I applied “Go Once” 12 times to generate the 12th level of this fractal.)

2. Create Your Own Fractal (60 points)

Create your own fractal program in NetLogo, and tell me about it.

For this assignment, it’s fine to start with the L-System program or one of the other existing NetLogoprograms.

  • If you are in HONR 300, you can just experiment with the parameter settings to explore the space of fractals that can be created with the program.
  • If you are in CMSC 491, you should modify the program in some significant way to create a family of fractals that wouldn’t have been possible with the existing code. This new fractal family should involve at least one new parameter, which you should add to the interface as a slider. (For example, a “middle p% Koch curve” might build a peak from a fraction of each edge other than 1/3 – for example, if p was .5, then you would get the “middle half” Koch curve that we talked about in class.)
  • You’re welcome to go beyond these requirements: HONR 300 students can modify models to your heart’s content; and any student can create a new model from scratch if you so choose.

After creating your new model, you should experiment with it to understand the space of fractals that it can generate, and how the parameters affect the way the fractal looks. You should write a short summary of how your model works, including some screen captures of different variations of the fractal. This report should not be longer than two pages.

You should submit the model itself by saving it as a “.nlogo” file in the “Save As” dialog, and uploading this to the “Fractal Model” project in Blackboard. Your model summary should be submitted as hardcopy, along with the answers to the fractal identification exercise.