I need some help in Mandelbulber development

[Buddhi]

Hi

As you see development of Mandelbulber has slowed down last months. Now I don't have enough time for sitting by my computer because of some personal issues and in few months I will have less free time than today So that's why I'm asking for

Generally what I need:
- some C++ sources for new interesting fractal formulas (not only mathematical ideas). I'm not so good mathematician, so it's difficult for me to derive formulas.
- code optimization and cleaning up
- GUI improvement
- preparing of DEB packages (for easier instillation Linux)
- preparing of better Windows installer
- program debugging

It's too much for me now.  If somebody is interested in contributing in my project with me and I will give direct access to SVN repository.

I'm not postponing development of program, but I'm limiting my activities. I still want to drive this project.

I will be very thankful if somebody helps me.
 

[cytotox]

Hi Buddhi

Unfortunately, I am not qualified to be of any help. However, you might want to post this plea for support somewhat higher up in the topics' structure (i.e., in 'Mandelbulb Software' or '3D Fractal Generation'). I am sure that there are more - knowledgable and possibly helpful - people populating these 'higher order' threads ...
 

[David Makin]

I'd love to help with Mandelbulber but I'm so pushed for time myself that I haven't created a new fractal image in about a year
I don't even have as much time to work on converting i.Candy to OSX as I would like
Also I now only want to work from a Mac platform using Xcode as far as development is concerned.

[MackTuesday]

I think it would be interesting to try offsetting the center of the spherical folding operation in the Mandelbox fractal.  It would be a simple generalization of the formula.  Instead of

Code:

length = sqrt(x² + y² + z²)

//spherical folding
if(length < minRadius)
{
    x = x * fixedRadius² / minRadius²
    y = y * fixedRadius² / minRadius²
    z = z * fixedRadius² / minRadius²
}
elseif(length < fixedRadius)
{
    x = x * fixedRadius² / length²
    y = y * fixedRadius² / length²
    z = z * fixedRadius² / length²
}

you'd have

Code:

length = sqrt(x² + y² + z²)

//spherical folding
x += xOffset
y += yOffset
z += zOffset
if(length < minRadius)
{
    x = x * fixedRadius² / minRadius²
    y = y * fixedRadius² / minRadius²
    z = z * fixedRadius² / minRadius²
}
elseif(length < fixedRadius)
{
    x = x * fixedRadius² / length²
    y = y * fixedRadius² / length²
    z = z * fixedRadius² / length²
}
x -= xOffset
y -= yOffset
z -= zOffset

By the way, do you have that square root and all those divides in the actual code?  They aren't all necessary.

[Buddhi]

I think it would be interesting to try offsetting the center of the spherical folding operation in the Mandelbox fractal.  It would be a simple generalization of the formula.  Instead of

Thank you for interesting idea. I have just implemented in Mandelbulber. It gives interesting results.

[MackTuesday]

Awesome!  I can't wait to see the result.

I have downloaded the source to see if there are any obvious optimizations.  So far I've looked in fractal.cpp, common_math.cpp, and algebra.cpp.  I found a few things.

First, there are a number of places were the code does something like

Code:

a = 2.0 * b * c

where

Code:

temp = b * c
a = temp + temp

is likely faster.  Also I noticed your rand function does something like

Code:

return rand() % (max - 1)

If max < 65536 and rand() generates 16 bits instead of 31 or 32 you can do

Code:

return (rand() * (max - 1)) >> 16

This is likely faster.  It's also better because it gives the highest bits rather than the lowest, which are more random in the type of pseudorandom number generator used by rand().  In fact, you might prefer to implement rand() yourself.  It's quite easy and saves an extra function call if you declare it inline:

Code:

static unsigned buddhi_rand_seed = 4632784;  // you can initialize this any way you like
inline unsigned buddhi_rand()
{
    buddhi_rand_seed = buddhi_rand_seed * 1103515245 + 12345;  // This is the exact formula used in gcc's rand()
    return buddhi_rand_seed & 0x7fffffff;  // gcc's rand returns bits 0 to 30; that's the reason for the mask
    // If you use either of the following instead you can use multiply-shift instead of the % operator
    // return (buddhi_rand_seed & 0x7fffffff) >> 15;
    // return buddhi_rand_seed & 0xffff;
}

[marius]

First, there are a number of places were the code does something like

Code:

a = 2.0 * b * c

where

Code:

temp = b * c
a = temp + temp

is likely faster.

First rule of optimization: profile!

I'd vote for legibility and defer to the compiler to optimize at the instruction sequence level; gcc isn't that bad anymore.
You might be able to beat it with carefully chosen sse3+ sequences for the DE loops but on simple arith and logic code it's hard to beat.

[DarkBeam]

