C/C++

pixeltype HSLtoRGB(pixeltype palette_color){
	//0.0f <= h <  360.0f
	//0.0f <= s <= 1.0f
	//0.0f <= l <= 1.0f
	double h = (double)(HUE_OF(palette_color));
    double s = (double)(SATURATION_OF(palette_color));
    double l = (double)(LIGHTNESS_OF(palette_color));
	double q, p, h_k;
	double rgb[3];

	if(l < 0.5f){
		q = l * (1 + s);
	}else{
		q = l + s - (l * s);
	}
	p = 2 * l - q;
	h_k = h / 360.0f;
	rgb[0] = h_k + (1 / 3);
	rgb[1] = h_k;
	rgb[2] = h_k - (1 / 3);
	for(size_t i = 0; i < 3; i++){
		if(rgb[i] < (1 / 6)){
			rgb[i] = p + ((q - p) * 6.0f * rgb[i]);
		}else if(rgb[i] >= (1 / 6) && rgb[i] < (1 / 2)){
			rgb[i] = q;
		}else if(rgb[i] >= (1 / 2) && rgb[i] < (2 / 3)){
			rgb[i] = p + ((q - p) * 6.0f * ((2 / 3) - rgb[i]));
		}else{
			rgb[i] = p;
		}
	}
	//0.0f <= rgb[0] <= 1.0f
	//0.0f <= rgb[1] <= 1.0f
	//0.0f <= rgb[2] <= 1.0f
	return RGB_OF(rgb[0], rgb[1], rgb[2]);
}

C/C++

pixeltype RGBtoHSV(pixeltype palette_color){
	//0.0f <= r <= 1.0f
	//0.0f <= g <= 1.0f
	//0.0f <= b <= 1.0f
    double r = (double)(RED_OF(palette_color));
    double g = (double)(GREEN_OF(palette_color));
    double b = (double)(BLUE_OF(palette_color));
    double max, min, h, s, l;

	if(r > g){
		max = r;
	}else{
		max = g;
	}
	if(b > max){
		max = b;
	}

	if(r < g){
		min = r;
	}else{
		min = g;
	}
	if(b < min){
		min = b;
	}

    if(max == min){
        h = 0.0f;
    }else if(max == r){
        h = ((60.0f * ((g - b) / (max - min)) + 360) % 360.0f);
    }else if(max == g){
        h = ((60.0f * ((b - r) / (max - min)) + 120));
    }else if(max == b){
        h = ((60.0f * ((r - g) / (max - min)) + 240));
    }

	l = (max + min) / 2.0f;

	if(max == min){
		s = 0;
	}else if(l <= 0.5f){
		s = ((max - min) / (2 * l));
	}else if(l > 0.5f){
		s = ((max - min) / (2 - (2 * l)));
	}

	//0.0f <= h <= 360.0f
	//0.0f <= s <= 1.0f
	//0.0f <= l <= 1.0f
    return HSL_OF(h, s, l);
}
}

C/C++

pixeltype RGBtoHSV(pixeltype palette_color){
	//0.0f <= r <= 1.0f
	//0.0f <= g <= 1.0f
	//0.0f <= b <= 1.0f
    double r = (double)(RED_OF(palette_color));
    double g = (double)(GREEN_OF(palette_color));
    double b = (double)(BLUE_OF(palette_color));
    double max, min, h, s, v;

	if(r > g){
		max = r;
	}else{
		max = g;
	}
	if(b > max){
		max = b;
	}

	if(r < g){
		min = r;
	}else{
		min = g;
	}
	if(b < min){
		min = b;
	}

    if(max == min){
        h = 0.0f;
    }else if(max == r){
        h = ((60.0f * ((g - b) / (max - min)) + 360) % 360.0f);
    }else if(max == g){
        h = ((60.0f * ((b - r) / (max - min)) + 120));
    }else if(max == b){
        h = ((60.0f * ((r - g) / (max - min)) + 240));
    }

    if(max == 0){
        s = 0.0f;
    }else{
        s = 1.0f - (min / max);
    }
    v = max;

	//0.0f <= h <= 360.0f
	//0.0f <= s <= 1.0f
	//0.0f <= v <= 1.0f
    return HSV_OF(h, s, v);
}

C/C++

