Opencv C++图像处理（全）

Opencv官方资料

Opencv（Open Source Computer Vision）官方资料。支持在线查看 / 搜索函数，有超详细的参数说明与函数使用说明（全英文版）。

（BUG1）报错提示：无法打开包括文件"math.h"
解决方案：配置属性 + 常规 + Windows SDK版本 + 最新安装的版本

（BUG2）报错提示：未定义标识符"CV_WINDOW_AUTOSIZE"
解决方案：添加头文件 #include <opencv2/highgui/highgui.hpp>

（BUG3）报错提示：未定义标识符"string"
解决方案：需同时添加头文件 #include <string>、using namespace std;
c++ 学习：未声明的标识符"string"（using namespace std;）

（BUG4）报错提示：无法找到Visual Studio 2015（v140）的生成工具
解决方案：配置属性 + 常规 + 平台工具集 + 选择当前VS版本对应的工具
无法找到Visual Studio 2015（v140）的生成工具

（BUG5）报错提示：当前不会命中断点。源代码与原始版本不同
解决方案：复制该文件的内容后删除该文件，并在新建文件中粘贴内容，并修改新建文件名为原文件名。
当前不会命中断点。源代码与原始版本不同 (VS2012)

一、入门基础

1.1、头文件说明：#include <opencv2/opencv.hpp>

在编辑器中点击opencv.hpp，其汇总了OpenCV图像处理相关的所有头文件（共15个）。如：图像处理模块头文件imgproc.hpp、高层GUI图形用户界面模块头文件highgui.hpp、2D特征模块头文件features2d.hpp等等。

所以，我们在编写core 、 objdetect 、 imgproc 、 photo 、 video 、 features2d 、 calib3d 、 ml 、 highgui模块的应用程序时，只需要添加该头文件即可。

1.2、头文件说明：#include <opencv2/highgui/highgui.hpp>

HighGUI（high-level graphical user interface）是一个可以移植的图形工具包。可以实现硬件（摄像机）、文件系统和操作系统的交互功能。
（1）硬件相关：用来对于视频的操作。VideoCapture、VidoeWriter
（2）文件系统：用来对于图像的操作。imread、imwrite、imshow
（3）操作系统：用来对于窗口的操作。namedWindow、destoryWindow、moveWindow、resizeWindow、WaitKey

二、图像处理

Opencv C++图像处理：亮度+对比度+饱和度+高光+暖色调+阴影+漫画效果+白平衡+浮雕+羽化+锐化+颗粒感

Opencv C++图像处理：亮度+对比度+饱和度+高光+暖色调+阴影+漫画效果+白平衡+浮雕+羽化+锐化+颗粒感

Opencv C++图像处理：矩阵Mat + 随机数RNG + 计算耗时 + 鼠标事件

Opencv C++图像处理：矩阵Mat + 随机数RNG + 计算耗时 + 鼠标事件

Opencv C++图像处理：点多边形测试 + 矩 + 凸包 + 映射 + 反向投影

Opencv C++图像处理：点多边形测试 + 矩 + 凸包 + 映射 + 反向投影

2.1、图像加载、保存与显示

2.1.1、加载图像：cv::imread() —— 返回Mat对象

• 支持的文件格式：* .bmp、* .dib、* .jpeg、* .jpg、*.jpe、* .jp2、* .png、* .webp、* .pbm、* .pgm、* .ppm、* .pxm、* .pnm、* .tiff、* .tif。

• 注意事项：

  • 11、在指定的图像路径和文件名中，支持中文和空格。opencv默认图片通道顺序是BGR，而不是RGB。
  • 22、如果无法读取图像（文件丢失，权限不正确，格式不支持或无效），不会报错，而是返回一个空矩阵（Mat中的data项为NULL）。

函数说明：Mat cv::imread( const string &filename, int flag=1 )
输入参数：
				filename			加载的图像路径（包括文件名）
				flag				标志类型（默认1）
						cv::ImreadModes {
								cv::IMREAD_UNCHANGED = -1,					If set, return the loaded image as is (with alpha channel, otherwise it gets cropped). Ignore EXIF orientation.
								cv::IMREAD_GRAYSCALE = 0,					If set, always convert image to the single channel grayscale image (codec internal conversion).
								cv::IMREAD_COLOR = 1,						If set, return the loaded image as is (with alpha channel, otherwise it gets cropped). Ignore EXIF orientation.
								cv::IMREAD_ANYDEPTH = 2,					If set, return 16-bit/32-bit image when the input has the corresponding depth, otherwise convert it to 8-bit.
								cv::IMREAD_ANYCOLOR = 4,					If set, the image is read in any possible color format.
								cv::IMREAD_LOAD_GDAL = 8,					If set, use the gdal driver for loading the image.
								cv::IMREAD_REDUCED_GRAYSCALE_2 = 16,		If set, always convert image to the single channel grayscale image and the image size reduced 1/2.
								cv::IMREAD_REDUCED_COLOR_2 = 17,			If set, always convert image to the 3 channel BGR color image and the image size reduced 1/2.
								cv::IMREAD_REDUCED_GRAYSCALE_4 = 32,		If set, always convert image to the single channel grayscale image and the image size reduced 1/4.
								cv::IMREAD_REDUCED_COLOR_4 = 33,			If set, always convert image to the 3 channel BGR color image and the image size reduced 1/4.
								cv::IMREAD_REDUCED_GRAYSCALE_8 = 64,		If set, always convert image to the single channel grayscale image and the image size reduced 1/8.
								cv::IMREAD_REDUCED_COLOR_8 = 65,			If set, always convert image to the 3 channel BGR color image and the image size reduced 1/8.
								cv::IMREAD_IGNORE_ORIENTATION = 128			If set, do not rotate the image according to EXIF's orientation flag.
								}

2.1.2、保存图像：cv::imwrite() —— 只支持JPG/PNG/TIFF格式

函数说明：bool cv::imwrite( const string &filename, InputArray img, const vector<int>&params=vector<int>() )
输入参数：
				filename		保存的图像路径（包括文件名）
				img				待保存的图像
				params			设置压缩参数来控制图片的质量（可选参数）。一般情况下，图片格式都是经过压缩的。
									11、该参数是一个vector<int>类型，里面分别存入paramId_1, paramValue_1, paramId_2, paramValue_2, ... 即存入一对属性值。
									22、若不设置该参数，则程序会自动根据所保存的图像格式采用一个默认的参数。
返回值：			保存成功返回1，失败返回0。

备注1：该函数目前只支持8位、16位JPG/PNG/TIFF的单通道或者三通道BGR图像格式，而不是所有Mat类型都支持。
备注2：如果Mat类型数据的深度和通道数不满足上面的要求，则需要使用convertTo()函数和cvtColor()函数来进行转换。

2.1.3、显示图像：cv::imshow()

函数说明：void cv::imshow( const string &winname, IputArray mat )
输入参数：
				winname			窗口名称
				image			待显示的图像
				
备注1：imshow()函数通常与waitKey()函数连用，否则程序执行完毕，闪一下就消失了。
备注2：waitKey(0)：其中，0表示等待用户任意按键后结束暂停功能；其余值表示等待指定时间，单位为毫秒。

2.1.4、实战案例

#include<opencv2\opencv.hpp>
#include <string>
//using namespace cv;
//using namespace std;

int main(int argc,char* argv[])
{
	//输入图像（字符串）路径的五种方法：
	//（1）单左斜线法		string imgpath = "C:/Users/pc/Desktop/test.jpg";
	//（2）双右斜线法		string imgpath = "C:\\Users\\pc\\Desktop\\test.jpg";
	//（3）双左斜线法		string imgpath = "C://Users//pc//Desktop//test.jpg";
	//（4）以上三种混合法		string imgpath = "C:/Users//pc\\Desktop//test.jpg";
	//（5）相对路径法		string imgpath = "test.jpg";
	
	//（1）读取图像
	std::string img_path = "test.jpg";	
	cv::Mat img = cv::imread(img_path, 1);		
				
	//（2）判断图像是否读取成功
	if(img.empty())											
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}
    
    //（3）打印图像信息
	std::cout << "宽度："<<img.cols << std::endl;
	std::cout << "高度：" << img.rows << std::endl;
	std::cout << "通道数：" << img.channels() << std::endl;
	std::cout << "字节数：" << img.elemSize() / img.channels()*8 << std::endl;
	unsigned char* pData = img.data;
	std::cout << "数据地址：" << &pData << std::endl;
	//std::cout << "打印矩阵：" << img << std::endl;
	
	//（4）保存与显示图像
	cv::imwrite("C:/Users/my/Desktop/save.jpg", img);		//保存图像
	cv::imshow("img", img);									//显示图像
	
	cv::waitKey(0);		//等待用户任意按键后结束暂停功能
	return 0;
}

2.2、窗口操作

2.2.1、创建窗口：cv::namedWindow()

• 函数namedWindow创建一个窗口，该窗口可以用作图像和轨迹条的占位符。
• 创建的窗口由其名称引用。
• 如果已经存在具有相同名称的窗口，则该函数将不执行任何操作。

#include <opencv2/highgui.hpp>
函数说明：void cv::namedWindow(const String &winname, int flags = WINDOW_AUTOSIZE)
输入参数：		winname：		窗口标题中，可以用作窗口标识符的窗口名称。
				flags ：		窗口标志符。默认WINDOW_AUTOSIZE
						WINDOW_NORMAL			用户可以调整窗口大小（无限制）/也可以将全屏窗口切换到正常大小。
						WINDOW_AUTOSIZE 		用户无法调整窗口大小，窗口大小受显示图像的限制。
						WINDOW_OPENGL 			支持opengl的窗口。
						WINDOW_FULLSCREEN 		将窗口更改为全屏。
						WINDOW_FREERATIO 		调整图像而没有比率约束。
						WINDOW_KEEPRATIO 		图像的比例得到了尊重。
						WINDOW_GUI_EXPANDED 	（旧方法）在没有状态栏和工具栏的情况下绘制窗口（一种新的增强型GUI）
						WINDOW_GUI_NORMAL 		（旧方法）在没有状态栏和工具栏的情况下绘制窗口

2.2.2、销毁指定/所有窗口：cv::destoryWindow() + cv::destoryAllWindow()

#include <opencv2/highgui.hpp>
函数作用：销毁给定名称的窗口。
函数说明：void cv::destroyWindow( const String &winname )	
输入参数：		winname：		要销毁的窗口名称。

#include <opencv2/highgui.hpp>
函数作用：销毁所有打开的HighGUI窗口。
函数说明：void cv::destroyAllWindows()		

2.2.3、移动窗口到指定位置：cv::moveWindow()

#include <opencv2/highgui.hpp>
函数说明：void cv::moveWindow( const string &winname, int x, int y )
输入参数：		winname			窗口名称。
				x				窗口的新x坐标。
				y				窗口的新y坐标。

2.2.4、调整窗口大小：cv::resizeWindow()

• 只能在窗口标记符 flags 不等于 cv::WINDOW_AUTOSIZE 的情况下，创建的窗口才能调整大小。

#include <opencv2/highgui.hpp>
函数说明：void cv::resizeWindow(const string &winname, int width, int height)
输入参数：       
				winname			窗口名称。
				width			新窗口宽度。
				height			新窗口高度。

2.2.5、等待按键：cv::WaitKey()

• 函数waitKey无限等待键事件（当延迟≤0时），或等待延迟毫秒（当延迟>0正时）。
• 返回所按下键的代码，若在指定时间内没有按下任何键，则返回-1。要检查按键是否按下但不等待，请使用 int cv::pollKey()。函数waitKey和pollKey是HighGUI中唯一可以获取和处理GUI事件的方法。
• 只有当至少创建了一个HighGUI窗口并且该窗口处于活动状态时，WaitKey才能工作。如果有多个HighGUI窗口，其中任何一个都可以处于活动状态。

#include <opencv2/highgui.hpp>
函数说明：int cv::waitKey( int delay=0 )	
输入参数：
				当delay<=0		无限等待键事件，直到用户触发一个按键。
				当delay>0		等待延迟毫秒。
				
备注：延迟delay（以毫秒为单位）。0是表示“永远”的特殊值。

2.3、颜色空间转换：cv::cvtColor()

该函数将输入图像从一个颜色空间转换为另一个颜色。在从RGB颜色空间转换到的情况下，应明确指定通道的顺序（RGB或BGR）。请注意，OpenCV中的默认颜色格式是BGR。
R、G、B通道值的常规范围为：（1）CV_8U图像：0到255；（2）CV_16U图像：0到65535；（3）CV_32F图像：0到1。

更多颜色空间转换码，请看官网：Color Space Conversions

函数说明：void cv::cvtColor( InputArray src, OutputArray dst, int code, int dstCn = 0 )
输入参数：
				src				输入图像：8位无符号、16位无符号（CV_16UC…）或单精度浮点。
				dst				输出与src大小和深度相同的图像。
				dstCn			输出图像的通道数，默认0。如果参数为0，那么通道的数量将自动从src和code中导出。
				code			颜色空间转换码。总计有200种左右，只列出其中常用转换码。
						cv::ColorConversionCodes {
								cv::COLOR_BGR2RGB = 4,
								cv::COLOR_RGB2BGR = COLOR_BGR2RGB,
								cv::COLOR_BGR2GRAY = 6,
								cv::COLOR_RGB2GRAY = 7,
								cv::COLOR_GRAY2BGR = 8,
								cv::COLOR_GRAY2RGB = COLOR_GRAY2BGR
								}
备注1：若设置dst==src，即实现原图的转换。但不改变原矩阵，而是将src.data存放在编译器新建的内存地址中。

#include<opencv2\opencv.hpp>
#include <string>
//using namespace cv;
//using namespace std;

