True 3D mandelbrot type fractal

[David Makin]

Hi again,

I abandoned trying to get DE working for the 4D ring I was using for the "real" 3D Mandelbrot and decided to try rendering it adding it as an option in the beta Julibrot formula that I posted which uses solid based on iteration density rather than solid based on iteration - it's not as optimum as using DE but considerably more optimum than plain iteration and produces results very similar to using DE.
So I did a test render of the same minibrot I did previously but this time allowing the rest of the Mandelbrot to appear in the background.
Here's the result:



http://www.fractalforums.com/gallery/?sa=view;id=695

[David Makin]

Another view - this time the "top" of the Mandy:



Or:

http://makinmagic.deviantart.com/art/Attempt-at-real-3D-Mandy-126306420

[David Makin]

Hi all, it's not simple, but I think solving this will give the derivative in general cases (where a solution is possible):

For deriving the derivative of 4 functions of 4 reals, we have:
 
 x1 = a(x,y,z,w)
 y1 = b(x,y,z,w)
 z1 = c(x,y,z,w)
 z2 = d(x,y,z,w)
 
We want the derivative of the system where:
 
 N.p = 0
 
Which is given by the limit(v->0) of:
 
( |          i                       j                      k                      l               | ).(x1,y1,z1,w1) = 0
  | a(x+v,y,z,w)-x1  b(x+v,y,z,w)-y1  c(x+v,y,z,w)-z1  b(x+v,y,z,w)-w1  |
  | a(x,y+v,z,w)-x1  b(x,y+v,z,w)-y1  c(x,y+v,z,w)-z1  b(x,y+v,z,w)-w1  |
  | a(x,y,z+v,w)-x1  b(x,y,z+v,w)-y1  c(x,y,z+v,w)-z1  b(x,y,z+v,w)-w1  |
  | a(x,y,z,w+v)-x1  b(x,y,z,w+v)-y1  c(x,y,z,w+v)-z1  b(x,y,z,w+v)-w1  |

All values treated as reals - obviously treating all values as complex would maybe provide a solution in cases where using reals does not.

Duh - OK this is just WIP - I guess my recollection of getting a normal was a little hazy, but maybe just omitting the bottom row of the matrix.....or make it 5*5 with the last column as ident ?

Aaaargh !! I really should think things through more before posting stuff:

[cKleinhuis]

cool stuff, you can use the feature 

for what do you need this ? as surface normal vector ? ... btw. how do you get the surface ? raytracing until volume is hit ? 

[David Makin]

cool stuff, you can use the <Quoted Image Removed> feature 

for what do you need this ? as surface normal vector ? ... btw. how do you get the surface ? raytracing until volume is hit ? 

I tend to rethink stuff from first principles - I don't have any high levels maths books and working it out myself is usually quicker than ordering books from the library
In this case I was considering the fact that for distance estimation (to be used in ray-tracing) we need the derivative of a formula and thinking about it I suddenly thought that that is very closely related to the normal to the surface - hence my calculation above.
In fact it turns out that if you calculate the 4*4 matrix above (below the i,j,k,l) to the limit of v then you get the transpose of the Jacobian so I guess I'm not completely off target

[David Makin]

Hi all, I just realised something - I never knew the derivation of distance estimation but I just realised that maybe using the normal to the object surface at some point (a) on the surface and a point (b) to be tested gives us a method to find the shortest distance from b to the surface.
At each iteration level we know equation of the surface and the distance from point b to the surface at that iteration will always be less than the distance of b to the surface at a higher iteration level (assuming our initial b is "outside").
Goes back to the " drawing board".......

[lycium]

Hi all, I just realised something - I never knew the derivation of distance estimation but I just realised that maybe using the normal to the object surface at some point (a) on the surface and a point (b) to be tested gives us a method to find the shortest distance from b to the surface.
At each iteration level we know equation of the surface and the distance from point b to the surface at that iteration will always be less than the distance of b to the surface at a higher iteration level (assuming our initial b is "outside").
Goes back to the " drawing board".......

hmm while i haven't completely understood the method you're proposing, i think it's not possible to infer global characteristics from local sampling: basically the normal can vary chaotically at any point inside the field of consideration, so we should not expect there to be a "straight line" to the point of nearest intersection, at any level of iteration. moreover i've found that with fractals there is never really a "surface" at all, making normals extremely troublesome to even estimate reasonably

[David Makin]

hmm while i haven't completely understood the method you're proposing, i think it's not possible to infer global characteristics from local sampling: basically the normal can vary chaotically at any point inside the field of consideration, so we should not expect there to be a "straight line" to the point of nearest intersection, at any level of iteration. moreover i've found that with fractals there is never really a "surface" at all, making normals extremely troublesome to even estimate reasonably