pixeltype HSVtoRGB(pixeltype palette_color){
    //0.0f <= h <= 360.0f
    //0.0f <= s <= 1.0f
    //0.0f <= v <= 1.0f
    double h = (double)(HUE_OF(palette_color));
    double s = (double)(SATURATION_OF(palette_color));
    double v = (double)(VALUE_OF(palette_color));
    double hi, f, p, q, t, temp;
    pixeltype rgb;

	temp = (h / 60.0f);
	hi = floor(temp) % 6.0f;
	f = temp - floor(temp);
	p = v * (1.0f - s);
	q = v * (1.0f - f * s);
	t = v * (1.0f - (1.0f - f) * s);
	switch((int)floor(hi)){
		case 0:rgb = RGB_OF(v, t, p);break;
		case 1:rgb = RGB_OF(q, v, p);break;
		case 2:rgb = RGB_OF(p, v, t);break;
		case 3:rgb = RGB_OF(p, q, v);break;
		case 4:rgb = RGB_OF(t, p, v);break;
		case 5:rgb = RGB_OF(v, p, q);break;
	}
	return rgb;

        //0.0f <= r <= 1.0f
	//0.0f <= g <= 1.0f
	//0.0f <= b <= 1.0f
}

Floating point is represented by scaling an integer.
In C/C++ one would shift the number by a scale…

const int SHIFT_AMT = 16;
const int INTEGER_MASK = 0xFF;
const int DECIMAL_MASK = 0xFF;

It is easiest for me to think of fixed point as a number multiplied by a scale.
I find it easier because it makes thinking about operations on the fixed point easier.

MATH

C/C++

typedef signed int fixedpoint;
int i = 10;
fixedpoint fp = i << SHIFT_AMT;

Addition and Subtraction are trivial with fixed point, Multiplication and Division are not...
Well... they are just not as trivial, there is one more step involved, scaling the result.

For Multiplication, you need to divide by the scale.
For Division, you need to multiply by the scale.

Multiplication
MATH

C/C++

fixedpoint number1 = 10 << SHIFT_AMT;
fixedpoint number2 = 10 << SHIFT_AMT;
fixedpoint result = (number1 * number2) >> SHIFT_AMT;

Division
MATH

C/C++

fixedpoint number1 = 10 << SHIFT_AMT;
fixedpoint number2 = 10 << SHIFT_AMT;
fixedpoint result = (number1 / number2) << SHIFT_AMT;

Other useful operations on fixed point could be:
Modulus.
Square-root.
Sine.
Cosine.

We are finding the average value for the three color components…

1. Extract the Red, Green and Blue of a color.
2. Add the three values together, divide them by three.
3. Put the Red, Green and Blue values together to form the gray value.

int pixel_value = RGB(13, 152, 186);
//get the red value of the pixel
int red = RED_OF(pixel_value) ;
//get the green value of the pixel
int green = GREEN_OF(pixel_value) ;
//get the blue value of the pixel
int blue BLUE_OF(pixel_value) ;
//average each color together to get the gray value
int gray = (red + green + blue)/3;
//bitwise 'or' them to make the complete RGB
int gray_pixel_value = RGB_OF(gray, gray, gray);

sidenote:
Love these colors from Crayola, they bring back so many memories!

Extract the RGB color values of the initial and to be drawn pixels colors.
Add each of the extract RGB values together and multiply by 0.5 (basically find the average of the two colors.

//The initial pixel color.
int color_initial = PIXELCOLOR;
//The pixel color to draw.
int color_draw = DRAWCOLOR;
//Extract each of the R, G, and B for each color of the initial pixel color.
int red_initial = RED_OF(color_initial);
int green_initial = GREEN_OF(color_initial);
int blue_initial = BLUE_OF(color_initial);
int red_draw = RED_OF(color_draw);
int green_draw = GREEN_OF(color_draw);
int blue_draw = BLUE_OF(color_draw);
//Find the average of the initial and new pixel colors.
int new_red = (red_initial + red_draw) * 0.5f;
int new_green = (green_initial + green_draw) * 0.5f;
int new_blue  = (blue_initial + blue_draw) * 0.5f;
int new_color = RGB_OF(new_red, new_green, new_blue);

Next up… gray values…

Powered by Twitter Tools.

Powered by Twitter Tools.