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.

Another vines image, same fractal location but with variation in the fractal coloring parameters.

After I decided to call this series "Vines", I checked the internet for similar images. I found a few fractal images called vines. Those were images only, without description of method. From the appearance they were generated via a different method.

There are many fractals called "Stalks". I had considered that, but vines are curved and stalks are straight. The methods behind the stalks fractals incorporate straight lines in various ways.

Tomorrow (hopefully, if not, then some other future date) I will talk about stalks and one or two other ways to color fractals.

You are in luck, much less text today...

Today the vine coloring formula parameters have a smaller r_2 value. The color gradient is steeper from center to the edge of the arcs or vines, making them more pronounced.

Two days ago I promised to shift gears. So here is a new series called vines. The title may not obvious with today's image. More on that later.

Today's image is the same area as the previous two, Smooth 1D Color #18 and Smooth 1D Colors #17. It is also a continuation of the accumulator colors method. However, now the parameters are set in such a way to create shapes in the background, rather than just smoothing out the color bands. The colors are still continuous, we are not going to bring back the banding in the early fractals. The goal now is to put interesting things in the background.

The previous images were generated by overlaying many fuzzy disks. This one is generated by overlaying many fuzzy circles. By strict definition, if not by common usage, disks and circles are not the same thing. A circle is the edge or border and a disk is the inside of that round thing you are thinking about.

Some gentle mathematics follow, I promise it is gentle, please give it a chance even if you do not consider yourself a "math person". It is very easy.

I introduced the math for accumulator colors in Smooth 1D Colors #10. The simple formula $ 1 - |z|/r$ played a key role. Actually many of the pictures use $ 1 - |z-a|/r$. Which is the same thing when a = 0.

Today's image uses $ 1 - ||z-a|-r_1|/r_2$

First a recap on the old formula. a and r are arbitrary parameters. a is complex and r is real. (A complex number is a pair of real numbers.) Different values of a and r produce different colorings, and a lot of opportunities to experiment.

z has many values, in an academic paper it would be called $ z_i$. z tracks a point's orbit in the fractal calculation. The mathematician's definition of orbit is different from the astronomer's. For now, just think of it as a big bucket of numbers that you get from the fractal calculation.

$ 1 - |z-a|/r$ is a disk centered at a with radius r.

People with some mathematical sophistication will object, for you folks, the set of z's for which this function is positive is a disk centered at a with radius r.

Let's say C = the circle centered at a with radius r. This is just to make my typing and your reading a bit easier. The aforementioned disk is the interior of C.

Let's break it down the formula.

If z = a then $ 1 - |z-a|/r = 1$

If z is inside C, then |z-a| < r and $ 0 < 1 - |z-a|/r <= 1$

If z is on C, then |z-a| = r and $ 1 - |z-a|/r = 0$

If z is outside C, then |z-a| > r and $ 1 - |z-a|/r < 0$

I called this a fuzzy disk. Imagine we are painting, and this formula tells us how much paint to use. 1 is full coverage, 0 or less is no coverage, and the numbers in-between indicate partial coverage. 1/2 is a mix of 1/2 the new color and 1/2 the previous color. If we put black paint on a white background with this recipe we get a blurred disk, solid black at the center, and a smooth transitions to white at the edge.

Now, back to our bucket of numbers, the z's. Apply this formula to each one, and add up all of the positive values. The resulting sum is used to look up a color in a color palette. Paint the screen pixel that color. This is done for every pixel on the screen. (Each pixel gets a different bucket of z numbers, and so a different color.)

Wow, that is just recap. On to today's picture and

$ 1 - ||z-a|-r_1|/r_2$

If z is distance $ r_1$ from a, then $ |z-a|-r_1 = 0$, call this circle C. On C the full expression $ 1 - ||z-a|-r_1|/r_2 = 1$

If z is distance $ r_1 + r_2$ from a, then $ ||z-a|-r_1| = r_2$ and $ 1 - ||z-a|-r_1|/r_2 = 0$. Call this circle C+.

Also if z is distance $ r_1 - r_2$ from a, then $ ||z-a|-r_1| = r_2$ and $ 1 - ||z-a|-r_1|/r_2 = 0$. Call this circle C-. If  $ r_1 < r_2$ then C- does not exist. It would have negative radius. That is not a problem.

Summarizing, we have three circles, all centered at a, with different radii.

If z inside C- or outside C+ then $ 1 - ||z-a|-r_1|/r_2 < 0$

If z outside C- and inside C+ then $ 1 - ||z-a|-r_1|/r_2 > 0$

If z is on C then $ 1 - ||z-a|-r_1|/r_2 = 0$

And that is the fuzzy circle. The formula is one on the circle C and smoothly fades to 0, in both directions, in and out.

This formula has all the important properties for smooth coloring. It is a suitable candidate for accumulator coloring algorithm. Since the "hot spot" is a circle rather than a point, lines (actually arcs of distorted circles) begin to appear in the image.

(2019/06/07 edit note: Substantial revision incorporating suggestions from someone who considers herself not a "math person".)

OK, one more repost from my Smooth Colors series on Fractal Forums.

Earlier, before I started this series of posts here, I had started a thread on Fractal Forums, Smooth Colors. This image is one of a series that I posted there demonstrating the visual effects that result from changing various parameters. I am not going to repost that whole series. However, I like to do color experiments on this fractal location. I will use it as a reference to jump into another coloring idea, tomorrow.

For those of you who possess a complex number plane, this picture was taken at -0.9125+.2732i, with width = 0.125.

Another view of the Misiurewicz point, this time with accumulator colors and non-linear (square root) scaling.

