RGB,CMYK,HSB各种颜色表示的转换 C#语言

The RGB (Red, Green, Blue) color model is the most known, and the most used every day. It defines a color space in terms of three components:

• Red, which ranges from 0-255
• Green, which ranges from 0-255
• Blue, which ranges from 0-255

The RGB color model is an additive one. In other words, Red, Green and Blue values (known as the three primary colors) are combined to reproduce other colors.
For example, the color "Red" can be represented as [R=255, G=0, B=0], "Violet" as [R=238, G=130, B=238], etc.

Its common graphic representation is the following image:

In .NET, the Color structure use this model to provide color support through R, G and B properties.

Console.WriteLine(String.Format("R={0}, G={1}, B={2}",
    Color.Red.R, Color.Red.G, Color.Red.B);
Console.WriteLine(String.Format("R={0}, G={1}, B={2}",
    Color.Cyan.R, Color.Cyan.G, Color.Cyan.B);
Console.WriteLine(String.Format("R={0}, G={1}, B={2}",
    Color.White.R, Color.White.G, Color.White.B);
Console.WriteLine(String.Format("R={0}, G={1}, B={2}",
    Color.SteelBlue.R, Color.SteelBlue.G, Color.SteelBlue.B);

// etc...

but this is not its only usage. For this reason, we can define a dedicated RGB structure for further coding, as shown below:

Hide   Shrink   Copy Code

/// <summary>
/// RGB structure.
/// </summary>
public struct RGB
{
    /// <summary>
    /// Gets an empty RGB structure;
    /// </summary>
    public static readonly RGB Empty = new RGB();

    private int red;
    private int green;
    private int blue;

    public static bool operator ==(RGB item1, RGB item2)
    {
        return (
            item1.Red == item2.Red
            && item1.Green == item2.Green
            && item1.Blue == item2.Blue
            );
    }

    public static bool operator !=(RGB item1, RGB item2)
    {
        return (
            item1.Red != item2.Red
            || item1.Green != item2.Green
            || item1.Blue != item2.Blue
            );
    }

    /// <summary>
    /// Gets or sets red value.
    /// </summary>
    public int Red
    {
        get
        {
            return red;
        }
        set
        {
                red = (value>255)? 255 : ((value<0)?0 : value);
        }
    }

    /// <summary>
    /// Gets or sets red value.
    /// </summary>
    public int Green
    {
        get
        {
            return green;
        }
        set
        {
            green = (value>255)? 255 : ((value<0)?0 : value);
        }
    }

    /// <summary>
    /// Gets or sets red value.
    /// </summary>
    public int Blue
    {
        get
        {
            return blue;
        }
        set
        {
            blue = (value>255)? 255 : ((value<0)?0 : value);
        }
    }

    public RGB(int R, int G, int B)
    {
        this.red = (R>255)? 255 : ((R<0)?0 : R);
        this.green = (G>255)? 255 : ((G<0)?0 : G);
        this.blue = (B>255)? 255 : ((B<0)?0 : B);
    }

    public override bool Equals(Object obj)
    {
        if(obj==null || GetType()!=obj.GetType()) return false;

        return (this == (RGB)obj);
    }

    public override int GetHashCode()
    {
        return Red.GetHashCode() ^ Green.GetHashCode() ^ Blue.GetHashCode();
    }
}

• Hue : the color type (such as red, blue, or yellow).
  • Ranges from 0 to 360° in most applications. (each value corresponds to one color : 0 is red, 45 is a shade of orange and 55 is a shade of yellow).

The HSL color space, also called HLS or HSI, stands for:

• Hue : the color type (such as red, blue, or yellow).
  • Ranges from 0 to 360° in most applications (each value corresponds to one color : 0 is red, 45 is a shade of orange and 55 is a shade of yellow).
• Saturation : variation of the color depending on the lightness.
  • Ranges from 0 to 100% (from the center of the black&white axis).
• Lightness (also Luminance or Luminosity or Intensity).
  • Ranges from 0 to 100% (from black to white).

Its common graphic representation is the following image:

HSL is similar to HSB. The main difference is that HSL is symmetrical to lightness and darkness. This means that:

• In HSL, the Saturation component always goes from fully saturated color to the equivalent gray (in HSB, with B at maximum, it goes from saturated color to white).
• In HSL, the Lightness always spans the entire range from black through the chosen hue to white (in HSB, the B component only goes half that way, from black to the chosen hue).

For my part, HSL offers a more accurate (even if it‘s not absolute) color approximation than HSB.

All this said, a HSL structure can be:

Hide   Shrink   Copy Code

/// <summary>
/// Structure to define HSL.
/// </summary>
public struct HSL
{
    /// <summary>
    /// Gets an empty HSL structure;
    /// </summary>
    public static readonly HSL Empty = new HSL();

    private double hue;
    private double saturation;
    private double luminance;

    public static bool operator ==(HSL item1, HSL item2)
    {
        return (
            item1.Hue == item2.Hue
            && item1.Saturation == item2.Saturation
            && item1.Luminance == item2.Luminance
            );
    }

    public static bool operator !=(HSL item1, HSL item2)
    {
        return (
            item1.Hue != item2.Hue
            || item1.Saturation != item2.Saturation
            || item1.Luminance != item2.Luminance
            );
    }

    /// <summary>
    /// Gets or sets the hue component.
    /// </summary>
    public double Hue
    {
        get
        {
            return hue;
        }
        set
        {
            hue = (value>360)? 360 : ((value<0)?0:value);
        }
    }

    /// <summary>
    /// Gets or sets saturation component.
    /// </summary>
    public double Saturation
    {
        get
        {
            return saturation;
        }
        set
        {
            saturation = (value>1)? 1 : ((value<0)?0:value);
        }
    }

    /// <summary>
    /// Gets or sets the luminance component.
    /// </summary>
    public double Luminance
    {
        get
        {
            return luminance;
        }
        set
        {
            luminance = (value>1)? 1 : ((value<0)? 0 : value);
        }
    }

    /// <summary>
    /// Creates an instance of a HSL structure.
    /// </summary>
    /// <param name="h">Hue value.</param>
    /// <param name="s">Saturation value.</param>
    /// <param name="l">Lightness value.</param>
    public HSL(double h, double s, double l)
    {
        this.hue = (h>360)? 360 : ((h<0)?0:h);
        this.saturation = (s>1)? 1 : ((s<0)?0:s);
        this.luminance = (l>1)? 1 : ((l<0)?0:l);
    }

    public override bool Equals(Object obj)
    {
        if(obj==null || GetType()!=obj.GetType()) return false;

        return (this == (HSL)obj);
    }

    public override int GetHashCode()
    {
        return Hue.GetHashCode() ^ Saturation.GetHashCode() ^
            Luminance.GetHashCode();
    }
}

The CMYK color space, also known as CMJN, stands for:

• Cyan.
  • Ranges from 0 to 100% in most applications.
• Magenta.
  • Ranges from 0 to 100% in most applications.
• Yellow.
  • Ranges from 0 to 100% in most applications.
• blacK.
  • Ranges from 0 to 100% in most applications.

It is a subtractive color model used in color printing. CMYK works on an optical illusion that is based on light absorption.
The principle is to superimpose three images; one for cyan, one for magenta and one for yellow; which will reproduce colors.

Its common graphic representation is the following image:

Like the RGB color model, CMYK is a combination of primary colors (cyan, magenta, yellow and black). It is, probably, the only thing they have in common.
CMYK suffers from a lack of color shades that causes holes in the color spectrum it can reproduce. That‘s why there are often differencies when someone convert a color between CMYK to RGB.

Why using this model? Why black is used? you can tell me... Well it‘s only for practical purpose. Wikipedia said:

• To improve print quality and reduce moiré patterns,
• Text is typically printed in black and includes fine detail (such as serifs); so to reproduce text using three inks would require an extremely precise alignment for each three components image.
• A combination of cyan, magenta, and yellow pigments don‘t produce (or rarely) pure black.
• Mixing all three color inks together to make black can make the paper rather wet when not using dry toner, which is an issue in high speed printing where the paper must dry extremely rapidly to avoid marking the next sheet, and poor quality paper such as newsprint may break if it becomes too wet.
• Using a unit amount of black ink rather than three unit amounts of the process color inks can lead to significant cost savings (black ink is often cheaper).

Let‘s come back to our reality. A CMYK structure can be:

Hide   Shrink   Copy Code

/// <summary>
/// Structure to define CMYK.
/// </summary>
public struct CMYK
{
    /// <summary>
    /// Gets an empty CMYK structure;
    /// </summary>
    public readonly static CMYK Empty = new CMYK();

    private double c;
    private double m;
    private double y;
    private double k;

    public static bool operator ==(CMYK item1, CMYK item2)
    {
        return (
            item1.Cyan == item2.Cyan
            && item1.Magenta == item2.Magenta
            && item1.Yellow == item2.Yellow
            && item1.Black == item2.Black
            );
    }

    public static bool operator !=(CMYK item1, CMYK item2)
    {
        return (
            item1.Cyan != item2.Cyan
            || item1.Magenta != item2.Magenta
            || item1.Yellow != item2.Yellow
            || item1.Black != item2.Black
            );
    }

    public double Cyan
    {
        get
        {
            return c;
        }
        set
        {
            c = value;
            c = (c>1)? 1 : ((c<0)? 0 : c);
        }
    }

    public double Magenta
    {
        get
        {
            return m;
        }
        set
        {
            m = value;
            m = (m>1)? 1 : ((m<0)? 0 : m);
        }
    }

    public double Yellow
    {
        get
        {
            return y;
        }
        set
        {
            y = value;
            y = (y>1)? 1 : ((y<0)? 0 : y);
        }
    }

    public double Black
    {
        get
        {
            return k;
        }
        set
        {
            k = value;
            k = (k>1)? 1 : ((k<0)? 0 : k);
        }
    }

    /// <summary>
    /// Creates an instance of a CMYK structure.
    /// </summary>
    public CMYK(double c, double m, double y, double k)
    {
        this.c = c;
        this.m = m;
        this.y = y;
        this.k = k;
    }

    public override bool Equals(Object obj)
    {
        if(obj==null || GetType()!=obj.GetType()) return false;

        return (this == (CMYK)obj);
    }

    public override int GetHashCode()
    {
        return Cyan.GetHashCode() ^
          Magenta.GetHashCode() ^ Yellow.GetHashCode() ^ Black.GetHashCode();
    }

}

The YUV model defines a color space in terms of one luma and two chrominance components. The YUV color model is used in the PAL, NTSC, and SECAM composite color video standards.
YUV models human perception of color more closely than the standard RGB model used in computer graphics hardware.

The YUV color space stands for:

• Y, the luma component, or the brightness.
  • Ranges from 0 to 100% in most applications.
• U and V are the chrominance components (blue-luminance and red-luminance differences components).
  • Expressed as factors depending on the YUV version you want to use.

A graphic representation is the following image:

A YUV structure can be:

Hide   Shrink   Copy Code

/// <summary>
/// Structure to define YUV.
/// </summary>
public struct YUV
{
    /// <summary>
    /// Gets an empty YUV structure.
    /// </summary>
    public static readonly YUV Empty = new YUV();

    private double y;
    private double u;
    private double v;

    public static bool operator ==(YUV item1, YUV item2)
    {
        return (
            item1.Y == item2.Y
            && item1.U == item2.U
            && item1.V == item2.V
            );
    }

    public static bool operator !=(YUV item1, YUV item2)
    {
        return (
            item1.Y != item2.Y
            || item1.U != item2.U
            || item1.V != item2.V
            );
    }

    public double Y
    {
        get
        {
            return y;
        }
        set
        {
            y = value;
            y = (y>1)? 1 : ((y<0)? 0 : y);
        }
    }

    public double U
    {
        get
        {
            return u;
        }
        set
        {
            u = value;
            u = (u>0.436)? 0.436 : ((u<-0.436)? -0.436 : u);
        }
    }

    public double V
    {
        get
        {
            return v;
        }
        set
        {
            v = value;
            v = (v>0.615)? 0.615 : ((v<-0.615)? -0.615 : v);
        }
    }

    /// <summary>
    /// Creates an instance of a YUV structure.
    /// </summary>
    public YUV(double y, double u, double v)
    {
        this.y = (y>1)? 1 : ((y<0)? 0 : y);
        this.u = (u>0.436)? 0.436 : ((u<-0.436)? -0.436 : u);
        this.v = (v>0.615)? 0.615 : ((v<-0.615)? -0.615 : v);
    }

    public override bool Equals(Object obj)
    {
        if(obj==null || GetType()!=obj.GetType()) return false;

        return (this == (YUV)obj);
    }

    public override int GetHashCode()
    {
        return Y.GetHashCode() ^ U.GetHashCode() ^ V.GetHashCode();
    }

}

In opposition to the previous models, the CIE XYZ model defines an absolute color space. It is also known as the CIE 1931 XYZ color space and stands for:

• X, which can be compared to red
  • Ranges from 0 to 0.9505
• Y, which can be compared to green
  • Ranges from 0 to 1.0
• Z, which can be compared to blue
  • Ranges from 0 to 1.089

Before trying to explain why I include this color space in this article, you have to know that it‘s one of the first standards created by the International Commission on Illumination (CIE) in 1931. It is based on direct measurements of the human eye, and serves as the basis from which many other color spaces are defined.

A graphic representation is the following image:

A CIE XYZ structure can be:

Hide   Shrink   Copy Code

/// <summary>
/// Structure to define CIE XYZ.
/// </summary>
public struct CIEXYZ
{
    /// <summary>
    /// Gets an empty CIEXYZ structure.
    /// </summary>
    public static readonly CIEXYZ Empty = new CIEXYZ();
    /// <summary>
    /// Gets the CIE D65 (white) structure.
    /// </summary>
    public static readonly CIEXYZ D65 = new CIEXYZ(0.9505, 1.0, 1.0890);


    private double x;
    private double y;
    private double z;

    public static bool operator ==(CIEXYZ item1, CIEXYZ item2)
    {
        return (
            item1.X == item2.X
            && item1.Y == item2.Y
            && item1.Z == item2.Z
            );
    }

    public static bool operator !=(CIEXYZ item1, CIEXYZ item2)
    {
        return (
            item1.X != item2.X
            || item1.Y != item2.Y
            || item1.Z != item2.Z
            );
    }

    /// <summary>
    /// Gets or sets X component.
    /// </summary>
    public double X
    {
        get
        {
            return this.x;
        }
        set
        {
            this.x = (value>0.9505)? 0.9505 : ((value<0)? 0 : value);
        }
    }

    /// <summary>
    /// Gets or sets Y component.
    /// </summary>
    public double Y
    {
        get
        {
            return this.y;
        }
        set
        {
            this.y = (value>1.0)? 1.0 : ((value<0)?0 : value);
        }
    }

    /// <summary>
    /// Gets or sets Z component.
    /// </summary>
    public double Z
    {
        get
        {
            return this.z;
        }
        set
        {
            this.z = (value>1.089)? 1.089 : ((value<0)? 0 : value);
        }
    }

    public CIEXYZ(double x, double y, double z)
    {
        this.x = (x>0.9505)? 0.9505 : ((x<0)? 0 : x);
        this.y = (y>1.0)? 1.0 : ((y<0)? 0 : y);
        this.z = (z>1.089)? 1.089 : ((z<0)? 0 : z);
    }

    public override bool Equals(Object obj)
    {
        if(obj==null || GetType()!=obj.GetType()) return false;

        return (this == (CIEXYZ)obj);
    }

    public override int GetHashCode()
    {
        return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();
    }

}

Well! why do I have to include this model?

I have made a quick research to include Cie L*a*b* color model in this article, and I find that a conversion to an absolute color space is required before converting to L*a*b*. The model used in the conversion principle is Cie XYZ. So, I‘ve included it and now everyone can understand "what are those XYZ values" used further in the article.

"A Lab color space is a color-opponent space with dimension L for luminance and a and b for the color-opponent dimensions, based on nonlinearly-compressed CIE XYZ color space coordinates."

As said in the previous definition, CIE L*a*b* color space, also know as CIE 1976 color space, stands for:

• L*, the luminance
• a*, the red/green color-opponent dimension
• b*, the yellow/blue color-opponent dimension

The L*a*b* color model has been created to serve as a device independent model to be used as a reference. It is based directly on the CIE 1931 XYZ color space as an attempt to linearize the perceptibility of color differences.

The non-linear relations for L*, a*, and b* are intended to mimic the logarithmic response of the eye, coloring information is referred to the color of the white point of the system.

A CIE L*a*b* structure can be:

Hide   Shrink   Copy Code

/// <summary>
/// Structure to define CIE L*a*b*.
/// </summary>
public struct CIELab
{
    /// <summary>
    /// Gets an empty CIELab structure.
    /// </summary>
    public static readonly CIELab Empty = new CIELab();

    private double l;
    private double a;
    private double b;


    public static bool operator ==(CIELab item1, CIELab item2)
    {
        return (
            item1.L == item2.L
            && item1.A == item2.A
            && item1.B == item2.B
            );
    }

    public static bool operator !=(CIELab item1, CIELab item2)
    {
        return (
            item1.L != item2.L
            || item1.A != item2.A
            || item1.B != item2.B
            );
    }


    /// <summary>
    /// Gets or sets L component.
    /// </summary>
    public double L
    {
        get
        {
            return this.l;
        }
        set
        {
            this.l = value;
        }
    }

    /// <summary>
    /// Gets or sets a component.
    /// </summary>
    public double A
    {
        get
        {
            return this.a;
        }
        set
        {
            this.a = value;
        }
    }

    /// <summary>
    /// Gets or sets a component.
    /// </summary>
    public double B
    {
        get
        {
            return this.b;
        }
        set
        {
            this.b = value;
        }
    }

    public CIELab(double l, double a, double b)
    {
        this.l = l;
        this.a = a;
        this.b = b;
    }

    public override bool Equals(Object obj)
    {
        if(obj==null || GetType()!=obj.GetType()) return false;

        return (this == (CIELab)obj);
    }

    public override int GetHashCode()
    {
        return L.GetHashCode() ^ a.GetHashCode() ^ b.GetHashCode();
    }

}

H ? [0, 360]

S, V, R, G, B ? [0, 1]

V = MAX

Hide   Shrink   Copy Code

/// <summary>
/// Converts RGB to HSB.
/// </summary>
public static HSB RGBtoHSB(int red, int green, int blue)
{
    // normalize red, green and blue values
    double r = ((double)red/255.0);
    double g = ((double)green/255.0);
    double b = ((double)blue/255.0);

    // conversion start
    double max = Math.Max(r, Math.Max(g, b));
    double min = Math.Min(r, Math.Min(g, b));

    double h = 0.0;
    if(max==r && g>=b)
    {
        h = 60 * (g-b)/(max-min);
    }
    else if(max==r && g < b)
    {
        h = 60 * (g-b)/(max-min) + 360;
    }
    else if(max == g)
    {
        h = 60 * (b-r)/(max-min) + 120;
    }
    else if(max == b)
    {
        h = 60 * (r-g)/(max-min) + 240;
    }

    double s = (max == 0)? 0.0 : (1.0 - (min/max));

    return new HSB(h, s, (double)max);
}

H ? [0, 360]

S, L, R, G, B ? [0, 1]

L = ½(MAX + MIN)

Hide   Shrink   Copy Code

/// <summary>
/// Converts RGB to HSL.
/// </summary>
/// <param name="red">Red value, must be in [0,255].</param>
/// <param name="green">Green value, must be in [0,255].</param>
/// <param name="blue">Blue value, must be in [0,255].</param>
public static HSL RGBtoHSL(int red, int green, int blue)
{
    double h=0, s=0, l=0;

    // normalize red, green, blue values
    double r = (double)red/255.0;
    double g = (double)green/255.0;
    double b = (double)blue/255.0;

    double max = Math.Max(r, Math.Max(g, b));
    double min = Math.Min(r, Math.Min(g, b));

    // hue
    if(max == min)
    {
        h = 0; // undefined
    }
    else if(max==r && g>=b)
    {
        h = 60.0*(g-b)/(max-min);
    }
    else if(max==r && g<b)
    {
        h = 60.0*(g-b)/(max-min) + 360.0;
    }
    else if(max==g)
    {
        h = 60.0*(b-r)/(max-min) + 120.0;
    }
    else if(max==b)
    {
        h = 60.0*(r-g)/(max-min) + 240.0;
    }

    // luminance
    l = (max+min)/2.0;

    // saturation
    if(l == 0 || max == min)
    {
        s = 0;
    }
    else if(0<l && l<=0.5)
    {
        s = (max-min)/(max+min);
    }
    else if(l>0.5)
    {
        s = (max-min)/(2 - (max+min)); //(max-min > 0)?
    }

    return new HSL(
        Double.Parse(String.Format("{0:0.##}", h)),
        Double.Parse(String.Format("{0:0.##}", s)),
        Double.Parse(String.Format("{0:0.##}", l))
        );
}

R, G, B ? [0, 1]

tC‘M‘Y‘ = {1 - R, 1 - G, 1 - B}

K = min{C‘, M‘, Y‘}

tCMYK = {0, 0, 0, 1} if K = 1

tCMYK = { (C‘ - K)/(1 - K), (M‘ - K)/(1 - K), (Y‘ - K)/(1 - K), K } otherwise

R, G, B, Y ? [0, 1]

U ? [-0.436, 0.436]

V ? [-0.615, 0.615]

tYUV = { (0.299 R + 0.587 G + 0.114 B), (- 0.14713 R + 0.28886 G + 0.436 B), (0.615 R + 0.51499 G + 0.10001 B) }

R, G, B ? [0, 1]

a = 0.055 and ? ˜ 2.2

where

a - HSB to RGB

The conversion principle is the one below :

The C# equivalent? Here it is.

Hide   Shrink   Copy Code

/// <summary>
/// Converts HSB to RGB.
/// </summary>
public static RGB HSBtoRGB(double h, double s, double b)
{
    double r = 0;
    double g = 0;
    double b = 0;

    if(s == 0)
    {
        r = g = b = b;
    }
    else
    {
        // the color wheel consists of 6 sectors. Figure out which sector
        // you‘re in.
        double sectorPos = h / 60.0;
        int sectorNumber = (int)(Math.Floor(sectorPos));
        // get the fractional part of the sector
        double fractionalSector = sectorPos - sectorNumber;

        // calculate values for the three axes of the color.
        double p = b * (1.0 - s);
        double q = b * (1.0 - (s * fractionalSector));
        double t = b * (1.0 - (s * (1 - fractionalSector)));

        // assign the fractional colors to r, g, and b based on the sector
        // the angle is in.
        switch(sectorNumber)
        {
            case 0:
                r = b;
                g = t;
                b = p;
                break;
            case 1:
                r = q;
                g = b;
                b = p;
                break;
            case 2:
                r = p;
                g = b;
                b = t;
                break;
            case 3:
                r = p;
                g = q;
                b = b;
                break;
            case 4:
                r = t;
                g = p;
                b = b;
                break;
            case 5:
                r = b;
                g = p;
                b = q;
                break;
        }
    }

    return new RGB(
        Convert.ToInt32( Double.Parse(String.Format("{0:0.00}", r*255.0)) ),
        Convert.ToInt32( Double.Parse(String.Format("{0:0.00}", g*255.0)) ),
        Convert.ToInt32( Double.Parse(String.Format("{0:0.00}", b*255.0)) )
    );
}

b - HSB to HSL

Conversion principle is quite simple (but not accurate): convert to RGB and then to HSL.

/// <summary>
/// Converts HSB to HSL.
/// </summary>
public static HSL HSBtoHSL(double h, double s, double b)
{
    RGB rgb = HSBtoRGB(h, s, b);

    return RGBtoHSL(rgb.Red, rgb.Green, rgb.Blue);
}

c - HSB to CMYK

Nothing new : conversion principle is to convert to RGB and then to CMYK.

/// <summary>
/// Converts HSB to CMYK.
/// </summary>
public static CMYK HSBtoCMYK(double h, double s, double b)
{
    RGB rgb = HSBtoRGB(h, s, b);

    return RGBtoCMYK(rgb.Red, rgb.Green, rgb.Blue);
}

d - HSB to YUV

Nothing new : conversion principle is to convert to RGB and then to YUV.

/// <summary>
/// Converts HSB to CMYK.
/// </summary>
public static YUV HSBtoYUV(double h, double s, double b)
{
    RGB rgb = HSBtoRGB(h, s, b);

    return RGBtoYUV(rgb.Red, rgb.Green, rgb.Blue);
}

H ? [0, 360]

S, L, R, G, B ? [0, 1]

if L < 0.5 ? Q = L × (1 + S)
if L = 0.5 ? Q = L + S – (L × S)

P = 2 × L – Q

Hk = H / 360

Tr = Hk + 1/3

Tg = Hk

Tb = Hk – 1/3

For each c = R,G,B :

if Tc < 0 ? Tc = Tc + 1.0
if Tc > 1 ? Tc = Tc – 1.0

if Tc < 1/6 ? Tc = P + ((Q – P) × 6.0 × Tc)
if 1/6 = Tc > 1/2 ? Tc = Q
if 1/2 = Tc > 2/3 ? Tc = P + ((Q – P) × (2/3 – Tc) × 6.0)
else Tc = P

R, G, B, Y ? [0, 1]

U ? [-0.436, 0.436]

V ? [-0.615, 0.615]

tRGB = { (Y + 1.13983 V), (Y - 0.39466 U - 0.58060 V), (Y + 2.03211 U) }

a = 0.055

then

for t > 0.008856

otherwise

Xn, Yn and Zn are the CIE XYZ tristimulus values of the reference white point.

d = 6/29

if then else

if then else

if then else