1、点多边形测试

1.1、计算像素点是在轮廓内部、外部或边界上：cv::pointPolygonTest()

#include <opencv2/imgproc.hpp>
函数说明：double cv::pointPolygonTest( InputArray contour, Point2f pt, bool measureDist );
输入参数：
				contour					输入轮廓。
				pt						测试点坐标。
				measureDist 			是否返回距离值。
								
返回值：			若measureDist=True，返回点到最近轮廓边的有符号距离。
				若measureDist=False时，返回值分别为+1（内部）、-1（外部）和0（边界上）。

1.2、计算最小值和最大值及其位置：cv::minMaxLoc()

该函数不适用于多通道阵列。如果需要在所有通道中找到最小或最大元素，请首先使用Mat:：整形将数组重新解释为单个通道。或者，您可以使用extractImageCOI、mixChannels或split提取特定频道。

#include <opencv2/core.hpp>
函数说明：void cv::minMaxLoc( InputArray src, double * minVal, double * maxVal = 0, Point * minLoc = 0, Point * maxLoc = 0, InputArray mask = noArray() );
输入参数：
				src							输入单通道阵列。
				minVal						最小值；如果不需要，则使用NULL。
				maxVal = 0 					最大值；如果不需要，则使用NULL。
				minLoc = 0					最小位置（在2D情况下）；如果不需要，则使用NULL。
				maxLoc = 0					最大位置（在2D情况下）；如果不需要，则使用NULL。
				mask = noArray()			用于选择子阵列的可选掩码。如果掩码不是空数组，则在指定的数组区域中搜索极值。

1.3、实战案例

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

int main(int argc, const char* argv[]) 
{
	//（1）构建一张单通道8位400 x 400的图像，
	const int r = 100;
	cv::Mat src = cv::Mat::zeros(r * 4, r * 4, CV_8UC1);
	
	//（2）绘制自定义六边形（通过line绘制六次）
	std::vector<cv::Point2f> vert(6);
	vert[0] = cv::Point(3 * r / 2, static_cast<int>(1.34 * r));
	vert[1] = cv::Point(1 * r, 2 * r);
	vert[2] = cv::Point(3 * r / 2, static_cast<int>(2.866 * r));
	vert[3] = cv::Point(5 * r / 2, static_cast<int>(2.866 * r));
	vert[4] = cv::Point(3 * r, 2 * r);
	vert[5] = cv::Point(5 * r / 2, static_cast<int>(1.34 * r));
	for (int ii = 0; ii < 6; ii++)
	{
		cv::line(src, vert[ii], vert[(ii+1) % 6], cv::Scalar(255), 3, 8, 0);
	}
	
	//（3）轮廓检测
	std::vector<std::vector<cv::Point>> contours;
	std::vector<cv::Vec4i> hierachy;
	cv::Mat src_contours = src.clone();
	cv::findContours(src_contours, contours, hierachy, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE, cv::Point(0, 0));
	
	//（4）对图像中所有像素点进行【点多边形测试】：测试像素点是在多边形内部、边界或外部上
	cv::Mat raw_dist = cv::Mat::zeros(src_contours.size(), CV_32FC1);
	for (int row = 0; row < raw_dist.rows; row++)
	{
		for (int col = 0; col < raw_dist.cols; col++)
		{
			//输入参数：输入轮廓，测试点，是否返回距离值。（False：1表示在内部，0表示在边界上，-1表示在外部）（True表示返回实际距离值）
			double dist = cv::pointPolygonTest(contours[0], cv::Point2f(static_cast<float>(col), static_cast<float>(row)), true);
			raw_dist.at<float>(row, col) = static_cast<float>(dist);
		}
	}
	
	//（5）按内部、边界、外部三个区域分开，并且内/外部依据距离远近动态赋值，形成渐变色（也可以自定义为固定值）
	double minValue, maxValue;
	cv::minMaxLoc(raw_dist, &minValue, &maxValue, 0, 0, cv::Mat());		//计算最大值和最小值
	cv::Mat dst = cv::Mat::zeros(src.size(), CV_8UC3);
	for (int row = 0; row < dst.rows; row++)
	{
		for (int col = 0; col < dst.cols; col++)
		{
			float dist = raw_dist.at<float>(row, col);
			if (dist > 0)
				dst.at<cv::Vec3b>(row, col)[0] = (uchar)(abs(1.0 - (dist / maxValue)) * 255);		//内部
			else if (dist < 0)
				dst.at<cv::Vec3b>(row, col)[2] = (uchar)(abs(1.0 - (dist / minValue)) * 255);		//外部
			else
			{
				dst.at<cv::Vec3b>(row, col)[0] = (uchar)(abs(255 - dist));		//边界
				dst.at<cv::Vec3b>(row, col)[1] = (uchar)(abs(255 - dist));		//边界
				dst.at<cv::Vec3b>(row, col)[2] = (uchar)(abs(255 - dist));		//边界
			}
		}
	}
	
	//（6）显示图像
	cv::imshow("src", src);
	cv::imshow("dst", dst);
	cv::waitKey(0);
	return 0;
}

