Distance Estimation precision is limited

[icalvo]

This a deep zoom that shows the issue:

[image]
width = 400
height = 400
[location]
real = -1.985467535840271852824618261156627554406853011849077360388159122360110009159038630495386345802651920400203428206886365065752898544006527952899905560840465332877927383784127443542721000707337022612806718532445
imag = -0.000006529008814623197575809125124807844785505303141042825718748023264716309101593587395404569129630910758203795809194950090927468918115975632416443778727255305823543004600355987400003567802754647839704897690786595
zoom = 1.5244061E100
depth = 20000000
[gpu]
colorizer=distance.glsl
[distance]
threshold=0.2
[palette]
image=white.png

The banding artifacts are produced by a problem when calculating the distance estimation. It works fine when using gradient.glsl. Also, it becomes worse as you zoom deeper, until all distances in the map are just zero.

[icalvo]

I believe I know what's the issue because I found a similar problem with Ultrafractal. I was able to fix it there and maybe this applies here.

The problem that I found is with the final calculation of the distance estimation:

$$d = \frac{|z|log|z|}{|dz|}$$

Which is calculated here at DrillMap.cpp:

    // Derive the normalized iteration count
    auto znlog = znabs.log() / std::log(Options::location.escape);
    auto znloglog = znlog.log() / std::log(2.0);
    nitcntMap[i] = lastIterationMap[i] - znloglog.asDouble();

    // Estimate the distance to the Mandelbrot set in pixels
    auto znabslog = znabs.log().asDouble();
    auto dist = znabs * 2.0 * znabslog / entry.derivative.abs();

In UltraFractal, the calculation of $$|z|$$ was giving me zeroes at those magnifications. Turns out that the square root was not working properly with very high values (even if it's supposedly working with arbitrary precision). So I replaced it by this calculation, which scales the value down before taking the square root:

$$|z| = \begin{cases} 0 & \text{if } Re(z)=0 \land Im(z)=0 \\\ |Re(z)| \sqrt{1 + \left(\frac{Im(z)}{|Re(z)|}\right)^2} & \text{if } Re(z) \ne 0 \land |Re(z)|>|Im(z)| \\\ |Im(z)| \sqrt{\left(\frac{Re(z)}{|Im(z)|}\right)^2 + 1} & \text{otherwise}     \end{cases}$$

This translated into this function in the Ultrafractal formula, which I believe serves as pseudocode for what is needed here (if this is indeed the problem):

  float func abs_stable(const complex z) const
    float absr = abs(real(z))
    float absi = abs(imag(z))
    if (absr > absi)
      return absr * sqrt(1+sqr(absi/absr))
    else
      return absi * sqrt(1+sqr(absr/absi))
    endif
  endfunc

I am trying it now so I may come back with a PR in some days.

[icalvo]

I generated the same image with the patch and it looks way better: