python实现YUV转RGB

已于 2022-08-24 16:25:34 修改
阅读量9.6k 收藏 63
点赞数 14
分类专栏： 笔记 文章标签： python
于 2021-05-07 11:42:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39056987/article/details/116483566
版权

序言

因为在项目中要用到yuv格式的视频图像进行模型推理，但是我们模型通常都是只接收RGB格式的图片，所以在推理前就要先把YUV格式转换为RGB格式。

一、什么是YUV

在代码实现之前，需要去了解什么是YUV格式编码，明白了其编码方式后再看实现会简单的多，如果只是需要代码实现，那可以直接简单略过。

YUV是一种类似RGB的颜色模型，起源于黑白和彩电的过渡时期，是一种颜色编码方法，其中Y代表亮度，UV组合起来可以表示色度。YUV信息只有y的信息就足以显示黑白的图片（所以我们早期的黑白电视就是只用了Y），这样的设计很好地解决了彩色电视机与黑白电视的兼容问题。并且，YUV不像RGB那样要求三个独立的视频信号同时传输，所以用YUV方式传送占用极少的频宽。

YUV码流的存储格式其实与其采样的方式密切相关，主流的采样方式有三种，YUV4:4:4，YUV4:2:2，YUV4:2:0，关于其详细原理，可以参考这篇文章一文读懂 YUV 的采样与格式，YUV与RGB编码这里就不再过多介绍，本文是实现根据其采样格式来从码流中还原每个像素点的YUV值，然后通过YUV与RGB的转换公式提取出每个像素点的RGB值，然后显示保存下来。

2. 实现过程

在实现代码之前，首先要明确自己要转换的YUV是什么存储格式，因为不同的存储格式需要不同的提取方式。简单看下下面这两种不同的存储格式：

yuv420P（YU12 和 YV12 ）格式如下，先存储Y分量，再存储U分量，最后存储V分量:
在这里插入图片描述
yuv420SP（NV12 和 NV21 ）格式如下，先存储Y分量，然后交替存储UV分量:
在这里插入图片描述
作为对比，再上一张RGB的存储格式：

RGB存储方式：RGB三个分量按照B、G、R的顺序储存。(4：4：4)
在这里插入图片描述

所以我们在实现之前需要明确是什么格式存储的，否则提取出来的UV分量可能是错的，导致转换后的图像色彩不对。

3. 代码实现

第一版实现，使用for循环逐点提取YUV值转换成RGB（非常耗时，不建议使用，为了更清楚实现的过程）：