int main(int argc, char* argv[])
{
	//（1）读取图像
	std::string img_path = "test.jpg";
	cv::Mat img = cv::imread(img_path, 1);

	//（2）判断图像是否读取成功
	if (img.empty())
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}

	//（3）空间颜色转换
	cv::Mat img_RGB, img_gray;
	cv::cvtColor(img, img_RGB, cv::COLOR_BGR2RGB);
	cv::cvtColor(img, img_gray, cv::COLOR_BGR2GRAY);

	//（4）显示图像
	cv::imshow("img", img);
	cv::imshow("RGB", img_RGB);
	cv::imshow("gray", img_gray);

	cv::waitKey(0);		//等待用户任意按键后结束暂停功能
	return 0;
}

2.4、边缘填充：cv::copyMakeBorder()

作用：在图像四周填充指定像素形成边框。
在过滤函数中，也有边界类型borderType参数，效果等同。区别是，该函数可以独立运行。

#include <opencv2/core.hpp>
函数说明：void cv::copyMakeBorder( InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value = Scalar() );
输入参数：
				src					输入图像。
				dst					与src类型相同的输出图像，大小为size（src.cols+left+right, src.rows+top+bottom）。
				top					顶部像素
				bottom				底部像素
				left				左侧像素
				right				右侧像素。指定在源图像的每个方向上要外推的像素数。top＝1，bottom＝1，left＝1，right＝1意味着需要构建像素宽为1的边界。
				borderType 			边框类型（即边界填充方式）。其中，BORDER_TRANSPARENT不可用。
						cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
						cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
						cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
						cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
						cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
						cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
						cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
						cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
						cv::BORDER_ISOLATED = 8 			do not look outside of ROI
				value = Scalar() 	如果borderType==Border_CONSTANT，则为边界值。

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

//using namespace std;
//using namespace cv;

int main(int argc, char* argv[])
{
	//（1）读取图像
	std::string img_path = "test.jpg";
	cv::Mat src = cv::imread(img_path, 1);

	//（2）判断图像是否读取成功
	if (!src.data)
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}

	//（3）边缘填充
	float border_width = 0.2;
	int top		= (int)(border_width * src.rows);
	int bottom	= (int)(border_width * src.rows);
	int left	= (int)(border_width * src.cols);
	int right	= (int)(border_width * src.cols);
	
	cv::RNG rng;
	cv::Mat img1, img2, img3, img4, img5, img6, img7, img8, img9;
	cv::Scalar color = cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
	
	cv::copyMakeBorder(src, img1, top, bottom, left, right, cv::BORDER_CONSTANT, color);
	cv::copyMakeBorder(src, img2, top, bottom, left, right, cv::BORDER_REPLICATE, color);
	cv::copyMakeBorder(src, img3, top, bottom, left, right, cv::BORDER_REFLECT, color);
	cv::copyMakeBorder(src, img4, top, bottom, left, right, cv::BORDER_WRAP, color);
	cv::copyMakeBorder(src, img5, top, bottom, left, right, cv::BORDER_REFLECT_101, color);
	//cv::copyMakeBorder(src, img6, top, bottom, left, right, cv::BORDER_TRANSPARENT, color);		//不可用
	cv::copyMakeBorder(src, img7, top, bottom, left, right, cv::BORDER_REFLECT101, color);
	cv::copyMakeBorder(src, img8, top, bottom, left, right, cv::BORDER_DEFAULT, color);
	cv::copyMakeBorder(src, img9, top, bottom, left, right, cv::BORDER_ISOLATED, color);

	//（4）显示图像
	cv::imshow("src", src);
	cv::imshow("img1", img1);
	cv::imshow("img2", img2);
	cv::imshow("img3", img3);
	cv::imshow("img4", img4);
	cv::imshow("img5", img5);
	//cv::imshow("img6", img6);		//不可用
	cv::imshow("img7", img7);
	cv::imshow("img8", img8);
	cv::imshow("img9", img9);
	
	cv::waitKey(0);
	return 0;
}

2.5、图像融合：cv::addWeighted()

计算两个数组的加权和：dst = src1*alpha + src2*beta + gamma;
注意：两张图像的大小和类型必须一致才行。

#include <opencv2/core.hpp>
函数说明：void cv::addWeighted( InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype = -1 )

输入参数：
				src1			第一输入阵列。
				alpha			第一阵列元素的权重。
				src2			具有与src1相同大小和通道数的第二输入阵列。
				beta			第二阵列元素的权重。
				gamma			给阵列的每个元素添加一个标量（截距）
				dst				具有与输入阵列相同大小和通道数的输出阵列。
				dtype			输出阵列的可选深度；当两个输入数组具有相同的深度时，dtype可以设置为-1（默认），等效于src1.depth()。

#include<opencv2\opencv.hpp>
#include <string>
//using namespace cv;
//using namespace std;

int main(int argc,char* argv[])
{
	//（1）读取图像
	std::string img_path1 = "test.jpg";	
	std::string img_path2 = "flower.jpg";
	cv::Mat img1 = cv::imread(img_path1, 1);				
	cv::Mat img2 = cv::imread(img_path2, 1);		
		
	//（2）判断图像是否读取成功
	if(img1.empty() || img2.empty())											
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}
    
    //（3）判断两张图像的宽高是否相同
    if(img1.rows != img2.rows || img1.cols != img2.cols)
    {
    	cv::resize(img2, img2, img1.size());
	    std::cout << "img1:" << img1.rows <<":" << img1.cols << std::endl;
    	std::cout << "img2:" << img2.rows <<":" << img2.cols << std::endl;
    }
	
	//（4）计算两个数组的加权和
	cv::Mat img3;
	double alpha = 0.6;
	cv::addWeighted(img1, alpha, img2, (1-alpha), 0, img3);
	
	//显示图像
	cv::imshow("img1", img1);					
	cv::imshow("img2", img2);			
	cv::imshow("img3", img3);			
	
	cv::waitKey(0);		//等待用户任意按键后结束暂停功能
	return 0;
}

2.6、图像的三色图

2.6.1、通道分离：cv::split()

将多通道阵列划分为多个单通道阵列。

#include <opencv2/core.hpp>	
函数说明：void cv::split( InputArray m, 	OutputArrayOfArrays mv );
输入参数：
				m				输入多通道阵列。
				mv				输出阵列；阵列的数量与src.channels()相匹配；如果需要，将重新分配阵列本身。

char d[] = {1,2,3,4,5,6,7,8,9,10,11,12};
Mat m(2, 2, CV_8UC3, d);
Mat channels[3];
split(m, channels);
/*
channels[0] = [1, 4; 7, 10]
channels[1] = [2, 5; 8, 11]
channels[2] = [3, 6; 9, 12]
*/

2.6.2、通道合并：cv::merge()

将多个数组合并为一个多通道数组。

#include <opencv2/core.hpp>	
函数说明：void cv::merge( InputArrayOfArrays mv, OutputArray dst );
输入参数：
				mv				待合并矩阵的输入向量；mv中的所有矩阵必须具有相同的大小和相同的深度。
				dst				与mv[0]具有相同大小和相同深度的输出阵列；通道的数量将是矩阵阵列中通道的总数。

Mat m1 = (Mat_<uchar>(2,2) << 1,4,7,10);
Mat m2 = (Mat_<uchar>(2,2) << 2,5,8,11);
Mat m3 = (Mat_<uchar>(2,2) << 3,6,9,12);
Mat channels[3] = {m1, m2, m3};
Mat m;
merge(channels, m);
/*
m = [1, 2, 3, 4, 5, 6; 7, 8, 9, 10, 11, 12]
m.channels() = 3
*/

2.6.3、实战案例

#include<opencv2\opencv.hpp>
#include <string>
//using namespace cv;
//using namespace std;
 
int main(int argc,char* argv[])
{
	//（1）读取图像
	std::string img_path = "test.jpg";	
	cv::Mat src = cv::imread(img_path, 1);			
		
	//（2）判断图像是否读取成功
	if(src.empty())											
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}
 
	//（3）将图像分割成多个通道（分离后的每个通道都是灰度图；而新建其余两通道全0，则可以显示对应的通道颜色）
	std::vector<cv::Mat> rgbChannels(3);
	cv::split(src, rgbChannels);
 
	//（4）新建其余两通道全0，并显示对应的通道颜色。
	cv::Mat blank_ch;
	blank_ch = cv::Mat::zeros(cv::Size(src.cols, src.rows), CV_8UC1);		//新建全0矩阵：大小与Mat相同，类型为CV_8UC1。
	//（4.1）显示红色通道
	std::vector<cv::Mat> channels_r;
	channels_r.push_back(blank_ch);		//Mat.push_back：将一个或多个元素添加到矩阵底部。其类型和列数必须与Mat矩阵中的相同。
	channels_r.push_back(blank_ch);
	channels_r.push_back(rgbChannels[2]);
	//（4.2）显示绿色通道
	std::vector<cv::Mat> channels_g;
	channels_g.push_back(blank_ch);
	channels_g.push_back(rgbChannels[1]);
	channels_g.push_back(blank_ch);
	//（4.3）显示蓝色通道
	std::vector<cv::Mat> channels_b;
	channels_b.push_back(rgbChannels[0]);
	channels_b.push_back(blank_ch);
	channels_b.push_back(blank_ch);
	
	//（5）合并三个通道
	cv::Mat r_img, g_img, b_img;		// 分离后的每个通道都是灰度图；而新建其余两通道全0，则可以显示对应的通道颜色。
	cv::merge(channels_r, r_img);		//（显示红色通道，其余两通道全部置0）
	cv::merge(channels_g, g_img);		//（显示绿色通道，其余两通道全部置0）
	cv::merge(channels_b, b_img);		//（显示蓝色通道，其余两通道全部置0）
	
	//（6）显示图像
	cv::imshow("src", src);
	cv::imshow("R_img", r_img);
	cv::imshow("G_img", g_img);
	cv::imshow("B_img", b_img);
	
	cv::imshow("R_gray", rgbChannels.at(0));
	cv::imshow("G_gray", rgbChannels.at(1));
	cv::imshow("B_gray", rgbChannels.at(2));
	
	cv::waitKey(0);
	return 0;
}

2.7、阈值化处理（基于灰度图分割目标1与背景0）

彩色图像：三通道，像素值一般为0~255；
灰度图像：单通道，像素值一般为0~255；
二值图像：单通道，像素值一般为0（黑色）、255（白色）；

常用方法有两种：

• （1）cv::threshold()：设定固定阈值，实现图像的阈值化分割，但缺乏灵活性，且有时候难以达到理想的分割效果。
• （2）cv::adaptiveThreshold()：通过图像的像素邻域块的分布特征，自适应确定区域的二值化阈值。即把图像分成N个邻域块，然后采用某种算法计算邻域块的二值化阈值，并对这些小块进行阈值化处理。

2.7.1、二值化处理：cv::threshold()

• 将设置的阈值应用于每个通道（阵列）的每个像素，进而过滤太小或太大的像素值。常用于去除噪声。
• 缺点：具有主观性，难以达到理想的分割效果。
  opencv 二值化阈值分割（图解+阈值类型详解）

#include <opencv2/imgproc.hpp>
函数说明：double cv::threshold( InputArray src, OutputArray dst, double thresh, double maxval, int type );
输入参数：
				src				输入阵列（多通道、8位或32位浮点）。
				dst				与src具有相同大小和类型以及相同通道数的输出数组。
				thresh			阈值。
				maxval			与THRESH_BINARY和THRESH_ BINARY_INV阈值类型一起使用的最大值。
				type			阈值类型。
						cv::THRESH_BINARY = 0 				若大于thresh，则设置为maxval，否则设置为0。（常用）
						cv::THRESH_BINARY_INV = 1 			若大于thresh，则设置为0，否则设置为maxval（反操作）。
						cv::THRESH_TRUNC = 2 				若大于thresh，则设置为thresh，否则保持不变。
						cv::THRESH_TOZERO = 3 				若大于thresh，则保持不变，否则设置为0。
						cv::THRESH_TOZERO_INV = 4 			若大于thresh，则设置为0，否则保持不变（反操作）。
						cv::THRESH_MASK = 5 
						cv::THRESH_OTSU = 6 				全局自适应阈值化（仅适用于8位单通道图像）。适合于直方图具有双峰的情况，其在双峰之间找到阈值；对于非双峰图像不是很好用。
						cv::THRESH_TRIANGLE = 7 			全局自适应阈值化（仅适用于8位单通道图像）。在直方图中，在最亮到最暗处连接一条直线，得到的最大直线距离所对应的直方图位置就是阈值thresh。
								
输出参数：仅当阈值类型为Otsu或Triangle方法时使用，输出自适应的阈值。

2.7.2、自适应二值化处理：cv::adaptiveThreshold()

通过窗口内像素的分布特征自适应计算阈值，并进行阈值化处理。详细步骤如下：

• （1）将图像拆分为M x N个区域；
• （2）采用自适应阈值算法（窗口均值阈值法、高斯分布阈值法），计算每个区域的（均值、高斯均值），该值即当前区域的二值化阈值；
• （3）根据每个窗口计算得到的不同阈值（动态），进行阈值化处理。opencv 自适应二值化处理

#include <opencv2/imgproc.hpp>
函数说明：void cv::adaptiveThreshold( InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C );
输入参数：
				src					8位单通道图像。
				dst					与src大小和类型相同的目标图像。
				maxValue			指定给满足条件的像素的非零值
				adaptiveMethod		自适应阈值算法。BORDER_REPLICATE|BORDER_ISOLATED用于处理边界。
							cv::ADAPTIVE_THRESH_MEAN_C = 0 			窗口均值阈值法。计算出领域的平均值再减去参数double C的值
							cv::ADAPTIVE_THRESH_GAUSSIAN_C = 1		高斯分布阈值法。计算出领域的高斯均值再减去参数double C的值
				thresholdType		阈值化类型（只有两个取值）。
							cv::THRESH_BINARY = 0 				若大于thresh，则设置为maxval，否则设置为0。（常用）
							cv::THRESH_BINARY_INV = 1 			若大于thresh，则设置为0，否则设置为maxval（反操作）。
				blockSize			像素邻域大小（单位）：3、5、7，依此类推。自适应阈值算法的阈值计算时使用。
				C					偏移值。自适应阈值算法的阈值计算时使用。

2.7.3、实战案例

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
 
//using namespace std;
//using namespace cv;
 
int main(int argc,char* argv[])
{
    //（1）读取图像
    std::string img_path = "test.jpg";
    cv::Mat src = cv::imread(img_path, 1);
	
	//（2）判断图像是否读取成功
    if (!src.data)
    {
		std::cout << "can't read image!" << std::endl;
		return -1;
	}
        
    //（3）转换为灰度图
    cv::Mat srcGray;
    cv::cvtColor(src, srcGray, cv::COLOR_RGB2GRAY);
    
    //（4）阈值化处理
    cv::Mat THRESH_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_INV, THRESH_MASK, THRESH_OTSU, THRESH_TRIANGLE;
    double thresh = 125;
    double maxval = 255;
	cv::threshold(srcGray, THRESH_BINARY, 		thresh, maxval, 0);
	cv::threshold(srcGray, THRESH_BINARY_INV, 	thresh, maxval, 1);
	cv::threshold(srcGray, THRESH_TRUNC, 		thresh, maxval, 2);
	cv::threshold(srcGray, THRESH_TOZERO, 		thresh, maxval, 3);
	cv::threshold(srcGray, THRESH_TOZERO_INV, 	thresh, maxval, 4);
	//cv::threshold(srcGray, THRESH_MASK, 		thresh, maxval, 5);
	//cv::threshold(srcGray, THRESH_OTSU, 		thresh, maxval, 6);
	//cv::threshold(srcGray, THRESH_TRIANGLE,		thresh, maxval, 7);

	//（5）自适应阈值化处理
	cv::Mat ADAPTIVE_THRESH_MEAN_C0, ADAPTIVE_THRESH_MEAN_C1, ADAPTIVE_THRESH_GAUSSIAN_C0, ADAPTIVE_THRESH_GAUSSIAN_C1;
    int blockSize = 5;
    int constValue = 10;
    const int maxVal = 255;
    cv::adaptiveThreshold(srcGray, ADAPTIVE_THRESH_MEAN_C0, 	maxVal, cv::ADAPTIVE_THRESH_MEAN_C, 	cv::THRESH_BINARY, blockSize, constValue);
	cv::adaptiveThreshold(srcGray, ADAPTIVE_THRESH_MEAN_C1, 	maxVal, cv::ADAPTIVE_THRESH_MEAN_C, 	cv::THRESH_BINARY, blockSize, constValue);
	cv::adaptiveThreshold(srcGray, ADAPTIVE_THRESH_GAUSSIAN_C0, maxVal, cv::ADAPTIVE_THRESH_GAUSSIAN_C, cv::THRESH_BINARY_INV, blockSize, constValue);
	cv::adaptiveThreshold(srcGray, ADAPTIVE_THRESH_GAUSSIAN_C1, maxVal, cv::ADAPTIVE_THRESH_GAUSSIAN_C, cv::THRESH_BINARY_INV, blockSize, constValue);
	
	//（6）显示图像
	cv::imshow("srcGray", srcGray);
	
	cv::imshow("img1", THRESH_BINARY);
	cv::imshow("img2", THRESH_BINARY_INV);
	cv::imshow("img3", THRESH_TRUNC);
	cv::imshow("img4", THRESH_TOZERO);
	cv::imshow("img5", THRESH_TOZERO_INV);
	//cv::imshow("img6", THRESH_MASK);
	//cv::imshow("img7", THRESH_OTSU);
	//cv::imshow("img8", THRESH_TRIANGLE);
	
	cv::imshow("img11", ADAPTIVE_THRESH_MEAN_C0);
	cv::imshow("img22", ADAPTIVE_THRESH_MEAN_C1);
	cv::imshow("img33", ADAPTIVE_THRESH_GAUSSIAN_C0);
	cv::imshow("img44", ADAPTIVE_THRESH_GAUSSIAN_C1);
	
    cv::waitKey(0);
    return 0;
}

2.8、滤波处理

• 椒盐噪声：噪声的幅值基本上相同，但是噪声出现的位置是随机的；（中值滤波效果好）
• 高斯噪声：每一点都存在噪声，但噪声的幅值是随机分布的。

滤波器分为线性滤波和非线性滤波：

• 非线性滤波：中值滤波、双边滤波。
• 线性滤波：方框滤波、均值滤波、高斯滤波、图像滤波器、可分离滤波器。
  （1）低通滤波器：允许低频率通过；
  （2）高通滤波器：允许高频率通过；
  （3）带通滤波器 ：允许一定区域的频率通过；
  （4）带阻滤波器 ：阻止一定范围内的频率并且允许其他频率通过；
  （5）全通滤波器 ：允许所有频率通过，仅仅改变相位；
  （6）陷波滤波器（Band stop filter）：阻止一个狭窄频率范围通过的特殊带阻滤波器。

滤波器的优缺点：

• （1）均值滤波器 cv::blur()：可以减少噪点或失真情况，缺点边缘信息丢失而导致图像变得模糊。
• （2）方框滤波器 cv::boxFilter()：很少用到。当归一化参数normalize=true时，等同于均值滤波器。
• （3）高斯滤波器 cv::GaussianBlur()：可以有效的去除高斯噪音，但不能完全避免边缘特征丢失问题。
• （4）中值滤波器 cv::medianBlur()：可以有效的消除脉冲噪声和椒盐噪声，且能保护边缘特征。缺点是花费的时间是均值滤波的5倍以上。
• （5）双边滤波器 cv::bilateralFilter()：在高斯滤波的基础上加入灰度信息权重，去噪的同时避免边缘信息丢失。缺点是需要更多的处理时间。
• （6）自定义卷积 cv::filter2D()：使用自定义二维卷积核实现卷积操作。
• （7）可分离滤波器 cv::sepFilter2D()：先对X方向进行一维滤波得到一维行向量，再对Y方向进行一维滤波得到一维列向量，然后将两个向量相乘得到一个值并替换卷积核。效果等同于连续调用两次的filter2D()。

备注：卷积核大小与平滑的效果直接相关，卷积核越大平滑效果越好，但卷积核过大会使边缘信息的损失过大，进而导致输出的图像变得模糊，因此需合理选择卷积核大小。

2.8.1、均值滤波器：cv::blur()

• 作用：取卷积核的平均值替换卷积核。

使用卷积核进行图像平滑：

#include <opencv2/imgproc.hpp>
函数说明：void cv::blur( InputArray src, OutputArray dst, Size ksize, Point anchor = Point(-1,-1), int borderType = BORDER_DEFAULT );
输入参数：
				src				输入图像。可以有任意数量的通道，这些通道是独立处理的，但深度应该是CV_8U、CV_16U、CV_16S、CV_32F或CV_64F。
				dst				输出与src大小和类型相同的图像。
				ksize			卷积核大小。
				anchor = Point(-1,-1)				锚点。默认值Point(-1，-1)：表示锚点位于内核中心。
				borderType = BORDER_DEFAULT 		边界类型（即边界填充方式）。默认BORDER_DEFAULT。不支持BORDER_WRAP。
						cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
						cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
						cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
						cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
						cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
						cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
						cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
						cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
						cv::BORDER_ISOLATED = 8 			do not look outside of ROI

2.8.2、方框滤波器：cv::boxFilter()

• （非归一化）方框滤波器可用于计算每个像素邻域上的各种积分特性。例如：图像导数的协方差矩阵（用于密集光流算法等）。
• （归一化）方框滤波器等同于均值滤波器。

使用卷积核进行图像平滑：

#include <opencv2/imgproc.hpp>
函数说明：void cv::boxFilter( InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor = Point(-1,-1), bool normalize = true, int borderType = BORDER_DEFAULT );
输入参数：
				src				输入图像。
				dst				输出与src大小和类型相同的图像。
				ddepth			输出图像深度（使用src.depth()时为-1）。
				ksize			卷积核大小。
				anchor = Point(-1,-1)			锚点。默认值Point(-1，-1)：表示锚点位于内核中心。
				normalize = true				指定内核是否按其面积进行规范化（默认True）。
				borderType = BORDER_DEFAULT		边界类型（即边界填充方式）。默认BORDER_DEFAULT。不支持BORDER_WRAP。
						cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
						cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
						cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
						cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
						cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
						cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
						cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
						cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
						cv::BORDER_ISOLATED = 8 			do not look outside of ROI

2.8.3、高斯滤波器：cv::GaussianBlur()

• 作用：对整幅图像进行加权平均。每一个像素点的值，都由其本身和邻域内的其他像素值经过加权平均后得到。
• 原理：加权是因为符合高斯分布，平均是因为符合正态分布=[0, 1]。高斯核中心的值最大，其余根据距离中心元素的距离递减。

#include <opencv2/imgproc.hpp>
函数说明：void cv::GaussianBlur( InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY = 0, int borderType = BORDER_DEFAULT );
输入参数：
				src				输入图像；图像可以具有任意数量的通道，这些通道是独立处理的，但深度应该是CV_8U、CV_16U、CV_16S、CV_32F或CV_64F。
				dst				输出与src大小和类型相同的图像。
				ksize			高斯核大小。ksize.width和ksize.height可以不同，但它们都必须是正数和奇数。或者，它们可以是零，然后根据sigma计算。
				sigmaX							X方向上的高斯核标准偏差。
				sigmaY = 0						Y方向上的高斯核标准偏差。如果sigmaY为零（默认），则设置为等于sigmaX；如果两个sigma都为零，那么分别从ksize.width和ksize.height计算。
				borderType = BORDER_DEFAULT		边界类型（即边界填充方式）。默认BORDER_DEFAULT。不支持BORDER_WRAP。
						cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
						cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
						cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
						cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
						cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
						cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
						cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
						cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
						cv::BORDER_ISOLATED = 8 			do not look outside of ROI

2.8.4、中值滤波器：cv::medianBlur()

作用：卷积核排序，取其中间值（不是平均值）替换该卷积核。在内部使用 BORDER_REPLICATE 来处理边界像素。

#include <opencv2/imgproc.hpp>
函数说明：void cv::medianBlur( InputArray src, OutputArray dst, int ksize );
输入参数：
				src				输入图像。1通道、3通道或4通道图像；当ksize为3或5时，图像深度应为CV_8U、CV_16U或CV_32F，对于较大的孔径尺寸，它只能是CV_8U。
				dst				输出与src大小和类型相同的图像。
				ksize			卷积核大小。必须是奇数并且大于1，例如：3、5、7...

2.8.5、双边滤波器：cv::bilateralFilter()

原理：同时使用空间高斯权重和灰度值相似性高斯权重。
（1）空间距离：指的是邻域内某点与中心点的欧式距离。
（2）灰度距离：指的是邻域内某点灰度与中心点灰度的差的绝对值。

• 高斯滤波：基于空间距离对图像进行加权平均。即在邻域内，越接近中心点的像素点，其权重越大。
• 双边滤波：在高斯滤波的基础上，加入灰度信息权重。即在邻域内，灰度值越接近中心点，其权重更大。最终卷积核的权重大小由空间域高斯核函数和值域高斯核函数共同确定。双边滤波(bilateralFilter)原理

#include <opencv2/imgproc.hpp>
函数说明：void cv::bilateralFilter( InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType = BORDER_DEFAULT );
输入参数：
				src				输入图像。8位或浮点、1通道或3通道图像。
				dst				输出与src大小和类型相同的图像。
				d				像素邻域的直径[5, 9...]。若d>0，由d直接指定邻域直径；若d<=0，则会自动由sigmaSpace的值确定，且与之成正比。
				sigmaColor		在颜色空间[0, 255]中过滤小于sigmaColor的像素值。值越大，卡通化效果越明显。sigma两个参数常设置相同
				sigmaSpace		在坐标空间[0, + ∞]中过滤小于sigmaSpace的像素值。值越大，卡通化效果越明显。
				borderType = BORDER_DEFAULT		边界类型（即边界填充方式）。默认BORDER_DEFAULT。不支持BORDER_WRAP。
						cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
						cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
						cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
						cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
						cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
						cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
						cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
						cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
						cv::BORDER_ISOLATED = 8 			do not look outside of ROI

2.8.6、自定义卷积：cv::filter2D()

作用：使用自定义二维卷积核实现卷积操作。在多通道图像的情况下，每个通道都是独立处理的。若需要将不同的卷积核应用于不同的通道，可使用cv::split。

该函数实际上计算的是相关性，而不是卷积：

#include <opencv2/imgproc.hpp>
函数说明：void cv::filter2D( InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor = Point(-1,-1), double 	delta = 0, int borderType = BORDER_DEFAULT );
输入参数：
				src				输入图像。
				dst				输出与src大小和类型相同的图像。
				ddepth			输出图像深度（使用src.depth()时为-1）。
				kernel			卷积核大小（单通道浮点矩阵）。
				anchor = Point(-1,-1)			锚点。位于卷积核内；默认值(-1，-1)：表示锚点位于内核中心。
				delta = 0						偏移量，卷积结果要加上这个数字。
				borderType = BORDER_DEFAULT		边界类型（即边界填充方式）。默认BORDER_DEFAULT。不支持BORDER_WRAP。
						cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
						cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
						cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
						cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
						cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
						cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
						cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
						cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
						cv::BORDER_ISOLATED = 8 			do not look outside of ROI

2.8.7、可分离滤波器：cv::sepFilter2D()

可分离滤波器：将自定义卷积分离为 x 方向和 y 方向两个独立的 1 维滤波器。

作用：先对X方向进行一维滤波得到一维行向量，再对Y方向进行一维滤波得到一维列向量，然后将两个向量相乘得到一个值并替换卷积核。
效果等同于连续调用两次的filter2D()。

