Buddhabrot reinvented

[cbuchner1]

I release this idea with an open source licence with share-alike attribute

what, no attribution attribute?

[richardrosenman]

Hey guys;

First off, I am tremendously impressed with this spectral mapping technique and the results it yields. Congratulations for such great work!

I have been attempting to implement this on my own as well based on the information provided but I seem to be having some problems:



I have successfully mapped the light spectrum using the proper algorithm from wavelengths 350-780 and converted them to RGB. You can see this on the bottom of the image. So I think I have this part correct. However, when it comes to mapping it to the Buddhabrot, I seem to be stuck.

On the left you can see the results with the Buddhabrot technique and on the right with the Nebulabrot. Clearly, none of them come even close to a decent result.

Basically, I am defining the wavelength using the following algorithm:

wavelength = 350 + (float)(430.0*((red+green+blue)/3.0));

The red, green and blue are the different Buddhabrot / Nebulabrot densities per color channel averaged together and scaled between 0-1. Right now for ease of sake, I am trying to achieve a good result with the simpler uddhabrot technique and not the Nebulabrot which is why I am averaging them out together for a single result. Then, I'm obviously starting the wavelength at 350 and then adding 430*(0...1) so that I get a total range of 350-780, the full color spectrum.

I then go on to calculate the respective RGB value for that particular wavelength which should also be in the range of 0-1. Finally, I multiply each channel by the result to retrieve what should be the correct result. Something like this:

red=red*abs(rgbwave_red);
green=green*abs(rgbwave_green);
blue=blue*abs(rgbwave_blue);

If you look closely at the images, you'll also notice black speckles which leads me to believe some are going out of range, despite my attempts to keep it within there.

So any thoughts on where I'm going wrong?

-Richard

[kram1032]

Not sure, I guess your conversion from Spectrum to RGB isn't quite correct...

http://www.fourmilab.ch/documents/specrend/ <- look there. You can find a c-file that converts spectral data into RGB values. Maybe it's of use.
The implementation of cbuchner used a converter written in Fortan... The RGB stimuli where pretty sharp. I guess it was easier to handle (not sure^^) but the CIE implementation in that c file is probably better suited if you can use it.

Your mapping doesn't look bad though

[cbuchner1]

I map short wavelengths (blue, violet) map to short orbits. It seems to be
different in your version because the area outside the buddhabrot appears red.
For me this area is entirely violet...

Note: The total orbit length (iteration count) defines the color of a pixel, not
the current iteration in the orbit. So an entire escape orbit adds the same color
contribution. I tried both variations, but the second one looked boring.

wavelength = 350 + (float)(430.0*((red+green+blue)/3.0));

I cannot really understand what you're doing with this mapping. Instead of
(red+green+blue/3.0) it should say "orbit length / Max_Iterations"
and the resulting wavelength THEN maps to red, green, blue color
contributions.

That color contribution is then added to the accumulation buffer. Because my buffer uses
integers of very limited range (~20 bits) I had to use a trick:  I add the integer 1 into a
color channel, if a uniformly distributed random number between 0 and 1 falls into the
range of the color channel's contribution (which is also somewhere between 0 and 1).
If you use floating point buffers or integers of at least 32 bits per color channel, then
there is no problem.

