Mandelbrot Coastlines

Written 2019-05-07

In this post I will explore using simple fractals and a bit of randomization to generate "coastlines" like the one below. Complete, runnable Haskell code to reproduce everything in this post can be found on GitHub. In the end what we will generate will look something like this:

Simple Fractals

Fractals are geometrical structures that show a property called self-similarity, i.e. a zoomed in picture of a part of the structure is very similar to the whole structure. In this post we will take a look at a very simple type of fractals called initiator-generator fractals. These fractals are specified by two parts: an initiator and a generator. The initiator is a simple structure - like a line or a triangle - and the generator is a set of initiators which replace the original initiator.

The Koch Curve

A good example is the Koch curve, which is a very simple initiator-generator fractal. The initiator for the Koch (as we will use it) is just a straight line. The generator will be the same line with the middle replaced by two lines in a 60 degree angle to the original line.

The generator applied once
The generator applied to every initiator
The generator applied to every initiator again
... and again

Adding randomness

The above line is neat in it's regularity, but what I want for a "coastlines" is a bit of randomness. When generating fractal structures there is no constraint to use only one generator. We can also use a set of generators, from which we choose randomly. This is what we will do next: we add another generator, which is just our original generator but upside down.
Each time an initiator is replaced with a generator, i.e. a straight line with an upward or downward pointing triangle, one of the two is picked with equal probability. So there is a 50% chance for each to be used.

The new generator
Random generators applied twice

Now all that needs to be done to get nicer coastlines is to apply the generators for few more iterations. After 6 rounds of the iterator-generator cycle the resulting picture will look similar to this:

Try it yourself!

If you want to play around with the code yourself, just clone my GitHub repository. The code is written in Haskell, I would recommend building it with the Stack build tool.

Once you have the code cloned and Stack installed, build the code with

    stack build
and use
    stack exec fractal-exe 6
to generate a coastline. Output will be stored in a file called fractal.pdf.

The numeric parameter to fractal-exe controls the number of iterations for which the randomized initiator-generator cycle will be run.