Floating squares.

I wanted to add some independent floating tiles to the image. This proved to be much more difficult that I thought it would be. I will spare you the details, the bottom line is I have been modifying the program / algorithm all along. Experienced programmers know what happens when a program goes through a long series of modifications and enhancements without a cleanup and refactor step, it becomes fragile and unmaintainable. I am at that state now. Often a change does not have the intended results. Fortunately my program is just painting pixels on screen is it not controlling a life and death or even business critical situation.

I am pleased with this one, but I decided to skip several other similar images I had queue up. I plan on returning to this idea once I clean up the program and it does what I want it to do.

What are the different types of computer art? I tried to research that questions, and I was not happy with what I found. Not that the descriptions were wrong, just not what I was looking for. I just want to say that these images are "pixel first algorithmic art".

So, let's make up a simple top level classification. As with similar classifications, it is just an exercise, it does not really matter.

Interactive, or computer assisted art. The user interactively tells the computer what to do. Think of the old MS Paint and similar programs. You tell the computer to put a circle here and a line there as you build up your image. Photoshop is a much more sophisticated example of the same basic process.

Algorithmic art, the computer, via an algorithm or program decides where to paint the circles and lines.

I propose this classification base on process not outcome. You can draw a circle with a mouse in paint, or write a program to draw the same circle. In theory, anything that can be produced by one method can also be produced by the other. But in practice there are clear differences, a human would never have the patience to replicate the precision of an algorithm, and it is very difficult to reproduce a human's free mouse movements with an algorithm.

Now I want to subdivide, algorithmic art. Let's call it object first and pixel fist.

Object first algorithmic art. The program decides where to place objects on the screen, then determines which pixels are affected, and colors those pixels appropriately. If the algorithm want to generate a blue line from point A to point B, it figures out the coordinates for the screen pixels lie on the line and colors them blue.

Pixel first algorithmic art. The algorithm starts with pixel coordinates x,y, and uses those to color the pixel.  Again this is definition not process. You can draw the same blue line pixel first, just ask a slightly different question, "does pixel x,y lies on the line from A to B, if so color it blue".

Again, in theory, everything you could create with one method, you could also create with the other. But in practice, the choice of object-first or pixel-first leads to distinctly different results. Everything I have posted so far, and for the foreseeable future, is pixel-first.

At this point, any description seems like stating the obvious. Bigger squares, less chopping, 50% of the canvas is left untouched.

I use the same program, a program I wrote, for both the fractal and the algorithmic art displayed here.

You cannot just sit down and write a program to create an image. Well, you could but it would quickly become a chore and much less fun. There is a lot of mundane overhead beyond the art-algorithm itself. The program needs to know how to color pixels on the screen. My program provides a work area with I create and explore with smaller images. Then when something is ready, it creates a larger, anti-aliased image to publish. It categorizes the image, and saves it to disk. It also saves all the formulas I write for later reuse. I can quickly change parameters for a formula and generate a new image without recompiling. When the code/program part of a formula changes, it compiles the new code without leaving the program.

It is like having a studio with paints, brushes, drop cloth, and with a blank canvas set up and waiting. I tried to design my program like that.

This fractal / confetti hybrid works much better. The fractal shape is well hidden. (There is a period 6 branch point to the left of center, the branches gently spiral counter clockwise.)

Here is another fractal / confetti hybrid. This works better because the fractal part is deemphasized. You probably recognized the dark potion as a tendril in a typical fractal with smaller branches off to the sides.

Although, in this case, while an improvement over the previous, I think it just adds unnecessary complexity. Layering the confetti mixing algorithm over a simple collection of circles, squares and lines works equally as well, if not better.

I tried to mix the confetti algorithm with the fractal algorithm. I am not pleased with the result. But I am posting it anyway if anyone else was wondering what a (failed) mashup might look like.

The main problem is the confetti algorithm and fractal algorithm have equal influence. The image cannot make up its mind what it is. Often that type of ambiguity is desirable, but it does not work here.

Here I am playing some more with varying the amount of confetti mixing across the image. The function that controls the mixing has become more complex.

A few days ago I called this abstract art and algorithmic art, and implied that it is not fractal art. What is the difference? Why do we need definitions? It is what it is. Feel free to appreciate it (or despise it) without defining it. Classifying it does not change it. Still, classification is an interesting exercise, so let's go there, gently, with that understanding that it does not actually matter.

Fractal art is algorithmic art since it is generated by an algorithm. Fractal art however is limited to a very specific algorithm. For many fractal artists, that algorithm is written by someone else. Even though I write the program(s) for my fractal art, I follow a recipe that is shared by thousands of fellow fractal artists.

Algorithmic art puts no restrictions on the algorithm. Everything is fair game. And generally every image is generated by a different algorithm. The algorithm itself sits on equal footing with all the other artistic stuff. So I like to reserve algorithmic art for the cases where creating the algorithm itself is a key part process.

