在 .NET 中操作颜色 - 第一部分

RGB（Red、Green、Blue）颜色模型是最知名、最常用的模型。它根据三个分量定义了一个颜色空间：

• Red，范围从 0-255。
• Green，范围从 0-255。
• Blue，范围从 0-255。

RGB 颜色模型是加色模型。换句话说，Red、Green 和 Blue 值（称为三原色）组合起来以重现其他颜色。
例如，“红色”可以表示为 [R=255, G=0, B=0]，而“紫色”则可以表示为 [R=238, G=130, B=238] 等。

它的常见图形表示如下：

在 .NET 中，`Color` 结构体使用此模型通过 R、G 和 B 属性提供颜色支持。

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...

但这并不是它唯一的用途。因此，我们可以定义一个专用的 RGB 结构体用于进一步的编码，如下所示：

/// <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（色相）：颜色的类型（如红色、蓝色或黄色）。
  • 在大多数应用程序中，范围从 0 到 360°。（每个值对应一种颜色：0 是红色，45 是某种橙色，55 是某种黄色）。

HSL 颜色空间，也称为 HLS 或 HSI，代表：

• Hue（色相）：颜色的类型（如红色、蓝色或黄色）。
  • 在大多数应用程序中，范围从 0 到 360°（每个值对应一种颜色：0 是红色，45 是某种橙色，55 是某种黄色）。
• Saturation（饱和度）：颜色随明度的变化。
  • 范围从 0 到 100%（从黑白轴的中心开始）。
• Lightness（亮度）（也称为 Luminance（发光度）或 Luminosity（亮度）或 Intensity（强度））。
  • 范围从 0 到 100%（从黑色到白色）。

它的常见图形表示如下：

HSL 与 HSB 类似。主要区别在于 HSL 相对于亮度和暗度是对称的。这意味着：

• 在 HSL 中，饱和度分量始终从完全饱和的颜色变为等效的灰色（在 HSB 中，当 B 达到最大值时，它从饱和颜色变为白色）。
• 在 HSL 中，亮度始终跨越从黑色到所选色相再到白色的整个范围（在 HSB 中，B 分量只跨越一半，从黑色到所选色相）。

对我而言，HSL 提供了比 HSB 更准确（即使不是绝对）的颜色近似。

说了这么多，一个 HSL 结构体可以是：

/// <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();
    }
}

CMYK 颜色空间，也称为 CMJN，代表：

• Cyan（青色）。
  • 在大多数应用程序中，范围从 0 到 100%。
• Magenta（品红色）。
  • 在大多数应用程序中，范围从 0 到 100%。
• Yellow（黄色）。
  • 在大多数应用程序中，范围从 0 到 100%。
• blacK（黑色）。
  • 在大多数应用程序中，范围从 0 到 100%。

它是一种用于彩色印刷的减色模型。CMYK 基于一种基于光吸收的光学错觉。
其原理是叠加三个图像；一个用于青色，一个用于品红色，一个用于黄色；它们将重现颜色。

它的常见图形表示如下：

与 RGB 颜色模型一样，CMYK 是原色（青色、品红色、黄色和黑色）的组合。这可能是它们唯一的共同点。
CMYK 在颜色色调方面存在不足，导致其可重现的颜色光谱出现“漏洞”。这就是为什么在有人将颜色从 CMYK 转换为 RGB 时经常存在差异。

为什么要使用这个模型？为什么使用黑色？你可能会问……好吧，这只是出于实际目的。维基百科说：*

• 为了提高打印质量并减少摩尔纹，
• 文本通常以黑色印刷，并包含精细细节（如衬线）；因此，用三种油墨复制文本需要为每个三种组件图像进行极其精确的对齐。
• 青色、品红色和黄色颜料的混合通常（或很少）不产生纯黑色。
• 混合所有三种颜色油墨来制作黑色，如果不是使用干式碳粉，可能会使纸张变得相当湿润，这在高速度印刷中是一个问题，因为纸张必须极快地干燥以避免弄脏下一张纸，而像报纸这样的劣质纸张如果变得太湿可能会破裂。
• 使用单位量的黑色油墨而不是三单位量的过程油墨可以带来显著的成本节约（黑色油墨通常更便宜）。*

回到我们的现实。一个 CMYK 结构体可以是：

/// <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();
    }

}

YUV 模型根据一个亮度（luma）和两个色度（chrominance）分量定义一个颜色空间。YUV 颜色模型用于 PAL、NTSC 和 SECAM 复合彩色视频标准。
YUV 颜色空间比计算机图形硬件中使用的标准 RGB 模型更接近人类对颜色的感知。

YUV 颜色空间代表：

• Y，亮度分量，或亮度。
  • 在大多数应用程序中，范围从 0 到 100%。
• U 和 V 是色度分量（蓝度-亮度和红度-亮度差异分量）。
  • 表示为取决于你想要使用的 YUV 版本的因子。

图形表示如下：

