Welcome to Fractal Forums

Many thanks to this wonderful forum and to David Making, who made my renderings work with DE  :D

Attached (i hope so, this i my first post, so i dont know what happens) is a rendering of the power2 bulb with a selfmade proggy, still under construction.

Downsampled from 2000x2000, calculation time was too long because i set the max iteration count to 555 and it hang a bit on the bottom of the bulb, where isnt any detail. More than 1 hour.

beautiful detail and colours.

I like the different shapes in the power 2 version, higher order bulbs becomes more "roundy".

Here is a power 3 in the positive Z version.

(If there is request, i can post the program i used. But some changes has to be done before.)

Beautiful renders. You have very good coloring and shading algorithm.

That coloring looks absolutely amazing! MOAR!!

Thank you, i am new to rendering, so a month ago they looked like crap  ;)
Maybe some experience in image processing helped.

Ok, some moar:

this bluish one is very interesting.
what formula you used?

with super-high iterations, the 2nd order Mbulb actually looks pretty much like THE Mbulb... :)

just wondering why no one posted it before... or I missed something?

@Jessy:

If you're using the smooth iteration DE then there is a faster method - basically Buddhi's suggestion here:

http://www.fractalforums.com/theory/a-new-simple-way-to-compute-de-for-any-trig-mandelbulb/msg11047/#msg11047 (http://www.fractalforums.com/theory/a-new-simple-way-to-compute-de-for-any-trig-mandelbulb/msg11047/#msg11047)

I've used it with the same method as the smooth iteration version i.e. get the final magnitude at step and at step+delta then use:

  dir = magn1 - magn
  DE = 0.3*@delta*sqrt(abs(@mpwr-1.0)))*magn*log(magn)/abs(dir)
 
I use changes in the sign of dir (from positive to negative) to check for "missed solid" when the option is enabled.
magn1-magn being zero needs testing for - in which case use a preset step distance (checked against the array if using that method) :)
 
I got the 0.3 by trial and error and I use:
 
  step = DE*(0.6/ @accuracy)
 
An @accuracy of 1 is fast but prone to errors and a value of 2 rarely produces errors.
 
Note the sqrt(abs(@mpwr-1.0)) - I found that using this makes it consistent using different powers in exactly the same way as it did for me using the analytical method.

I think it's faster because it only requires one log() call whereas the smooth iteration method needs at least 4, though it could be that in general the calculated distances are more accurate (but I doubt it) :)
If wanting to use smooth iteration for the colouring you now only need to calculate the value when solid is actually found.

Way back here:

http://www.fractalforums.com/3d-fractal-generation/true-3d-mandlebrot-type-fractal/msg4129/#msg4129 (http://www.fractalforums.com/3d-fractal-generation/true-3d-mandlebrot-type-fractal/msg4129/#msg4129)

And Lyc's rendering in the gallery:

http://www.fractalforums.com/gallery/?sa=view;id=160 (http://www.fractalforums.com/gallery/?sa=view;id=160)

I wonder how lyc's image would perform now as a lot was figured out by then.

Saw that pic back in 2008 and immediatedly loved it :D
I think, I kinda didn't realize that all the hype started in this forum, else I'd be in here since back then :)

I remember them, but they look bit different.
Maybe it's about perspective or as kram1032 said, iteration count.

the last one is my favourite 2nd order render so far :)

That is beautiful.  I'd love to see the whole thing from different angles and perspectives.  What if you crank iterations up to 1000?  Need help optimizing the math?  Care to post the code somewhere?  How about the iteration function?  What is the exact formula you are using for iteration?  Just standard mandelbulb?

Ted

Lovely renderings Jessy!

J

@Makin:

currently i use the 4 point method on the R-bailout values, so i should try it on the smoothed Iterations again. I did that before with only one delta, but didnt got the fine details.

Are you using 3 deltas or only one?
(Because this makes much more difference in the time consumption, i guess)

The array checking is also on the todo list, i hope that it can reduce time consumption without missing details...

Buddhi's results are really great, the shading i am using is:

(Ambient + Diffuse * HardShadow/2 + Specular * HardShadow) * SoftShadow
and fading to Background.

The soft shadow is nearly for free because i calculate it just from the Z values of the pixels, using wavelets.
Not perfect, but a good compromise between speed and realism.

