RGB与Lab转换

公式

我们获取的图片通常属于sRGB色彩空间，其中典型的图片格式如JPEG和PNG均属于此。所以我们通常所讲的RGB其实指的是sRGB，所以所谓的RGB与Lab的转换，更严格一点讲应该是sRGB与Lab的转换。

sRGB不能直接转换为Lab，需要用XYZ过渡：sRGB -> XYZ -> Lab。

反变换也一样需要XYZ过渡：Lab -> XYZ -> sRGB。

sRGB转Lab

sRGB转XYZ

分两步：

1. sRGB通过gamma变换转为RGB
2. RGB通过线性映射转为XYZ

sRGB通过gamma变换转为RGB

做gamma变换有一个注意事项：必需先将数据变到[0, 1]范围内。根据通常的认识，sRGB的数据范围应当是[0, 255]。下面的公式中我们以小写的rgb代表[0, 255]的数值范围，大写的RGB代表归一化后的[0, 1]数值范围。计算流程如下：

归一化：
$$\begin{gathered} R=r/255 \\ G=g/255 \\ B=b/255 \end{gathered}$$

gamma变换（t 代表R, G, B）：
$$t=\{\begin{array}{l}(\frac{t+0.055}{1.055}{)}^{2.4},if:t>0.04045\\ \frac{t}{12.92},else\end{array}$$
根据$t>0.04045$可得$[(t+0.055)/1.055{]}^{2.4}>0.0031308$，后者是反变换时的定义域，后面会用到。

线性变换：
$$\begin{gathered} X=0.412453\cdot R+0.357580\cdot G+0.180423\cdot B \\ Y=0.212671\cdot R+0.715160\cdot G+0.072169\cdot B \\ Z=0.019334\cdot R+0.119193\cdot G+0.950227\cdot B \end{gathered}$$
如果记线性变换矩阵为：
$$M_{RGB2XYZ}=\left[\begin{array}{ccc}0.412453& 0.357580& 0.180423\\ 0.212671& 0.715160& 0.072169\\ 0.019334& 0.119193& 0.950227\end{array}\right]$$
那么线性变换可表示为如下式子，上标T表示转置：
$$\left[\begin{array}{ccc}X& Y& Z\end{array}\right]=\left[\begin{array}{ccc}R& G& B\end{array}\right]M_{RGB2XYZ}^T$$

上述线性变换矩阵在Observer. = 2°, Illuminant = D65条件下得到，该条件与白色参考点定义相关，更具体的内容可参考如下网站：
Understanding CIE Illuminants and Observers

XYZ转Lab

下面用大写的XYZ表示上述sRGB转XYZ的结果，小写xyz表示XYZ通过白色参考点归一化后的结果，白色参考点使用Observer. = 2°, Illuminant = D65条件下的结果，是xyz_ref_white = (0.95047, 1.0, 1.08883)。那么XYZ转Lab的计算流程如下：

归一化：
$$\begin{gathered} x=X/X_{ref\_white} \\ y=Y/Y_{ref\_white} \\ z=Z/Z_{ref\_white} \end{gathered}$$

非线性变换（t 代表x, y, z）：
$$t=\{\begin{array}{l}{t}^{1/3},if:t>(\frac{6}{29}{)}^3\\ (\frac{1}{3})(\frac{29}{6}{)}^2\cdot t+\frac{16}{116},else\end{array}$$
根据t的范围$t>(6/29{)}^3$ 可得 $t^{1/3}$ > 6/29，后者是反变换时的定义域，后面会用到。

（另外要喷一下，这个分段公式在交界处函数值不连续，也不知道是根据什么道理设计出来的）

线性变换：
$$\begin{gathered} L=116\cdot y-16 \\ a=500\cdot (x-y) \\ b=200\cdot (y-z) \end{gathered}$$

Lab转sRGB

反变换只需把正变换的公式反着推一下就OK了，由于公式都比较简单，此处省略推导过程，直接罗列计算公式：

Lab转XYZ

线性变换：
$$\begin{gathered} y=(L+16)/116 \\ x=a/500+y \\ z=y-b/200 \end{gathered}$$

非线性变换（t 代表x, y, z）：
$$t=\{\begin{array}{l}{t}^3,if:t>6/29\\ (t-\frac{16}{116})\cdot 3\cdot (\frac{6}{29}{)}^2,else\end{array}$$

反归一化：
$$\begin{gathered} X=x\cdot X_{ref\_white} \\ Y=y\cdot Y_{ref\_white} \\ Z=z\cdot Z_{ref\_white} \end{gathered}$$

XYZ转sRGB

线性变换：
$$\left[\begin{array}{ccc}R& G& B\end{array}\right]=\left[\begin{array}{ccc}X& Y& Z\end{array}\right](M_{RGB2XYZ}^T{)}^{-1}$$

矩阵$M_{RGB2XYZ}$见sRGB转XYZ部分。

gamma变换（t 代表R, G, B）：
$$t=\{\begin{array}{l}1.055\cdot t^{1/2.4}-0.055,if:t>0.0031308\\ 12.92\cdot t,else\end{array}$$

裁减：
$$t=\{\begin{array}{l}1,if:t>1\\ 0,if:t<0\\ t,else\end{array}$$

反归一化：
$$\begin{gathered} r=R\cdot 255 \\ g=G\cdot 255 \\ b=B\cdot 255 \end{gathered}$$

程序

程序大体上参考了skimage.color模块的实现，但是这里主要为了配合公式进行理解，所以并没有广泛考虑数值类型的处理。所以下面程序中如果输入是RGB，那么其数值类型应当是uint8，数值范围是[0, 255]。

程序后面跟skimage.color模块的计算结果进行了比较，来检验自己的实现有没有出什么诡异的问题。

# -*- coding: utf-8 -*-
import numpy as np
from skimage import color

MAT_RGB2XYZ = np.array([[0.412453, 0.357580, 0.180423],
                        [0.212671, 0.715160, 0.072169],
                        [0.019334, 0.119193, 0.950227]])

MAT_XYZ2RGB = np.linalg.inv(MAT_RGB2XYZ)

XYZ_REF_WHITE = np.array([0.95047, 1.0, 1.08883])


def rgb_to_lab(rgb):
    """
    Convert color space from rgb to lab

    Parameters:
    -----------
    rgb: numpy array, dtype = uint8
        3-dim array, shape is [H, W, C], C must be 3

    Returns:
    --------
    numpy array in lab color space, dtype = float
    """
    return xyz_to_lab(rgb_to_xyz(rgb))


def lab_to_rgb(lab):
    """
    Convert color space from lab to rgb

    Parameters:
    -----------
    lab: numpy array, dtype = float
        3-dim array, shape is [H, W, C], C must be 3

    Returns:
    --------
    numpy array in rgb color space, dtype = uint8
    """
    return xyz_to_rgb(lab_to_xyz(lab))


def rgb_to_xyz(rgb):
    """
    Convert color space from rgb to xyz

    Parameters:
    -----------
    rgb: numpy array, dtype = uint8
        3-dim array, shape is [H, W, C], C must be 3

    Returns:
    --------
    xyz: numpy array, dtype = float
        array in xyz color space
    """
    # convert dtype from uint8 to float
    xyz = rgb.astype(np.float64) / 255.0

    # gamma correction
    mask = xyz > 0.04045
    xyz[mask] = np.power((xyz[mask] + 0.055) / 1.055, 2.4)
    xyz[~mask] /= 12.92

    # linear transform
    xyz = xyz @ MAT_RGB2XYZ.T
    return xyz


def xyz_to_rgb(xyz):
    """
    Convert color space from xyz to rgb

    Parameters:
    -----------
    xyz: numpy array, dtype = float
        3-dim array, shape is [H, W, C], C must be 3

    Returns:
    --------
    rgb: numpy array, dtype = uint8
        array in rgb color space
    """
    # linear transform
    rgb = xyz @ MAT_XYZ2RGB.T

    # gamma correction
    mask = rgb > 0.0031308
    rgb[mask] = 1.055 * np.power(rgb[mask], 1.0 / 2.4) - 0.055
    rgb[~mask] *= 12.92

    # clip and convert dtype from float to uint8
    rgb = np.round(255.0 * np.clip(rgb, 0, 1)).astype(np.uint8)
    return rgb


def xyz_to_lab(xyz):
    """
    Convert color space from xyz to lab

    Parameters:
    -----------
    xyz: numpy array, dtype = float
        3-dim array, shape is [H, W, C], C must be 3

    Returns:
    --------
    lab: numpy array, dtype = float
        array in lab color space
    """
    # normalization
    xyz /= XYZ_REF_WHITE

    # nonlinear transform
    mask = xyz > 0.008856
    xyz[mask] = np.power(xyz[mask], 1.0 / 3.0)
    xyz[~mask] = 7.787 * xyz[~mask] + 16.0 / 116.0
    x, y, z = xyz[..., 0], xyz[..., 1], xyz[..., 2]

    # linear transform
    lab = np.empty(xyz.shape)
    lab[..., 0] = (116.0 * y) - 16.0  # L channel
    lab[..., 1] = 500.0 * (x - y)  # a channel
    lab[..., 2] = 200.0 * (y - z)  # b channel
    return lab


def lab_to_xyz(lab):
    """
    Convert color space from lab to xyz

    Parameters:
    -----------
    lab: numpy array, dtype = float
        3-dim array, shape is [H, W, C], C must be 3

    Returns:
    --------
    xyz: numpy array, dtype = float
        array in xyz color space
    """
    # linear transform
    l, a, b = lab[..., 0], lab[..., 1], lab[..., 2]
    xyz = np.empty(lab.shape)
    xyz[..., 1] = (l + 16.0) / 116.0
    xyz[..., 0] = a / 500.0 + xyz[..., 1]
    xyz[..., 2] = xyz[..., 1] - b / 200.0
    index = xyz[..., 2] < 0
    xyz[index, 2] = 0

    # nonlinear transform
    mask = xyz > 0.2068966
    xyz[mask] = np.power(xyz[mask], 3.0)
    xyz[~mask] = (xyz[~mask] - 16.0 / 116.0) / 7.787

    # de-normalization
    xyz *= XYZ_REF_WHITE
    return xyz


if __name__ == '__main__':
    rgb = np.array([[[150, 150, 0]]], dtype=np.uint8)
    xyz = rgb_to_xyz(rgb)
    lab = xyz_to_lab(xyz)
    xyz_ = lab_to_xyz(lab)
    rgb_ = xyz_to_rgb(xyz_)

    print('-' * 15, ' self defined function result ', '-' * 15)
    print('rgb:', rgb)
    print('xyz:', xyz)
    print('lab:', lab)
    print('xyz_inverse:', xyz_)
    print('rgb_inverse:', rgb_)

    xyz2 = color.rgb2xyz(rgb)
    lab2 = color.xyz2lab(xyz2)
    xyz2_ = color.lab2xyz(lab2)
    rgb2_ = color.xyz2rgb(xyz2_)
    rgb2_ = np.round(255.0 * np.clip(rgb2_, 0, 1)).astype(np.uint8)

    print('-' * 15, ' skimage result ', '-' * 15)
    print('rgb:', rgb)
    print('xyz:', xyz2)
    print('lab:', lab2)
    print('xyz_inverse:', xyz2_)
    print('rgb_inverse:', rgb2_)

RGB转Lab后的数值范围

前面的内容很容易就可以在网上搜到，但是Lab类型数据的取值范围跟RGB类型的对应关系有点需要注意的地方：Lab的色域范围比RGB宽广，所以如果一个Lab的图片是由RGB转换过来的，那么它的色域无法覆盖Lab的定义范围。

接下来我们仔细算一下。

Lab数据类型的取值范围被定义为：
L：[0, 100]
a：[-128, 127]
b：[-128, 127]

下面我们写一小段程序，遍历RGB所有数值并转为Lab，然后看看转换出来的Lab的数值范围如何：

# -*- coding: utf-8 -*-
import numpy as np
from skimage import color

if __name__ == '__main__':
    rgb = np.zeros([1, 256 * 256 * 256, 3])
    index = 0
    for r in range(0, 256):
        print('\rr = %d' % r, end='')
        for g in range(0, 256):
            for b in range(0, 256):
                rgb[0, index, :] = np.array([r, g, b])
                index += 1
    print()
    rgb = np.uint8(rgb)
    lab = color.rgb2lab(rgb)

    print('L, min: %f, max: %f' % (np.min(lab[0, :, 0]), np.max(lab[0, :, 0])))
    print('a, min: %f, max: %f' % (np.min(lab[0, :, 1]), np.max(lab[0, :, 1])))
    print('b, min: %f, max: %f' % (np.min(lab[0, :, 2]), np.max(lab[0, :, 2])))

输入结果如下：

L, min: 0.000000, max: 100.000000
a, min: -86.183030, max: 98.233054
b, min: -107.857300, max: 94.478122

容易发现，L通道可以完整覆盖Lab定义的数值范围，但是a，b通道不行。

所以当我们需要对RGB转换而来的Lab数据做归一化时，a，b通道使用[-128, 127]的范围不能真正让数值归一化到[0, 1]之间。

应当使用下式（含L通道）：
$$\begin{gathered} L=L/100.0 \\ a=(a+86.183030)/184.416084 \\ b=(b+107.857300)/202.335422 \end{gathered}$$