2、矩

cv::moments是OpenCV中一个常用的函数，用于计算图像区域的各阶矩。如：计算输入图像中一个区域的几何矩、中心矩和归一化中心矩。

• 几何矩：是用来描述图像区域的形状和位置的；
• 中心矩：是关于区域质心的矩，它可以用于计算区域的方向；
• 归一化中心矩：是中心矩的归一化版本，可以用于不同尺度的比较。

常用于形状分析、图像识别、目标跟踪等领域。

• 在形状分析方面，可以用来计算图像中各个对象的重心、面积、方向和轮廓等信息，从而实现图像分割和形状匹配。
• 在图像识别方面，可以用来计算图像中特定对象的各种特征，如Hu矩，用于快速分类和识别目标。
• 在目标跟踪方面，可以用来计算目标位置和方向，从而实现实时跟踪。

2.1、计算多边形或光栅化形状的三阶以下的所有力矩：cv::moments()

spatial moments（空间距）	central moments（中心矩）	central normalized moments（中心归一化矩）
double m00	double mu20	double nu20
double m10	double mu11	double nu11
double m01	double mu02	double nu02
double m20	double mu30	double nu30
double m11	double mu21	double nu21
double m02	double mu12	double nu12
double m30	double mu03	double nu03
double m21
double m12
double m03

#include <opencv2/imgproc.hpp>
函数说明：Moments cv::moments( InputArray array, bool binaryImage = false );
输入参数：
				array						光栅图像（单通道、8位或浮点2D阵列）或2D点（点或点2f）的阵列（1×N或N×1）。
				binaryImage = false			如果为True，则将所有非零图像像素视为1。该参数仅用于图像。
返回值：			moments.

备注：仅适用于Python绑定中的轮廓矩计算：请注意，输入数组的numpy类型应为np.int32或np.float32。
备注：由于轮廓矩是使用格林公式计算的，对于具有自相交的轮廓，您可能会得到看似奇怪的结果，例如蝴蝶形轮廓的零面积（m00）。

2.2、计算轮廓面积：cv::contourArea()

#include <opencv2/imgproc.hpp>
函数说明：double cv::contourArea( InputArray contour, bool oriented = false );
输入参数：		contour					2D点（轮廓顶点）的输入向量，存储在std:：vector或Mat中。
				oriented = false		定向区域标志符。
								
返回值：			若oriented=true，返回一个带符号的面积值，符号值取决于轮廓方向（顺时针或逆时针）。
				若oriented=false（默认），返回面积的绝对值。

备注：与力矩类似，使用格林公式计算面积。因此，如果使用drawContours或fillPoly绘制轮廓，则返回的面积和非零像素数可能不同。此外，对于具有自相交的轮廓，该函数肯定会给出错误的结果。	

2.3、计算曲线长度或闭合轮廓周长：cv::arcLength()

#include <opencv2/imgproc.hpp>
函数说明：double cv::arcLength( InputArray curve, bool closed );
输入参数：		curve				2D点的输入矢量，存储在std:：vector或Mat中。
				closed 				曲线是否闭合的标志符。	
				
