Zooms in die Mandelbrotmenge sind Legion¹⁾, der Logarithmus log(x) ist bekannt und der komplexe Logarithmus log(z) ist berüchtigt²⁾.

Die Mandelbrotmenge ist Teil der komplexen Zahlenebene. Der komplexe Logarithmus bildet die komplexe Zahlenebene auf sich selbst ab. Im Folgenden geht es um das Bild der Mandelbrotmenge unter der log(z)-Abbildung und die Anwendung bei Mandelbrot-Zooms.

Etwas ungenau gesprochen entspricht der komplexe Logarithmus im Prinzip einem Koordinatenwechsel von kartesischen Koordinaten zu Polarkoordinaten der komplexen Zahlenebene.

• Ausnutzung eines optimalen Interpolationsrasters bei Mandelbrotzooms (bis zu 100 mal weniger Rasterpunkte bei ähnlicher Bildqualität)
• Ausnutzung von Symmetrien der Mandelbrotmenge zur Reduktion des Rechenaufwands (Die Symmeriebrechungen nutzen eher der Ästhetik)
• Fast beliebig hohes Antialiasing im kritischen Zentralbereich des Zooms
• Interaktiver Mandelbrot-Zoomer auf Basis von Flex-Shaders³⁾

Hier geht es kurz um einige Eigenschaften des komplexen Logarithmus. Die Eigenschaften werden am Beispiel der Mandelbrotmenge studiert.

Wir betrachten einen Zoom mit festem Zentrum b. Die komplexe Zahlenebene z = x + iy wird dann mit f(z) = log( z - b ) abgebildet. Abbildung 1 zeigt einen Ausschnitt des Randbereiches der Mandelbrotmenge in der z-Ebene (Kreis) und in der log(z)-Ebene (Hintergrund). Der grüne Kreis entspricht dabei dem grünen linken Rand des Bildes. Der grüne Keil entspricht dem grünen Rechteck.

Ein klareres Bild der Wirkung der log(z)-Transformation gewinnt man beim Betrachten der Zoom-Animation:

1. Ein Zoom in der z-Ebene entspricht eine Verschiebung in x-Richtung in der log(z)-Ebene.
2. Eine Rotation in der z-Ebene entspricht einer Verschiebung in y-Richtung in der log(z)-Ebene. Der obere Bildrand von Abbildung 1 passt nahtlos an den unteren Bildrand. Der Abstand der Ränder beträgt $2{\pi}i$.
3. Lokal unterscheiden sich Bild und Urbild kaum. Dies ist eine typische Eigenschaft von konformen Abbildungen⁴⁾, zu denen der komplexe Logarithmus zählt.

Diese Eigenschaften des komplexen Logarithmus sind aus der Mathematik bekannt. Hier können sie ohne Termumformungen erahnt werden.

Hier geht es kurz um einige Eigenschaften der Mandelbrotmenge. Die Eigenschaften werden am Beispiel der komplexen log(z)-Transformation studiert.

Mit zunehmender Zoomtiefe kommt es in der z-Ebene zu Bereichen mit immer höherer radialer Symmetrie. In der log(z)-Ebene entspricht das einer Translations-Symmetrie in y-Richtung. Im oben genannten Film ist das schön ab 1:30 bis 2:20 zu sehen. In Abbildung 2 ist beispielhaft eine typische 8-Symmetrie dargestellt.

Wird die Symmetrie vollständig gebrochen (1-Symmetrie), so erscheint wieder eine Mandelbrotmenge. Wird die Symmetrie nur zum Teil gebrochen (auf 2-, 4- oder 2ⁿ-Symmetrie), so erscheinen Julia-Fraktale.

Die Symmetriebrechnungen folgen einem festen Muster. So halbiert sich zum Beispiel die Zoomtiefe von Teilbrechnung zu Teilbrechnung. Durch Ausnutzung dieses Verhaltens kann man zu einer bestimmten Zoomtiefe das Auftreten einer 1-Symmetriebrechnung bzw. einer Mandelbrotmenge erzwingen. Dadurch war es zum Beispiel möglich einen 10¹⁰⁰⁰-Zoom mit einer Mandelbrotmenge genau am Ende zu erstellen⁵⁾.