Links to previous posts of this area: #6 #7 #15

Here is the image from Smooth 1D Colors #6 reimagined with accumulator colors. Notice the "shadows" behind the fractal, and that the blue and white are gone from the background and pushed into the fractal fine detail.

Those are not real shadows. No 3D, no light, no shadow. I use the word just to describe the lighter and darker shades in the background. The different shades arise because accumulator colors is not simple escape counting, or log-log smoothing of escape counts. Orbits of nearby points may escape at the same time, but they behave differently along the way. They take different paths on the way out. Accumulator colors uses all the points in the orbit.

Additional color tweaks on the same fractal shape. Added non-linear scaling (square root) to the accumulator color value to reduce the noise in the high-count areas. Other tweaks on the accumulator color add some highlight and shadow around the main fractal shape.

Here is a zoom into a Misiurewicz point using accumulator colors, with linear palette re-scaling. The main fractal has a lot of "sparkles". This is the same situation as with escape count coloring, the rate of color change increases with the higher iteration count.

The accumulator color method can create color shading that more closely follows the fractal shape. With iteration counts or log-log smoothing the background is a single color, or gradually changes from the outside to the inside. See Smooth 1D Colors #6 and Smooth 1D Colors #7 for comparison.

Minor oops, I intended to use the same coordinates to contrast accumulator coloring and log-log coloring. I just realized that I have two different Misiurewicz points. I have this image prepared so I am going with it. I may follow up later with new colors for the images in the earlier posts.

Here is a small zoom. The accumulator colors method is again provides smooth colors. A variation is used to add some interest to the background, without distracting from the main fractal shapes.

The image center is -1.055+0.261i. It is the period 2/7 bulb off the main 1/2 bulb. After looking at a few pictures like this you soon learn how to read these fraction numbers off the image. Notice that there are seven branches radiating from the center, and that the longest is the second clockwise from the root. If you zoom out to the full view, you see the black area on the bottom is part of the main 1/2 bulb (nose or head).

In the top left corner, notice how one stalk reaches a pinch point the seems to grow again. This is true of all of the branches in the picture. It is almost a degenerate case, but applying the same fraction counting scheme as for the 2/7 branch point, we get 1/2. That tells us that all of these are growing off the main 1/2 bulb.

Today's image uses the accumulator colors method with a variation in the accumulation function.

The log-log smooth coloring method is designed to be as close to escape count coloring as possible. There is very little room to get creative. The accumulator colors method abandons the idea that the integer portion of the smooth color value should match the escape count. Since something less than one is added to the accumulator at each step, the accumulator value is almost certainly less than the iteration escape count. This is not a big deal. In fact after applying linear or nonlinear re-scaling, even escape count coloring does not coincide with the escape count.

The only requirement for smooth coloring with the accumulator colors method is that the amount added at each step must be zero on the escape boundary. That provides a lot of freedom for variations.

Notice how a halo like effect is generated around the fractal. For the fractal purists out there, there is no mathematical significance to this variation. It is done purely for artistic effect.

Here is another method to generate smooth colors.

I first learned about the log-log smooth coloring method  Continuous_(smooth)_coloring in the mid-1990s on the alt.fractals or was it sci.fractals news group. I was afraid of this method because the log function is slow. Actually, log-log is very efficient. But my fear of taking a performance hit was enough that I continued to use a different method that I call accumulator colors. My method turns out to be slower, but it has other advantages.

I assume you have some basic knowledge about generating fractal images, so I will jump right into the middle

Suppose $ z_0$ is the start point, $ z_i$ is the orbit, and R is the escape radius. Color banding, happens when $ z_i$ gets close to R. The fractal function is continuous, but a small change in the starting point, $ z_0$ can result in $ z_i$ landing on the "other side" of R, and thus getting assigned a different color.

Think of escape counting as adding 1 to an accumulator in the inner loop. The accumulator, acc, is set to 0 at the start of the iteration, and inside the inner loop we have

if( |z| < R ) { acc = acc + 1 }

This should make it obvious how a small change in |z| near R, results in a big change +1 in the result.

Now use this instead:

if( |z| < R ) { acc = acc + 1 - |z| / R }

The added value is between 0 and 1, and it is close to 0 when |z| is close to R. The resulting color is continuous.

The derivative of the function is not continuous. Often the result has a different kind of banding, where the rate of color change varies between bands. If the value is squared then we get a continuous derivative:

if( |z| < R ) { acc = acc + (1 - |z| / R)^2 }

https://fractalforums.org/fractal-mathematics-and-new-theories/28/smooth-1d-coloring/2753 has all the math details.

And https://fractalforums.org/image-threads/25/smooth-1d-coloring/2755 has many example images

This method has a rich set of variations.

Today's image required some parameter twiddling to get a color range similar to the first log-log smooth color image.

Here is another example of a low zoom fractal using Continuous_(smooth)_coloring. Wikipedia gives this method a name that is too generic. There are other smooth coloring methods. I am going to call this method the log-log color method. (The reason is obvious if you check the link.)

In earlier posts I used linear and nonlinear rescaling to tweak the colors on deep zoom fractals. Now, after applying the smooth color algorithm, palette rescaling can be used to tweak colors on low zoom fractals.

I am not going to demonstrate this continuous color method on a deep zoom fractal. Since this method is carefully crafted to match the escape count, up to a fractional amount there is no appreciable difference in the resulting images between the two methods.

I should also mention that the log-log method only works for degree-2 polynomials like $ z^2+c$. It can be generalized to other polynomials, but often people overlook that. It does not generalize to non-polynomial formulas.

Tomorrow I will present a method that works everywhere.