A new multi-branch algorithm to render rational-exponent Mandelbrot fractals | Hacker News Reader

A new multi-branch algorithm to render rational-exponent Mandelbrot fractals

arcfn.com

67 pointschrismealy7 comments

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. :)

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.

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.

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

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.)

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?

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!

Reply on news.ycombinator.com