OpenCV学习04_core组件入门及颜色空间缩减与访问

一、core组件入门

1.1 ellipse()函数

//-------------------------------【DrawEllipse( )函数】--------------------------------
//		描述：自定义的绘制函数，实现了绘制不同角度、相同尺寸的椭圆
//-----------------------------------------------------------------------------------------
void DrawEllipse(Mat img, double angle)
{
	int thickness = 2;
	int lineType = 8;

	ellipse(img,
		Point(WINDOW_WIDTH / 2, WINDOW_WIDTH / 2),
		Size(WINDOW_WIDTH / 4, WINDOW_WIDTH / 16),
		angle,
		0,
		360,
		Scalar(255, 129, 0),
		thickness,
		lineType);
}

函数DrawEllipse调用了OpenCV中的ellipse函数,将椭圆画到图像img上,椭圆中心为点( WINDOW WIDTH/2.0, WINDOW WIDTH/2.0 ),并且大小位于矩形(WINDOW WIDTH/4.0, WINDOW WIDTH/16.0)内。椭圆旋转角度为angle扩展的弧度从0度到360度。图形颜色为Scalar(255,129,0)代表的蓝色,线宽(thickness)为2,线型(lineType)为8 (8联通线型)。

1.2 circle()函数

//-----------------------------------【DrawFilledCircle( )函数】---------------------------
//		描述：自定义的绘制函数，实现了实心圆的绘制
//-----------------------------------------------------------------------------------------
void DrawFilledCircle(Mat img, Point center)
{
	int thickness = -1;
	int lineType = 8;

	circle(img,
		center,
		WINDOW_WIDTH / 32,
		Scalar(0, 0, 255),
		thickness,
		lineType);
}

函数DrawFilledCircle()调用了OpenCV中的circle函数,将圆画到图像img上,圆心由点center定义,圆的半径为WINDOW-WIDTH/32,圆的颜色为Scalar(0,0,255),按BGR的格式为红色,线粗定义为thickness =-1,因此绘制的圆是实心的。

1.3 fillPoly()函数

//-----------------------------------【DrawPolygon( )函数】--------------------------
//		描述：自定义的绘制函数，实现了凹多边形的绘制
//--------------------------------------------------------------------------------------
void DrawPolygon(Mat img)
{
	int lineType = 8;

	//创建一些点
	Point rookPoints[1][20];
	rookPoints[0][0] = Point(WINDOW_WIDTH / 4, 7 * WINDOW_WIDTH / 8);
	rookPoints[0][1] = Point(3 * WINDOW_WIDTH / 4, 7 * WINDOW_WIDTH / 8);
	rookPoints[0][2] = Point(3 * WINDOW_WIDTH / 4, 13 * WINDOW_WIDTH / 16);
	rookPoints[0][3] = Point(11 * WINDOW_WIDTH / 16, 13 * WINDOW_WIDTH / 16);
	rookPoints[0][4] = Point(19 * WINDOW_WIDTH / 32, 3 * WINDOW_WIDTH / 8);
	rookPoints[0][5] = Point(3 * WINDOW_WIDTH / 4, 3 * WINDOW_WIDTH / 8);
	rookPoints[0][6] = Point(3 * WINDOW_WIDTH / 4, WINDOW_WIDTH / 8);
	rookPoints[0][7] = Point(26 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 8);
	rookPoints[0][8] = Point(26 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 4);
	rookPoints[0][9] = Point(22 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 4);
	rookPoints[0][10] = Point(22 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 8);
	rookPoints[0][11] = Point(18 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 8);
	rookPoints[0][12] = Point(18 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 4);
	rookPoints[0][13] = Point(14 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 4);
	rookPoints[0][14] = Point(14 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 8);
	rookPoints[0][15] = Point(WINDOW_WIDTH / 4, WINDOW_WIDTH / 8);
	rookPoints[0][16] = Point(WINDOW_WIDTH / 4, 3 * WINDOW_WIDTH / 8);
	rookPoints[0][17] = Point(13 * WINDOW_WIDTH / 32, 3 * WINDOW_WIDTH / 8);
	rookPoints[0][18] = Point(5 * WINDOW_WIDTH / 16, 13 * WINDOW_WIDTH / 16);
	rookPoints[0][19] = Point(WINDOW_WIDTH / 4, 13 * WINDOW_WIDTH / 16);

	const Point* ppt[1] = { rookPoints[0] };
	int npt[] = { 20 };

	fillPoly(img,
		ppt,
		npt,
		1,
		Scalar(255, 255, 255),
		lineType);
}

