I started a thread on 2D coloring, then spent most of my time describing a 1D coloring method. So I am forking the thread with a new appropriate title. This post is a follow up of https://fractalforums.org/fractal-mathematics-and-new-theories/28/2d-coloring/2745/msg13948#msg13948

TL;DR summary:
If f(z,c) is a continuous fractal generating formula, z_i or more properly z_i(c) are the iterations for parameter space value c, N is the max iteration cutoff value, and R is a good escape radius, that is \( |z_i|>R, j>i => |z_j| > R \). Then \(  \sum_{i=0}^{N}\max(R-|z_i|,0) \) is a continuous function \( \mathbb{C \rightarrow R} \), and so suitable for use in a smooth coloring algorithm.

I choose R-|z_i| originally because both these values are readily available during the fractal calculation. Actually the proof only requires \[ (1) |z| \geq R => g_1(z)=0  \]
If g₁ satisfies condition (1) then \(  \sum_{i=0}^{N}g_1(z_i) \) is continuous.

Consider the more relaxed condition \[ (2) |z| \geq R => g_1(z) \leq 0  \]\[ (3)g_1(z)=\max(g_2(z),0) \]
If g₂ satisfies (2) the g₁ defined by (3) satisfies condition (1). To reduce verbosity, in what follows when I define a function can call it g₂, it satisfies condition (2) and it defines a companion function g₁ via (3).

The function in the last post, \( g_2(z)=R-|z| \), is heavily depends on the value or R. If you are working on an image, then changing R will really mess up your colors.

 \( g_2(z)=1-|z|/R \) works much better. It still depends on R, but the color changes due to changes in R are more subtle. Note that \( 0 \leq g_1(z) \leq 1 \). If n is the iteration where the orbit escapes then summation is in the range  \(  0 \leq \sum_{i=0}^{N}g_1(z_i) \leq n \). This is starting to look like an iteration count. In fact for large R the summation starts to approach the iteration count step function. Of course, that is what we are trying to avoid. Still it is nice to know that R is a dial we can turn where one extreme is the familiar iteration count.

Both of these examples have \( |z|<R => g_1(z)>0 \). Which kind of complements condition (1). Don't be fooled, it is not necessary. Purists may object to relaxing this condition. It was already blasphemy to not give each iteration its full count value of 1, now some pre-escape steps in the iteration may contribute nothing, or horrors! even negatively to computation. Well you know I am not a purist, this is just another artistic tool to add to the tool box.

\( g_2(z)=1-|z|/R_1 \, where \, R_1 \leq R \). Now the radius that contributes to the summation is smaller, potentially much smaller than the escape radius. Small values for R₁ tends to put stronger emphasis, and direct viewer focus on points close to the fractal boundary. Again an artistic consideration not necessarily a mathematical one.

Variations on absolute value are possible. set z = x + iy
\[ g_2(z)=1-(|x|+|y|)/R_1\\
g_2(z)=1-\max(|x|,|y|)/R_1\\
g_2(z)=1-| |z| - a | / R_1 \, where \, a + R_1 <= R
 \]
The first is a filled in diamond, the second is a filled in square, the third, if a > R₁ is a circle of radius a and width R₁. Generally these choices only make subtle differences in the final image. If you do something extreme, like fractal formula is f(z,c) = c, and iteration count is 1, then you will see the shapes described, fuzzy around the edges. Each formula has a personality, but they look nothing like the single-iteration shape.

You can move the center \( g_2(z)=1-| z - c_0 | / R_1 \, where \, c_0 \in \mathbb{C}, |c_0| + R_1 <= R \). There are obvious similar variations for the other functions. Moving the center like this creates some asymmetry in the coloring. The colors are different on different sides of a feature in the image, often creating a shadowing like effect. Don't push this too far, displacing the coloring center too much results in disconnected splotches rather than subtle shading effects.

Want more functions? Let g₁ be any function that satisfies (1). Let h be any function mapping  \( \mathbb{C \rightarrow R} \). Any function at all, really, no restrictions. Then h₁(z) = g(z) * h(z) satisfies condition (1) and can be used for continuous colors. Go wild! But make sure your color palette can handle negative numbers.

Sometimes, for functions defined by (3), you get bands where \( g_2(z_i) = 0 \) for some z_i in the orbit. If you look closely the color change is actually continuous but the gradient changes sharply. The problem is the derivative is not continuous. Mathematics define different levels of smoothness. C⁰ is the class of continuous functions, C¹ is the class of continuously differentiable functions. See https://en.wikipedia.org/wiki/Smoothness.

Derivatives, at least in high school calculus, are for functions  \( \mathbb{R  \rightarrow  R} \, or \, \mathbb{C \rightarrow  C} \). Our functions are \( \mathbb{C \rightarrow  R} \). But let's discard mathematical rigor for now and pretend we can differentiate these functions. (If you insist on rigor, consider g as \( g:\mathbb{R^2  \rightarrow  R} \) and look at the partial derivatives.)

Assume g₂ is differentiable, that is, \( g_2 \in C^1 \). g₁(z) = max(g₂(z),0) is continuous, but in general not differentiable. The derivative is discontinuous when g₂(z) = 0. (or undefined, or two-sided, or whatever it is a bad deal)

This is easily fixed. \( h_1(z) = g_1(z)^2 \) is differentiable. Both side of the derivative is 0 where g₂(z)=0. So  \( h_1 \in C^1 \).

