SoftStep includes both a Fractal module and an Image module. While each can be used independently, the two modules in combination become exceptionally powerful and flexible tools for exploring musical translations of fractal images.

In general, fractals are a difficult fit for music because the beauty of fractal images is perceived as a two-dimensional pattern, while music is linear. Just reading out the pixel data line by line like an unraveled Persian rug results in a very limited translation of the complexity and self-similarity of fractal patterns.

Advertising researchers have done studies tracking how the eye moves on an image. Lots of squiggles on particular areas of the picture, such as the face, not as many on most other areas, hardly any at all on the background. These eye-focus traces are remarkably similar to strange attractor math functions.

And therein lies the SoftStep approach to fractal music - which is to start with the fractal image (or any other image), and to read out its pixel data not in a linear, line by line fashion; but rather follow a complex pattern that more closely resembles how the eye reads the information. Thus the computer "sees" the image somewhat as you might see it -- a combination of a fractal image with an attractor scanning pattern. The Image module takes as input an X,Y location and produces pixel color information as output. And the Fractal module generates the fractal / strange attractor values for the image X,Y address locations.

This results in the image data being accessed in various (depending on the algorithm selected) patterns which produce discernible relationships that are both more complex and more related than simply reading the image line by line - and it provides a far richer tool set for exploring the music in fractals.

The Fractal module produces X,Y points of various fractal, attractor, and other functions. This is different from the fractals data produced with the Image module, which are pixel colors, and the data produced by the Chaos module, which are single parameters.

The topmost, **Clock input** accepts a standard 0-NZ gate transition
to initiate the next fractal in the current algorithm. Click on the blue
**turbo button** (labeled "Trb") to bypass the clock input and run at turbo
(64th note triplets) speed. The **Seed input **(0-127) causes a different
pattern to be produced with the same algorithm. A gate in the **Reset
input** resets the algorithm to its start, and holds the output; releasing
the Reset input starts the pattern anew with the current seed.. The **Scale
input** limits the possible result to no more than its setting; the **Offset
input** is added to the final result after it has been scaled.

Choose the fractal algorithm (described below) with the drop down menu. As the algorithm runs, it will display the pixel X,Y location as a series of dots. To view the fractal image as it will be played out over time, left click on the image area and hold the mouse button down. This will show the fractal as a colored image. MIDI output will stop while the image is being generated. When the mouse button is released, the fractal image will be cleared and the algorithm will start from the beginning. Although the image generated this way is transient, a copy if it is stored internally and may be retrieved by the Image module. To clear the image area of a running algorithm without restarting it, you can right click on the image.

Output from the Fractal module is the X parameter of the algorithm; use
the **FracOut** module to get the Y parameter. It can be set to send the X
parameter by clicking on the blue button labeled "**=Y**," which will change
to "**=X**" when sending the X parameter. FracOut modules can be seen as
satellites to the Fractal module. Each FracOut module must be told which
Fractal module it is to take its output from. Do this by setting the **upper
left drop down menu** to the same number as the controlling Fractal module.
If you have created only one Fractal module, then the only choice will be 1,
and it will be set by default The FracOut module inputs are for scale and
offset, and they work exactly the same as the scale and offset inputs for the
Fractal module.

**Fractal module algorithms:**

Most of these fractals are derived from Robert Greenhouse's
The Well Tempered Fractal, and are used with his kind
permission. For detailed information on these fractals, including history and
pseudocode algorithms, please visit the web site. These algorithms are:
*Mira, Hopalong, Ikeda, Ivanov, Julia*, and *Chebychev*.

The *Martin* and *Pickover* algorithms are from an article by
Rod Stephens entitled *"Fractal Frenzy"*, published in the
Visual Basic
Developer Online. His latest book is
Visual Basic Graphics Programming.

The *Lorenz* attractor (strictly speaking, it's a chaotic
attractor, not a fractal) is the classic Lorenz algorithm:

xnew=x+d*a*(y-x)

ynew=y+d*(x*(c-z)-y)

znew=z+d*(x*y-b*z)

...where
a, b, c and d are constants with the values 10, 8/3, 28, and .003 respectively.

*Lonenz* does not lend itself to using random seeds to making the
attractor change shape - it is too strong an attractor, and falls back into its
classic butterfly shape in almost all cases. However, since Lorenz is 3
dimensional (X, Y, and Z), the seed input is used to choose which two of the 3
coordinates is used. A seed of 0 displays the X and Y coordinates; a seed of 1
displays X, Z; and 2 displays Z, Y. any value greater than 2 wraps around.

The *Recursive* algorithm is my own (John Dunn). It is not a
fractal, rather it is a method of scanning an image that relates the pixels
more to each other than you would get from a simple line scan. Seed sets the
starting point.

