WingedBrot

[ker2x]

This is, again, some kind of buddhabrot. (plotting trajectory of point escaping the m-set)

But but but... is a modified formula.
The original iteration process is :
xnew = x * x  - y * y  + x0;
ynew = 2 * x * y + y0;

the modified is :
xnew = x * x  - y * y  + x0;
ynew = 1 * x * y + y0;

[ker2x]

humanbrot ?

Bleh... i have too much imagination

[ker2x]

It's hard to notice in this picture, but with some tweeking we find that the large bright vertical "line" are part of a logistic map.
something that was already found here : http://www.superliminal.com/fractals/bbrot/l-map/

edit : mmm... maybe not

[ker2x]

Same rendering technique :

a "burningship" :
http://ker.endofinternet.net/img/burnship.jpg

And much more obvious, a "mandelbar/tricorn" :
http://ker.endofinternet.net/img/mandelbar.jpg

[kram1032]

very nice stuff

Did you already see my tries on buddhabrot variations?

http://kram1032.deviantart.com/gallery/#Fractals

besides the very oldest two (the last two, currently on page 3), they're all done with the buddhabrot rendering technique and some kind of colour gradient.

[Nahee_Enterprises]

I liked the way that both "WingedBrot" and "WingedBrot-II" came out.  Very interesting images.

[ker2x]

Thx.
I added the sourcecode and more pic : http://ker.endofinternet.net/img/

@kram : very nice. and thx for posting the formula in some of them, i will try them

[ker2x]

I'm wondering if the rendering could be faster with an opencl/gpgpu version.
It's not sure at all ... as every iteration need an access to the shared orbit map.

each point is not independant like a good old mandelbrot rendering ...
And shared memory access on a gpu is really slow (800 cycle latency)

[twinbee]

Nice and scary! Reminds me of the "bat coming towards the camera" scene in (the latest?) Batman film.

[ker2x]

thx.

I just added a new pic, 47 billions points.
I added a new features (not in this pic) to benchmark the performances.
Around 50.000 iteration per milliseconds.

PureBasic is Fast 

[ker2x]

And now with color ! 

[Buddhi]

Some time ago I rendered some animations with Widget/Buddhabrots.

In first animation I changed degree multiplier (@mul) in range -6 to 7. It was rendered in around 100 hours.
Formula was:

deg = atan2(x,y)
r = x^2 + y^2
x = r * cos(deg*@mul) + c.x
y = r * sin(deg*@mul) + c.y

<a href="http://www.youtube.com/v/KTS7F9dzr4k&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/KTS7F9dzr4k&rel=1&fs=1&hd=1</a>

Second animation shows some details of Buddhabrot. Fractal was rendered in resolution 8000x8000 pixels. Render mesh resolution was 50000x50000 samples and maximum number of iterations was also 50000.

<a href="http://www.youtube.com/v/QsWEbx2wOBM&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/QsWEbx2wOBM&rel=1&fs=1&hd=1</a>

[ker2x]

Very nice videos

BTW ... you can download software and sourcecode at http://ker.endofinternet.net/img/
at 60.000 iterations per milliseconds (or 60 millions/s), i think i can say that it's very fast for a monothread app

[kram1032]

very nice buddhi

ker2x:
I can't guarantee that I still have all the formulae but if you want to know any specific of them I can try to find it

Are you using a fixed grid approach or a random grid one to render your results?

In both cases, multithreating should be somewhat easy to implement: for the random case, just start an additional rekursion per thread and for the fixed grid maybe render per quadrant or make it so the cores cycle through the points.
Just some thoughts...

[ker2x]

very nice buddhi

ker2x:
I can't guarantee that I still have all the formulae but if you want to know any specific of them I can try to find it

Are you using a fixed grid approach or a random grid one to render your results?

In both cases, multithreating should be somewhat easy to implement: for the random case, just start an additional rekursion per thread and for the fixed grid maybe render per quadrant or make it so the cores cycle through the points.
Just some thoughts...

I choose random point.
You can find the the source code in *.pb file
Even if you don't know purebasic, it's very easy to understand

The problem with multithread :
- With a standard mandelbrot rendering, computing one point write one pixel.
- With buddhabrot, computing one point write on the whole image.
- with millions of point written per seconds, the problem will spend all its time to wait for mutex. Unless i accept some consistancy problem... the effect could be negligible.

For now, i'm playing with rewriting fractal rendering in x64 asm with SSE2&3 instruction. Big speed improvement.

I started to rewrite the buddhabrot renderer in asm with SSE