c++ - tipos - sig de degradado

¿Qué gradiente de color se usa para colorear mandelbrot en wikipedia?

Question

En la página de Mandelbrot de la wikipedia, hay realmente bellas imágenes generadas del conjunto de Mandelbrot.

También acabo de implementar mi propio algoritmo mandelbrot. Dado que n es el número de iteraciones utilizadas para calcular cada píxel, las coloreo de negro a verde a blanco de forma muy simple (con C ++ y Qt 5.0):

QColor mapping(Qt::white);
if (n <= MAX_ITERATIONS){
    double quotient = (double) n / (double) MAX_ITERATIONS;
    double color = _clamp(0.f, 1.f, quotient);
    if (quotient > 0.5) {
        // Close to the mandelbrot set the color changes from green to white
        mapping.setRgbF(color, 1.f, color);
    }
    else {
        // Far away it changes from black to green
        mapping.setRgbF(0.f, color, 0.f);
    }
}
return mapping;

Mi resultado se ve así:

Me gusta bastante, ¿pero qué gradiente de color se usa para las imágenes en Wikipedia? ¿Cómo calcular ese gradiente con un dado n de iteraciones?

(Esta pregunta no se trata de suavizar ).

Answer 1

Bueno, hice algo de ingeniería inversa en los colores utilizados en wikipedia usando el cuentagotas de Photoshop. Hay 16 colores en este degradado:

  R   G   B
 66  30  15 # brown 3
 25   7  26 # dark violett
  9   1  47 # darkest blue
  4   4  73 # blue 5
  0   7 100 # blue 4
 12  44 138 # blue 3
 24  82 177 # blue 2
 57 125 209 # blue 1
134 181 229 # blue 0
211 236 248 # lightest blue
241 233 191 # lightest yellow
248 201  95 # light yellow
255 170   0 # dirty yellow
204 128   0 # brown 0
153  87   0 # brown 1
106  52   3 # brown 2

El simple hecho de usar un módulo y una matriz QColor me permite repetir todos los colores en el degradado:

if (n < MAX_ITERATIONS && n > 0) {
    int i = n % 16;
    QColor mapping[16];
    mapping[0].setRgb(66, 30, 15);
    mapping[1].setRgb(25, 7, 26);
    mapping[2].setRgb(9, 1, 47);
    mapping[3].setRgb(4, 4, 73);
    mapping[4].setRgb(0, 7, 100);
    mapping[5].setRgb(12, 44, 138);
    mapping[6].setRgb(24, 82, 177);
    mapping[7].setRgb(57, 125, 209);
    mapping[8].setRgb(134, 181, 229);
    mapping[9].setRgb(211, 236, 248);
    mapping[10].setRgb(241, 233, 191);
    mapping[11].setRgb(248, 201, 95);
    mapping[12].setRgb(255, 170, 0);
    mapping[13].setRgb(204, 128, 0);
    mapping[14].setRgb(153, 87, 0);
    mapping[15].setRgb(106, 52, 3);
    return mapping[i];
}
else return Qt::black;

El resultado se parece mucho a lo que estaba buscando:

:)

Answer 2

Creo que son los colores predeterminados en Ultra Fractal . La versión de evaluación viene con fuente para muchos parámetros, y creo que incluye ese mapa de color (si no puedes inferirlo de la captura de pantalla en la página principal) y posiblemente también la lógica detrás de escalar dinámicamente ese mapa de color para cada escena

Answer 3

El gradiente es probablemente de Ultra Fractal. Está definido por 5 puntos de control:

Position = 0.0     Color = (0,   7,   100)
Position = 0.16    Color = (32,  107, 203)
Position = 0.42    Color = (237, 255, 255)
Position = 0.6425  Color = (255, 170, 0)
Position = 0.8575  Color = (0,   2,   0)

donde la posición está en el rango [0, 1] y el color es RGB de 0 a 255.

La trampa es que no es un gradiente lineal. La interpolación entre puntos es cúbica (o algo similar). La siguiente imagen muestra la diferencia entre la interpolación cúbica lineal y monótona :

Como puede ver, el cúbico es mucho más suave y "más bonito". Utilicé la interpolación cúbica monótona para evitar "sobrepasar" el rango de color que puede ser causado por el cúbico básico. Unidades monótona cúbicas que los valores interpolados están siempre en el rango de los puntos de entrada (0-255).

Uso el siguiente código para calcular el color en función de la iteración i :

double size = Math.Sqrt(re * re + im * im);
double smoothed = Math.Log(Math.Log(size) * ONE_OVER_LOG2) * ONE_OVER_LOG2;
int colorI = (int)(Math.Sqrt(i + 1 - smoothed) * gradient.Scale + gradient.Shift) % colors.Length;
Color color = colors[colorI];

Donde i es el número de iteración divergente, re e im son coordenadas divergentes, gradient.Scale . gradient.Scale es 256, gradient.Shift . gradient.Shift es 0 y los colors son matriz con gradiente pre-discretizado que se muestra arriba. Su longitud suele ser 2048.