I am paranoid that someone will vehemently disagree, and that paranoia drives me to deal with the minutia. First, I in no way intend to diminish the work of fractal artists that use someone else's program. Discovery and selection an interesting fractal region, then framing it and coloring it is the artistic input. That takes a lot of skill and practice and creativity.

I should say something similar for using a computer rather than a brush and acrylics. Maybe I will save that for another day.

Second, there are no clear boundaries. Many fractal artists soon get bored with z^2+c and start experimenting with other, and increasing exotic, formulas. Most fractal software allow users to write formulas, so there is no limit, it crosses over into general algorithmic art.

Some may consider this image a fractal. I don't but someone else might. Fractals are sometimes defined as having fractional dimension. I doubt that anyone could compute a Hausdorff dimension for today's image from the underlying formula/algorithm. But by appearance, it certainly seems to fit the definition. Also the process of repeatedly chopping and shuffling pixels seems fractal in nature.

In today's image, different "entropy" levels are assigned to different areas. Recall (yesterday's post Confetti #2,) the algorithm generates different distorted squares, which are used to shuffle around the colors in the starting image. The algorithm has parameters that control the size of the distortion. Rather than setting these parameters universally for the whole image. Another "set up" function sets them differently for different areas of the image.

Previously I mentioned that making these distorted too small or too large, or too variable or too uniform produced uninteresting results. But there are interesting results when the more extreme parameter values are mixed in the same image.

Today's image has the same basic starting point as yesterday. Here the typical "square" is an actual square. Yesterday they were elongated rectangles.

If you are not a daily reader, the algorithm is described in the previous post Confetti #1. The final algorithm is quite different, and much more complex than where I started.

Sometimes algorithmic art incorporates randomness into the algorithm. Despite what the appearance may suggest, this image and the rest are not random. The algorithm will produce this image, and only this image on every run. And in response to the cynics, no, that consistency is not achieved by setting a seed for a random number generator. For example there is a reference "square", that gets modified. Width, height, orientation angle are changes. The changes are determined by a function based on the x,y screen coordinates. There is a mix of different distorted squares. The mix has a mean and standard deviation like a random sample in statistics. But it is deterministic, not random.

Today starts a new series called Confetti. I am leaving fractals behind for now. Although I am sure I will return to fractals, I always do.

This is abstract art and algorithmic art. In the world of mathematics and computers definitions are precise. You can look at something and definitely decide if it fits the definition or not. The real world is not so clean, and the above linked Wikipedia articles are trying to classify things that are difficult to classify. I am sure someday I will be compelled to return to these definitions and add my two cents. But, you know, one day at a time. I will avoid that rabbit hole today, and simply assert that this is that type of art.

This image is generated by an algorithm that I wrote. The original idea was to start with a simple minimalist geometric abstraction, in this case white and black with a small splotch of blue and cyan, with smooth color transitions. Then chop the image up into small squares, displace the squares by varying amounts and then repeat until the original was suitably mixed up. When I implemented this algorithm in a straight forward manner, as suggested by the description, I was disappointed in the results. It was not want I expected, and not in a serendipitous way.

It works better to leave the square in place and pull the colors from elsewhere into the square. The squares are not uniform, they have different width, height and orientation. So they are actually tilted rectangles. The simple repeat loop did not work well, the last set of cuts were too obvious and a distraction. The repeat steps needed a kind of memory which informed the size and displacement for the next step.

There is a narrow range of rectangle sizes that works. If too large then it just looks like random rectangles. If too small, then the confetti effect disappears and it looks too much like the original smooth color image. Also, it takes a lot of iterations to get the squares chopped up and messy. This one has 80 iterations, although usually 20 to 50 is enough.

After all these adjustments I came up with something close to my original intent.

And here the the second alternate coloring of the image in Vines #11. There are more colors to help the fractal fireworks standout. The vines now appear as shadows or waves around the main fractal shape.

I was going to move on to another topic today. But my obsessive compulsive disorder prevents me from leaving this topic with "yeah, that one could be better if I worked on it more". So I went back to work on it. Here are two alternate views of the same fractal space, with better foreground / background separation. I muted the background, removed the corners on the vines and added gold / brown to highlight the high spots in the fractal shape.

Today's image has some of the same issues as yesterday's, too noisy and not in a good way. But since I had it queued up, and I am busy on other stuff it is what I have for today...

Center: -0.7535-0.0482i, window width = .0019.

I was undecided whether to post this one or delete it. The accumulator coloring uses a square rather than a circle. The problem is that the base fractal, that is same area but with default escape-time coloring, is complex and interesting on its own. In a sense, that starting point is thick. The vine coloring is fighting with, and colliding with the base fractal. There is not enough surrounding open area for the "decorations".

