彩色空间转换（编程实现YUV与RGB文件格式的相互转换）

最新推荐文章于 2022-02-20 16:48:26 发布
最新推荐文章于 2022-02-20 16:48:26 发布
阅读量674 收藏 2
点赞数
分类专栏： 数据压缩课程实验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxrabc/article/details/114903275
版权

文章目录

一、实验要求

1. 基本要求（必做）
编写RGB转化为YUV程序，重点掌握函数定义，部分查找表的初始化和调用，缓冲区分配。将得到的RGB文件转换为YUV文件，用YUV Viewer播放器观看，验证是否正确。

2. 提高要求（可选）
编写将YUV转换为RGB的程序。将给定的实验数据用该程序转换为RGB文件。并与原RGB文件进行比较，如果有误差，分析误差来自何处。

注：down.rgb和down.yuv两个文件的分辨率均为256*256。yuv文件为4:2:0采样空间。

二、实验思路

1. 创建1个头文件、2个源程序文件，在主程序中设置初始化参数
定义输入、输出文件指针，定义宽、高变量并赋值，定义四个缓冲区指针。

2. 打开待转换的文件
为rgb、y、u、v（或yuv、r、g、b)四个缓冲区指针分配相应大小的动态内存，用fread函数将rgb文件（或yuv文件）的数据依次读入四个缓冲区。

3. 调用自定义的RGB2YUV（或YUV2RGB）函数
先调用查找表计算相应像素的Y、U、V值，再进行下采样，输出到yuv的缓冲区。
（或者先对U、V分量进行上采样，再调用查找表计算相应像素的R、G、B值，输出到rgb的缓冲区。）

  • 查找表
    由于从内存中提取数值经常要比复杂的计算速度快很多，所以使用查找表得到的速度提升是很显著的。

  • RGB 与 YUV 空间的相互转换

在这里插入图片描述

  • 转换公式
    为将两个色差信号电平控制在-0.5~0.5，零电平对应128的码电平

                                  Y ＝ 0.299 R + 0.587 G + 0.114 B
                              U ＝ - 0.1684 R - 0.3316 G + 0.5 B
                              V ＝ 0.5 R - 0.4187 G - 0.0813 B

                              R = Y + 1.4075 *（V-128） 
                              G = Y – 0.3455 （U –128） – 0.7169 （V –128) 
                              B = Y + 1.779 *（U – 128）

  • 越界判定
    程序YUV2RGB，计算出的RGB值会超过允许的范围（0-255），会导致图像失真。因此需要舍去超过范围的RGB值，若>255则赋值为255，若<0则赋值为0。

4. 将数据写入文件，释放缓冲区，关闭文件。

5. 在调试中设置程序文件所在的工作目录和主函数所需的命令参数
命令参数分别为：读入待转换的文件名、输出文件名、图像的宽、图像的高。

三、代码实现

1.RGB2YUV

  • 头文件（rgb2yuv.h）
int RGB2YUV (int x_dim, int y_dim, void *bmp, void *y_out, void *u_out, void *v_out, int flip);

void InitLookupTable();
  • 源文件（main.cpp）
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include "rgb2yuv.h"

#define u_int8_t	unsigned __int8
#define u_int		unsigned __int32
#define u_int32_t	unsigned __int32
#define FALSE		false
#define TRUE		true

