Last week, we saw how to use linear interpolation to rotate a series of fractal images. It was not unusually difficult, but it was important to call functions in the right sequence in order to make the code as simple as possible.

This week we’ll explore different ways to use color. Using color in digital art is a broad and complex topic, so we’ll only scratch the surface today.

The first movie shows how the different parts of the Sierpinski triangles corresponding to different affine transformations of the iterated function system can be drawn in different colors.

Recall that the *points* variable stored all the points to be drawn in any given fractal image. Since the points are drawn all at once, it is difficult to say *which* of the three transformations generated a particular point. But this is important because we want the color of a point to correspond to the transformation used to generate it.

One idea is to use *three* variables to store the points, and have these variables correspond to the three affine transformations. Here is the code — we’ll discuss it in detail in a moment.

We use variables *points1,* *points2,* and *points3* to store the points generated by each of the three affine transformations. Note that the use of *append* is now *within* each *if* statement, not *after* all the *if* statments. This is because we want to remember which points are generated by which transformation, so we can plot them all the same color.

As a result, we now need *three* separate calls to the *stroke* and *point* routines. Recall that in Processing, a call to the *stroke* command changes the color of *everything* drawn after that *stroke* command is called. So if we want to draw using three different colors, we need three calls to the *stroke* command.

Of course it follows that we need three calls to the *point* routine, since once we change the color of what is drawn, we need to make sure the correct set of points is that color. In this case, all the points in *points1* are yellow, those in *points2* are red, and those in *points3* are blue.

Again, not unusually complicated. You just have to make sure you know how each function in Processing works, and the appropriate order in which to call the functions you use.

On to the next color experiment! It’s been a few weeks since we used linear interpolation with color. You’ll see in the movie below that the yellow triangle gradually turns to red, the blue triangle changes to yellow, and the red triangle becomes blue.

Let’s see how we’d use linear intepolation to accomplish this. Below is the only code which needs to be altered — the *stroke* and *point* commands. Also, I left out the *rotate* function so the changing of the colors would be easier to follow.

We’ll focus on how to change the red triangle to blue in this example, which occurs for the points in the variable *points2*. The other color changes are handled similarly. All we need to do is use linear interpolation on each of the RGB values of the colors we are looking at.

For example, red has an R value of 255, but blue has an R value of 0. Now when *p* = 0 the triangle is red, and when *p* = 1, the triangle is blue. So we need to start (*p, *R) at (0, 255) and end at (1, 0). Creating a line between these two points results in the equation

R = (1 – *p*) * 255.

You can see the right-hand side of this equation as the first argument to the *stroke* command used to change the color for *points2.*

Working with the G values is easy. Since both red *and* blue have a G value of 0, we don’t need linear interpolation at all! Just leave the G value 0, and everything will be fine.

Finally, we look at the B value. For red, the B value is 0, but it’s 255 for blue. So we need to start (*p*, R) at (0, 0) and end at (1, 255). This is not difficult to do; we get the line

R = *p* * 255.

You’ll see the right-hand side of this equation as the third argument to the *stroke* command which changes the color for *points2.*

Just linear interpolation at work again! It’s not too difficult, once you look at it the right way.

For our last example, we’ll let the triangles “fade out,” as shown in the following movie.

Can you figure out how this is done? Linear interpolation again, but this time in the *strokeWeight* function. Here are the changes:

Let’s what this *if-else* clause does. If the parameter *p* is less than 0.5, leave the stroke weight as 2. Otherwise, calculate the stroke weight to be (1 – *p*)*4.

What does this accomplish? Well, at *p* = 0.5, the stroke weight is (1 – 0.5)*4, which is 2. And at *p* = 1, the stroke weight is 0. This means that the stroke weight is 2 for the first half of the movie, then gradually diminishes to 0 by the end of the movie. In other words, a fade out.

Of course when you write the code, you have to reverse engineer it. If I call my stroke weight W, I want to start (*p*, W) at (0.5, 2) and end at (1, 0). Creating a line between these two points gives the equation

W = (1 – *p) * 4.*

That’s all there is to it!

I hope you’ve seen how linear interpolation is a handy tool you can use to create all types of special effects. The neat thing is that it can be applied to any function which takes numerical parameters — and those parameters can correspond to color values, angles of rotation, location, or stroke weight. The only limit to how you can incorporate linear interpolation into your movies is your imagination!

## One thought on “Making Movies with Processing V”