计算机视觉基础——图像处理（彩色空间互转）cpp+python

最新推荐文章于 2022-05-10 22:25:32 发布

浩波的笔记

最新推荐文章于 2022-05-10 22:25:32 发布

阅读量1k

点赞数

分类专栏：图像机器/深度学习 python 文章标签： opencv 计算机视觉 cpp python

本文链接：https://blog.csdn.net/weixin_44023658/article/details/105758950

版权

机器/深度学习同时被 3 个专栏收录

56 篇文章 51 订阅

订阅专栏

python

31 篇文章 1 订阅

订阅专栏

图像

27 篇文章 10 订阅

订阅专栏

3.1 简介

图像彩色空间互转在图像处理中应用非常广泛，而且很多算法只对灰度图有效；另外，相比RGB，其他颜色空间(比如HSV、HSI)更具可分离性和可操作性，所以很多图像算法需要将图像从RGB转为其他颜色空间，所以图像彩色互转是十分重要和关键的。

3.2 学习目标

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

3.3 内容介绍

1.相关颜色空间的原理介绍

2.颜色空间互转理论的介绍

3.OpenCV代码实践

3.4 算法理论介绍与资料推荐

3.4.1 RGB与灰度图互转
RGB（红绿蓝）是依据人眼识别的颜色定义出的空间，可表示大部分颜色。但在科学研究一般不采用RGB颜色空间，因为它的细节难以进行数字化的调整。它将色调，亮度，饱和度三个量放在一起表示，很难分开。它是最通用的面向硬件的彩色模型。该模型用于彩色监视器和一大类彩色视频摄像。

RGB颜色空间基于颜色的加法混色原理，从黑色不断叠加Red，Green，Blue的颜色，最终可以得到白色，如图：
在这里插入图片描述
将R、G、B三个通道作为笛卡尔坐标系中的X、Y、Z轴，就得到了一种对于颜色的空间描述，如图

对于彩色图转灰度图，有一个很著名的心理学公式：

Gray = R * 0.299 + G * 0.587 + B * 0.114

直接计算因为是浮点型计算，所以复杂度较高，速度较低。所以我们考虑优化，可以将小数转为整数，除法变为移位，乘法也变为移位（整数计算比浮点型快，移位运算和加减法比乘除法快），但是这种方法也会带来一定的精度损失，我们可以根据实际情况选择需要保留的精度位数。下面给出不同精度(2-20位)的计算公式：

Grey = (R*1 + G*2 + B*1) >> 2
 
Grey= (R*2 + G*5 + B*1) >> 3
 
Grey= (R*4 + G*10 + B*2) >> 4
 
Grey = (R*9 + G*19 + B*4) >> 5
 
Grey = (R*19 + G*37 + B*8) >> 6
 
Grey= (R*38 + G*75 + B*15) >> 7
 
Grey= (R*76 + G*150 + B*30) >> 8
 
Grey = (R*153 + G*300 + B*59) >> 9
 
Grey = (R*306 + G*601 + B*117) >> 10
 
Grey = (R*612 + G*1202 + B*234) >> 11
 
Grey = (R*1224 + G*2405 + B*467) >> 12
 
Grey= (R*2449 + G*4809 + B*934) >> 13
 
Grey= (R*4898 + G*9618 + B*1868) >> 14
 
Grey = (R*9797 + G*19235 + B*3736) >> 15
 
Grey = (R*19595 + G*38469 + B*7472) >> 16
 
Grey = (R*39190 + G*76939 + B*14943) >> 17
 
Grey = (R*78381 + G*153878 + B*29885) >> 18
 
Grey =(R*156762 + G*307757 + B*59769) >> 19
 
Grey= (R*313524 + G*615514 + B*119538) >> 20

3.4.2 RGB与HSV互转
HSV是一种将RGB色彩空间中的点在倒圆锥体中的表示方法。HSV即色相(Hue)、饱和度(Saturation)、明度(Value)，又称HSB(B即Brightness)。色相是色彩的基本属性，就是平常说的颜色的名称，如红色、黄色等。饱和度（S）是指色彩的纯度，越高色彩越纯，低则逐渐变灰，取0-100%的数值。明度（V），取0-max(计算机中HSV取值范围和存储的长度有关)。HSV颜色空间可以用一个圆锥空间模型来描述。圆锥的顶点处，V=0，H和S无定义，代表黑色。圆锥的顶面中心处V=max，S=0，H无定义，代表白色。

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

HSV模型
在这里插入图片描述
这个模型就是按色彩、深浅、明暗来描述的。

H是色彩；

S是深浅， S = 0时，只有灰度；

V是明暗，表示色彩的明亮程度，但与光强无直接联系。
在这里插入图片描述
应用：可以用于偏光矫正、去除阴影、图像分割等

1.RGB2HSV
在这里插入图片描述
或

2.HSV2RGB

3.5 基于OpenCV的实现

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

