Welcome to Fractal Forums

I've been doing quite a bit of testing on my Buddhabrot generator with new and unique techniques and I figured this would be a good place to post them.

This first image stemmed from this thread in which cbuchner1 shows is fantastic Buddhabrot spectral renders! http://www.fractalforums.com/images-showcase-(rate-my-fractal)/buddhabrot-reinvented/

I experimented with such a technique but ran into some roadblocks, particularly in the way that my plugin is coded versus his would require quite an overhaul for a similar treatment. However, that led me into trying out HSV spectral coloring techniques and the results turned out nicely. Basically, this involves coloring the Buddhabrot by mapping the orbit length to the Hue channel of HSV color space. As the orbit length increases, the color hue changes therefore using the entire color spectrum to color with. This, in turn, reveals many Buddhabrot features that were previously difficult to see:

(http://richardrosenman.com/gallery/photo/originals/4c5f7012b3248.jpg)
  
Most of these images have had levels adjusted for optimal presentation.

-Richard

Having had good results with the HSV, I tried Lab color space:

(http://richardrosenman.com/gallery/photo/originals/4c60aaefe2877.jpg)

Of course, it all depends on what channel you map it to. In this case, the coloring was mapped to the 'b' color-opponent dimension but it could have been mapped to the 'a', although it didn't yield as nice results. You could also map to both and change the balance between the two for even more unique effects. The 'L' channel in Lab simply controls lightness so it would simply produce somewhat boring luminance-based renders.

-Richard

And another interesting test, this one using the IUV color space and mapped to the 'V' channel (I believe):

(http://richardrosenman.com/gallery/photo/originals/4c60ad54df856.jpg)

-Richard

If you convert Lab to HSL (just L, radius from whitepoint and relative angle to whitepoint) does that look any different to the HSV one?

Hi Kram1032;

I'm not sure which L you mean (the Lab or HSL) and which component you want to map to... Here's some pseudo code of my process. Maybe you can re-write it to show me what you mean and I'll give it a shot.


h = rgb2hsl (red ,green,blue,0);
s = rgb2hsl (red ,green,blue,1);
l = rgb2hsl (red ,green,blue,2);

pset(x,y,0,hsl2rgb(red,s,l,0));
pset(x,y,1,hsl2rgb(green,s,l,1));
pset(x,y,2,hsl2rgb(blue,s,l,2));

H = atan2(Lab.b,Lab.a)
S = sqrt(Lab.a²+Lab.b²)
L =  Lab.L

And use those just in the way, you used HSV before.
I hope, that's clear :)

Hi Kram1032;

Well, here's what I get using this method:

(http://richardrosenman.com/gallery/photo/originals/4c6349dc19e1c.jpg)

There's definitely some problems with this because it doesn't work in 16 bit mode, only 8. In addition, after some further investigation, here's what I found:


depth=255.0;
red = red*depth;
green = green*depth;
blue = blue*depth;
l = rgb2lab ((int)red ,(int)green,(int)blue,0);
a = rgb2lab ((int)red ,(int)green,(int)blue,1);
b = rgb2lab ((int)red ,(int)green,(int)blue,2);


h = (int)atan2((float)b,(float)a);
s = (int)sqrt((float)a*(float)a+(float)b*(float)b);
l2 = l;


Above, h always returns one which is most likely a problem.


pset((int)x,(int)y,0,hsl2rgb(h,s,l2,0));
pset((int)x,(int)y,1,hsl2rgb(h,s,l2,1));
pset((int)x,(int)y,2,hsl2rgb(h,s,l2,2));


Is this the algorithm you had in mind? I have a feeling there's a flaw in here somewhere... ;)

-Richard

On another note, neat result of the Tricorn using HSL color space mapping:

(http://richardrosenman.com/gallery/photo/originals/4c634a023e77b.jpg)

-Richard

very interesting buddhabrots on display here, you're all making me want to render some of my own *jealous*  ;D

great work!

buddhabrots offer nice views of well known formulas, i would love to see more formulas rendered as buddhabrots ( hybrid formulas, any other existing fractal )
and also i would be interested in a 3d version of the buddhabrots made of triplex numbers :D

the H value always returns 1? That definitely should NOT happen....

atan2(y,x) should give the angle (x,0,y) in radians, so the angle that points from the origin to the point in the plane.
As the Lab space is built in this way, it should work perfectly...

Well, allthough it's only red, it looks very nice :)
And the tricorn of it looks great :)

I took a quick look at it tonight and noticed that the result of atan2(b,a) spits out a float between 0 and 1. Since I was converting to integer, it rounded it off to one. For this test, I multiplied that float by the color bit depth and then converted to int. Here's the result:

(http://richardrosenman.com/gallery/photo/originals/4c64ba1930667.jpg)

It's a bit better but not really to my liking. At least you see a lot more detail than the previous one! :)

-Richard

I let this test go last night and it turned out quite nice. Heading describes the technique:

(http://richardrosenman.com/gallery/photo/originals/4c64bab01cba9.jpg)

-Richard

you multiplied by the colour bit depth?
I think, that's wrong but I'm not sure...

Why not use the float and convert to ints later?
Also the atan2 function in theory should return values from 0 to 2pi or from -pi tp pi...
Oh well, maybe the definition is different for some unknown reason...


The split comples Buddhabrot looks beautiful :D
The heading?

I did some tests a while back based on Ker2x's interesting Buddhabrot mutations that can be found here:

http://www.fractalforums.com/fractal-programs/a-creative-buddhabrot-rendering/

This first test involves computing a random c-point, and then incrementing xa or ya by 0.0001. Once you reach a million samples, you recompute a new random c-point and do it all over again. By incrementing xa / ya, you produce lines instead of points:

(http://richardrosenman.com/gallery/photo/originals/4c64bb4faf10b.jpg)

Of course, the problem with this is that the longer you let it iterate, the more it will develop to look like a typical Buddhabrot render so unlike the standard practice, the less time you iterate, the more unique it looks. Iteration time here was only 20 minutes.

-Richard

Here's another similar test with a somewhat varied algorithm:

(http://richardrosenman.com/gallery/photo/originals/4c64bb6ce730e.jpg)
 
-Richard

Like Ker2x's second test, this one involves computing a random c-point, and then generating new neighboring random points. Again, every 1000000 samples, a new c-point is generated and the loop starts again.

This results in very interesting 'clouds', or as Ker2x wrote, "Brownian Motion". Once again, the look is very unique but only at the early development of the Buddhabrot. After sufficient iteration time, the image will once again develop into a typical Buddhabrot render. Iteration time here was only 20 minutes.

(http://richardrosenman.com/gallery/photo/originals/4c64bb978f426.jpg)

-Richard

really nice execution of this :)

What happens if you do this with Buddhagram in 4D fBM?

Very nice :)

It looks very similar when I set the variance of the Metropolis Hastings algorithm in my GPU based renderer to a very small number. Then the orbital starting coordinates stay very close to their initial values, creates bright spots and patterns like those seen in your image.

(http://richardrosenman.com/gallery/photo/originals/4c69f7f2a49d8.jpg)

(The anti-aliasing looks great in the source image but because I'm adjusting levels, they become a bit jagged.)

-Richard

(http://richardrosenman.com/gallery/photo/originals/4c69f8123e2f1.jpg)

(The anti-aliasing looks great in the source image but because I'm adjusting levels, they become a bit jagged.)

-Richard

Would the Metropolis Hastings algorithm speed up my full Buddhabrot view? I believe it speeds up dramatically only once you start zooming in (which I cannot do yet), correct?

-Richard

An useful link to the buddhabrot solution using metropolis-hastings: :)
http://www.steckles.com/buddha/

Yes, very correct.

What will happens if you mix this (Buddhabrot for the Newton Method):
http://www.openprocessing.org/visuals/?visualID=4159
with this (Newton Method Mandelbrot Set):
http://commons.wikimedia.org/wiki/File:Newton-lplane-Mandelbrot-smooth.jpg

just an idea  :)

Millenium: What you ask for there is pretty straight forward :)
But the second one is a zoom. So richard can't do that yet.
I can zoom but it's a very slow process for me as I didn't do the Metropolis stuff...

Richard: Did you try the tan yet? :) (I'm currently rendering a ztanz one that I *think* should be the Nebulagram version of it... It sure is the coloured version but I'm not sure if I got the -gram part right, yet...)

kram1032: Mandelbrot appears in many equations, so why only render buddhabrots from the original mandelbrot?
As for the metropolis stuff..well..it sounds like an easy thing to do (or at least what I have seen on that webpage)
http://www.steckles.com/buddha/

I'm aware of that ;)
http://kram1032.deviantart.com/gallery/#Fractals <- there. TONS of different formulas, using the buddhabrot technique to render them.
I'm currently working on an other one :)

The only criticism that I have with that web page is that his mathematical expressions used in the source code can be simplified greatly for computing the probabilities to use in the Markov chain. Essentially the code is calling and pow, log way unnecessarily often - slowing it down because these are expensive to compute on a CPU.

Kram1032, there's some really nice renders there! Congrats!

-Richard

thanks :)
You still didn't experiment with z*tanz, did you?
It looks really nice.

I'd love to but I'm not sure I can with my algorithm and the way it's set up. If you take a look at this post: http://www.fractalforums.com/gallery-b179/buddhabrot-creative-gallery/msg20368/#msg20368 You'll see that you mentioned I can't do a Tan variation. No?

-Richard

Some more tests, this time mutating c.x and c.y:

(http://richardrosenman.com/gallery/photo/originals/4c69f8d01940c.jpg)

-Richard

(http://richardrosenman.com/gallery/photo/originals/4c69f89e23112.jpg)

-Richard

(http://richardrosenman.com/gallery/photo/originals/4c69f8669f9fd.jpg)

-Richard

you can't do a tan variant based on the simple parameters you had there. That's all I meant with you can't do it directly. However, it's straight forward to change it into one.
As you programmed that software on your own, it should be straight forward to change the source ;)

All you need to do is to change your equations which do complex squaring into equations which do complex tan times a complex number:

instead of

x->x²-y²+x0
y->2xy+y0

do

x->(x*sin(2x)-y*sinh(2y))/(cos(2x)+cosh(2y))+x0
y->(y*sin(2x)+x*sinh(2y))/(cos(2x)+cosh(2y))+y0

Btw the new stuff is very nice again :)