@Walther:
It is the "standard" mandelbulb with -Z, a code snippet:

    if Option = MinusZ then O2 := -2 else O2 := 2;
    X1 := C1;
    X2 := C2;
    X3 := C3;
    S1 := X1 * X1;
    S2 := X2 * X2;
    S3 := X3 * X3;
    ItResultI := 0;
    repeat
      if S2 < 1e-40 then
      begin
        X3 := O2 * X3 * Abs(X1) + C3;
        X1 := S1 - S3 + C1;
        X2 := C2;
      end
      else
      begin
        XT := S1 + S2;
        X3 := O2 * X3 * Sqrt(XT) + C3;
        XT := (XT - S3) / XT;
        X2 := 2 * XT * X1 * X2 + C2;
        X1 := XT * (S1 - S2) + C1;
      end;
      S1 := X1 * X1;
      S2 := X2 * X2;
      S3 := X3 * X3;
      Rout := S1 + S2 + S3;
      Inc(ItResultI);
    until (ItResultI >= maxIt) or (Rout > RStop);
    Rout := Sqrt(Rout);
    if Rout <= 1 then
      SmoothItD := ItResultI
    else
      SmoothItD := ItResultI - Log10(Log10(Rout)) * LogC21d;


where LogC21d is:  1/Log10(2)
 

Missed one question:
the blueish "space-ship" is a quaternion:
    X1 := C1;
    X2 := C2;
    X3 := C3;
    X4 := 0;
    ItResultI := 0;
    repeat
      XT1 := X1;
      XT2 := X2;
      XT3 := X3;
      X1  := X1 * X1 - X2 * X2 - X3 * X3 - X4 * X4 + C1;
      X2  := 2 * (X2 * XT1 + X3 * X4) + C2;
      if Option <> 0 then X3 := 2 * (X3 * XT1 - XT2 * X4) + C3   //ship
                     else X3 := 2 * (X3 * XT1 + XT2 * X4) + C3; 
      X4 := 2 * (X4 * XT1 + XT2 * XT3);
      Rout := X1 * X1 + X2 * X2 + X3 * X3 + X4 * X4;
      inc(ItResultI);
    until (ItResultI >= maxIt) or (Rout > RStop);


RStop is the squared Rbailout, of course.