一个 YUV 结构体可以是：

/// <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();
    }

}

与之前的模型相反，CIE XYZ 模型定义了一个绝对颜色空间。它也称为 CIE 1931 XYZ 颜色空间，代表：

• X，可以与红色进行比较
  • 范围从 0 到 0.9505。
• Y，可以与绿色进行比较
  • 范围从 0 到 1.0。
• Z，可以与蓝色进行比较
  • 范围从 0 到 1.089。

在尝试解释为什么我在本文中包含这个颜色空间之前，你应该知道，它是国际照明委员会 (CIE) 于 1931 年创建的第一个标准之一。它基于人眼的直接测量，并作为许多其他颜色空间定义的基准。

图形表示如下：

一个 CIE XYZ 结构体可以是：

/// <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();
    }

}

好吧！我为什么要包含这个模型？

我快速研究了一下，想在本文中包含 Cie L*a*b* 颜色模型，我发现需要先转换到绝对颜色空间，然后再转换为 L*a*b*。转换原理中使用的模型是 Cie XYZ。所以，我包含了它，现在大家都能理解文章中更进一步使用的“那些 XYZ 值”是什么了。

“Lab 颜色空间是一个颜色对抗空间，其维度 L 代表亮度，a 和 b 代表颜色对抗维度，基于非线性压缩的 CIE XYZ 颜色空间坐标。”

正如在前一个定义中所述，CIE L*a*b* 颜色空间，也称为 CIE 1976 颜色空间，代表：

• L*，亮度。
• a*，红/绿颜色对抗维度。
• b*，黄/蓝颜色对抗维度。

L*a*b* 颜色模型被创建为一种与设备无关的模型，用作参考。它直接基于 CIE 1931 XYZ 颜色空间，旨在线性化颜色差异的可感知性。

L*、a* 和 b* 的非线性关系旨在模仿人眼的对数响应，颜色信息相对于系统白点的颜色。

一个 CIE L*a*b* 结构体可以是：

/// <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

/// <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)

/// <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 且 ? ˜ 2.2

其中

a - HSB 到 RGB

转换原理如下：

C# 的等效代码？在这里。

/// <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 到 HSL

转换原理非常简单（但不准确）：先转换为 RGB，然后再转换为 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 到 CMYK

没什么新内容：转换原理是先转换为 RGB，然后再转换为 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 到 YUV

没什么新内容：转换原理是先转换为 RGB，然后再转换为 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

对于每个 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

a - YUV 到 RGB

转换原理如下：

C# 的等效代码是：

/// <summary>
/// Converts YUV to RGB.
/// </summary>
/// <param name="y">Y must be in [0, 1].</param>
/// <param name="u">U must be in [-0.436, +0.436].</param>
/// <param name="v">V must be in [-0.615, +0.615].</param>
public static RGB YUVtoRGB(double y, double u, double v)
{
    RGB rgb = new RGB();

    rgb.Red = Convert.ToInt32((y + 1.139837398373983740*v)*255);
    rgb.Green = Convert.ToInt32((
        y - 0.3946517043589703515*u - 0.5805986066674976801*v)*255);
    rgb.Blue = Convert.ToInt32((y + 2.032110091743119266*u)*255);

    return rgb;
}

b - YUV 到 HSL

没什么新内容：转换原理是先转换为 RGB，然后再转换为 HSL。