#include <opencv2/imgproc.hpp>
函数说明：void cv::sepFilter2D( InputArray src, OutputArray dst, int ddepth, InputArray kernelX, InputArray kernelY, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT );
输入参数：
				src				输入图像。
				dst				输出与src大小和类型相同的图像。
				ddepth			输出图像深度（使用src.depth()时为-1）。
				kernelX			用于过滤每一行的系数。
				kernelY			用于过滤每一列的系数。
				anchor = Point(-1,-1)			锚点。位于卷积核内；默认值(-1，-1)：表示锚点位于内核中心。
				delta = 0						偏移量，卷积结果要加上这个数字。
				borderType = BORDER_DEFAULT		边界类型（即边界填充方式）。默认BORDER_DEFAULT。不支持BORDER_WRAP。
						cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
						cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
						cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
						cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
						cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
						cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
						cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
						cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
						cv::BORDER_ISOLATED = 8 			do not look outside of ROI

2.8.8、实战案例

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

//using namespace std;
//using namespace cv;

int main(int argc, char* argv[])
{
    //（1）读取图像
    std::string img_path = "test.jpg";
    cv::Mat src = cv::imread(img_path, 1);

    //（2）判断图像是否读取成功
    if (!src.data)
    {
        std::cout << "can't read image!" << std::endl;
        return -1;
    }

    //（3）滤波处理（由于滤波器的边界类型默认为自动填充=1，故滤波前后的尺寸不变。）
    cv::Mat img1, img2, img3, img4, img5, img6, img7;

    cv::blur(src, img1, cv::Size(3, 3));						//均值滤波
    cv::boxFilter(src, img2, src.depth(), cv::Size(3, 3));		//方框滤波
    cv::GaussianBlur(src, img3, cv::Size(3, 3), 0, 0);			//高斯滤波
    cv::medianBlur(src, img4, 3);								//中值滤波
    cv::bilateralFilter(src, img5, 5, 150, 150);				//双边滤波

    cv::Mat kernel = (cv::Mat_<float>(3, 3) << 1, 1, 1, 1, 3, 1, 1, 1, 1) / int(1 + 1 + 1 + 1 + 3 + 1 + 1 + 1 + 1);
    cv::filter2D(src, img6, src.depth(), kernel);				//自定义卷积

    cv::Mat kx = (cv::Mat_<float>(1, 3) << 0, -1, 0);
    cv::Mat ky = (cv::Mat_<float>(1, 3) << -1, 0, -1);
    cv::sepFilter2D(src, img7, src.depth(), kx, ky);			//可分离滤波

    std::cout << "高：" << src.rows << "宽" << src.cols << std::endl;
    std::cout << "高：" << img1.rows << "宽" << img1.cols << std::endl;

    //（4）显示图像
    cv::imshow("src", src);

    cv::imshow("均值", img1);
    cv::imshow("方框", img2);
    cv::imshow("高斯", img3);
    cv::imshow("中值", img4);
    cv::imshow("双边", img5);
    cv::imshow("自定义", img6);
    cv::imshow("可分离", img7);

    cv::waitKey(0);
    return 0;
}

2.9、图像变换

2.9.1、图像缩放：cv::resize()

将图像大小调整为指定的大小。

• 11、若调整src与dst对齐：
  resize(src, dst, dst.size(), 0, 0, interpolation);
• 22、若在输入图像的基础上进行等比例缩放：
  resize(src, dst, Size(), 0.5, 0.5, interpolation);

#include <opencv2/imgproc.hpp>
函数说明：void cv::resize( InputArray src, OutputArray dst, Size dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR )
输入参数：
				src				输入图像：8位无符号、16位无符号（CV_16UC…）或单精度浮点。
				dst				输出图像；大小为dsize（当它为非零时）或根据src.size()、fx和fy计算的大小；dst的类型与src的类型相同。
				dsize			输出图像大小；dsize=None，则计算为：dsize = Size(round(fx*src.cols), round(fy*src.rows))，dsize或fx和fy都必须为非零。
				fx = 0			沿水平轴的缩放比例；当它等于0时，它被计算为：(double)dsize.width/src.cols
				fy = 0			沿垂直轴的缩放比例；当它等于0时，它被计算为：(double)dsize.height/src.rows
				interpolation = INTER_LINEAR	插值方法。
						cv::InterpolationFlags{
								cv::INTER_NEAREST			最近邻插值
								cv::INTER_LINEAR			双线性插值（默认）
								cv::INTER_CUBIC 			双三次插值
								cv::INTER_AREA 				使用像素面积关系进行重新采样。
								cv::INTER_LANCZOS4 			8x8邻域上的Lanczos插值
								cv::INTER_LINEAR_EXACT 		位精确双线性插值
								cv::INTER_NEAREST_EXACT		位精确最近邻插值。这将产生与PIL、scikit图像或Matlab中的最近邻方法相同的结果。
								cv::INTER_MAX 				插值代码掩码
								cv::WARP_FILL_OUTLIERS 		标志，填充所有目的地图像像素。如果其中一些对应于源图像中的异常值，则将其设置为零。
								cv::WARP_INVERSE_MAP 		标志，逆变换
								}

2.9.2、图像翻转：cv::flip()

将二维数组沿着上下翻转、左右翻转或对两个轴同时翻转。

• flipCode = 0：上下翻转图像。
• flipCode > 0：左右翻转图像。
• flipCode < 0：同时上下和左右翻转图像。

#include <opencv2/core.hpp>
函数说明：void cv::flip( InputArray src, OutputArray dst, int flipCode );
输入参数：
				src					输入数组。
				dst					输出数组。与src相同大小和类型。
				flipCode			翻转标志。
							11、0表示绕x轴翻转。
							22、正值(例如1)表示绕y轴翻转。
							33、负值(例如-1)意味着在两个轴上翻转。

2.9.3、图像旋转（计算仿射变换的旋转矩阵）：cv::getRotationMatrix2D()

矩阵计算如下：

#include <opencv2/imgproc.hpp>
函数说明：Mat cv::getRotationMatrix2D( Point2f center, double angle, double scale );
输入参数：
				center				输入图像的旋转中心坐标。一般取图像的中心点，可自定义。
				angle				旋转角度（以度为单位）。正值表示逆时针旋转(坐标原点假定为左上角)。
				scale				各向比例尺度因子。

2.9.4、计算仿射变换的2×3矩阵：cv::getAffineTransform()

#include <opencv2/imgproc.hpp>
函数说明：Mat cv::getAffineTransform( const Point2f src[], const Point2f dst[] );
输入参数：
				src					输入图像中三角形的顶点坐标。
				dst					输出图像中对应三角形的顶点坐标。

2.9.5、计算透视变换的3×3矩阵：cv::getPerspectiveTransform()

#include <opencv2/imgproc.hpp>
函数说明：Mat cv::getPerspectiveTransform( InputArray src, InputArray dst, int solveMethod = DECOMP_LU );
输入参数：
				src					输入图像中四边形的顶点坐标。
				dst					输入图像中对应四边形的顶点坐标。
				solveMethod = DECOMP_LU			解决方法。
								cv::DECOMP_LU 			选择最优的元素进行高斯消除。
								DECOMP_SVD 				奇异值分解法。系统可以是过定义的，并且/或者矩阵src1可以是奇异的
								DECOMP_EIG 				特征值分解。矩阵src1必须是对称的
								DECOMP_CHOLESKY 		Cholesky LLT分解。矩阵src1必须是对称的并且是正定义的
								DECOMP_QR 				QR分解。系统可以是过定义的，并且/或者矩阵src1可以是奇异的
								DECOMP_NORMAL			虽然前面的所有标志都是互斥的，但这个标志可以与前面的任何标志一起使用;这意味着使用通用公式(src1转置*src1*dst=src1转置*src2)，而不是原系统(src1⋅dst=src2)

2.9.6、仿射变换：cv::warpAffine()

• 仿射变换（Affine Transformation）：二维坐标到二维坐标的变换，其本质上就是多种变换的叠加。包括：缩放、平移、旋转、反射。 仿射变换（Affine Transformation）原理及应用

• 仿射的含义：
  （1）共线性：若几个点在一条线上（变换前），则变换后仍然在一条线上。
  （2）平行性：若两条线平行（变换前），则（变换后）仍然平行。
  （3）共线比例不变性：若两条线段成比例（变换前），则（变换后）比例不变。

• 由于仿射特性，变换后仍是平行四边形，故只需要非共线的三个点就能确定。三个坐标点没有固定顺序，但变换前后的矩阵必须是对应的。

矩阵计算如下：（z表示缩放比例因子，z=1表示不进行缩放）（i=0,1,2表示三个顶点）

矩阵变换如下：

#include <opencv2/imgproc.hpp>
函数说明：void cv::warpAffine( InputArray src, OutputArray dst, InputArray M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, const Scalar &borderValue = Scalar() );
输入参数：
				（1）src				输入图像。
				（2）dst				输出图像。输出大小为dsize且类型与src相同的图像。
				（3）M					2×3变换矩阵。2x3是三角形的三个顶点[x, y]。仿射变换只需要三个点，三点即可确定一个平行四边形。
				（4）dsize				输出图像的大小。
				（5）flags = INTER_LINEAR			插值方法。
								cv::INTER_NEAREST			最近邻插值
								cv::INTER_LINEAR			双线性插值（默认）
								cv::INTER_CUBIC 			双三次插值
								cv::INTER_AREA 				使用像素面积关系进行重新采样。
								cv::INTER_LANCZOS4 			8x8邻域上的Lanczos插值
								cv::INTER_LINEAR_EXACT 		位精确双线性插值
								cv::INTER_NEAREST_EXACT		位精确最近邻插值。这将产生与PIL、scikit图像或Matlab中的最近邻方法相同的结果。
								cv::INTER_MAX 				插值代码掩码
								cv::WARP_FILL_OUTLIERS 		标志，填充所有目的地图像像素。如果其中一些对应于源图像中的异常值，则将其设置为零。
								cv::WARP_INVERSE_MAP 		标志，逆变换
						
				（6）borderMode = BORDER_CONSTANT		边界类型（即边界填充方式）。
								cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
								cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
								cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
								cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
								cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
								cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
								cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
								cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
								cv::BORDER_ISOLATED = 8 			do not look outside of ROI
				（7）borderValue = Scalar()				边界值（在边界不变的情况下）。缺省值是0。

2.9.7、透视转换：cv::warpPerspective()

• 透视变换（Perspective Transformation）：将二维图片投影到三维平面上，然后再转换到二维坐标下，所以也称为投影映射（Projective Mapping）。透视变换包括了所有的仿射变换。
• 透视变换相比仿射变换更加灵活，变换后会产生一个新的四边形，但不一定是平行四边形，所以需要非共线的四个点才能确定。四个坐标点没有固定顺序，但变换前后的矩阵必须是对应的。OpenCV4 详解仿射变换和透视变换和C++实现

矩阵计算如下：（z表示缩放比例因子，z=1表示不进行缩放）（i=0,1,2,3表示四个顶点）

矩阵变换如下：二维(x, y) -> 三维(X, Y, Z) -> 二维(x’, y’)

详细过程如下：

#include <opencv2/imgproc.hpp>
函数说明：
void cv::warpPerspective( InputArray src, OutputArray dst, InputArray M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, const Scalar &borderValue = Scalar() );
输入参数：
				（1）src				输入图像。
				（2）dst				输出图像。输出大小为dsize且类型与src相同的图像。
				（3）M					3×3变换矩阵。
				（4）dsize				输出图像的大小。
				（5）flags = INTER_LINEAR			插值方法。
								cv::INTER_NEAREST			最近邻插值
								cv::INTER_LINEAR			双线性插值（默认）
								cv::INTER_CUBIC 			双三次插值
								cv::INTER_AREA 				使用像素面积关系进行重新采样。
								cv::INTER_LANCZOS4 			8x8邻域上的Lanczos插值
								cv::INTER_LINEAR_EXACT 		位精确双线性插值
								cv::INTER_NEAREST_EXACT		位精确最近邻插值。这将产生与PIL、scikit图像或Matlab中的最近邻方法相同的结果。
								cv::INTER_MAX 				插值代码掩码
								cv::WARP_FILL_OUTLIERS 		标志，填充所有目的地图像像素。如果其中一些对应于源图像中的异常值，则将其设置为零。
								cv::WARP_INVERSE_MAP 		标志，逆变换
						
				（6）borderMode = BORDER_CONSTANT		边界类型（即边界填充方式）。
								cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
								cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
								cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
								cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
								cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
								cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
								cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
								cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
								cv::BORDER_ISOLATED = 8 			do not look outside of ROI
				（7）borderValue = Scalar()				边界值（在边界不变的情况下）。缺省值是0。

2.9.8、实战案例

#include<opencv2\opencv.hpp>
#include <string>
//using namespace cv;
//using namespace std;

cv::Mat Rotate(cv::Mat src, int rotate_angle);
cv::Mat Translation(cv::Mat src, int tx, int ty);
cv::Mat WARPAFFINE(cv::Mat src);

