在图像处理和计算机视觉中，基于彩色空间有许多的应用，本实验主要涉及基于HLS模型的皮肤检测和红眼检测，测试图片如下：


在OpenCV中，将RGB图像转换到HLS空间的效果如下：


在大量的研究实验工作后,(S>=50)  && (L_S_ratio>0.5) && (L_S_ratio<3.0) && ((H<=14) || (H>=165))的模型较为可靠，下面分别是测试代码和效果：

void skinDetect(Mat &hls_image, Mat &bina_image){
	CV_Assert(hls_image.channels() == 3 && bina_image.type() == CV_8UC1);
	for (int row = 0; row < hls_image.rows; ++row)
		for (int col = 0; col < hls_image.cols; ++col)
		{
			uchar H = hls_image.at<Vec3b>(row, col)[0];
			uchar L = hls_image.at<Vec3b>(row, col)[1];
			uchar S = hls_image.at<Vec3b>(row, col)[2];
			double LS_ratio = ((double)L) / ((double)S);
			bina_image.at<uchar>(row, col) = ((S >= 50) && (LS_ratio>0.5) &&
				(LS_ratio < 3.0) && ((H <= 14) || (H>165)))? 255:0;
		}
	
}


在红眼检测中，(L>=64) && (S>=100) && (L_S_ration>0.5) && (L_S_ratio<1.5) && ((H<=7) || (H>=162))的模型较为可靠。

void redEyeDetect(Mat &hls_image, Mat &bina_image){
	CV_Assert(hls_image.channels() == 3 && bina_image.type() == CV_8UC1);
	for (int row = 0; row < hls_image.rows; ++row)
		for (int col = 0; col < hls_image.cols; ++col)
		{
			uchar H = hls_image.at<Vec3b>(row, col)[0];
			uchar L = hls_image.at<Vec3b>(row, col)[1];
			uchar S = hls_image.at<Vec3b>(row, col)[2];
			double LS_ratio = ((double)L) / ((double)S);
			bina_image.at<uchar>(row, col) = ((L >= 64) && (S>=100) &&
				(LS_ratio >0.5) && (LS_ratio<1.5) && ((H <= 7) || (H>162)))? 255:0;
		}
}

Datawhale 计算机视觉基础-图像处理（上）-Task03 彩色空间互转
3.1 简介
图像彩色空间互转在图像处理中应用非常广泛，而且很多算法只对灰度图有效；另外，相比RGB，其他颜色空间(比如HSV、HSI)更具可分离性和可操作性，所以很多图像算法需要将图像从RGB转为其他颜色空间，所以图像彩色互转是十分重要和关键的。
3.2 学习目标

了解相关颜色空间的基础知识
理解彩色空间互转的理论
掌握OpenCV框架下颜色空间互转API的使用

3.3 内容介绍
1.相关颜色空间的原理介绍
2.颜色空间互转理论的介绍
3.OpenCV代码实践
4.动手实践并打卡（读者完成）
3.4 算法理论介绍与资料推荐
3.4.1 RGB与灰度图互转
RGB（红绿蓝）是依据人眼识别的颜色定义出的空间，可表示大部分颜色。但在科学研究一般不采用RGB颜色空间，因为它的细节难以进行数字化的调整。它将色调，亮度，饱和度三个量放在一起表示，很难分开。它是最通用的面向硬件的彩色模型。该模型用于彩色监视器和一大类彩色视频摄像。
注：Opencv是BGR
RGB颜色空间 基于颜色的加法混色原理，从黑色不断叠加Red，Green，Blue的颜色，最终可以得到白色，如图：
    


将R、G、B三个通道作为笛卡尔坐标系中的X、Y、Z轴，就得到了一种对于颜色的空间描述，如图：
    


    


对于彩色图转灰度图，有一个很著名的心理学公式：
$Gray = R * 0.299 + G * 0.587 + B * 0.114$
3.4.2 RGB与HSV互转
HSV是一种将RGB色彩空间中的点在倒圆锥体中的表示方法。HSV即色调(Hue)、饱和度(Saturation)、亮度(Value)，又称HSB(B即Brightness)。
色调（Hue）
色调：色调是指物体反射的光线中以哪种波长占优势来决定的，不同波长产生不同颜色的感觉，色调是颜色色调的重要特征，它决定了颜色本质的根本特征。

色调不是指颜色的性质，而是对一幅绘画作品的整体颜色的概括评价。色调是指一幅作品色彩外观的基本倾向。在明度、纯度（饱和度）、色相这三个要素中，某种因素起主导作用，我们就称之为某种色调。一幅绘画作品虽然用了多种颜色，但总体有一种倾向，是偏蓝或偏红，是偏暖或偏冷等等。这种颜色上的倾向就是一副绘画的色调。
饱和度（Saturation）
饱和度可定义为彩度除以明度，与彩度同样表征彩色偏离同亮度灰色的程度。注意，与彩度完全不是同一个概念。但由于其和彩度决定的是出现在人眼里的同一个效果，所以才会出现视彩度与饱和度为同一概念的情况。