You can attain any level of smoothness. If \( g_1 \in C^2 \, then \, h_2(z) = g_1(z)^3 \in C^2 \), etc.





Linkback: https://fractalforums.org/index.php?topic=2753.0

gerrit: I will put together some examples tomorrow. I started to do some today, but that is going down the proverbial rabbit hole. I had to abandon the pictures to have time to get the text written. I think you have it implemented correctly, thank you for trying it out.

For large R, at least with the \( 1-|z|/R \) variant, this method is approximately that same as iteration counting. (Each step is adding something very close to 1.) So for R=1e6 it is going to have bands. Try a smaller R. As I pointed out half way through the post, the coloring radius does not have to match the escape radius. You can use \( 1-|z|/R_1 \)  where \( R_1 \) < R works. Try \( R_1 \) = 1 or 2, and the banding should go away.

It is also true that the derivative of the color function has discontinuities. It is continuous, but the derivative discontinuites can also create a banding effect. The function is \( C^0 \) but not \( C^1 \). Exponents can move the function into higher smoothness classes.  \( (1-|z|/R_1)^n \) will move the summation up to \( C^{n-1} \). I usually go with n=2. However, that does not help much when R is so large.

\( g(z) = 1 - \log(|z|)/\log(R) \) looks dangerous, it blows up if |z|=0. \( g(z) = 1 - \log(|z|+1)/\log(R) \) would be safer. But who wants safe, your version is more exciting. It is likely smoother simply because the denominator log(R) is a whole lot smaller that R=1e6.

I've implemented something similar that I call "smooth traps". The idea is that there is a trap shape somewhere, and when an orbit point lands inside it a value is added to a sum. The base value ranges from 1 at the trap center to 0 at the edge, is raised to a power and possibly put through an additional function, and then added into the sum. The sum is put through another function before being used to color the pixel. And the orbit points can be modified with a function beforehand, as well as only every nth one counted.

If the trap shape is a disk, the center is at (0,0), and the three functions are the identity function, this appears to be the same thing discussed in this thread. Of course the center can be elsewhere and the functions can be non-trivial. Making the orbit modifying function be 1/x results in the trap effectively becoming the outside of the disk, with 0 at the edge and 1 at infinity, for instance.

I also implemented two other shapes: half-plane (0 at the edge, 1 at infinity, can be translated or rotated, the position within the half-plane is put through a rational function with a horizontal asymptote tending to 1) and ribbon (infinitely long, finitely high rectangle, 0 at the edges and 1 along the midline, can be translated or rotated).

Two images are attached. 1: Hénon map parameter space. Trap is a radius-3 disk about the point (1.31900998, -0.4622137328), power is two, the only non-identity function is the transfer of the sum to the color gradient, where I used log. 2: A space-filling triple matchmaker Julia set (there are no attractors; the whole Riemann sphere is the Julia set). 2D colored by combining two sums of this type. The first uses the exact same parameters, down to the disk center, as the Hénon image. The second uses a ribbon trap whose midline passes through (11.31900998, -0.4622137328), of midline-to-edge width 2, rotated 0.61111 of a complete circle, and again with logarithmic transfer into color space.

Paul: "smooth traps" sounds very similar.

In accumulator colors I try to require that the pseudo-distance inner function is 0 outside a bounded region and always <= 1.

The function range bound makes it possible to say, "see it is like iteration counting, after all counting is just adding 1 each iteration." The bounded range also helps when deciding how to scale the palette, but otherwise it is mostly unnecessary.

The bounded non-zero domain avoids color banding, provided it is contained inside the escape threshold.

In the general version, it can be any function from Complex numbers to Real numbers. This is in fact how I have coded it in my program. I have tried several wild things, and will probably experiment there in the future. But almost always the more ascetically pleasing results are found keeping to functions limited this way.

I usually just mess with the \( \mathbb{C}\Rightarrow\mathbb{R} \) function directly, I like your idea of transforming z with a \( \mathbb{C}\Rightarrow\mathbb{C} \)  function first, and then applying a \( \mathbb{C}\Rightarrow\mathbb{R} \)  function. Logically equivalent, but much easier to track.

What additional things do you do with the sum? It can be re-scaled and shaped with sqrt or log like iteration count values to tame a noisy palette. Are you doing more?

I like your ideas dealing with infinity. I think I spent too much time with polynomials and iteration cut-offs, so that was never a consideration. If everything is "inside", then there is no reason for a bounded domain. The [0,1] or similarly bounded range is probably still necessary.

The upper half plane is conformally isomorphic to the unit disk by \( z \Rightarrow \frac{i-z}{i+z} \). This would be an interesting transformation to drop into your preliminary transformation.

I had also tried grabbing every nth orbit point. I did not notice much difference, the output range is reduced to 1/n and some performance speed up, since 100*(n-1)/n percent of the color calculation operations are avoided.

One variation I tried was taking a \( p : \mathbb{Z}\Rightarrow\mathbb{R} \) function, let q(k) be the value from above at step k , and  evaluating \( \sum p(k)*q(k) \). If \( p(k) = cos( k * 2* \pi / n ) \), this is like a DFT and teases out components with frequency k. I tried this with space filling mess, but it made no difference. However it does a great job of lighting up certain bulbs and minis in polynomial based fractals.

Interesting. I shall certainly try the weighted version.