OpenCV中的RGB与YUV转换

1 基本概念

        YUV 颜色空间从模拟电视时代开始就被广泛应用于彩色图像的转换与处理。其基于一个 3x3 的矩阵,通过线性变换将 RGB 像素转换为一个亮度(Luma)分量 Y 以及两个色度(Chroma)分量 U 和 V。由于模拟电视存在着多种制式,如 NTSC 与 PAL 等等,考虑到具体硬件与技术上的差异,它们通常会采用不同的转换矩阵系数。即便到了如今的数字电视时代,业界依旧会保留这些差异以保证兼容性,但同时又会根据需求发展出更多新的转换系数。这就导致了 YUV 颜色空间其实是一个非常混乱的概念,甚至于 YUV 本身也只是一个约定俗成的统称,其实际可能为 YCbCr, Y’CbCr, Y’UV, YPbPr, YCC 等等标准叫法中的一种。因此,如果不清楚具体的转换系数,在 RGB 转 YUV 再转回 RGB 的过程中就可能存在转换矩阵不互逆而产生颜色偏差的问题。但是,要完整地阐明 YUV 的各种转换系数是比较困难的,具体可网上查阅 Wiki 等相关资料。本文主要从实用性出发,对 OpenCV 中的 YUV 颜色空间转换进行一些梳理,毕竟 OpenCV 在图像预处理中是非常常用的。

        首先要说明的是,尽管 RGB 与 YUV 的转换可通过一个 3x3 的矩阵变换来实现,但实际上这个 3x3 矩阵中的 9 个数字并不是完全独立选取的。YUV 另一个比较通用的叫法是 YCbCr,即 U 对应 Cb,V 对应 Cr。YCbCr 中的亮度 Y 由 R / G / B 加权求和所得,对应的是单通道的灰度图;而 Cb 反映了蓝色 B 分量与亮度 Y 的差异,Cr 反映了红色 R 分量与亮度 Y 的差异,Cb 与 Cr 统称为色差或色度。具体的转换公式如下:

Y  = R2Y * R + G2Y * G + B2Y * B
Cb = (B - Y) * YCB + delta
Cr = (R - Y) * YCR + delta

其中 [ R2Y, G2Y, B2Y, YCB, YCR ] 决定了不同的转换矩阵,它们都是非负的。由于 Cb 与 Cr 反映的是色差,所以它们的数值分布应该关于原点 0 对称,因此需要加上一个 delta 偏移使其尽量落在与 Y 一致的区间,常用的是 delta = 128。通常来说,RGB 与 YUV 的转换不是正交变换,因此对于 256 x 256 x 256 正立方体分布的 RGB 值,转换所得的 YUV 分布并不同样满足正立方体的分布,而通常是一个截断的锥体。如果在 YUV 转换回 RGB 时使用了锥体外的 YUV 值,所得 RGB 值在现实中则是不存在的,因而也无法显示。

        对于 RGB 转 YUV 或者 YUV 转 RGB,OpenCV 可通过调用 dst = cvtColor(src, code) 来实现,code 决定了所使用的转换系数以及 srcdst 的存储格式。注意,OpenCV 通常使用 BGR 而非 RGB 颜色顺序,但其依旧保留了对 RGB 顺序输入的支持,它们除了内存访问顺序不一样外并没有什么区别,因此在后续讨论 code 时,文章不会对 BGR 与 RGB 进行区分。通过查阅 OpenCV 源码中的 imgproc.hpp,可得 code 主要有:

// YCbCr 4:4:4  <-->  BGR
COLOR_BGR2YCrCb    = 36,
COLOR_YCrCb2BGR    = 38,
// YUV 4:4:4  <-->  BGR
COLOR_BGR2YUV      = 82, 
COLOR_YUV2BGR      = 84,
// YUV_FOCC 4:2:0  -->  BGR
COLOR_YUV2BGR_NV12  = 91,
COLOR_YUV2BGR_NV21  = 93,
COLOR_YUV420sp2BGR  = COLOR_YUV2BGR_NV21,
COLOR_YUV2BGR_YV12  = 99,
COLOR_YUV2BGR_IYUV  = 101,
COLOR_YUV2BGR_I420  = COLOR_YUV2BGR_IYUV,
COLOR_YUV420p2BGR   = COLOR_YUV2BGR_YV12,
// YUV_FOCC 4:2:2  -->  BGR
COLOR_YUV2BGR_UYVY = 108,
COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY,
COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY,
COLOR_YUV2BGR_YUY2 = 116,
COLOR_YUV2BGR_YVYU = 118,
COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2,
COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2,
// BGR  <-->  YUV_FOCC 4:2:0
COLOR_BGR2YUV_I420  = 128,
COLOR_BGR2YUV_IYUV  = COLOR_BGR2YUV_I420,
COLOR_BGR2YUV_YV12  = 132,