int main(int argc,char* argv[])
{
	//（1）读取图像
	std::string img_path1 = "test.jpg";	
	std::string img_path2 = "flower.jpg";
	cv::Mat src = cv::imread(img_path1, 1);				
	cv::Mat src2 = cv::imread(img_path2, 1);		
		
	//（2）判断图像是否读取成功
	if(src.empty() || src2.empty())											
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}
    
    //（3）将（图像2）拉伸与（图像1）相同尺寸。
    if(src.rows != src2.rows || src.cols != src2.cols)
    {
       	std::cout << "src=" << src.rows <<":" << src.cols << std::endl;
    	std::cout << "src2=" << src2.rows <<":" << src2.cols << std::endl;
    	
    	cv::resize(src2, src2, src.size(), 0, 0, cv::INTER_LINEAR);
    	
    	std::cout << "src11=" << src.rows <<":" << src.cols << std::endl;
    	std::cout << "src22=" << src2.rows <<":" << src2.cols << std::endl;
    }
    
    //（4）图像缩放（等比例放大 + 等比例缩小）
    cv::Mat resize_B, resize_S;
	cv::resize(src, resize_B, cv::Size(0, 0), 1, 2, cv::INTER_LINEAR);
	cv::resize(src, resize_S, cv::Size(0, 0), 0.8, 0.8, cv::INTER_LINEAR);
   	std::cout << "resize_B=" << resize_B.rows <<":" << resize_B.cols << std::endl;
   	std::cout << "resize_S=" << resize_S.rows <<":" << resize_S.cols << std::endl;

	//（5）图像翻转
	cv::Mat src_flip;
	cv::flip(src, src_flip, 0);		//	=0：上下翻转	>0：左右翻转	<0：上下和左右同时翻转

   	//（6）图像旋转（封装函数）
	cv::Mat src_rotate;
	src_rotate = Rotate(src, 45);

   	//（7）图像平移（封装函数）
	cv::Mat src_trans;
	src_trans = Translation(src, 20, 50);		

	//（8）仿射变换
	cv::Mat src_wrap;
	cv::Point2f src_xy[3];											//三个点坐标(x,y)，其中x、y是浮点型。
	cv::Point2f dst_xy[3];		
	src_xy[0] = cv::Point2f(0, 0);									//计算输入图像的三点坐标
	src_xy[1] = cv::Point2f(src.cols - 1, 0);
	src_xy[2] = cv::Point2f(0, src.rows - 1);
	dst_xy[0] = cv::Point2f(src.cols*0.0, src.rows*0.33);			//计算输入图像变换后对应的三点坐标
	dst_xy[1] = cv::Point2f(src.cols*0.85, src.rows*0.25);
	dst_xy[2] = cv::Point2f(src.cols*0.15, src.rows*0.7);
	cv::Mat warp_mat = cv::getAffineTransform(src_xy, dst_xy);		//计算仿射变换矩阵
	cv::warpAffine(src, src_wrap, warp_mat, src.size());			//仿射变换	
	//标记坐标点
	cv::Mat src_WW(src);
	for (int i = 0; i < 4; i++)
	{
		circle(src_WW, src_xy[i], 2, cv::Scalar(0, 0, 255), 2);
		circle(src_wrap, dst_xy[i], 2, cv::Scalar(0, 0, 255), 2);
	}
	cv::imshow("src_WW", src_WW);	

	//（9）透视变换
	//11、若输入坐标超过图像尺寸，则显示异常。22、若输入坐标不对应，则显示异常
	cv::Mat src_Pers;
	cv::Point2f scrPoints[4] = { cv::Point2f(0, 0), cv::Point2f(src.cols-1, 0), cv::Point2f(0, src.rows-1), cv::Point2f(src.cols-1, src.rows-1) };
	cv::Point2f dstPoints[4] = { cv::Point2f(0, 0), cv::Point2f(100, 0), cv::Point2f(0, 100), cv::Point2f(150, 120) };
	cv::Mat Trans = cv::getPerspectiveTransform(scrPoints, dstPoints);				//计算透视变换矩阵
	cv::warpPerspective(src, src_Pers, Trans, cv::Size(src.cols, src.rows));		//透视变换
	//标记坐标点
	cv::Mat src_PP(src);
	for (int i = 0; i < 4; i++)
	{
		circle(src_PP, scrPoints[i], 2, cv::Scalar(0, 0, 255), 2);
		circle(src_Pers, dstPoints[i], 2, cv::Scalar(0, 0, 255), 2);
	}
	cv::imshow("src_PP", src_PP);	
	
	//显示图像
	cv::imshow("src", src);					
	cv::imshow("src2", src2);		
	cv::imshow("resize_B", resize_B);		
	cv::imshow("resize_S", resize_S);
	cv::imshow("src_flip", src_flip);
	cv::imshow("src_rotate", src_rotate);
	cv::imshow("src_trans", src_trans);
	cv::imshow("src_wrap", src_wrap);	
	cv::imshow("src_Pers", src_Pers);	
	
	cv::waitKey(0);		//等待用户任意按键后结束暂停功能
	return 0;
}

/*--------------------------------------------------
函数说明：图像平移
--------------------------------------------------
输入参数：	src			输入图像
			tx			x轴平移距离
			ty			y轴平移距离
--------------------------------------------------*/
cv::Mat Translation(cv::Mat src, int tx, int ty)
{
	cv::Mat dst;
	int height = src.cols;		//获取图像的高度
	int width = src.rows;		//获取图像的宽度
	// 使用tx和ty创建平移矩阵
	float warp_values[] = { 1.0, 0.0, tx, 0.0, 1.0, ty };
	cv::Mat translation_matrix = cv::Mat(2, 3, CV_32F, warp_values);
	// 基于平移矩阵进行仿射变换
	cv::warpAffine(src, dst, translation_matrix, src.size());

	return dst;
}

/*--------------------------------------------------
函数说明：图像旋转
--------------------------------------------------
输入参数：	src			输入图像
			angle		旋转角度
--------------------------------------------------*/
cv::Mat Rotate(cv::Mat src, int angle)
{
	cv::Mat dst;
	int wight = src.cols;
	int height = src.rows;
	//获取旋转矩阵
	cv::Mat Matrix = cv::getRotationMatrix2D(cv::Point2f(wight / 2, height / 2), angle, 1.0);
	
	//获取旋转后图像的尺寸
	double cos = abs(Matrix.at<double>(0, 0));
	double sin = abs(Matrix.at<double>(0, 1));
	int nw = cos * wight + sin * height;
	int nh = sin * wight + cos * height;
	//获取x, y方向的偏移量
	Matrix.at<double>(0, 2) += (nw / 2 - wight / 2);
	Matrix.at<double>(1, 2) += (nh / 2 - height / 2);
	//基于旋转矩阵进行仿射变换
	cv::warpAffine(src, dst, Matrix, cv::Size(nh, nw));
	
	return dst;
}

2.10、形态学操作

opencv c++ 图像形态学变化

2.10.1、腐蚀：cv::erode()

腐蚀可以应用多次（迭代）。在多通道图像的情况下，每个通道都是独立处理的。若需要将不同的卷积核应用于不同的通道，可使用cv::split。

#include <opencv2/imgproc.hpp>
函数说明：void cv::erode( InputArray src, OutputArray dst, InputArray kernel, Point anchor = Point(-1,-1), int iterations = 1, int 	borderType = BORDER_CONSTANT, const Scalar &borderValue = morphologyDefaultBorderValue() );	
输入参数：
				src									输入图像；通道的数量可以是任意的，这些通道是独立处理的，但深度应该是CV_8U、CV_16U、CV_16S、CV_32F或CV_64F中的一个。
				dst									输出与src大小和类型相同的图像。
				kernel								卷积核大小（单通道浮点矩阵）。如果element=Mat()，则使用一个3x3矩形结构化元素。内核可以使用getStructureElement创建。
				anchor = Point(-1,-1)				锚点。位于卷积核内；默认值(-1，-1)：表示锚点位于内核中心。
				iterations = 1						腐蚀迭代次数（默认1）。迭代N次与连续调用N次的效果是不等同的。
				borderType = BORDER_CONSTANT		边界类型（即边界填充方式）。默认BORDER_CONSTANT。不支持BORDER_WRAP。
									cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
									cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
									cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
									cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
									cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
									cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
									cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
									cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
									cv::BORDER_ISOLATED = 8 			do not look outside of ROI
				borderValue = morphologyDefaultBorderValue() 		边界值（在边界不变的情况下）

2.10.2、膨胀：cv::dilate()

膨胀可以应用多次（迭代）。在多通道图像的情况下，每个通道都是独立处理的。若需要将不同的卷积核应用于不同的通道，可使用cv::split。

#include <opencv2/imgproc.hpp>
函数说明：void cv::dilate( InputArray src, OutputArray dst, InputArray kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, const Scalar &borderValue = morphologyDefaultBorderValue() );	
输入参数：
				src									输入图像；通道的数量可以是任意的，这些通道是独立处理的，但深度应该是CV_8U、CV_16U、CV_16S、CV_32F或CV_64F中的一个。
				dst									输出与src大小和类型相同的图像。
				kernel								卷积核大小（单通道浮点矩阵）。如果element=Mat()，则使用一个3x3矩形结构化元素。内核可以使用getStructureElement创建。
				anchor = Point(-1,-1)				锚点。位于卷积核内；默认值(-1，-1)：表示锚点位于内核中心。
				iterations = 1						膨胀迭代次数（默认1）。迭代N次与连续调用N次的效果是不等同的。
				borderType = BORDER_CONSTANT		边界类型（即边界填充方式）。默认BORDER_CONSTANT。不支持BORDER_WRAP。
									cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
									cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
									cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
									cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
									cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
									cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
									cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
									cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
									cv::BORDER_ISOLATED = 8 			do not look outside of ROI
				borderValue = morphologyDefaultBorderValue() 		边界值（在边界不变的情况下）

2.10.3、形态学变化：cv::morphologyEx()。（腐蚀、膨胀、开运算、闭运算、顶帽、黑帽、基本梯度、击中击不中）

膨胀可以应用多次（迭代）。在多通道图像的情况下，每个通道都是独立处理的。若需要将不同的卷积核应用于不同的通道，可使用cv::split。

#include <opencv2/imgproc.hpp>
函数说明：void cv::morphologyEx( InputArray src, OutputArray dst, int op, InputArray kernel, Point anchor = Point(-1,-1), int 	iterations = 1, int borderType = BORDER_CONSTANT, const Scalar &borderValue = morphologyDefaultBorderValue() );
输入参数：
				src									输入图像；通道的数量可以是任意的，这些通道是独立处理的，但深度应该是CV_8U、CV_16U、CV_16S、CV_32F或CV_64F中的一个。
				dst									输出与src大小和类型相同的图像。
				op									形态学运算的类型。
									cv::MORPH_ERODE = 0			腐蚀操作
									cv::MORPH_DILATE = 1		膨胀操作
									cv::MORPH_OPEN = 2			开运算：先腐蚀再膨胀。用于去除微小干扰点/块。
									cv::MORPH_CLOSE = 3			闭运算：先膨胀再腐蚀。用于填充闭合区域。
									cv::MORPH_GRADIENT = 4		基本梯度：膨胀图（减去）腐蚀图
									cv::MORPH_TOPHAT = 5		顶帽：原图（减去）开运算图。注：顶帽和黑帽用于获取图像中的微小细节。
									cv::MORPH_BLACKHAT = 6		黑帽：闭运算图（减去）原图
									cv::MORPH_HITMISS = 7		“命中或未命中”。仅支持CV_8UC1二进制图像。
				kernel								卷积核大小（单通道浮点矩阵）。如果element=Mat()，则使用一个3x3矩形结构化元素。内核可以使用getStructureElement创建。
				anchor = Point(-1,-1)				锚点。位于卷积核内；默认值(-1，-1)：表示锚点位于内核中心。
				iterations = 1						腐蚀和膨胀的迭代次数（默认1）。两次迭代的顺序：侵蚀+侵蚀+扩张+扩张（而不是侵蚀+扩张+侵蚀+扩张）。
				borderType = BORDER_CONSTANT		边界类型（即边界填充方式）。默认BORDER_CONSTANT。不支持BORDER_WRAP。
									cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
									cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
									cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
									cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
									cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
									cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
									cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
									cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
									cv::BORDER_ISOLATED = 8 			do not look outside of ROI
				borderValue = morphologyDefaultBorderValue() 		边界值（在边界不变的情况下）

2.10.4、获取指定大小和形状的结构化元素：cv::getStructuringElement()

构造并返回可以进一步传递以腐蚀、膨胀或形态Ex的结构化元素。也可以自己构造任意的二进制掩码，并将其用作结构化元素。

#include <opencv2/imgproc.hpp>
函数说明：Mat cv::getStructuringElement( int shape, Size ksize, Point anchor = Point(-1,-1) );	
输入参数：
				shape				结构化元素的形状。
						cv::MORPH_RECT = 0 			矩形结构化元素：E(i,j)=1
						cv::MORPH_CROSS	= 1			十字形结构元素：E(i,j)=10 if i=anchor.y or j=anchor.x else 0
						cv::MORPH_ELLIPSE = 2		椭圆形结构元素：即内切到矩形Rect(0, 0, esize.width, 0.esize.height)中的填充椭圆。
				ksize				结构化元素的大小。
				anchor				锚点。默认值(−1，−1)表示锚点位于中心。注意，只有十字形元件的形状取决于锚定位置。在其他情况下，锚点只是调节形态学运算的结果偏移了多少。

2.10.5、实战案例：提取水平线与垂直线

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

//using namespace std;
//using namespace cv;

int main(int argc, char* argv[])
{
	//（1）读取图像
	std::string img_path = "test.jpg";
	cv::Mat src = cv::imread(img_path, 1);

	//（2）判断图像是否读取成功
	if (!src.data)
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}

	//（3）灰度化+二值化
	cv::Mat gray, binary;
	cv::cvtColor(src, gray, cv::COLOR_BGR2GRAY);
	cv::threshold(gray, binary, 0, 255, cv::THRESH_BINARY_INV | cv::THRESH_OTSU);


	//（4）形态学变化
	cv::Mat img_h, img_v;
	int x_size = binary.cols / 30;			//像素的水平长度=width/30
	int y_size = binary.rows / 30;			//像素的垂直长度=height/30
	cv::Mat h_line = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(x_size, 1), cv::Point(-1, -1));
	cv::Mat v_line = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(1, y_size), cv::Point(-1, -1));
	cv::morphologyEx(binary, img_h, cv::MORPH_OPEN, h_line , cv::Point(-1, -1), 1, 0);			//开运算（提取水平线）
	cv::morphologyEx(binary, img_v, cv::MORPH_CLOSE, v_line, cv::Point(-1, -1), 1, 0);			//闭运算（提取垂直线）

	//（4）显示图像
	cv::imshow("binary", binary);
	cv::imshow("img_h", img_h);
	cv::imshow("img_v", img_v);

	cv::waitKey(0);
	return 0;
}

2.10.6、实战案例

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

//using namespace std;
//using namespace cv;

