精华内容
下载资源
问答
  • 在图像处理和计算机视觉中,基于彩色空间有许多的应用,本实验主要涉及基于HLS模型的皮肤检测和红眼检测,测试图片如下: 在OpenCV中,将RGB图像转换到HLS空间的效果如下: 在大量的研究实验工作后,(S>=50...

    在图像处理和计算机视觉中,基于彩色空间有许多的应用,本实验主要涉及基于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;
    		}
    }

    展开全文
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...

    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=R0.299+G0.587+B0.114 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/255R' = R/255

    G=G/255G' = G/255

    B=B/255B' = B/255

    Cmax=max(R,G,B)Cmax = max(R', G', B')

    Cmin=min(R,G,B)Cmin = min(R', G', B')

    =CmaxCmin\triangle = Cmax - Cmin

    色调的计算:

    饱和度的计算:

    亮度的计算:

    L=(Cmax+Cmin)/2L = (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值;...2.彩色空间转换的转换公式及分析 (1)由RGB转换为YUV公式:Y=0.2990

    一、实验原理

    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 ...

    一、本实验涉及到的基本原理

    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.最后,最重要的还是要细心!因为粗心犯了很多错误,作业写得很艰难。

    展开全文
  • 而RGB是按像素存储,即存储每个像素的R,G,B,需要3倍的存储空间。 图片链接 带参数的主函数传递参数的方式 在Visual studio的开发环境下,打开项目属性,在配置属性->调试中更改工作目录和命令参数,...
  • (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 归一 化后的色差信号为: U=-0.1684R -0.3316G+0.5B V=0.5R -0.4187G -0.0813B ...
  • 与设备无关的彩色空间

    千次阅读 2019-07-18 18:22:29
    CIE Lab 彩色空间:是在色彩科学、创造艺术和诸如打印机、摄像机和扫描仪之类的彩色设备的设计中广泛应用彩色空间 优点: Lab 更清楚的分离了彩色信息(用 a值和b值表示)和灰度信息(完全用L值表示) 设计了 La*b...
  • Task03 彩色空间互转

    2020-04-25 22:45:20
    图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • OpenCV—彩色空间互转

    2020-04-25 21:47:04
    图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • Datawhale干货作者:姚童,Datawhale优秀学习者图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 空间中确定不同波长光照的物体的像平面,按照同一物理尺寸重建不同色光的像光场是应用研究中必须解决的问题。提出一种不必知道光学系统的透镜参数而通过实验确定不同色光像平面的简易方法,并基于数字全息重建像焦...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  •  本质上,彩色模型是对坐标系统和子空间的阐述,位于系统的每种颜色都用单个点表示。从应用的角度来看,人们提出的众多色彩模型可以分为两类: 【1】面向诸如“彩色显示器”“彩色打印机”之类的硬设备; 【2】...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 图像彩色空间互转在图像处理中应用非常广泛,而且很多算法只对灰度图有效;另外,相比RGB,其他颜色空间(比如HSV、HSI)更具可分离性和可操作性,所以很多图像算法需要将图像从RGB转为其他颜色空间,所以图像彩色互转...
  • 基于HSV彩色空间与直方图信息的植物叶脉FFCM算法提取[J/OL]. 计算机应用研究,2018,(08):1-7. (2017-07-21)[2017-10-09]. http://kns.cnki.net/kcms/detail/51.1196.TP.20170721.1354.084.html Abstract: 彩色空间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 410
精华内容 164
关键字:

彩色空间应用