I’ve been very happy to get the time lately to restart some investigations that I put on the back burner for quite a while (i.e., years). The first of these projects was to create a bank of images created using one-dimensional cellular automata. My inspiration to investigate this comes from Flake’s enjoyable “fish and chips” book, “The Computational Beauty of Nature.”
Cellular automata (CA) images are a sort of life map for a community of symbolic cells, which may be in only one of a finite number of states. In its simplest form, the map is represented by a grid of squares, each of which can be either white or black. The top row of squares represents the initial state of the cells. The next line of squares is the state of the cells after one unit of time, and so on. Whether a given cell is live or dead is specified by a very simple set of rules. Its state is (defined to be) only dependent on the states of a few squares on the line above it, representing the lives of itself and a few cells around it, one time unit ago. In the simplest interesting case, it depends on the lives of itself and its two nearest neighbors. In the graphical sense, the square — which is of course a kind of pixel — is white or black depending on the colors of the three squares just above it. For example, one example of a set of rules is shown here, in a figure from Flake’s book, that he kindly provides free on his website for educational etc. use:
This next figure shows the evolution of two black cells for a few time units following this rule:
The third figure shows the handsome Sierpinski triangles created by the evolution of this system on a larger scale, on the left, and the triangular froth created if we start with a random line of several live and dead cells.
Further images and discussion can be seen here in this link to Flake’s figures, and this Wikipedia CA link.
Flake provides his audience with a downloadable set of C programs to experiment with topics in his book. Happily this is the progamming language I decided to learn after leaving physics and finding Basic and Fortran compilers gone scarce. Despite the code being almost ten years old (I run it in the DOS environment of windows) it’s up and running on my this-year’s pc. I ran into some little problems, such as only succeeding in getting on-screen output, not file output (which I need, to further work with my image in Photoshop afterwards). For the moment, my shaky knowledge of dealing with libraries of C routines, as opposed as a simple self-contained program, is limiting me from hacking in and modifying his code to suit me.
I’ll have to learn, as there are other topics (notably those involving vector-based graphics rather than pixel-based — I REALLY don’t want to reinvent the wheel and make routines for vector drawing) that will really take that knowledge for me to do the custom modifications I would like to explore. However, for the moment, no problem, as cellular automata are simple enough (and very much pixel-based!) and it was fun to program my own crude C routines that output cellular automata images to photoshop RAW files. Meanwhile Flake’s routines remain more convenient for me for quickly studying many cases, and I made up long batch files of rules carefully generated with a mix of selection and randomness, and scanned through thousands of images to make my first swatch bank of 160 well-varied CA images/textures. For artistic reference, I have sorted these images into many categories, varying from frothes in many flavors — small triangle, big triangle, modern, pacman and sierpinkski to name a few — to basketweaves, nettings and … alien invasion:
Each image is labeled with a sequence of numbers that tells me how to recreate its type of image in my own programming, so that I can generate it with my own routines, should I need to generate it at a larger scale than can be screen-shotted.
This may in fact be less necessary than I thought at first. While I normally have a horror of using things at such blown-up resolution that pixelation is visible, the pixels here are fundamental, significant entities in themselves, representing unique cells, rather than being just tiny units that in juxtaposition we use to compose an apparently unpixelated image. I’m currently planning to be using CA images/texture in relatively small insets, at a scale where pixels are small but visible, perhaps the 60dpi level. This means therefore much smaller files than I normally need. Here are some of my favorites:
In some cases I might use these files at even larger scales, for example:
giving a pronounced flavor of woven textile, possibly overlaying a finer resolution file to add subtle fine texture.
Cellular automata, in addition to being a way I can, as desired, use mathematics to generate images for my work, fits perfectly with my general mode in its interplay of constraints, randomness and selection. My next step will be to use some of these swatches incorporated in my final work. I have a huge selection already to use, but would still like to go back sometime and explore further with my own routines: more general rules (Flake uses a constrained set in his code), — and more specific ones — for some reason I’m having trouble getting his routine to do the simplest case, cells that have only two states. I’m also wondering what would happen in the asymmetric case of not requiring the same number of neighboring cells on the left and on the right to influence the next state of a given cell. Finally, since CA where each cell’s evolution depends on many previous states tend to give a too-garbled randomness, I would like to study such behavior as a small perturbation on evolution dependent on closer neighbors; in other words, have evolution mainly dependent on closer neighbors, but with small mutations in behavior introduced by the states of further neighbors (something that cannot be implemented in the constrained set of rules used in Flake’s routines).
.
