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

Hello,

I am new to this forum and also in fractals. I am trying to learn and as a start, I have written a simple, multi-threaded application that calculates the Mandelbrot set. I want to use it as a benchmark, because it is easy to parallelize (each pixel can be calculated independently), but irregular (we don't know how many iterations we need to calculate each pixel).

Everything seems to work fine and since I got up to this point, I thought that it would be nice to produce also some output images. However, I have some trouble finding a good way to map colors to the image. Currently, the best I have achieved is based on a simple linear mapping and looks like this:



Not very good and certainly far from my favorite color mapping, which looks like this:

http://en.wikipedia.org/wiki/Image:Mandelpart2.jpg

Unfortunately, I can't figure out which algorithm is used to produce this mapping of colors. Does anyone know the answer? I would like to use it in my program.

By the way, I am currently using the libtiff library to write out the image, which means that I need RGB values. I don't know if it is really relevant, but I mention it because I have seen some algorithms use other things, like Hue, Saturation etc.

Thanks for any help!

First of all, Greetings and Welcome to this particular Forum !!     



What are you using to set the initial colors for each of the generated pixels??  Do you use something like the .MAP files used by FractInt and many other fractal rendering applications??
  http://spanky.triumf.ca/www/fractint/color_params.html
  http://spanky.triumf.ca/www/fractint/palette_maps.html

Are you looking for various coloring techniques such as those found in "The Beauty of Fractals" (pages 60 thru 62)??
  http://spanky.triumf.ca/www/fractint/append_a_misc.html

Hello again,

Firstly, let me thank you for answering. However, your answers created a few more questions for me 

As suggested, I had a look at the .MAP files used by FractInt. As far as I can tell, they support only 256 colors. Is this right? On the other hand, I am currently using libtiff, so my color space is larger. I use 1 byte for each one of the RGB values, which gives me a total of 16 million colors (from 0 to 0xFFFFFF). The question is, can I use all these colors or are they far more than I need?

I am also not certain that I understand this question:

"What are you using to set the initial colors for each of the generated pixels??"

I also constructed the histogram, as suggested by Duncan, but I stuck again at the last part: How do I map each value of the histogram into an RGB value that is close to the previous color I used? I checked the links Duncan provided, but I am not certain how he did this part.

As a reference, I have the code here that calculates the histogram and also the part that causes me trouble. Just to make sure that I am doing the right thing.

/*
 * xpixels, ypixels: The number of pixels on the horizontal and vertical axis
 * IterationsPerPixel: Stores the number of iterations required to reach the bailout value, for each pixel.
 *
 * I check each pixel 'i'. Depending on how many iterations were needed, I update the histogram.
 * We need at least 1 iteration for each pixel, which is why I subtract 1, to update the correct element
 * in the histogram.
 */
for (i = 0; i < xpixels * ypixels; i++) {
   Histogram[IterationsPerPixel[ i ] - 1]++;
}

/*
 * Create the sum of all previous histogram values.
 * 'NumOfIterations' is the maximum number of iterations that we check each pixel,
 * before we decide that it belongs to the Mandelbrot set.
 */
for (i = 1; i < NumOfIterations; i++) {
   Histogram[ i ] += Histogram[i - 1];
}

/*
 * Iterate again over all pixels
 */
for (i = 0; i < xpixels * ypixels; i++) {
   Red[ i ]    = Some function of Histogram[IterationsPerPixel[ i ] - 1] ??  (But must have a value between 0 - 255)
   Green[ i ] = Some function of Histogram[IterationsPerPixel[ i ] - 1] ??  (But must have a value between 0 - 255)
   Blue[ i ]    = Some function of Histogram[IterationsPerPixel[ i ] - 1] ??  (But must have a value between 0 - 255)
}


So, my question is, how do i fill in the last loop? Is the number of iterations to reach the bailout value enough information, or do I have to save more data, i.e. the last value calculated for each point? I feel that I am missing some important point in this part, but what is it?

I hope someone has the patience to point out some good reference that I can read or even complete the above loop and explain why it should be as he suggests

Thank you for your help! I really appreciate it!

Yes, the .MAP files are basically setup for a 256-color palette.

You may wish to take a look at using some form of gradient file to choose from when coloring the fractals.  There are several programs that use this technique.  One of the most popular is UltraFractal, which use .UGR files, and looks something like this:

Default {
gradient:
  title="Default" smooth=yes numnodes=4 index=0 color=16711680 index=100
  color=16777215 index=200 color=65535 index=300 color=255
}

Grayscale {
gradient:
  title="Grayscale" smooth=no numnodes=2 index=0 color=0 index=200
  color=16777215
}

Royal {
gradient:
  title="Royal" smooth=yes numnodes=4 index=0 color=9043968 index=69
  color=3158085 index=150 color=14736366 index=302 color=675176
} 



I doubt that a single image will ever use all of the 16 million colors.  But in the long run of producing fractal images, they may all get used at some time.     

Hello everyone,

I experimented a bit with the method that Duncan suggested and I came up with the following picture:



Seems quite nice and similar to the one I wanted. My program is still not general enough, but the more I understand the method, the more I will work to overcome this problem.

Thanks again for all your suggestions and help!

Yes, your image is colored almost exactly like the original you referenced at:
   http://en.wikipedia.org/wiki/Image:Mandelpart2.jpg
More so than the one which Duncan posted, which does not pick up the yellow tones.

But Duncan's seems to show more of the details than yours does.  It is almost as though yours has been anti-aliased to the point of blurring.

Looking more closely at the original, I think you're right. My image misses the yellow tones in the original. I wonder if the original is more than just a single gradient? Upon inspection, it looks like the original might use a black to orange gradient, blended smoothly into an orange to yellow gradient.

iev,

How did you get the colors in your image?


Duncan C

iev,

My application has a user interface for assigning colors. The UI lets users create color "schemes" with one or more color gradients, or "bands". Each color gradient starts at a low iteration count, and goes to the beginning of the next iteration band, or the highest iteration value.

A color band can be anchored at a fixed iteration value, or using the plot histogram. If a color band is anchored using the plot histogram, the user specifies a percent value. (say, 20%). The program then uses the plot histogram to find the iteration value where 20% of the pixels have a lower iteration count. It uses that iteration count as the start of the iteration band.

This works well because it means that the same color scheme adapts to the pixel distribution in a variety of different plots.


No, that's not right.
Before you do anything, you create an array, histogram[max_iterations] of long integers. Go through every pixel in your image, and count the number of pixels with each iteration count, like this:

for x = 1 to width
   for y = 1 to height
      pixel_iteration_value = pixel[x,y];
     histogram[pixel_iteration_value]++;
   next y;
next x;

(It would be more efficient to calculate your histogram as you compute the plot, but that's minor)

Next, from your example, say you wanted to create a color band for pixels with an iteration value of 1 to 64.

You'd do something like this:

for index = 1 to 64;
   band_total = band_total + histogram[index];
next index;

running_total = 0;
float percents[1] = 0;
for index = 2 to 64;
   running_total = running_total + histogram[index];
   percents[index] = running_total / band_total;
next index;

At the end of the second loop, your percents array would contain floating point numbers that start at 0 (at percents[0]) and end at 1 (at percents[64]). You can then apply these percentages to your color range.

(if percents[index] = 0, use 100% start color. If percents[index] = 1, use 100% end color. If percents[index] = .5, use a color halfway between the start and end color for your range.)

Take another look at the image I posted of the image histogram, along with the color gradient it created. It should help you to understand what I am trying to describe.
click here to see that image.



Duncan C