Hi
This thread encourages me to explore once again the 2nd order.
What do you think about this "triangle" effect that we often see in lower order? Is it an artifact or the real thing?
(http://www.fractalforums.com/gallery/1/492_15_01_10_7_46_41.jpeg)

I have also rendered this simple image to show the similarities that could exist between the 2D M-Set and its equivalent in the perpendicular cut plane. This shapes reveals very nice fractal patterns and very interesting similarities with the M Set (seahorse valley, minibrots (same shape as the whole but smaller and distorted), spirals, etc...). Has this fractal already been explored as a 2D fractal?
(http://www.fractalforums.com/gallery/1/492_15_01_10_7_50_34.jpeg)

I don't think you can use log10() - you need natural log() or ln() if you prefer.
Although logx(a)/logx(b) is the same for all x, logx(logx(a))/logx(b) is not.
Also instead of using 1/log(2) you should only use that when bailout occurs on the first iteration, otherwise instead of multiplying by 1/log(2) you should divide by log(log(Rout)/log(OldRout)) where OldRout is the magnitude from the penultimate iteration:

e.g.

    if Option = MinusZ then O2 := -2 else O2 := 2;
    X1 := C1;
    X2 := C2;
    X3 := C3;
    S1 := X1 * X1;
    S2 := X2 * X2;
    S3 := X3 * X3;
    ItResultI := 0;
    repeat
      oldRout := Rout
      if S2 < 1e-40 then
      begin
        X3 := O2 * X3 * Abs(X1) + C3;
        X1 := S1 - S3 + C1;
        X2 := C2;
      end
      else
      begin
        XT := S1 + S2;
        X3 := O2 * X3 * Sqrt(XT) + C3;
        XT := (XT - S3) / XT;
        X2 := 2 * XT * X1 * X2 + C2;
        X1 := XT * (S1 - S2) + C1;
      end;
      S1 := X1 * X1;
      S2 := X2 * X2;
      S3 := X3 * X3;
      Rout := S1 + S2 + S3;
      Inc(ItResultI);
    until (ItResultI >= maxIt) or (Rout > RStop);
;    Rout := Sqrt(Rout);  Omit this unless you need it for something else - the 0.5*ln does the same job faster
    if Rout <= 1 then
      SmoothItD := ItResultI
    elseif ItResultI<2
      SmoothItD := 1 + (Ln(0.5*Ln(RStop)) - Ln(0.5*Ln(Rout))) * LnC21d;
    else
      SmoothItD := ItResultI + (Ln(0.5*Ln(RStop)) - Ln(0.5*Ln(Rout))) / ln(ln(Rout)/ln(OldRout));
 
Using the actual divergence at bailout in this way is a lot more accurate.
Note that you can of course pre-calculate Ln(0.5*Ln(RStop)) - it's included because it's essential when using the calculated divergence.

@Makin:

Thank you for correction, also 5 ln's wont speed it up  :sad1:

I came around the unsteadyness by steering the Z position to a point where frac(smoothIt) becomes 0.5  ::)

Is there maybe a trick to get a gradient from one iterated position, so we dont need to calculate 4 positions. That would be cool.

The DE part is nearly the same as you posted, i also observed that in higher order bulbs you can use a slightly bigger step width.

@bib:

What great renderings, you are using photoshop with plugins iirc, so soft shading isnt possible?
I have to think about how this would further improve the quality.

The triangle effect, that can be also seen in a leave in one of my images, is surely a artifact from the DE - what my image belongs. Because if i set the DE step value lower, the triangles are becoming smaller. The beam just passes the very thin slides so you can see through it.

On the other hand, i am asking me if all these thin slides belongs really to the mandelset or if the gradient is only very high?

bib, what is the exact position of the rendering?

I'll tell you when I go back home and I will post the UF parameter file.

I'm just using UF and Dave Makin's WIP code. No post-processing. Usually I use Analytical DE, but recently I noticed that without analytical DE some more shapes appear, like the 2 branches on the side of the spike in your MinZp2 picture.

Without postprocessing, so you dont have to antialias?

I didnt got familiar with UF, but if i can speed up a little there is maybe an alternative for stills  :D

Hmm, is there a link to the analytical DE, i must have missed that one.


Just made a zoom on the outside, but took 2 hours:

UF does offer antialiasing, Id id'nt know AA is classified as post-processing. Imean I do not use another application than UF, but UF offers a lot of features, especially layers and mlerging mode (I guess very similar to Photoshop) but I mostly don't use these with my Mandelbulb renders.

My mistake about the "Spike with triangles" render : it was a 4th order, and here is the parameters:
Mandelbulb4Spike {
::cqEnFgn2thVyuROOS07FQ9PIoTdDXWp4mkyaAP0T7aAagq6umFg52YQpkKT1F1SrFnO9X/Ec
  RSUKtvYGBV84jBDGRwssXUMKUf+jfIIYsaUJ5hfT0cSqynU5B0ghuqfIDDuWda8CPhGHcRWd
  +yInmFHoE3k9DcUQZvoWCDyij14U2Nwx4oYUGhmlgJZMCOooXeqacgHK6HkNy/G6AieAHjiD
  /4HMAZoQhobsqthH+VtqAaYQbnooa8GHFHHUL7PLrbPJ5DtljKNRAdjXaPxrnUjVdihBzGpX
  0M0J6lNj8bSQVtorrq5sdJAtye+joIc8x4jJZpMcK+4h4IWW6xE0x0kMC64RWQt4cDHlmlSj
  opf8Dlt9wqIMgULetSjSWQnsv4is4H82yygyKlsB8F8wG51v9t/x1qOyTO7imKrD12Crf/Ne
  4/93+O5JYD298ocAc98mWY8LgHV7AQRxg0wl2rVNltwcaL7eu0ecNerDWj/T/k6WA5pA3JWf
  7oGuypTnlc0GDIPBL4hfP4vmqK+Rwb/vuHKCXnlCz+PnEwGqBWbYaMMt1+hWV1J+Tf5wvBzK
  0nNaC3L6c+9wv3W1Mq94dhuZerviHfI2avRxf+DtCQqtPva044SApZnINWPXuoS1ONCH0Yak
  z6hRR/oFuZpFssS8YjjqotZQ/hRkDRJWbNqgv+x4I8BvvCMBG21eFWZsBp6urAJgBnqeRHhx
  xzr/0g8pvYPYEFFTg36GHrtoq5U1woexd/xsaHKEwVoZ2rFEKlOGUjw0Yr2qBns+zHldc2Xe
  k6ElCIYCWetKLGw56oAiGwLf1wg8klSA70Y6gzsaNQsmQpjecmDrn40fOBcFZ94ml0Gd1LLV
  yCXgnOIco7isXuEspVZ2mwyrXb44aACVeTPs5sSCjte12+T6xWrEvK1fV4rf62ne7TX1RFVN
  6DW7y86N3534bXtmLqNLyjgvExc0uVpsX5h5hw6ZT0DfkwiY0DpsoUUqZXAB/98vDXc6gdDc
  EaxoSvN1HLlFKY8jWhcjAzs/17PLFAdolttRqsvFSegjWmOXA3xXlx2tjZoSWOuGzYU1bSSu
  +5k1PnkPW7PzYb3WjRmb3/SOc1baUOrcxvZkebOuXL4cQeI02Xpz9taAdd9pvH8UL8rQQ9XB
  66RgVUcqaawbTU0WnX1Ao2ca+yHcXuHS5CZy1uCYUwDBL5QMBFgg96yS0ax04qh/qZk+87vX
  zDrrLjgKSfGSq+8voGBdh2pie55zQ9k+qCd8iLpnRNYCkpsMv2Fur1aKeE+U1LBokZAGkwFK
  EmQZJrmbqrZHqTSCOj040ZN1iKILf3yXIg0GCIvxvbu9tCSlpSzXBPjwtRiOVVIXs70Ud9N+
  K367usmpH0IfddNOLqrF2TRzHDZljth3gkq9qJaf10LgXvD+ikl/Sn/W5LS1guyld3DlYgyj
  DbW4Sl4csLvysLIerPofIed/X3FvUwRL3AWH7hFaHWo9Yh2YeNcbEtiFS3NBzDO8O4wO48P+
  w+sD7DHIozn6hHx2lQgHkk9Mk4jHxHPCnQiSZb9e0dUkuHPqPe0dePQOJCaMxDQ2OAZ7Bktz
  Fy85IjTOGR2AYyOATeHnYiPJT8BMhjziQb8ip37FT3TyUfAT9BMFSKng35Fz2xxs94lZKH7w
  TPLbjfMjjOGls1RecHmH3j5ROejj8o3FNAzjcSSELZzWHFf/eHd3FGQjHbNz7hLInFRJ7DkQ
  3d35+LPIT3Lz4qnHv1PA6wsIy2zL0+rRo37eEo0HcsBcPkhbTQ7a7cHvzFK0d3oANZeIrnHt
  n3wdr4ojbDcR7vbhovHv13h8gX/Ne0UDOFqgltznweHmf3VNQDx/kU/Bxk7IPjTxRIb0nu0m
  qfum60oy01E/GINPcuyJUYJ81HKhyq/0wf1P+T3g2xhWy/5fOMo853Kb4Vngi7um7UtF8v2W
  YqqOX9eeZUuKv8fFeSSv4h/YEav7h/9Fxp2rDzzDlu2U3qAqNMX5/F3oO4tNugVTH8GDX7i1
  KO33N0jpTRm2ARduJqH+/MvghnXHmvOUpHO34KskRaD1d1ZSUo0tpjidjQ6y9GDzV6Wzc93o
  LLPXJT56GPSHA37Lc2XIfRw5BE12Nw/CerptDJAV9zc40IXHrwjNcdVYF69aixo48mpz9kMb
  HjUzkdhGmzcbkQrrrCtuOmxbEO7LkvSAFS/2M+fUWOIHNyL9OqgGHfk4sy0MNjdgYFButG7r
  GugmhXTKsHpwekC7TK8MpcYg925K8OShXJFelUYNposDJLY4ollTYfOR84ExjTktnHG5z+Tu
  wJyOORW5ExypZIWolRaDnI+ci6xJqjTOMo+uKqPno+ciujTb6MXRXdV0NciuhTUfOxccyBBz
  zVx85EznTMfOx840MKruK2KnYb4EbDnYe+CNtS8cVJecKxnTJ+cKZXceyOXVyKnSW5UyGOls
  PMPxCI84bIt6nX+1jKh0iFT5y+22RvfWH4NF0opCV48viD8eEa+jzvx5pqe4Jouf6klfKHdS
  R7vWiNRrOnTlYYOnQryWhtpgrMPVwLDo7nBylz4jfAeH998c2qz63lB8yM7QNw8LG3fF8A5X
  5EWg+xV9QngIMUVypGhm1nlkRywz6Jxm0h2pQpIcCiug0xZ9kjZpZMoun7npzfphMy2vPe5H
  xDr/0/vhtQmx
}

It's difficult to tell the position, because I use 2 coordinate systems simultaneously : the UF location, and the xyz target coordinates inside Dave's formula. The magnification is ~18000 for this one.

Ok, thanks. Dont know if i can get it to work with my evaluation version of UF.

I think i have found the analytic DE version, thats where the derivates are for.
So i have to go programming and less rendering... a last little zoom in the p8 bulb,
but i havent found very new shapes so far:

In order to compare, here are the 2 versions, first without Analytical DE, and then with:
(http://www.fractalforums.com/gallery/1/492_15_01_10_7_46_41.jpeg)
(http://www.fractalforums.com/gallery/1/492_15_01_10_8_07_42.jpeg)

Experimentally I could not find any really new shapes when zooming into different parts of the bulb. Only distorted shapes similar to the original zooming area. But I haven't explored from the inside.

Unfortunately no-one else can render this as we're the only ones with this version of my formula.

I'm very honored  :angel1:

The extra logs are just to make it more accurate :) (Actually using that method for bicomplex fractals then they're essential).

If you actualy check the number of steps taken along the ray then doing 4(analytic) or 8(delta) extra iterations to get the gradient is pretty minimal :)

Just to re-iterate that using the adaption of the analytical equation using the difference in magnitudes that I posted earlier is considerably faster than the smooth iteration method - typical accurate render of a full view of the degree 8 "-sine" Mandelbulb @640*480 on my 3GHz P4HT (distance threshold 1e-3 max.iter 400):

Analytical DE: 39 secs
Smooth Iter delta DE: 1 min 5 secs
Magnitude delta DE: 42 secs

The Smooth Iter and Magnitude renders were virtually identical.
In case it helps divide the times by 3 to give correct speeds on a 2GHz core2Duo :)

Edit: Just to add that Smooth Iter delta DE without using the run-time calculated divergence took 50 secs.

Yes, the values are now really smooth, but with some extra time consumption. And the method to stear to a frac part solves problems with the inaccuracy, so i am not sure if i have to use it. The smoothed values in the variable power function were really smooth, so i don't see a need here.

But what i dont understand:
I make in each step of the ray the 4 iterations to calculate a 3D gradient!
This takes much time and it sounds like you dont do this for each step?  ???

It is clear that the extra time, once the set is found, is not that much important.

Thanks

I think I may have been confused by your term "gradient" - I assumed you meant the 4 points used to get the surface normall, but I guess not :)