可以看到,关于 RGB 与 YUV 转换的命名非常繁杂混乱,但以上的 code 实际所涉及的转换系数可分为三类。其中,第一类为 COLOR_BGR2YUV 及其反变换 COLOR_YUV2BGR;第二类为 COLOR_BGR2YCrCb 及其反变换 COLOR_YCrCb2BGR;第三类为带有 FOCC (Four-Character Code) 后缀的 COLOR_BGR2YUV_FOCC 及其反变换 COLOR_YUV2BGR_FOCC。而通过进一步探究,可知前两类用于非下采样 YUV 的转换,而第三类则用于经过下采样的 YUV 的转换。在这里我们先简单地介绍一下 YUV 的下采样格式,这对于后续的理解十分有帮助。

        YUV 由一个亮度分量 Y 与两个色度分量 U 和 V 组成,而根据色彩科学的研究,人眼对亮度变化更加敏感,而对色度变化的感知则比较弱。因此,为了降低图像数据传输所需的带宽,通常会对色度分量 U 和 V 进行下采样,同时完整地保留 Y,这样可以尽可能地以较低成本维持相同的视觉主观体验。一般来说,U 和 V 的下采样位置是一样的。色度分量的下采样通常以每相邻的 4 个像素作为一个下采样单位,在其中保留 1 或 2 或 4 个像素,然而这相邻 4 个像素以及保留像素的选取方式是多样的,这就产生了非常繁杂的下采样格式,它们通常用 YUV 4 : m : n 来表示。下图是三种比较常用的下采样格式。

YUV 4 : m : n 通常是一种约定俗成的概念,m 与 n 并不一定具有实际意义。YUV 4:4:4 等同于保留所有的色度像素,这种格式通常只在 YUV 与 RGB 转换时使用。YUV 4:2:2 表示色度分量在水平方向上进行 1/2 的下采样,而垂直方向则不进行下采样,即 4 个像素中只保留 2 个,其中水平方向 1/2 下采样通常保留左侧像素而丢弃右侧像素,但这并不是强制的,在具体硬件实现中通常有多种模式选择,包括只保留右侧像素,或者两个像素求平均等等。YUV 4:2:2 通常只用在比较高端的摄像机图像处理芯片中。YUV 4:2:0 表示水平与垂直方向都进行 1/2 的下采样,即 4 个像素只保留 1 个,通常为左上角像素,但正如 YUV 4:2:2,其具体的实现也是可选的。YUV 4:2:0 是绝大多数图像处理芯片所使用的格式。YUV 4:1:1 类似于 YUV 4:2:0 只保留 4 个像素中的 1 个,但其只在水平方向上进行 1/4 的下采样,而垂直方向则完整保留,这种格式的应用相对较少。除了以上的格式以外,我们通常用 YUV 4:0:0 来表示灰度图,即只保留亮度 Y 而完全丢弃色度 U 和 V。当需要从下采样格式恢复到完整的 4:4:4 格式时,通常只需要把下采样时所保留的像素复制到所丢弃的像素位置即可,当然这不可避免会导致失真,但由于人眼对色度变化不敏感,这种失真是可接受的。

2 YUV 4:4:4 转换

        对于非下采样 YUV,或者称为 YUV 4:4:4 格式,OpenCV 提供了两类转换系数。

        对于第一类 COLOR_BGR2YUV 及其反变换 COLOR_YUV2BGR,虽然它的名字非常符合我们的认知直觉,但根据 Wikipedia 其应该属于比较久远的 BT.470 标准,目前已不多用。在 OpenCV 源码的 color_yuv.simd.hpp 中,可以看到

//to YUV
static const float B2YF = 0.114f;
static const float G2YF = 0.587f;
static const float R2YF = 0.299f;
static const float B2UF = 0.492f;
static const float R2VF = 0.877f;

代入前面的转换公式,可得具体的转换系数与公式如下:

[ Y U V ] = [ 0.299 0.587 0.114 − 0.147 − 0.289 0.436 0.615 − 0.515 − 0.100 ] [ R G B ] + [ 0 128 128 ] \left[ {\begin{array}{c} Y \\ U \\ V \end{array}} \right] = \left[ {\begin{array}{c} {0.299}&{0.587}&{0.114} \\ { - 0.147}&{ - 0.289}&{0.436} \\ {0.615}&{ - 0.515}&{ - 0.100} \end{array}} \right]\left[ {\begin{array}{c} R \\ G \\ B \end{array}} \right] + \left[ {\begin{array}{c} 0 \\ {128} \\ {128} \end{array}} \right] YUV = 0.2990.1470.6150.5870.2890.5150.1140.4360.100 RGB + 0128128

[ R G B ] = [ 1 0 1.140 1 − 0.395 − 0.581 1 2.032 0 ] [ Y U − 128 V − 128 ] \left[ {\begin{array}{c} R \\ G \\ B \end{array}} \right] = \left[ {\begin{array}{c} 1&0&{1.140} \\ 1&{ - 0.395}&{ - 0.581} \\ 1&{2.032}&0 \end{array}} \right]\left[ {\begin{array}{c} Y \\ {U - 128} \\ {V - 128} \end{array}} \right] RGB = 11100.3952.0321.1400.5810 YU128V128

要注意到,当 R = G = 0 , B = 255 R=G=0, B=255 R=G=0,B=255 时, U U U 取得最大值 U m a x = 239 U_{max}=239 Umax=239。依此计算,可得 Y ∈ [ 0 , 255 ] Y \in [0, 255] Y[0,255] U ∈ [ 17 , 239 ] U \in [17, 239] U[17,239] V ∈ [ − 29 , 285 ] V \in [-29, 285] V[29,285]。因此,Y / U / V 三者的量程在 BT.470 标准下并不一样,这大概是为了弥补模拟电视对于不同分量的响应差异。在数字信号处理中,因为图像通常使用 uint8 来表示像素值,所以 V 在存储前需要截断,从而丢失部分色彩信息。

        对于第二类 COLOR_BGR2YCrCb 及其反变换 COLOR_YCrCb2BGR,要注意的是 OpenCV 使用的是 YCrCb 而非 YUV 所对应的 YCbCr 顺序,在使用时应该小心,但具体这么做的原因未知。实际上 COLOR_BGR2YCrCb 所使用的转换系数才是我们比较熟知且常用的 BT.601 标准。在 OpenCV 源码的 color_yuv.simd.hpp 中,可以看到