函数DrawPolygon()调用了OpenCV中的fillPoly函数,用于将多边形画到图像img上,其中多边形的顶点集为ppt,要绘制的多边形顶点数目为npt,要绘制的多边形数量仅为1,多边形的颜色定义为白色Scalar(255,255,255)

1.4 line()函数

//-----------------------------------【DrawLine( )函数】--------------------------
//		描述：自定义的绘制函数，实现了线的绘制
//---------------------------------------------------------------------------------
void DrawLine(Mat img, Point start, Point end)
{
	int thickness = 2;
	int lineType = 8;
	line(img,
		start,
		end,
		Scalar(0, 0, 0),
		thickness,
		lineType);
}

DrawLin()函数调用了OpenCV中的line函数,用于在图像img上画一条从点start到点end的直线段,线的颜色为Scalar0,0.0)代表的黑色,线的粗细thickness为2,且此线为8联通(lineType=8)。

1.5 绘制示例

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
using namespace cv;
#include <opencv2/imgproc/imgproc.hpp>


#define WINDOW_NAME1 "【圆与椭圆】"        //为窗口标题定义的宏 
#define WINDOW_NAME2 "【多边形与线段】"        //为窗口标题定义的宏 
#define WINDOW_WIDTH 600//定义窗口大小的宏

//全局函数声明
void DrawEllipse(Mat img, double angle);//绘制椭圆
void DrawFilledCircle(Mat img, Point center);//绘制圆
void DrawPolygon(Mat img);//绘制多边形
void DrawLine(Mat img, Point start, Point end);//绘制线段


//控制台应用程序的入口函数，我们的程序从这里开始执行
int main(void)
{
	// 创建空白的Mat图像
	Mat atomImage = Mat::zeros(WINDOW_WIDTH, WINDOW_WIDTH, CV_8UC3);
	Mat rookImage = Mat::zeros(WINDOW_WIDTH, WINDOW_WIDTH, CV_8UC3);

	// ---------------------<1>示例图------------------------
	//【1.1】先绘制出椭圆
	DrawEllipse(atomImage, 90);
	DrawEllipse(atomImage, 0);
	DrawEllipse(atomImage, 45);
	DrawEllipse(atomImage, -45);

	//【1.2】再绘制圆心
	DrawFilledCircle(atomImage, Point(WINDOW_WIDTH / 2, WINDOW_WIDTH / 2));

	// ---------------------<2>绘制组合图----------------------
	//【2.1】先绘制出椭圆
	DrawPolygon(rookImage);

	// 【2.2】绘制矩形
	rectangle(rookImage,
		Point(0, 7 * WINDOW_WIDTH / 8),
		Point(WINDOW_WIDTH, WINDOW_WIDTH),
		Scalar(0, 255, 255),
		-1,
		8);

	// 【2.3】绘制一些线段
	DrawLine(rookImage, Point(0, 15 * WINDOW_WIDTH / 16), Point(WINDOW_WIDTH, 15 * WINDOW_WIDTH / 16));
	DrawLine(rookImage, Point(WINDOW_WIDTH / 4, 7 * WINDOW_WIDTH / 8), Point(WINDOW_WIDTH / 4, WINDOW_WIDTH));
	DrawLine(rookImage, Point(WINDOW_WIDTH / 2, 7 * WINDOW_WIDTH / 8), Point(WINDOW_WIDTH / 2, WINDOW_WIDTH));
	DrawLine(rookImage, Point(3 * WINDOW_WIDTH / 4, 7 * WINDOW_WIDTH / 8), Point(3 * WINDOW_WIDTH / 4, WINDOW_WIDTH));

	// ---------------------------<3>显示绘制出的图像------------------------
	imshow(WINDOW_NAME1, atomImage);
	moveWindow(WINDOW_NAME1, 0, 200);
	imshow(WINDOW_NAME2, rookImage);
	moveWindow(WINDOW_NAME2, WINDOW_WIDTH, 200);

	waitKey(0);
	return(0);
}

