Coding With Processing, Part 3

I just learned about for loops in Processing, and it occurred to me that they are perfect for illustrating iterated function systems. The classic example of an iterated function system is where you start with three vertices of a triangle, labeled 1, 2, and 3. Then perform the following steps:

  1. Plot a point (x0, y0) anywhere inside the triangle.
  2. Use a random number generator to generate 1, 2, or 3 randomly.
  3. If 1 comes up, plot the midpoint between vertex #1 and (x0, y0).
  4. If 2 comes up, plot the midpoint between vertex #2 and (x0, y0).
  5. If 3 comes up, plot the midpoint between vertex #3 and (x0, y0).
  6. Make your new point (x0, y0).
  7. Repeat the process.

Even though the locations of the points are being generated randomly, a very interesting picture emerges. Here is after 100 iterations:

And here is the result after 1000 iterations:

And here it is after 10,000. It’s pretty clear that we’re getting the Sierpinski Triangle!

Here’s the code:

float x1 = width/2;
float y1 = 0;
float x2 = 0;
float y2 = height;
float x3 = width;
float y3 = height;

float x0 = width/2;
float y0 = height/2;

size(600, 600);

for (int i = 1; i < 10000; i = i + 1) {
int roll = int (random(0, 4));
if (roll == 1) {
x0 = (x0 + x1)/2;
y0 = (y0 + y1)/2;
point(x0, y0);
} else if (roll == 2) {
x0 = (x0 + x2)/2;
y0 = (y0 + y2)/2;
point(x0, y0);
} else {
x0 = (x0 + x3)/2;
y0 = (y0 + y3)/2;
point(x0, y0);

Another Jump Into Fractals

Every January, the school where I teach has a 3-week alternative curriculum called Winterim. I teach a short course on fractals during this time. My students have just finished working on some simple Iterated Function Systems (IFS’s) using some software called, surprisingly, IFS 2.0 (free download here). I say simple, because the transforms are limited to scale changes, rotations, and translations, and the outputs are black and white. What’s fascinating about these IFS’s is that those basic transforms can create startlingly organic figures. Here’s an example of one I made using only two transforms (a scale reduction with a horizontal translation, and a scale reduction with a rotation):

An IFS Fractal

You can see my students’ creations here. I am always amazed at how quickly they can figure out how to make beautiful images.

Yesterday, we downloaded and installed another IFS program called Apophysis. (Free download here, and lots of tutorials here.) The difference between Apophysis and IFS 2.0 is like the difference between a Maserati and a tricycle, even though the mathematical principles behind them are exactly the same. I’ve been messing around with Apophysis off and on for about three years now, and I have barely scratched the surface of its capabilities. Right now, we are out of school due to icy roads, but as my students and I make more fractals, I’ll be posting links to them. Anyway, here are a couple of fractals I made with it last night (click on thumbnails for full-size images):

Apophysis Fractal #1

Apophysis Fractal #2