YUV到RGB颜色空间转换

最新推荐文章于 2024-04-09 11:12:31 发布
最新推荐文章于 2024-04-09 11:12:31 发布
阅读量4k 收藏 6
点赞数 2
分类专栏： opencv与机器视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013752202/article/details/50437608
版权

三种颜色空间简介：

YUV：是欧洲电视系统采用的一种颜色编码格式，Y表示亮度值（Luminance或Luma），U和V表示色彩及饱和度(Chrominance或Chroma)。

YUV主要格式有：YUV444、YUV 422、YUV 411和YUV 420。YUV对原始数据以每4个像素为单元进行压缩处理，处理的方式就是对U和V分量进行降采样，如YUV444就是每4个像素YUV都会被采样4次数据无压缩，YUV422就是每4个像素YUV采样次数分别为422，数据减小了1/3，同理YUV411数据就减小了一半。但是根据奈奎斯特采样定理可以知道，采样后的数据信息损失量很小，不会造成图像的视觉效果变差。

假设有四个YUV空间的像素点{Y0,U0,V0},{Y1,U1,V1},{Y2,U2,V2},{Y3,U3,V3}

(1)YUV444

存储格式为：{Y0,U0,V0},{Y1,U1,V1},{Y2,U2,V2},{Y3,U3,V3}

像素表示为：{Y0,U0,V0},{Y1,U1,V1},{Y2,U2,V2},{Y3,U3,V3}

没有压缩。

(2) YUV422

存储格式为：{Y0,U0},{Y1,V1},{Y2,U2},{Y3,V3}

像素表示为：{Y0,U0,V1}, {Y1,U0,V1},{Y2,U2,V3}, {Y3,U2,V3}

可以看出四个像素点Y分量全部采样，U保留了偶数，V保留了奇数，四个像素点每两个像素点共用同一个U和V分量，数据压缩了1/3。

(3)YUV411

存储格式为：{Y0,U0,Y1},{Y2,V2,Y3}

像素表示为：{Y0,U0,V2}, {Y1,U0,V2},{Y2,U0,V2}, {Y3,U0,V2}

可以看出四个像素点Y分量全部采样，U和V只采样了U0和V2两个值，然后四个像素点的UV分离都是U0和V2，数据压缩了1/2。

(3)YUV420

这个有点特殊，上面的几种每4个像素点中的YUV三个分量都有采样，而YUV420则是第一次四个像素点中只采样Y和U分量，第二次四个像素点总只采用Y和V分量，然后依次交替进行。

存储格式为：{Y0,U0,V0},{Y1,U1,V1},{Y2,U2,V2}, {Y3,U3,V3},{Y5,U5,V5}, {Y6,U6,V6}, {Y7,U7,V7} , {Y8,U8,V8}

像素表示为：{Y0,U0,V5}, {Y1,U0,V5},{Y2,U2,V7}, {Y3,U2,V7},{Y5,U0,V5}, {Y6,U0,V5},{Y7,U2,V7}, {Y8,U2,V7}

数据压缩了1/2。

YcbCr：是经过伽马修正(gamma correction)编码处理后的YUV版本，Y'为颜色的亮度(luma)成分、而cb和Cr则为蓝色和红色的浓度偏移量成份。

RGB：是现在运用最广的颜色系统之一，通过红绿蓝三个分量的变化叠加来得到其他颜色。

BGR：把RGB的红色分量和蓝色交换即BGR。

颜色空间转换格式：

YUV<==>RGB

Y = (B * 1868 + G * 9617 + R * 4899 +8192)/16384;

U = ((B - Y)* 9241 + 8192)/16384 + 128;

V = ((R - Y)*11682 + 8192)/16384 + 128;

R = Y + 1.14V

G = Y - 0.39U - 0.58V

B = Y + 2.03U

YcbCr<==>RGB

Y’ = 0.257*R' + 0.504*G' + 0.098*B' + 16

