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…

# Tag: fractal

## Vines #10

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.

## Smooth 1D Colors #10

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 is the start point, is the orbit, and R is the escape radius. Color banding, happens when gets close to R. The fractal function is continuous, but a small change in the starting point, can result in 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.

## Smooth 1D Colors #9

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 . 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.

## Smooth 1D Colors #8

Today’s image uses a modification of the escape count to produce a continuous value that is used to set the color.

Recall that escape counting produces integer values, which creates color bands in the image.

So far, we have not done anything special for color smoothing. Even with the discrete valued iteration count color method, the color bands naturally disappear in a deep zoom. We re-scale the color palette, using both linear and non-linear methods, to get the optimal amount of color entropy. At some point, the color distance between color steps in the fractal calculation is less than the displayable color steps in the computer graphics hardware.

But re-scaling the palette does not work for no-zoom or low-zoom images. There are simply not enough color values. If scaling used to make each step small, then there is not enough color range, the image appears as a single color.

The first idea is to somehow make the escape count into a real number. If the leading edge of one band is n, and the next is n+1, then fill in the area in-between with real numbers between n and n+1. Once an orbit crosses the escape threshold, try to measure by how much. Then turn that over-shoot into a fraction between 0 and 1 and add it to the escape count. Personally, I tried several things, and I got some to work. My solutions were hacky and ugly. Someone else came up is this elegant answer: Continuous_(smooth)_coloring (Unfortunately the Wikipedia article does not say who developed this method. He or she certainly deserves some praise.)

I am not going to reproduce the math here. Wikipedia does a better job of that. Today’s picture shows that this method effectively removes the banding on low-zoom, low escape count, fractal images.