平滑光谱用于曼德博集合渲染

Question

我正在编写一个程序来生成非常巨大的曼德博集合图像（65536x65536像素及以上），我想设计一种光谱和着色方案，以使它们更加出色。维基百科特色曼德博集合图像似乎是一个很好的例子，尤其是调色板在序列的所有缩放级别下保持多样化。虽然我不确定它是否旋转了调色板或者使用了其他技巧来实现这一点。

我熟悉曼德博集合的平滑着色算法，因此我可以避免出现带状条纹，但我仍然需要一种方法来为该算法的输出值分配颜色。

我生成的图像是金字塔形式的（例如，一系列图像，每个图像的尺寸都是前一个图像的一半），因此我可以使用某种旋转的调色板，只要在后续缩放级别之间调色板的变化不太明显即可。

- Arachnid

Answer 1

这是平滑着色算法：

假设你从复数 z0 开始迭代 n 次直到逃逸。让终点为 zn。

平滑值为

nsmooth := n + 1 - Math.log(Math.log(zn.abs()))/Math.log(2)

这只适用于Mandelbrot集合，如果您想计算Julia集合的平滑函数，则使用

Complex z = new Complex(x,y);
double smoothcolor = Math.exp(-z.abs());

for(i=0;i<max_iter && z.abs() < 30;i++) {
    z = f(z);
    smoothcolor += Math.exp(-z.abs());
}

然后smoothcolor在区间(0,max_iter)内。

将smoothcolor除以max_iter，得到介于0和1之间的值。

要从这个值中得到平滑的颜色：

例如，可以在Java中进行如下调用：

Color.HSBtoRGB(0.95f + 10 * smoothcolor ,0.6f,1.0f);

由于 HSB 颜色参数中的第一个值用于从颜色圆中定义颜色，因此需要注意。

- Per Alexandersson

---

感谢提供 Julia Set 平滑颜色公式，我在 https://www.shadertoy.com/view/XssXDr 中使用了它。 - Erik Martino

你如何将nsmooth转换为颜色值？ - vcapra1

Color.HSBtoRGB(0.95f + 10 * nsmooth ,0.6f,1.0f); 可能吗？ - Per Alexandersson

我想知道是否有一种公式可以同时用于曼德博集合和朱利亚集合。 - Falk

Answer 2

使用平滑着色算法计算视口内所有值，然后将调色板从最低值映射到最高值。因此，随着缩放的进行，较高的值不再可见，调色板也会相应缩小。使用相同的n和B常量，您将得到完全缩放出的集合范围从0.0到1.0，但在更深入的缩放中，动态范围将缩小，例如在200％缩放时为0.0到0.1，在20000％缩放时为0.0到0.0001等。

- Sparr

Answer 3

这是一个朴素的曼德博集合生成器的典型内部循环。为了获得平滑的颜色，您需要传入实部和复部的“长度”以及退出迭代时的迭代次数。我已经包含了曼德博集合代码，因此您可以看到用于计算颜色的变量。