I basically iterate at step and at step+delta (assuming step is not "inside") and then calculate the smooth iteration value for these using:

smooth = iter + (log(0.5*log(bailout))-log(0.5*log(m)))/log(divergence)

in each case where m is the square of the final magnitude and divergence is either fixed or calculated.

Then I use:

Distance Estimate (DE) = 0.4/(1.0 + abs(smooth1-smooth0)/delta)

That's the value I check against the solid threshold, but is scaled to give a step distance if solid is not found:

step = DE*0.6/accuracy

Where accuracy is a user parameter - 1 for speed, 2 or more for accuracy (2 is normally sufficient but sometimes I use up to 4).

So while stepping I only calculate 2 iterations per step, if solid is hit then I find the boundary more accurately using a binary search and then finally iterate at the adjacent points on adjacent rays at the found distance and found distance + delta to get the DE for those - I assume all the DE values are correct so this gives me 5 surface points to average the normals from 4 triangles.
Note that I actually use the adjacent rays at 0.5 pixel offsets on the viewing plane rather than whole pixel by default, though the offset used is actually a user parameter.

Ah, that is exactly what i wanted to know, sorry for the confusion and many THANKS!  :D

So there must be a factor 2 in speed increasing left, at least  ;D ;D

Then i go back programming... :angel1: