Hinzufügen von Farbschichten zum Mandelbrot

Question

Ich habe ein großes Interesse an Fraktalen, hatte aber bis vor kurzem noch keine Gelegenheit, sie umzusetzen. Ich habe zuerst ein Mandelbrot-Set in Schwarz-Weiß umgesetzt und dann versucht, Farben hinzuzufügen.

Hier ist die Umsetzung meiner mandel (I org.apache.commons.math3.complex.Complex für komplexe Zahlen verwenden)

public class MyMandelbrot { 

    public static int numberOfIterationsToCheck(Complex z0, int max) { 
     Complex z = z0; 
     for (int t = 0; t < max; t++) { 
      if (z.abs() > 2.0) return t; 
      z =z.multiply(z).add(z0); 
     } 
     return max; 
    } 

    public static void main(String[] args) { 
     double xc = Double.parseDouble(args[0]); 
     double yc = Double.parseDouble(args[1]); 
     double size = Double.parseDouble(args[2]); 

     int N = 512; 
     int max = 255; 

     Viewer viewer = new Viewer(N, N); 
     for (int i = 0; i < N; i++) { 
      for (int j = 0; j < N; j++) { 
       double x0 = xc - size/2 + size*i/N; 
       double y0 = yc - size/2 + size*j/N; 
       Complex z0 = new Complex(x0, y0); 
       int gray = max - numberOfIterationsToCheck(z0, max); 

       Color color = new Color(gray, gray, gray); 
       if (z0.abs() > 2.0) { 

        color = new Color(gray, 128, gray); 
       } else if (z0.abs() > 2.0 && numberOfIterationsToCheck(z0,  max) > max/2) { 
        color = new Color(255, gray, 255); 
       } else if (z0.abs() > 2.0 && numberOfIterationsToCheck(z0,  max) < max/2) { 
        color = new Color(gray, 128,128); 
       } 

       else if (z0.abs() > 1.0 && numberOfIterationsToCheck(z0,  max) < max/2) { 
        color = new Color(128, gray, 128); 
       } else if (z0.abs() > 1.0) { 

        color = new Color(128, gray, 128); 
       } 

       else if (z0.abs() <= 1.0) { 
        color = new Color(gray, gray, 128); 
       } 

       viewer.set(i, N-1-j, color); 
      } 
     } 
     viewer.show(); 
    } 

} 

ich eine benutzerdefinierten Viewer-Klasse bin mit dem Satz anzuzeigen, nachdem es Zeichnung in ein Bildobjekt. Hier ist die Set-Methode des Viewers

Der Code macht das Set richtig, aber ich bekomme nicht das erwartete Ergebnis. Was ich will, ist in der Lage ein farbiges Set ähnlich wie diese

Oder diese

zu produzieren Aber ich konnte keinen besseren farbigen Satz als diese.

Ich habe einige theoretische Erklärung darüber gelesen here und here, aber ich bin offensichtlich etwas falsch in der Praxis zu tun. Was ist falsch an meiner Farbgebung? Wie kann ich es reparieren? Danke

Answer 1

In den Beispielen, die Sie zeigen, basiert die Farbe nur auf der Anzahl von Iterationen, bevor der Punkt entkommt, und nicht auf der anfänglichen komplexen Koordinate z0. Ein Ansatz ist die Farbton-Sättigung-Helligkeit Farbwerte mit getHSBColor(), zu verwenden und den Farbton auf der Anzahl der Iterationen auf Basis zu ändern, bevor es entweicht, zum Beispiel:

 double x0 = xc - size/2 + size*i/N; 
     double y0 = yc - size/2 + size*j/N; 
     Complex z0 = new Complex(x0, y0); 
     int escapeIterations = numberOfIterationsToCheck(z0, max); 

     // set color varying hue based on escape iterations: 
     Color color = Color.getHSBColor((float)escapeIterations/(float)max, 1.0f, 1.0f); 

     viewer.set(i, N-1-j, color); 

Der obige Code nicht die Sättigung ändern oder die Helligkeit (beide sind auf 1.0 gesetzt), aber Sie können sie auch variieren, je nachdem, welche Art von Effekt gewünscht wird.

Sie könnten den Farbzyklus durch den Farbkreis von Farbtönen mehr als einmal machen, indem Sie den Farbtonwert durch eine Konstante zB Multiplikation:

(float)escapeIterations * 2.0f/(float)max 

Sie können auch eine Konstante hinzufügen, um es an einer bestimmten Farbe beginnen zu machen .

Da escapeIterations ein Int ist, springt die Farbe für jede Iteration schrittweise. Sie können die Farben glatter durch einen Schwimmer aus numberOfIterationsToCheck Rückkehr:

public static float numberOfIterationsToCheckSmooth(Complex z0, int max) { 
    Complex z = z0; 
    for (int t = 0; t < max; t++) { 
     double fAbs = z.abs(); 
     if (fAbs > 2.0) 
     { 
      // based on the final value, add a fractional amount based on 
      // how much it escaped by (fAbs will be in the range of 2 to around 4):     
      return (float)t + (2.0f - (Math.log(fAbs)/Math.log(2.0))); 
     } 
     z =z.multiply(z).add(z0); 
    } 
    return (float)max; 
} 

schließlich einen anderen Ansatz, der die meisten Freiheit und Kontrolle über die Farben geben wird eine Tabelle von Farben zu verwenden, eine für jeden die maximale Iteration bis und optional interpolieren zwischen ihnen.