The *Raster* algorithms are simply line scans. *Raster* and
*HRaster* are both horizontal line scans that read a line, step to the
next, read it, etc. The difference between them is that the seed for
*Raster* sets the count increment (or skip value); so if you set the seed
to 10, for example, it will read every 10th pixel. Seed in *HRaster* sets
the starting line. *VRaster* reads vertically, and the seed sets the
starting position.

The Function Generator produces LFO (Low Frequency Oscillator) type values: Sine, Triangle, and Ramp waveforms, plus Noise and 1/F Noise. What is especially interesting about this module is that it does not produce its values sequentially as a result of a clock gate; rather the values are randomly addressable throughout their range. This gives a great deal of flexibility in generating the values - compressing and stretching them, or using an attractor generated by the Fractal module to produce unique transforms of the original wave patterns. Of course if you want sequential addressing that is readily available with the Counter module or the Stepper module.

The uppermost drop down menu selects the function: Sine, Triangle, Ramp
Up, Ramp Down, Random, and 1/f random. The **Length input** selects the
number of steps to complete the function. For example, with the Ramp Up
function selected, setting Length to 127 will cause the **Step Input** to be
passed to the output unchanged; setting Length to 64 effectively doubles the
Step input (of Ramp Up) because the sequence length is half (of 127), allowing
for rounding errors. Typically, you would set the maximum value of the driving
module to be the same as the Length input. For example if you are using a
Stepper module, as in the example image, you would likely want to set its Limit
input to the same value as the Func Gen's Length input.

The **Scale input** limits the possible result to no more than its
setting; the **Offset input** is added to the final result after it has been
scaled.

The Number Generator produces an expanded version of the Thue-Morse sequence. The algorithm counts the (base-10) digits in a number sequence, in any given base. So the number 1234 in base 10 would yield a result of 1+2+3+4, or 10. This perhaps seems simplistic at first glance, but it turns out there are multitudes of interesting fractal-like patterns to be found with this algorithm. For more detailed information, including a very nice free download program, visit Lars Kindermann's MusiNum website.

A 0-NZ gate in the **Clock input **increments (or decrements) the
internal counter, and generates a new output. The internal counter has a range
of 0 to 1,048,575 (hexadecimal FFFFF).

The **Base input** determines how the output is calculated by setting
the number base of the internal counter. Base 2 is binary, base 8 is octal,
base 10 is decimal, base 16 is hexadecimal, and so on. Any number base can be
used from 2 to 127. Setting Base to 0 or 1 is the same as setting it to 2.

The **Step input** determines the amount the internal counter is
changed on each clock tick. The actual step is the value of the Step input +1.
So 0 gives a step of 1 (the clock increments/decrements the internal counter by
1), 1 gives a step of 2, and so on up to 127 which gives a step of 128.

Any non-zero in the **Rev input** (Reverse) causes the internal
counter to decrement, 0 causes the counter to increment.

The **Start input** has two different actions, depending on whether
the blue**Start mode button **is clicked in. If not clicked in, the starting
position of the sequence is the value of the Start input; if clicked in, the
Start input is multiplied by 8192 Changing the Start input has no effect until
the **Reset input** is set to non zero. This will cause the module to reset
its internal counter to the new starting point, and then hold until the Reset
input goes back to zero.

The **Offset input **is added to the output after all other
calculations are done.

The Chaos module produces single dimension (only 1 point) chaotic algorithms, selectable by the topmost drop down menu. Algorithms currently available are:

The **Burt Shift** is a binary feedback algorithm contributed by
Australian composer Warren Burt. It includes a series of binary shift registers
with feedback taps. Selecting different Seed inputs changes the feedback taps
and thus changes the pattern.

The **Bifurcation algorithm**, also known as the logistic difference
equation, was originally developed by biologists to predict animal populations.
The equation is: **xn + 1 = r * xn (1 - xn)**. For a detailed description of
this algorithm (and an excellent introduction to chaos and fractals in general)
visit Larry Bradley's web paper:
The World of Chaos and Fractals.

The **Henon attractor** was discovered by French astronomer Michele
Henon while working with the dynamics of stars moving within galaxies. The
equation is: **x[n+1] = 1 + (a * x[n] * x[n]) + (b * x[n-1])**, where n is
the sequence step, and a and b are constants. In the SoftStep implementation,
if the seed input is 0, the values for x[n], x[n-1], a, and b are fixed at **a
= -1.4, b = 0.3, x[n] = 0.63135448, **and** x[n-1] = 0.18940634**, as
suggested by
Sprott; for seeds other than 0, these are set to
repeatable random values. This gives some pretty wild fluctuations, and in
general the Henon is best used in situations where extreme peaks and valleys
are appropriate (try it as a Voice module Pan
input!). In order to preserve the sense of the Henon attractor in the 0-127
MIDI context, the module output is the absolute fraction part of X, times 127,
however it is the true X that is feed back into the algorithm.

The **Seed input** changes the seed values for the algorithms, and
thus changes the patterns. You can change the seed while a pattern is running
and the pattern will instantly change: if the pattern for that seed has not
been run, the algorithm will start at the beginning, as with a reset; if the
pattern has been run, it will continue where it last left off.

