Reproducing images with geometric primitives.

A target image is provided as input. The algorithm tries to find the most optimal shape that can be drawn to minimize the error between the target image and the drawn image. It repeats this process, adding one shape at a time. Around 50 to 200 shapes are needed to reach a result that is recognizable yet artistic and abstract.

Now available as a .NET and .NET Core nuget package!

Follow @PrimitivePic on Twitter to see a new primitive picture every 30 minutes!

The Twitter bot looks for interesting photos using the Flickr API, runs the algorithm using randomized parameters, and posts the picture using the Twitter API.

You can tweet a picture to the bot and it will process it for you.

Depending on the output filename extension provided, you can produce different types of output.

• PNG: raster output
• JPG: raster output
• SVG: vector output
• GIF: animated output showing shapes being added

This GIF demonstrates the iterative nature of the algorithm, attempting to minimize the mean squared error by adding one shape at a time. (Use a ".gif" output file to generate one yourself!)

Since the algorithm has a random component to it, you can run it against the same input image multiple times to bring life to a static image.

If you're willing to dabble in the code, you can enforce constraints on the shapes to produce even more interesting results. Here, the rectangles are constrained to point toward the sun in this picture of a pyramid sunset.

The matrix below shows triangles, ellipses and rectangles at 50, 100 and 200 iterations each.

Say we have a Target Image. This is what we're working towards recreating. We start with a blank canvas, but we fill it with a single solid color. Currently, this is the average color of the Target Image. We call this new blank canvas the Current Image. Now, we start evaluating shapes. To evaluate a shape, we draw it on top of the Current Image, producing a Buffer Image. This Buffer Image is compared to the Target Image to compute a score. We use the root-mean-square error for the score.

Current Image + Shape => Buffer Image
RMSE(Buffer Image, Target Image) => Score

The shapes are generated randomly. We can generate a random shape and score it. Then we can mutate the shape (by tweaking a triangle vertex, tweaking an ellipse radius or center, etc.) and score it again. If the mutation improved the score, we keep it. Otherwise we rollback to the previous state. Repeating this process is known as hill climbing. Hill climbing is prone to getting stuck in local minima, so we actually do this many different times with several different starting shapes. We can also generate N random shapes and pick the best one before we start hill climbing. Simulated annealing is another good option, but in my tests I found the hill climbing technique just as good and faster, at least for this particular problem.

Once we have found a good-scoring shape, we add it to the Current Image, where it will remain unchanged. Then we start the process again to find the next shape to draw. This process is repeated as many times as desired.

The following primitives are supported:

• Triangle
• Rectangle (axis-aligned)
• Rotated Rectangle
• Ellipse (axis-aligned)
• Rotated Ellipse
• Circle
• Quadratic Bezier
• Quadrilateral
• Regular Polygons (Square, Pentagon, Hexagon, Octagon)
• Regular Stars (Four-Pointed star, Pentagram, Hexagram)
• Combo (a mix of the above in a single image)

More shapes can be added by implementing the following interface:

public interface IShape
{
    Worker Worker { get; set; }
    IShape Copy();
    IPath GetPath();
    void Draw(Image<Rgba32> image, Rgba32 color, double scale);
    void Mutate();
    string SVG(string attrs);
    List<Scanline> GetScanlines();
}

• Hill Climbing or Simulated Annealing for optimization (hill climbing multiple random shapes is nearly as good as annealing and faster)
• Scanline rasterization of shapes in pure C# (preferable for implementing the features below)
• Optimal color computation based on affected pixels for each shape (color is directly computed, not optimized for)
• Partial image difference for faster scoring (only pixels that change need be considered)
• Anti-aliased output rendering

This project was originally inspired by the popular and excellent work of Roger Johansson - Genetic Programming: Evolution of Mona Lisa. Since seeing that article when it was quite new, I've tinkered with this problem here and there over the years. But only now am I satisfied with my results.

It should be noted that there are significant differences in my implementation compared to Roger's original work. Mine is not a genetic algorithm. Mine only operates on one shape at a time. Mine is much faster (AFAIK) and supports many types of shapes.

Here are more examples from interesting photos found on Flickr.