![]() |
Modules | |
HSI Color Coordinate System Conversions | |
Functions | |
float | imColorZero (int data_type) |
int | imColorMax (int data_type) |
template<class T > | |
T | imColorQuantize (const float &value, const T &max) |
template<class T > | |
float | imColorReconstruct (const T &value, const T &max) |
template<class T > | |
void | imColorYCbCr2RGB (const T Y, const T Cb, const T Cr, T &R, T &G, T &B, const T &zero, const T &max) |
template<class T > | |
void | imColorRGB2YCbCr (const T R, const T G, const T B, T &Y, T &Cb, T &Cr, const T &zero) |
template<class T > | |
void | imColorCMYK2RGB (const T C, const T M, const T Y, const T K, T &R, T &G, T &B, const T &max) |
template<class T > | |
void | imColorXYZ2RGB (const T X, const T Y, const T Z, T &R, T &G, T &B, const T &max) |
template<class T > | |
void | imColorRGB2XYZ (const T R, const T G, const T B, T &X, T &Y, T &Z) |
void | imColorXYZ2Lab (const float X, const float Y, const float Z, float &L, float &a, float &b) |
void | imColorLab2XYZ (const float L, const float a, const float b, float &X, float &Y, float &Z) |
void | imColorXYZ2Luv (const float X, const float Y, const float Z, float &L, float &u, float &v) |
void | imColorLuv2XYZ (const float L, const float u, const float v, float &X, float &Y, float &Z) |
float | imColorTransfer2Linear (const float &nonlinear_value) |
float | imColorTransfer2Nonlinear (const float &value) |
void | imColorRGB2RGBNonlinear (const float RL, const float GL, const float BL, float &R, float &G, float &B) |
template<class T > | |
T | imColorRGB2Luma (const T R, const T G, const T B) |
float | imColorLuminance2Lightness (const float &Y) |
float | imColorLightness2Luminance (const float &L) |
ChromaUV = sqrt(u*u + v*v) HueUV = atan2(v, u) SaturationUV = ChromaUV / L (called psychometric saturation) (the same can be calculated for Lab)
byte [0,255] or [-128,+127] (1 byte) ushort [0,65535] or [-32768,+32767] (2 bytes) int [0,16777215] or [-8388608,+8388607] (3 bytes) float [0,1] or [-0.5,+0.5] (4 bytes)
float imColorZero | ( | int | data_type | ) | [inline] |
int imColorMax | ( | int | data_type | ) | [inline] |
T imColorQuantize | ( | const float & | value, | |
const T & | max | |||
) | [inline] |
Quantize r=0-1 values into q=0-max. max is the maximum value. max and the returned value are usually integers, but the dummy quantizer uses real values. See also Math Utilities.
float imColorReconstruct | ( | const T & | value, | |
const T & | max | |||
) | [inline] |
Reconstruct 0-max values into 0-1.
max is the maximum value. max and the given value are usually integers, but the dummy reconstructor uses real values. See also Math Utilities.
void imColorYCbCr2RGB | ( | const T | Y, | |
const T | Cb, | |||
const T | Cr, | |||
T & | R, | |||
T & | G, | |||
T & | B, | |||
const T & | zero, | |||
const T & | max | |||
) | [inline] |
Converts Y'CbCr to R'G'B' (all nonlinear).
ITU-R Recommendation 601-1 with no headroom/footroom.
0 <= Y <= 1 ; -0.5 <= CbCr <= 0.5 ; 0 <= RGB <= 1 R'= Y' + 0.000 *Cb + 1.402 *Cr G'= Y' - 0.344 *Cb - 0.714 *Cr B'= Y' + 1.772 *Cb + 0.000 *Cr
00135 { 00136 float r = float(Y + 1.402f * (Cr - zero)); 00137 float g = float(Y - 0.344f * (Cb - zero) - 0.714f * (Cr - zero)); 00138 float b = float(Y + 1.772f * (Cb - zero)); 00139 00140 // now we should enforce 0<= rgb <= max 00141 00142 R = (T)IM_CROPMAX(r, max); 00143 G = (T)IM_CROPMAX(g, max); 00144 B = (T)IM_CROPMAX(b, max); 00145 }
void imColorRGB2YCbCr | ( | const T | R, | |
const T | G, | |||
const T | B, | |||
T & | Y, | |||
T & | Cb, | |||
T & | Cr, | |||
const T & | zero | |||
) | [inline] |
Converts R'G'B' to Y'CbCr (all nonlinear).
ITU-R Recommendation 601-1 with no headroom/footroom.
0 <= Y <= 1 ; -0.5 <= CbCr <= 0.5 ; 0 <= RGB <= 1 Y' = 0.299 *R' + 0.587 *G' + 0.114 *B' Cb = -0.169 *R' - 0.331 *G' + 0.500 *B' Cr = 0.500 *R' - 0.419 *G' - 0.081 *B'
void imColorCMYK2RGB | ( | const T | C, | |
const T | M, | |||
const T | Y, | |||
const T | K, | |||
T & | R, | |||
T & | G, | |||
T & | B, | |||
const T & | max | |||
) | [inline] |
Converts C'M'Y'K' to R'G'B' (all nonlinear).
This is a poor conversion that works for a simple visualization.
0 <= CMYK <= 1 ; 0 <= RGB <= 1 R = (1 - K) * (1 - C) G = (1 - K) * (1 - M) B = (1 - K) * (1 - Y)
void imColorXYZ2RGB | ( | const T | X, | |
const T | Y, | |||
const T | Z, | |||
T & | R, | |||
T & | G, | |||
T & | B, | |||
const T & | max | |||
) | [inline] |
Converts CIE XYZ to Rec 709 RGB (all linear).
ITU-R Recommendation BT.709 (D65 white point).
0 <= XYZ <= 1 ; 0 <= RGB <= 1 R = 3.2406 *X - 1.5372 *Y - 0.4986 *Z G = -0.9689 *X + 1.8758 *Y + 0.0415 *Z B = 0.0557 *X - 0.2040 *Y + 1.0570 *Z
00204 { 00205 float r = 3.2406f *X - 1.5372f *Y - 0.4986f *Z; 00206 float g = -0.9689f *X + 1.8758f *Y + 0.0415f *Z; 00207 float b = 0.0557f *X - 0.2040f *Y + 1.0570f *Z; 00208 00209 // we need to crop because not all XYZ colors are visible 00210 00211 R = (T)IM_CROPMAX(r, max); 00212 G = (T)IM_CROPMAX(g, max); 00213 B = (T)IM_CROPMAX(b, max); 00214 }
void imColorRGB2XYZ | ( | const T | R, | |
const T | G, | |||
const T | B, | |||
T & | X, | |||
T & | Y, | |||
T & | Z | |||
) | [inline] |
Converts Rec 709 RGB to CIE XYZ (all linear).
ITU-R Recommendation BT.709 (D65 white point).
0 <= XYZ <= 1 ; 0 <= RGB <= 1 X = 0.4124 *R + 0.3576 *G + 0.1805 *B Y = 0.2126 *R + 0.7152 *G + 0.0722 *B Z = 0.0193 *R + 0.1192 *G + 0.9505 *B
void imColorXYZ2Lab | ( | const float | X, | |
const float | Y, | |||
const float | Z, | |||
float & | L, | |||
float & | a, | |||
float & | b | |||
) | [inline] |
Converts CIE XYZ (linear) to CIE L*a*b* (nonlinear).
The white point is D65.
0 <= L <= 1 ; -0.5 <= ab <= +0.5 ; 0 <= XYZ <= 1 if (t > 0.008856) f(t) = pow(t, 1/3) else f(t) = 7.787*t + 16/116 fX = f(X / Xn) fY = f(Y / Yn) fZ = f(Z / Zn) L = 1.16 * fY - 0.16 a = 2.5 * (fX - fY) b = (fY - fZ)
void imColorLab2XYZ | ( | const float | L, | |
const float | a, | |||
const float | b, | |||
float & | X, | |||
float & | Y, | |||
float & | Z | |||
) | [inline] |
Converts CIE L*a*b* (nonlinear) to CIE XYZ (linear).
The white point is D65.
0 <= L <= 1 ; -0.5 <= ab <= +0.5 ; 0 <= XYZ <= 1
00286 { 00287 float fY = (L + 0.16f) / 1.16f; 00288 float gY = IM_GWLAB(fY); 00289 00290 float fgY = IM_FWLAB(gY); 00291 float gX = fgY + a / 2.5f; 00292 float gZ = fgY - b; 00293 gX = IM_GWLAB(gX); 00294 gZ = IM_GWLAB(gZ); 00295 00296 X = gX * 0.9505f; // white point D65 00297 Y = gY * 1.0f; 00298 Z = gZ * 1.0890f; 00299 }
void imColorXYZ2Luv | ( | const float | X, | |
const float | Y, | |||
const float | Z, | |||
float & | L, | |||
float & | u, | |||
float & | v | |||
) | [inline] |
Converts CIE XYZ (linear) to CIE L*u*v* (nonlinear).
The white point is D65.
0 <= L <= 1 ; -1 <= uv <= +1 ; 0 <= XYZ <= 1 Y = Y / 1.0 (for D65) if (Y > 0.008856) fY = pow(Y, 1/3) else fY = 7.787 * Y + 0.16/1.16 L = 1.16 * fY - 0.16 U(x, y, z) = (4 * x)/(x + 15 * y + 3 * z) V(x, y, z) = (9 * x)/(x + 15 * y + 3 * z) un = U(Xn, Yn, Zn) = 0.1978 (for D65) vn = V(Xn, Yn, Zn) = 0.4683 (for D65) fu = U(X, Y, Z) fv = V(X, Y, Z) u = 13 * L * (fu - un) v = 13 * L * (fv - vn)
00326 { 00327 float XYZ = (float)(X + 15 * Y + 3 * Z); 00328 float fY = Y / 1.0f; 00329 00330 if (XYZ != 0) 00331 { 00332 L = 1.16f * IM_FWLAB(fY) - 0.16f; 00333 u = 6.5f * L * ((4 * X)/XYZ - 0.1978f); 00334 v = 6.5f * L * ((9 * Y)/XYZ - 0.4683f); 00335 } 00336 else 00337 { 00338 L = u = v = 0; 00339 } 00340 }
void imColorLuv2XYZ | ( | const float | L, | |
const float | u, | |||
const float | v, | |||
float & | X, | |||
float & | Y, | |||
float & | Z | |||
) | [inline] |
Converts CIE L*u*v* (nonlinear) to CIE XYZ (linear).
The white point is D65. 0 <= L <= 1 ; -0.5 <= uv <= +0.5 ; 0 <= XYZ <= 1
00349 { 00350 float fY = (L + 0.16f) / 1.16f; 00351 Y = IM_GWLAB(fY) * 1.0f; 00352 00353 float ul = 0.1978f, vl = 0.4683f; 00354 if (L != 0) 00355 { 00356 ul = u / (6.5f * L) + 0.1978f; 00357 vl = v / (6.5f * L) + 0.4683f; 00358 } 00359 00360 X = ((9 * ul) / (4 * vl)) * Y; 00361 Z = ((12 - 3 * ul - 20 * vl) / (4 * vl)) * Y; 00362 }
float imColorTransfer2Linear | ( | const float & | nonlinear_value | ) | [inline] |
Converts nonlinear values to linear values.
We use the sRGB transfer function. sRGB uses ITU-R 709 primaries and D65 white point.
0 <= l <= 1 ; 0 <= v <= 1 if (v < 0.03928) l = v / 12.92 else l = pow((v + 0.055) / 1.055, 2.4)
float imColorTransfer2Nonlinear | ( | const float & | value | ) | [inline] |
Converts linear values to nonlinear values.
We use the sRGB transfer function. sRGB uses ITU-R 709 primaries and D65 white point.
0 <= l <= 1 ; 0 <= v <= 1 if (l < 0.0031308) v = 12.92 * l else v = 1.055 * pow(l, 1/2.4) - 0.055
Referenced by imColorRGB2RGBNonlinear().
void imColorRGB2RGBNonlinear | ( | const float | RL, | |
const float | GL, | |||
const float | BL, | |||
float & | R, | |||
float & | G, | |||
float & | B | |||
) | [inline] |
Converts RGB (linear) to R'G'B' (nonlinear).
References imColorTransfer2Nonlinear().
00406 { 00407 R = imColorTransfer2Nonlinear(RL); 00408 G = imColorTransfer2Nonlinear(GL); 00409 B = imColorTransfer2Nonlinear(BL); 00410 }
T imColorRGB2Luma | ( | const T | R, | |
const T | G, | |||
const T | B | |||
) | [inline] |
float imColorLuminance2Lightness | ( | const float & | Y | ) | [inline] |
float imColorLightness2Luminance | ( | const float & | L | ) | [inline] |
Converts Lightness (CIE L*) to Luminance (CIE Y) (all linear).
The white point is D65.
0 <= Y <= 1 ; 0 <= L* <= 1 fY = (L + 0.16)/1.16 if (fY > 0.20689) Y = pow(fY, 3) else Y = 0.1284 * (fY - 0.16/1.16) Y = Y * 1.0 (for D65)