//to YCbCr
static const float B2YF = 0.114f;
static const float G2YF = 0.587f;
static const float R2YF = 0.299f;
static const float YCBF = 0.564f; // == 1/2/(1-B2YF)
static const float YCRF = 0.713f; // == 1/2/(1-R2YF)

代入转换公式,可得具体的转换系数与公式如下:

[ Y C b C r ] = [ 0.299 0.587 0.114 − 0.169 − 0.331 0.500 0.500 − 0.419 − 0.081 ] [ R G B ] + [ 0 128 128 ] \left[ {\begin{array}{c} Y \\ {Cb} \\ {Cr} \end{array}} \right] = \left[ {\begin{array}{c} {0.299}&{0.587}&{0.114} \\ { - 0.169}&{ - 0.331}&{0.500} \\ {0.500}&{ - 0.419}&{ - 0.081} \end{array}} \right]\left[ {\begin{array}{c} R \\ G \\ B \end{array}} \right] + \left[ {\begin{array}{c} 0 \\ {128} \\ {128} \end{array}} \right] YCbCr = 0.2990.1690.5000.5870.3310.4190.1140.5000.081 RGB + 0128128

[ R G B ] = [ 1 0 1.402 1 − 0.344 − 0.714 1 1.772 0 ] [ Y C b − 128 C r − 128 ] \left[ {\begin{array}{c} R \\ G \\ B \end{array}} \right] = \left[ {\begin{array}{c} 1&0&{1.402} \\ 1&{ - 0.344}&{ - 0.714} \\ 1&{1.772}&0 \end{array}} \right]\left[ {\begin{array}{c} Y \\ {Cb - 128} \\ {Cr - 128} \end{array}} \right] RGB = 11100.3441.7721.4020.7140 YCb128Cr128

通过对比 COLOR_BGR2YUV 的转换公式,可知它们的亮度分量是相等的,但不同的地方在于 YCbCr 各个分量的量程都为 [ 0 , 255 ] [0, 255] [0,255],从而无需截断即可存储在 uint8 类型内,而这正是为了适应数字信号处理而对色度分量范围的调整。不考虑存储精度的损失,使用 COLOR_BGR2YCrCb 及其反变换 COLOR_YCrCb2BGR 进行颜色空间转换不会造成颜色失真。注意,在旧版本的 OpenCV 中,可能还存在 COLOR_BGR2YCR_CB,它和 COLOR_BGR2YCrCb 其实是一个东西,一般不使用。