Code:

			case menger_sponge:
			{
				double temp;
				z.x = fabs(z.x);
				z.y = fabs(z.y);
				z.z = fabs(z.z);
				if (z.x - z.y < 0)
				{
					temp = z.y;
					z.y = z.x;
					z.x = temp;
				}
				if (z.x - z.z < 0)
				{
					temp = z.z;
					z.z = z.x;
					z.x = temp;
				}
				if (z.y - z.z < 0)
				{
					temp = z.z;
					z.z = z.y;
					z.y = temp;
				}

				if (Mode == colouring)
				{
					double length2 = z.Length();
					if (length2 < min) min = length2;
				}

				z *= 3.0;

				z.x -= 2.0;
				z.y -= 2.0;
				if (z.z > 1.0) z.z -= 2.0;
				r = z.Length();
				tgladDE *= 3.0;
				break;

It's a bit incomplete.

The original formula is;

Menger3(x,y,z){
   r=x*x+y*y+z*z;
   for(i=0;i<MI && r<bailout;i++){
      rotate1(x,y,z); (I think pre-rotation is done with another system in your program)

      x=abs(x);y=abs(y);z=abs(z);
      if(x-y<0){x1=y;y=x;x=x1;}
      if(x-z<0){x1=z;z=x;x=x1;}
      if(y-z<0){y1=z;z=y;y=y1;}

      rotate2(x,y,z); // (is missing)
    
      x=scale*x-CX*(scale-1);
      y=scale*y-CY*(scale-1);
      z=scale*z;
      if(z>0.5*CZ*(scale-1)) z-=CZ*(scale-1);
      
      r=x*x+y*y+z*z;
   }
   return (sqrt(x*x+y*y+z*z)-2)*scale^(-i);
}

Okay then. For MengerKoch, modify as follows;

Menger3(x,y,z){
   r=x*x+y*y+z*z;
   for(i=0;i<MI && r<bailout;i++){
      rotate1(x,y,z);

      x=abs(x);y=abs(y);z=abs(z);
      if(x-y<0){x1=y;y=x;x=x1;}
      if(x-z<0){x1=z;z=x;x=x1;}
      if(y-z<0){y1=z;z=y;y=y1;}

      rotate2(x,y,z);
      if(edgex>0) x=edgex-abs(edgex-x) // Thanks Syntopia for the exact formula!
       // By default use edgex=1 and all other = 0
       if(edgey>0) y=edgey-abs(edgey-y)
       if(edgez>0) z=edgez-abs(edgez-z) // edgez is not implemented in MB3D jet!
      // By default use scalex=1 - scaley=0 - scalez=1/3
      x=scale*x-CX*(scale-1);
      y=scale*y-CY*(scale-1);
      z=scale*z;
      if(z>0.5*CZ*(scale-1)) z-=CZ*(scale-1);
      
      r=x*x+y*y+z*z;
   }
   return (sqrt(x*x+y*y+z*z)-2)*scale^(-i);
}

[Syntopia]

Okay then. For MengerKoch, modify as follows;

Hi, DarkBeam, what exactly is a MengerKoch? Do you have an image or thread link?

I tried your formula and got some nicely pertubated Mengers (like the attached), but they are not very koch'y, I'm afraid.

[DarkBeam]

Tried to invert as I suggested?

You should get something like it ; (if not able to do so please contact me via pm!)

Be careful with cscale settings they are very important!

[Buddhi]

Tried to invert as I suggested?

You should get something like it ; (if not able to do so please contact me via pm!)

Be careful with cscale settings they are very important!

I will try this formula next week. Now I'm working on other topic. With one of "upstrems" we are making Mandelbulber as a Debian package. Mandelbulber will be in Debian repository. Second thing, what I'm also doing now is Windows installer for Mandelbulber. It's almost done (I'm using InstallJammer which is on GPL licence).

[DarkBeam]

Tried to invert as I suggested?

You should get something like it ; (if not able to do so please contact me via pm!)

Be careful with cscale settings they are very important!

I will try this formula next week. Now I'm working on other topic. With one of "upstrems" we are making Mandelbulber as a Debian package. Mandelbulber will be in Debian repository. Second thing, what I'm also doing now is Windows installer for Mandelbulber. It's almost done (I'm using InstallJammer which is on GPL licence).

That's okay Kriz (can I call you so? ) since I don't even remember the exact formula, hope Syntopia helps

You can also ask to visual http://www.fractalforums.com/3d-fractal-generation/fragmentarium-an-ide-for-exploring-3d-fractals-and-other-systems-on-the-gpu/msg32167/#msg32167 <- he rendered my fractal successfully

[Syntopia]

Tried to invert as I suggested?

Ah, I found the combination :-)

Code:

if (edge.x > 0) z.x = edge.x-abs(edge.x-z.x)  ;

This also explains why the structure vanish even for very small edge.x values (e.g. 0.00000001)

[DarkBeam]

Cool! Now we have the exact formula, fixed my post too

[Buddhi]

I have implemented MengerKoch formula as an option for general IFS formula. It looks exactly the same like Syntipia's version. Thank you for details about this formula.