I wrote a tiny fractal renderer. You can find it here.

There are many fractal renderers out there (e.g. the amazing XaoS), so this one is not special by any means. What is neat about it is that it doesn't have any external dependencies. Well, it needs CMake to build, but I'm sure you can figure out how to compile it without that, too.

It outputs plain `*.bmp`

files which can become quite huge at large resolutions. Using e.g. ImageMagick to convert the resulting images e.g to `*.png`

files is recommended.

I had lots of fun coding this up and I'm currently extending it towards supporting user-defined formulas, which would make it even more fun.

The build system is `cmake`

, there are no dependencies except for the standard library and the C math library. You might wanna build the program in a separate directory, maybe like so:

```
$ tar -xzf mandelbmp.tar.gz
$ mkdir mandelbmp.build
$ cd mandelbmp.build
$ cmake ../mandelbmp
$ make
```

When invoked without any arguments, `mandelbmp`

will display a help message:

```
$ ./mandelbmp
usage: ./mandelbmp Re{c} Im{c} nx ny x1 y1 x2 y2 max_iter output.bmp [colormap]
good values for x1, y1, x2, y2 are -2, -2, 2 and 2
colormaps:
0 - nausea (default)
1 - colorblind
2 - inverted colorblind
3 - heresy
4 - prophecy
5 - parasite
6 - invader
```

`Re{c}`

and `Im{c}`

are the coordinates in the complex plane for which to do compute the sequence. If you put the letters `x`

and `y`

there, the programm will be in *Mandelbrot mode* and compute the mandelbrot set. If you put numbers there, the program will compute the Julia set for the given point. The parameters `nx`

and `ny`

define the resolution of the resulting image. Be careful here as `mandelbmp`

outputs uncompressed BMP files which can be quite huge. If you have `imagemagick`

installed you can `convert`

the result e.g. to PNG though which saves a lot of space. The arguments `x1, y1`

and `x2, y2`

define the region of the complex plane in which the calculation will be carried out, and `max_iter`

specifies the maximum number of iterations to do. The optional `colormap`

will be normalized to the number of iterations. Make sure to check all colormaps out!

Here's an overview over the colormaps

generated with this script:

```
#!/bin/bash
for i in {0..6}
do
./mandelbmp x y 64 64 -2 -2 2 2 30 thumb$i.bmp $i
done
montage -tile 7x1 -geometry +0+0 thumb{0..6}.bmp "all_colormaps.png"
rm thumb{0..6}.bmp
```

Much in the same way, we can run

```
#!/bin/bash
index=0
for i in -2. -1.5 -1. -.5 0 .5 1. 1.5 2.
do
./mandelbmp -.5 $i 64 64 -2 -2 2 2 20 thumb$index.bmp 2
index=$(expr $index + 1)
done
montage -tile 9x1 -geometry +0+0 thumb{0..8}.bmp "julia_sweep.png"
rm thumb{0..8}.bmp
```

to sweep `y`

across the complex plane at `x = -.5`

, which will yield the following output in `julia_sweep.png`

:

The output of the following script, which generates a montage of Julia sets all across the complex plane, gives us some insight into the connection between the Julia set and the Mandelbrot set.

```
#!/bin/bash
x0=-2
y0=-2
N=32
idx=0
flist=""
for ((i=0; i<$N; i++))
do
x=$(bc -l <<< "$x0 + $i*4. / $N")
for ((j=0; j<$N; j++))
do
fname=thumb$idx.bmp
flist="$flist $fname"
y=$(bc -l <<< "$y0 + $j*4. / $N")
./mandelbmp $x $y 32 32 -2 -2 2 2 64 $fname 2
J=$(expr $J + 1)
idx=$(expr $idx + 1)
done
done
montage -tile $N"x"$N -geometry +0+0 $flist "julia_to_mandelbrot.png"
rm $flist
```

Its output (`julia_to_mandelbrot.png`

) looks like this: