Glattes Spektrum für Mandelbrot-Set-Rendering

Schreibe ich momentan ein Programm zum generieren wirklich enorm (65536x65536 Pixel und oben), Mandelbrot-Bildern, und ich würde gerne erarbeiten ein Spektrum und Farbschema, das tut Ihnen Gerechtigkeit. Die wikipedia vorgestellten mandelbrot-Bild scheint ein hervorragendes Beispiel, vor allem, wie die abwechslungsreiche Farbpalette bleibt in allen zoom-Stufen der Sequenz. Ich bin mir nicht sicher, ob es das drehen der palette oder tun einige andere trick, um dies zu erreichen, obwohl.

Ich bin vertraut mit der glatt coloring-Algorithmus für die mandelbrot-Menge, so kann ich vermeiden, Streifenbildung, aber ich brauche immer noch einen Weg, um die Farben zur Ausgabe von Werten aus diesen Algorithmus.

Die Bilder, die ich bin, zu generieren, sind pyramidal (z.B. eine Serie von Bildern, von denen jedes die Hälfte der Abmessungen des vorigen), so kann ich mit einem rotierenden palette der einige Sortieren, solange die änderung in der palette zwischen nachfolgenden zoom-Stufen nicht zu offensichtlich.

InformationsquelleAutor der Frage Nick Johnson | 2008-12-15

30

Dies ist die Farbe glätten Algorithmus:

Können sagen, Sie beginnen mit der komplexen Zahl z0 und Durchlaufen n mal, bis es entweicht. Lassen Sie den end-Punkt werden zn.

Einen glatten Wert wäre
```
nsmooth := n + 1 - Math.log(Math.log(zn.abs()))/Math.log(2)
```
Funktioniert dies nur für mandelbrot, wenn Sie wollen, um zu berechnen, für eine reibungslose Funktion für julia-Mengen, dann verwenden Sie
```
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());
}
```
Dann smoothcolor im Intervall (0,max_iter).

Teilen smoothcolor mit max_iter um einen Wert zwischen 0 und 1.

Bis eine gleichmäßige Farbe aus dem Wert:

Diese können aufgerufen werden, zum Beispiel (in Java):
```
Color.HSBtoRGB(0.95f + 10 * smoothcolor ,0.6f,1.0f);
```
da der erste Wert in der HSB-Farbe-Parameter wird verwendet, um zu definieren die Farbe aus dem Farbkreis.

InformationsquelleAutor der Antwort Per Alexandersson
5

Verwenden Sie die glatte Färbung Algorithmus zur Berechnung der Werte innerhalb des Viewports, dann ordnen Sie Ihre palette vom niedrigsten zum höchsten Wert. So, wie Sie zoom in und die höheren Werte sind nicht mehr sichtbar, ist die palette wird so skaliert, wie gut. Mit der gleichen Konstanten für n und B Sie werden am Ende mit einem Bereich von 0.0 bis 1.0, die für eine vollständig heraus gezoomt gesetzt, sondern auf tieferen vergrößert den Dynamikbereich verkleinern, zu sagen, 0,0 bis 0,1 bei 200% zoom, 0.0 0.0001 bei 20000% zoom, etc.

InformationsquelleAutor der Antwort Sparr

Hier ist eine typische innere Schleife für eine naive Mandelbrot-generator. Um eine glatte Farbe, die Sie wollen, passieren in der realen und komplexen "Längen" und die iteration, die Sie gerettet. Ich habe die Mandelbrot-code, so dass Sie sehen können, welche vars zu verwenden, um zu berechnen, ist die Farbe.

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);
        }

und MapColor unter: (siehe diesem link, um sich die ColorFromHSV Funktion)

 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 ist "glätten" die Rettung der Werte von 0 bis 1, die dann verwendet werden können, um der Karte eine Farbe, ohne schreckliche banding. Spielen mit MapColour und/oder der hsv-Funktion können Sie ändern, welche Farben verwendet werden.

InformationsquelleAutor der Antwort Alex Russell

4

Scheint einfach zu tun durch Versuch und Irrtum. Angenommen, Sie definieren können, auch HSV1 und HSV2 (Farbton, Sättigung, Wert) des endpoint-Farben, die Sie verwenden möchten, (schwarz und weiß; blau und gelb; dunkel-rot und grün; etc.), und angenommen, Sie haben ein Algorithmus zum zuweisen eines P-Wert zwischen 0.0 und 1.0, die auf jedem Ihrer Pixel. Dann, dass die pixel die Farbe wird
```
(H2 - H1) * P + H1 = HP
(S2 - S1) * P + S1 = SP
(V2 - V1) * P + V1 = VP
```
Damit fertig, nur die Ergebnisse zu beobachten und zu sehen, wie Sie möchten. Wenn der Algorithmus zum zuweisen von P stetig ist, dann ist die Steigung sollte glatt sein, wie gut.

InformationsquelleAutor der Antwort Paul Brinkley
4

Meine letztendliche Lösung war eine gut aussehende (und ziemlich großen) palette und speichern Sie es als ein Konstanten-array in der Quelle, dann eine Interpolation zwischen den Indizes in es mit die smooth coloring-Algorithmus. Die palette umschließt (und ist so konzipiert, kontinuierliche), aber das scheint keine Rolle, viel.

InformationsquelleAutor der Antwort Nick Johnson

hier finden Sie eine version mit javascript

Verwendung :

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

Funktion

/*
 * 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;
}

//http://stackoverflow.com/questions/369438/smooth-spectrum-for-mandelbrot-set-rendering
//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);
}

InformationsquelleAutor der Antwort

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.