anthony mattox new media art & design

Cellular Automata

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 »

Cell Cluster Circles

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 »

Neuron Fractal

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 »

Cell Cluster

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 »

Creating Geometric Fractals with Processing

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 »

3d L-System Structure

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.

Processing Collaboration with Graham W.

read on »

Tree Fractal

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.

Tendril Fractals

I created a relatively simple recursive algorithm in Processing which allows me to control any number of parameters of a geometric fractal. The function repeats it self changing parameters for the size and position and then calls another function to render a predefined graphic using the resulting data. Based on a set percentage and a randomized number, the function also recalls itself twice, causing the graphic system to branch.

Adjusting the initial parameter for the first call to the function, those for how each generation is calculated, and the graphic function can produce innumerable different forms and textures. These are a few images I have created using the scripts. Processing also has the ability to export graphics as vector graphics, which can be scaled and used in vector software such as Illustrator. I am working on an application which will allow the parameters to be changed through an interface within the application.

read on »