3 YUV 下采样格式转换

        除了支持 YUV 4:4:4 格式的颜色空间转换以外,OpenCV 还支持 RGB 直接转换为 YUV 下采样格式,或者 YUV 下采样格式直接转换为 RGB,也就是前面所说的第三类 code。第三类 code 可表示为带有某个 FOCC 后缀的 COLOR_BGR2YUV_FOCC 以及反变换的 COLOR_YUV2BGR_FOCC,其中 FOCC 指由 4 个 ASCII 字符所组成的代码,即 Four-Character Code,有点类似于 C/C++ 中的 enumFOCC 在个人程序中通常可以任意定义,但是也存在一些约定俗成或者标准化的命名,例如编解码标准中的 JPEG, MPG4, H264 等等。在第一节中,我们提到过 YUV 中的色度分量通常要进行下采样以节省系统带宽。进一步地,经过下采样后的 YUV 数据中亮度和色度的像素个数是不一样的,我们不能像 RGB 那样将其表示为一个 [H, W, 3] 的矩阵,所以下采样的 YUV 数据存在多种不同的存储方式,这些就构成了各种繁乱的关于 YUV 格式的 FOCC

        为了正确使用 OpenCV 进行下采样格式的 YUV 数据颜色空间转换,这里简单地对 YUV 的存储方式进行介绍。常用的存储方式分为三种,即 Planar, Semi-Planar 以及 Interleave

  • Planar 即平面式存储。其在内存空间中先完整地顺序存储所有 Y 像素,然后再完整地顺序存储所有经过下采样的 U 数据,最后完整地顺序存储所有经过下采样的 V 数据,例如 Y1 Y2 Y3 … Yend U1 U2 U3 … Uend V1 V2 V3 … Vend。它的优点是可以适应任意的下采样格式,并且在只对单个分量如 Y 分量进行操作时无需对其他分量进行存取,缺点是在内存中 Y / U / V 数据间的跨度太大,当需要同时处理 Y / U / V 数据时不利于数据的连续突发传输,或者需要多个数据并行存取分支。注意,有时候也会先存储 V 再存储 U,这时要通过具体的 FOCC 进行区分。

  • Semi-Planar 即半平面式存储。其在内存空间中也是先完整地顺序存储所有 Y 像素,但由于 U 和 V 的数据量是相等的,且绝大多数算法都需要同时用到 U 和 V,所以 U 和 V 之间并不需要分开存储,而是可以进行交叉,例如 Y1 Y2 Y3 … Yend U1 V1 U2 V2 U3 V3 … Uend Vend。它也具有 Planar 格式的适应性以及亮度与色度分量独立存储的优点,但是能够将 U 和 V 的数据访问操作进行合并,改善了内存突发传输性能,所以 Semi-Planar 格式在硬件中反而是更加常用的。和 Planar 同理,有时候也会先存储 V 再存储 U,这时要通过具体的 FOCC 进行区分。

  • Interleave 即交叉式存储。不同于 Semi-Planar 只将 U 和 V 进行交叉,Interleave 将 Y / U / V 数据都交织在一起,可以最大化 YUV 数据的突发传输性能,缺点是在只需要亮度分量时必须把色度分量也进行传输。它通常用于亮度与色度数据量相等的情况,如 YUV 4:2:2 格式,这时两个 Y 对应着一个 U 和一个 V,根据四者的顺序的不同存在着多种 Interleave 格式,并对应着不同的 FOCC。YUV 4:2:2 常用的交叉式存储顺序有 YUYV, YVYU, UYVY, VYUY 等等,其中的两个 Y 需按像素顺序排列。例如对于 YUYV,在内存中有 Y1 U1 Y2 V1 Y3 U2 Y4 V2 …。实际上,大多数硬件都支持内存隔点并行存取的操作,因此对于 YUV 4:2:2 而言,将亮度与色度分量进行交叉存储并不会造成太大的数据传输负担,所以 YUV 4:2:2 数据的处理通常采用此存储格式。

        在第一节中我们已经列出了 OpenCV 所支持的 FOCC,但要注意 COLOR_BGR2YUV_FOCCCOLOR_YUV2BGR_FOCC 所支持的 FOCC 并不是对称的,例如 COLOR_BGR2YUV_FOCC 并不支持 RGB 到 YUV 4:2:2 的转换,如果有这方面的需求则需要利用第二节的 COLOR_BGR2YCrCb 将 RGB 转换到 YUV 4:4:4 并手动进行下采样。不过要注意的是,COLOR_BGR2YCrCbCOLOR_BGR2YUV_FOCC 的转换系数是有差异的,这个留到后面讨论。另外有些 FOCC 的意义是重复的。这里先对各个 FOCC 所对应的下采样及存储格式进行明确:

  • NV12 :YUV 4:2:0 Semi-Planar格式,其中色度分量先存 U 再存 V。
  • NV21 / 420S :YUV 4:2:0 Semi-Planar格式,其中色度分量先存 V 再存 U。
  • IYUV / I420 :YUV 4:2:0 Planar 格式,其中色度分量先存 U 再存 V。
  • YV12 / 420P :YUV 4:2:0 Planar 格式,其中色度分量先存 V 再存 U。
  • UYVY / Y222 / UYNV :YUV 4:2:2 Interleave 格式,存储顺序为 UYVY。
  • YUY2 / YUYV / YUNV :YUV 4:2:2 Interleave 格式,存储顺序为 YUYV。
  • YVYU :YUV 4:2:2 Interleave 格式,存储顺序为 YVYU。

        在 OpenCV 中,虽然 YUV 经过了下采样,但还是会把 YUV 数据打包为一个矩阵方便处理。对于 YUV 4:2:0,色度分量 U 和 V 的尺寸分别为亮度 Y 的 1/4,为了将它们打包在一起,OpenCV 使用一个 [H*3/2, W] 的二维矩阵进行存储,其中 [:H, :W] 存储的是 Y 数据,而 [H : H+H/2, :W] 则根据 Planar 或 Semi-Planar 格式顺序对 U 和 V 数据进行存储。根据以上的 FOCC 对应的格式,它们在二维矩阵中的分布如下图所示:

而对于 YUV 4:2:2,色度分量 U 和 V 的尺寸分别为亮度 Y 的 1/2,即色度分量的数据量和亮度分量是一样的,所以 OpenCV 使用一个 [H, W, 2] 的三维矩阵进行存储。因为矩阵在内存中的索引顺序通常从最后的维度开始,所以根据 FOCC 顺序对 YUV 4:2:2 数据进行存储时,应该在两个 [H, W] 平面上交替写入。以 UYVY 为例,它们在三维矩阵中的分布如下图所示,其他 FOCC 可自行推理,这里不赘述:

        在了解了 YUV 下采样格式的存储方式及对应的 FOCC 以后,我们就能基于 OpenCV 中的 COLOR_BGR2YUV_FOCCCOLOR_YUV2BGR_FOCC 直接将下采样后的 YUV 数据转换为 RGB,或者直接将 RGB 转换为特定下采样及存储方式的 YUV 数据了。实际上,第三类 COLOR_BGR2YUV_FOCC 可看作是第二类 COLOR_BGR2YCrCb 即 BT.601 的继承,但是又有些不同。在信号处理中,一个很重要的概念是系统响应,频域的滤波等操作通常会在时域或空域中引入震荡或过冲,最常见的就是理想低通滤波器中的 Gibbs 现象。数字 YUV 信号最终需要转换为模拟电平信号才能驱动显示器工作,例如通过电压控制液晶的偏转角度等等,而离散时间信号在还原为模拟连续时间信号时需连接一个低通滤波器,以此过滤掉由采样定理所引入的高频延拓分量,因此这时就有可能出现信号过冲的问题。因为 COLOR_BGR2YCrCb 所得 YUV 数据的取值范围都为 [0, 255],如果数模转换的过程中把 0 映射为 0 电平,而 255 映射为最高电平,经过系统滤波响应以后,信号实际的电平就有可能超出系统所能处理的范围。为了解决这个问题,ITU-R 组织在 BT.601 转换系数的基础上,对 COLOR_BGR2YCrCb 所得结果进行缩放与偏移,保留大约 10% 的过冲余量,从而得到了 OpenCV 第三类 code 所对应的转换系数,其通常配合特定的 YUV 下采样及存储格式使用。通过查阅 OpenCV 源码的 color_yuv.simd.hpp,可以看到