饱和度是指色彩的鲜艳程度，也称色彩的纯度。饱和度取决于该色中含色成分和消色成分（灰色）的比例。含色成分越大，饱和度越大；消色成分越大，饱和度越小。纯的颜色都是高度饱和的，如鲜红，鲜绿。混杂上白色，灰色或其他色调的颜色，是不饱和的颜色，如绛紫，粉红，黄褐等。完全不饱和的颜色根本没有色调，如黑白之间的各种灰色。
亮度（Lightness、Luminosity或Brightness）：
亮度指照射在景物或图像上光线的明暗程度。图像亮度增加时，就会显得耀眼或刺眼，亮度越小时，图像就会显得灰暗。


HSV颜色空间可以用一个圆锥空间模型来描述。圆锥的顶点处，V=0，H和S无定义，代表黑色。圆锥的顶面中心处V=max，S=0，H无定义，代表白色。

RGB颜色空间中，三种颜色分量的取值与所生成的颜色之间的联系并不直观。而HSV颜色空间，更类似于人类感觉颜色的方式，封装了关于颜色的信息：“这是什么颜色？深浅如何？明暗如何？
HSV模型
    


这个模型就是按色彩、深浅、明暗来描述的。
H是色彩；
S是深浅， S = 0时，只有灰度；
    


应用：可以用于偏光矫正、去除阴影、图像分割等
RGB2HSV
    


或
    


HSV2RGB
    


3.4.3 BGR2HSL
HSL 类似于 HSV。对于一些人，HSL 更好的反映了“饱和度”和“亮度”作为两个独立参数的直觉观念，但是对于另一些人，它的饱和度定义是错误的，因为非常柔和的几乎白色的颜色在 HSL 可以被定义为是完全饱和的。对于 HSV 还是 HSL 更适合于人类用户界面是有争议的。
$R' = R/255$
$G' = G/255$
$B' = B/255$
$Cmax = max(R', G', B')$
$Cmin = min(R', G', B')$
$\triangle = Cmax - Cmin$
色调的计算：
    


饱和度的计算：
    


亮度的计算：
$L = (Cmax + Cmin) / 2$
3.5 基于OpenCV的实现

工具：OpenCV3.1.0+VS2013
平台：WIN10

函数原型（c++）

void cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0)


src: 输入图像
dst: 输出图像
code: 颜色空间转换标识符

OpenCV2的CV_前缀宏命名规范被OpenCV3中的COLOR_式的宏命名前缀取代
注意RGB色彩空间默认通道顺序为BGR
具体可以参考： enum cv::ColorConversionCode部分


dstCn: 目标图像的通道数，该参数为0时，目标图像根据源图像的通道数和具体操作自动决定

实现示例（c++)
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
// main
int main( int argc, char** argv )
{
    // Load image
    cv::Mat srcImage = cv::imread("1.jpg"), dstImage;
    
    // RGB2GHSV
    cv::cvtColor(srcImage, dstImage, cv::COLOR_BGR2hHSV);
    imshow("Lab Space", dstImage);
    
    //RGB2GRAY
    cv::cvtColor(srcImage, dstImage, cv::COLOR_BGR2GRAY);
    imshow("Gray Scale", dstImage);
    
    cv::waitKey();
    
    return 0;
}

进阶实现(根据原理自己实现)

1.RGB2GRAY

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
 
cv::Mat RGB2GRAY(cv::Mat src, bool accelerate=false){
	CV_Assert(src.channels()==3);
	cv::Mat dst = cv::Mat::zeros(src.size(), CV_8UC1);
	cv::Vec3b rgb;
	int r = src.rows;
	int c = src.cols;
	
	  for (int i = 0; i < r; ++i){
		 for (int j = 0; j < c; ++j){
			rgb = src.at<cv::Vec3b>(i, j);
			uchar B = rgb[0]; uchar G = rgb[1]; uchar R = rgb[2];
			if (accelerate = false){
				dst.at<uchar>(i, j) = R*0.299 + G*0.587 + B*0.114;   //原式
			}
			else{
				dst.at<uchar>(i, j) = (R * 4898 + G * 9618 + B * 1868) >> 14;  //优化
			}
		 }
	   }
	return dst;
}
 
