Generic escape-time fractals

[David Makin]

Hi all,

I just sent a reply to a message from a while ago that I had from Jesse and realised that it's relevant to all who are interested in fractal programming, here's a para-phrased version...

To make fractals more varied on zooming then change/morph or in any way modify the formulas as iterations progress - conditionally of course e.g. location based, genetic path based etc. i.e. remember that your bulb, box or kifs is just a limited escape-time IFS tree where the whole resulting attractor is limited to a set of specific paths through the tree each path essentially decided on a starting location basis.
For instance if you have a full escape-time IFS for the branches of a bush but on reaching a given overall scale factor down any path through the IFS tree you switch the transforms to ones that produce a leaf, or (conditionally) a berry....
Ideally a completely generic fractal program would allow the user the option of fully defining the entire IFS tree i.e. number of child nodes for each parent node and the relevant transform to be applied (linear or non-linear) to a specified depth (e.g. termination of a path by specifying 0 as number of child nodes).

Just to add - of course ideally said program would be able to work out (quickly) the optimum bailout centre, radius, fractal dimension etc. for the attractor and any/all sub-attractors from a given node in the tree and (depending on the algorithm used) the best order of traversal through the tree when rendering.

[Syntopia]

For instance if you have a full escape-time IFS for the branches of a bush but on reaching a given overall scale factor down any path through the IFS tree you switch the transforms to ones that produce a leaf, or (conditionally) a berry....
Ideally a completely generic fractal program would allow the user the option of fully defining the entire IFS tree i.e. number of child nodes for each parent node and the relevant transform to be applied (linear or non-linear) to a specified depth (e.g. termination of a path by specifying 0 as number of child nodes).

Some time ago I developed Structure Synth, which makes it possible to build 3D systems along the lines above: for each node you can have a number of child nodes and transformations (only affine transformations though). Nodes may refer to each other recursively (allowing for fractal structures), and nodes may have multiple definitions with different weights (allowing for random systems depending on the initial seed). These systems were specified as Context Free Grammars. The approach is very similar to stochastic Lindenmayer systems.

There is some more info here: http://structuresynth.sourceforge.net/index.php
and some example images here: http://www.flickr.com/groups/structuresynth/

Of course my approach did not use implicit surfaces, but instead explicit polygonal geometry (each node must terminate in one of the available graphics primitives: box, sphere, point , ...), so you quickly run out of polygons this way - and you don't get the cheap sphere ray tracing :-(

Being able to transform these kind of systems into a escape time / distance estimation system would be great, and I have thought about it several times. But I doubt it is possible. Systems like the KIFS are able to produce an exponential amount of objects given a number of iterations, because of the intrinsic symmetries (even though the symmetries are no longer visible, because of rotations or other transformations inside the main loop). I doubt generic IFS or L-Systems can be cast into a similar symmetric form.

[David Makin]

Being able to transform these kind of systems into a escape time / distance estimation system would be great, and I have thought about it several times. But I doubt it is possible. Systems like the KIFS are able to produce an exponential amount of objects given a number of iterations, because of the intrinsic symmetries (even though the symmetries are no longer visible, because of rotations or other transformations inside the main loop). I doubt generic IFS or L-Systems can be cast into a similar symmetric form.

Granted to be completely generic one would have to switch to what would be a full IFS tree traversal combined with ray-stepping and DE but one could probably do the DE at each stage in the tree traversal to allow pruning of the tree.
Also Hart's method could still be used if all transforms are affine and then the method could be mixed with using primitives simply by specifying that at a given depth or overall scale factor instead of testing against a bounding sphere and continuing down the tree until reaching a defined overall scale (or a maximum depth) one simply intersects with a primitive (my private 3D IFS formula is half-way towards this, further progress was interrupted by the appearance of the bulbs + boxes etc. and other (non-fractal) related stuff

[David Makin]

Here are two experimental renders I did some time ago:

http://makinmagic.deviantart.com/gallery/?catpath=scraps#/d25rsdy
http://makinmagic.deviantart.com/gallery/?catpath=scraps#/d25t3dv

In actual fact the spheres one is obviously simply true spheres as primitives but the other is using a sub-IFS for the sticks with just a rectangle primitive which is obviously non-optimum for something so simple

They were rendered in UF using class-based code so the times are waay slower then could be achieved in dedicated 3D software like Mandelbulb3d or Mandelbulber etc. - in fact times are comparable to some bulbs and boxes using UF classes so appropriate OpenGL or OpenCL code should be able to do them realtime.
To be honest I have too little time at the moment for fractal programming and in any case I'm determined to find a way to apply distance estimation to a (potentially) infinitely varied diamond-square landscape before going back to escape-time stuff.