Cb' = -0.148*R' - 0.291*G' + 0.439*B' + 128

Cr' = 0.439*R' - 0.368*G' - 0.071*B' + 128

R' = 1.164*(Y’-16) + 1.596*(Cr'-128)

G' = 1.164*(Y’-16) - 0.813*(Cr'-128) -0.392*(Cb'-128)

B' = 1.164*(Y’-16) + 2.017*(Cb'-128)

颜色空间转换代码：

在opencv中可以用cvtColor();函数来进行颜色空间的转换，同样我们也可以自己写函数来实现。

(1)自定义颜色空间转换函数

下面这个函数是根据上面的公式实现的YcbCr2BGR的函数，经过本人调试成功，不过出来最后的图像上下颠倒了，可以自己改一下，也可以根据YUV2RGB公式稍微改一下便可以进行YUV到RGB的转换。其中YcbCr为422格式，RGB为888格式。

int YcbCr2RGB(void* pYUV, void* pRGB, int width, int height, bool alphaYUV, bool alphaRGB)
{
    if (NULL == pYUV)
    {
        return -1;
    }
    unsigned char* pYUVData = (unsigned char *)pYUV;
    unsigned char* pRGBData = (unsigned char *)pRGB;
    int Y1, U1, V1, Y2, alpha1, alpha2, R1, G1, B1, R2, G2, B2;
    int C1, D1, E1, C2;
    if (alphaRGB)
    {
        if (alphaYUV)
        {
            for (int i=0; i<height; ++i)
            {
                for (int j=0; j<width/2; ++j)
                {
                    Y1 = *(pYUVData+i*width*3+j*6);    //i*width*3 = i*(width/2)*6
                    U1 = *(pYUVData+i*width*3+j*6+1);
                    Y2 = *(pYUVData+i*width*3+j*6+2);
                    V1 = *(pYUVData+i*width*3+j*6+3);
                    alpha1 = *(pYUVData+i*width*3+j*6+4);
                    alpha2 = *(pYUVData+i*width*3+j*6+5);
                    C1 = Y1-16;
                    C2 = Y2-16;
                    D1 = U1-128;
                    E1 = V1-128;
                    R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);
                    G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);
                    B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);
                    R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);
                    G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);
                    B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);
                    *(pRGBData+(height-i-1)*width*4+j*8+2) = R1<0 ? 0 : R1;
                    *(pRGBData+(height-i-1)*width*4+j*8+1) = G1<0 ? 0 : G1;
                    *(pRGBData+(height-i-1)*width*4+j*8) = B1<0 ? 0 : B1;
                    *(pRGBData+(height-i-1)*width*4+j*8+3) = alpha1;
                    *(pRGBData+(height-i-1)*width*4+j*8+6) = R2<0 ? 0 : R2;
                    *(pRGBData+(height-i-1)*width*4+j*8+5) = G2<0 ? 0 : G2;
                    *(pRGBData+(height-i-1)*width*4+j*8+4) = B2<0 ? 0 : B2;
                    *(pRGBData+(height-i-1)*width*4+j*8+7) = alpha2;
                }
            }
        }
        else
        {
            int alpha = 255;
            for (int i=0; i<height; ++i)
            {
                for (int j=0; j<width/2; ++j)
                {
                    Y1 = *(pYUVData+i*width*2+j*4);
                    U1 = *(pYUVData+i*width*2+j*4+1);
                    Y2 = *(pYUVData+i*width*2+j*4+2);
                    V1 = *(pYUVData+i*width*2+j*4+3);
                    C1 = Y1-16;
                    C2 = Y2-16;
                    D1 = U1-128;
                    E1 = V1-128;
                    R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);
                    G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);
                    B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);
                    R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);
                    G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);
                    B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);
                    *(pRGBData+(height-i-1)*width*4+j*8+2) = R1<0 ? 0 : R1;
                    *(pRGBData+(height-i-1)*width*4+j*8+1) = G1<0 ? 0 : G1;
                    *(pRGBData+(height-i-1)*width*4+j*8) = B1<0 ? 0 : B1;
                    *(pRGBData+(height-i-1)*width*4+j*8+3) = alpha;
                    *(pRGBData+(height-i-1)*width*4+j*8+6) = R2<0 ? 0 : R2;
                    *(pRGBData+(height-i-1)*width*4+j*8+5) = G2<0 ? 0 : G2;
                    *(pRGBData+(height-i-1)*width*4+j*8+4) = B2<0 ? 0 : B2;
                    *(pRGBData+(height-i-1)*width*4+j*8+7) = alpha;
                }
            }
        }
    }
    else
    {
        if (alphaYUV)
        {
            for (int i=0; i<height; ++i)
            {
                for (int j=0; j<width/2; ++j)
                {
                    Y1 = *(pYUVData+i*width*3+j*4);
                    U1 = *(pYUVData+i*width*3+j*4+1);
                    Y2 = *(pYUVData+i*width*3+j*4+2);
                    V1 = *(pYUVData+i*width*3+j*4+3);
                    C1 = Y1-16;
                    C2 = Y2-16;
                    D1 = U1-128;
                    E1 = V1-128;
                    R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);
                    G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);
                    B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);
                    R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);
                    G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);
                    B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);
                    *(pRGBData+(height-i-1)*width*3+j*6+2) = R1<0 ? 0 : R1;
                    *(pRGBData+(height-i-1)*width*3+j*6+1) = G1<0 ? 0 : G1;
                    *(pRGBData+(height-i-1)*width*3+j*6) = B1<0 ? 0 : B1;
                    *(pRGBData+(height-i-1)*width*3+j*6+5) = R2<0 ? 0 : R2;
                    *(pRGBData+(height-i-1)*width*3+j*6+4) = G2<0 ? 0 : G2;
                    *(pRGBData+(height-i-1)*width*3+j*6+3) = B2<0 ? 0 : B2;
                }
            }
        }
        else
        {
            for (int i=0; i<height; ++i)
            {
                for (int j=0; j<width/2; ++j)
                {
                    Y1 = *(pYUVData+i*width*2+j*4);
                    U1 = *(pYUVData+i*width*2+j*4+1);
                    Y2 = *(pYUVData+i*width*2+j*4+2);
                    V1 = *(pYUVData+i*width*2+j*4+3);
                    C1 = Y1-16;
                    C2 = Y2-16;
                    D1 = U1-128;
                    E1 = V1-128;
                    R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);
                    G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);
                    B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);
                    R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);
                    G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);
                    B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);
                    *(pRGBData+(height-i-1)*width*3+j*6+2) = R1<0 ? 0 : R1;
                    *(pRGBData+(height-i-1)*width*3+j*6+1) = G1<0 ? 0 : G1;
                    *(pRGBData+(height-i-1)*width*3+j*6) = B1<0 ? 0 : B1;
                    *(pRGBData+(height-i-1)*width*3+j*6+5) = R2<0 ? 0 : R2;
                    *(pRGBData+(height-i-1)*width*3+j*6+4) = G2<0 ? 0 : G2;
                    *(pRGBData+(height-i-1)*width*3+j*6+3) = B2<0 ? 0 : B2;
                }
            }
        }
    }
    return 0;
}