Ah, but what you're overlooking is that when rendering 3D fractals to a given iteration depth then the fractal "surface" we're rendering is not actually chaotic in itself, in fact for iterating z^2+c it's simply a high level polynomial.
And I meant getting the normal analytically not via local sampling.
If In(z^2+c) is the iterate at iteration n i.e. such that I1(z^2+c) is z^2+c, I2(z^2+c) is (z^2+c)^2+c then the surface at iteration depth n is given by:
|In(z^2+c)| = bailout
I did think that one alternative way of finding intersection for a fixed iteration depth is:
Given our ray is p+ad where p is the viewpoint and d is the unit direction vector then for a given In we could fully expand In to a polynomial, then substitute in p+ad as z then solve for a using the Newton to get the roots and the smallest positive real root is our intersection point but I suspect that method may be less efficient than it sounds even ignoring the complexity of getting the equation for say I20(z^2+c) I did wonder about using a modified Newton where on each iteration (n) of the Newton f(z) as z^2+c became In(z^2+c) instead and f'(z) became the derivative of In(z^2+c) instead of just 2z.

[David Makin]

Ok, did a higher res. still shot of the "true 3D" minibrot:



or:

http://makinmagic.deviantart.com/art/quot-Real-3D-quot-Minibrot-126708978

The minibrot is at approx. -1.76 on the real axis and is viewed from 30 degrees above and 60 degrees around (camera target point set slightly nearer the main cardioid).
Bailout was x^2+y^2+z^2+w^2>4 and the maximum iteration count allowed was 60, though solid was based on iteration density so rarely if ever would 60 iterations actually be used.
Rendered to disk in Ultra Fractal at a resolution of 3840*2880, time 1hour 51mins on a (heat impaired) 3GHz P4HT effectively in single-threaded mode due to the render being performed to a screen buffer in the global section of a UF formula.

Hope you guys like it

[David Makin]

I did wonder about using a modified Newton where on each iteration (n) of the Newton f(z) as z^2+c became In(z^2+c) instead and f'(z) became the derivative of In(z^2+c) instead of just 2z.

Actually make that using a modified Newton for finding a root of f(a)="|In(g(a))|-bailout" where a is alpha in p+ad where p is the camera viewpoint and d is the unit viewing direction vector... problem is our equation is:

c = p+ad
z = p + ad

|In(z^2 + c)| - bailout = 0

Note that here if In(z^2+c) is 4D then the || means x^2+y^2+z^2+w^2

So finding f(a) and f'(a) is not completely straightforward - I mean in particular what's say the derivative of |f(q)| where the function is quaternionic ? I guess you could write it as f(q)*conj(f(q)) ?? ... but then what's the derivative of conj(f(q)) ?

[David Makin]

Just for comparison with the "True 3D" Minibrot:

http://makinmagic.deviantart.com/art/Hypercomplex-Minibrot-126754381

http://makinmagic.deviantart.com/art/Quaternionic-Minibrot-126754860

[cKleinhuis]

cool, but the non-quaternionic method one looks very quadratic ... is it because of low iteration depth ?
or sampling errors ?

or ist it the used math ? ... anyway .... i would now be interested in a X/Z cut plane 2d version of the pseudo method,
or is it just the mandelbrot again ? ( as proposed ... )

greets
ck

[David Makin]

cool, but the non-quaternionic method one looks very quadratic ... is it because of low iteration depth ?
or sampling errors ?

or ist it the used math ? ... anyway .... i would now be interested in a X/Z cut plane 2d version of the pseudo method,
or is it just the mandelbrot again ? ( as proposed ... )

greets
ck

Hi, well if you look at the math for the "real 3D" "roundy version:

* | r   i   j   k
-------------
r | r   i    j   k
i | i  -r   k   j
j | j   k  -r  i
k | k  j   i  -r

Which gives z^2+c:

              xi = mx
              yyy = my
              zzz = mz
              mx = mx*mx - my*my - mz*mz - mw*mw + x
              my = 2.0*(my*xi + mz*mw) + y
              mz = 2.0*(mz*xi + yyy*mw) + zz
              mw = 2.0*(mw*xi + yyy*zzz) + w

Assuming the start value is always (0,0,0,0) then:

if we start with a 3D cut such that w=0 and from that a 2D cut such that zz is 0 then the iterate is reduced to:

              xi = mx
              mx = mx*mx - my*my + x
              my = 2.0*my*xi + y

if w=0 and y is 0 then it's reduced to:

              xi = mx
              mx = mx*mx - mz*mz + x
              mz = 2.0*mz*xi + zz

And if we take a 3D cut where y=0 (or zz=0) and a 2D cut where zz=0 (or y=0):

              xi = mx
              mx = mx*mx - mw*mw + x
              mw = 2.0*mw*xi + w

However, for example in the first two cases (i.e. a 3D cut where w=0) then although the 2D X-Y slice and 2D X-Z slice both are the 2D Mandelbrot Set any other rotation of a plane including the X axis around the X axis will result in other images.

For the "squarry" version the iteration depth was only 10 The above holds for the 2D slices in that case also (as the only difference is that in the full iteration it uses "mw = 2.0*(mw*xi - yyy*zzz) + w" instead of "mw = 2.0*(mw*xi + yyy*zzz) + w").

I hope that makes things clearer

[David Makin]

Hi, in case you miss them:

http://www.fractalforums.com/gallery/?sa=view;id=700

http://www.fractalforums.com/gallery/?sa=view;id=701

[David Makin]

Here's the minibrot for the "squarry" version:

http://makinmagic.deviantart.com/art/quot-Real-3D-quot-Minibrot-Squarry-126885372