Algorithm for a red to green colour gradient - algorithm

Question

I need some mathematical algorithm for converting the value from #FF0000 to #00FF00.
I do not want to go via a black value. The conversion should go from red to some cyan color (light blue) then to turn into green. If just needed to go from FF0000 to 000000 and then to 00FF00 it would be very easy.
The goal is to have levels let say from 0 to 1000 where 0 is #FF0000 and 1000 is #00FF00.
All I need is some smart mapping.

Answer 1

From the comments, I understand you want to be able to show colors between red and green, and that you don't want to "go through black", which I understand as "I want to keep the same intensity".
For this to work, you need to change color spaces. Instead of RGB move to HSL. Take the HSL value for your red, then the HSL value for your green, and interpolate between them in HSL space.
Convert all the intermediate values back to RGB, and there you have your red to green range.

Answer 2

For a general solution, Bart's suggestion to use the HSV space is good. Pooya's and Emilio's answers will interpolate between red and green in the RGB space, which will yield dark yellow/olive in the middle.
If you need a gradient only between red and green, I suggest the following quick solution: Interpolate between red and yellow (#FFFF00) in the first half, and between yellow and green in the second half:
unsigned int red_green_interpol(double x)
{
if (x <= 0.0) return 0xFF0000;
if (x >= 1.0) return 0x00FF00;
if (x < 0.5) {
unsigned int g = 510 * x;
return 0xFF0000 | g << 8;
} else {
unsigned int r = 510 * (1.0 - x);
return 0x00FF00 | r << 16;
}
}
I used a double between 0.0 and 1.0 instead of your integer range from 0 to 1000, but it shouldn't be difficult to adapt it.

Answer 3

maybe something like this :
c :
void print_color ( int value )
{
int r=(255*value)/1000;
printf("#%02x%02x00",r,255-r)
}
edit !
sorry , i didn't read question carefully!
to represent all three colors :
c:
void print_color ( int value )
{
int curr=(3*value)/1000;
int color[3];
color[curr%3]=(255* (value-curr*(1000/3)))/(1000/3);
color[(curr+1)%3]=255-color[curr];
color[(curr+2)%3]=0;
printf("#%02x%02x%02x",color[0],color[1],color[2]);
}
(indexes can be changed for RGB orders...)

Answer 4

well already answered but you wanted something easy:
void gradient()
{
const int _a=3; // color components order
const int _r=2;
const int _g=1;
const int _b=0;
union _col // color
{
DWORD dd; // unsigned 32bit int (your color)
BYTE db[4]; // 4 x BYTE
} col;
col.db[_r]=255; // start color 0x00FF0000
col.db[_g]= 0;
col.db[_b]= 0;
col.db[_a]= 0;
for (int i=0;i<255;i++) // gradient cycle (color 'intensity' = 255)
{
col.db[_r]--;
col.db[_g]++;
// here use your color col.dd;
}
}
for levels case there are only 255 levels in this case so remove for and add this instead (level=i 0..255):
col.db[_r]=255-i;
col.db[_g]= i;
col.db[_b]= 0;
col.db[_a]= 0;