I have to do some mainline work on the rest of my stuff that will actually help this along. When I get the demo updated, I’ll ping you (the same link I posted above will work, just with more detail).

It looks like I’m going to have to understand the Decimal package anyway, I guess maybe I’ll go back to more conventional approaches to rendering the mandelbrot tiles.

imshow(I.T, origin=’lower left’, vmin=0, vmax=100)

Problem solved!

Sadly, however, it reveals another problem that I’m still chasing — a memory leak in imshow. It’s memory consumption grows without bounds until crashing my 32-bit Python by using 2G of memory. I’ll see if I can get around that, perhaps by just calling PIL directly.

I’ll update the abaxoscope link once I get it running properly. Although five zoom levels are fun, I *really* want to demonstrate the full effect of arbitrary zoom.

My “abaxoscope” (a device for viewing things that only exist as a result of computation, of which Mandelbrot sets are an example) must remain a sideline while make its underlying platform viable. That means I’ll have to restrict myself to working on it on occasional weekends.

Your approach sounds perfectly reasonable, and has the added benefit that it will force me to actually wrap my head around numpy and mapplotlib — things I really MUST do.

Of course, if you know more than 17 people who might be interested in paying real money for such magic, I’m all ears .

The problem is that you are rendering rectangular blocks separately and the colouring algorithm isn’t designed for this. The way it colours is to use the hot-cold (jet) colour map from the lowest to highest stored iteration number. This means you always get a nice scaling on any given image, but they are not comparable on zooms or across tiles. To get that effect, you’d want to use a cyclic colour map. This is something that can be done in numpy. Just choose a number of iterations as the cycle (say 100), take x=(i%100)/100 and then the colour would be cmap(x) for cmap a cyclic colour map. Pick one from http://www.scipy.org/Cookbook/Matplotlib/Show_colormaps (e.g. hsv will do the trick). Now when you call imshow add the keywords cmap=cmap, vmin=0, vmax=1.

Unfortunately this won’t work with my stupid trick to make the interior coloured differently, so you’ll have to handle that separately. I don’t have time to write the code now, but you can apply a matplotlib cmap to a 2D array and get back a 3D array where the last dimension has size 4 and gives the RGBA components, and this can be passed to imshow. So, first create an array of the right shape initialised to black (zeros), then set the points which are not in the interior to have the colours output by applying cmap. Hope that makes sense, sorry I don’t have more time to write it out fully.

Do post results and code here if you do it, would love to see the result.

Boundaries that are subtle when the entire set is rendered are colored incorrectly when a portion is rendered. I used an image size of 256×256 in rendering the above, and here is an example parameter set that demonstrates the problem (this is for the top left tile at zoom level 2):

n, m = 256
itermax = 100
xmin = -2.0
xmax = -1.375
ymin = -1.25
ymax = -0.625

I created these images using Python 2.7.2 and numpy 1.7.0 on a Windows 7-Pro system.

I wonder if you could perhaps write more about the algorithm for actually coloring each point in the image? I *think* the relevant line is “img[ix[rem], iy[rem]] = i+1″. Since I’m a numpy newbie, I’m hazy about what this is doing. A coloring scheme used by a different approach (that, sadly, is not nearly as beautiful!) that avoids these artifacts is to calculate the RGB values separately:
r = i % 4 * 64
g = i % 8 * 32
b = i % 16 * 16
color = b * 65536 + g * 256 + r

Perhaps there’s a way to preserve your coloring scheme while avoiding the anomalies in certain (but not all!) of the tiles?

In any case, your example is totally awesome. I’d love to get this coloring issue solved, then I can *really* have fun with it.