This week, we begin a discussion of creating movies consisting of animated fractals. Last week’s post about the dot changing colors was at a beginning level as far as Processing goes. This week’s post will be a little more involved, but will assume a knowledge of Iterated Function Systems. I talked about IFS on Day034, Day035, and Day036. Feel free to look back for a refresher….

Today, we’ll see how to create the following movie. You’ll notice that both the beginning and final Sierpinski triangles are fractals discussed on Day034.

As a reminder, these are the three transformations which produce the initial Sierpinksi triangle:

Also, recall that to get the modified Sierpinski triangle at the end of the video, all we did was change the first transformation to

We’ll how to use linear interpolation to create the animation. But first, let’s look at the Python code for creating a fractal using an iterated function system.

The parameter *p* is for the linear interpolation (which we’ll discuss later), and *n* is the number of points to plot. First, import the library for generating random integers — since each transformation will be weighted equally, it’s simpler just to choose a random integer from 1, 2, and 3. The variable *points* keeps track of all the points, while *last* keeps track of the most recently plotted point. Recall from earlier posts that you only need the last point in order to get the next one.

Next, the *for* loop just creates new points, one at a time, and appends them to *points.* Once an affine transformation is randomly chosen by selecting a *randint* in the range from 1 to 3, it is applied to the last point generated. For the purpose of writing Python code, it’s easier to use the notation

rather than matrix notation. In order to use vector and matrix notation, you’d need to indicate that (1,2) is a vector by writing

v = vector(1,2),

and similarly for matrices. Since we’re doing some fairly simple calculations, just writing out the individual terms of the result is easier and requires less code.

Once the points are all created, it’s time to plot them. You’ll recognize the *background,* *stroke,* and *strokeWeight* functions from last week. Nothing fancy here, since we’re focusing on algorithms today. Just a black background and small orange dots.

The last line plots the points, and is an example of what is called *list comprehension* in Python. First, note that the iterated function system would create a fractal which would fit inside a triangle with vertices (0,2), (0,0), and (2,0). So we need to suitably scale the fractal — in this case by a factor of 225 so it will be large enough to see. Remember that units are in pixels in Processing.

Then we need to compensate for Processing’s coordinate system. You’ll notice a similarity to what we did a few weeks ago.

What the last line does is essentially this: for every point *x* in the list *points,* adjust the coordinates for screen space, and then plot *x* with the *point* function. List comprehension is convenient because you don’t have to make a loop or other iterative construct — it’s done automatically for you.

Of course that doesn’t mean you never need a *for* loop. It wouldn’t be easy to replace the *for* loop above with a list comprehension as each new point depends on the previous one. But for plotting a bunch of points, for example, it doesn’t matter which one you plot first.

Now for the linear interpolation! We want the first frame to be the usual Sierpinski triangle, and the last frame to be our modified triangle. The only difference is that one of the constants in the first function changes from 0.5 to 0.25.

This is perfect for using linear interpolation. We’d like our parameter *p* to be 0.5 when *p* = 0, and 0.25 when *p* = 1. So we just need to create a linear function of *p* which passes through the points (0, 0.5) and (1, 0.25). This isn’t hard to do; you should easily be able to get

The effect of using the parameter *p* in this way is to create a series of fractals, each one slightly different from the one before. Since we’re taking 360 steps to vary from 0.5 to 0.25, there is very little difference from one fractal to the next, and so when strung together, the fractals make a convincing animation.

I should point out the dots look like they’re “dancing” because each time a fractal image is made, a different series of random affine transformations is chosen. So while the points in each successive fractal will be close to each other, most of them will actually be different.

For completeness, here is the code which comes before the *sierpinski* function is defined.

It should look pretty familiar from last week. Similar setup, creating the parameter *p,* writing out the frames, etc. You’ll find this a general type of setup which you can use over and over again.

So that’s all there is to it! Now that you’ve got a basic grasp of Processing’s screen space and a few different ways to use linear interpolation, you can start making movies on your own.

Of course there are lots of cool effects you can add by using linear interpolation in more creative ways. We’ll start to take a look at some of those next week!