public static bool WillMutate(int mutationRate)
{
if (GetRandomNumber(0, mutationRate) == 1)
return true;
return false;
}

Heh.

public static bool WillMutate(int mutationRate) {
return GetRandomNumber(0,mutationRate) == 1;
}

In doing this, you lose the pitfalls of a hill-climbing algorithm. Honestly, despite your objections, this is still a hill-climbing algorithm. It will develop along one path and come out with one output. There is no competition at the end, there is no pruning, even if you try to weasel and say “parents compete with children.” OK so parent wins, parent just makes another child. It is serial hill-climbing. Oops I turned right I should have gone straight now I will go straight instead. Still stuck in the valley, when there could be others exploring other parts of the map, efficiently, as I outlined above (give more CPU time to the better seeming ones).

The algorithm itself makes a presupposition that the first few thousand generations are even important. The fitness function does not work on them properly; it preselects polygons that make up a sort of a base and paints on top of them, which is a little absurd, considering that they make up broad details that will not be in a finished picture that doesn’t have a small tonal range like the mona lisa. It becomes a somewhat additive process (even though that base is moved around and changed a little). You could pick almost a random collection of polygons and start from there and get roughly a same result; there is a lot of waste near the beginning. There should be a non-genetic pre-processing step, or multiple competitors that each get a fixed number of generations before any sort of pruning is done.

I would apportion the populations into the following divisions:
1) A population that just works on the image
2) A population that at first works on a blurred or simplified version
3) A population that at first works on a contrast-enhanced version
4) A population that at first works on an edge-detection composite
5) A population that at first works on a tone-mapped version of the picture (much like HDR tone-mapping, but in reverse: in this case, taking data and reducing it).

Finally, another fitness test that can be added is compressibility of output. This could probably be efficiently performed by sorting polygons according to a weight function between their spacial location and average RGBA values, and then using differential encoding (next vertex is + 4,2 with color -8,+120,-100,+2 of last). If you’re looking to compress images instead of just making pretty ones, it is possible this could turn into a decent method, because of how easy it is to compress polygonal data on a 2D plane.

You know, I’m inspired to implement all of this myself. I wonder how it might do.

There’s a significant difference between Euclidian and Euclidian squared fitness routines. You think that 4 + 5 + 10 is roughly the same as 16+25+100, but it becomes quite important.

Take:
0,0,0,10 and compare it with 5,5,5,4

While the former adds up to 10, and the latter adds to 29 the former squares to 100 and the latter squares to 91. Single random pixels with high color distances rather than averaged out get a veto power. While it seems like N² is reasonable for an approximation (and with a sample size of two where any improvement is taken it likely doesn’t). With anything more, you’re shooting yourself in the foot, and it bears it out with the generated images. They look significantly sloppier if you try to ramp up the sample size to get better images without realizing the assumption of the improvement is sample==2.

While there’s a lot of different things to try, one shouldn’t accept that you can just lose that square-root without any consequences at all. If your sample size is larger than 2, this speed up is a shot in the foot. The sum of the variance of the color distances is different than sum of the color distances.

Yes. You can have the fitness reach zero. I’ve written something similar, which is significantly more optimized than the above program (it would take seconds rather than days to run), and I’ve run the program long enough to get perfect representations (after a while it could only improve single pixels and then improved itself out of them).

With the way it’s currently written it would take years. But, rasterization is really just an image with pixels and pixels are little squares. So clearly it *could* be done if the six vertexes denote a particular polygon that ends up being a single pixel. But the diminishing returns make it rather worthless. It’s possible, but would take years and is hugely diminishing in the returns department.

I have made something which in a way lower scale resembles your application. It’s an Excel macros which is kind of a graphic implementation of Richard Dawkins Weasel program. You can find it in the following links (due to filesize limits, the containing rar file has been divided on two volumes):

Part 1
Part 2

Hope you like it, and congratulations for a very inspiring work.