二、颜色空间缩减

我们知道,若矩阵元素存储的是单通道像素,使用C或C++的无符号字符类型,那么像素可有256个不同值。但若是三通道图像,这种存储格式的颜色数就太多了(确切地说,有一千六百多万种)。用如此之多的颜色来进行处理,可能会对我们的算法性能造成严重影响。

其实,仅用这些颜色中具有代表性的很小的部分,就足以达到同样的效果。

如此,颜色空间缩减(color space reduction)便可以派上用场了,它在很多应用中可以大大降低运算复杂度。颜色空间缩减的做法是:将现有颜色空间值除以某个输入值,以获得较少的颜色数。也就是“做减法”,比如颜色值0到9可取为新值0, 10到19可取为10,以此类推。如uchar类型的三通道图像,每个通道取值可以是0~255,于是就有256x256个不同的值。我们可以定义:

• 0 ~ 9范围的像素值为0;
• 10 ~ 19范围的像素值为10;
• 20~29范围的像素值为20.

这样的操作将颜色取值降低为26x26×26种情况。这个操作可以用一个简单的公式来实现。因为C++中int类型除法操作会自动截余。

例如Iold=14;Inew=(Iold/10)*10=(14/10)* 10=1*10=10;

在处理图像像素时,每个像素需要进行一遍上述计算,也需要一定的时间花销。但我们注意到其实只有0~255种像素,即只有256种情况。进一步可以把256种计算好的结果提前存在表中table中,这样每种情况不需计算,直接从table中取结果即可。

