Eventually I did the algebra by hand for the visualisation part. The analytic part (root-finding, etc) is still broken at the moment.

Formula is z^2 |z|^a + c, with a fractional and/or negative. I also implemented power 3 and 4 versions. In the animation, a varies between about +/-0.4.

(repost from Fractal Chats Discord, not my work)

I added motion blur as suggested by lycium in the fractal chats discord, not sure if I like it (I think 8 subframes is not enough to avoid steppy appearance, and rendering 8x as many frames takes 8x as long, it took 3 hours to render 1024 images for this 128 frame output, not counting the time taken to trace the rays to the locations etc).

quite pleased with parts of this, though when the number of branches jumps a few times in quick succession it's a bit annoying. maybe i can ping-pong some of the longer sections (corresponding to the 1/3, 1/2, 2/3 child bulbs)

The first 3 prefixes were 1 1/2 2 1/2 3 followed by:

- 1/10 28
- 1/8 24 1/2 28
- 1/7 21 1/2 28

where the first is what I designed, and the other 2 are extrapolated. I think the change of /10 to /8 and /7 messed up the structural assumptions of the suffix, which was

1/2 56 1/2 57 1/2 58 1/3 144 1/2 145 1/2 146 1/3 320 ... 1378

In particular the influencing island had period 3 and the influencing angle was n/10, so 3*10=30 aligned nicely with the repeated structure of p->2p+30 in the angled internal addresses; while the non-n/10 addresses are forced/unrelated so don't look as good...

mildly stroboscopic animation

Playing with colour cycling again, this time with OpenGL GLSL colouring algorithms (for colouring based on distance estimate (black filaments) and iteration count (white and red bands).

Software: KF, plus a bash script to update the ColorOffset field in the palette, plus ImageMagick and gifsicle.

In the process was reminded of old idea to make ColorOffset fractional instead of integer for more flexibility. Also old feature requests to have colour cycling in-program.

Magic number for this fractal is 30, the red bands are spaced that many iterations apart making the colours synchronize with the shapes.

Also worked on the transformation dialog, moved the "Auto Skew (Escape)" feature there from the old Newton zoom dialog.

I made it display the difference between the old transformation and new transformation, as trying to display the total transformation in an editable way was getting too confusing for me. (The difference is needed to warp the image without recalculating the pixels, the total is needed for recalculating the pixels at which point the warping transformation should be reset to identity.)

I also made it so the number entry boxes have spin buttons so that editing is easier (in fact you can get live results from the edit boxes, rather than having to edit without being able to see the results before clicking OK).

Rewrote the Newton-Raphson zooming dialog for KF, and added absolute zooming for minibrots and atom domains (the old mode is relative between current zoom and minibrot size, which works very well in practice, but just occasionally the other ways are useful too). Also added a geometric size factor as well as the exponential size power / folding.

(low resolution for reasons of computation cost)

I added a "disable texture resize" option to KF, which means you can access actual texture image pixels in OpenGL, which makes the "legendary colour palette" technique much easier (no need to convert the image to a linear palette in text format first).

colouring algorithm code:

vec3 colour()
{
if (getInterior()) return KFP_InteriorColor;
int w = textureSize(KFP_Texture, 0).x;
int h = textureSize(KFP_Texture, 0).y;
int N = to_int(floor(div(getN(), KFP_IterDiv)));
N += int(KFP_ColorOffset) * w * h / 1024;
int i = N % w;
int j = (N / w) % h;
return texelFetch(KFP_Texture, ivec2(i, j), 0).rgb;
}

(if you try this in latest released KF you will probably be disappointed, as the texture image is resized to match the output image size)

fractal perturbation maths summary

Here's an example of the kind of glitches that can happen (in this case, missing details in the right hand image with KF's default threshold), with a lower tolerance for glitches it takes much longer but the image is hopefully correct.

Test location in the Mandelbrot set taken from here deviantart.com/olbaid-st/art/D

Experimenting with colouring for : for each pixel, normalize a neighbourhood's smooth iteration count so the minimum is $0$ and the sum is $1$, then compute $E = \frac{ \sum x \log x }{ \sum 1 }$. Substitute $0$ for $0 \log 0$.

Without jitter I got some strange grid artifacts that looked really bad, especially when animated, with jitter the image is so noisy I need tons of samples to smooth it out, which also means I can't use fast-changing palettes in the exterior because the averaging turns them to mud.

This video is with 100 samples for entropy calculations to get each colour sample, and 100 colour samples per pixel.

Nearly finished kf-2.15.2 and zoomasm-3.0. Will probably release next week after final testing.

The main new feature in is being able to define your own colouring algorithms in OpenGL shader language (). The shader fragment can get raw computed data from KF, such as (smooth) iteration count and analytic distance estimates, and return a colour for the pixel.

There is also an emulation of the previous CPU colouring algorithm, which is modularized so you can use parts of it in your custom shaders.

The main new feature in is being able to load palettes from KF that use OpenGL GLSL colouring shader fragments, so you don't have to repeat work. This includes support for the list-of-colours palette and the other variables in KF's colour dialog.