public static CIE1931Point RgbToXY(RGBColor color, string model)
{
// Apply gamma correction. Convert non-linear RGB colour components
// to linear color intensity levels.
double r = InverseGamma(color.R);
double g = InverseGamma(color.G);
double b = InverseGamma(color.B);
// Hue bulbs (depending on the type) can display colors outside the sRGB gamut supported
// by most computer screens.
// To make sure all colors are selectable by the user, Philips in its implementation
// decided to interpret all RGB colors as if they were from a wide (non-sRGB) gamut.
// The effect of this is to map colors in sRGB to a broader gamut of colors the hue lights
// can produce.
//
// This also results in some deviation of color on screen vs color in real-life.
//
// The Philips implementation describes the matrix below with the comment
// "Wide Gamut D65", but the values suggest this is infact not a standard
// gamut but some custom gamut.
//
// The coordinates of this gamut have been identified as follows:
// red: (0.700607, 0.299301)
// green: (0.172416, 0.746797)
// blue: (0.135503, 0.039879)
//
// (substitute r = 1, g = 1, b = 1 in sequence into array below and convert
// from XYZ to xyY coordinates).
// The plotted chart can be seen here: http://imgur.com/zelKnSk
//
// Also of interest, the white point is not D65 (0.31271, 0.32902), but a slightly
// shifted version at (0.322727, 0.32902). This might be because true D65 is slightly
// outside Gamut B (the position of D65 in the linked chart is slightly inaccurate).
double X = r * 0.664511f + g * 0.154324f + b * 0.162028f;
double Y = r * 0.283881f + g * 0.668433f + b * 0.047685f;
double Z = r * 0.000088f + g * 0.072310f + b * 0.986039f;
CIE1931Point xyPoint = new CIE1931Point(0.0, 0.0);
if ((X + Y + Z) > 0.0)
{
// Convert from CIE XYZ to CIE xyY coordinates.
xyPoint = new CIE1931Point(X / (X + Y + Z), Y / (X + Y + Z));
}
if (model != null)
{
//Check if the given XY value is within the colourreach of our lamps.
CIE1931Gamut gamut = CIE1931Gamut.ForModel(model);
// The point, adjusted it to the nearest point that is within the gamut of the lamp, if neccessary.
return(gamut.NearestContainedPoint(xyPoint));
}
return(xyPoint);
}
public static RGBColor XYToRgb(CIE1931Point point, string model)
{
if (model != null)
{
CIE1931Gamut gamut = CIE1931Gamut.ForModel(model);
// If the color is outside the lamp's gamut, adjust to the nearest color
// inside the lamp's gamut.
point = gamut.NearestContainedPoint(point);
}
// Also adjust it to be in the Philips "Wide Gamut" if not already.
// The wide gamut used for XYZ->RGB conversion does not quite contain all colors
// all of the hue bulbs support.
point = CIE1931Gamut.PhilipsWideGamut.NearestContainedPoint(point);
// Convert from xyY to XYZ coordinates.
double Y = 1.0; // Luminance
double X = (Y / point.y) * point.x;
double Z = (Y / point.y) * point.z;
// The Philips implementation comments this matrix with "sRGB D65 conversion"
// However, this is not the XYZ -> RGB conversion matrix for sRGB. Instead
// the matrix that is the inverse of that in RgbToXY() is used.
// See comment in RgbToXY() for more info.
double r = X * 1.656492 - Y * 0.354851 - Z * 0.255038;
double g = -X * 0.707196 + Y * 1.655397 + Z * 0.036152;
double b = X * 0.051713 - Y * 0.121364 + Z * 1.011530;
// Downscale color components so that largest component has an intensity of 1.0,
// as we can't display colors brighter than that.
double maxComponent = Math.Max(Math.Max(r, g), b);
if (maxComponent > 1.0)
{
r /= maxComponent;
g /= maxComponent;
b /= maxComponent;
}
// We now have the (linear) amounts of R, G and B corresponding to the specified XY coordinates.
// Since displays are non-linear, we must apply a gamma correction to get the pixel value.
// For example, a pixel red value of 1.0 (255) is more than twice as bright as 0.5 (127).
// We need to correct for this non-linearity.
r = Gamma(r);
g = Gamma(g);
b = Gamma(b);
// Philips applies a second round of downscaling here, but that should be unnecessary given
// gamma returns a value between 0.0 and 1.0 for every input between 0.0 and 1.0.
return(new RGBColor(r, g, b));
}
