#Skip to menu

Mandelbrot set tutorial

Published:

A fractal image is an image in which a pattern is repeated when the image is magnified. In this article we'll see how to draw a Mandelbrot set, one of the most well known fractals.

Definition

The Mandelbrot set is the set of all the complex numbers \(c\) for which the iteration

(1) \(z_{n+1}=z_n^2+c\)

starting with \(z_0=0\), never escapes to infinity, but stays bounded, no matter how many iterations we do. For example:

  1. If \(c=1+2i\) we have \(z_0=0\), \(z_1=1+2i\), \(z_2=-2+6i\), \(z_3=-31-22i\)... as we go on \(z_n\) grows without stopping, it escapes to infinity.
  2. If \(c=-1\) we have \(z_0=0\), \(z_1=-1\), \(z_2=0\), \(z_3=-1\)... in this case \(z_n\) is bounded, so \(c\) is in the Mandelbrot set.

Plotting

On a Cartesian plane the Mandelbrot set intersects with the \(x\) axis at \((-2.5, 1)\) and with the \(y\) axis at \((-1,1)\). To plot the set on a \(WxH\) surface we scale each \((x,y)\) point of the surface in the \((-2.5,1)\) range for \(x\) and \((-1,1)\) range for \(y\). The scaled \(x\) becomes the real part of \(c\) and the scaled \(y\) becomes the imaginary part. Once we have \(c\) how do we know if \(z_n\) is bounded or not? We can't count to infinity so we introduce limits. One is the upper bound on the number of iterations (for example 50). The other is a bailout condition: if \(|z_n| > 2\) then \(z_n\) has grown too much and we know that it'll grow indefinitely so \(c\) is not in the set, if at the end of the loop we have \(|z_n| < 2\) then \(c\) is in the set.

All black

black.go is a basic implementation. If a pixel is inside the set we draw it black, otherwise transparent. It uses the image Golang package.

To run do:

go run black.go > black.png

Escape time algorithm

The way the set is drawn is up to the programmer. One common technique (known as Escape time algorithm) is to use a different color based on how many iterations takes \(z_n\) to escape to infinity. escape.go shows an implementation. On http://colourlovers.com you may find some inspiration for your colors.

Smooth coloring

The problem with the above algorithm is that it creates bands of color. An improved algorithm is the "Normalized Iteration Count". We use a fractional iteration count to better smooth the colors. The integral part is used to choose two colors, the fractional part is used to blend them togheter. To get this count do:

\(f = i - log_2(log_2(z_n))\)

where \(i\) is the number of iterations done. For the derivation of the formula see Renormalizing the Mandelbrot Escape.

This time we'll use lucasb-eyer/go-colorful which provides some color manipulation functions. The implementation is in smooth.go.

Binary decomposition

We can draw the Mandelbrot set however we want. For example we can use one palette of colors if the imaginary part of \(z_n\) is \(<0\) and another if it's \(>=0\). See decomposition.go.

Donate