(2)使用opencv进行颜色空间转换

下面的代码主要调用了cvtColor();函数来实现YUV2BGR，把CV_YUV2BGR改成CV_ YcbCr2RGB即可把YcbCr转换成RGB。其中YUV为422格式，RGB为888格式。

（下面的代码运行效率较低，需要优化！）

void YUV2RGB (unsigned char *inbuf,Mat&bgrimg, int width, int height)
{
   vector<Mat> yuvchs;
   unsigned char ybuf[width*height];
   unsigned char ubuf[width*height/2];
   unsigned char vbuf[width*height/2];
   int cnt=0,y=0,u=0,v=0;
   for(int i=0;i<width*height*2;i++){
       if(i%2){
           if(cnt==0){
                ubuf[u++]=inbuf[i];
                cnt=1;
           }
            else{
                vbuf[v++]=inbuf[i];
                cnt=0;
           }
       }
       else{
           ybuf[y++]=inbuf[i];
       }
    }
   Mat umat0(1,width*height/2,CV_8UC1,ubuf);
   Mat vmat0(1,width*height/2,CV_8UC1,vbuf);
    Mat ymat1(1,width*height,CV_8UC1,ybuf);
   Mat umat1(1,width*height,CV_8UC1);
   Mat vmat1(1,width*height,CV_8UC1);
   resize(umat0,umat1,umat1.size());
   resize(vmat0,vmat1,vmat1.size());
   Mat yimg=ymat1.reshape(1,height);
   Mat uimg=umat1.reshape(1,height);
   Mat vimg=vmat1.reshape(1,height);
   yuvchs.push_back(yimg);
   yuvchs.push_back(uimg);
   yuvchs.push_back(vimg);
 
   Mat yuvimg;
   merge(yuvchs,yuvimg);
   cvtColor(yuvimg,bgrimg,CV_YUV2BGR);
}