Die eben dargestellten Eigenschaften der Mandelbrotmenge und der log(z)-Transformation ergänzen sich. Dabei ergibt sich durch Verwendung der log(z)-Transformation ein zur Berechnung der Mandelbrotmenge effizientes Raster, das im Folgenden kurz dargestellt wird.

Die Rechte Seite von Abbildung 3 zeigt ein log(z)-Raster, das in die z-Ebene zurücktransformiert wurde. Nach den obigen Erläuterungen sollte nicht mehr überraschen, dass Spalten des log(z)-Rasters konzentrische Kreise in der z-Ebene Bilden. Bei einem Zoom werden die Pixel auf den konzentrischen Kreisen optimal „recycelt“. Der Abstand der konzentrischen Kreise sollte etwa dem Abstand der Pixel auf einem Kreis entsprechen.

Der linke Teil in Abbildung 3 zeigt, wie vorhandene Symmetrien ausgenutzt werden können. Unter Ausnutzung von Pixel-Recycling und Symmetrie müssen pro Bild nur die orange markierten Punkte neu berechnet werden.

In Abbildung 3 bestehen die konzentrischen Kreise aus 128 Punkten. Für Mandelbrot-Zooms sind Werte ab 400 brauchbar. Es müssen also pro Bild nur 400/n Pixel bei n-Symmetrie berechnet werden. Man vergleiche das mit entsprechenden 800 x 640 also gut 400.000 Pixel! Andere Interpolationen mögen gegenüber dem Brute-Force-Ansatz etwas besser aussehen.

In den äußeren Bereichen des Bildes werden die Abstände des Rasters immer größer. Es nimmt aber auch die Geschwindigkeit der Pixel durch den Zoom zu. Die sich ergebende Unschärfe kann man also als Motion-blur durchgehen lassen.

In der Mitte des Bildes – dort wo in der Regel der Blick ruht – liegen die Rasterpunkte praktisch beliebig dicht: Es ist also Anitaliasing bis zum Abwinken möglich – und das ohne nennenswerten Mehraufwand.

Mit dieser Technik habe ich mit Mathematica einige Deep-Zooms erstellt:

Ein rechteckiger Teil aus der log(z)-Ebene ist also eine sehr effiziente Art, Informationen eines Zooms in einem Bild statisch festzuhalten. Lässt man die Rücktransformation e^z von der GPU erledigen, so kann man in Echtzeit Zoom und Drehung steuern.

Mit Pixelbender kann man für Flex entsprechende Shader/Kernel ⁶⁾ erstellen, die auf entsprechender Hardware ausreichend schnell ausgeführt werden. Zwei Zooms habe ich mit dieser Technik umgesetzt und für Leute hochgeladen, die herunter geladenen Code gerne direkt(X) und ohne doppelten Boden auf ihrer GPU laufen lassen wollen:

Ein typischer Shader sieht so aus:

<languageVersion: 1.0;> 
kernel zoomer
< namespace : "Zoomer"; vendor : "private"; version : 2; description : "zoomer 2"; >
{
  const float PI = 3.14159265;
  const float EU = 2.71828; 
  parameter float translate <       
      minValue:float(0);
      maxValue:float(400.0); 
      defaultValue:float(0.0); >;
  parameter float rotate <       
      minValue:float(0.0);
      maxValue:float(960.0); 
      defaultValue:float(0.0); >;
  input image4 iImage1;
  input image4 iImage2;
  input image4 iImage3;
  input image4 iImage4;
  output float4 outputColor;
  void evaluatePixel()
  {
      float2 position = outCoord() - float2(479.5,199.5);
      float2 tmp = outCoord();
      tmp.y = abs(log(sqrt(pow(position.x,2.0) + pow(position.y,2.0))/510.0))*30.474;
      tmp.x = mod((atan(position.x, position.y)/PI + 1.0)*480.0, 958.5) ;
      position = tmp + float2(rotate,translate);
      position.x = mod(position.x,958.5)+1.0;
      if ( position.y < 398.5) {outputColor = sampleLinear( iImage1, position );} 
      else if ( position.y < 797.0) {outputColor = sampleLinear( iImage2, position - float2( 0.0 , 398.0 ));} 
      else if ( position.y < 1199.5) {outputColor = sampleLinear( iImage3, position - float2( 0.0 , 796.0 ));}
      else {outputColor = sampleLinear( iImage4, position - float2( 0.0 , 1194.0 ) );}  
  }
}