int main(){
	cv::Mat src = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\lena.jpg");
 
	if (src.empty()){
		return -1;
	}
	cv::Mat dst,dst1;
 
	//opencv自带
	double t2 = (double)cv::getTickCount(); //测时间
	cv::cvtColor(src, dst1, CV_RGB2GRAY);
	t2 = (double)cv::getTickCount() - t2;
	double time2 = (t2 *1000.) / ((double)cv::getTickFrequency());
	std::cout << "Opencv_rgb2gray=" << time2 << " ms. " << std::endl << std::endl;
 
	//RGB2GRAY
	double t1 = (double)cv::getTickCount(); //测时间
	dst = RGB2GRAY(src, true);
	t1 = (double)cv::getTickCount() - t1;
	double time1 = (t1 *1000.) / ((double)cv::getTickFrequency());
	std::cout << "My_rgb2gray=" << time1 << " ms. " << std::endl << std::endl;
 
 
	cv::namedWindow("src", CV_WINDOW_NORMAL);
	imshow("src", src);
	cv::namedWindow("My_rgb2gray", CV_WINDOW_NORMAL);
	imshow("My_rgb2gray", dst);
	cv::namedWindow("Opencv_rgb2gray", CV_WINDOW_NORMAL);
	imshow("Opencv_rgb2gray", dst1);
	cv::waitKey(0);
	return 0;
 
}


2.RGB2HSV/HSV2RGB

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
using namespace cv;
 
 
Mat RGB2HSV(Mat src) {
	int row = src.rows;
	int col = src.cols;
	Mat dst(row, col, CV_32FC3);
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			float b = src.at<Vec3b>(i, j)[0] / 255.0;
			float g = src.at<Vec3b>(i, j)[1] / 255.0;
			float r = src.at<Vec3b>(i, j)[2] / 255.0;
			float minn = min(r, min(g, b));
			float maxx = max(r, max(g, b));
			dst.at<Vec3f>(i, j)[2] = maxx; //V
			float delta = maxx - minn;
			float h, s;
			if (maxx != 0) {
				s = delta / maxx;
			}
			else {
				s = 0;
			}
			if (r == maxx) {
				h = (g - b) / delta;
			}
			else if (g == maxx) {
				h = 2 + (b - r) / delta;
			}
			else if (b==maxx) {
				h = 4 + (r - g) / delta;
			}
			else{
				h = 0;
			}
			h *= 60;
			if (h < 0)
				h +=  360;
			dst.at<Vec3f>(i, j)[0] = h;
			dst.at<Vec3f>(i, j)[1] = s;
		}
	}
 
	return dst;
}
 
Mat HSV2RGB(Mat src) {
	int row = src.rows;
	int col = src.cols;
	Mat dst(row, col, CV_8UC3);
	float r, g, b, h, s, v;
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			h = src.at<Vec3f>(i, j)[0];
			s = src.at<Vec3f>(i, j)[1];
			v = src.at<Vec3f>(i, j)[2];
			if (s == 0) {
				r = g = b = v;
			}
			else {
				h /= 60;
				int offset = floor(h);
				float f = h - offset;
				float p = v * (1 - s);
				float q = v * (1 - s * f);
				float t = v * (1 - s * (1 - f));
				switch (offset)
				{
				case 0: r = v; g = t; b = p; break;
				case 1: r = q; g = v; b = p; break;
				case 2: r = p; g = v; b = t; break;
				case 3: r = p; g = q; b = v; break;
				case 4: r = t; g = p; b = v; break;
				case 5: r = v; g = p; b = q; break;
				default:
					break;
				}
			}
			dst.at<Vec3b>(i, j)[0] = int(b * 255);
			dst.at<Vec3b>(i, j)[1] = int(g * 255);
			dst.at<Vec3b>(i, j)[2] = int(r * 255);
		}
	}
	return dst;
}
 
 
 
 
int main(){
	cv::Mat src = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\lena.JPG");
 
	if (src.empty()){
		return -1;
	}
	cv::Mat dst, dst1, dst2;
 
	opencv自带/
	cv::cvtColor(src, dst1, CV_RGB2HSV); //RGB2HSV
 
	//RGB2HSV//
	dst = RGB2HSV(src); //RGB2HSV
	dst2 = HSV2RGB(dst); //HSV2BGR
 
	cv::namedWindow("src", CV_WINDOW_NORMAL);
	imshow("src", src);
	cv::namedWindow("My_RGB2HSV", CV_WINDOW_NORMAL);
	imshow("My_RGB2HSV", dst);
	cv::namedWindow("My_HSV2RGB", CV_WINDOW_NORMAL);
	imshow("My_HSV2RGB", dst2);
	cv::namedWindow("Opencv_RGB2HSV", CV_WINDOW_NORMAL);
	imshow("Opencv_RGB2HSV", dst1);
	cv::waitKey(0);
	return 0;
 
}

