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

[M Benesi]

  Allright, here is yet another one with the newest formula type, except I added signs to the w,v, and u values.  The thing is, instead of having the reflection over the x axis, I took into account whether z and y are positive or negative.  That might be the equivalent of taking the original 2d mandelbrot and having different values generated if y is positive or negative (no reflection over x axis): haven't thought about it enough yet, so this may be a hasty incorrect conclusion.  At very low iterations, it has complex repeated details.  We can increase repetition by using the original pixel assignments instead of the new ones, or simply making the new ones less complex (perhaps simplify it to what I said in the previous post: if pixeli*pixelj < 0 do the one thing, if not, do the other).

  We've got a very interesting beast here.

  I set values with  (need to look this over, feel free to):
   /* pixelw assignment  */

      if (pixeli<0 && pixelj<0) {      
             pixelw=0-sqrt(pixelj^2+pixeli^2);
      }
      else if (pixeli<0 && pixelj < abs(pixeli)) {
         pixelw= 0-sqrt(abs(pixelj^2-pixeli^2));
      }
      else if (pixeli<0 && pixelj >= abs(pixeli)) {
      pixelw= sqrt(abs(pixelj^2-pixeli^2));
      }    
                 else if (pixelj<0 && pixeli < abs(pixelj)) {
      pixelw= 0-sqrt(abs(pixelj^2-pixeli^2));
      }
                 else if (pixelj<0 && pixeli >= abs(pixelj)) {
       pixelw= sqrt(abs(pixelj^2-pixeli^2));
            } else {
       pixelw=sqrt(pixelj^2+pixeli^2);
      }
      
/* pixelv assignment  */

      if (pixelr<0 && pixelj<0) {      
         pixelv=0-sqrt(pixelj^2+pixelr^2);
      }
         else if (pixelr<0 && pixelj < abs(pixelr)) {
            pixelv= 0-sqrt(abs(pixelj^2-pixelr^2));
      }
         else if (pixelr<0 && pixelj >= abs(pixelr)) {
            pixelv= sqrt(abs(pixelj^2-pixelr^2));
      }  else if (pixelj<0 && pixelr < abs(pixelj)) {
          pixelv= 0-sqrt(abs(pixelj^2-pixelr^2));
      }else if (pixelj<0 && pixelr >= abs(pixelj)) {
          pixelv= sqrt(abs(pixelj^2-pixelr^2));
      } else {
         pixelv=sqrt(pixelj^2+pixelr^2);
      }
      
/* pixelu assignment  */

      if (pixelr<0 && pixeli<0) {      
         pixelu=0-sqrt(pixeli^2+pixelr^2);
      }
         else if (pixelr<0 && pixeli < abs(pixelr)) {
            pixelu= 0-sqrt(abs(pixeli^2-pixelr^2));
      }
         else if (pixelr<0 && pixeli >= abs(pixelr)) {
            pixelu= sqrt(abs(pixeli^2-pixelr^2));
      }  else if (pixeli<0 && pixelr < abs(pixeli)) {
          pixelu= 0-sqrt(abs(pixeli^2-pixelr^2));
      }else if (pixeli<0 && pixelr >= abs(pixeli)) {
          pixelu= sqrt(abs(pixeli^2-pixelr^2));
      } else {
         pixelu=sqrt(pixeli^2+pixelr^2);
      }

[M Benesi]

Here is a youtube of the old formula (pixelw=sqrt(pixeli^2+pixelj^2) rather than the above complicated sign assignments), which is basically a 3d mandala animation.

  You can use the old formula to make pretty mandala type things by setting bail1 and bail2 to opposite signed values at the same time having high bailout, low iterations, and I think you need to vary the wvu and xyz rotations.

  Of course, the new formula is just freaky.

<a href="http://www.youtube.com/v/n59GN4yEbT4&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/n59GN4yEbT4&rel=1&fs=1&hd=1</a>

[M Benesi]

  Here are 4 more pics from the new formula.  Order 3 and order 4.  Order 3 is rather boring.  Order 4 cooler.

  Haven't even altered the bail settings, or really messed with rotations a lot yet.  Although, I have been using only wvu bail=^2, and haven't even done xyz bail (I wonder if its totally different now that things are signed?).

  Here are the pics:

[M Benesi]

  And here is one with 2 xyz rotations and 3 wvu rotations, bail1 (wvu) = 1 bail2 (xyz) = -1

  Notice the demonic face on the right, and the angelic statue on the left.  Probably simply due to clipping (if you've looked at some of the 180 degree rotations I posted above, you can see that parts get clipped out due to my background detection).

[M Benesi]

One last round of pics of the new type tonight. 

  I extended it to 4d, and as you can imagine, it took a bit to write out and double check the +/i assignments for the variables.

  Extending the equations is the simple part...  But when you see the code for sign assignment.... sheesh.

  Here are a couple (not many, very tired, gotta eat some food and crash) of the new 4d variety.  Just changed the times a bit.

  I've gotta clean up the code, remove extra fractal test types, extra variables that were added, etc.  I think tomorrow I can, but maybe I'll be busy.

  Gotta decide whether to keep the extreme variation in signs, or make them simple and reduce fractal variety.  At the moment, the 2 sides of the fractal are just about day and night.  Both have interesting features, so it would be a shame to loose a quadrant of unique activity just to have a symmetric fractal.  On the other hand, some people like symmetry, but still desire more variety than the mandalaballs from the videos.  Maybe make 3 different varieties.. or more.  The basic knowledge is here in the thread, and I'll post the extended dimensional version for others to pick over in a bit. 

  Here are the 4d pics, at various (probably similar times), 2 of the standard 2 rotation (2nd order) at t1~.2, and I think 1 is what I've dubbed "mandala mode" (a checkbox in my parameter window).  Nothing pretty.  Just a demo of the additional possible weirdness.  A side note: takes longer to calculate these, so... these are lower resolution, I am on a laptop, after all. 

[M Benesi]

  From what I've been able to tell, we can have symmetry at the sacrifice of details included in the fractal.  I've done a bunch of quick and dirty math, and ended up with various results <-- that's pretty specific, ehh?

  We can make many specific symmetric fractal types, each with a quadrants detail repeated through all quadrants.  

  For a quick and dirty new look to the mandalas, reverse the sign from

pixelw= sqrt(pixeli^2+pixelj^2)    to...   pixelw= 0-sqrt(pixeli^2+pixelj^2)    // I wrote 0- because the software I am using does not recognize leading -

and do the same for pixelv and pixelu...

Another thing you could do is change the sign within the magnitudes of the mandala:
pixelw= sqrt(pixeli^2 + pixelj^2)    to...   pixelw= sqrt(pixeli^2 - pixelj^2)
which gives you another variety.

  Of course, you can combine the two as well (making the new magnitudes negative), or divide them into quadrants as I did in post 90.

  So, for now, it is time to clean up code, set up switches, or types (mandala +/-, mandala magnitude subtraction +/-, quadrant +/-....).

  Some input might help, or if a moderator takes these posts to a new thread, or maybe we should just start a new thread from the beginning (although it seems to be related to this threads topic).

  And here is a new type, I took the angles by squaring the x,y,z axis components, used the negative of mandalamode pixelw,pixelu,pixelv

pixelw= 0-sqrt(pixelj^2+pixeli^2)   
pixelv= 0-sqrt(pixelj^2+pixelr^2)
pixulu= 0-sqrt(pixelr^2+pixeli^2)


theta=atan2(su+flip(sz^2));  <--- squared z axis component
phi=atan2(sw+flip(sx^2));     <--- squared x axis component ... so on and so forth
tango=atan2(sv+flip (sy^2));

[M Benesi]

  Here is a simplified assignment for pixels w, v, and u, which is much easier to extend to higher dimensions:

pixelw=pixelj*abs(pixelj)+pixeli*abs(pixeli);  //abs(variable) means take the absolute value of the variable
pixelv=pixelr*abs(pixelr)+pixelj*abs(pixelj);  // don't know if there is a squaring function that preserves sign, or this
pixelu=pixelr*abs(pixelr)+pixeli*abs(pixeli);  // could be even simpler....

  if (pixelw<0) {
  pixelw=0-sqrt(abs(pixelw));
  }   else {
  pixelw=sqrt(abs(pixelw));
  }
  if (pixelv<0) {
  pixelv=0-sqrt(abs(pixelv));
  }   else {
  pixelv=sqrt(abs(pixelv));
  }
  if (pixelu<0) {
  pixelu=0-sqrt(abs(pixelu));
  }   else {
  pixelu=sqrt(abs(pixelu));
  }

  this is just for the complicated assignment ones.  Making a video that I will add to this post later.

  Matt

  Here is the link to the video.  Not exciting, just a bailout reduction video to show some details (by bailout amount) in a low iteration count new fractal type:
<a href="http://www.youtube.com/v/lAny0QDBBRQ&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/lAny0QDBBRQ&rel=1&fs=1&hd=1</a>

[Timeroot]

// don't know if there is a squaring function that preserves sign, or this
// could be even simpler....

I suppose it depends on the compiler and such, but in some cases pixelj^2*sign(pixelj) might be faster.

[M Benesi]

  Cool, I'll check and see.  

  Another thing I thought of is modifying the equation, leaving out calculating nw,nu,nv, and the pixelw,v,u values altogether and after:
sx= nx +pixelr;
sy= ny +pixeli;
sz= nz +pixelj;

doing:

sw=sy*abs(sy)+sz*abs(sz);
if (sw<0) {
sw= 0-sqrt(abs(sw));
} else {
sw= sqrt(sw);
}
.... same for sv and su values.  I wonder how that will look.    For later though, got to do tons of stuff tonight.

  Ok, here are a couple of images with the above modification.  Note that I also set angles with

theta=atan2(su+flip(sz^v1));  //changing v1 from 1 to 2 for the following images made relatively boring fractals.. interesting
phi=atan2(sw+flip(sx^v1));    // seems to make slightly "dark" looking fractals...
tango=atan2(sv+flip (sy^v1));  // the demon head fractal was a power 2 one as well

[jehovajah]

 Thanks jehovajah,

  I'm thinking we can accomplish that by taking a hybrid version between the mandalball (from mandala and mandelbrot/bulb and its spherical tendencies in higher rotations) and the mandelbulb/mandelbrot x/y.  

  Do the standard x,y things from mandelbulb/mandelbrot, but do the mandalball z axis equations (which generate reflections).  Gonna try it in a few hours after this current animation is done computing and I've done all that I have to get done.  Maybe after dinner I will have a few minutes.

  Can't get caught up now, so I'll try and just leave this message, in case I forget what I was going to try.. I'll probably see this again.  


  Hahaha, mid work out I thought: maybe we should differentiate pixelw, pixelu, pixelv components:
for pixelw, if pixeli and pixelj are the same sign, leave as is.  If they are the opposite:
pixelw=sqrt(abs(pixeli^2-pixelj^2))

  So basically, if pixeli*pixelj<0 ....   (do the same for other components)
  Of course, the later equations might need to be modified as well.  Back to the work out.  Try not to think about fractals. 

Are you kidding!  I see them in my sleep!!!.   

Anyway well done with what you are exploring so far. I am busy writing up polynomial rotations so i have missed a day, and my what i have missed. Will comment when i have more time but looks like the search is on!

[M Benesi]

  I'm wondering if these fractals are even Mandelbrot extensions into 3d.

  In 2d we rotate x values against y values, which, if we take this formula down to 2d we would be doing.

  In 3d we rotate x and sqrt(y^2+z^2), so in 2d we would rotate x and sqrt(y^2).. x and y.  I suppose this requires paper and pen, or at least a wxMaxima window so I can look at the interactions directly.

  That ideas thrown into the mix, so here is some more from the latest addition to the new fractal formula family, although it's the same exact fractal as above, I did an incremental bailout increase because I like the fractal and wanted to see it "grow".  I need anti-aliasing, and I set background detect to "Extremely Soft" which reduces calculation time but causes the clipping you see in many of the images I post- in other words, there are hard edges and a few noticeable clips.

<a href="http://www.youtube.com/v/UWgfAK4HmqA&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/UWgfAK4HmqA&rel=1&fs=1&hd=1</a>

  In the pic below, I set background detect (also altered magnitude (not rotation) by +.5, so that explains the slightly different features) to standard instead of extremely soft like in the video above.  I think this may be enough to redo the above video and eliminated clipping, but maybe not.  For now, I have tons of stuff to get done, so barring an exciting idea, will be away for a bit.

  matt

[vector]

Interesting pictures,
here´s another one, maybe we can take these attempts and efforts as some sort of brainstorming,
leading to nowhere or to an unexpected end:
In this, it is the mandelbulb algorithm, but now not adding the vector c as usual, but the vector c´,
the vector some sort of conjunctive to c, in relation to the equatorial plane, in which the original mandelbrot structure will shine up.
In that plane, the conjunctive vector will cincide with the original vector c-
it was just trying-

[jehovajah]

Looks good, so can you render alternate views?  Which algorithm are you using? Can you define your conjunctive to the equatorial plane?

@Mbenesi: can you control the reflections in the northerly directions? Maybe stop reflecting in the horizontal axis, so the bottom part can develop and be looked at in 3d?

[vector]

sorry, wrote a long reply, an error occured, now a shorter version:
with conjugated i mean the original vector c with x1,y1,z1 will be conjugated by taking -x1 instead of x1.
(In your programs it might be y1 or z1, your coordinate system is oriented differently, the vector will be symmetrical to the plane, for which phi is always zero in the mandelbulb algorithm, it is the equatorial plane, in which the mandelbrot structure will occure)
In the attached picture, the vector z´, which will be added at the end of each iteration, is reflected to this plane, but the determining its angle theta and phi, phi will be changed to 0.5, at last, the original value of phi will bechanged to -0.5*phi, torn towards the equatorial plane. But then also conjugate the value of the point znew, which we get as the result of squaring the triplex number(doubling theta and phi, squaring the length of this vector), so the result will be no more simple locodromic like spirals cut more trajectories in form of a "bretzel" an 8 .
the complete formula(working in fine chaospro) also attached

[vector]

viewing from a side