for (ix = 0; ix < panelMain.Width; ix++)
    {
    cx = cxMin + (double )ix * pixelWidth;
    // init this go 
    zx = 0.0;
    zy = 0.0;
    zx2 = 0.0;
    zy2 = 0.0;
    for (i = 0; i < iterationMax && ((zx2 + zy2) < er2); i++)
        {
        zy = zx * zy * 2.0 + cy;
        zx = zx2 - zy2 + cx;
        zx2 = zx * zx;
        zy2 = zy * zy;
        }
    if (i == iterationMax)
        {
        // interior, part of set, black
        // set colour to black
        g.FillRectangle(sbBlack, ix, iy, 1, 1);
        }
    else
        {
        // outside, set colour proportional to time/distance it took to converge
        // set colour not black
        SolidBrush sbNeato = new SolidBrush(MapColor(i, zx2, zy2));
        g.FillRectangle(sbNeato, ix, iy, 1, 1);
        }

并且在下面是MapColor: (参见此链接以获取ColorFromHSV函数)

 private Color MapColor(int i, double r, double c)
                {
                double di=(double )i;
                double zn;
                double hue;

                    zn = Math.Sqrt(r + c);
                    hue = di + 1.0 - Math.Log(Math.Log(Math.Abs(zn))) / Math.Log(2.0);  // 2 is escape radius
                    hue = 0.95 + 20.0 * hue; // adjust to make it prettier
                    // the hsv function expects values from 0 to 360
                    while (hue > 360.0)
                        hue -= 360.0;
                    while (hue < 0.0)
                        hue += 360.0;

                    return ColorFromHSV(hue, 0.8, 1.0);
                }

MapColour将撤离值从0到1进行"平滑处理"，然后可以用来映射颜色而不会出现可怕的条纹。使用MapColour和/或hsv函数可以改变使用的颜色。

- Alex Russell

---

你所说的“naive generator”是什么意思？你如何使其不再“naive”？你是指多线程生成器吗？ - Nicky

Answer 4

我的最终解决方案是创建一个外观漂亮（而且相当大）的调色板，并将其作为常量数组存储在源代码中，然后使用平滑着色算法在其中的索引之间进行插值。 调色板可以包裹（并且设计为连续），但这似乎并不重要。

- Arachnid

Answer 5

试错法似乎很简单。假设您可以定义所需使用的端点颜色（黑色和白色；蓝色和黄色；深红色和浅绿色等）的HSV1和HSV2（色相、饱和度、明度），并且假设您有一种算法来为每个像素分配0.0到1.0之间的值P。那么该像素的颜色变为

(H2 - H1) * P + H1 = HP
(S2 - S1) * P + S1 = SP
(V2 - V1) * P + V1 = VP

完成后，观察结果并查看您是否满意。如果分配P的算法是连续的，则梯度也应该是平滑的。

- Paul Brinkley

---

我不能保证值的范围在0到1.0之间，因为这会导致分辨率更高的图像缺乏细节（它们最终都变成了高迭代值）。需要进行某种渐进式调色板旋转。 - Nick Johnson

没问题。即使范围大小是无限的，它仍然可以有一个周期，即使该周期是强制性的。只需要选择一个适当的值N，将值映射到自身mod N，然后将其缩放到0-1范围内即可。 - Paul Brinkley

Answer 6

那张图片中的颜色映射是使用了“对数转换函数”（根据文档）。具体它是如何实现的我还没有完全弄清楚。生成该图片的程序使用了一个包含400种颜色的调色板，因此索引范围为[0,399)，如果需要则循环。我已经成功地接近了它的行为。我使用了一个索引范围为[0,1)，并进行如下映射：

    double value = Math.log(0.021 * (iteration + delta + 60)) + 0.72;
    value = value - Math.floor(value);

有点奇怪的是，我必须在其中使用这些特殊常量才能使我的结果匹配，因为我怀疑它们是否真的起到了作用。但无论如何，最终能够达到目的就好了，对吧？

- Jason Hoffoss

Answer 7

您可以在此找到带有 JavaScript 版本。

用法：

var rgbcol = [] ;
var rgbcol = MapColor ( Iteration , Zy2,Zx2 ) ;
point ( ctx , iX, iY ,rgbcol[0],rgbcol[1],rgbcol[2] );  

函数

/*
 * The Mandelbrot Set, in HTML5 canvas and javascript.
 * https://github.com/cslarsen/mandelbrot-js
 *
 * Copyright (C) 2012 Christian Stigen Larsen
*/

/*
 * Convert hue-saturation-value/luminosity to RGB.
 *
 * Input ranges:
 *   H =   [0, 360] (integer degrees)
 *   S = [0.0, 1.0] (float)
 *   V = [0.0, 1.0] (float)
 */
function hsv_to_rgb(h, s, v)
{
  if ( v > 1.0 ) v = 1.0;
  var hp = h/60.0;
  var c = v * s;
  var x = c*(1 - Math.abs((hp % 2) - 1));
  var rgb = [0,0,0];

  if ( 0<=hp && hp<1 ) rgb = [c, x, 0];
  if ( 1<=hp && hp<2 ) rgb = [x, c, 0];
  if ( 2<=hp && hp<3 ) rgb = [0, c, x];
  if ( 3<=hp && hp<4 ) rgb = [0, x, c];
  if ( 4<=hp && hp<5 ) rgb = [x, 0, c];
  if ( 5<=hp && hp<6 ) rgb = [c, 0, x];

  var m = v - c;
  rgb[0] += m;
  rgb[1] += m;
  rgb[2] += m;

  rgb[0] *= 255;
  rgb[1] *= 255;
  rgb[2] *= 255;

  rgb[0] = parseInt ( rgb[0] ); 
  rgb[1] = parseInt ( rgb[1] );
  rgb[2] = parseInt ( rgb[2] );  

  return rgb;
}

// https://dev59.com/u3RC5IYBdhLWcg3wOeWB
// alex russel : http://stackoverflow.com/users/2146829/alex-russell

function MapColor(i,r,c)
{
    var di= i;
    var zn;
    var hue;

        zn = Math.sqrt(r + c);
        hue = di + 1.0 - Math.log(Math.log(Math.abs(zn))) / Math.log(2.0);  // 2 is escape radius
        hue = 0.95 + 20.0 * hue; // adjust to make it prettier
        // the hsv function expects values from 0 to 360
        while (hue > 360.0)
            hue -= 360.0;
        while (hue < 0.0)
            hue += 360.0;

        return hsv_to_rgb(hue, 0.8, 1.0);
}

- user2107435