150 blog posts and I finally have a topic I consistently write about…

YES!!

**Table of Contents**

- Quick Background Overview
- Linear
- Color
- Mobius, Ortho, and Bipolar
- Spherical play (Xenophilic)

Please note, this article is in progress because I have yet to finish uploading videos. Cross-linking requires publishing first.

**Quick Background Overview**

Iterated function series (IFS – or iterative function systems, whichever you prefer) are used to make fractal flames. Fractal flames aren’t true fractals but can be used to mimic their detailed features by repeating patterns into smaller scales. This can make for very nice artwork. An iterated function series works like this: Start with some points, perform a mathematical function (called a “mathematical transform” or just “transform”) on them, then randomly pick another mathematical function to perform on them, and keep doing this up to a certain number of repetitions. This is nice in that, in order to make IFS fractals, you don’t need to perform any math; the computer does the math. However, you *do* need to know what the mathematical functions do to the overall shape.

To give you a better understanding of the construction of fractal flames, I’ve written a couple articles and created a few videos to better explain how things work.

If you would like to know more about the fractal flame algorithm, please read my article How Fractal Transforms Work.

The rest of this article is devoted to explaining some of the transforms you will find in popular fractal flame creation software.

**Linear**

The most important transform you will ever use is linear-based. I include linear, linear3D, and the pre- and post-affine transforms in this set because they do essentially the same things (although the latter two you can rotate).

Note: In order to see the linear transformations in versions of JWildfire 1.50 or earlier, you need either one other transform (such as blur or something to create a bulk) or three linear transforms (see later in this article for how to do the Sierpinski triangle/gasket).

Linear transforms are used for moving other transforms, and in so doing, we can make trees, swirls, or form the basis for larger patterns. By applying plain linear transforms that are shifted (with a post-affine transform), we can extend patterns out to infinity, which is useful when we plan on using transforms that invert space (such as mobius, which I have written about further down in this article).

Linear is simple: change the location, rotation, and scale of the current space. Each transform creates a new relative reference frame in which other things can happen. Hence, if you create a simple tree in the first reference frame, it will get repeated to each successive reference frame.

NOTE: linear differs from linear3D in that the latter preserves the z-value of points whereas the former does not.

To create a tree, we first start with a transform as our base. In the video, I start with a blur because it is easy (I set the x of the affine tranform to 0.3 to make it look more like the trunk of the tree and so that you could see the changes). Next, we create a transform that we moved up by a couple units, moved to the right by a unit, and rotated by about 15 degrees. This creates the first branch and it also creates a spiral. Each time the points go through a transform, they enter a new relative reference frame where they are moved up, moved right, and rotated 15 degrees. To create a second branch, duplicate the first linear transform and move the affine triangle to the left instead of the right. Every time the points go through one transform, the algorithm randomly picks which transform comes next, and in this case, it can pick to send the points to the blur, first linear (going to the right), or the second linear (going to the left). (Both paths will be traversed, just that they will be traversed by different points.) Hence, each reference frame gives the same tree options.

There are a couple things to note about the tree. First, if you change the rotation, you can get the tree to tighten. Doing this creates inward spirals. There are transforms dedicated to spirals (spiral and whorl, etc.), and these dedicated transforms will actually curve space, so if you’re looking for a smooth curl, use those.

**Sierpinski Gasket**

One thing I didn’t specify in the video was how to make a Sierpinski gasket, although the repetitious nature I demonstrated should have given you a hint. Here’s the cheat:

To make a Sierpinski gasket, create three linear transforms and set the main value for all of them to 0.5. Then move one of them up, one of them down, and one of them to the right or left (it doesn’t matter how much, though you may want to keep the values reasonable so you can see the result). In total, there are eight normal orientations you can make for the same size gasket without even rotating any of the transforms.

What is happening here is the repetitious nature of the pattern on a repeatedly smaller scale (because you shrunk the transforms). The problem is that some transforms tend to not maintain that beautiful pattern. In many cases, shrinking the differing transform will improve the result, and you should see the new shape repeated throughout the structure/gasket.

**Mobius, Ortho, and Bipolar**

Mobius, ortho, and bipolar are transforms with one key thing in common: they all invert space. The left, right, top, and bottom sides of a shape are curled around to be at the center while the middle is curled outwards. Each of these transforms handles things a different way.

Other transforms that invert space in a similar manner are curl and curl3d.

The transforms mobius, ortho, and bipolar may be similar, but a cheat sheet for their differences is as follows:

**Mobius:** Inverts space leaving two of the sides pushed off to one side, creating an imbalanced shape. You * cannot* change this

*(at least, not easily). All parameters are in terms of real and imaginary numbers (basically, the coefficients of the raw variables of the math behind the scenes). Going back to itself in xaos creates a mess (advice: scale the pre-affine transforms).*

**imbalance in space****Ortho:** Creates a balanced inversion of space. It is the * easiest* to modify and control. Going back to itself in xaos in its natural state reverts the central shape back to exactly what it was.

**Bipolar:** Inverts space completely. You * cannot* the

**of this inversion. The spacial divide is at the x-axis horizon (that is, the ). You can change this divide via the shift parameter.**

*shape***Spherical Play**

The spherical pattern may be familiar to you: It looks like a repeating top of a mandelbrot. This pattern has been used for hundreds of fractals, its most common form being the xenophilic.

The spherical pattern is actually very easy to make. Make two x-forms and have them both contain only spherical transforms. You can use spherical3d as well for a cool 3D curl effect as in xenophilic. Move one of the x-forms 1 unit to the right (or up) and rotate it clockwise 90 degrees, and the other x-form you rotate counterclockwise 90 degrees.

In order to make something appear within the pattern that goes with it, you need to “go with the grain” so to speak: If you pattern is vertical, then you should built your what-will-be-inner-components vertically. In the simplest terms, you can use an x-form with a vertical cylinder. If your pattern is horizontal, you should rotate the post transform of your x-form with the cylinder by 90 degrees so that the cylinder points horizontally. The effects should be evident immediately. Notice that the spherical pattern actually curls the cylinder so that it fits in the pattern nicely. This is actually a clue as to why the pattern appears itself: That pattern is composed of the endpoints that result from the last iterations through the algorithm – i.e. what happens when you iterate through the spherical as much as you can. That’s a big hint: It turns out, you can do this with other things.

To get the 3D effect of xenophilic, use a z-translate on the cylinder. This translation gets carried through all of the iterations, changing its overall effect and making it look like its dropping down. Why? The more points are iterated through the spherical pattern, the less they have been influenced by the cylinder transform, and thus the less the z-translate of the cylinder pattern applies to them. The more a point goes back to the cylinder pattern, the more effect the z-translate will have on it. The effects are additive in this case.

**A Little Treat**

For those of you who have faithfully read this article, I have a little treat for you. Remember when I said that the spherical pattern was actually endpoints from iterating through the spherical pattern as much as we could? It turns out, you can also do this same thing with curl and get a new but remarkably reminiscent pattern. Here’s how:

Start by doing the same thing you did to make the spherical pattern: You need one x-form moved 1 unit to the right and rotated 90 degrees clockwise and one x-form rotated 90 degrees counterclockwise. Both of these transforms should contain curl. These curls should be set to 1 and their c1 values should be set to 0.3. What you should be seeing right now are some slightly amusing flicks, but nothing really interesting. Here’s where it all comes together: Make a cylinder and set its post-affine transform x to 0.1. See it now? 😀

Thanks for reading!