效果


3.6 HSV色彩空间的应用
一般对颜色空间的图像进行有效处理都是在HSV空间进行的，然后对于基本色中对应的HSV分量需要给定一个严格的范围，下面是通过实验计算的模糊范围（准确的范围在网上都没有给出）。
H:  0 — 180
S:  0 — 255
V:  0 — 255
此处把部分红色归为紫色范围：



参考：https://blog.csdn.net/taily_duan/article/details/51506776
    


import cv2
import numpy as np


def extract_red(image):
    """
    通过红色过滤提取出指针
    """
    red_lower1 = np.array([0, 43, 46])
    red_upper1 = np.array([10, 255, 255])
    red_lower2 = np.array([156, 43, 46])
    red_upper2 = np.array([180, 255, 255])
    dst = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
    mask1 = cv2.inRange(dst, lowerb=red_lower1, upperb=red_upper1)
    mask2 = cv2.inRange(dst, lowerb=red_lower2, upperb=red_upper2)
    mask = cv2.add(mask1, mask2)
    return mask


src = cv2.imread('image/1_0181.jpg')
cv2.imshow('src', src)
mask = extract_red(src)
cv2.imshow('extract_red', mask)
cv2.imwrite('extract_red.jpg', mask)
cv2.waitKey(0)

    


  ---
### 相关技术文档、博客、书籍、项目推荐
opencv文档：https://docs.opencv.org/3.1.0/de/d25/imgproc_color_conversions.html  
博客：https://blog.csdn.net/weixin_40647819/article/details/92596879  
     https://blog.csdn.net/weixin_40647819/article/details/92660320  
python版本：https://www.kancloud.cn/aollo/aolloopencv/263731  
3.7 总结
该部分主要讲解彩色空间互转，彩色空间互转是传统图像算法的一个关键技术，学习颜色转换有助于我们理解图像的色域，从而为我们从事CV相关工程技术和科学研究提供一些基础、灵感和思路。

Task03 彩色空间互转 END.
— By: 小武

博客：https://blog.csdn.net/weixin_40647819

关于Datawhale：

Datawhale是一个专注于数据科学与AI领域的开源组织，汇集了众多领域院校和知名企业的优秀学习者，聚合了一群有开源精神和探索精神的团队成员。Datawhale以“for the learner，和学习者一起成长”为愿景，鼓励真实地展现自我、开放包容、互信互助、敢于试错和勇于担当。同时Datawhale 用开源的理念去探索开源内容、开源学习和开源方案，赋能人才培养，助力人才成长，建立起人与人，人与知识，人与企业和人与未来的联结。

一、实验原理
1.图像文件的存储格式
图像在文件中均以数据流的形式存储，RGB格式图像在文件中按扫描行顺序，依次存储每一像素的B、G、R值；而YUV格式图像在文件中各分量独立保存，先存储一帧图像中所有像素的Y分量值，按扫描行顺序排列，紧接着再存储一帧图像所有像素的U分量值，最后是一帧图像所有像素的V分量值。
2.彩色空间转换的转换公式及分析
（1）由RGB转换为YUV公式：Y＝0.2990R+0.5870G+0.1140B   U＝-0.1684R-0.3316G+0.5B    V＝0.5R-0.4187G-0.0813B
其中，为了使色差信号U、V的动态范围控制在0.5之间，对其做归一化处理，将色差信号R-Y、B-Y分别乘以压缩系数。
（2）相应地可计算出由YUV转换为RGB公式：R=Y+1.4020V   G=Y-0.3440U-0.7140V   B=Y+1.7720U
3.码电平分配及数字表达式
(1)亮电平信号量化后码电平分配
在对分量信号进行8比特均匀量化时，共分为256个等间隔的量化级。为了防止信号变动造成过载，在256级上端留20级，下端留16级作为信号超越动态范围的保护带。
(2)色差信号量化后码电平分配
色差信号经过归一化处理后，动态范围为-0.5－0.5，让色差零电平对应码电平128，色差信号总共占225个量化级。在256级上端留15级，下端留16级作为信号超越动态范围的保护带。
4.色度格式
4:2:0格式是指色差信号U、V的取样频率为亮度信号取样频率的四分之一，在水平方向和垂直方向上的取样点数均为Y的一半。
 