Also in my version of the spectrum there is a drop in intensity towards the edges
to model the reduced sensitivity of the eye when we go towards ultraviolet and
infrared. In a program update that I posted to the nVidia forums I even let intensity
drop towards 0 (that's complete invisibility).

[richardrosenman]

Not sure, I guess your conversion from Spectrum to RGB isn't quite correct...

http://www.fourmilab.ch/documents/specrend/ <- look there. You can find a c-file that converts spectral data into RGB values. Maybe it's of use.
The implementation of cbuchner used a converter written in Fortan... The RGB stimuli where pretty sharp. I guess it was easier to handle (not sure^^) but the CIE implementation in that c file is probably better suited if you can use it.

Your mapping doesn't look bad though

Good point. This is the algorithm I have used: http://miguelmoreno.net/sandbox/wavelengthtoRGB/

It sounds (and looks) correct. What do you think?

-Richard

[richardrosenman]

I map short wavelengths (blue, violet) map to short orbits. It seems to be
different in your version because the area outside the buddhabrot appears red.
For me this area is entirely violet...

Note: The total orbit length (iteration count) defines the color of a pixel, not
the current iteration in the orbit. So an entire escape orbit adds the same color
contribution. I tried both variations, but the second one looked boring.

wavelength = 350 + (float)(430.0*((red+green+blue)/3.0));

I cannot really understand what you're doing with this mapping. Instead of
(red+green+blue/3.0) it should say "orbit length / Max_Iterations"
and the resulting wavelength THEN maps to red, green, blue color
contributions.

Ok, so in the traditional Buddhabrot render, you figure out the orbit length and then, when it escapes, you increment the accumulation buffer by one. It a second pass, you convert the accumulations into the red, green, blue based on totals. It sounds like you're doing something else, right? It sounds like you are incrementing the accumulation buffer by the escaped orbit length / Max_Iterations. But this would result in a float <1.0 not an integer. Do I have it correct?

That color contribution is then added to the accumulation buffer. Because my buffer uses
integers of very limited range (~20 bits) I had to use a trick:  I add the integer 1 into a
color channel, if a uniformly distributed random number between 0 and 1 falls into the
range of the color channel's contribution (which is also somewhere between 0 and 1).
If you use floating point buffers or integers of at least 32 bits per color channel, then
there is no problem.

I do not get this. Are you calculating color within the orbit length accumulation routine? Is it not calculated afterwards, once you have gathered a growing total number of orbit lengths?

Also in my version of the spectrum there is a drop in intensity towards the edges
to model the reduced sensitivity of the eye when we go towards ultraviolet and
infrared. In a program update that I posted to the nVidia forums I even let intensity
drop towards 0 (that's complete invisibility).

The drop should be easy to implement. I hope you can shed some light into the other areas though.

Thanks! Really interested in this...

-Richard

[cbuchner1]

Hmm, let me clarify this a bit more:

First I determine the orbit length. When I find the orbit escapes within the iteration limit, I map this orbit to a wavelength. And I map the wavelength to R,G,B values (each color component is in the range 0...1). With a statistical sampling (above mentioned random number method) I increment my accumulation buffer's red green and blue channels either by 1 or by 0 (i.e. not at all) for all pixels on this orbit individually.

It is mostly a single pass algorithm, except maybe for the first determination whether or not the orbit escapes.

It's probably the easiest choice to use a uint32 per color channel, alternatively a float (maybe a double for best quality during long renders). With 32 bit integers you may increment each channel with an 8 bit RGB value (0-255), depending on color of the orbit. No trickery with random numbers is needed then. The wavelength function should then return R,G,B values from 0-255.

Here's how my accumulation buffer works (that's an implementation detail really):

My buffer holds red, green, blue channels interleaved. Bizarelly I store this in two separate uint32 arrays. Each color channel uses 10 bits within a single uint32. By combining these two uint32 arrays I get 20 bits in total per color channel.

I can increment the color channels of one pixel using a single read-modify-write to one uint32. That's just a single memory transaction to modify three color channels (hooray!).

Overflow from the lower 10 bits to the upper 10 bits of each color channel needs to be dealt with periodically, for example while doing the output processing to show intermediate rendering results on screen (whenever the 10th bit is set in a color channel in the first array, I clear it and then increment the second array by 1).

This strange buffer design is the reason I get good performance on the graphics chip and this isn't much slower than rendering a grayscale buddhabrot. But due to the limited 20 bits precision I cannot really increment the colors by large numbers (0-255) or I would soon be overflowing my buffer.

[kram1032]

hmm... on that site he said, none of them creates a pleasing spectrum...
I wish I could see an example of the corresponding CIE spectrum.

Well that's fine. It's very simplifyed though

[richardrosenman]

Hi cbuchner1;

Thanks for the explanation. It makes a lot more sense now but it would take some significant changes to my program to adapt it to a similar system.

I played around with the spectrum mapping some more but didn't get any better results. However, it led me to wonder what it would look like if I mapped an HSV color model to it (Hue, Saturation, Value) on the Hue channel. This, in effect, would yield a similar result to the wavelength mapping since we're telling it to map a hue based on the orbit length. Like the wavelength mapping, it reveals many more details in the Buddhabrot that weren't previously visible. The result is much better than my previous attempts:



I am now experimenting with other color models such as LAB, IUV, YCBCR, etc. I will post the results as I render them.

Cheers,
-Richard

[kram1032]

With Lab you wouldn't be far away from spectral, would you?

Very nice results

[richardrosenman]

Hey guys;

I've added new renders but started a new thread as I'm beginning to feel as if I'm hijacking this one! lol. Anyway, all this info can now be found here.

-Richard

[Millennium Nocturne]

Innocent Question:
Mandelbulb buddha looks like this one?

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

[kram1032]

not so innocent answer: nope.
What you see there is an animation of the full 4D-space of the Buddhabrot.
The Buddhabulb would be 6-dimensional during animation.
That's because you have 6 variables...

[Millennium Nocturne]

Oh 
So, no 3D mandelbulb looking buddhas?
not even with a multidimensional diet? (using 3 dimensions only?)