/// <summary>
/// Converts YUV to HSL.
/// </summary>
/// <param name="y">Y must be in [0, 1].</param>
/// <param name="u">U must be in [-0.436, +0.436].</param>
/// <param name="v">V must be in [-0.615, +0.615].</param>
public static HSL YUVtoHSL(double y, double u, double v)
{
    RGB rgb = YUVtoRGB(y, u, v);

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

c - YUV 到 HSB

没什么新内容：转换原理是先转换为 RGB，然后再转换为 HSB。

/// <summary>
/// Converts YUV to HSB.
/// </summary>
/// <param name="y">Y must be in [0, 1].</param>
/// <param name="u">U must be in [-0.436, +0.436].</param>
/// <param name="v">V must be in [-0.615, +0.615].</param>
public static HSB YUVtoHSB(double y, double u, double v)
{
    RGB rgb = YUVtoRGB(y, u, v);

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

d - YUV 到 CMYK

没什么新内容：转换原理是先转换为 RGB，然后再转换为 CMYK。

/// <summary>
/// Converts YUV to CMYK.
/// </summary>
/// <param name="y">Y must be in [0, 1].</param>
/// <param name="u">U must be in [-0.436, +0.436].</param>
/// <param name="v">V must be in [-0.615, +0.615].</param>
public static CMYK YUVtoCMYK(double y, double u, double v)
{
    RGB rgb = YUVtoRGB(y, u, v);

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

F - XYZ 转换

a - XYZ 到 RGB

转换原理如下：

a = 0.055

然后

C# 的等效代码是：

/// <summary>
/// Converts CIEXYZ to RGB structure.
/// </summary>
public static RGB XYZtoRGB(double x, double y, double z)
{
    double[] Clinear = new double[3];
    Clinear[0] = x*3.2410 - y*1.5374 - z*0.4986; // red
    Clinear[1] = -x*0.9692 + y*1.8760 - z*0.0416; // green
    Clinear[2] = x*0.0556 - y*0.2040 + z*1.0570; // blue

    for(int i=0; i<3; i++)
    {
        Clinear[i] = (Clinear[i]<=0.0031308)? 12.92*Clinear[i] : (
            1+0.055)* Math.Pow(Clinear[i], (1.0/2.4)) - 0.055;
    }

    return new RGB(
        Convert.ToInt32( Double.Parse(String.Format("{0:0.00}",
            Clinear[0]*255.0)) ),
        Convert.ToInt32( Double.Parse(String.Format("{0:0.00}",
            Clinear[1]*255.0)) ),
        Convert.ToInt32( Double.Parse(String.Format("{0:0.00}",
            Clinear[2]*255.0)) )
        );
}

b - XYZ 到 L*a*b*

转换原理如下：

其中
for t > 0.008856
otherwise

Xn, Yn 和 Zn 是参考白点的 CIE XYZ 三刺激值。

C# 的等效代码是：

/// <summary>
/// XYZ to L*a*b* transformation function.
/// </summary>
private static double Fxyz(double t)
{
    return ((t > 0.008856)? Math.Pow(t, (1.0/3.0)) : (7.787*t + 16.0/116.0));
}

/// <summary>
/// Converts CIEXYZ to CIELab.
/// </summary>
public static CIELab XYZtoLab(double x, double y, double z)
{
    CIELab lab = CIELab.Empty;

    lab.L = 116.0 * Fxyz( y/CIEXYZ.D65.Y ) -16;
    lab.A = 500.0 * (Fxyz( x/CIEXYZ.D65.X ) - Fxyz( y/CIEXYZ.D65.Y) );
    lab.B = 200.0 * (Fxyz( y/CIEXYZ.D65.Y ) - Fxyz( z/CIEXYZ.D65.Z) );

    return lab;
}

G - L*a*b* 转换

a - L*a*b* 到 XYZ

转换原理如下：

d = 6/29

if then else
if then else
if then else

C# 的等效代码是：

/// <summary>
/// Converts CIELab to CIEXYZ.
/// </summary>
public static CIEXYZ LabtoXYZ(double l, double a, double b)
{
    double delta = 6.0/29.0;

    double fy = (l+16)/116.0;
    double fx = fy + (a/500.0);
    double fz = fy - (b/200.0);

    return new CIEXYZ(
        (fx > delta)? CIEXYZ.D65.X * (fx*fx*fx) : (fx - 16.0/116.0)*3*(
            delta*delta)*CIEXYZ.D65.X,
        (fy > delta)? CIEXYZ.D65.Y * (fy*fy*fy) : (fy - 16.0/116.0)*3*(
            delta*delta)*CIEXYZ.D65.Y,
        (fz > delta)? CIEXYZ.D65.Z * (fz*fz*fz) : (fz - 16.0/116.0)*3*(
            delta*delta)*CIEXYZ.D65.Z
        );
}

b - L*a*b* 到 RGB

没什么特别新的，原理是先转换为 XYZ，然后再转换为 RGB。

/// <summary>
/// Converts CIELab to RGB.
/// </summary>
public static RGB LabtoRGB(double l, double a, double b)
{
    return XYZtoRGB( LabtoXYZ(l, a, b) );
}

使用代码

好了，展示了转换算法后，也许我没有什么可以告诉你的了。

事实上，ColorSpaceHelper 中还有许多其他有用的方法。你会发现：

• 平均颜色实现（ColorSpaceHelper.GetColorDistance()）。
• 色轮颜色生成（ColorSpaceHelper.GetWheelColors()），支持 32 位（alpha）。
• 光谱颜色生成（ColorSpaceHelper.GetSpectrumColors()），支持 32 位（alpha）。
• 与网页颜色的相互转换（ColorSpaceHelper.HexToColor()）。
• 与 System.Drawing.Color 和其他结构体之间的相互转换。

关注点

正如我之前所说，格式有很多种。本文提供了一个关于如何使用常见颜色模型（RGB、HSL、HSB 等）的示例，也许能帮助你完成自己的项目。

以下是我们能够做到的（以及我们将在下一篇文章中看到的）ColorSpaceHelper 的预览：

历史

• 2007 年 6 月 8 日
  • 添加了 GraGra_33 VB .NET 版本。
• 2007 年 6 月 7 日
  • 添加了 CIE XYZ 颜色空间定义，以及 ColorSpaceHelper 中的转换方法。
  • 添加了 CIE L*a*b* 颜色空间定义，以及 ColorSpaceHelper 中的转换方法。
• 2007 年 6 月 3 日 - 初始文章。