二、实验流程分析
1.创建工程、头文件、2个源程序文件;
2.在工程-设置-调试中设置程序文件所在的工作目录和主函数所需的命令参数，读入待转换的文件名、输出文件名、图像的宽、高尺寸；

 
3.在主程序中设置初始化参数：定义输入、输出文件指针，定义宽、高变量并赋值，定义四个缓冲区指针：rgbBuf、yBuf、uBuf、vBuf；
4.用fopen函数打开文件，用malloc函数为四个缓冲区指针分配相应大小的动态内存，用fread函数将yuvFile的数据依次读入yBuf、uBuf、vBuf；
5.调用自定义的YUV2RGB函数，在yuv2rgb.cpp中定义YUV2RGB函数，先对U、V分量进行上采样，再调用查找表计算相应像素的R、G、B值，输出到rgbBuf；
6.在主程序中用fwrite函数将rgbBuf的数据写入rgbFile；
7.释放缓冲区，关闭文件。
 
三、关键代码及分析
yuv2rgb.h:
头文件里包含所用函数的申明：
#ifndef YUV2RGB_H_
#define YUV2RGB_H_

int YUV2RGB(int x_dim,int y_dim,void *y_in,void *u_in,void *v_in,void *rgb_out,int flip);

void InitLookupTable();

#endif

main.cpp:
1.为四个缓冲区指针分配相应大小的动态内存:因为YUV色度格式按4:2:0采样，所以uBuf、vBuf大小为YBuf的四分之一，即(frameWidth * frameHeight) / 4)。
rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);
 yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
 uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
 vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);

2.用fread函数将yuvFile的数据依次读入yBuf、uBuf、vBuf，文件指针yuvFile随着数据块的读出自动移位到所操作的位置；调用YUV2RGB函数后，再将rgbBuf的数据写入rgbFile。
while (fread(yBuf,1,frameWidth*frameHeight,yuvFile))
 {
  while (fread(uBuf,1,(frameWidth*frameHeight)/4,yuvFile))
  {
   while (fread(vBuf,1,(frameWidth*frameHeight)/4,yuvFile))
  {
  if(YUV2RGB(frameWidth, frameHeight,  yBuf, uBuf, vBuf,rgbBuf))
  {
   printf("error");
   return 0;
  }

fwrite(rgbBuf, 1, frameWidth * frameHeight*3, rgbFile);

}
  }
 }

yuv2rgb.cpp:
#include "stdlib.h"
#include "yuv2rgb.h"

static float YUVRGB1402[256],YUVRGB1772[256];
static float YUVRGB0344[256],YUVRGB0714[256];定义查找表所用公式系数的浮点型数组，数组大小为量化级范围256


int YUV2RGB (int x_dim,int y_dim,void *y_in,void *u_in,void *v_in,void *rgb_out)函数的定义，参数包括宽、高、四个缓冲区指针
{

 static int init_done = 0;/定义调用查找表时的控制变量，初始化为0

 long i, j, size;///定义循环变量和尺寸变量
 float r_tmp,g_tmp,b_tmp;///为防止r、g、b值溢出，定义浮点型中间变量来限定溢出值
 unsigned char *r, *g, *b;
 unsigned char *y, *u, *v;

 unsigned char *y_buffer, *u_buffer, *v_buffer,*rgb_buffer;//定义buffer指针
 unsigned char *add_u_buffer, *add_v_buffer;///定义上采样后的U、V缓冲区指针
 unsigned char *pu1, *pu2, *pv1, *pv2, *psu, *psv;///定义上采样时缓冲区的移位指针
 

 if (init_done == 0)
 {
  InitLookupTable();///调用查找表，计算各量化级的公式系数
  init_done = 1;
 }


 if ((x_dim % 2) || (y_dim % 2)) return 1;//判断图像宽、高是否为偶数，以确定上采样格式
 size = x_dim * y_dim;尺寸变量赋值


 y_buffer = (unsigned char *)y_in;
 u_buffer = (unsigned char *)u_in;
 v_buffer = (unsigned char *)v_in;
 rgb_buffer=(unsigned char *)rgb_out;将YUV2RGB函数的void型形参转换成无符号字符型指针
 add_u_buffer=(unsigned char *)malloc(size);
 add_v_buffer=(unsigned char *)malloc(size);//为上采样后的U、V缓冲区指针分配动态内存

 b = rgb_buffer;
 y = y_buffer;
 u = add_u_buffer;
 v = add_v_buffer;

 for (j = 0; j < y_dim/2; j ++)//j分量控制行数循环
 {
  psu = u_buffer + j * x_dim / 2;psu指针指向原始u_buffer的起始位置，通过变量j控制其移位，每操作完一行，psu加x_dim/2指向u_buffer的下一行
  psv = v_buffer + j * x_dim / 2;v分量缓冲区的相应移位指针操作同u
  pu1 = add_u_buffer + 2 * j * x_dim;pu1指针指向上采样后add_u_buffer的偶数行起始位，每操作完一行，pu1加x_dim指向add_u_buffer的下一偶数行
  pu2 = add_u_buffer + (2 * j + 1) * x_dim;//pu2指针指向上采样后add_u_buffer的奇数行起始位，每操作完一行，pu2加x_dim指向add_u_buffer的下一奇数行
  pv1 = add_v_buffer + 2 * j * x_dim;
  pv2 = add_v_buffer + (2 * j + 1) * x_dim;
  for (i = 0; i < x_dim/2; i ++)//i分量控制列数循环
  {
   *pu1=*psu;
   *(pu1+1)=*psu;
   *pu2=*psu; 
   *(pu2+1)=*psu;///将u_buffer中的u值分别赋给add_u_buffer中相应邻域的4个像素
   *pv1=*psv;
   *(pv1+1)=*psv;
   *pv2=*psv; 
   *(pv2+1)=*psv;
   psu ++;///每操作一次psu向后移一位
   psv ++;
   pu1 += 2;
   pu2 += 2;//每操作一次pu1、pu2向后移2位
   pv1 += 2;
   pv2 += 2;
  }
 }

 for (i = 0; i < size; i++)将上采样后缓冲区的Y、U、V值计算得到相应像素的R、G、B值
  {
   g = b + 1;
   r = b + 2;RGB文件中图像每一像素按B、G、R依次排列
   r_tmp=  (*y)+YUVRGB1402[*v];/为中间变量赋值
   *r=(r_tmp>255?255:(r_tmp<0?0:(unsigned char)r_tmp));//若计算的r值大于255（即溢出），将相应r值赋值为255；若计算的r值小于0，将相应r值赋值为0；
   g_tmp=(*y)-YUVRGB0344[*u]-YUVRGB0714[*v];
   *g=(g_tmp>255?255:(g_tmp<0?0:(unsigned char)g_tmp));
   b_tmp=(*y)+YUVRGB1772[*u];
   *b=(b_tmp>255?255:(b_tmp<0?0:(unsigned char)b_tmp));
   b += 3;
   y ++;
   u ++;
   v ++;
  }
 if(add_u_buffer!=NULL)
 {
 free(add_u_buffer);
 }
 if(add_v_buffer!=NULL)
 {
 free(add_v_buffer);
 }

释放缓冲区add_u_buffer、add_v_buffer，为避免重复释放，先进行判断

 return 0;
}


