END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

what, no attribution attribute?

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

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.

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

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

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...