// Coefficients for RGB to YUV420p conversion
static const int ITUR_BT_601_SHIFT = 20;
static const int ITUR_BT_601_CRY =  269484;
static const int ITUR_BT_601_CGY =  528482;
static const int ITUR_BT_601_CBY =  102760;
static const int ITUR_BT_601_CRU = -155188;
static const int ITUR_BT_601_CGU = -305135;
static const int ITUR_BT_601_CBU =  460324;
static const int ITUR_BT_601_CGV = -385875;
static const int ITUR_BT_601_CBV = -74448;
//R = 1.164(Y - 16) + 1.596(V - 128)
//G = 1.164(Y - 16) - 0.813(V - 128) - 0.391(U - 128)
//B = 1.164(Y - 16)                  + 2.018(U - 128)

其中未标明的 ITUR_BT_601_CRV 和 ITUR_BT_601_CBU 是一样的。转换为浮点后,可得带有 FOCC 后缀的 RGB 与 YUV 转换系数与如下

[ Y ′ U ′ V ′ ] = [ 0.257 0.504 0.098 − 0.148 − 0.291 0.439 0.439 − 0.368 − 0.071 ] [ R G B ] + [ 16 128 128 ] \left[ {\begin{array}{c} {Y'} \\ {U'} \\ {V'} \end{array}} \right] = \left[ {\begin{array}{c} {0.257}&{0.504}&{0.098} \\ { - 0.148}&{ - 0.291}&{0.439} \\ {0.439}&{ - 0.368}&{ - 0.071} \end{array}} \right]\left[ {\begin{array}{c} R \\ G \\ B \end{array}} \right] + \left[ {\begin{array}{c} {16} \\ {128} \\ {128} \end{array}} \right] YUV = 0.2570.1480.4390.5040.2910.3680.0980.4390.071 RGB + 16128128

[ R G B ] = [ 1.164 0 1.596 1.164 − 0.391 − 0.813 1.164 2.018 0 ] [ Y ′ − 16 U ′ − 128 V ′ − 128 ] \left[ {\begin{array}{c} R \\ G \\ B \end{array}} \right] = \left[ {\begin{array}{c} {1.164}&0&{1.596} \\ {1.164}&{ - 0.391}&{ - 0.813} \\ {1.164}&{2.018}&0 \end{array}} \right]\left[ {\begin{array}{c} {Y' - 16} \\ {U' - 128} \\ {V' - 128} \end{array}} \right] RGB = 1.1641.1641.16400.3912.0181.5960.8130 Y16U128V128

容易算得,此时 Y ∈ [ 16 , 235 ] Y \in [16, 235] Y[16,235],而 U , V ∈ [ 16 , 240 ] U,V \in [16, 240] U,V[16,240]。即 YUV 数据的左右两侧都预留了一定的空间,使得一般的操作都不会导致数据的溢出,从而可以在硬件中减少一些截断操作。当然,其代价是数据的表示范围有所缩减,不能最大化 uint8 类型所能表示的精度,但总体上还是利大于弊的,所以这种非满量程的 YUV 也被 ITU-R 组织作为一种标准进行推广。前面我们提到,COLOR_BGR2YUV_FOCC 是对 COLOR_BGR2YCrCb 进行缩放与偏移得到的结果,事实也是如此,只需对比两者的转换矩阵即可,如下:

[ 0.257 0.504 0.098 − 0.148 − 0.291 0.439 0.439 − 0.368 − 0.071 ] ≈ 1 255 [ 219 224 224 ] [ 0.299 0.587 0.114 − 0.169 − 0.331 0.500 0.500 − 0.419 − 0.081 ] \left[ {\begin{array}{c} {0.257}&{0.504}&{0.098} \\ { - 0.148}&{ - 0.291}&{0.439} \\ {0.439}&{ - 0.368}&{ - 0.071} \end{array}} \right] \approx \frac{1}{{255}}\left[ {\begin{array}{c} {219}&{}&{} \\ {}&{224}&{} \\ {}&{}&{224} \end{array}} \right]\left[ {\begin{array}{c} {0.299}&{0.587}&{0.114} \\ { - 0.169}&{ - 0.331}&{0.500} \\ {0.500}&{ - 0.419}&{ - 0.081} \end{array}} \right] 0.2570.1480.4390.5040.2910.3680.0980.4390.071 2551 219224224 0.2990.1690.5000.5870.3310.4190.1140.5000.081

4 验证

为了验证以上的分析是否正确,这里提供了一个测试脚本,有兴趣的可以自行复制运行。

# -*- coding: utf-8 -*-
import numpy as np
import cv2rgb2yuv_470_full = np.array([[ 0.299,  0.587,  0.114],[-0.147, -0.289,  0.436],[ 0.615, -0.515, -0.100]
])rgb2yuv_601_full = np.array([[ 0.299,  0.587,  0.114],[-0.169, -0.331,  0.500],[ 0.500, -0.419, -0.081]
])rgb2yuv_709_full = np.array([[ 0.2126,  0.7152,  0.0722],[-0.1146, -0.3854,  0.5000],[ 0.5000, -0.4542, -0.0458]
])yuv2rgb_470_full = np.linalg.inv(rgb2yuv_470_full)
yuv2rgb_601_full = np.linalg.inv(rgb2yuv_601_full)
yuv2rgb_709_full = np.linalg.inv(rgb2yuv_709_full)'''
print('rgb2yuv_470_full')
print(rgb2yuv_601_full)
print('yuv2rgb_470_full')
print(yuv2rgb_601_full)
print('rgb2yuv_601_full')
print(rgb2yuv_601_full)
print('yuv2rgb_601_full')
print(yuv2rgb_601_full)
print('rgb2yuv_709_full')
print(rgb2yuv_709_full)
print('yuv2rgb_709_full')
print(yuv2rgb_709_full)
'''rgb2yuv_601_comp = 1./255 * np.diag([219, 224, 224]).dot(rgb2yuv_601_full)
rgb2yuv_709_comp = 1./255 * np.diag([219, 224, 224]).dot(rgb2yuv_709_full)yuv2rgb_601_comp = np.linalg.inv(rgb2yuv_601_comp)
yuv2rgb_709_comp = np.linalg.inv(rgb2yuv_709_comp)'''
print('rgb2yuv_601_comp')
print(rgb2yuv_601_comp)
print('yuv2rgb_601_comp')
print(yuv2rgb_601_comp)
print('rgb2yuv_709_comp')
print(rgb2yuv_709_comp)
print('yuv2rgb_709_comp')
print(yuv2rgb_709_comp)
'''def convert_bgr_to_yuv(bgr):h, w = bgr.shape[:2]assert h % 4 == 0 and w % 4 == 0b, g, r = bgr.transpose(2, 0, 1)y =  0.299 * r + 0.587 * g + 0.114 * b# COLOR_BGR2YUVu = -0.147 * r - 0.289 * g + 0.436 * b + 128v =  0.615 * r - 0.515 * g - 0.100 * b + 128yuv_470 = np.clip(np.array([y, u, v]).transpose(1, 2, 0), 0, 255).astype('uint8')# COLOR_BGR2YCrCbu = -0.169 * r - 0.331 * g + 0.500 * b + 128v =  0.500 * r - 0.419 * g - 0.081 * b + 128yvu_601 = np.clip(np.array([y, v, u]).transpose(1, 2, 0), 0, 255).astype('uint8')# COLOR_BGR2YUV_FOCCy = y * 219. / 255 + 16u = u * 224. / 255 + 16v = v * 224. / 255 + 16yuv_fcc = np.clip(np.array([y, u, v]).transpose(1, 2, 0), 0, 255).astype('uint8')return yuv_470, yvu_601, yuv_fccdef convert_yuv_to_fcc(yuv, fcc):fcc_list_420 = ['NV12', 'NV21', '420S', 'YV12', 'IYUV', 'I420', '420P']fcc_list_422 = ['UYVY', 'Y422', 'UYNV', 'YUY2', 'YVYU', 'YUYV', 'YUNV']assert fcc in fcc_list_420 + fcc_list_422h, w = yuv.shape[:2]assert h % 4 == 0 and w % 4 == 0y, u, v = yuv.transpose(2, 0, 1)if fcc in fcc_list_420:yuv420 = np.zeros([3*h//2, w], dtype='uint8')yuv420[:h] = yif fcc == 'NV12':yuv420[h:, 0::2] = u[::2, ::2]yuv420[h:, 1::2] = v[::2, ::2]elif fcc == 'NV21' or fcc == '420S':yuv420[h:, 0::2] = v[::2, ::2]yuv420[h:, 1::2] = u[::2, ::2]elif fcc == 'YV12' or fcc == '420P':yuv420[h: h+h//4] = v[::2, ::2].reshape([-1, w])yuv420[-h//4:   ] = u[::2, ::2].reshape([-1, w])elif fcc == 'IYUV' or fcc == 'I420':yuv420[h: h+h//4] = u[::2, ::2].reshape([-1, w])yuv420[-h//4:   ] = v[::2, ::2].reshape([-1, w])return yuv420elif fcc in fcc_list_422:yuv422 = np.zeros([h, w, 2], dtype='uint8')if fcc == 'UYVY' or fcc == 'Y422' or fcc == 'UYNV':yuv422[:, 0::2, 0] = u[:, ::2]yuv422[:, 1::2, 0] = v[:, ::2]yuv422[:,    :, 1] = yelif fcc == 'YUY2' or fcc == 'YUYV' or fcc == 'YUNV':yuv422[:,    :, 0] = yyuv422[:, 0::2, 1] = u[:, ::2]yuv422[:, 1::2, 1] = v[:, ::2]elif fcc == 'YVYU':yuv422[:,    :, 0] = yyuv422[:, 0::2, 1] = v[:, ::2]yuv422[:, 1::2, 1] = u[:, ::2]return yuv422else:return yuvdef convert_yuv470_to_bgr(yuv470):rgb = (yuv470 - np.array([0, 128, 128])).dot(yuv2rgb_470_full.T)bgr = np.clip(rgb[..., ::-1], 0, 255).astype('uint8')return bgrdef convert_yvu601_to_bgr(yvu601):rgb = (yvu601[..., [0, 2, 1]] - np.array([0, 128, 128])).dot(yuv2rgb_601_full.T)bgr = np.clip(rgb[..., ::-1], 0, 255).astype('uint8')return bgrdef test_yuv2bgr_fcc(yuv):fcc_dict_420 = {'NV12': cv2.COLOR_YUV2BGR_NV12,'NV21': cv2.COLOR_YUV2BGR_NV21, '420S': cv2.COLOR_YUV420sp2BGR,'YV12': cv2.COLOR_YUV2BGR_YV12, '420P': cv2.COLOR_YUV420p2BGR,'IYUV': cv2.COLOR_YUV2BGR_IYUV, 'I420': cv2.COLOR_YUV2BGR_I420}fcc_dict_422 = {'UYVY': cv2.COLOR_YUV2BGR_UYVY, 'Y422': cv2.COLOR_YUV2BGR_Y422, 'UYNV': cv2.COLOR_YUV2BGR_UYNV,'YUY2': cv2.COLOR_YUV2BGR_YUY2, 'YUYV': cv2.COLOR_YUV2BGR_YUYV, 'YUNV': cv2.COLOR_YUV2BGR_YUNV,'YVYU': cv2.COLOR_YUV2BGR_YVYU}yuv420up = yuv.copy()yuv420up[::2, 1::2, 1:] = yuv420up[::2, ::2, 1:]yuv420up[1::2, :, 1:] = yuv420up[::2, :, 1:]rgb = (yuv420up - np.array([16, 128, 128])).dot(yuv2rgb_601_comp.T)bgr420 = np.clip(rgb[..., ::-1], 0, 255).astype('int')yuv422up = yuv.copy()yuv422up[:, 1::2, 1:] = yuv422up[:, ::2, 1:]rgb = (yuv422up - np.array([16, 128, 128])).dot(yuv2rgb_601_comp.T)bgr422 = np.clip(rgb[..., ::-1], 0, 255).astype('int')for fcc, code in fcc_dict_420.items():yuv_fcc = convert_yuv_to_fcc(yuv, fcc)bgr_cv = cv2.cvtColor(yuv_fcc, code)print('{} bgr max diff: {}'.format(fcc, np.max(np.abs(bgr420 - bgr_cv))))for fcc, code in fcc_dict_422.items():yuv_fcc = convert_yuv_to_fcc(yuv, fcc)bgr_cv = cv2.cvtColor(yuv_fcc, code)print('{} bgr max diff: {}'.format(fcc, np.max(np.abs(bgr422 - bgr_cv))))if __name__ == '__main__':w, h = 128, 128bgr = np.random.randint(0, 256, [h, w, 3], dtype='uint8')yuv470, yvu601, yuv_fcc = convert_bgr_to_yuv(bgr)# test COLOR_BGR2YUVy0 = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV)x0 = cv2.cvtColor(y0, cv2.COLOR_YUV2BGR)x1 = convert_yuv470_to_bgr(yuv470)d0 = np.max(yuv470.astype('int') - y0)d1 = np.max(x1.astype('int') - x0)print('470 max diff: yuv={}, bgr={}'.format(d0, d1))# test COLOR_BGR2YCrCby0 = cv2.cvtColor(bgr, cv2.COLOR_BGR2YCrCb)x0 = cv2.cvtColor(y0, cv2.COLOR_YCrCb2BGR)x1 = convert_yvu601_to_bgr(yvu601)d0 = np.max(yvu601.astype('int') - y0)d1 = np.max(x1.astype('int') - x0)print('601 max diff: yuv={}, bgr={}'.format(d0, d1))# test fcc yuv2bgrtest_yuv2bgr_fcc(yuv_fcc)# test fcc br2yuvy0 = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV_I420)y1 = convert_yuv_to_fcc(yuv_fcc, 'I420')print('I420 yuv max diff: {}'.format(np.max(np.abs(y1.astype('int') - y0))))y0 = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV_IYUV)y1 = convert_yuv_to_fcc(yuv_fcc, 'IYUV')print('IYUV yuv max diff: {}'.format(np.max(np.abs(y1.astype('int') - y0))))y0 = cv2.cvtColor(bgr, cv2.COLOR_BGR2YUV_YV12)y1 = convert_yuv_to_fcc(yuv_fcc, 'YV12')print('YV12 yuv max diff: {}'.format(np.max(np.abs(y1.astype('int') - y0))))

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/761.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

K8s 为什么要弃用 Docker

K8s 为什么要弃用 Docker 最近在学习容器技术的过程中&#xff0c;看到有关于Kubernetes“弃用 Docker”的事情&#xff0c;担心现在学 Docker 是否还有价值&#xff0c;是否现在就应该切换到 containerd 或者是其他 runtime。 随着深入了解&#xff0c;这些疑虑的确是有些道理…

git 工具使用--分支管理

git 工具使用–分支管理 文章目录 git 工具使用--分支管理理解分支创建分支切换分支合并分支删除分支合并冲突分支管理策略分支策略bug分支删除临时分支总结 理解分支 分支管理是Git的杀手级功能之一。分支&#xff1a;就是科幻中的平行宇宙&#xff0c;当你正在电脑面前学习C…

设计模式-单例模式

面向对象语言讲究的是万物皆对象。通常流程是先定义可实例化类&#xff0c;然后再通过各种不同的方式创建对象&#xff0c;因此类一般可以实例化出多个对象。但是实际项目开发时&#xff0c;我们还是希望保证项目运行时有且仅包含一个实例对象。这个需求场景的出发点包括但不限…

变压器试验介质损耗

试验目的 介质损耗因数 tanδ (% ) 是判断变压器绝缘状态的一种较有效的手段, 主要用来检 查变压器整体受潮、 油质劣化及严重的局部缺陷等, 但不一定能发现变压器局部受潮 等集中性局部缺陷。 试验设备 异频介质损耗测试仪 厂家&#xff1a; 湖北众拓高试 试验接线 (1) 介…

搜索引擎elasticsearch :安装elasticsearch (包含安装组件kibana、IK分词器、部署es集群)

文章目录 安装elasticsearch1.部署单点es1.1.创建网络1.2.加载镜像1.3.运行 2.部署kibana2.1.部署2.2.DevTools2.3 分词问题(中文不友好) 3.安装IK分词器3.1.在线安装ik插件&#xff08;较慢&#xff09;3.2.离线安装ik插件&#xff08;推荐&#xff09;1&#xff09;查看数据卷…

数据结构--哈夫曼树

数据结构–哈夫曼树 带权路径长度 结点的 权 \color{red}权 权:有某种现实含义的数值&#xff08;如:表示结点的重要性等) 结点的带权路径长度 \color{red}结点的带权路径长度 结点的带权路径长度:从树的根到该结点的路径长度(经过的边数&#xff09;与该结点上权值的乘积 树的…

小程序MobX创建store并实现全局数据共享

查看小程序根目录中是否存在package.json文件 在项目根目录运行cmd 没有package.json文件输入npm init -y初始化一下,初始化一个包管理 安装MobX npm install --save mobx-miniprogram4.13.2 mobx-miniprogram-bindings1.2.1 小程序菜单栏工具–构建npm 根目录创建store文…

el-ment ui 表格组件table实现列的动态插入功能

在实际需求中我们经常遇到各种奇葩的需求&#xff0c;不足为奇。每个项目的需求各不相同&#xff0c;实现功能的思路大致是一样的。 本文来具体介绍怎么实现table表格动态插入几列。 首先实现思路有2种&#xff0c; 1. 插入的位置如果是已知的&#xff0c;我知道在哪个标题的…

设计模式之建造者设计模式

写在前面 不知道&#xff0c;你在工作中有没有使用过lombok&#xff0c;如果你使用过&#xff0c;不知道你有没有使用过其中的Builder注解&#xff0c;其就会帮我们生成建造者设计模式相关的代码&#xff0c;本文就一起来看下吧&#xff01; 1&#xff1a;介绍 1.1&#xff…

spark启动HA时workers为0,且为standby状态

今天学习一个spark视频&#xff0c;在启动StandAloneHa模式的时候&#xff0c;发现workers为0&#xff0c;而且spark两个master的状态都为standby&#xff0c;找了很久&#xff0c;才知道我用的spark3.2 最低支撑的zookeeper版本为3.5.x,而且zookeeper的安装包是需要带bin的那个…

CSS3 动画 animation 入门学习笔记 之 属性详解

文章目录 简单介绍 CSS 动画CSS 动画的作用CSS 动画语法介绍CSS 动画属性animation-nameanimation-durationanimation-delayanimation-directionanimation-iteration-countanimation-play-stateanimation-timing-functionanimation-fill-modeanimation 简单介绍 CSS 动画 引用…

基于深度学习的高精度80类动物目标检测系统(PyTorch+Pyside6+YOLOv5模型)

摘要&#xff1a;基于深度学习的高精度80类动物目标检测识别系统可用于日常生活中或野外来检测与定位80类动物目标&#xff0c;利用深度学习算法可实现图片、视频、摄像头等方式的80类动物目标检测识别&#xff0c;另外支持结果可视化与图片或视频检测结果的导出。本系统采用YO…

Matplotlib是什么

Matplotlib 是一款用于数据可视化的 Python 软件包&#xff0c;支持跨平台运行&#xff0c;它能够根据 NumPy ndarray 数组来绘制 2D 图像&#xff0c;它使用简单、代码清晰易懂&#xff0c;深受广大技术爱好者喜爱。 NumPy 是 Python 科学计算的软件包&#xff0c;ndarray 则…

HTTP1.1 wireshark分析

目录 http1.1wireshark分析http 1.1 keep-alive的2次http请求wireshark分析http1.1 keep-alive过期的2次请求keep-alive报文 本地springboot启动一个简单的服务&#xff0c;然后请求测试 tcpdump -i lo0 -nnvv -w tmp.cap tcpdump 本地回环网卡 http1.1 HTTP/1.0 每进行一次…

蚂蚁集团开源可信隐私计算框架「隐语」:开放、通用

7 月 4 日,蚂蚁集团宣布面向全球开发者正式开源可信隐私计算框架 “隐语”。 隐语是蚂蚁集团历时 6 年自主研发,以安全、开放为核心设计理念打造的可信隐私计算技术框架,涵盖了当前几乎所有主流隐私计算技术。 据介绍,隐语内置 MPC、TEE、同态等多种密态计算虚拟设备,提…

操作系统练习:创建内核模块,并加载和卸载模块

说明 本文记录如何创建和编译一个内核模块&#xff0c;以及加载和卸载内核模块。为《操作系统概念(第九版)》第二章&#xff0c;关于“Linux内核模块”的练习题。 创建内核模块 注&#xff1a;我这里是基于阿里云的轻量应用服务器&#xff08;即当前博客服务器&#xff09; 首…

【Linux】分布式监控 Zabbix

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 Zabbix 介绍zabbix 概述Zabbix 监控原理Zabbix 6.0 新特性Zabbix 6.0 功能组件 Zabbix 6.0 部署Zabbix 添加客户端主机Zabbix 自定义监控内容Zabbix 自动发现与自动…

Python+Requests+Excel接口测试实战

1、EXCEL文件接口保存方式&#xff0c;如图。 2、然后就是读取EXCEL文件中的数据方法&#xff0c;如下&#xff1a; 1 import xlrd2 3 4 class readExcel(object):5 def __init__(self, path):6 self.path path7 8 property9 def getSheet(self): 10 …

android更换开机动画

android11 路径&#xff1a;device / {vendor-name} / {platform-name} / {device-name} / system / bootanimation.zip 例&#xff1a;android \ device \ softwinner \ ceres \ ceres-b6 \ system \ bootanimation.zip android13 路径&#xff1a;device / softwinner / {PRO…

MyBatis全篇

文章目录 MyBatis特性下载持久化层技术对比 搭建MyBatis创建maven工程创建MyBatis的核心配置文件创建mapper接口创建MyBatis的映射文件测试功能加入log4j日志功能加入log4j的配置文件 核心配置文件的完善与详解MyBatis的增删改查测试功能 MyBatis获取参数值在IDEA中设置中配置文…