void InitLookupTable()//定义查找表函数
{
 int i;

 for (i = 0; i < 256; i++) YUVRGB1402[i] = (float)1.402 * (i-128);
 for (i = 0; i < 256; i++) YUVRGB0344[i] = (float)0.344 * (i-128);
 for (i = 0; i < 256; i++) YUVRGB0714[i] = (float)0.714 * (i-128);
 for (i = 0; i < 256; i++) YUVRGB1772[i] = (float)1.772 * (i-128);//计算各量化级的公式系数,由于在RGB2YUV程序中，为了使色差零电平对应128，U、V值均加了128，所以这里要相应地减去128
}



 
四、实验结果分析
将down.rgb文件通过RGB2YUV程序后得到down.yuv文件，再将down.yuv通过YUV2RGB程序转换为test.rgb文件，再通过RGB2YUV程序得到test.yuv。将down.yuv和test.yuv文件用YUVplayer查看，图像如下：



 
可以看到，两张YUV图像虽然存在一定的色度变化，但是用肉眼难以分辨出差异，图像转换失真度小。
若不限定溢出，直接将浮点型中间变量类型转换，转换后的图像会出现噪点和颜色失真的像素点，如下图：
*r=(unsigned char )r_tmp;

*g=(unsigned char )g_tmp;

*b=(unsigned char )b_tmp;


 
另外给出3个YUV图像文件与其通过YUV2RGB和RGB2YUV转换后得到的test.yuv的对比：



可以看到，原图与转换后的图像基本相同，以此证明编写的YUV2RGB程序是正确的。
 
五、实验结论：
RGB图像文件与YUV图像文件可以进行彩色空间互换，虽然在下采样过程中，通过邻域像素U、V值取平均的方法会丢失一部分数据，产生色度失真，且无法在后续恢复原始色度值，但是这种失真度较小，人眼难以分辨。
 
 
 
 
 
 
 
 

一、本实验涉及到的基本原理
1．彩色空间转换的基本思想及转换公式
（1）YUV与RGB空间的相互转换（为了使色差信号的动态范围控制在0.5之间，需要进行归一化）：
Y＝0.2990R+0.5870G+0.1140B
U＝-0.1684R-0.3316G+0.5B
V＝0.5R-0.4187G-0.0813B
（2）RGB与YUV空间的相互转换
R=Y+1.14075(V-128)
G=Y-0.7169(V-128)-0.3455(U-128)
B=Y+1.779(U-128)
（3）色度格式
4:2:0格式是指色差信号U，V的取样频率为亮度信号取样频率的四分之一，在水平方向和垂直方向上的取样点数均为Y的一半。

