Amazing fractal hybrid types

[M Benesi]

  Just messing around a bit with the formula, blended it with one of my old ones (type B).  Other blends (such as the standard Mandelbulb) may work as well... haven't really thought about it much.

  When you increase the type b rotations, it's good to set scalef to a lower value.  I'll post the code tomorrow, although it should be around here somewhere.

[kram1032]

great impact by just a single iteration increase!

Nice

[M Benesi]

  I found that decreasing the scale factor reduces the complexity per iteration, which is probably important for higher order (z^n++, increased rotation multipliers, whatever you call 'em) versions of this.

  Initialize the following parametric variables with whatever you like:
check.default= 1
fold.default=2
fixedRadius.default=1
minRadius.default=.5
pt.default=1   /* to set trig "planar" exponent  */
lt.default=1   /* to set trig "linear" exponent  */
mag.default=2  /* set "planar" rotations  */
v.default = 2   /* set "linear" rotations   (not really planar or linear... just call 'em that because... because...  */
n.default= 2   /* to set magnitude.. generally match the rotations, but do whatever you want... really   */
bail2.default=whatever   /* if you use bailcontrol mode, you need to set a value for your bail exponent */

  

Code:

if (fractaltype=="Tglad Typo B") {
	/* fold box onto itself  */
         if (sx > check) {
            sx = fold - sx;
	} else if (sx<0-check) {
            sx = 0-fold - sx;
	}

        if (sy > check) {
                sy = fold - sy;
	} else if (sy<0-check) {
                sy = 0-fold - sy;
	}

         if (sz > check) {
                sz = fold - sz;
	} else if (sz<0-check) {
                sz = 0-fold - sz;
	}
			
 /*fold sphere onto itself   */
        r = (sx^2+sy^2+sz^2);
        if (r < sqr(minRadius)) {
                r1=(sqr(fixedRadius)/sqr(minRadius));   /* can initialize this, not repeat in loop, and other constants */
	        sx=sx*r1;
		sy=sy*r1;
		sz=sz*r1;
			 
	} else if (r < fixedRadius) {
                r1=(sqr(fixedRadius)/(r));
                sx=sx*r1;
		sy=sy*r1;
		sz=sz*r1;
	}
			
       if (r1mode) {
		   sx=sx+pixelr;
		   sy=sy+pixeli;
		   sz=sz+pixelj;
	           r=(sx^2+sy^2+sz^2)^(n/2);	
	} else {
		if (r2mode) {
		        r=r^(n/2);
		} else {
			r=(sx^2+sy^2+sz^2)^(n/2);
		}
         }


	theta=atan2(sx^pt+flip(sy^lt));   /* throw an if statement in here to eliminate extra calculations... remove the exponents  */
	tango=atan2(sx^pt+flip(sz^lt));  /* if pt = 1 && lt = 1    */
		  
	sx=r*cos(theta*mag)*scalef+pixelr;
	sy=r*sin(theta*v)*scalef+pixeli;
	sz=r*sin(tango*v)*scalef+pixelj;
		
        if (bailcontrol) {	
		bail=abs(sx)^bail2+abs(sy)^bail2+abs(sz)^bail2;
        } else {
		bail=sqr(sx)+sqr(sy)+sqr(sz);
	}
}

  The images are from the z^8, file names have the various variables in them.  Just a -90 degree horizontal rotation, followed by a zoom in on the central point and increased iterations from a low low 4 to a whopping 6.  

[M Benesi]

 Amazing Hybrid D kicks ass.   Note that I think I had it set up so it DIDN'T account for the "fold sphere in half" code for some of the earlier images.  Might need to have that as an option... yup.

Code:

/* fold box onto itself  */
        if (sx > 1) {
                sx = xfold - sx;
	} else if (sx<-1) {
                sx = 0-xfold - sx;
	}

        if (sy > 1) {
                sy = yfold - sy;
	} else if (sy<-1) {
                sy = 0-yfold - sy;
	}

        if (sz > 1) {
                sz = zfold - sz;
	} else if (sz<-1) {
                sz = 0-zfold - sz;
	}

             /*fold sphere onto itself   */
        length = sqrt(sx^2+sy^2+sz^2);

        if (length < minRadius) {
                t1=(sqr(fixedRadius)/sqr(minRadius));
		sx=sx*t1;
		sy=sy*t1;
		sz=sz*t1;
	} else if (length < fixedRadius) {
                t2=(sqr(fixedRadius)/sqr(length));
                sx=sx*t2;
		sy=sy*t2;
		sz=sz*t2;
	}
			
			
	theta=atan2(sx+flip(sqrt((sqr(sz)+sqr(sy)))));
	phi=atan2(sy+flip(sqrt((sqr(sx)+sqr(sz)))));
	tango=atan2(sz+flip(sqrt ((sqr(sx)+sqr(sy)))));
			
			
	sx=length^n*cos(mag*theta)*scalef+pixelr;
	sy=length^n*cos(mag*phi)*scalef+pixeli;
	sz=length^n*cos(tango*mag)*scalef+pixelj;
			
	bail=sx^2+sy^2+sz^2;

3rd order images:




8th order (BORING ALERT, the EVEN numbers are slightly boring (maybe not when zoomed into, but...):


9th order top:

9th order side:


13th order top (pretty similar initial structure to 9th order.. who knows):


  The last one reminded me of Alundra.  Great game.

  Here are a couple deep zooms into the side of the 13th order (basically, I realized that the fractal was sooooo complex that I needed to get closer to it to avoid lots of crazyness, and increase z-resolution dramatically):

  These last 3 (part of the "couple of zooms" I mentioned before...) are from a totally zoomed location near Santa's ear? head? beard?  in the above image.  First one is the same # of iterations, 2nd is 1 more, 3rd is 2 more.  I lose coherence on the third image despite setting the z resolution (depth) to ~64*2^10 * x_resolution because I didn't zoom in enough.

Here is a z^2 one, the Crown of the Fractal Lord  <-- nerd etiquette demands this name:


  I really like this blob in the julia of it...  series of zooms and iteration increases followed by a second blob within the first blob.

[twinbee]

Wow! This is looking very promising.

Who could've thought multiple formulas could coexist like this!

[M Benesi]

  I tried to hybridize with Msltoe's Serpinski type, but it didn't turn out as awesome.  I like the Amazing D variety... seems like a great new type.

  This one works out well...  lots of variety.