To continue with test renderings, here's a 1920x1080 view of the tail end of the
power 8, iteration 7 mandelbulb.  [WARNING: 3MB]

To fill the shadows, I've found using radiosity renders quicker than adding even
a tiny area light.

Also, recursive anti-aliasing seems to make the best images.  When using lower
radiosity for darker shadows, the settings +A0.5 +AM2 +R2 -J work well.

Post a reply to this message

Attachments:
Download 'mb8i7_tail.png' (3322 KB)

Preview of image 'mb8i7_tail.png'

This is the first image I'm really happy with, another view of the tail end of
the power eight mandelbulb after six iterations.  Although I forgot to save the
rendering information for this image, it took about as long as other similar
images with my latest mandelbulb isosurface SDL function, about eight hours on
an eight-core Linux machine using an unpatched POV-Ray beta with radiosity and
recursive anti-aliasing -J +A0.5 +AM2 +R2.  For those interested, I've posted
some more images on my website.

http://wiki.waggy.org/dokuwiki/mandelbulb

Cheers!

Post a reply to this message

Attachments:
Download 'mb8i6_tail_up_1920q4.png' (2813 KB)

Preview of image 'mb8i6_tail_up_1920q4.png'

>waggy  on date 05/12/2009 19:12 wrote:
> This is the first image I'm really happy with, another view of the tail end of
> the power eight mandelbulb after six iterations.  Although I forgot to save the
> rendering information for this image, it took about as long as other similar
> images with my latest mandelbulb isosurface SDL function, about eight hours on
> an eight-core Linux machine using an unpatched POV-Ray beta with radiosity and
> recursive anti-aliasing -J +A0.5 +AM2 +R2.  For those interested, I've posted
> some more images on my website.
> 
> http://wiki.waggy.org/dokuwiki/mandelbulb
> 
> Cheers!
> 
> 
> 
> 
> ------------------------------------------------------------------------
> 
The animation is impressive.
Paolo

Post a reply to this message

I found a way to make "hybrid" mandelbulbs combining two different powers.  It's
a simple adjustment with no practical impact on computational time.

newx = r^n1 * sin(theta*n1) * cos(phi*n2)
newy = r^n1 * sin(theta*n1) * sin(phi*n2)
newz = r^n1 * cos(theta*n1)

As a sample, I attached a test render of an 8,4-power mandelbulb.

Post a reply to this message

Attachments:
Download 'mb84_full.png' (327 KB)

Preview of image 'mb84_full.png'

The smoothing function I'm using can give an interesting dissolution effect as
well as "free" iterations, and I attached an image to illustrate this.

The iteration level of the power-8 mandelbulb shown varies smoothly from two at
the bottom to six at the top, though the iterating function never went beyond
the four iterations shown in the middle.  The return value after four iterations
can be used to generate a reasonably accurate isosurface of up to about five
iterations.  The number of "free" iterations increases with the number of actual
iterations (the max_iteration parameter).

Beyond those accurate "free" iterations, the smoothing function returns values
that can be used for the interesting dissolution effect seen toward the top.

On another note, I'm satisfied enough with the function to recode it in C++ and
compile it into the current POV-Ray beta.  Preliminary results indicate about a
5-6x speedup over the recursive SDL version.  After a bit more testing I'll post
the patch to the appropriate newsgroup.

Post a reply to this message

Attachments:
Download 'mb8i4q1_vary_i.png' (293 KB)

Preview of image 'mb8i4q1_vary_i.png'

waggy wrote:
> I found a way to make "hybrid" mandelbulbs combining two different powers.  It's
> a simple adjustment with no practical impact on computational time.
> 
> newx = r^n1 * sin(theta*n1) * cos(phi*n2)
> newy = r^n1 * sin(theta*n1) * sin(phi*n2)
> newz = r^n1 * cos(theta*n1)
> 
> As a sample, I attached a test render of an 8,4-power mandelbulb.
> 
Woops.  I think the image is of a n1=p_theta=4, n2=p_phi=8 'bulb.  It 
was late.

Also, I did a little experimentation (with the SDL version), and it 
looks worthwhile to allow three independent powers, like this.

newx = r^p_r * sin(theta*p_theta) * cos(phi*p_phi)
newy = r^p_r * sin(theta*p_theta) * sin(phi*p_phi)
newz = r^p_r * cos(theta*p_theta)

Now I need to refigure what log base to use for the smoothing function 
(it was originally just base "p"), then recompile...again...

Would it be worthwhile to add two functions, f_mandelbulb() for the 
single-powered 'bulb, and f_mandelbulb3() for the multi-powered one? 
I'm thinking of just specifying the triple-powered version, and leave it 
to users to declare a single-power function if they so desire...

#declare my_mandelbulb = function(x,y,z, my_power,
       my_i_bailout, my_r_bailout)
{
    f_mandelbulb(x,y,z, my_power,my_power,my_power,
       my_i_bailout, my_r_bailout)
};


P.S.  I've switched to using a "p" to indicate the [p]ower (as is done 
in some of the literature) to avoid confusion with the [n]umber of 
iterations.