（4）YUV与RGB存储方式
YUV文件采用平面(Planer)格式，使用三个数组分开存放每一帧的Y、U、V三个分量。

RGB文件采用打包(Packed)格式，将每一帧的每个像素点依照B、G、R的顺序存放在同一个数组中。
二、YUVtoRGB文件转换流程分析
1. 程序初始化（打开两个文件、定义变量和缓冲区 程序初始化（打开两个文件、定义变量和缓冲区等）
2. 读 读取 取YUV 文件，抽取YUV数据写入缓冲区 数据写入缓冲区
3.  调用YUV2RGB 的函数实现YUV 到RGB数据的转 数据的转换
4.  写RGB文件 文件
5. 程序收尾工作（关闭文件，释放缓冲区）

三、关键代码及其分析
1.YUVtoRGB.h

#ifndef YUV2RGB_H_
#define YUV2RGB_H_

int YUVtoRGB (int x_dim, int y_dim, void *bmp, void *y_out, void *u_out, void *v_out, int flip);

void InitLookupTable();

#endif
2.main.cpp


#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include "YUVtoRGB.h"									//自己定义的头文件

#define u_int8_t	unsigned __int8							//无符号8位整形
#define u_int		unsigned __int32						//无符号4字节整形
#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 = FALSE;				/* --flip */			//这里要改成FALSE！RGB转YUV的时候是TRUE，这里刚好相反！！！

	unsigned int i;

	/* internal variables */
	char* rgbFileName = NULL;							//定义文件名
	char* yuvFileName = NULL;
	FILE* rgbFile = NULL;								//定义文件指针
	FILE* yuvFile = NULL;
	u_int8_t* rgbBuf = NULL;							//定义RGB、Y、U、V buffer
	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];								//YUV文件名数组
	rgbFileName = argv[2];								//RGB文件名数组
	frameWidth = atoi(argv[3]);								
	frameHeight = atoi(argv[4]);							
	
	/* open the YUV file */
	yuvFile = fopen(yuvFileName, "rb");						//打开YUV文件，同时判断是否能够打开
	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");						//打开或创建RGB文件，判断是否成功
	if (rgbFile == NULL)									
	{
		printf("cannot find rgb file\n");
		exit(1);
	}
	else
	{
		printf("The output rgb file is %s\n", rgbFileName);
	}
	
	
	/* get the output buffers for a frame */
	yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);				//为YUV文件的数据开辟空间
	uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
	vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
	
	/* get an input buffer for a frame */
	rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);			//为RGB文件的数据开辟空间
	

	if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)		//判断空间是否预留够
	{
		printf("no enough memory\n");
		exit(1);
	}

	while (fread(yBuf,1,frameWidth*frameHeight,yuvFile)				//判断一帧的yuv分量是不是都读完了
			&&fread(uBuf,1,frameWidth*frameHeight/4,yuvFile)
			&&fread(vBuf,1,frameWidth*frameHeight/4,yuvFile)) 
	{
		if(YUVtoRGB(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
		{
			printf("error");
			return 0;
		}

		fwrite(rgbBuf,1,frameWidth*frameHeight*3,rgbFile);			//写入rgb数据

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

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

	/* cleanup */// 收尾工作
	
	if(rgbFile!=NULL)			//文件一定要记得关闭！
		fclose(rgbFile);
    if(yuvFile!=NULL)   
		fclose(yuvFile);
 
	if(rgbBuf!=NULL)			//开辟了的空间一定要记得释放掉！
		free(rgbBuf);
    if(yBuf!=NULL)   
		free(yBuf);
    if(uBuf!=NULL)   
		free(uBuf);
    if(vBuf!=NULL)   
		free(vBuf);
	system("pause");
	return(0);
}
3.YUVtoRGB.cpp


#include "stdlib.h"
#include "YUVtoRGB.h"

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

int YUVtoRGB (int x_dim, int y_dim, void *rgb_out, void *y_in, void *u_in, void *v_in, int flip)
{
	static int init_done = 0;

	long i, j, size;
	unsigned char *r, *g, *b;									
	unsigned char *y, *u, *v;									
	float rr, gg, bb;								//防止数值溢出，设置的中间变量
	unsigned char *pu, *pv, *psu1, *psu2, *psv1, *psv2;			
	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;
	}

	// 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;					//输入YUV
	u_buffer  = (unsigned char *)u_in;
	v_buffer  = (unsigned char *)v_in;
	sub_u_buf = (unsigned char *)malloc(x_dim * y_dim);			//作为UV的中转量，存放上采样以后的值
    sub_v_buf = (unsigned char *)malloc(x_dim * y_dim);
	
	b = (unsigned char *)rgb_out;								
	y = y_buffer;
	u = sub_u_buf;
	v = sub_v_buf;

	for (j = 0; j < y_dim/2; j ++)								
	{
		pu = u_buffer + j*x_dim/2;					//定位U分量的位置，此时pu指向的是4:2:0格式时U分量位置
		psu1 = sub_u_buf + 2*j*x_dim;					//这个指针指向的是转成4:4:4格式后的四个相邻像素里左上角的像素的U分量的位置
		psu2 = sub_u_buf + (2*j+1)*x_dim;				//这个指针指向的是转成4:4:4格式后的四个相邻像素里左下角的像素的U分量的位置

		pv = v_buffer + j*x_dim/2;					//同上
		psv1 = sub_v_buf + 2*j*x_dim;
		psv2 = sub_v_buf + (2*j+1)*x_dim;
		
		/*对U、V分量数值进行操作，把原本的4:2:0格式填补成4:4:4格式
		原来相邻四个像素点共用一个U和V，现在把那个点的U和V的值复制给相邻的三个点*/
		for (i = 0; i < x_dim/2; i ++)							
		{
			*psu1=*(psu1+1)
				=*psu2=*(psu2+1)=*pu;
			*psv1=*(psv1+1)
				=*psv2=*(psv2+1)=*pv;

			pu++;
			psu1+=2;psu2+=2;
			
			pv++;
			psv1+=2;psv2+=2;
		}
	}

	// convert RGB to YUV
	if (!flip)													
	{
		for (j = 0; j < y_dim; j ++)						//把YUV(4:4:4格式)转成RGB
		{
			for (i = 0; i < x_dim; i ++) 
			{
				g = b + 1;						//RGB图像是按B、G、R的顺序存储的
				r = b + 2;
				//*r = *y + YUVRGB14075[*v];
				//*g = *y - YUVRGB03455[*u] - YUVRGB07169[*v];
				//*b = *y + YUVRGB17790[*u];
				
				rr = *y + YUVRGB14075[*v];				//按公式把YUV转成RGB
				gg = *y - YUVRGB03455[*u] - YUVRGB07169[*v];
				bb = *y + YUVRGB17790[*u];
				//R= Y + 1.4075(V−128)
				//G= Y − 0.3455(U−128) − 0.7169(V−128)
				//B= Y + 1.779 (U−128)
				*r = (unsigned char)(rr<0 ? 0 : rr>255 ? 255 : rr);	//防止变换后色彩溢出0~255
                		*g = (unsigned char)(gg<0 ? 0 : gg>255 ? 255 : gg);	//如果变换后小于0 则取0 大于255 则取255
                		*b = (unsigned char)(bb<0 ? 0 : bb>255 ? 255 : bb);	//否则取变换后的值
				
				b += 3;						//RGB图像将每一帧的每个像素点依照B、G、R的顺序存放在同一个数组中。
				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++) YUVRGB17790[i] = (float)1.7790 * (i-128);
}

四、实验结果及分析
1.down

中间的是原图，右边是因为未考虑变换后数据的值可能会大于256或者小于0，因而未对RGB的值的大小进行判断，导致数据溢出，出现的红点。
经过定义中间变量rr、gg、bb，并对他们的值进行判断，大于256的赋值为256，小于0的赋值为0，这样处理之后，得到最左边的图，可以看到和原图基本上没有差异。
2.akiyo




3.foreman


五、总结
1.我觉得最艰难的部分其实是看懂老师给的RGB转YUV的思路，因为太久没有接触编程了，看到指针、函数什么的就非常烦躁…因为以前学C语言的时候就觉得很难，上课之前也没有好好复习C语言的知识。
而且对图像的数据存储方式的了解也非常片面，虽然老师讲了很久RGB和YUV的数据的存储方式，但是没有了解得很透彻，还是在写程序的时候才慢慢悟出来到底是怎么存储的。
上课的时候看到老师给的程序非常头大，不知道从何下手，非常不愿意去看，有很强的抵触情绪。这也导致我一拖再拖，最后关头才写完这次的实验。
以后还是要改正这种思想，应该静下心来整理老师的思路，有不懂的地方问同学，还可以看已经写完了的大神们的总结，这些对我来说帮助是非常大的。
2.关于数据溢出部分的处理，扪心自问，我自己肯定是想不到，是看了同学的博客才意识到，这里可能会有问题出现，也学习到了怎么处理类似的问题。
3.最后，最重要的还是要细心！因为粗心犯了很多错误，作业写得很艰难。