int dividewith=10;
uchar table[2561;
for (int i =0; i < 256; ++1)
	table[i] =dividewith* (i/dividewith);

于是table[j]存放的是值为i的像素减小颜色空间的结果,这样也就可以理解上述方法中的操作:

p[j] = table [p[j]];

这样,简单的颜色空间缩减算法就可由下面两步组成:

• (1)遍历图像矩阵的每一个像素;
• (2)对像素应用上述公式。

值得注意的是,我们这里用到了除法和乘法运算,而这两种运算又特别费时,所以,应尽可能用代价较低的加、减、赋值等运算来替换它们。此外,还应注意到,上述运算的输入仅能在某个有限范围内取值,如uchar类型可取256个值。

由此可知,对于较大的图像,有效的方法是预先计算所有可能的值,然后需要这些值的时候,利用查找表直接赋值即可。查找表是一维或多维数组,存储了不同输入值所对应的输出值,其优势在于只需读取、无须计算。

2.1 LUT函数: Look up table操作

对于上文提到的Look up table操作, OpenCV官方文档中强烈推荐我们使用一个原型为operationsOnArrays:LUT()的函数来进行。它用于批量进行图像元素查找、扫描与操作图像。其使用方法如下:

//首先我们建立一个mat型用于查表
Mat lookUpTable (1, 256, cv_8U);
uchar* p= lookUpTable. data;
for ( int i=0; ic 256; ++i)
	p[i] =table[i];
//然后我们调用函数(I是输入J是输出):
for (int i = 0; i < times; ++i)
	LUT (I, 1ookUprable, J);

2.1 访问图像中的像素

任何图像处理算法,都是从操作每个像素开始的。即使我们不会使用OpenCV提供的各种图像处理函数,只要了解了图像处理算法的基本原理,也可以写出具有相同功能的程序。在OpenCV中,提供了三种访问每个像素的方法。

• 方法一 指针访问: C操作符[];
• 方法二 迭代器iterator;
• 方法三 动态地址计算。

这三种方法在访问速度上略有差异。debug模式下,这种差异非常明显,不过在release模式下,这种差异就不太明显了。我们通过一组程序来说明这几种方法。程序的目的是减少图像中颜色的数量,比如原来的图像是是256种颜色,我们希望将它变成64种颜色,那只需要将原来的颜色除以4 (整除)以后再乘以4就可以了。

#include <opencv2/core/core.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <iostream>  
using namespace std;
using namespace cv;


// 全局函数声明
void colorReduce(Mat& inputImage, Mat& outputImage, int div);

int main()
{
	//【1】创建原始图并显示
	Mat srcImage = imread("F:\\CV\\LearnCV\\files\\maliao.jpg");
	imshow("原始图像", srcImage);

	//【2】按原始图的参数规格来创建创建效果图
	Mat dstImage;
	dstImage.create(srcImage.rows, srcImage.cols, srcImage.type());//效果图的大小、类型与原图片相同 

	//【3】记录起始时间
	double time0 = static_cast<double>(getTickCount());

	//【4】调用颜色空间缩减函数
	colorReduce(srcImage, dstImage, 32);

	//【5】计算运行时间并输出
	time0 = ((double)getTickCount() - time0) / getTickFrequency();
	cout << "\t此方法运行时间为： " << time0 << "秒" << endl;  //输出运行时间

	//【6】显示效果图
	imshow("效果图", dstImage);
	waitKey(0);
}

其中，colorReduce()函数可见以下三种方式访问像素并进行空间缩减。

tip:以下三种方法运行时长为debug下测试时间

2.1.1 用指针访问像素

//使用【指针访问：C操作符[]】方法版的颜色空间缩减函数
void colorReduce(Mat& inputImage, Mat& outputImage, int div)
{
	//参数准备
	outputImage = inputImage.clone();  //拷贝实参到临时变量
	int rowNumber = outputImage.rows;  //行数
	int colNumber = outputImage.cols*outputImage.channels();  //列数 x 通道数=每一行元素的个数

	//双重循环，遍历所有的像素值
	for (int i = 0; i < rowNumber; i++)  //行循环
	{
		uchar* data = outputImage.ptr<uchar>(i);  //获取第i行的首地址
		for (int j = 0; j < colNumber; j++)   //列循环
		{
			// ---------【开始处理每个像素】-------------     
			data[j] = data[j] / div * div + div / 2;
			// ----------【处理结束】---------------------
		}  //行处理结束
	}
}

2.1.2 用迭代器访问像素

//使用【迭代器】方法版的颜色空间缩减函数
void colorReduce(Mat& inputImage, Mat& outputImage, int div)
{
	//参数准备
	outputImage = inputImage.clone();  //拷贝实参到临时变量
	//获取迭代器
	Mat_<Vec3b>::iterator it = outputImage.begin<Vec3b>();  //初始位置的迭代器
	Mat_<Vec3b>::iterator itend = outputImage.end<Vec3b>();  //终止位置的迭代器

	//存取彩色图像像素
	for (; it != itend; ++it)
	{
		// ------------------------【开始处理每个像素】--------------------
		(*it)[0] = (*it)[0] / div * div + div / 2;
		(*it)[1] = (*it)[1] / div * div + div / 2;
		(*it)[2] = (*it)[2] / div * div + div / 2;
		// ------------------------【处理结束】----------------------------
	}

2.1.3 用动态地址计算配合at访问像素

//使用【动态地址运算配合at】方法版本的颜色空间缩减函数
void colorReduce(Mat& inputImage, Mat& outputImage, int div)
{
	//参数准备
	outputImage = inputImage.clone();  //拷贝实参到临时变量
	int rowNumber = outputImage.rows;  //行数
	int colNumber = outputImage.cols;  //列数

	//存取彩色图像像素
	for (int i = 0; i < rowNumber; i++)
	{
		for (int j = 0; j < colNumber; j++)
		{
			//【开始处理每个像素】
			outputImage.at<Vec3b>(i, j)[0] = outputImage.at<Vec3b>(i, j)[0] / div * div + div / 2;  //蓝色通道
			outputImage.at<Vec3b>(i, j)[1] = outputImage.at<Vec3b>(i, j)[1] / div * div + div / 2;  //绿色通道
			outputImage.at<Vec3b>(i, j)[2] = outputImage.at<Vec3b>(i, j)[2] / div * div + div / 2;  //红是通道
			// 【处理结束】
		}  // 行处理结束    
	}
}