彩色空间转换

实验目的

1. 学会从计算和程序的角度分析问题

通过完成本实验,理解计算思维,即从问题出发,通过逐步分析和分解,把原问题转化为可用程序方式解决的问题。在此过程中设计出一个解决方案。

2. 进一步理解彩色空间的概念并掌握不同彩色空间转换的基本方程。

3. 通过逐步运行程序,掌握编程细节:如查找表的设计,内存分配,对 U 和 V 信号进行下采样,文件读写过程等。掌握程序调试的基本方法。

实验原理

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.1684R-0.3316G+0.5B
V=0.5R-0.4187G-0.0813B

2. 码电平分配及数字表达式

 亮电平信号量化后码电平分配在对分量信号进行8比特均匀量化时,共分为256个等间隔的量化级。为了防止信号

变动造成过载,在256级上端留20级,下端留16级作为信号超越动态范围的保护带。 

 色差信号量化后码电平分配

色差信号经过归一化处理后,动态范围为-0.5-0.5,让色差零电平对应码电平128,色差信号总共占225个量化级。在256级上端留15级,下端留16级作为信号超越动态范围的保护带。

(3)色度格式

4:2:0格式是指色差信号U,V的取样频率为亮度信号取样频率的四分之一,在水平方向和垂直方向上的取样点数均为Y的一半。

实验步骤

1. RGB2YUV文件转换流程分析 

1）程序初始化(打开两个文件、定义变量和缓冲区等)

2）读取RGB文件,抽取RGB数据写入缓冲区

3）调用RGB2YUV的函数实现RGB到YUV数据的转换

4）写YUV文件

5）程序收尾工作(关闭文件,释放缓冲区) 

2. YUV2RGB文件转换流程分析

1）程序初始化(打开两个文件、定义变量和缓冲区等)

2）读取YUV文件,抽取YUV数据写入缓冲区

3）调用YUV2RGB的函数实现YUV到RGB数据的转换

4）写RGB文件

5）程序收尾工作(关闭文件,释放缓冲区) 

3. 部分查找法：

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

代码分析

1.  main.cpp

#include   
#include   
#include   
#include "yuv2rgb.h"  
  
/* 为防止不同计算机软件对int分配字节的不同，这里做统一的定义*/  
#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= */  
	u_int frameHeight = 240;/* --height= */  
	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 */  
  
	//argv[0]是当前执行的exe文件名,其中包含该文件的路径名  
	yuvFileName = argv[1];  
	rgbFileName = argv[2];  
  
  
	frameWidth = atoi(argv[3]);/* 这里由于argv[3]和argv[4]中的数据以字符串类型存储，需要引用atoi函数，将字符串强制转换为整型 */  
	frameHeight = atoi(argv[4]);  
  
	/*int main(int argc, char** argv) 调用：命令名 参数1  参数2 ......参数n; argc= n+1; argv[0]自动指向当前执行的程序的全路径名 */  
	/* 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 the input 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);  
	/* get an output buffer for a frame */  
	rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);  
  
  
	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, yBuf, uBuf, vBuf, rgbBuf, 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);  
  	
  
		/* cleanup */  
	free(rgbBuf);  
	free(yBuf);  
	free(uBuf);  
	free(vBuf);  
	fclose(rgbFile);  
	fclose(yuvFile);  
      	
	return(0);  
}  

 2.  yuv2rgb.cpp

#include "stdlib.h"  
#include "yuv2rgb.h"  
  
static float YUVRGB14075[256];  
static float YUVRGB034455[256], YUVRGB07169[256];  
static float YUVRGB1779[256];  
  
int YUV2RGB (int x_dim, int y_dim,void *y_in, void *u_in, void *v_in,void *bmp, 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;  
	float psr,psg,psb;  
  
	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;  
  
	y_buffer = (unsigned char *)y_in;  
	sub_u_buf = (unsigned char *)u_in;  
	sub_v_buf = (unsigned char *)v_in;  
	u_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));  
	v_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));  
	//将U, V扩充之后，U,V所占的空间大小与Y相同  
  
	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;  
  
	// exspand UV  
	for (j = 0; j < y_dim/2; j ++)  
	{  
		psu = sub_u_buf + j * x_dim / 2;//sub_u_buf是指向输入u_in的指针，psu指向输入的每一行  
		psv = sub_v_buf + j * x_dim / 2;  
		pu1 = u_buffer + 2 * j * x_dim;// pu1指向u_buffer的奇数行  
		pu2 = u_buffer + (2 * j + 1) * x_dim;//pu2指向u_buffer的偶数行  
		pv1 = v_buffer + 2 * j * x_dim;  
		pv2 = v_buffer + (2 * j + 1) * x_dim;  
		for (i = 0; i < x_dim/2; i ++)  
		{  
			*pu1 = *psu ;  
			*(pu1+1) = *psu;  
			*pu2 = *psu ;  
			*(pu2+1) = *psu;//将输入的一个像素的U以田字格形式赋给输出中的4个像素点  
  
			*pv1 = *psv ;  
			*(pv1+1) = *psv;  
			*pv2 = *psv ;  
			*(pv2+1) = *psv;  
              
			psu ++;  
			psv ++;  
			pu1 += 2;  
			pu2 += 2;  
			pv1 += 2;  
			pv2 += 2;  
		}  
	}  
	  
  	// convert YUV to RGB  
	for (j = 0; j < size; j++)  
	{  
		g = b + 1;  
		r = b + 2;  
		psr = *y+YUVRGB14075[*v];  
		if(psr > 255)  
			psr = 255;  
		if(psr <0)  
			psr = 0;  
		*r = (unsigned char)psr;  
		psg = *y-YUVRGB034455[*u]-YUVRGB07169[*v];  
		if(psg > 255)  
			psg = 255;  
		if(psg <0)  
			psg = 0;  
		*g = (unsigned char)psg;  
		psb = *y+YUVRGB1779[*u];  
		if(psb > 255)  
			psb = 255;  
		if(psb <0)  
			psb = 0;  
		*b = (unsigned char)psb;  
		b += 3;  
		y ++;  
		u ++;  
		v ++;  
	}  
	/*unsigned char 的数据范围是0--255，如果公式右边的计算结果越界，产生的图片就会发生错误。 
         在这里设置了三个中间变量,先对公式的结果进行判断，再进行数据赋值*/  
  
	free(u_buffer);  
	free(v_buffer);  
	//每一个malloc对应一个free  
	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++) YUVRGB034455[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);  
}  
//部分查找表法，将公式简化,提高运行效率  

实验结果

左图为原始的YUV文件，右图为经过yuv->rgb->yuv两重变换之后得到的YUV文件，经对比变换之后的图片与原文件视觉上没有太大差别。

示例1：

示例2：

示例3：

示例4：