int main(int argc, char* argv[])
{
	//（1）读取图像
	std::string img_path = "test.jpg";
	cv::Mat src = cv::imread(img_path, 1);

	//（2）判断图像是否读取成功
	if (!src.data)
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}

	//（3）灰度化+二值化
	cv::Mat gray, binary;
	cv::cvtColor(src, gray, cv::COLOR_BGR2GRAY);
	cv::threshold(gray, binary, 0, 255, cv::THRESH_BINARY_INV | cv::THRESH_OTSU);


	//（4）形态学变化
	int kernel_size = 5;
	//getStructuringElement：返回指定大小和形状的结构化元素以进行形态学运算。
	cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(kernel_size, kernel_size), cv::Point(-1, -1));

	cv::Mat img1, img2, img3, img4;
	cv::erode(binary, img1, kernel);							//腐蚀
	cv::erode(binary, img2, kernel, cv::Point(-1, -1), 3);		//腐蚀（迭代三次）
	cv::dilate(binary, img3, kernel);							//膨胀
	cv::dilate(binary, img4, kernel, cv::Point(-1, -1), 3);		//膨胀（迭代三次）

	cv::Mat img11, img22, img33, img44, img55, img66, img77, img88;
	cv::morphologyEx(binary, img11, cv::MORPH_ERODE, kernel, cv::Point(-1, -1), 1, 0);			//腐蚀
	cv::morphologyEx(binary, img22, cv::MORPH_DILATE, kernel, cv::Point(-1, -1), 1, 0);			//膨胀
	cv::morphologyEx(binary, img33, cv::MORPH_OPEN, kernel, cv::Point(-1, -1), 1, 0);			//开运算
	cv::morphologyEx(binary, img44, cv::MORPH_CLOSE, kernel, cv::Point(-1, -1), 1, 0);			//闭运算

	cv::morphologyEx(binary, img55, cv::MORPH_GRADIENT, kernel, cv::Point(-1, -1), 1, 0);		//基本梯度
	cv::morphologyEx(binary, img66, cv::MORPH_TOPHAT, kernel, cv::Point(-1, -1), 1, 0);			//顶帽
	cv::morphologyEx(binary, img77, cv::MORPH_BLACKHAT, kernel, cv::Point(-1, -1), 1, 0);		//黑帽
	cv::morphologyEx(binary, img88, cv::MORPH_HITMISS, kernel, cv::Point(-1, -1), 1, 0);		//击中击不中

	//（4）显示图像
	cv::imshow("src", src);

	cv::imshow("腐蚀1", img1);
	cv::imshow("腐蚀3", img2);
	cv::imshow("膨胀1", img3);
	cv::imshow("膨胀3", img4);

	cv::imshow("腐蚀", img11);
	cv::imshow("膨胀", img22);
	cv::imshow("开运算", img33);
	cv::imshow("闭运算", img44);
	cv::imshow("基本梯度", img55);
	cv::imshow("顶帽", img66);
	cv::imshow("黑帽", img77);
	cv::imshow("击中击不中", img88);

	cv::waitKey(0);
	return 0;
}

2.11、图像金字塔

• 图像金字塔由多个分辨率的一组图像组成，最底层是图像尺寸最大的一张，最顶层是图像尺寸最小的一张。从空间上由上向下看，就像古埃及的金字塔。
• 在图像处理中常需要调整图像大小，尽管几何变换也可以实现图像放大（zoom in）和缩小（zoom out），但图像金字塔在神经网络中更常见且方便快捷。

高斯不同（Difference of Gaussian，DOG）

• 定义：将同一张图像在不同的参数下做高斯模糊之后的结果相减，得到输出图像。
• 应用：高斯不同是图像的内在特征。常用于灰度图像增强，角点检测。

• 高斯金字塔：通过高斯滤波和下采样不断地将图像的尺寸缩小。
• 拉普拉斯金字塔：在高斯金字塔的基础上，为了实现图像重建而存在。

由图可得，第n层拉普拉斯图像实际上是第n层高斯图像与第n+1层高斯图像经上采样后的差值。
由于高斯滤波器是一种低通滤波器，所以我们可以说某一级的拉普拉斯金字塔可以反映出其同级的高斯金字塔的高频分量。图像金字塔、高斯金字塔、拉普拉斯金字塔是怎么回事？

2.11.1、降采样：cv::pyrDown()

• 作用：通过高斯卷积使图像模糊，并对其进行下采样。（宽高各缩小一倍）
• 尺寸：默认情况下，输出图像的大小计算为size=((src.cols+1)/2，(src.rows+1)/2)。

该函数执行高斯金字塔构造的下采样步骤：将源图像与高斯卷积核进行卷积（模糊化），然后删除偶数行和偶数列来对图像进行下采样。

• 提问：为什么高斯金字塔在下采样操作之前要先进行高斯低通滤波？
• 回答：可以保留高斯金字塔低通滤波特点，且能对图像进行平滑，使下采样得到的图像不会出现边界缝隙。

pyrDown使用的高斯核如下：

#include <opencv2/imgproc.hpp>
函数说明：void cv::pyrDown( InputArray src, OutputArray dst, const Size &dstsize = Size(), int borderType = BORDER_DEFAULT);
输入参数：
				src					输入图像。
				dst					输出图像。它具有指定的大小、且与src具有相同的类型。
				dstsize				输出图像的大小。
				borderType = BORDER_DEFAULT		边界类型（即边界填充方式）。默认且只支持BORDER_DEFAULT。
							cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
							cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101

2.11.2、上采样：cv::pyrUp()

• 作用：对图像进行上采样，然后通过高斯卷积使其模糊。（宽高各放大一倍）
• 尺寸：默认情况下，输出图像的大小计算为size=(src.cols*2，src.rows*2)。

该函数执行高斯金字塔构造的上采样步骤：通过均匀地隔行隔列的方式，填充全零行和全零列来对源图像进行上采样，然后将结果与（cv::pyrDown的相同高斯卷积核乘以4）进行卷积（模糊化）。

pyrDown使用的高斯核如下：

#include <opencv2/imgproc.hpp>
函数说明：void cv::pyrUp( InputArray src, OutputArray dst, const Size &dstsize = Size(), int borderType = BORDER_DEFAULT);
输入参数：
				src					输入图像。
				dst					输出图像。它具有指定的大小、且与src具有相同的类型。
				dstsize				输出图像的大小。
				borderType = BORDER_DEFAULT		边界类型（即边界填充方式）。默认且只支持BORDER_DEFAULT。
							cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
							cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101

2.11.3、实战案例

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

//using namespace std;
//using namespace cv;

int main(int argc, char* argv[])
{
	//（1）读取图像
	std::string img_path = "test.jpg";
	cv::Mat src = cv::imread(img_path, 1);

	//（2）判断图像是否读取成功
	if (!src.data)
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}

	//（3）图像金字塔
	cv::Mat img_up, img_down;
	cv::pyrUp(src, img_up, cv::Size(src.cols * 2, src.rows * 2));			//上采样
	cv::pyrDown(src, img_down, cv::Size(src.cols / 2, src.rows / 2));		//降采样
	
	//（4）显示图像
	cv::imshow("src", src);
	cv::imshow("img_up", img_up);
	cv::imshow("img_down", img_down);

	cv::waitKey(0);
	return 0;
}

2.12、边缘检测（基于灰度图提取边缘特征）

边缘检测技术：利用灰度的变化信息来检测物体的边缘，进而得到物体轮廓，实现图像分割。

边缘特征（Edge）：图像中的像素值发生跃迁的地方，此时图像的局部特征出现不连续性。主要变现在灰度值突变、颜色突变、纹理结构突变等等。如：黑色到白色的突变。

• 图(a)是理想边缘模型：每个灰度级跃变到一个垂直的台阶上。
• 图(b)是实际边缘模型：在实际的数据采集中，图像的质量受到多因素的印象（如：设备性能、采样率、照明条件等），因此得到的边缘特征往往是模糊的，进而导致模糊的边缘" 呈斜面 “，而清晰的边缘变” 窄 "。

图像的边缘有两种属性：方向和幅度。边缘特征通常采用一阶导数或二阶导数检测得到。

• 一阶导数：以极大值或极小值作为对应边缘的位置。用于检测一个点是不是边缘点；导数值越大，说明像素在该方向变化越大，边缘信号越强。
• 二阶导数：以过零点作为对应边缘的位置。用于判断一个边缘点是在边缘亮的一边还是暗的一边。

备注：边缘检测主要基于导数计算，但导数通常对噪声很敏感。故需要在边缘检测之前，采用形态学变化、高斯滤波、阈值化等进行前处理。

边缘检测算子的分类

• （1）一阶导数的边缘算子：Sobel算子、Scharr算子、Roberts算子、Prewitt算子。后两种在Opencv中不支持，想要研究的可参考Python版本
• （2）二阶导数的边缘算子：Laplacian算子。
• （3）非导数的边缘算子：Canny算子。

边缘检测算子的优缺点（最常用Sobel算子、Laplacian算子Canny算子）

• （1）Roberts 算子：对具有陡峭边缘且含噪声少的图像效果较好，尤其是边缘正负45度较多的图像，但定位准确率较差导致丢失一部分边缘，不具备抑制噪声能力。
• （2）Sobel 算子：对噪声较多的图像效果更好，边缘定位效果不错，但检测出的边缘容易出现多像素宽度。
• （3）Scharr算子：Sobel算子的改进版，可以j解决Sobel算子在3×3的检测效果不好的问题。两种算子在实现方式上类似。
• （4）Prewitt 算子：对灰度渐变的图像效果较好，但没有考虑相邻点的距离远近对当前像素点的影响，与Sobel 算子类似，不同的是在平滑部分的权重大小有些差异；
• （5）Laplacian 算子：对图像中的阶跃型边缘点定位准确，但对噪声非常敏感，会丢失一部分边缘，造成一些不连续的检测边缘。因此很少用于边缘检测，常用于判断边缘是明区还是暗区（黑与白），提供更加清晰锐利的边缘效果。
• （6）Canny 算子：不容易受噪声干扰，通过双边阈值检测和边缘连接能够很好地检测弱边缘。比前几种效果好，但实现较为复杂。

2.12.1、sobel算子：cv::Sobel()

又被称为一阶微分算子。

• 作用：将图像与sobel卷积核进行卷积运算。分别在水平x与垂直y方向上进行一阶求导，得到对应的梯度图像。
• 原理：根据当前像素点上、下、左、右4个相邻点的灰度加权差，在边缘处达到极值进而检测边缘。其认为相邻点的距离远近对当前像素点的影响是不同的，距离越近的像素点对应当前像素的影响越大，从而实现图像锐化并突出边缘轮廓。
• 特点：结合了高斯平滑和微分求导（分化），因此具有一定的抗噪性，但所得边缘较粗。
• 应用：常用于噪声较多、灰度渐变的图像。当对精度要求不是很高时，Sobel算子是一种较为常用的边缘检测方法。

使用sobel算子获取边缘信息的两种不同的调用方式：

• 方式1：只调用一次sobel算子，即同时设置(dx=1,dy=1)，获取图像在两个方向上的梯度。
• 方式2：分别调用两次sobel算子，并分别设置为(dx=1,dy=0)、(dx=0,dy=1)，即分别计算图像在水平方向和垂直方向的边缘信息。最后通过图像融合cv::addWeighted()得到两个方向的边缘信息。

一般采用方式2，边缘信息提取效果更好。

目标像素点求得的值小于0或大于255怎么办？

• 正值负值：白到黑是正数（255 ~ 0），黑到白就是负数（0 ~ 255）。
• OpenCV 默认采用截断操作（即小于0，置0；大于255，置255）。但不适用于边缘检测，故需要通过cv::convertScaleAbs取绝对值（即小于0，取绝对值；大于255，置255）。

#include <opencv2/imgproc.hpp>
函数说明：void cv::Sobel( InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT );
输入参数：
				src					输入图像。
				dst					与src具有相同大小和相同通道数的输出图像。
				ddepth				输出图像深度（使用src.depth()时为-1）。
				dx					x方向的求导阶数。一般为0,1,2。其中，0表示该方向没有求导。
				dy					y方向的求导阶数。一般为0,1,2。其中，0表示该方向没有求导。
				ksize = 3			卷积核大小。一般为1、3、5或7。
				scale = 1			计算导数值的可选比例因子；默认1，即不应用缩放。
				delta = 0			偏移量，卷积结果要加上这个数字。
				borderType = BORDER_DEFAULT		边界类型（即边界填充方式）。默认BORDER_DEFAULT。不支持BORDER_WRAP。
							cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
							cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
							cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
							cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
							cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
							cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
							cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
							cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
							cv::BORDER_ISOLATED = 8 			do not look outside of ROI

2.12.2、Scharr算子：cv::Scharr()

• 作用：将图像与Scharr卷积核进行卷积运算。分别在水平x与垂直y方向上进行一阶求导，得到对应的梯度图像。

#include <opencv2/imgproc.hpp>
函数说明：void cv::Scharr( InputArray src, OutputArray dst, int ddepth, int dx, int dy, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT );
输入参数：
				src					输入图像。
				dst					与src具有相同大小和相同通道数的输出图像。
				ddepth				输出图像深度（使用src.depth()时为-1）。
				dx					x方向的求导阶数。一般为0,1,2。其中，0表示该方向没有求导。
				dy					y方向的求导阶数。一般为0,1,2。其中，0表示该方向没有求导。
				ksize = 3			卷积核大小。它必须是1、3、5或7。
				scale = 1			计算导数值的可选比例因子；默认1，即不应用缩放。
				delta = 0			偏移量，卷积结果要加上这个数字。
				borderType = BORDER_DEFAULT		边界类型（即边界填充方式）。默认BORDER_DEFAULT。不支持BORDER_WRAP。
							cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
							cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
							cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
							cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
							cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
							cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
							cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
							cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
							cv::BORDER_ISOLATED = 8 			do not look outside of ROI

2.12.3、拉普拉斯算子：cv::Laplacian()

又被称为二阶微分算子