def yuv2rgb(Y, U, V):
    bgr_data = np.zeros((IMG_HEIGHT, IMG_WIDTH, 3), dtype=np.uint8)
    for h_idx in range(Y_HEIGHT):
        for w_idx in range(Y_WIDTH):
            y = Y[h_idx, w_idx]
            u = U[int(h_idx // 2), int(w_idx // 2)]
            v = V[int(h_idx // 2), int(w_idx // 2)]

            c = (y - 16) * 298
            d = u - 128
            e = v - 128

            r = (c + 409 * e + 128) // 256
            g = (c - 100 * d - 208 * e + 128) // 256
            b = (c + 516 * d + 128) // 256

            bgr_data[h_idx, w_idx, 2] = 0 if r < 0 else (255 if r > 255 else r)
            bgr_data[h_idx, w_idx, 1] = 0 if g < 0 else (255 if g > 255 else g)
            bgr_data[h_idx, w_idx, 0] = 0 if b < 0 else (255 if b > 255 else b)

    return bgr_data

第二版实现，使用numpy数组运算进行加速（速度非常快，建议用这版）：

def np_yuv2rgb(Y,U,V):
    bgr_data = np.zeros((IMG_HEIGHT, IMG_WIDTH, 3), dtype=np.uint8)
    V = np.repeat(V, 2, 0)
    V = np.repeat(V, 2, 1)
    U = np.repeat(U, 2, 0)
    U = np.repeat(U, 2, 1)

    c = (Y-np.array([16])) * 298
    d = U - np.array([128])
    e = V - np.array([128])

    r = (c + 409 * e + 128) // 256
    g = (c - 100 * d - 208 * e + 128) // 256
    b = (c + 516 * d + 128) // 256

    r = np.where(r < 0, 0, r)
    r = np.where(r > 255,255,r)

    g = np.where(g < 0, 0, g)
    g = np.where(g > 255,255,g)

    b = np.where(b < 0, 0, b)
    b = np.where(b > 255,255,b)

    bgr_data[:, :, 2] = r
    bgr_data[:, :, 1] = g
    bgr_data[:, :, 0] = b

    return bgr_data

实验对比：输入同一张（1152*648）的YUV图像。

第一版耗时：5.698601007461548
第二版耗时：0.04670834541320801

速度提升了一百多倍，图片越大，提升效果越明显，最后转换出来的图像如图所示：
在这里插入图片描述
全部代码：

import os
import cv2
import numpy as np

IMG_WIDTH = 1152
IMG_HEIGHT = 648
IMG_SIZE = int(IMG_WIDTH * IMG_HEIGHT * 3 / 2)

Y_WIDTH = IMG_WIDTH
Y_HEIGHT = IMG_HEIGHT
Y_SIZE = int(Y_WIDTH * Y_HEIGHT)

U_V_WIDTH = int(IMG_WIDTH / 2)
U_V_HEIGHT = int(IMG_HEIGHT / 2)
U_V_SIZE = int(U_V_WIDTH * U_V_HEIGHT)


def from_I420(yuv_data, frames):
    Y = np.zeros((frames, IMG_HEIGHT, IMG_WIDTH), dtype=np.uint8)
    U = np.zeros((frames, U_V_HEIGHT, U_V_WIDTH), dtype=np.uint8)
    V = np.zeros((frames, U_V_HEIGHT, U_V_WIDTH), dtype=np.uint8)

    for frame_idx in range(0, frames):
        y_start = frame_idx * IMG_SIZE
        u_start = y_start + Y_SIZE
        v_start = u_start + U_V_SIZE
        v_end = v_start + U_V_SIZE

        Y[frame_idx, :, :] = yuv_data[y_start : u_start].reshape((Y_HEIGHT, Y_WIDTH))
        U[frame_idx, :, :] = yuv_data[u_start : v_start].reshape((U_V_HEIGHT, U_V_WIDTH))
        V[frame_idx, :, :] = yuv_data[v_start : v_end].reshape((U_V_HEIGHT, U_V_WIDTH))
    return Y, U, V

def from_YV12(yuv_data, frames):
    Y = np.zeros((frames, IMG_HEIGHT, IMG_WIDTH), dtype=np.uint8)
    U = np.zeros((frames, U_V_HEIGHT, U_V_WIDTH), dtype=np.uint8)
    V = np.zeros((frames, U_V_HEIGHT, U_V_WIDTH), dtype=np.uint8)

    for frame_idx in range(0, frames):
        y_start = frame_idx * IMG_SIZE
        v_start = y_start + Y_SIZE
        u_start = v_start + U_V_SIZE
        u_end = u_start + U_V_SIZE

        Y[frame_idx, :, :] = yuv_data[y_start : v_start].reshape((Y_HEIGHT, Y_WIDTH))
        V[frame_idx, :, :] = yuv_data[v_start : u_start].reshape((U_V_HEIGHT, U_V_WIDTH))
        U[frame_idx, :, :] = yuv_data[u_start : u_end].reshape((U_V_HEIGHT, U_V_WIDTH))
    return Y, U, V


def from_NV12(yuv_data, frames):
    Y = np.zeros((frames, IMG_HEIGHT, IMG_WIDTH), dtype=np.uint8)
    U = np.zeros((frames, U_V_HEIGHT, U_V_WIDTH), dtype=np.uint8)
    V = np.zeros((frames, U_V_HEIGHT, U_V_WIDTH), dtype=np.uint8)

    for frame_idx in range(0, frames):
        y_start = frame_idx * IMG_SIZE
        u_v_start = y_start + Y_SIZE
        u_v_end = u_v_start + (U_V_SIZE * 2)

        Y[frame_idx, :, :] = yuv_data[y_start : u_v_start].reshape((Y_HEIGHT, Y_WIDTH))
        U_V = yuv_data[u_v_start : u_v_end].reshape((U_V_SIZE, 2))
        U[frame_idx, :, :] = U_V[:, 0].reshape((U_V_HEIGHT, U_V_WIDTH))
        V[frame_idx, :, :] = U_V[:, 1].reshape((U_V_HEIGHT, U_V_WIDTH))
    return Y, U, V


def from_NV21(yuv_data, frames):
    Y = np.zeros((frames, IMG_HEIGHT, IMG_WIDTH), dtype=np.uint8)
    U = np.zeros((frames, U_V_HEIGHT, U_V_WIDTH), dtype=np.uint8)
    V = np.zeros((frames, U_V_HEIGHT, U_V_WIDTH), dtype=np.uint8)

    for frame_idx in range(0, frames):
        y_start = frame_idx * IMG_SIZE
        u_v_start = y_start + Y_SIZE
        u_v_end = u_v_start + (U_V_SIZE * 2)

        Y[frame_idx, :, :] = yuv_data[y_start : u_v_start].reshape((Y_HEIGHT, Y_WIDTH))
        U_V = yuv_data[u_v_start : u_v_end].reshape((U_V_SIZE, 2))
        V[frame_idx, :, :] = U_V[:, 0].reshape((U_V_HEIGHT, U_V_WIDTH))
        U[frame_idx, :, :] = U_V[:, 1].reshape((U_V_HEIGHT, U_V_WIDTH))
    return Y, U, V

def np_yuv2rgb(Y,U,V):
    bgr_data = np.zeros((IMG_HEIGHT, IMG_WIDTH, 3), dtype=np.uint8)
    V = np.repeat(V, 2, 0)
    V = np.repeat(V, 2, 1)
    U = np.repeat(U, 2, 0)
    U = np.repeat(U, 2, 1)

    c = (Y-np.array([16])) * 298
    d = U - np.array([128])
    e = V - np.array([128])

    r = (c + 409 * e + 128) // 256
    g = (c - 100 * d - 208 * e + 128) // 256
    b = (c + 516 * d + 128) // 256

    r = np.where(r < 0, 0, r)
    r = np.where(r > 255,255,r)

    g = np.where(g < 0, 0, g)
    g = np.where(g > 255,255,g)

    b = np.where(b < 0, 0, b)
    b = np.where(b > 255,255,b)

    bgr_data[:, :, 2] = r
    bgr_data[:, :, 1] = g
    bgr_data[:, :, 0] = b

    return bgr_data

def yuv2rgb(Y, U, V):
    bgr_data = np.zeros((IMG_HEIGHT, IMG_WIDTH, 3), dtype=np.uint8)
    for h_idx in range(Y_HEIGHT):
        for w_idx in range(Y_WIDTH):
            y = Y[h_idx, w_idx]
            u = U[int(h_idx // 2), int(w_idx // 2)]
            v = V[int(h_idx // 2), int(w_idx // 2)]

            c = (y - 16) * 298
            d = u - 128
            e = v - 128

            r = (c + 409 * e + 128) // 256
            g = (c - 100 * d - 208 * e + 128) // 256
            b = (c + 516 * d + 128) // 256

            bgr_data[h_idx, w_idx, 2] = 0 if r < 0 else (255 if r > 255 else r)
            bgr_data[h_idx, w_idx, 1] = 0 if g < 0 else (255 if g > 255 else g)
            bgr_data[h_idx, w_idx, 0] = 0 if b < 0 else (255 if b > 255 else b)

    return bgr_data

if __name__ == '__main__':
    import time

    yuv = "request/YUV/2021-05-06/test.yuv"
    frames = int(os.path.getsize(yuv) / IMG_SIZE)

    with open(yuv, "rb") as yuv_f:
        time1 = time.time()
        yuv_bytes = yuv_f.read()
        yuv_data = np.frombuffer(yuv_bytes, np.uint8)

        # Y, U, V = from_I420(yuv_data, frames)
        # Y, U, V = from_YV12(yuv_data, frames)
        # Y, U, V = from_NV12(yuv_data, frames)
        Y, U, V = from_NV21(yuv_data, frames)

        rgb_data = np.zeros((IMG_HEIGHT, IMG_WIDTH, 3), dtype=np.uint8)
        for frame_idx in range(frames):
            # bgr_data = yuv2rgb(Y[frame_idx, :, :], U[frame_idx, :, :], V[frame_idx, :, :])            # for 
            bgr_data = np_yuv2rgb(Y[frame_idx, :, :], U[frame_idx, :, :], V[frame_idx, :, :])           # numpy 
            time2 = time.time()
            print(time2 - time1)
            if bgr_data is not None:
                cv2.imwrite("frame_{}.jpg".format(frame_idx), bgr_data)
                frame_idx +=1

代码和测试用的YUV文件已上传到github，使用时请参考文档。

三叔家的猫
关注
  • 14
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
YUV转BGR：Python实现及优化方案
weixin_50547796的博客
06-14 34
在图像和中，颜色空间转换是一项必要的技术。其中，YUV和BGR都是常用的颜色空间。本文将介绍如何在Python中将YUV图像转换为BGR图像，并提出一些优化方案。
python:实现YUV转RGB(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-29 471
python:实现YUV转RGB(附完整源码)
python实现YUV422转RGB
amateur_hy的博客
05-08 4922
YUV422转RGB过程记录 参考：YUV图解 https://blog.csdn.net/xjhhjx/article/details/80291465 1.确定.yuv格式文件的存储方式 YUV码流的存储方式与其采样的方式密切相关，主流的采样方法有三种：YUV4:4:4，YUV4:2:2，YUV4:2:0。 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编...
YUV格式转换为RGB（基于opencv）
小村长技术blog
05-17 2万+
之前写代码过程中需要将YUV格式视频中每帧提取出来，然后保存为图片。网上普遍有两种方法，第一种是通过opencv自带cvCvtColor，但是这种方法有bug，得到的图片会泛白。第二种方法是公式法。 法一：opencv自带cvCvtColor 说明：这种方法会出现图片“泛白”，具体原因网上是说cvCvtColor这个函数左右协议不同，不太懂。 代码：  void FileWriteFram
python实现yuv转RGB图片程序
风口上的传奇
11-09 5287
全套源码下载地址：https://download.csdn.net/download/bvngh3247/10774909 主程序： import os import cv2 import numpy as np from PIL import Image #from scipy import misc import utilty as util search_path = 'E:/stitc...
python rgb转yuv_python - YUV转RGB
weixin_39531992的博客
12-09 504
转换原理很简单，只要知道变换矩阵就简单了，这个可以参考一些《数字图像处理》相关书籍或者查维基就ok了。import numpy as npimport cv2 as cvdef yuv2rgb(img):W = np.array([[1, 0., 1.13983],[1, -0.39465, -0.58060],[1, 2.03211, 0.]])imc = img.copy()imc = imc...
python中rgb转yuv_python - YUV转RGB
weixin_39826080的博客
12-10 1193
转换原理很简单，只要知道变换矩阵就简单了，这个可以参考一些《数字图像处理》相关书籍或者查维基就ok了。import numpy as npimport cv2 as cvdef yuv2rgb(img):W = np.array([[1, 0., 1.13983],[1, -0.39465, -0.58060],[1, 2.03211, 0.]])imc = img.copy()imc = imc...
利用python读取YUV文件 转RGB 8bit/10bit通用
01-21
注：本文所指的YUV均为YUV420中的I420格式（最常见的一种），其他格式不能用以下的代码。 位深为8bit时，每个像素占用1字节，对应文件指针的fp.read(1)； 位深为10bit时，每个像素占用2字节，对应文件指针的fp.read...
yuv422格式转rgb格式
03-06
本篇文章将深入探讨如何将YUV422格式的图像转换为8位RGB灰度图像，这是一个在视频处理、图像编码与解码等场景中常见的需求。 ### YUV422格式简介 YUV422是一种常见的彩色图像格式，其中“Y”代表亮度信号，“U”和...
rgb转yuv420，yuv444
01-18
用来python2的opencv接口，需要事先安装opencv for python2.7
yolov5中的Focus模块的理解
热门推荐
小菜的博客
01-16 7万+
序言 v5出来这么久，一直搜不到网上对Focus的理解，还想着白嫖一下结论，但是发现搜出来的都是一知半解，讲的全都是Focus做了什么，愣是没说为什么要这么做。没办法只好自己花点时间深入学习一下，本人也记录一下本人对Focus模块的一些理解，如果有理解错误的地方，还请评论区告知。 一、Focus模块的原理 Focus模块在v5中是图片进入backbone前，对图片进行切片操作，具体操作是在一张图片中每隔一个像素拿到一个值，类似于邻近下采样，这样就拿到了四张图片，四张图片互补，长的差不多，但是没有信息丢失，这
YOLOv3-SPP介绍
小菜的博客
02-15 3万+
我们知道YOLOv3目前是业界比较流行的检测算法，在速度和精度上相对于其他检测算法，都有很大的优势，但是今天介绍的不是YOLOv3，而是它的改进版本yolov3-SPP，在学习的同时，也随便记录一下，如果有误还请大家指出。 1. YOLO各个版本对比 首先来看下官方给的在COCO数据集上的表现，可以看到SPP版本相对于前面几个版本，mAP有了好几个百分点的提升，在加了SPP模块之后的YOLOv3为...
浅谈深度学习中Batch_size的大小对模型训练的影响
小菜的博客
03-24 2万+
序言 本文根据知乎原文内容进行整理：深度学习中的batch的大小对学习效果有何影响？ 正文 Batch_size的作用：决定了下降的方向。 在合理范围内，增大Batch_size的好处： 提高了内存利用率以及大矩阵乘法的并行化效率； 跑完一次epoch(全数据集）所需要的迭代次数减少，对相同的数据量，处理的速度比小的Batch_size要更快； 在一定范围内，一般来说 Batch_Size 越大...
yolov8命令行运行参数详解
小菜的博客
03-17 2万+
基准测试提供了关于导出格式的大小、其mAP50-95指标(用于对象检测和分割)或精度top5指标(用于分类)的信息，以及在各种导出格式(如ONNX、OpenVINO、TensorRT等)中，每张图像的推断时间(以毫秒为单位)。这些信息可以帮助用户根据他们对速度和准确性的需求，为他们的特定用例选择最佳的导出格式。yolov8目前支持：BoT-SORT、ByteTrack两种目标跟踪，默认使用BoT-SORT。跟踪的传参和推理时一样，主要有三个：conf、 iou、 show。
pytorch模型(.pth)转tensorrt模型(.engine)几种方式
小菜的博客
05-05 1万+
序言 这篇文章总结了训练好的pytorch模型转成tensorrt模型部署的几种方式，转换原理流程大致如下： 导出网络定义以及相关权重； 解析网络定义以及相关权重； 根据显卡算子构造出最优执行计划； 将执行计划序列化存储； 反序列化执行计划； 进行推理 值得注意的是第三点，可以看到tensorrt转换出来的模型实际上是和硬件绑定的，也就是在部署的过程中，如果你的显卡和显卡相关驱动软件（cuda、cudnn）发生了改变，那么模型就得需要重新做转换。 一、trtexec trtexec是在tensorrt包
深度学习CV岗位面试问题总结（目标检测篇）
小菜的博客
01-06 1万+
序言 首先说一下为什么写这篇文章，一方面是因为在平时工作中或者项目上会用到各种各样的算法，虽然用多了心里大概都知道这些算法是什么原理，但是在面试的时候当面试官闻起来，突然一下子就组织不上语言，原理说得零零碎碎，显得非常不专业，相信很多人都有这样的面试经历。另一方面我觉得当读到一篇好的文章或者一段出彩的文字时，看完能够用自己的一句话把文章核心内容总结出来，才能够掌握文章的精髓，当然深度学习的东西，很难用一句话概括出来，但是我们可以总结其中的重点，再通过思维的延申到实现细节上，是不错的学习方式。 废话说得太多了
python yuv转rgb
最新发布
06-07
下面是一个简单的Python函数，用于将YUV图像转换为RGB格式： ```python def yuv2rgb(yuv): y, u, v = yuv[0], yuv[1] - 128, yuv[2] - 128 r = y + 1.13983 * v g = y - 0.39465 * u - 0.58060 * v b = y + 2.03211 * u return int(r), int(g), int(b) ``` 其中，yuv是一个长度为3的元组或列表，分别表示图像中的Y、U、V分量。返回值为一个长度为3的元组，分别表示RGB图像中的R、G、B分量。请注意，该函数仅适用于YUV格式为YUV444的图像。如果您的图像格式为YUV422或YUV420，请使用适当的转换算法。
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值