
A new multi-branch algorithm to render rational-exponent Mandelbrot fractals - chrismealy
http://www.arcfn.com/2011/12/new-multi-branch-algorithm-to-render.html
======
colomon
I'm kind of worried that the images you are generating are just artifacts of
your approach rather than getting at the fundamental nature of what is going
on. The first thing that worries me is that your fractals don't look properly
Mandelbrot-ish to my eye. Admittedly I've only ever looked at integer power
Mandelbrot-like sets before, but all that I've ever looked at were either
completely uninteresting or had snowmen somewhere.

(I'm afraid I'm having a hard time putting into words what's bugging me, and
alas I need to work, so I'm skipping what would be a much longer middle
section to this post in an ideal world.)

So I'd really like to see what happens if you make a particular branch choice
and stick to that branch, for non-standard branches. And I'd like to see Julia
sets. And I will try to get on implementing that stuff myself when I get the
chance. :)

~~~
kens
I understand what you're saying, My motivation is that I want to find the
"fundamental nature" rather than artifacts or pretty pictures. The regular
z^2.5+c fractal has obvious artifacts when you pass over the branch cut, and I
hope that my technique is more "true". (These terms are all hard to define,
but I think I mean the same thing you do.) I've explored different escape
bounds, for instance, to make sure that isn't causing artifacts. (The bound
causes huge artifacts with negative exponents, by the way.)

It bothers me too that my fractals are less Mandelbrot-ish. I suspect this is
due to all the branches overlapping and obscuring the details. I'm currently
working on a couple ways to separate out these branches. Unfortunately just
picking a different branch doesn't help, since it just moves the
discontinuities. One plan is to display the fractal on the Riemann surface in
3D to separate the branches. The other plan is to crawl along the edge so you
can continuously move from branch to branch without jumps. Julia sets are also
on my list of things to do if I ever have time.

If you do experiment with this, let me know what you find out.

------
hsmyers
Good stuff! Along with Saupe and Pietgen, his landscapes (fractals rendered in
3D) gave me a necessary fix as needed. Nice to see him back in to it.

~~~
kens
I think you have me confused with someone else? I haven't done anything with
3D landscapes.

------
RBerenguel
I find it odd that using both branches is "new", or more precisely, that
people weren't doing it before. I would have guessed this would be missing a
lot of information.

And I agree with one of the commenters in the post: you could get a decent
speed up (at the loss of "truthness" of the image) by choosing randomly the
branch as you iterate (or for every point getting only a fixed depth-number of
iterations with randomly chosen branches.)

~~~
kens
Thanks for the comments (I'm the author). I did a bunch of searching and
couldn't find anyone else who has used these techniques. I'm sure someone will
let me know if this has all been done before.

I haven't had much luck yet trying to randomly select branches; the image
comes out terribly noisy. But a combination of fixed-depth and random might
work; I'll give it a try.

Edit: in case anyone is wondering why I used C# for this... I started off all
nice and open-sourcey using OpenGL, GLUT, C++, and Linux, but discovered that
my graphics card locked up, a problem that might be fixed if I upgraded to the
latest version of Linux. I decided not to spend my evening upgrading, so
decided to use OpenGL on Windows instead. Rather than install the whole gcc
envirnment, I figured I'd use the free Visual Studio C++ Express, which worked
fine. However, it was difficult to get even a primitive UI with GLUT, so I
figured I'd switch to Windows Forms, which lets me create simple dialogs
easily. But it turns out that Visual Studio C++ insanely doesn't support
Intellisense, which makes it very hard to use Windows Forms. So I decided to
try C#, which is working out okay so far - it's extremely similar to Java. For
the 3D fractal display (which I hope to finish soon), I was going to use
DirectX, but discovered after a lot of investigation that it's been replaced
by something called XNA. And to use that, I need the free Visual Studio 2010
Express for Windows Phone (which despite the name also works on the desktop).
So far that seems to be working okay, but I may end up rendering the 3D
fractals in POV-Ray or something.

Now that I write that down, it seems like I've tried a crazy number of
different software stacks. Does anyone else end up doing this?

~~~
RBerenguel
I use plain C and a small set of plotting functions I created to generate PPM
images. If I were to create 3D stuff I'll probably settle for generating POV
files automatically or something along this lines... But my usual thinking is:
get it done. If it is open sourcey, better, if you need some proprietary stuff
and you get it done (and it's for you!), what's the problem?

Also, Montecarlo things have this noisiness, comes with the algorithm :/
Usually it is a tradeoff: I have an algorithm that creates sharp images of
bifurcation loci, but is awfully slow. If I turn on the randomness, it can go
between 4 and 10 times faster, but the images are no longer sharp and crisp.
The advantage is that adding this kind of "Montecarloing" is just adding a ?:
condition in some for, together with a special flag and a mod operation: easy
to do and no need to add nasty inner loops!

