END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

Hi
Playing with old 3D formulas is still good fun. Some videos are still calculating with intersesting 3D fractal details from pseudo-seahorse valleys...

Wow, I did not realize that the non­trigonometric formulas were so much faster. Here are some higher order formulas that I found with Mathematica. Hopefully, these formulas will provide huge time savings, especially for the popular 8th order version. One nice thing about the odd powers is that they do not require any square roots, so they should be quite fast. These formulas are a bit lengthy, but they checked out correctly on my computer. For optimum efficiency, you will probably need to declare some intermediate variables to avoid redundant calculations.

Hi all,

Awesome work with the Mandelbulb!

My first post here.
I've been wondering for a little while about another possible way of generating a 3D Mandelbrot and would appreciate your thoughts.

A comment in this Reddit triggered this recent line of thought: http://www.reddit.com/r/math/comments/9nnc0/hypercomplex_fractals_pics/c0djtbw

Since seeing some of Thomas Banchoff's animations years ago I've been fascinated by the 3-sphere and its stereographic projection into flat 3-space (Something I explored in my 4D rotation animations here: http://spacesymmetrystructure.wordpress.com/2008/12/11/4-dimensional-rotations/ )
and what I was wondering is: What would it look like to take the intersection of the set in 4-space described above with the unit 3-Sphere and stereographically project down to 3D ?

Actually it would make more sense to work backwards - to check if a point in 3D space is part of the fractal, first reverse stereographic project like this:

   X  = 2 * x / (1 + x ^ 2 + y ^ 2 + z ^ 2)
   Y  = 2 * y / (1 + x ^ 2 + y ^ 2 + z ^ 2)
   Z  = 2 * z / (1 + x ^ 2 + y ^ 2 + z ^ 2)
   W = (-1 + x^2 + y^2 + z^2) / (1 + x^2 + y^2 + z^2)

Then do the iteration to see if it is in the set.

My questions for you are:

• Has this been done before ?
• Do you think the results would be interesting ?
• How would you recommend getting started?
  I have a little programming experience but have never done any raytracing/raymarching before. From reading some of Inigo Quilez's writing I suspect that the Hubbard Douady potential might be useful here

Apologies if you guys already have this, but I just realised a more compact form of the White/Nylander formula - though not necessarily fastest in all cases (e.g. even powers<10), though it is faster than the explicit trig version in UF:

            ztemp = ((r=cabs(zri)) + flip(zj))^@mpwr
            zri = real(ztemp)*(zri/r)^@mpwr + cri
            zj = -imag(ztemp) + cj

ztemp, zri and cri all complex
r, zj and cj all real.
@mpwr real, though using complex is possible with this form.
In case anyone isn't familiar flip(zj) simply produces i*zj i.e. makes zj imaginary.

Hi guys, I just registered to the forum because somebody pointed me to this thread this morning. I got interested in the trigonometric version of the Mandelbrot set posted here, so I wrote a small raymarcher (in C) and tried the idea. Results are interesting. First I tried it in the CPU:



Render time was about 15 minutes (512 ambient occlusion rays, one shadow ray, two light sources, 2x2 antialias at 1280x720). The raymarcher is very rudimentary, the step size is constant, no distance estimation computations to speed the marching. Not yet. The surface normal (if such a thing exists for fractals) is computed by the central differences method, it's not analytic.

Since a couple of years ago I did a demo with a quaternion 4d julia set in realtime with ambient occlusion in the GPU (Kindernoiser: http://iquilezles.org/prods/#kindernoiser), I decided to port this little raymarcher of this morning to the GPU this afternoon. Results are promising, I get almost realtime rendering (5 frames per second) without the distance estimation optimization and some non-raytrace-based ambient occlusion.

My motivation to try this has been one of those green-broccoli zooms posted by Twenbie, it so much looks like real vegetation or a forest, it's amazing. I hope I can work a bit next days again and do something like that, I will continue to do so.

Also, I think twenbie or somebody with a good raytracer handy should try some subsurface-scattering (translucent surfaces), that should rock quite a lot!!!

About the topic, it's really a pity the thing doesn't work that nicely for exponent=2, otherwise I would say this would have been the definite 3D M-Set. In any case, the choice of multiplying both angles by the exponent in the trigonometric multiplication is rather arbitrary I think. It's a pity. I somehow feel the real thing not trigonometric, but polynomial, although I'm not the one to tell. My best attempt so far was this http://iquilezles.org/www/articles/experimental3djulia/experimental3djulia.htm whici is completely ridiculous compared to the beautiful images produced by this trigonometric variation discussed in the thread.

Very impressive image for a first post here!

Your 3D julia images remind me a video I did recently :
<a href="http://www.youtube.com/v/uotgvkZO2Zk&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/uotgvkZO2Zk&rel=1&fs=1&hd=1</a>

and this one as well:
<a href="http://www.youtube.com/v/tCGqXDnzje8&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/tCGqXDnzje8&rel=1&fs=1&hd=1</a>

Hello,   

This very simple iteration can produce some interesting results (in a very unoptimized C code):

bool JuliaSimple(double x, double y, double z){
double radius,ny,nx,nz;
unsigned char Counter;
for(Counter=0;Counter<50;Counter++){

 nx = x*x-z*z-0.27;
 nz = 2*x*z;

ny=y;
x=nz;
y=-nx;
z=-ny;
radius=x*x+y*y+z*z;
if (radius>1000) break;
}
if(radius>1000)
return false; //its outside of the set
 else
   return true; //its on the set
}

These are two other C values:
/*nx = x*x-z*z-0.285;
nz = 2*x*z-0.1;*/

/*nx = x*x-z*z-0.27;
 nz = 3*x*z;*/

here are two renders of this system:
http://www.rfractals.net/gallery/main.php/v/JuliaSets/3DJulia1.html
http://www.rfractals.net/gallery/main.php/v/JuliaSets/3DJulia2.html

The Mandelbrot of this series doesn't looks good but I have tested it on many other julia equations (such as the phoenix and the newton fractal) and it looks interesting.

I have some feedback to share.

I implemented the polynomial version of the 8x rotation (it's slightly different than the Mathematica-one posted above -  I did my own derivation based on the spherical coordinate system I'm using).  The speed improvement in the CPU version was great (4 to 5 times faster). However, the GPU version runs equally fast, no speed gain at all between trigonometric or polynomial version. Still, it's very fast (interactive to realtime, depending on the resolution/quality settings) This is disappointing, and might be related to the fact that probably the trig functions are partially implemented by little texture lookups which are fast, while the polynomial version consumes lots of instructions (MADs). Of course I took into account that most terms in the polynomials where even, so only one square root is needed per iteration in the end. So conclusion is: big speed gains in CPU, but no speed gain in the GPU