Anthony Mattox Interaction Design + Digital Art

Generative Images created in Processing. Click to Enlarge.

I was recently asked to create some work for a collaborative project. I decided to create some generative work in Processing and try out some ideas I’ve had in the back of my mind. The script wraps a number of different generative patterns into one system. Each circle has instructions for how it behaves and creates new circles and these instructions change as they grow. The images it creates are more complex and dynamic that a lot of my preview sketches.

A slightly more technical explanation: The script has an array of objects, I’ll call them nodes. Each node has a couple of functions for initializing itself, branching new nodes, updating, and rendering. The container creates a new node which grows, branches, and then becomes inactive. The newly branched nodes grow and branch and the cycle continues, growing the image.

The fun part is that the basic ‘node’ object can be extended to any number of variations all of which can still be handled as the generic type by the container in the same way. The container tells a node to ‘branch’ and it may create new nodes randomly around itself or touching it’s sides or in a set direction to grow tendrils. Each variation of node also sometimes branches to different types so one structure will morph into another. Other functions, like rendering, can also be extended or overwritten to create different behavior.

I think there’s a lot of potential in this kind of polymorphic system. I’ll play around with it some more and maybe post some more technical examples.

This afternoon I played around with 1d cellular automata. The program is creates an array of cells which corresponds to a row of pixels on the screen. Each new generation of the structure is represented by the next row of pixels and the value (black or white) of each pixel is based on the three directly above it. There are eight possibilities for the pattern of the three parent pixels and an array of eight values stores the results to each of these possibilities. Changing the rule-set and the values of the first generation creates vastly different images. The script I was using was very much based off of Dan Shiffman’s code.

Read On »

I built this script which creates circles budding off of circles. What better to do with it than put it in a circle? I could give some lofty symbolism for circles, and some if it might even be half true, but to be frank I just like them. They look nice. Not to mention it’s much too late to be coding anyway (or blogging).

Read On »

I created this Context Free Art script a few months ago and revisited it to tweak it a bit and make some nice high resolution renderings. This is a great illustration of what I find so fascinating about fractals. Computers are often considered the antithesis of organic growth, however, their incredible ability to replicate such processes seems to be in the very nature of object oriented programming. The complexity that can be formed from such simple rules and patterns continues to amaze me.

Although a mathematics purist may not willingly call this a fractal, it is in my opinion a prime example. I think Benoît Mandelbrot would agree with me. It is a mathematical function which, through a simple iterate system, fantastically mimics physical structures. It also has the properties of self similarity over infinite scale which is indicative of fractals.

Read On »

Initially this script replicated some drawings I have been working on in my sketchbook. Although it’s very meditative to create such drawings I feel the interesting aspect is the form and texture that emerges from the repetition of the simple process. Creating a script to replicate this system allows the work to be detached from a particular composition and focus on these aspects which interest me. It also allows for the image to be animated.

The script is written in Processing. Each circle buds new circles at random angles. The new circles grow until the hit they collide with another. The color of each is a slight variation of it’s parent.

Read On »

Geometric fractals can be very visually interesting and aesthetically pleasing and are quite easy to understand and create, even just with pencil and paper. Computers make the process a bit easier though.
Within an object oriented programming environment

The process of creating such a fractal begins with a basic shape. In this illustration a line, but it could be a square, circle, arc, cube, or perhaps a bunny rabbit. Then we have the rule. Each iteration every instance of the initial object is replaced with the rule shape. Here a line is turned into a ‘Y’ and in each subsequent iteration all lines are turned into ‘Y’s as well. You can probably see quite quickly by using different rules geometric fractals can generate all sorts of shapes and textures. More possibilities are opened by adding more complex transformations, changing the scale, color, or any other property, limiting iteration to only certain shapes, adding random factors, and working in 3d environments.

Read On »

This is another script working with 3d l-systems but renders them quite differently. The 3d structure is translated onto a two dimensional plane and then a vertical line draws up to each point. The numbers represent the index number of each object within the code structure. The script uses the P3D library as it renders a little faster and the more advanced rendering of OpenGL is not needed.

Read On »

Simple recursive functions can created complex geometric fractals. A function draws a graphic and then by calling itself any number of times creates branches in the image. Each of the branches follows the same algorithm and creates the fractal. The transformations which occur between iterations, the graphic drawn, and any other steps or even randomized algorithms within the process determine the resulting fractals structure. This video of a fractal programmed in Processing is one of the simplest geometric fractals. Each iteration produces two copies of itself at it’s end. More complex versions of such a function are used to generate trees and other structures in video games and other virtual environments. The rotations of these two branches are changed slightly each frame and the function is recalculated. Within an object oriented programming language like Processing, each iteration could also create a new object or pass values into an array allowing the data to be easily reused without re-running the entire function.