Post a reply to this message

Here, a cylindrical coordinate transformation splits the power 8 'bulb at the
seam, and unrolls it endlessly along the x-axis.  It might make a nice cornice
or something.

It's called like this.

isosurface{
    function{f_mandelbulb(y*cos(x),y*sin(x),z, mb_power_theta, mb_power_phi,
int(mb_iterations-1), mb_rdiverge)}
....
  contained_by{box{<-100*pi,0,-1.2>,<2*pi,1.2,1.2>} }
....
}

Post a reply to this message

Attachments:
Download 'mb8i5q0_unrolled_640a.png' (307 KB)

Preview of image 'mb8i5q0_unrolled_640a.png'

waggy wrote:
> Here, a cylindrical coordinate transformation splits the power 8 'bulb at the
> seam, and unrolls it endlessly along the x-axis.  It might make a nice cornice
> or something.
> 
> It's called like this.
> 
> isosurface{
>     function{f_mandelbulb(y*cos(x),y*sin(x),z, mb_power_theta, mb_power_phi,
> int(mb_iterations-1), mb_rdiverge)}
> ....
>   contained_by{box{<-100*pi,0,-1.2>,<2*pi,1.2,1.2>} }
> ....
> }
> 
> 
> ------------------------------------------------------------------------
> 
And this is what everyone on the fractal forums is missing - artistic 
modifications of the shape just for fun. I can see this type of mapping 
producing some very interesting shapes!

I'm very much hoping that your f_mandelbulb() is included in the next 
beta, so I can start playing with it. Using the df3 approach is limiting 
the resolution for me too much now, and taking way too much time/space 
for what can be done better this way.
I'd use the patch now, but don't have the ability to compile windows 
builds, and I haven't had luck extending the expiration on home-compiled 
linux builds.

Once the number of entries bug is fixed in color_map I'll post my 
Fractint color map to pov color map converter, which will let you take 
generated maps from ApoMap (and Apophysis itself). Should be a fun way 
to get more coloring.

Post a reply to this message

The following code is not very inefficient, but it demonstrates how you can
render the Mandelbulb in POV-Ray as an isosurface using recursive functions:

// Quadratic Mandelbulb: runtime: 4.5 minutes
camera{location <-2.5,5,5> look_at <-0.5,0,0.25> up z sky z angle 25}
light_source{20*z,1}
#declare f=function(i,x,y,z,xc,yc,zc) {select(i>0 & x*x+y*y+z*z<4, 0,
sqrt(x*x+y*y+z*z),
f(i-1,(x*x-y*y)*(1-z*z/(x*x+y*y))+xc,2*x*y*(1-z*z/(x*x+y*y))+yc,-2*z*sqrt(x*x+y*y)+zc,xc,yc,zc))};
isosurface{function{f(24,x,y,z,x,y,z)} threshold 2 max_gradient 10
contained_by{sphere{<-0.5,0,0>,2}} pigment{rgb 1}}

// Power Mandelbulb: runtime: 28 minutes
camera{location <1.75,4,5.5> look_at 0 up z sky z angle 25}
light_source{20*z,1}
#declare n=8;
#declare f=function(i,x,y,z,xc,yc,zc) {select(i>0 & x*x+y*y+z*z<4, 0,
sqrt(x*x+y*y+z*z),f(i-1,pow(x*x+y*y+z*z,n/2)*cos(n*atan2(y,x))*cos(n*atan2(z,sqrt(x*x+y*y)))+xc,pow(x*x+y*y+z*z,n/2)*si
n(n*atan2(y,x))*cos(n*atan2(z,sqrt(x*x+y*y)))+yc,-pow(x*x+y*y+z*z,n/2)*sin(n*atan2(z,sqrt(x*x+y*y)))+zc,xc,yc,zc))};
isosurface{function{f(24,0,0,0,x,y,z)} threshold 2 max_gradient 1000
contained_by{sphere{0,1.5}} pigment{rgb 1}}

I also posted this sample code here:
http://www.bugman123.com/Hypercomplex

Post a reply to this message

Attachments:
Download 'mandelbulb.jpg' (47 KB)

Preview of image 'mandelbulb.jpg'

Also, here is some code for a Mandelbrot - Tricorn:

camera{location <-3.5,5,4> look_at <-0.5,0,0.4> up z sky z angle 25}
light_source{20*z,1}
#declare f=function(i,x,y,z,xc,yc,zc) {select(i>0 & x*x+y*y+z*z<4, 0,
sqrt(x*x+y*y+z*z), f(i-1,x*x-y*y-z*z+xc,2*x*y+yc,-2*x*z+zc,xc,yc,zc))};
isosurface{function{f(24,x,y,z,x,y,z)} threshold 2 max_gradient 25
contained_by{sphere{<-0.5,0,0>,2}} pigment{rgb 1}}

Post a reply to this message

Attachments:
Download 'tricorn.jpg' (22 KB)

Preview of image 'tricorn.jpg'