Since fractals seem to be the theme nowadays, here's my shot at it.

  There's quite a developement history behind this image.

  The basic idea was this: What if you take a julia fractal and then
extrude it (a bit like a prism), but while you extrude it, change
the complex number from which the julia is being calculated? That is,
different layers of the prism are composed of julia fractals with
slightly modified values.

  Allright, so take the julia fractal for example for <0.353, 0.288>
and extrude it by half a unit so that at the other end it is the
julia for <0.353+0.25, 0.288>. 10 iterations should be ok.

  How exactly to implement this was in no way trivial.

  My first thought was to make an isosurface using the julia fractal
pattern as a function. So far so good, but pattern functions can't take
parameters, so it can't be done like that.

  So I had to actually make the julia fractal function, in other words
a recursive function myself (it's slower, of course, but works).

  I got the isosurface to work, but it had one problem: Not accurate
enough. The surface was full of noise. I had to lower the accuracy
by two orders of magnitude in order to get a smooth surface, but at
the cost of a ridiculously high max_gradient (over 20000). Not good.

  So I settled on a compromise: accuracy 1e-4, max_gradient 2000.
It still had some noise, but not as much. Bearable.

  However, it was still not good: After 1.5 hours of rendering the
final version and when only about 10% was ready (and it was only
slowing down) I decided that it's ridiculously slow.

  So back to the thinking board.

  In this particular case a heightfield would do (it wouldn't work
in all cases, but this one was simple enough). However, how to create
the heightfield?

  I came to the conclusion that creating a heighfield from my recursive
function was just impossible. So instead, I had to create a mesh.

  Of course the mesh is also impossible to be created from the function
directly, at least without sampling the function. But that's actually
exactly what the isosurface is doing: It samples the function until
it finds the surface.

  So I created the (300x300x2 triangles) mesh by tracing the isosurface.

  The tracing was very slow, of course, but I still got this image
ready in 42 minutes (rendering the isosurface directly would probably
have taken more than a day).
  Curiously, it also has the noise, probably because the mesh is so
accurate. But at least I got it faster.

Post a reply to this message

Attachments:
Download 'juliamorph.jpg' (75 KB)

Preview of image 'juliamorph.jpg'