实现示例（python)
使用工具Python3.5
使用包cv2，numpy
涉及函数cv2.cvtColor(),cv2.inRange()

1.转换颜色空间

在 OpenCV 中有 超过150 种进行颜色空间转换的方法。但是你以后就会发现我们经常用到的也就两种：BGR↔Gray 和 BGR↔HSV。
我们用到的函数是cv2.cvtColor(input_imageﬂag)，其中ﬂag就是转换类型。
对于BGR↔Gray的转换，我们使用的ﬂag就是cv2.COLOR_BGR2GRAY。
同样对于BGR↔HSV的转换我们用的ﬂag就是cv2.COLOR_BGR2HSV。
你可以下的命令得到所有可用的 ﬂag。

import cv2 
flags=[i for in dir(cv2) if i startswith('COLOR_')] 
print (flags)

在 OpenCV 的 HSV 格式中，H（色彩/色度）的取值范围是 [0，179]， S（饱和度）的取值范围 [0，255]，V（亮度）的取值范围 [0，255]。但是不同的软件使用的值可能不同。所以当你拿 OpenCV 的 HSV 值与其他软件的 HSV 值对比时，一定要记得归一化。

2.物体跟踪
现在我们知怎样将一幅图像从 BGR 换到 HSV 了，我们可以利用一点来提取带有某个特定色的物体。在 HSV 颜色空间中要比在 BGR 空间中更容易表示一个特定颜色。在我们的程序中，我们提取的是一个蓝色的物体。下就是就是我们做的几步：
• 从视频中获取每一帧图像
• 将图像换到 HSV 空间
• 设置 HSV 阀值到蓝色范围。
• 获取蓝色物体，当然我们可以做其他任何我们想做的事，比如：在蓝色物体周围画一个圈。

import cv2
import numpy as np

cap = cv2.VideoCapture(0)

while(1):
    #获取每一帧
    ret,frame = cap.read()
    #转换到HSV
    hsv = cv2.cvtColor(frame,cv2.COLOR_BGR2HSV)
    #设定蓝色的阀值
    lower_blue = np.array([110,50,50])
    upper_blue = np.array([130,255,255])
    #根据阀值构建掩模
    mask = cv2.inRange(hsv,lower_blue,upper_blue)
    #对原图和掩模进行位运算
    res = cv2.bitwise_and(frame,frame,mask=mask)
    #显示图像
    cv2.imshow('frame',frame)
    cv2.imshow('mask',mask)
    cv2.imshow('res',res)
    k = cv2.waitKey(5)&0xFF
    if k == 27:
        break
#关闭窗口
cv2.destroyAllWindows()

在这里插入图片描述噪点还是很多，后面会介绍如何消减噪音。
追踪物体轮廓，以后可以找物体中心，然后跟踪物体，可以在摄像头前挥挥手就可以画图等一些有趣的事。

3.怎样找到要跟踪对象的HSV值
函数cv2.cvtColor()可以用到这里，现在需要传入的参数是RGB的值而不是一幅图。例如要找到绿色的HSV值，只需在终端输入以下命令：

import cv2 import numpy as np
green=np.uint8([0,255,0]) hsv_green=cv2.cvtColor(green,cv2.COLOR_BGR2HSV)

error: /builddir/build/BUILD/opencv-2.4.6.1/ modules/imgproc/src/color.cpp:3541: 
error: (-215) (scn == 3 || scn == 4) && (depth == CV_8U || depth == CV_32F) in function cvtColor

#scn (the number of channels of the source),
#i.e. self.img.channels(), is neither 3 nor 4. 
# #depth (of the source), 
#i.e. self.img.depth(), is neither CV_8U nor CV_32F.
# 所以不能用 [0,255,0] 而用 [[[0,255,0]]] 
# 的三层括号应分别对应于 cvArray cvMat IplImage

green=np.uint8([[[0,255,0]]]) hsv_green=cv2.cvtColor(green,cv2.COLOR_BGR2HSV) 
print (hsv_green )
[[[60 255 255]]]

现在你可以分别用 [H-100，100，100] 和 [H+100，255，255] 做上下阀值。除了个方法之外，你可以使用任何其他图像编辑软件（例如 GIMP）或者在线换软件找到相应的 HSV 值，但是后别忘了调节 HSV 的范围。

函数原型（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;
 
}

效果
在这里插入图片描述

浩波的笔记

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
1
评论
计算机视觉基础——图像处理（彩色空间互转）cpp+python

3.1 简介图像彩色空间互转在图像处理中应用非常广泛，而且很多算法只对灰度图有效；另外，相比RGB，其他颜色空间(比如HSV、HSI)更具可分离性和可操作性，所以很多图像算法需要将图像从RGB转为其他颜色空间，所以图像彩色互转是十分重要和关键的。3.2 学习目标了解相关颜色空间的基础知识理解彩色空间互转的理论掌握OpenCV框架下颜色空间互转API的使用3.3 内容介绍1.相关颜...
复制链接

扫一扫