C++ Julia集距离估计的坏结果

我一直在使用距离估计器而不是归一化迭代计数绘制Julia集。我通常使用下面的代码，在获得足够好的图片之前，反复计算迭代次数

double Mandelbrot::getJulia(double x, double y)
{
    complex<double> z(x, y);
    complex<double> c(-0.7269, 0.1889);

    double iterations = 0;

    while (iterations < MAX)
    {
        z = z * z + c;
        if (abs(z) > 2) {
            return iterations + 1.0 - log(log2(abs(z)));
            break;
        }
        iterations++;
    }
    return double(MAX);
}

double Mandelbrot:：getJulia（双x，双y）
{
复z（x，y）；
复合物c（-0.7269,0.1889）；
双迭代=0；
同时（迭代次数<最大值）
{
z=z*z+c；
如果（abs（z）>2）{
返回迭代次数+1.0-log（log2（abs（z））；
打破
}
迭代++；
}
返回双（最大）；
}

然后我为每个点调用它并绘制位图

    ZoomTool zt(WIDTH, HEIGHT);
    zt.add(Zoom(WIDTH / 2, HEIGHT / 2, 4.0 / WIDTH));
    for (int y = 0; y < HEIGHT; y++) {
        for (int x = 0; x < WIDTH; x++) {
            pair<double, double> coords = zt.zoomIn(x, y);

            double iterations = Mandelbrot::getJulia(coords.first,
                coords.second);

            double ratio = iterations / Mandelbrot::MAX;
            double h = 0;
            double s= 0;
            double v = 0;

            if (ratio != 1)
            {
                h = 360.0*ratio;
                s = 1.0;
                v = 1.0;
            }

            HSV hsv(h, s,  v);
            RGB rgb(0, 0, 0);
            rgb = toRGB(hsv);

            bitmap.setPixel(x, y, rgb._r, rgb._g, rgb._b);
        }
    }

ZoomTool zt（宽度、高度）；
zt.add（缩放（宽度/2，高度/2，4.0/宽度））；
对于（int y=0；y

在600次迭代中，我得到了这个

这不是很好，但比我现在尝试使用的距离估计器更好。我已经实现了如下距离估计器

double Mandelbrot::getJulia(double x, double y)
{
    complex<double> z(x,y);
    complex<double> c(-0.7269, 0.1889);
    complex<double> dz = 0;

    double iterations = 0;

    while (iterations < MAX)
    {
        dz = 2.0 * dz * z + 1.0;
        z = z * z + c;

        if (abs(z) > 2)
        {
            return abs(z) * log(abs(z)) / abs(dz);
        }
        iterations++;
    }
    return Mandelbrot::MAX;
}

double Mandelbrot:：getJulia（双x，双y）
{
复z（x，y）；
复合物c（-0.7269,0.1889）；
复dz=0；
双迭代=0；
同时（迭代次数<最大值）
{
dz=2.0*dz*z+1.0；
z=z*z+c；
如果（abs（z）>2）
{
返回abs（z）*log（abs（z））/abs（dz）；
}
迭代++；
}
返回Mandelbrot:：MAX；
}

在600次迭代中，我得到以下图像

---

我没有正确地标准化颜色吗？我猜这是因为我正在标准化到360.0，并且正在进行从HSV到RGB的转换。由于距离很小，我得到了非常密集的颜色分布

如何确保

0

？如果while循环没有中断，我将返回MAX。绝对值永远不会为零，所以我不检查（我已经测试过了）好吧

>0

有点明显，但要正确规范化结果，需要确保

abs（z）*log（abs（z））/abs（dz）

小于

MAX