/// <summary>
/// RGB to HSL.
/// </summary>
/// <param name="rgb">The RGB.</param>
/// <returns></returns>
public static HSLColour RGBToHSL(RGBColour rgb)
{
double varR = (rgb.Red / 255.0); //Where RGB values = 0 ÷ 255
double varG = (rgb.Green / 255.0);
double varB = (rgb.Blue / 255.0);
double varMin = GetMinimumValue(varR, varG, varB); //Min. value of RGB
double varMax = GetMaximumValue(varR, varG, varB); //Max. value of RGB
double delMax = varMax - varMin; //Delta RGB value
double h;
double s;
double l = (varMax + varMin) / 2;
if (delMax == 0) //This is a gray, no chroma...
{
h = 0; //HSL results = 0 ÷ 1
//s = 0;
// UK:
s = 1.0;
}
else //Chromatic data...
{
if (l < 0.5)
{
s = delMax / (varMax + varMin);
}
else
{
s = delMax / (2.0 - varMax - varMin);
}
double delR = (((varMax - varR) / 6.0) + (delMax / 2.0)) / delMax;
double delG = (((varMax - varG) / 6.0) + (delMax / 2.0)) / delMax;
double delB = (((varMax - varB) / 6.0) + (delMax / 2.0)) / delMax;
if (varR == varMax)
{
h = delB - delG;
}
else if (varG == varMax)
{
h = (1.0 / 3.0) + delR - delB;
}
else if (varB == varMax)
{
h = (2.0 / 3.0) + delG - delR;
}
else
{
// Uwe Keim.
h = 0.0;
}
if (h < 0.0)
{
h += 1.0;
}
if (h > 1.0)
{
h -= 1.0;
}
}
// --
return(new HSLColour(h * 360.0, s * 100.0, l * 100.0));
}
/// <summary>
/// Converts <see cref="RgbColor"/> to <see cref="HSBColour"/>.
/// </summary>
/// <param name="rgb">A <see cref="RgbColor"/> object containing the <see cref="RgbColor"/> values that are to
/// be converted to <see cref="HSBColour"/> values.</param>
/// <returns>A <see cref="HSBColour"/> equivalent.</returns>
public static HSBColour RGBToHSB(RGBColour rgb)
{
// _NOTE #1: Even though we're dealing with a very small range of
// numbers, the accuracy of all calculations is fairly important.
// For this reason, I've opted to use double data types instead
// of float, which gives us a little bit extra precision (recall
// that precision is the number of significant digits with which
// the result is expressed).
double r = rgb.Red / 255d;
double g = rgb.Green / 255d;
double b = rgb.Blue / 255d;
double minValue = GetMinimumValue(r, g, b);
double maxValue = GetMaximumValue(r, g, b);
double delta = maxValue - minValue;
double hue = 0;
double saturation;
double brightness = maxValue * 100;
if (maxValue == 0 || delta == 0)
{
hue = 0;
saturation = 0;
}
else
{
// _NOTE #2: FXCop insists that we avoid testing for floating
// point equality (CA1902). Instead, we'll perform a series of
// tests with the help of Double.Epsilon that will provide
// a more accurate equality evaluation.
if (minValue == 0)
{
saturation = 100;
}
else
{
saturation = (delta / maxValue) * 100;
}
if (Math.Abs(r - maxValue) < Double.Epsilon)
{
hue = (g - b) / delta;
}
else if (Math.Abs(g - maxValue) < Double.Epsilon)
{
hue = 2 + (b - r) / delta;
}
else if (Math.Abs(b - maxValue) < Double.Epsilon)
{
hue = 4 + (r - g) / delta;
}
}
hue *= 60;
if (hue < 0)
{
hue += 360;
}
return(new HSBColour((int)Math.Round(hue), (int)Math.Round(saturation), (int)Math.Round(brightness)));
}
/// <summary>
/// Creates from a given color.
/// </summary>
/// <param name="colour">The color.</param>
/// <returns></returns>
public static HSLColour FromRGBColour(RGBColour colour)
{
return(colour.ToHSLColour());
}
/// <summary>
/// Converts a <see cref="RgbColor"/> color structure to a Color object.
/// </summary>
/// <param name="rgb">A <see cref="RgbColor"/> object representing the color that is to be
/// converted.</param>
/// <returns>A Color equivalent.</returns>
public static Color RGBToColour(RGBColour rgb)
{
return(Color.FromArgb(rgb.Red, rgb.Green, rgb.Blue));
}
/// <summary>
/// Creates from a given color.
/// </summary>
/// <param name="colour">The color.</param>
/// <returns></returns>
public static RGBColour FromRgbColour(RGBColour colour)
{
return(new RGBColour(colour.Red, colour.Green, colour.Blue));
}