• 作用：将图像与Laplacian卷积核进行卷积运算。即分别对x和y方向上进行二次求导，然后相加。
• 本质：计算图像中心像素与其在上、下、左、右4个相邻点的灰度差值。其具有旋转不变性。
• 应用：拉普拉斯算子的检测性能较好，常用于图像增强领域和边缘提取。
  

#include <opencv2/imgproc.hpp>
函数说明：void cv::Laplacian( InputArray src, OutputArray dst, int ddepth, int ksize = 1, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT );
输入参数：
				src					输入图像。
				dst					与src具有相同大小和相同通道数的输出图像。
				ddepth				输出图像深度（使用src.depth()时为-1）。
				ksize = 1			卷积核大小。它必须是1、3、5或7。
				scale = 1			计算导数值的可选比例因子；默认1，即不应用缩放。
				delta = 0			偏移量，卷积结果要加上这个数字。
				borderType = BORDER_DEFAULT		边界类型（即边界填充方式）。默认BORDER_DEFAULT。不支持BORDER_WRAP。
							cv::BORDER_CONSTANT = 0 			iiiiii|abcdefgh|iiiiiii			常量法。填充常数值
							cv::BORDER_REPLICATE = 1 			aaaaaa|abcdefgh|hhhhhhh			复制法。复制最边缘像素
							cv::BORDER_REFLECT  = 2 			fedcba|abcdefgh|hgfedcb			反射法。以两边为轴
							cv::BORDER_WRAP = 3 				cdefgh|abcdefgh|abcdefg			外包装法。
							cv::BORDER_REFLECT_101 = 4 			gfedcb|abcdefgh|gfedcba			反射法。以最边缘像素为轴
							cv::BORDER_TRANSPARENT = 5 			uvwxyz|abcdefgh|ijklmno
							cv::BORDER_REFLECT101 = 6 			same as BORDER_REFLECT_101
							cv::BORDER_DEFAULT = 7 				same as BORDER_REFLECT_101
							cv::BORDER_ISOLATED = 8 			do not look outside of ROI

2.12.4、Canny算子：cv::Canny()

canny边缘检测算法步骤：

• 1、使用高斯滤波器对图像进行平滑处理。
• 2、利用一阶偏导算子找到灰度图像沿着水平方向Gx和垂直方向Gy的偏导数，并计算梯度的幅值和方向。
• 3、对梯度幅值进行NMS非极大值抑制，获取局部梯度的最大值。
  在3X3窗口中，将给定像素P与沿着梯度线方向的两个像素进行比较，若P的梯度幅值小于该两个像素的梯度幅值，则令P=0；否则保留原幅值。
  备注：将梯度方向分为4种来比较梯度幅值的强度：水平方向、垂直方向、正方向、-45°方向。
• 4、用双边阈值检测和边缘连接。
  分三种情况：
  （1）若像素值大于高阈值，则该像素一定是边缘像素（强边缘点），置为255；
  （2）若小于低阈值，则一定不是，置为0；
  （3）若像素值大于低阈值但小于高阈值，则观察该像素的（3X3）8邻域像素中是否有大于高阈值的像素点，若有则该像素是边缘像素，并将该点置为255，用以连接强边缘点；否则不是，则该点置为0。

#include <opencv2/imgproc.hpp>
函数说明：void cv::Canny	( InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize = 3, bool L2gradient = false );
输入参数：
				image						8位输入图像。
				edges						输出图像。其具有与输入图像相同大小和类型。
				threshold1					第一个阈值（低阈值）。
				threshold2					第二个阈值（高阈值）。
				apertureSize = 3			Sobel算子孔径尺寸 。默认为3。可以是1、3、5、7
				L2gradient = false			选择L1 or L2范数计算图像梯度大小。
									(L2graduation=false)默认L1范数=|dI/dx|+|dI/dy|。
									(L2gradient=true)L2范数= (dI/dx)^2 + (dI/dy)^2。
									
注释：	高阈值比较严格，求的边缘很少，一般认为高阈值的边缘都是有效。
		低阈值比较宽松，求的边缘很多（一般包括高阈值求到的边缘），其中不少是无效的边缘。
	
Canny求得的边缘希望是连在一起的（通常是封闭的）
（1）先用高阈值将要提取轮廓的物体与背景区分开来，但可能边缘轮廓不连续或者不够平滑。
（2）然后低阈值平滑边缘的轮廓，将不连续的部分连接起来。

2.12.5、实战案例

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

//using namespace std;
//using namespace cv;

int main(int argc, char* argv[])
{
	//（1）读取图像
	std::string img_path = "test.jpg";
	cv::Mat src = cv::imread(img_path, 1);

	//（2）判断图像是否读取成功
	if (!src.data)
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}

	//（3）图像预处理
	cv::Mat src_Gray, src_Gaus;
	cv::GaussianBlur(src, src_Gaus, cv::Size(3, 3), 0, 0);		//高斯滤波
	cv::cvtColor(src, src_Gray, cv::COLOR_BGR2GRAY);			//灰度化

	//（4）边缘检测
	cv::Mat Sobel_X, Sobel_Y, Sobel_X_abs, Sobel_Y_abs, Sobel_XY, Sobel_XY1;
	cv::Sobel(src_Gray, Sobel_X, src_Gray.depth(), 1, 0);					//计算 x 轴方向
	cv::Sobel(src_Gray, Sobel_Y, src_Gray.depth(), 0, 1);					//计算 y 轴方向
	cv::convertScaleAbs(Sobel_X, Sobel_X_abs);								//取绝对值
	cv::convertScaleAbs(Sobel_Y, Sobel_Y_abs);								//取绝对值
	cv::addWeighted(Sobel_X_abs, 0.5, Sobel_Y_abs, 0.5, 0, Sobel_XY);		//图像融合
	cv::Sobel(src_Gray, Sobel_XY1, src_Gray.depth(), 1, 1);					//同时计算 x和y 轴方向
	
	cv::Mat Scharr_X, Scharr_Y, Scharr_X_abs, Scharr_Y_abs, Scharr_XY, Scharr_XY1; 
	cv::Scharr(src_Gray, Scharr_X, src_Gray.depth(), 1, 0);					//计算 x 轴方向
	cv::Scharr(src_Gray, Scharr_Y, src_Gray.depth(), 0, 1);					//计算 y 轴方向
	cv::convertScaleAbs(Scharr_X, Scharr_X_abs);							//取绝对值
	cv::convertScaleAbs(Scharr_Y, Scharr_Y_abs);							//取绝对值
	cv::addWeighted(Scharr_X_abs, 0.5, Scharr_Y_abs, 0.5, 0, Scharr_XY);	//图像融合
	//cv::Scharr(src_Gray, Scharr_XY1, src_Gray.depth(), 1, 1);				//同时计算 x和y 轴方向

	cv::Mat src_Laplacian, src_Canny;
	cv::Laplacian(src_Gray, src_Laplacian, src_Gray.depth());		
	cv::Canny(src_Gray, src_Canny, 10, 100);

	//（5）显示图像
	cv::imshow("src", src);
	//cv::imshow("Sobel_X", Sobel_X);
	//cv::imshow("Sobel_Y", Sobel_Y);	
	//cv::imshow("Sobel_X_abs", Sobel_X_abs);
	//cv::imshow("Sobel_Y_abs", Sobel_Y_abs);	
	cv::imshow("Sobel_XY", Sobel_XY);
	//cv::imshow("Sobel_XY1", Sobel_XY1);
	
	//cv::imshow("Scharr_X", Scharr_X);
	//cv::imshow("Scharr_Y", Scharr_Y);
	//cv::imshow("Scharr_X_abs", Scharr_X_abs);
	//cv::imshow("Scharr_Y_abs", Scharr_Y_abs);	
	cv::imshow("Scharr_XY", Scharr_XY);
	//cv::imshow("Scharr_XY1", Scharr_XY1);
	
	cv::imshow("src_Laplacian", src_Laplacian);
	cv::imshow("src_Canny", src_Canny);
	
	cv::waitKey(0);
	return 0;
}

2.13、轮廓检测（基于二值化提取轮廓特征）

2.13.1、提取轮廓：cv::findContours()

在(0, 1)二进制图像中提取轮廓。轮廓是用于形状分析、物体检测和识别的显著特征。

#include <opencv2/imgproc.hpp>
函数说明：void cv::findContours( InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset = Point() );
输入参数：
				（1）image				输入图像。8位单通道图像。二进制图像：非零像素被视为1，零像素保持为0。
				（2）contours			所有的轮廓点。每个轮廓都存储为点的矢量，例如：std::vector<std::vector<cv::Point>>
				（3）hierarchy			每个轮廓对应的属性。主要是图像的拓扑信息。其与轮廓点具有相同数量。
											00、使用[0][i]访问第i个轮廓的层次结构元素。
											11、对于第i个轮廓的每个元素hierarch[i][0]、hierarch[i][1]、hierarch[i][2]和hierarch[i][3]
											22、分别被设置为相同层次结构的下一个轮廓、前一个轮廓、第一个子轮廓、第一个父轮廓。
											33、若没有对应的轮廓，则层次结构[i]的相应元素将为负。
				（4）mode				轮廓检索模式。
								cv::RETR_EXTERNAL = 0		只检索最外部的轮廓。它为所有轮廓设置层次结构[i][2]=hierarchy[i][3]=-1。
								cv::RETR_LIST = 1 			检索所有轮廓。不建立任何层次关系
								cv::RETR_CCOMP = 2 			检索所有轮廓。并建立两个等级的层次结构：顶层是外部边界。内层是边界信息。
								cv::RETR_TREE = 3 			检索所有轮廓。并建立一个等级树的完整层次结构。（最常用）
								cv::RETR_FLOODFILL = 4 		官网没有说明。
				（5）method				轮廓近似方法。
								cv::CHAIN_APPROX_NONE = 0 			存储所有的轮廓点。	例如：矩形的四条边（最常用）。	相邻2个轮廓点的位置差不超过1（连成线）。
								cv::CHAIN_APPROX_SIMPLE = 1 		只保留端点坐标。	例如：矩形的四个角。			压缩水平、垂直、对角线方向的元素。
								cv::CHAIN_APPROX_TC89_L1 = 2 		应用Teh-Chin链近似算法的一种风格
								cv::CHAIN_APPROX_TC89_KCOS = 3 		应用Teh-Chin链近似算法的一种风格
				（6）offset = Point()	每个轮廓点移动的可选偏移量。若需要从图像ROI中提取轮廓，可以在整个图像的上下文中对其进行分析。

2.13.2、绘制轮廓：cv::drawContours()

绘制轮廓线或填充轮廓。如果轮廓线厚度 ≥ 0，该函数将在图像中绘制轮廓；如果厚度＜0，则该函数将填充由轮廓限定的区域。

#include <opencv2/imgproc.hpp>
函数说明：void cv::drawContours( InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar &color, int thickness = 1, int lineType = LINE_8, InputArray hierarchy = noArray(), int maxLevel = INT_MAX, Point offset = Point() );
输入参数：
				（1）image						目标图像。
				（2）contours					所有输入轮廓。每个轮廓都存储为一个点向量。
				（3）contourIdx					指示要绘制的轮廓的参数。如果为-1，则绘制所有轮廓。
				（4）color						颜色。
				（5）thickness = 1				线厚度。如果为负值（例如，厚度=FILLED），则绘制轮廓内部。
				（6）lineType = LINE_8			线的类型。
										cv::FILLED 			填充。当线厚度为负值时使用
										cv::LINE_4 			4连接线型
										cv::LINE_8 			8连接线型
										cv::LINE_AA 		抗锯齿线
				（7）hierarchy = noArray()		层次结构的可选信息。只有当您只想绘制一些轮廓时才需要它（请参见maxLevel）。
				（8）maxLevel = INT_MAX			绘制轮廓的最大水平。
										00、只有当有可用的层次结构时，才会考虑此参数。
										11、如果为0，则仅绘制指定的轮廓。
										22、如果为1，函数将绘制轮廓和所有嵌套的轮廓。
										33、如果为2，则函数绘制轮廓、所有嵌套的轮廓、所有从嵌套到嵌套的轮廓等。
							
				（9）offset = Point()			可选轮廓偏移参数。将所有绘制的轮廓移动指定的偏移量=(dx, dy)。

2.13.3、曲线轮廓

（1）计算曲线长度或闭合轮廓周长：cv::arcLength()

#include <opencv2/imgproc.hpp>
函数说明：double cv::arcLength(InputArray curve, bool closed );
输入参数：		curve				输入2D点集，存储在std::vector或Mat中。
				closed				指示曲线是否闭合的标志
				
返回值：		epsilon				原始曲线与近似曲线的距离。可以将epsilon乘以系数k=[0,1]，控制近似曲线的形状。其中，1表示真实轮廓，值越大拟合越粗糙。

（2）计算与原始曲线最大距离的近似曲线的坐标：cv::approxPolyDP()

将一条曲线或一个多边形与另一条顶点较少的曲线/多边形进行近似，使它们之间的距离小于或等于指定的精度。

#include <opencv2/imgproc.hpp>
函数说明：void cv::approxPolyDP( InputArray curve, OutputArray approxCurve, double epsilon, bool closed );
输入参数：
				（1）curve				输入2D点集，存储在std::vector或Mat中。
				（2）approxCurve		输出近似曲线的点集坐标。
				（3）epsilon			原始曲线与近似曲线的距离。
				（4）closed				指示曲线是否闭合的标志。

（3）绘制近似曲线的轮廓：通过drawContours

2.13.4、矩形轮廓

（1）计算矩形的左上角坐标与宽高：cv::boundingRect()

#include <opencv2/imgproc.hpp>
函数说明：Rect cv::boundingRect(InputArray array);
输入参数：		array				输入灰度图像或2D点集，存储在std::vector或Mat中。
输出参数：		rect				返回矩形的四个参数：左上角坐标(x,y)，宽高(w,h)

（2）绘制矩形框：cv::rectangle()