I may return to this one. A lighter touch on the enhancements, similar to Smooth 1D colors #16 or Vines #1 may produce better results.

I have moved on to other things, and there is more work to do before starting the next topic. I do not want to get in the habit of skipping a day because what I have is not perfect. So I decided to post this as-is.

Location -0.718423+0.297283i. Window width = .0000076.

The coloring is similar to yesterday's image Vines #8. Each flower / star / snowflake surrounds a period eleven Misiurewicz point. There are eleven branches coming out of each.

Fractal location 0.020 + 0.818i, image width 0.016. With more a conventional coloring method, the fractal shape here is a jagged line with branches, it is very thin. It looks like lightning. But it is rather boring, as if it is calling out for some decoration.

The vines algorithm is one way to add decorations. Points in what would normally be called the actual fractal (non-escaping orbits) are removed from this image. Focus is on the path the nearby escaping points take while escaping. Like wrapping vines around a jagged invisible branch.

No words, just a picture today.

Another location, still coloring with vines.

The r₁ parameter in accumulator function has been reduced. In other words, here is a more viny picture for the Vines series.

What follows is a lengthy post that has almost nothing to do with the featured image. While looking for vine fractals on the internet I found some stalk fractals which reminded me of some other ways to color fractals. I do not plan to do a series on these alternatives, or create my own examples. Although that plan may change someday if I am staring at a blank post and have nothing else to write about. Nonetheless, they deserve some mention.

Previously, I stated that a fractal calculation creates a bucket of numbers that are used to determine a color. The numbers have a particular order so a list or sequence of numbers is a more accurate description than bucket. If you are curious, Robert Devaney has a good entry level article What is the Mandelbrot Set.

I will just start with this list of numbers, "the orbit", and discuss how to create a color. The first method people used, and probably still the most common is escape time counting, which amounts to simply counting how many numbers are less than a fixed threshold value. I wrote about that method way back in Smooth 1D Colors #1, to demonstrate non-smooth coloring.

I always found iteration counting somewhat disappointing. You have this big list of numbers, and all you do is count them? Surely there is more information and other things of interest in these numbers than a count. Back in the day I really did believe we were missing some deep mathematical meaning. Now, I do not care about mathematical meaning, I am just looking to create pretty pictures. Simple counting overlooks much potential.

In addition to smoothing out the color bands in those early escape time fractals, I was motivated to develop accumulator colors because it used all of the numbers in the orbit. It provides alternate interesting ways to color the same basic fractal.

Here are a couple of "stalky" early coloring ideas that go beyond counting. First the Pickover stalk, Image, Article. (The Wikipedia article incorrectly calls this an orbit trap, and I think it overstates the mathematical significance.)

This method uses the closest distance the orbit gets to either the x or y axes. Or a little more formally, if z_k = x_k + i * y_k, then d = min_k (min |x_k|, |y_k |) is used for coloring. k is an index that ranges over all of the points in the orbit.

The second example is orbit traps, here is an example of orbit trap stalks. The orbit trap method tests each orbit point against a boolean (true/false) condition. If z_k is the first orbit point for which the test is true, then the index number k is used to determine the color. The exact formula is not documented for the linked image, but it would be something like min(|x_k|,|y_k |) < 0.1.

The Wikipedia article on orbit traps is incorrect. I found a couple of good references here VisMath and Softology The latter is a support page for the fractal software  Visions of Chaos. I do not know anything about the software, if you try it out, let me know what you think.

So, where do these two methods fit into the fractal coloring landscape? Both methods use all of the orbit points, at least in the sense that they test each point and select one. Once selected, the color value is determined by that single orbit point. Pickover stalks uses the minimum value over all the orbit points, a real number. It turns out to be a continuous function of the orbit, and generates smooth colorings. Orbit traps use the index of the first orbit point, an integer, so it produces discrete colors. With orbit traps the focus becomes more on the trap shape than the generating fractal. Often a psuedo-3D effect is applied to the trapped region. When done right the result is artistically pleasing.

There is a key distinction between these methods. Pickover Stalks, and other min-value methods check all orbit points and finds the minimum value of some test function. They are naturally continuous. Whereas orbit traps use a boolean test condition and uses the first index (sometimes the last index) where the conditions is true. The result is a discrete value, the index. They are similar in that both apply some kind of test function to the orbit point. (As does accumulator colors.) The various min-distance methods, and accumulator colors predate orbit traps.

The Wikipedia article on orbit traps is actually describing the various min-distance methods. Some fractal programs have started calling any method that applies a test function to a point an orbit trap.

Bill Clinton might have said "It all depends on what your definition of orbit trap is". (He did not say that, but he would if he read this post.) Definitions change and are basically whatever is the common usage. But, usually I  prefer accuracy and precision. So around here, I will use the more precise definitions of the various color methods.