返回值：			若closed=true，返回闭合轮廓周长。
				若closed=false，返回曲线长度。

2.4、实战案例

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

int main(int argc, char** argv)
{
	//（1）输入图像
	cv::Mat src = cv::imread("test.jpg");
	if (!src.data)
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}

	//（2）图像处理
	cv::Mat src_gray_, src_blur, src_canny;
	cv::cvtColor(src, src_gray_, cv::COLOR_BGR2GRAY);
	cv::GaussianBlur(src_gray_, src_blur, cv::Size(3, 3), 0, 0);
	cv::Canny(src_blur, src_canny, 0, 160);			//该参数极大影响最终效果
	//cv::Canny(blur_src, canny_src, 80, 160);		//该参数极大影响最终效果


	//（3）轮廓检测
	std::vector<std::vector<cv::Point>> contours;
	std::vector<cv::Vec4i> hierachy;
	cv::findContours(src_canny, contours, hierachy, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE, cv::Point(0, 0));

	//（4）计算每个轮廓的矩。矩中心点center=(x0, y0)。【其中：x0=m10/m00，y0=m01/m00】
	std::vector<cv::Moments> contours_moments(contours.size());
	std::vector<cv::Point2f> ccs(contours.size());
	for (size_t i = 0; i < contours.size(); i++)
	{
		//输入参数：输入图像，是否返回二值化图像
		contours_moments[i] = cv::moments(contours[i]);		//计算矩
		ccs[i] = cv::Point(static_cast<float>(contours_moments[i].m10 / contours_moments[i].m00), static_cast<float>(contours_moments[i].m01 / contours_moments[i].m00));
	}

	//（5）绘制轮廓和圆（打印轮廓面积 + 弧长）
	cv::Mat dst = cv::Mat::zeros(src.size(), CV_8UC3);		//空矩阵
	//cv::Mat dst = src.clone();
	cv::RNG rng(12345);
	for (size_t i = 0; i < contours.size(); i++)
	{
		if (contours[i].size() < 10) 		//轮廓筛选（过滤较小的轮廓）
			continue;
		cv::Scalar color = cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));		//生成随机数
		cv::drawContours(dst, contours, i, color, 2, 8, hierachy, 0, cv::Point(0, 0));
		cv::circle(dst, ccs[i], 2, color, 2, 8);
		std::cout << "当前为第[i]个轮廓：" << i << "【轮廓中心点】x=" << ccs[i].x << ", y=" << ccs[i].y << "【轮廓面积contourArea】" << cv::contourArea(contours[i]) << "【轮廓弧长arcLength】" << cv::arcLength(contours[i], true) << std::endl;
	}

	//（6）显示图像
	cv::imshow("src", src);
	cv::imshow("gray", src_gray_);
	cv::imshow("blur", src_blur);
	cv::imshow("canny", src_canny);
	cv::imshow("dst", dst);
	cv::waitKey(0);
	return 0;
}

3、凸包

定义：基于给定二维平面上的点集，将最外层的点连接起来构成的凸多边型即凸包。该多边形包含点集中所有的点。
凸包算法详解(convex hull)

Graham扫描算法

• 11、首先选择 y 方向最低的点作为起始点p0，然后对p0进行极坐标扫描，依次添加p1…pn（排列顺序根据极坐标的角度大小，逆时针方向决定）
• 22、添加任意 pi 点到凸包中，若导致左转向（逆时针），则添加该点到凸包；反之，若导致右转向（顺时针），则删除该点。

3.1、计算凸包：cv::convexHull()

