True 3D mandelbrot fractal (search for the holy grail continues)

[kram1032]

nice stuff

[vector]

i´ve got lots of distorted M-sets on screen, These look very interesting, will try them on my own too, seems as if you were taking three angles from the vector to the starting point z to all three axes, then doubling those, or multiplying by n, this seems different to the common approaches, at least at first look-carry on

[M Benesi]

Alright guys, here is another of 2 new formulas (yeah, I know... making lots of formulas, not exploring them a lot), but I really like the symmetry of this one.

   r=sqrt(bail);
        theta=atan2(sx+flip(sy));
        tango=atan2(sx2+flip(sz));

 sx=r^n*cos(theta*scalef)+pixelr;
         sx2=r^n*cos(tango*scalef)+pixelr;
      
        sy=r^n*sin(theta*scalef)+pixeli;
        sz=r^n*sin(tango*scalef)+pixelj;

sx=sqrt(abs(sx*sx2));   //  I have an if statement so I can switch between this one (which I like more) and
                                // this more traditional formula (which I find more boring):  sx=sqrt( (sx^2+sx2^2)/division variable);
                               //  check that... I changed the division variable to 1... and it is interesting for the z^9 version posted below

bail=sx^2+sy^2+sz^2;

  The first 2 are of the front of the 4th order version (I like the front's 4x90 symmetry<-- joke for MakinMagic through all z^n, but... higher is more intricate as you will see in the 9th order version).

  Keep in mind I think these are all low iteration (5), just to make quick demo images.


zoomed a bit (I think):

This is the same location as the last image above, just increased to z^9:

This next one is the z^9 from the rear.  These guys are really fun to zoom into.

z^9 from the rear, sx=sqrt(sx^2+sx2^2):


  I will tell you that I've zoomed into the center of the sx=sqrt(sx*sx2) mode ones pretty much as far as I wanted to go, and it was all fractally.  Time to check if the rear entry on the sx=sqrt(sx^2+sx2^2) one is as fractally/entertaining.


  It's like a hole with a bunch of squid suckers on the side.  Interesting, I guess.  :p  There may be weirdness in the suckers.

[M Benesi]

  Ok, here are two more 9th order images.  (z^9)

  Same exact location, but the first is sx=sqrt(sx^2+sx2^2):


and this one is sx=sqrt(sx*sx2)     //  you should see why I like this mode a bit more, the details.. the details

[M Benesi]

Here is another formula:
  
        r=sqrt(bail);
        theta=atan2(sx+flip(sy));
        tango=atan2(sx2+flip(sz));  // sx2,sy2, and sz2 are set to sx,sy, and sz respectively before iteration begins
        tau=atan2(sy2+flip(sz2));   //  bail is set to sx^2+sy^2+sz^2 before iterations as in the rest of my formulas
        
        sx=r^n*cos(theta*scalef)+pixelr;
        sx2=r^n*cos(tango*scalef)+pixelr;
        sy=r^n*sin(theta*scalef)+pixeli;
        sy2=r^n*cos(tau*scalef)+pixeli;
        sz=r^n*sin(tango*scalef)+pixelj;
        sz2=r^n*sin(tau*scalef)+pixelj;

sx=sqrt(abs(sx*sx2));  //more detailed mode, you do need to zoom into specific areas to get fractally goodness
sy=sqrt(abs(sy*sy2));
sz=sqrt(abs(sz*sz2));
  OR:
sx=sqrt((sqr(sx)+sqr(sx2))/fixedRadius);   // this is the "boring" mode
sy=sqrt((sqr(sy)+sqr(sy2))/fixedRadius);
sz=sqrt((sqr(sz)+sqr(sz2))/fixedRadius);

and of course:
sx2=sx;
sy2=sy;
sz2=sz;

  bail=sx^2+sy^2+sz^2.......

  This first one is to demonstrate this formulas potential.  It's the top of the front of the 9th order version in what I called "the more detailed mode".  Note that it appears to be sharp and pointy, but this is an optical illusion, it is actually bulbous and oozey (you need to look at it the right way and you will see this).  I'll have to locate it and post a less detailed image or alter lighting so you can tell.


Here is the front of the 9th order:

Same location, "boring" mode:


Here is the rear of the 9th order:

And here is a random 12th order location:


  There are some neat places in this one, but I find type B to be more pleasing to the eyes, except for some stark locations within Type C which... appeal more to my imagination and love of stark mountains rising out of cold glaciers.

[M Benesi]

In Type B, setting angular rotation to -2 instead of 2 looks a bit promising.  Doing a render of sqrt(sx^2+sx2^2) first, then sqrt(sx*sx2).

  The renders were slightly boring.  
First one is sqrt(sx^2+sx2^2) mode:

this one is sqrt(sx*sx2) mode (I like it more although it is lower z-resolution and lower iterations):



This z^4 Mandelbulb B (<-- the new formula in this thread) is pretty neat, although I need to remember to start rendering png(s) instead of jpg(s), as the quality is lower than the image in ChaosPro.  Probably another setting I don't know about, like the parameter tab that allows you to set z-axis resolution, which makes it so you can zoom more..

  It looks like there is a cup in the middle of it.  Not to mention the clusters of grapes at the top, the leaves, and the other clusters... They all look neat with pixelk set negative.

  

[M Benesi]

Here is yet another new formula and some images from it.  This one is a combo of Mandelbulb B (my xy-plane vs. z axis type) and type B that I call type B2 because of the extreme originality of the name.

  pixelw=sqrt(pixelj^2+pixeli^2)*scalef;   <-- pixelw is one of the variables we will be using in this one.
  //set:
sw=pixelw;
sx=pixelr;  <-x component of pixel
sy=pixeli;  <-y
sz=pixelj;  <-z

 r=sqrt(bail);
theta=atan2(sx+flip(sy));   <--it's like type B here
tango=atan2(sx+flip(sz));
whiskey=atan2(sx+flip(sw));   <-- then I do a play out of the Mandelbulb B handbook here
r2=r^n;                                 //  the difference is that I use sx generated with whiskey for all of them, instead of using the angle
                                           //  and applying it to sy and sz with trig functions, of course, also in Mandelbulb B we only have
                                           //  2 angles, one between sx and sy, and one between sz and sk... but you can re-read that one
                                           //  earlier in the thread

sx=r2*cos(whiskey*fixedRadius)+pixelr;   //fixedRadius is a SCAVENGED variable from another formula in this set of formulas
sy=r2*sin(theta*fixedRadius)+pixeli;        // you can just set it to n (the magnitude), but if you want to set angular rotation
sz=r2*sin(tango*fixedRadius)+pixelj;       //to a negative number you need to use different variables... and fixedradius is in a
sw=r2*sin(whiskey*fixedRadius)+pixelw;  //convenient location on my menu... soo... therefore I used it

  bail, once again:

bail= sx^2+sy^2+sz^2;   // if bail>bailout then bail....

Ok.  The images from this one are pretty neat.  I like them.  They seem to have decent variety, even at low iterations. 

Here ya is, some 9th order images (lots of zooms in the same area):

Here be some 10th (all lower than 10 iterations from the same location in the front, just zooming more and more):

[jehovajah]

Way to go ! Each different form has its own intrinsic interest and really shows that there is no standard 3d mandlebulb, because the extra degrees of freedom preclude that. When you get done it would be nice to see a catologue of the different types with the z²+c images then the interesting zⁿ+c images. Thanks Benesi. I am still figuring out how the generating programmes actually work using quaternion math and what limitations this puts on our freedom to render our conceptions,   if any.

[M Benesi]

  I was thinking about that earlier (due to a comment my father made):  Is there an infinite number of 3d Mandelbrot sets? 

  Rule 1:  The 3d set should be able to be reduced to the 2d set by elimination of the 3rd axis.
 
  In other words:  It should produce fractals that have exact correspondence to the 2d versions when viewed with z~0.

  If we only define 3d Mandelbrot by rule #1, we can make an infinite variety of 3d sets, all with different relationships between the z axis and the standard x-y axis manipulation of the 2d Mandelbrot.  This doesn't really lead to a satisfying definition, or a simple well defined standard for extension of Mandelbrot sets into higher dimensions.

  Setting the standard Mandelbulb's angles and rotations like this:

r=sqrt (sx^2+sy^2+sz^2);
theta=atan2(sqrt(sx^2+sy^2)+flip(sz));
phi=atan2(sy+flip(sx));

sx=r^n * cos (n*theta) * sin  (n*phi) +pixelr;
sy=r^n * cos (n*theta) * cos (n*phi) +pixeli;
sz=r^n * sin  (n*theta) +pixelj;                     //pixelr is x axis component of pixel, etc

Gives us a detailed elephant valley (haven't checked seahorse valley yet), in addition to other interesting fractal patterns. 

  Setting the angles and rotations as in the Mandelbulb B formula results in less interesting zooms in the elephant valley section of the fractal, but gives us a more interesting top/bottom section to explore.  It also gives us different bulbs to explore at higher z^n (z^4++).

[jehovajah]

I don't think we need to bother with standardisation. Leave that for the following generation of programmers and explorers and artists. Now is the time to be inspired and inspirational. I wondered if you had thought about Lie groups and how what you are doing might relate the mandelbrot to those and supersymmetry, and string theory. If you get time give it some thought.

[M Benesi]

I'd like to, but am not familiar with mathematical Lie groups.  For now, however, I have been inspired by your and others comments, and in general by the whole forum.  

  So here is another formula, one that rotates x axis vs the yz plane, y axis vs. the xz plane, and z axis vs. the xy plane.

  It is interesting, but starts out pretty plain at the z^2 area, as I've not got up into the 200th iteration (when the seahorse valley starts getting interesting).  I suppose this is a good place to put a teaser image to demonstrate the potential variety contained in the new formula.  This is a z^8 (8th order, as I call them) 10 iteration 3d fractal (zoomed pretty deep (especially for 10 iterations) in on some islands in this one quadrant (this is a set of tiny nubs off of a nub of a nub of a nub of a tiny island):



  This is based off of the kaleidoscope formula from earlier in this thread.  I was thinking that there had to be a way to create a fractal by rotating the components around the other 2 components planar magnitude, so went back to the old formula and tweaked it.  As the old formula was named "type D", I've gotten very original and named this one "type D2".  I suppose I should make a formula "type R"... so that I can modify it.
  I don't know why I didn't do this fractal thing earlier: I think I just didn't bother to zoom in enough (or set bailout correctly).  

MAKE SURE YOU SET BAILOUT HIGH, I set mine to 10^30, or you get a tiny little thing

  Pixel and variable assignment follow:
pixelr is the x component, as usual
pixeli is the y
pixelj is the z

pixelw is the yz planar component (I should name it plane_yz, but.. I didn't rewrite the formula yet)
  anyways:  pixelw= sqrt(pixeli^2+pixelj^2);
pixelv is the xz planar component:  pixelv=sqrt(pixelr^2+pixelj^2);
pixelu is the xy planar component: pixelu=sqrt(pixelr^2+pixeli^2);

I set all variables to their initial pixel components before beginning the iteration.  If you want to include a seed value, you can do so instead of setting the variables to the corresponding pixel and planar components.
sx=pixelr;    sw=pixelw;  // sw rotates with sx
sy=pixeli;    sv=pixelv;   // sv rotates with sy
sz=pixelj;    su=pixelz;   // su rotates with sz

  Here is the formula:
  One way to do it, checked it out, I don't think this method is "better" or even that much faster.  Not sure what the problem was (probably was running something in the background when I tried the other method).
r= (sx^2+sy^2+sz^2)^(n);    // I don't know why, but you basically get the same fractal if you split the components
r2=(sw^2+sv^2+su^2)^(n);    // like this, but for some reason it calculates a lot faster (I think it's because the
                                         // fractal is bigger)   
r=sqrt(r2+r)*.5;                   // I multiplied the magnitude by .5 to increase the size of the fractal...

You can just do this, but for some reason it's a lot slower and the details I've seen don't look that different:
r= (sx^2+sy^2+sz^2+sw^2+sv^2+su^2)^(n/2);

  A tangent (skip if you like):
  I also use an if statement to assign r=sqrt(sx^2+sy^2+sz^2) so I can make those cool kaleidoscopes I posted a bunch of earlier in this thread (it is the same code except for the magnitude).  There is one more mode I call "weirdmode" in which I set r=xyz and r2=wvu values and assign them to opposite variables: it's weird because you get these images that escape after about 2-3 iterations, totally solid, no change for higher iterations: but the images are interesting and different for different angles.  It's like completely solid mathematical objects or something (and I forgot the exact settings... bleh).... back to the formula:

phi=atan2(sw+flip(sx));       //  
tango=atan2(sv+flip (sy));
theta=atan2(su+flip(sz));
         
nx=r*sin(v*phi) ;
ny=r*sin(v*tango);     // you can just use whatever multiplier variable names you like
nz=r*sin(v*theta);     //  I used v for the xyz and mag for the wvu...  you can use only one, unless you like to mess
nw=r*cos(mag*phi) ;    // around... but there is enough variety in the stock fractals that.. well maybe there is
nv=r*cos(mag*tango) ;   // maybe we need another dimension
nu=r*cos(mag*theta) ;     // the 4d extension of this concept is pretty simple: just do 3d planes instead of 2d...
  
         
if (juliaMode) {
sx=nx+cr;
sy=ny+ci;     //  you gotta add in 3 more variables for julias... I haven't bothered yet, as you can see
sz=nz+cj;
   
} else {
sx=nx+pixelr;
sy=ny+pixeli;
sz=nz+pixelj;
sw=nw+pixelw;
sv=nv+pixelv;
su=nu+pixelu;
}

I just set bail= |sx+sy+sz|  because of the high cutoff, but... doesn't help much.  I haven't figure out why the bailout is sooooo high for this one.

  Or you can play with various bail formulas (I just have bail2=1 for the above), like a - bail1 and + bail2.. or whatever:

bail=abs(sw)^bail1*abs(sx)^bail2+abs(sv)^bail1*abs(sy)^bail2+abs(su)^bail1*abs(sz)^bail2;

  Now for some images of the new formula.  I messed around in the 2nd order one for a while, because it's just neat to find the patterns I found in a z^2 3d fractal.

  This is a series of zooms, from some location:








  Here are a few random images, a 23, 36, then 30 iteration z^2:


Here is another 30 iteration z^2 (done with the slower formula: what a pain):

[M Benesi]

  All right,

  I checked regular 2d Mandelbrot sets.  You get a lot more details in a z^8 at 50 iterations than you do in a z^2, which explains the lack of super duper details in the above images (and the fact that I am now getting high amount of details in z^13s of the "new" type D2 fractal at low iterations (8 and a 9 iteration of the same location, for the 9 iteration in the same location I had to exponentially increase z resolution, which makes for a slooooowwwwwww fractal calculation: i suppose the cure for this time of calculation problem is to zoom way in when you increase iterations).  Anyways, I'll include those 2 images later.

  For now, here are two 2d Mandelbrots, one z^2 the other z^8, both at 50 iterations.  The z^8 is zoomed in a lot more, and just a lot more detailed.  Even seahorse valley is a little boring at low iterations for the z^2.
z^2, 50 iterations:

z^8, 50 iterations:


  I'm not even going to bother to post the 20 iteration images: they have far more details in the z^8 than z^2 version.

  Here are a couple of 13th order images, first one is 8 iterations:

  This one is 9 iterations, had to increase z resolution a lot, still got clipping issues because I wasn't going to wait 4-8 hours to render it at higher resolution/checking/other time consuming variables:


  Here is a 2nd order image, 18 iterations of more or less a whole quadrant (1/8th of a sphere, basically... maybe a bit less) of the fractal:


  You can see that 18 iterations is a lot less detailed than.. well, how about I post a 8th order lower iteration of the same spot?  I'll edit it in when it's done.  Doing an 8 iteration (higher resolution though... details require it) 8th order version of the same location.

  Here is the 8th order, 8 iteration quadrant of the fractal:


  It's a little bit clipped, but you can see the massive increase in details for the lower iteration count 8th order fractal.  Maybe even cubic instead of quadratic...

I introduced a "bubblebrot" mode by taking the magnitude r=(sx^2+....+su^2)^(n/3).  Makes lots of little bubbles that you can zoom into.  Also, weirdmode is done by setting r=(sw^2+sv^2+su^2)^(n/2), a lot like mandelamode uses r=(sx^2+sy^2+sz^2).  Weirdmode produces some pretty neat images, especially if you set the planar values negative (pixelw= 0 - pixelw...).

  You can increase the size of your base fractal by dividing the magnitude (r) by a number (or multiplying it by a number smaller than 1... darhhh).  It doesn't seem to distort the z^8 that I'm looking at now, although it seems to increase the time to calculate for some images (but maybe not?), and for some reason now its taking less than 1/2 the time (I divided the value by 4, zoomed into the exact same location of the fractal, maybe off by a few pixels).  Of course, multiplication by a small number that is easily converted to base 2 may be advantageous as well...

[jehovajah]

Just a thought about the speed of these programmes: Does any one use  flags in the register for each iterated point to indicate if it is part of a sequence that  escapes or if it orbits? This would mean when the programme steps to that point it can skip the calculation calls as it already has determined this point is in the set 0r not. I know you add a flag look up call,but maybe overall this might save time?

[David Makin]

Just a thought about the speed of these programmes: Does any one use  flags in the register for each iterated point to indicate if it is part of a sequence that  escapes or if it orbits? This would mean when the programme steps to that point it can skip the calculation calls as it already has determined this point is in the set 0r not. I know you add a flag look up call,but maybe overall this might save time?

If not using distance estimation then that might help on Julia Sets.
It's actually a better optimisation for 2D Julias - if your Julia formula is particularly complicated/slow and you only want to render the entire Julia to a given resolution (say up to around 4096*4096) then you can use a snap-to-grid method with per-pixel flags and as soon as any orbit hits a pixel that's already been calculated then you can stop iterating for that point as you've already got the result for the rest of its orbit.
Doesn't help for Mandelbrots though

[M Benesi]

 Here are a few more of the new formula z^2 (2nd order) images.  I think it really depends on where you look in the fractal: there is fractally stuff all over, but the most interesting variety (at these low iterations) seems to be constrained to certain locations (like the 2d set).  
  These first three (sorry about the clipping, I set my checking point at 5% back to increase speed, which chops off sections of the fractal) are simple iteration increments:


This one is a blow up/zoom in of the above, with a higher iteration:

This is a zoom in on a section of the above, with higher z resolution, lower total resolution and slightly higher checking point percentage (a little bit less clipping):


  The last one, I am going to explore the twisty section on the right.  It's only 30 iterations, and already beginning to show signs of more interesting forms, which is good for a 30 iteration z^2 fractal (or so I assume).