#include <opencv2/imgproc.hpp>
函数说明：void cv::rectangle( InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness = 1, int lineType = LINE_8, int shift = 0 );
输入参数：
				（1）img						输入灰度图像或2D点集，存储在std::vector或Mat中。
				（2）pt1						矩形的左上角顶点坐标。
				（3）pt2						矩形的右下角顶点坐标。
				（4）color						颜色或亮度（灰度图像）。
				（5）thickness = 1				线条厚度。如果为负值（例如，厚度=FILLED），意味着函数将绘制一个填充的矩形。
				（6）lineType = LINE_8			线的类型。
										cv::FILLED 			填充。当线厚度为负值时使用
										cv::LINE_4 			4连接线型
										cv::LINE_8 			8连接线型
										cv::LINE_AA 		抗锯齿线
				（7）shift = 0					点坐标中的小数位数。

2.13.5、外接圆轮廓

（1）计算最小封闭圆的中心点与半径：cv::minEnclosingCircle()

#include <opencv2/imgproc.hpp>
函数说明：void cv::minEnclosingCircle(InputArray points, Point2f &center, float &radius );
输入参数：
				（1）points						输入灰度图像或2D点集，存储在std::vector或Mat中。
				（2）center						（输出）圆的中心。
				（3）radius						（输出）圆的半径。

（2）绘制圆形框：cv::circle()

#include <opencv2/imgproc.hpp>
函数说明：void cv::circle( InputOutputArray img, Point center, int radius, const Scalar &color, int thickness = 1, int lineType = LINE_8, int shift = 0 );
输入参数：
				（1）img						输入灰度图像或2D点集，存储在std::vector或Mat中。
				（2）center						圆的中心。
				（3）radius						圆的半径。
				（4）color						颜色。
				（5）thickness = 1				线条厚度。如果为负值（例如，厚度=FILLED），意味着函数将绘制一个填充的矩形。
				（6）lineType = LINE_8			线的类型。
										cv::FILLED 			填充。当线厚度为负值时使用
										cv::LINE_4 			4连接线型
										cv::LINE_8 			8连接线型
										cv::LINE_AA 		抗锯齿线
				（7）shift = 0					中心坐标和半径值中的小数位数。

2.13.6、实战案例

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

//using namespace std;
//using namespace cv;

int main(int argc, char* argv[])
{
	//（1）读取图像
	std::string img_path = "test.jpg";
	cv::Mat src = cv::imread(img_path, 1);

	//（2）判断图像是否读取成功
	if (!src.data)
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}

	//（3）图像预处理
	cv::Mat src_Gray, src_binary;
	cv::cvtColor(src, src_Gray, cv::COLOR_BGR2GRAY);							//灰度化
	cv::threshold(src_Gray, src_binary, 125, 255, cv::THRESH_BINARY);			//二值化

	//（4.1）轮廓检测
	cv::Mat src_binary1 = src_binary.clone();			//复制矩阵
	std::vector<std::vector<cv::Point>> contours;			
	std::vector<cv::Vec4i> hierarchy;					//hierarchy = cv::noArray()
	cv::findContours(src_binary1, contours, hierarchy, cv::RETR_TREE, cv::CHAIN_APPROX_NONE);
	
	//（4.2）在全黑画板上绘制轮廓
	cv::Mat src_binary2 = src_binary1.clone();			//复制矩阵
	src_binary2 = cv::Scalar::all(0);					//返回所有元素都为标量0的矩阵。
	cv::drawContours(src_binary2, contours, -1, cv::Scalar(255, 255, 2555));

	//（5）用近似曲线拟合轮廓的边界（全黑画板）
	cv::Mat src_binary3 = src_binary1.clone();			//复制矩阵
	src_binary3 = cv::Scalar::all(0);					//返回所有元素都为标量0的矩阵。
	std::vector<std::vector<cv::Point>> contours_poly(contours.size());					//用于存放曲线点集
	for (int i = 0; i < contours.size(); i++)
	{
		//int epsilon = cv::arcLength(cv::Mat(contours[i]), true);						//5.1计算周长
		cv::approxPolyDP(cv::Mat(contours[i]), contours_poly[i], 15, true);				//5.2近似曲线坐标
		cv::drawContours(src_binary3, contours_poly, i, cv::Scalar(255, 255, 255));  	//5.3绘制曲线
	}
	
	//（6）矩形画出轮廓的边界（全黑画板）
	cv::Mat src_binary4 = src_binary1.clone();			//复制矩阵
	src_binary4 = cv::Scalar::all(0);					//返回所有元素都为标量0的矩阵。
	for (int i = 0; i < contours.size(); i++)
	{
		cv::Rect rect = cv::boundingRect(cv::Mat(contours[i]));					//6.1矩形坐标
		cv::rectangle(src_binary4, rect, cv::Scalar(255, 255, 255));  			//6.2绘制矩形
	}

	//（7）圆形画出轮廓的边界（全黑画板）
	cv::Mat src_binary5 = src_binary1.clone();			//复制矩阵
	src_binary5 = cv::Scalar::all(0);					//返回所有元素都为标量0的矩阵。
	cv::Point2f center;
	float radius = 0;
	for (int i = 0; i < contours.size(); i++)
	{
		cv::minEnclosingCircle(cv::Mat(contours[i]), center, radius);			//7.1圆形坐标
		cv::circle(src_binary5, center, radius, cv::Scalar(255, 255, 255));  	//7.2绘制圆形
	}

	//（8）显示图像（由于是单通道，故颜色三通道必须都有值）
	cv::imshow("src", src);
	cv::imshow("dst", src_binary1);
	cv::imshow("cont", src_binary2);
	cv::imshow("appr", src_binary3);
	cv::imshow("rect", src_binary4);
	cv::imshow("circ", src_binary5);
	
	cv::waitKey(0);
	return 0;
}

2.14、绘制多种图形

2.14.1、绘制直线：cv::line()

#include <opencv2/imgproc.hpp>
函数说明：void cv::line( InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness = 1, int lineType = LINE_8, int shift = 0 );
输入参数：
				（1）img						输入灰度图像或2D点集，存储在std::vector或Mat中。
				（2）pt1						线段的第一个点。
				（3）pt2						线段的第二个点。
				（4）color						颜色。
				（5）thickness = 1				线条厚度。如果为负值（例如，厚度=FILLED），意味着函数将绘制一个填充的矩形。
				（6）lineType = LINE_8			线的类型。
										cv::FILLED 			填充。当线厚度为负值时使用
										cv::LINE_4 			4连接线型
										cv::LINE_8 			8连接线型
										cv::LINE_AA 		抗锯齿线
				（7）shift = 0					中心坐标和半径值中的小数位数。

2.14.2、绘制椭圆：cv::ellipse()

如果要绘制整个椭圆，而不是圆弧，请通过startAngle=0和endAngle=360。如果startAngle大于endAngle，则它们将被交换。

#include <opencv2/imgproc.hpp>
函数说明：void cv::ellipse( InputOutputArray img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar &color, int thickness = 1, int lineType = LINE_8, int shift = 0 );
输入参数：
				（1）img						输入灰度图像或2D点集，存储在std::vector或Mat中。
				（2）center						椭圆中心坐标。
				（3）axes						椭圆x,y的半径。
				（4）angle						椭圆旋转角度，单位为度。
				（5）startAngle					椭圆弧的起始角，单位为度。[0, 360]、[0, 180]
				（6）endAngle					椭圆弧的终止角，单位为度。
				（7）color						颜色。
				（8）thickness = 1				线条厚度。如果为负值（例如，厚度=FILLED），意味着函数将绘制一个填充的矩形。
				（9）lineType = LINE_8			线的类型。
										cv::FILLED 			填充。当线厚度为负值时使用
										cv::LINE_4 			4连接线型
										cv::LINE_8 			8连接线型
										cv::LINE_AA 		抗锯齿线
				（10）shift = 0					中心坐标和半径值中的小数位数。

2.14.3、填充多边形：cv::fillPoly()

填充由多个多边形轮廓限定的区域。可以填充复杂区域，例如，具有孔的区域、具有自相交的轮廓（其某些部分）等。

#include <opencv2/imgproc.hpp>
函数说明：void cv::fillPoly( InputOutputArray img, InputArrayOfArrays pts, const Scalar &color, int lineType = LINE_8, int shift = 0, Point offset = Point() );
输入参数：
				（1）img						输入灰度图像或2D点集，存储在std::vector或Mat中。
				（2）pts						多边形阵列，其中每个多边形表示为点阵列。
				（3）color						颜色。
				（4）lineType = LINE_8			线的类型。
										cv::FILLED 			填充。当线厚度为负值时使用
										cv::LINE_4 			4连接线型
										cv::LINE_8 			8连接线型
										cv::LINE_AA 		抗锯齿线
				（5）shift = 0					中心坐标和半径值中的小数位数。
				（6）offset = Point()			可选轮廓偏移参数。将所有绘制的轮廓移动指定的偏移量=(dx, dy)。

2.14.4、添加文字：cv::putText()

在图像中呈现指定的文本字符串。无法使用指定字体呈现的符号将替换为问号。

#include <opencv2/imgproc.hpp>
函数说明：void cv::putText( InputOutputArray img, const String & text, Point org, int fontFace, double fontScale, Scalar color, int thickness = 1, int lineType = LINE_8, bool bottomLeftOrigin = false );
输入参数：
				（1）img						输入灰度图像或2D点集，存储在std::vector或Mat中。
				（2）text						文本字符串。
				（3）org						图像中文本字符串的左下角。
				（4）fontFace					字体类型。
										cv::FONT_HERSHEY_SIMPLEX 			普通大小无衬线字体
										cv::FONT_HERSHEY_PLAIN 				小型无衬线字体
										cv::FONT_HERSHEY_DUPLEX 			普通大小无衬线字体（比font_HERSHEY_SIMPLEX更复杂）
										cv::FONT_HERSHEY_COMPLEX 			普通尺寸衬线字体
										cv::FONT_HERSHEY_TRIPLEX 			普通大小衬线字体（比font_HERSHEY_complex更复杂）
										cv::FONT_HERSHEY_COMPLEX_SMALL 		较小版本的FONT_HERSHEY_COMPLEX
										cv::FONT_HERSHEY_SCRIPT_SIMPLEX 	手写字体
										cv::FONT_HERSHEY_SCRIPT_COMPLEX 	更复杂的FONT_HERSHEY_SCRIPT_SIMPLEX变体
										cv::FONT_ITALIC 					斜体标志
				（5）fontScale					字体比例因子，乘以特定于字体的基本大小。
				（6）color						颜色。
				（7）thickness = 1				线条厚度。如果为负值（例如，厚度=FILLED），意味着函数将绘制一个填充的矩形。
				（8）lineType = LINE_8			线的类型。
										cv::FILLED 			填充。当线厚度为负值时使用
										cv::LINE_4 			4连接线型
										cv::LINE_8 			8连接线型
										cv::LINE_AA 		抗锯齿线
				（9）bottomLeftOrigin = false	如果为true，则图像数据原点位于左下角。否则，它在左上角。

2.14.5、实战案例

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

//using namespace std;
//using namespace cv;

int main(int argc, char* argv[])
{
	//绘制多种图形
	cv::Mat img = cv::Mat::zeros(500, 500, CV_8UC3);		//值全0矩阵。
	std::cout << img.cols << img.rows << std::endl;
	cv::Scalar color(0, 255, 255);		//指定颜色（RGB）
	
	//（1）绘制线
	cv::Point p1(50, 200);				//起点(y,x)
	cv::Point p2(150, 150);				//起点1(y,x)
	cv::Point p3(250, 200);				//起点2(y,x)
	cv::line(img, p1, p2, color);
	cv::line(img, p2, p3, color);
	
	//（2）绘制矩形
	cv::Point PT1(10, 10);				//左上角坐标(y,x)
	cv::Point PT2(100, 100);			//右下角坐标(y,x)
	cv::rectangle(img, PT1, PT2, color); 
	
	//（3）绘制圆形
	cv::Point P_Y(150, 300);			//中心坐标(y,x)
	int radius = 20;					//半径
	cv::circle(img, P_Y, radius, color); 

	//（4）绘制椭圆
	cv::Point P_TY(150, 300);			//中心坐标(y,x)
	cv::Size radius_TY(50, 100);		//x,y的半径
	int angle = 90;
	int angle_start = 0;
	int angle_end = 360;
	cv::ellipse(img, P_TY, radius_TY, angle, angle_start, angle_end, color); 

	//（5）填充自定义的四边形
	cv::Point pts[1][5];		//左上角、右上角、右下角、左下角、左上角。
	pts[0][0] = cv::Point(200, 10);
	pts[0][1] = cv::Point(300, 10);
	pts[0][2] = cv::Point(300, 100);
	pts[0][3] = cv::Point(200, 100);
	pts[0][4] = cv::Point(200, 10);
	const cv::Point* ppts[] = { pts[0] };
	int npt[] = { 5 };
	cv::fillPoly(img, ppts, npt, 1, color);

	//（6）添加文字
	cv::Point Putt(60, 220);
	cv::putText(img, "Hi, Pearson!", Putt, cv::FONT_HERSHEY_COMPLEX, 1.0, color);	

	//（7）循环线图
	cv::Mat img11 = img.clone();			//复制矩阵
	img11 = cv::Scalar::all(0);				//返回所有元素都为标量0的矩阵。
	
	cv::RNG rng(-1);
	cv::Point pt1;
	cv::Point pt2;
	for (int i = 0; i < 10; i++)
	{
		pt1.x = rng.uniform(0, img11.cols);
		pt2.x = rng.uniform(0, img11.cols);
		pt1.y = rng.uniform(0, img11.rows);
		pt2.y = rng.uniform(0, img11.rows);
		//cv::Scalar color0 = (rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));				//每次生成数固定
		cv::Scalar color0 = cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));		//每次生成数随机
		cv::waitKey(50);
		cv::line(img11, pt1, pt2, color0);
		cv::imshow("img11", img11);
	}

	//（3）显示图像
	cv::imshow("img", img);
	cv::waitKey(0);
	return 0;
}