#include <opencv2/imgproc.hpp>
函数说明：void cv::convexHull( InputArray points, OutputArray hull, bool clockwise = false, bool returnPoints = true );
输入参数：
				points						输入2D点集，存储在std::vector或Mat中。
				hull						输出凸包。
									（1）指数的整数向量。在第一种情况下，hull元素是原始数组中凸包点的基于0的索引(因为凸包的点集是原始点集的子集)。
									（2）点的向量。在第二种情况下，hull元素是凸船体点本身。
				clockwise = false			定位标志。true表示输出凸包为顺时针方向。否则为逆时针方向。假设的坐标系是X轴向右，Y轴向上。
				returnPoints = true			操作标记。true则返回凸包点。否则返回凸包点的索引。
									当输出数组为std::vector时，该标志被忽略。
									输出取决于vector的类型：（1）std::vector<int>则returnPoints=false;（2）std::vector<Point>则returnPoints=true。

3.2、实战案例

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

int main(int argc, char** argv)
{
	//（1）输入图像
	cv::Mat src = cv::imread("test.jpg");
	if (!src.data)
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}

	//（2）图像处理
	cv::Mat src_gray, src_blur, src_bin;
	cv::cvtColor(src, src_gray, cv::COLOR_BGR2GRAY);
	cv::blur(src_gray, src_blur, cv::Size(3, 3));
	cv::threshold(src_blur, src_bin, 100, 255, cv::THRESH_BINARY);		//该参数极大影响最终效果

	//（3）轮廓检测
	std::vector<std::vector<cv::Point>> contours;
	std::vector<cv::Vec4i> hierachy;
	cv::findContours(src_bin, contours, hierachy, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE, cv::Point(0, 0));

	//（4）计算凸包
	std::vector<std::vector<cv::Point>> convexs(contours.size());
	for (size_t i = 0; i < contours.size(); i++)
	{
		//输入参数：轮廓点，凸包，方向（默认False=逆时针），是否返回点个数（默认True）
		cv::convexHull(contours[i], convexs[i], false, true);
	}

	//（5）绘制凸包
	cv::Mat dst = cv::Mat::zeros(src.size(), CV_8UC3);		//空矩阵
	//cv::Mat dst = src.clone();							//复制原图
	std::vector<cv::Vec4i> empty(0);
	cv::RNG rng(12345);
	for (size_t k = 0; k < contours.size(); k++)
	{
		cv::Scalar color = cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
		cv::drawContours(dst, contours, k, color, 2, cv::LINE_8, hierachy, 0, cv::Point(0, 0));
		cv::drawContours(dst, convexs, k, color, 2, cv::LINE_8, empty, 0, cv::Point(0, 0));
	}

	//（6）显示图像
	cv::imshow("src", src);
	cv::imshow("src_gray", src_gray);
	cv::imshow("src_blur", src_blur);
	cv::imshow("src_bin", src_bin);
	cv::imshow("dst", dst);
	cv::waitKey(0);
	return 0;
}

4、映射

4.1、像素重映射：cv::remap()

#include <opencv2/imgproc.hpp>
函数说明： void cv::remap( InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode = BORDER_CONSTANT, const Scalar &borderValue = Scalar() );
输入参数：
				（1）src					源图像。
				（2）dst					目的图像。大小与map1相同，类型与src相同。
				（3）map1					(x,y)点的第一个映射或只有x值的第一个映射，其类型为CV_16SC2, CV_32FC1或CV_32FC2。
				（4）map2					第二个y值的映射，其类型分别为CV_16UC1、CV_32FC1或none(如果map1为(x,y)点，则为空映射)。
				（5）interpolation			插值方法。不支持INTER_AREA和INTER_LINEAR_EXACT方法。
									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）Scalar &borderValue = Scalar()			边界值（在边界不变的情况下）。缺省值是0。

备注：此函数不能原地操作。

4.2、实战案例

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