叶落西湘
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
YUV格式与RGB格式图片转换
weixin_45824717的博客
03-14 316
实验一 YUV格式与RGB格式图片转换 一、实验内容 1.问题描述 课上老师已给出RGB转YUV格式的示例程序，阅读并理解该程序，编写将YUV转换为RGB的程序。将给定的实验数据用该程序转换为RGB文件。并与原RGB文件进行比较，如果有误差，分析误差来自何处。 2.实验环境 Visual Studio 2019 C语言 二、算法原理 RGB转YUV的公式： Y = 0.2990R + 0.5870G + 0.1140B U = - 0.1684R - 0.3316G + 0.5B + 128 V = 0.
yuv与rgb互转
wang__shenli的博客
09-05 948
YCbCr ：也叫YCC或者Y'CbCr，YCbCr 是数字信号，它包含两种形式，分别为TV range和full range，TV range 主要是广播电视采用的标准， full range主要是pc端采用的标准，所以full range 有时也叫 pc range。TV range 的各个分量的范围为： YUV Y∈[16,235] Cb∈[16-240] Cr∈[16-240]。YUV ： YUV是一种模拟型号， Y∈ [0,1] U,V∈[-0.5,0.5]
【图像处理】-小议YUV色彩空间-YUV和RGB格式的来由，相互关系以及转换方式，并对编程实现的YUV转为RGB程序进行介绍
最新发布
JasonHuan的博客
04-09 1138
在视频图像处理等相关相关领域，YUV是一个经常出现的格式。本文主要以图解的资料形式详细描述YUV和RGB格式的来由，相互关系以及转换方式，并对编程实现的YUV转为RGB程序进行介绍。
YUV与RGB格式转换
热门推荐
liujian8654562的博客
12-24 2万+
YUV与RGB格式转换 转载 2015年11月26日 12:24:43 标签：
C++实现YUV转RGBA
liji_digital的博客
04-20 937
本文受了https://blog.csdn.net/fanyun_01/article/details/100068351 的启发。但是该文章有一处谬误：YUV420的内存排列不是按照下图所示的。 正确的排列应如下（来源维基百科yuv条目）： 根据正确的内存排列，写出相应的代码： YUV2RGB.h #pragma once #include <qglobal.h> void vFillY_U_V_Buff(const quint32 & ui32Width, con
YUV转RGB汇总
mt122的专栏
08-09 2188
/* YUV, http://zh.wikipedia.org/wiki/YUV#.E5.B8.B8.E7.94.A8.E7.9A.84YUV.E6.A0.BC.E5.BC.8F * 作为视频媒体类型的辅助说明类型（Subtype），它们对应的GUID如下： * 在DirectShow中，常见的RGB和YUV格式 GUID
数据压缩实验一——YUV和RGB互相转换
weixin_50971817的博客
04-05 671
数据压缩——YUV和RGB互相转换 一、实验内容： 1，实现将编写将YUV转换为RGB的程序。将给定的实验数据用该程序转换 为RGB文件。并与原RGB文件进行比较，如果有误差，分析误差来自何处。2，总结 RGB 和 YUV 彩色空间转换的转换公式及编程实现的算法并写成实验报告。 二、实验原理： Y=0.299R+0.587G+0.114B U=-0.1684R-0.3316G+0.5B+128 V=0.5R-0.4187G-0.0813B+128 R=Y+1.4075（V-128） G=Y-0.3455（U
RGB YUV 转换工具
01-06
RGB颜色空间是基于三原色理论，由红色（Red）、绿色（Green）和蓝色（Blue）三种基色按照不同比例混合来创建各种颜色。任何可见光的颜色都可以通过这三种颜色的不同强度组合得到。RGB模型是一种线性的颜色表示方式，...
YUV颜色空间转换（YV12、NV12、NV21、I420、RGB等）
08-17
注：1、本程序只是简单YUV之间的颜色空间转换和YUV与RGB的转换。 2、本程序使用的vs2019创建的，需使用2019打开工程。 3、包含功能： 1）YV12_2_I420； 2）I420_2_YV12； 3）NV12_2_I420; 4）I420_2_NV12； 5...
YUV格式和RGB格式颜色空间原始素材文件
11-14
1.颜色空间转换是非常基础的操作。 2.包含YUV格式的颜色空间原始文件Mona.yuv。 3.包含RGB格式的颜色空间原始文件Mona.rgb。
YUV与RGB色彩空间的转换
07-30
对于数字电子多媒体领域来说，我们经常接触到的色彩空间的概念，主要是RGB , YUV这两种（实际上，这两种体系包含了许多种具体的颜色表达方式和模型，如sRGB, Adobe RGB, YUV422, YUV420 …）, RGB是按三基色加光系统...
yuv与rgb转换与处理工具
12-07
支持yuv\rgb的各种处理，比如rgb与yuv的相互转换，视频格式转换，从一段长视频中截取出某几帧等，此工具包里包含多个工具 YUVviewerPlus.exe 对YUVviewer进行了修改，增加一下内容： 1、增加支持的格式：yuv4:4:4, yuv4:2:2, gbmp 2、增加zoom的范围 BMP2GBMP.exe 将一副副的BMP图片合并成一个没有BMP头信息的文件 note:仅支持24位bmp图片 DYUV2SEQ.exe 实现分离的yuv文件转换成YUV序列 4：2：0 ShowDIB.exe BMP图片显示程序，多文档框架 YUV2BMP.exe 实现了YUV转换成24位的BMP图片，实现了批量转换 BMP2SEQ.exe 将一系列24位或8位的BMP图片转换成4：2：0的YUV序列。 DYUV2BMP.exe 将分离的Y，U，V转换成24位的BMP图片，实现了批量转换 GBMP2SEQ.exe 实现包含一组rgb24图片（不含文件头）的单一文件到yuv4:2:0序列文件的转换 SEQ2BMP.exe 实现了SEQ2BMP的程序 输出BMP文件为24位真彩 SeqCut.exe 实现对YUV4:2:0文件的剪切操作 即从序列文件中取出一段序列 SeqSnr.exe 实现了两序列对应帧之间Y分量的SNR求取，并给出平均值 YUV2SEQ.exe 将单帧的YUV文件转换位YUV序列 4：2：0 YUV2SEQ2.exe 将单帧的YUV文件转换位YUV序列 4：2：0 可以选择目标图像的位置和大小
YUV和RGB的区别和互相转换
03-31
YUV和RGB 色彩空间 什么是YCbCr ；YUV420P 和 YUV420SP 的区别；YUV和RGB的区别和互相转换
常用YUV转RGB代码
weixin_34015566的博客
01-19 377
常用YUV转RGB [java]view plaincopyprint? publicclassYuvToRGB{ privatestaticintR=0; privatestaticintG=1; privatestaticintB=2; //I420是yu...
【视频处理】YUV与RGB格式转换
weixin_34138377的博客
05-16 178
YUV格式具有亮度信息和色彩信息分离的特点，但大多数图像处理操作都是基于RGB格式。 因此当要对图像进行后期处理显示时，需要把YUV格式转换成RGB格式。 RGB与YUV的变换公式如下：   YUV(256 级别) 可以从8位 RGB 直接计算： Y = 0.299 R + 0.587 G + 0.114 B U = - 0.1687 R - 0.3313 G + 0.5 B + 128 V =...
YuvToRGB 快速转换
liuxs2009的专栏
04-08 1082
android平台提供的RenderScript可以帮助应用快速完成yuv到rgb的数据互转。 首先创建实例： rs = RenderScript.create(this); yuvToRgbIntrinsic = ScriptIntrinsicYuvToRGB.create(rs, Element.U8_4(rs)); 接着创建builder和allocator： yuvType =...
C# YUV转RGB
qq114480的博客
04-23 2040
YUV测试数据： https://download.csdn.net/download/xunixiaotou111/12197306 转换之后的结果： 核心代码： public class YUVtoRGB { static double[,] YUV2RGB_CONVERT_MATRIX = new double[3, 3] { { 1, 0, 1.4022 }...
YUV2RGB快速算法分析
程序猿老樊的博客
03-29 1361
YUV实际是YcrCb了，YUV2RGB的转换公式本身是很简单的，但是牵涉到浮点运算，所以，如果要实现快速算法，算法结构本身没什么好研究的了，主要是采用整型运算或者查表来加快计算速度。 首先可以推导得到转换公式为： R = Y + 1.4075 *（V-128） G = Y – 0.3455 *（U –128） – 0.7169 *（V –128） B = Y...
YUV到RGB的转换
weixin_30654583的博客
04-29 112
以下内容来源于网络，下面三个链接里的内容是比较好的，感谢博主的分享。 http://blog.csdn.net/housisong/article/details/1859084 http://blog.csdn.net/tommy_wxie/article/details/37909643 http://www.cnblogs.com/qinjunni/archive/2012/...
matlab实现rgb空间转换到yuv空间
05-05
好的，很高兴为您解答问题。您可以使用MATLAB内置的rgb2yuv函数来实现RGB到YUV空间的转换，具体代码如下： ```matlab rgbImage = imread('your_image.png'); yuvImage = rgb2yuv(rgbImage); ``` 这样，您就可以将一个RGB图像转换为YUV图像了。 同时，您也可以手动实现该转换，代码如下： ```matlab rgbImage = imread('your_image.png'); yuvImage = zeros(size(rgbImage)); for i = 1:size(rgbImage, 1) for j = 1:size(rgbImage, 2) R = rgbImage(i, j, 1); G = rgbImage(i, j, 2); B = rgbImage(i, j, 3); Y = 0.299 * R + 0.587 * G + 0.114 * B; U = -0.14713 * R - 0.28886 * G + 0.436 * B; V = 0.615 * R - 0.51498 * G - 0.10001 * B; yuvImage(i, j, 1) = Y; yuvImage(i, j, 2) = U; yuvImage(i, j, 3) = V; end end ``` 以上代码中，我们手动实现了RGB到YUV的转换方式。其中，Y表示亮度，U和V则表示色度。这里需要注意的是，该转换中需要进行颜色空间的归一化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

叶落西湘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值