Non zero in the **Reset input** resets to the start of the algorithm
and holds the output until the input goes back to zero. The **Scale input**
limits the possible result to no more than its setting; the **Offset input**
is added to the final result after it has been scaled.

The Image module consists of two parts: the Image module itself, and the
Draw Fractal dialog box that pops up when you click on the **Frac** button.
Additionally, there is an ImgOut module that allows multiple readouts from the
same image.

The basic function of both the Image and ImgOut modules is quite simple:
you give them **X, Y coordinates** of 0-127 and they both will send the
pixel information at that location to the output. Click on the **Dot**
option button to show a white dot at the addressed X,Y location. The **Scale
input** limits the possible result to no more than its setting; the **Offset
input** is added to the final result after it has been scaled.

The pixel value produced by the Image module is a blended RGB color value, with 3 bits each for Red, Green, and Blue. Blending takes place by using the same bit for high bit Red and low bit Green; and for high bit Green and low bit Blue:

Bit: 6 5 4 3 2 1 0 = 0-127 Red: X X X = 1-7 Green: X X X = 4-28 Blue: X X X = 16-112

The **ImgOut** module has several additional pixel value
interpretations available to it, selectable by the blue drop down menu. These
are gray scale, red only, green only, blue only, cyan, magenta, yellow, black;
and hue, saturation and value.

ImgOut modules can be seen as satellites to the Image module. Each
ImgOut module must be told which Image module it is to take its output from. Do
this by setting the **red drop down menu** to the same number as the
controlling Image module. If you have created only one Image module, then the
only choice will be 1, and it will be set by default

The image contained in the Image module can be manipulated in several
ways. **Left click on the edges** of the image to reflect it about the
center. Top and bottom will reflect about the horizontal center; left and right
will reflect about the vertical center, and the corners with do both at once.
**Left click in the center** to rotate the image 90° one click for each
rotation until in 4 clicks the image is back where you started.

**Right click on the edges** of the image to shift it one pixel
toward the edge, and in the corners to shift it both directions at once.

**Right click in the center** of the image to "set" it. This has two
effects. (1.) It makes the color shifts (described below) a permanent part of
the image; and (2.) it makes the image available to be loaded into other Image
modules with the module's **Get** button.

The** Colr button** cycles the color values of the image. The method
of cycling is simply to exchange the R, G, and B components. Since there are 3
components, there are 3x3 or 9 possible color combinations. Additionally, there
is a grayscale cycle step and an inverse color step. In order for the color
cycling to be predictable, the colors are taken from an unaltered backup copy
of the image, and therefore the colors are not a permanent part of the image in
all circumstances. In order to "set" the colors so they are permanent, right
click on the center of the image. A word of caution: if you set the image while
it is showing as gray scale, you will not be able to cycle the colors further,
as all the R,G,B color components will have become equal.

Use the **Get button** to import an image from either another Image
module (that has had its image set by right clicking on its center), or from a
Fractal module that you have created an image in by left
clicking on the image and holding the button down for a few seconds.

The **Frac button** brings up the **Draw Fractal** dialog:

The primary function of the Draw Fractal dialog is to allow you to
create and zoom into fractal patterns. Currently there are two fractals to
choose from, selectable from the top drop down menu. These are the classic
Mandelbrot set and a variation of the Julia set, called the Dragon curve. Both
of these algorithms are from an article by Rod Stephens entitled *"Fractal
Frenzy"*, published in the
Visual Basic
Developer Online.

The **New button** will create a new, 0-level zoom fractal. For the
Mandelbrot, this is always the same fractal image; but for the Dragon fractal,
each time New is clicked a different set is produced. Some of these are not
very useful, others are astonishingly rich - you just have to keep clicking New
until you get one you want to work with.

Zoom in on the fractal by **left-click-and-drag in the image area**.
You will see a box outline showing the area you are selecting. Release the
mouse button and the box will expand to the full image area. You can repeat
this about a dozen times before the fractal bottoms out. Click on the **Back
button** to zoom back out.

You can change the color assignments with the **RGB button**, which
will change to show how color is assigned. This is similar to the Colr button
on the Image module, but instead of simply cycling the colors it assigns them
to be used in all subsequent fractal images you create or zoom in to.

Images may be saved to disk with the **Save button**. And they may be
loaded from disk files with the Load button. You can load any standard image
file, not just the fractal images you made with this dialog. Images must be
exactly 128x128. If larger, only the upper left area will show; if smaller it
will be positioned in the upper left corner. It is best to resize the image
with a paint program such as Paint Shop Pro before loading it into SoftStep.

Once you have an image you want to work with, click on the **OK
button**, and the image will be transferred to the Image module. Click on the
**Cancel button** to discard the image.

SoftStep is Copyright © 1999-2004 by John Dunn and Algorithmic Arts. All Rights Reserved.