int main(int argc, char** argv)
{
	while (true)
	{
		//（1）输入图像
		cv::Mat src = cv::imread("test.jpg");
		if (!src.data)
		{
			std::cout << "can't read image!" << std::endl;
			return -1;
		}

		//（2）像素重映射的四种类型（自定义）
		int c = cv::waitKey(500);		//2.1、等待键盘事件
		if ((char)c == 27) 				//2.2、退出键：Esc
			break;
		int index = c % 4;				//2.3、根据输入值进行四种类型判断：[0, 1, 2, 3]
		
		cv::Mat map_x, map_y;
		map_x.create(src.size(), CV_32FC1);			//x映射表
		map_y.create(src.size(), CV_32FC1);			//y映射表
		for (int row = 0; row < src.rows; row++) 
		{
			for (int col = 0; col < src.cols; col++) 
			{
				switch (index) 
				{
				case 0:					//2.2.1、缩小一半
					if (col > (src.cols * 0.25) && col <= (src.cols*0.75) && row > (src.rows*0.25) && row <= (src.rows*0.75)) 
					{
						map_x.at<float>(row, col) = 2 * (col - (src.cols*0.25));
						map_y.at<float>(row, col) = 2 * (row - (src.rows*0.25));
					}
					else 
					{
						map_x.at<float>(row, col) = 0;
						map_y.at<float>(row, col) = 0;
					}
					break;
				case 1:					//2.2.2、沿着Y方向翻转
					map_x.at<float>(row, col) = (src.cols - col - 1);
					map_y.at<float>(row, col) = row;
					break;
				case 2:					//2.2.3、沿着X方向翻转
					map_x.at<float>(row, col) = col;
					map_y.at<float>(row, col) = (src.rows - row - 1);
					break;
				case 3:					//2.2.4、沿着XY方向同时翻转
					map_x.at<float>(row, col) = (src.cols - col - 1);
					map_y.at<float>(row, col) = (src.rows - row - 1);
					break;
				}
			}
		}

		//（3）像素重映射：将输入图像的所有像素根据指定规则进行映射，并形成新图像。
		cv::Mat dst;
		cv::remap(src, dst, map_x, map_y, cv::INTER_LINEAR, cv::BORDER_CONSTANT, cv::Scalar(0, 255, 255));

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

	return 0;
}

5、反向投影

反向投影是一种被广泛应用于医学影像处理，计算机视觉和计算机图形学中的图像重建技术。

• 在医学领域，反向投影技术经常用于CT（计算机断层扫描仪）和PET（正电子发射断层扫描）成像中，用于3D图像重建和图像分割。
• 在计算机视觉领域，反向投影在3D物体重建中被广泛使用。例如，通过将多个2D图像拼接起来重建3D物体，如在机器人领域中处理3D传感器数据或为虚拟现实应用程序创建3D模型。
• 在计算机图形学中，反向投影可以用于对3D对象进行渲染和投射，如对电影制作和电子游戏开发。

5.1、将指定通道从输入阵列复制到输出阵列的指定通道：cv::mixChannels()

#include <opencv2/core.hpp>
函数说明：void cv::mixChannels( const Mat * src, size_t nsrcs, Mat * dst, size_t ndsts, const int * fromTo, size_t npairs );
输入参数：		（1）src				矩阵的输入数组或向量；所有矩阵必须具有相同的大小和相同的深度。
				（2）nsrcs 				src中的矩阵数。
				（3）dst				矩阵的输出阵列或向量；必须分配所有矩阵；它们的大小和深度必须与src[0]中的相同。
				（4）ndsts				dst中的矩阵数。
				（5）fromTo				索引对数组：指定要复制的通道以及复制的位置。
								fromTo[k*2]是src中输入通道的基于0的索引，fromTo[m*2+1]是dst中输出通道的索引；
								使用连续的通道编号：	第一个输入图像通道的索引从0到src[0].channels()-1;
													第二个输入图像频道的索引从src[0]到src[0].channels()+src[1].Channelss()-1;
													依此类推，输出图像通道使用相同的方案。
								特殊情况：当fromTo[k*2]为负时，相应的输出通道填充为零。
				（6）npairs 			fromTo中的索引对数。

5.2、计算直方图的反向投影：cv::calcBackProject()

• 反向投影：在输入图像中，查找与模板图像最匹配的点或区域，即定位模板图像出现在输入图像的位置。
• 定位方法：不断的在输入图像中切割跟模板图像大小一致的图像块，并用直方图对比的方式与模板图像进行比较。

假设我们有一张100x100的输入图像，有一张10x10的模板图像，查找的过程是这样的：
（1）从输入图像的左上角(0,0)开始，切割一块(0,0)至(10,10)的临时图像；
（2）生成临时图像的直方图；
（3）用临时图像的直方图和模板图像的直方图对比，对比结果记为c；
（4）直方图对比结果c，就是结果图像(0,0)处的像素值；
（5）切割输入图像从(0,1)至(10,11)的临时图像，对比直方图，并记录到结果图像；
（6）重复（1）～（5）步直到输入图像的右下角。

#include <opencv2/imgproc.hpp>
函数说明：void cv::calcBackProject( const Mat * images, int nimages, const int * channels, InputArray hist, OutputArray backProject, const float ** ranges, double scale = 1, bool uniform = true );
输入参数：		（1）images					输入图像（CV_8U、CV_16U或CV_32F）。具有相同的深度和尺寸，且每一个都可以具有任意数量的通道。
				（2）nimages 				输入图像的数量。
				（3）channels				计算反向投影的通道列表。通道数量必须与直方图维度相匹配。
									第一个阵列通道的计数从0到images[0].channels()-1;
									第二个阵列通道的计数从images[0].channels()到images[0].channels() + images[1].channels()-1, and so on.
				（4）hist					直方图。可以是密集的或稀疏的
				（5）backProject			目标反向投影阵列。与images[0]具有相同大小和深度的单通道阵列。
				（6）ranges 				每个维度中的直方图bin边界的数组。请参见calcHist。
				（7）scale = 1				可选比例因子，一般都设置成1。
				（8）uniform = true			直方图是否一致的标志符。

备注：该函数的执行效率非常的低。在使用之前需要注意图像大小，直方图维数，对比方式。
举例：对于1010 x 1010的RGB输入图像，10x10的模板图像，需要生成1百万次3维直方图，然后对比1百万次3维直方图。

5.3、实战案例

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

int main(int argc, const char* argv[]) 
{
	//（1）输入图像
	cv::Mat src = cv::imread("test.jpg");
	if (src.empty())
	{
		std::cout << "can't read image!" << std::endl;
		return -1;
	}

	//（2）图像处理
	cv::Mat src_hsv, src_hue;
	cv::cvtColor(src, src_hsv, cv::COLOR_BGR2HSV);			//格式转换
	src_hue.create(src_hsv.size(), src_hsv.depth());		//新建矩阵
	int nchannels[] = {0, 0};
	cv::mixChannels(&src_hsv, 1, &src_hue, 1, nchannels, 1);		//将制定通道从输入阵列复制到输出阵列的指定通道

	//（3）计算直方图和归一化
	cv::Mat h_hist;
	int bins = 12;
	float range[] = {0, 180};
	const float* histRanges = {range};
	cv::calcHist(&src_hue, 1, 0, cv::Mat(), h_hist, 1, &bins, &histRanges);
	cv::normalize(h_hist, h_hist, 0, 255, cv::NORM_MINMAX, -1, cv::Mat());

	//（4）计算直方图的反向投影
	cv::Mat Back_Project_Image;
	cv::calcBackProject(&src_hue, 1, 0, h_hist, Back_Project_Image, &histRanges, 1);
	
	//（5）计算反向投影的直方图
	int hist_h = 400;
	int hist_w = 400;
	cv::Mat Hist_Image(hist_w, hist_h, CV_8UC3, cv::Scalar(0, 0, 0));
	int bin_w = hist_w / bins;
	for(int ii = 1; ii < bins; ii++)
	{
		cv::rectangle(Hist_Image, cv::Point((ii - 1) * bin_w, (hist_h - cvRound(h_hist.at<float>(ii - 1) * (400 / 255)))), cv::Point(ii * bin_w, hist_h), cv::Scalar(0, 0, 255), -1);
	}
	
	//（6）显示图像
	cv::imshow("src", src);								//原图
	cv::imshow("BackProj", Back_Project_Image);			//反向投影
	cv::imshow("Histogram", Hist_Image);				//反向投影的直方图
	cv::waitKey(0);
	return 0;
}