High-Precision Deep Zoom

Technical Info

Fractal Rendering Software

All images on this site were created with custom software I have been slowly developing over the past 7-8 years. It is written in C++ with a little hand-coded assembly language. The compiler is Visual Studio, and the user interface is based on MFC.

Topics on other pages

Most of the major topics related to the software have grown enough to deserve their own pages now.

Topics on this page

Distributed Processing

The software is capable of distributed processing (DP) and can divide up the task of drawing an image among several computers, or among several cores on a multi-core system. This was more useful when I had several nearly equivalent Pentium III systems. Once I got a Pentium-IV, it was so much faster that adding the P-III systems to the processing didn't make much difference, and I didn't use the DP capability very much. Now that I have a quad-core system, the DP subsystem allows the software to divide up the rendering work among the four cores.

Types of Fractals

The software can generate images in high-precision for any order polynomial Mandelbrot function. I have implemented some of the convergent-type fractals like Newton (for cubics) and Nova, as well as the Phoenix fractal based on the Henon map. Deep zooms into convergent fractals require full floating-point arithmetic (i.e. mantissa with exponent), rather than the fixed-point arithmetic (one digit of integer with multiple digits of fraction) I am currently using, so I have made only a few short animations of them, but plans for 2009 include extending the arithmetic system to support full floating-point.

Drawing Operations

The software has a high-precision distance estimator function. I like the DE method of drawing for many things, especially areas where the set is predominantly filamentous. It keeps the details of the points near the set in sharp contrast, and if the parameters are set right, it also adds a texture to the background that makes the whole image much more visually interesting. A similar effect can be achieved in the standard count-based rendering method by reducing the escape radius to 4, rather than keeping it at a very high value like 10000. Higher values for the escape radius, combined with fractional count generation, can produce very smooth gradients in the background, but sometimes that's not what you want and it can look rather dull.

Rectangular Decomposition

I sometimes use a variation on the rectangular decomposition algorithm (also called the Mariani-Silver algorithm) to speed up drawing of areas that have a lot of points in the set. This is based on the fact that if the points on the boundary of any box all have the same count value, then all points in the interior of that box must also have that count value and do not need to be calculated explicitly. The algorithm can be applied recursively, starting with the whole image to be drawn, dividing up the image into smaller rectangles until some are found whose boundaries are all the same.

This method can miss some details since the samples around the edge of the box may have a step size larger than some tiny filament that connects the interior of the box to the rest of the set, but it can give dramatic speed increases for quick exploration. It also precludes the use of smoothing techniques to create nice gradients of color in the final image.

My variation limits the use of the algorithm to fill in the interior of the set, so that smooth gradients outside the set can still be drawn and no details are missed. The speed increase is not as great as the original algorithm, but no image quality is lost. I had this method working years ago but stopped using it for two reasons. First, I was focusing my efforts on still images and typically they do not have many close-up encounters with mini-brots within them. Second, I extended the software to a multithreaded architecture, and it is not easy to convert a recursive algorithm like this to a parallel-processing architecture. However, when animating deep zooms, mini-brots often appear, and now that CanyonDeep is in the works, I have finally brought back rectangular decomposition and implemented it in a multithreaded way so it can run efficiently on a multi-core system.