int main(int argc, char** argv)
{
	/* variables controlable from command line */
	u_int frameWidth = 352;			/* --width=<uint> */
	u_int frameHeight = 240;		/* --height=<uint> */
	bool flip = TRUE;				/* --flip */
	unsigned int i;

	/* internal variables */
	char* rgbFileName = NULL;
	char* yuvFileName = NULL;
	FILE* rgbFile = NULL;
	FILE* yuvFile = NULL;
	u_int8_t* rgbBuf = NULL;
	u_int8_t* yBuf = NULL;
	u_int8_t* uBuf = NULL;
	u_int8_t* vBuf = NULL;
	u_int32_t videoFramesWritten = 0;

	/* begin process command line */
	/* point to the specified file names */
	rgbFileName = argv[1];
	yuvFileName = argv[2];

	frameWidth = atoi(argv[3]);
	frameHeight = atoi(argv[4]);
	
	/* open the RGB file */
	rgbFile = fopen(rgbFileName, "rb");
	if (rgbFile == NULL)
	{
		printf("cannot find rgb file\n");
		exit(1);
	}
	else
	{
		printf("The input rgb file is %s\n", rgbFileName);
	}

	/* open the RAW file */
	yuvFile = fopen(yuvFileName, "wb");
	if (yuvFile == NULL)
	{
		printf("cannot find yuv file\n");
		exit(1);
	}
	else
	{
		printf("The output yuv file is %s\n", yuvFileName);
	}

	/* get an input buffer for a frame */
	rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);

	/* get the output buffers for a frame */
	yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
	uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
	vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);

	if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)
	{
		printf("no enought memory\n");
		exit(1);
	}

	while (fread(rgbBuf, 1, frameWidth * frameHeight * 3, rgbFile)) 
	{
		if(RGB2YUV(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
		{
			printf("error");
			return 0;
					}

		for (i = 0; i < frameWidth*frameHeight; i++)
		{
			if (yBuf[i] < 16) yBuf[i] = 16;
			if (yBuf[i] > 235) yBuf[i] = 235;
		}

		for (i = 0; i < frameWidth*frameHeight/4; i++)
		{
			if (uBuf[i] < 16) uBuf[i] = 16;
			if (uBuf[i] > 240) uBuf[i] = 240;

			if (vBuf[i] < 16) vBuf[i] = 16;
			if (vBuf[i] > 240) vBuf[i] = 240;
		}

		fwrite(yBuf, 1, frameWidth * frameHeight, yuvFile);
		fwrite(uBuf, 1, (frameWidth * frameHeight) / 4, yuvFile);
		fwrite(vBuf, 1, (frameWidth * frameHeight) / 4, yuvFile);

		printf("\r...%d", ++videoFramesWritten);
	}

	printf("\n%u %ux%u video frames written\n", 
		videoFramesWritten, frameWidth, frameHeight);

	/* cleanup */

	fclose(rgbFile);
	fclose(yuvFile);

	return(0);
}
  • 源文件（rgb2yuv.cpp）
#include "stdlib.h"
#include "rgb2yuv.h"

static float RGBYUV02990[256], RGBYUV05870[256], RGBYUV01140[256];
static float RGBYUV01684[256], RGBYUV03316[256];
static float RGBYUV04187[256], RGBYUV00813[256];

int RGB2YUV (int x_dim, int y_dim, void *bmp, void *y_out, void *u_out, void *v_out, int flip)
{
	static int init_done = 0;

	long i, j, size;
	unsigned char *r, *g, *b;
	unsigned char *y, *u, *v;
	unsigned char *pu1, *pu2, *pv1, *pv2, *psu, *psv;
	unsigned char *y_buffer, *u_buffer, *v_buffer;
	unsigned char *sub_u_buf, *sub_v_buf;

	if (init_done == 0)
	{
		InitLookupTable();
		init_done = 1;
	}

	// check to see if x_dim and y_dim are divisible by 2
	if ((x_dim % 2) || (y_dim % 2)) return 1;
	size = x_dim * y_dim;

	// allocate memory
	y_buffer = (unsigned char *)y_out;
	sub_u_buf = (unsigned char *)u_out;
	sub_v_buf = (unsigned char *)v_out;
	u_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
	v_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
	if (!(u_buffer && v_buffer))
	{
		if (u_buffer) free(u_buffer);
		if (v_buffer) free(v_buffer);
		return 2;
	}

	b = (unsigned char *)bmp;
	y = y_buffer;
	u = u_buffer;
	v = v_buffer;

	// convert RGB to YUV
	if (!flip) {
		for (j = 0; j < y_dim; j ++)
		{
			y = y_buffer + (y_dim - j - 1) * x_dim;
			u = u_buffer + (y_dim - j - 1) * x_dim;
			v = v_buffer + (y_dim - j - 1) * x_dim;

			for (i = 0; i < x_dim; i ++) {
				g = b + 1;
				r = b + 2;
				*y = (unsigned char)(  RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
				*u = (unsigned char)(- RGBYUV01684[*r] - RGBYUV03316[*g] + (*b)/2          + 128);
				*v = (unsigned char)(  (*r)/2          - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
				b += 3;
				y ++;
				u ++;
				v ++;
			}
		}
	} else {
		for (i = 0; i < size; i++)
		{
			g = b + 1;
			r = b + 2;
			*y = (unsigned char)(  RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
			*u = (unsigned char)(- RGBYUV01684[*r] - RGBYUV03316[*g] + (*b)/2          + 128);
			*v = (unsigned char)(  (*r)/2          - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
			b += 3;
			y ++;
			u ++;
			v ++;
		}
	}

	// subsample UV
	for (j = 0; j < y_dim/2; j ++)
	{
		psu = sub_u_buf + j * x_dim / 2;
		psv = sub_v_buf + j * x_dim / 2;
		pu1 = u_buffer + 2 * j * x_dim;
		pu2 = u_buffer + (2 * j + 1) * x_dim;
		pv1 = v_buffer + 2 * j * x_dim;
		pv2 = v_buffer + (2 * j + 1) * x_dim;
		for (i = 0; i < x_dim/2; i ++)
		{
			*psu = (*pu1 + *(pu1+1) + *pu2 + *(pu2+1)) / 4;
			*psv = (*pv1 + *(pv1+1) + *pv2 + *(pv2+1)) / 4;
			psu ++;
			psv ++;
			pu1 += 2;
			pu2 += 2;
			pv1 += 2;
			pv2 += 2;
		}
	}

	free(u_buffer);
	free(v_buffer);

	return 0;
}


void InitLookupTable()
{
	int i;

	for (i = 0; i < 256; i++) RGBYUV02990[i] = (float)0.2990 * i;
	for (i = 0; i < 256; i++) RGBYUV05870[i] = (float)0.5870 * i;
	for (i = 0; i < 256; i++) RGBYUV01140[i] = (float)0.1140 * i;
	for (i = 0; i < 256; i++) RGBYUV01684[i] = (float)0.1684 * i;
	for (i = 0; i < 256; i++) RGBYUV03316[i] = (float)0.3316 * i;
	for (i = 0; i < 256; i++) RGBYUV04187[i] = (float)0.4187 * i;
	for (i = 0; i < 256; i++) RGBYUV00813[i] = (float)0.0813 * i;
}

2.YUV2RGB

  • 头文件（yuv2rgb.h）
int YUV2RGB(int x_dim, int y_dim, void* bmp, void* y_out, void* u_out, void* v_out, int flip);

void InitLookupTable();
  • 源文件（main.cpp）
#include <stdio.h>
#include <stdlib.h>  
#include <malloc.h>
#include "yuv2rgb.h"

#define u_int8_t	unsigned __int8  
#define u_int		unsigned __int32  
#define u_int32_t	unsigned __int32
#define FALSE		false
#define TRUE		true

int main(int argc, char* argv[])
{
	/* variables controlable from command line */
	u_int frameWidth = 352;			/* --width=<uint> */
	u_int frameHeight = 240;		/* --height=<uint> */
	bool flip = TRUE;				/* --flip */
	unsigned int i;

	/* internal variables */
	char* rgbFileName = NULL;
	char* yuvFileName = NULL;
	FILE* rgbFile = NULL;
	FILE* yuvFile = NULL;
	u_int8_t* rgbBuf = NULL;
	u_int8_t* yBuf = NULL;
	u_int8_t* uBuf = NULL;
	u_int8_t* vBuf = NULL;
	u_int32_t videoFramesWritten = 0;

	/* begin process command line */
	/* point to the specified file names */
	yuvFileName = argv[1];
	rgbFileName = argv[2];

	frameWidth = atoi(argv[3]);   
	frameHeight = atoi(argv[4]);

	/* open the YUV file */
	yuvFile = fopen(yuvFileName, "rb");
	if (yuvFile == NULL)
	{
		printf("cannot find yuv file\n");
		exit(1);
	}
	else
	{
		printf("The input yuv file is %s\n", yuvFileName);
	}

	/* open the RGB file */
	rgbFile = fopen(rgbFileName, "wb");
	if (rgbFile == NULL)
	{
		printf("cannot find rgb file\n");
		exit(1);
	}
	else
	{
		printf("The output rgb file is %s\n", rgbFileName);
	}

	/* get an input buffer for a frame */
	rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);  

	/* get the output buffers for a frame */
	yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
	uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
	vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);

	if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL) 
	{
		printf("no enought memory\n");
		exit(1);
	}

	while (fread(yBuf, 1, frameWidth * frameHeight, yuvFile)
		&& fread(uBuf, 1, frameWidth * frameHeight / 4, yuvFile)
		&& fread(vBuf, 1, frameWidth * frameHeight / 4, yuvFile))
	{
		
		if (YUV2RGB(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
		{
			printf("error");
			return 0;
		}
		fwrite(rgbBuf, 1, frameWidth * frameHeight * 3, rgbFile);


		printf("\r...%d", ++videoFramesWritten);
	}

	printf("\n%u %ux%u video frames written\n",
		videoFramesWritten, frameWidth, frameHeight);


	fclose(rgbFile);
	fclose(yuvFile);

	if (rgbBuf != NULL) free(rgbBuf);
	if (yBuf != NULL)free(yBuf);
	if (uBuf != NULL)free(uBuf);
	if (vBuf != NULL)free(vBuf);

	return(0);
}
  • 源文件（yuv2rgb.cpp）
#include "stdlib.h"
#include "yuv2rgb.h"

static float YUVRGB14075[256];
static float YUVRGB03455[256], YUVRGB07169[256];
static float YUVRGB1779[256];

int YUV2RGB(int width, int height, void* rgb_out, void* y_in, void* u_in, void* v_in, int flip)
{
	static int init_done = 0;

	long i, j, size;
	float r1, g1, b1;
	unsigned char* r, * g, * b;
	unsigned char* y, * u, * v;
	unsigned char* y_buffer, * u_buffer, * v_buffer, * rgb_buffer;
	unsigned char* sub_u_buf, * sub_v_buf;

	if (init_done == 0)
	{
		InitLookupTable();
		init_done = 1;
	}


	if ((width % 2) || (height % 2)) return 1;
	size = width * height;


	y_buffer = (unsigned char*)y_in;
	u_buffer = (unsigned char*)u_in;
	v_buffer = (unsigned char*)v_in;
	rgb_buffer = (unsigned char*)rgb_out;
	sub_u_buf = (unsigned char*)malloc(size);
	sub_v_buf = (unsigned char*)malloc(size);

	for (i = 0; i < height; i++)
	{
		for (j = 0; j < width; j++)
		{
			*(sub_u_buf + i * width + j) = *(u_buffer + (i / 2) * (width / 2) + j / 2);
			*(sub_v_buf + i * width + j) = *(v_buffer + (i / 2) * (width / 2) + j / 2);
		}
	}

	b = rgb_buffer;//RGB格式文件储存时顺序为倒序
	y = y_buffer;
	u = sub_u_buf;
	v = sub_v_buf;

	for (i = 0; i < height; i++)
	{
		for (j = 0; j < width; j++)
		{
			g = b + 1;
			r = b + 2;
			r1 = *y + YUVRGB14075[*v];
			g1 = *y - YUVRGB03455[*u] - YUVRGB07169[*v];
			b1 = *y + YUVRGB1779[*u];
			*r = (r1 > 0 ? (r1 > 255 ? 255 : (unsigned char)r1) : 0);
			*g = (g1 > 0 ? (g1 > 255 ? 255 : (unsigned char)g1) : 0);
			*b = (b1 > 0 ? (b1 > 255 ? 255 : (unsigned char)b1) : 0);
			b = b + 3;
			y++;
			u++;
			v++;
		}
	}
	if (sub_u_buf != NULL) free(sub_u_buf);
	if (sub_v_buf != NULL) free(sub_v_buf);



	return 0;
}


void InitLookupTable()
{
	int i;

	for (i = 0; i < 256; i++) YUVRGB14075[i] = (float)1.4075 * (i - 128);
	for (i = 0; i < 256; i++) YUVRGB03455[i] = (float)0.3455 * (i - 128);
	for (i = 0; i < 256; i++) YUVRGB07169[i] = (float)0.7169 * (i - 128);
	for (i = 0; i < 256; i++) YUVRGB1779[i] = (float)1.779 * (i - 128);

}

四、总结分析

1.RGB2YUV

左图为yuv原图，右图为rgb图像转换的yuv图像。可以看出图像一致，转换成功。
经理论分析，图像转换无损。
在这里插入图片描述

2.YUV2RGB

左图为rgb原图，右图为yuv图像转换的rgb图像。可以看出并无明显误差，但经理论分析转换有损。
在这里插入图片描述

误差分析

  1. 因为YUV采样空间为4:2:0，所以U、V分量只有Y的1/4。在YUV2RGB的转换过程中，需要进行上采样，因此造成了误差。
  2. 公式只保留了四位小数，造成了计算误差。
cxrabc
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据压缩实验一 实现RGB与YUV的转换
wyy001022的博客
03-24 302
实验目的： 1、编写rgb到yuv的转换代码，并通过yuvviewer播放器观看。 2、编写rgb到yuv的转换代码，与原rgb文件相对比，并思考差别。 实验原理： ·根据亮度方程式得出： Y ＝0.2990R+0.5870G+0.1140B R-Y＝0.7010R-0.5870G-0.1140B B-Y＝-0.2990R-0.5870G+0.8860B ·对色差信号引入压缩系数，归一化后的色度方程式是： V＝0.877（R-Y）= 0.5 R-0.4187 G-0.0813 B U＝0.493 (B-Y)
【数据压缩作业】使用C++实现YUV与RGB彩色空间转换
Abigailiar的博客
03-17 493
目录一、实验要求二、RGB TO YUV1. 实验原理2. 代码实现3. 实验结果三、YUV TO RGB1. 实验原理2. 代码实现（1）主函数（2）子程序（3）定义指针（4）开缓冲3.实验结果四、实验总结 一、实验要求 1.学会从计算和程序的角度分析问题 通过完成本实验，理解计算思维，即从问题出发，通过逐步分析和分解，把原问题转化 为可用程序方式解决的问题。在此过程中设计出一个解决方案。 2.进一步理解彩色空间的概念并掌握不同彩色空间转换的基本方程。 3.通过逐步设计程序，掌握编程细节:如查找表的设计，
彩色图像颜色空间的转换RGB2yuv
02-21
matlab非常使用的代码程序 适合初学者阅读
RGB-YUV颜色空间转换
03-24
这个代码是我数字图像处理课程的实验设计，实现了将一个RGB图像转化成YUV图像，且可以将Y分量、U分量、V分量进行分离，生成不同通道的图像。
编写彩色空间转换程序：YUVtoRGB
qq_43399224的博客
03-18 140
Y=+0.299R+0.587G+0.114B U0=0.564(B-Y)=−0.1684R−0.3316G+0.5B V0=0.713(R-Y)=+0.5R−0.4187G−0.0813B 所以 B-Y=U0/0.564 B=Y+1.773U0 R-Y=V0/0.713 R=Y+1.403V0 G=(Y-(0.299R+0.114B))/0.587 G=Y-0.714V0-0.344U0 U=U0+128 V=V0+128 所以 B=Y+1.773U-226.944
RGB YUV颜色空间转换matlab实现
03-15
RGB YUV颜色空间转换matlab实现
C#中关于视频YUV格式与RGB24格式之间的相互转换
09-27
总而言之，文档中提到的内容围绕了如何在C#环境下实现图像格式的转换，特别从RGB24转换到YUV格式，以及如何处理图像数据以优化存储和处理速度。这些知识点对于进行图像处理、视频处理或任何需要图像数据转换的应用...
彩色空间转换rgb与yuv的相互转换
csy201710413030的博客
03-29 896
彩色空间转换的基本思想及转换公式 （1）YUV与RGB空间的相互转换 由电视原理可知，亮度和色差信号的构成如下： Y＝0.2990R+0.5870G+0.1140B R-Y＝0.7010R-0.5870G-0.1140B B-Y＝-0.2990R-0.5870G+0.8860B 为了使色差信号的动态范围控制在0.5之间，需要进行归一化，对色差信号引入压缩 系数。归一化后的色差信号为： U＝-0.1...
【实验一】使用C++实现YUV与RGB色彩空间转换
weixin_47048525的博客
07-13 504
实验一@TOC 1、实验目的 1．学会从计算和程序的角度分析问题 2.通过完成本实验，理解计算思维，即从问题出发，通过逐步分析和分解，把原问题转化为可用程序方式解决的问题。在此过程中设计出一个解决方案。 3．进一步理解彩色空间的概念并掌握不同彩色空间转换的基本方程。 3．通过逐步设计程序，掌握编程细节：如查找表的设计，内存分配，对 U 和 V 信号进行下采样，文件读写过程等。掌握程序调试的基本方法。 4.实验设备：安装 Visual Studio 及其他软件的个人计算机。 2.实验原理： 1.彩色空间转换的
实现彩色空间转换 即RGB到YUV240 和 YUV240到RGB的转换
qq_43850979的博客
03-14 419
使用C++ Python实现彩色空间转换 即RGB到YUV240 和 YUV240 到RGB的转换一. 彩色空间转换的基本公式1. RGB转YUV2. YUV转RGB二. 使用C++ 实现RGB到YUV240的转换1. 打开RGB文件与创建待存储的YUV文件2. 创建存储区Buffer3. 主函数以及码电平分配及数字表达式4. rgb2yuv函数的编写5. YUV文件的输出对比三. 使用Python 实现YUV240到RGB的转换1. YUV通道的分离与扩展2. YUV向RGB的转换3. YUV向RGB的转
YUV与RGB色彩空间的转换
07-30
对于数字电子多媒体领域来说，我们经常接触到的色彩空间的概念，主要是RGB , YUV这两种（实际上，这两种体系包含了许多种具体的颜色表达方式和模型，如sRGB, Adobe RGB, YUV422, YUV420 …）, RGB是按三基色加光系统的原理来描述颜色，而YUV则是按照 亮度，色差的原理来描述颜色。
YUV422转RGB888 FPGA Verilog纯逻辑代码
03-03
YUV422转RGB888 FPGA Verilog纯逻辑代码 支持1920x1080
YUV信号转RGB
03-07
FPGA VHDA Verilog，YCbCr YUV RGB
视频处理中YUV转RGB
11-10
打开就可以使用完整的代码程序，直接打开工程。已经调试完。
YUV转RGB 的verilog代码
06-16
YUV转RGB 的verilog代码。实现方法采用查表法，经过验证。
24位BMP图像RGB与YUV转换
FrozenShore
11-22 3962
关于BMP图像格式的部分这里就不讲了，网上有很多资料可以查阅，详细可以看下面的代码。 在读取了BMP图像以后，开始把RGB转化为YUV（有关YUV可以查阅wiki）。 本次使用的YUV标准是8-bit BT.601 YUV，也就是YUV 4:4:4。 从RGB转化为YUV格式有很多种方法，我采用的是整型法，公式如下： Y = ( ( 66 * R + 129 * G + 25
matlab yuv转rgb_fpga实现YCbCr422转YCbCr444
weixin_39890633的博客
11-28 702
1 YCbCr颜色空间 YCbCr颜色空间是YUV颜色空间的缩放和偏移版本。Y定义为8bit,标称颜色范围为16-235；Cb和Cr标称颜色表示范围为16-240。YCbCr的采样格式一般有4:4:4、4:2:2、4:1:1、和4:2:0。 1.1 4:4:4 YCbCr格式 图1表示4:4:4格式YCbCr采样点的定位。每个采样点有Y、Cb和Cr值，每个颜色值的颜色分量为8bit（典型），因...
编程实现色彩空间YUV转化成RGB
weixin_45631006的博客
03-24 258
一.实验原理 1.YUV转RGB的转换公式 R=Y+1.14075(V-128) G=Y-0.7169(V-128)0.3455(U-128) B=Y+1.779(U-128)（-128是为了保证在区间内） 2.YUV一帧的结构 YUV 4:2:0采样，每四个Y共用一组UV分量 3.RGB存储结构：按照B、G、R顺序分别存储： 4.yuv2rgb中关键思想——上采样： 二.代码实现在这里插入代码片 ...
【音视频开发（三）】---YUV转RGB 图像颜色空间转换
sdewenking的专栏
02-20 3606
Opencv YUV转RGB
RGB到YUV彩色空间转换实验详解
"彩色空间转换实验1 - 实现RGB到YUV的转换，涉及文件操作、主函数参数处理以及彩色空间基础知识" 实验1的核心是将RGB颜色空间的图像数据转换成YUV颜色空间。在数字图像处理中，RGB（红绿蓝）是一种加色模型，用于...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值