There are a number of different active link user commands you can access in the Help Browser that can be used to control directed evolution of MSG presets in the Evolution Editor palette. If you have previously used the MSG Evolver application to evolve MSG presets some of these will be familiar to you. When these commands are run on the evolution grid each msg preset preview in the grid is modified by the command.

Often there are 2 different command options (observe the color coded triangle icons above). One runs the command on the existing contents of the evolution grid. The other runs the command on the MSG editor preview and fills the grid using that as the source for the command.

Grid Evolution Commands

Randomize – randomly mutates the parameters

Swap 1 – randomly swaps 1 processor

Swap Random N – randomly swaps random N processors

Swap All – randomly swaps all processors

Insert 1 – randomly inserts a new processor in the the processor chain

Delete 1 – randomly deletes 1 processor from the processor chain

Add MetaEffect – randomly selects a meta edit effect and runs it on the processor chain

Add Color Gradient MetaEdit – randomly runs a color gradient meta edit

Add Color Palette MetaEdit - randomly runs a color palette meta edit

ReSeed –  any random see parameters are randomly reset

Fix Recursion Problems – looks for potential problems with recursive io connections and fixes them

Grid Generate Commands

Scan Backward Presets Once – scans forward through the factory msg presets

Scan Forward Presets Once - scans backwards through the factory msg presets

Scan Random Presets Once - scans randomly through the factory msg presets

AutoEvolve Random Presets Once – auto evolves random factory presets

Auto Configuration – generates random fixed configurations

Evolve Continuous Commands

These commands mirror the ones explained above but will continuously update the evolution grid every few seconds until stopped by pressing the spacebar.

Directed Evolution Strategies

Working with directed evolution in the Evolution Editor to create procedural art is somewhat of an art in itself. There’s a definite feel to it and with practice you will get better. The more you work with the various commands described above the better feel you will get for the process.  

Randomly mutating parameters in a fixed processor configuration will generate endless variations on a particular effect or art style, but will never break new ground in terms of complexity of the effect or changes in the style of the generated output.  

Swapping processors changes the nature of the effect since the actual processors and their associated io connections are changing. Swapping one random processor will not create as radical an effect as swapping all of the processors, which can often be too radical a change or lead to garbage. Swapping N random processors is somewhere in between the two. Sometimes Swap All will break you out of a rut into something new but often it’s too much of a change and leads into a bad configuration.

Often the best approach is to repeatably use Swap 1 to generate new sets of presets in the evolution grid, followed by clicking on the one you like best to mutate variations of that swapped configuration, then repeat as necessary. Doing this over and over will move you slowly through the overall MSG configuration space in a controlled fashion. You can always undo to drop back to your previous evolution grid if you don’t like what a particular evolve command did.

Adding a MetaEffect is a great way to take something simple and add additional complexity. Doing this and then following it by a series of Swaps can lead to processor configurations you would have never have thought to try and potentially stunning visual effects. Or a lot of garbage. The trick to directed evolution is to figure out how to avoid the garbage and direct the evolution grid over time to get visually interesting results for your particular artistic sense and style.

Here’s an example of a preview of a procedural image created by directed evolution and the associated processor chain that creates the preview image. This is a good example of something created by starting with a simple pre built preset followed by adding 2 MetaEffects and a random Insert to increase complexity followed by a series of directed Swap 1 and click Mutation evolution steps until i arrived at something i really liked.  

Often when that happens you have entered a sweet spot in the MSG configuration space. By sweet spot i mean that with every Randomize or Swap 1 command you generate more interesting preview images that contain a lot of potential keepers. A sweet spot is always a good place to restart directed evolution at a later time. You can do this by loading a MSG preset you previously saved from the sweet spot and running one of the commands that derives the evolution grid from the preview image as source for the grid command.

Each image stream in a MSG preset is a monochrome image. So generating a color output means that 3 image streams need to be generated. There are many different editing strategies that can be used to create a color image and we’ll run through a few examples below. All of the examples shown will use the same simple monochrome texture field created by the AdvTurb processor. The screen snap below shows the io routing for the AdvTurb processor, which takes the R Out stream as its input and output.

AdvTurb is short for advanced turbulence.  This processor can generate a wide variety of different procedural texture fields.  It also has an input io port which can be used to locally modulate different parameters associated with the texture field generation process.  The SetToValue processor is just creating a flat color image in the R Out stream which would be the simplest modulator possible to use as an input modulator for the AdvTurb processor.

This example above shows how the monochrome output stream from the AdvTurb processor is then used as the input to a 1to3 processor. The IO Port connections are shown in the screen snap above. The 1to3 processor is very simple and just routes it’s input stream to its 3 output streams with no additional processing.

This next example above replaces the 1to3 processor in the previous preset with a 1to3GradMap processor. This processor has 2 input ports, one for an image stream and the other for a color gradient stream. The input image stream is used as a mapping index into the color gradient. So the 1to3GradMap processor takes a black and white image and converts it into a 3 stream color image. By changing the color gradient you can change the coloring of the texture field.

Gradient or palette mapping a monochrome image is a common technique to take a black and white monochrome image and turn it into a color one. Each has a characteristic aesthetic look to it.

Here’s an example of modifying the preset shown above to use a 1to3PaletteMap processor. This processor again has 2 inputs, one for an image stream and the other for a color palette stream. So the 1to3PaletteMap processor takes a black and white image and converts it into a 3 stream color image. By changing the color palette you can change the coloring of the texture field.

An alternative to mapping a monochrome image into a color one is to generate 3 different monochrome images, one for each of the 3 color streams in the output color image. The preset above shows a simple example of this approach. Notice that there is a characteristic look to the end result. The technique shown next is a way to take this basic strategy and make it more visually appealing.

There are a number of different MSG processors that take a color input and then colorize it using 1 or more color palette or gradients. These processors are very useful for generating more appealing colorings for abstract artwork generated using MSG. The ForceColorMap processor is being used for this purpose in the example above. This processor takes 3 image input streams and 2 color palette input streams and then generates 3 output streams. Note how the visual appearance and aesthetic of the previous example has been radically modified by this ForceColorMap processor.

There are a number of different SmoothColorMap and ForceColorMap processors that can be used as described above to recolorize a color image. Some base their coloring on color palettes and others on color gradients. Some are also configured so that they can generate 2 different colors in different local areas in the output image based on another modulator input stream.

More Elaborate Coloring Strategies

The example above shows a more elaborate coloring strategy. While working with directed evolution in the Evolution Editor i ended up with a MSG preset that used the 1to3PaletteMap processor as a final coloring step. This gave a very characteristic appearance associated with color palette mapping that seemed too synthetic or sterile to me. So to create something more organic, i added an additional processor that filtered the palette mapped output to soften it and add more organic character. I then used the ForceColorMap processor with 2 different color palette mapping inputs to remap the processed palette mapped image into a different color palette to create a much more organic effect shown above.

This example also shows how a little select manual editing after a round of directed evolution can help clean up any potential problems or hone in a particular artistic style.