c++ opencv4.5.5 学习笔记（九）检测出物体轮廓 cv::findContours (三角形、圆形、四边形、五边形、六边形、星形)

检测出物体轮廓

/**
  * findContours  检测出物体轮廓
  * image         单通道图像矩阵，可以是灰度图，但更常用的是二值图像，一般是经过Canny、拉普拉斯等边缘检测算子处理过的二值图像；
  * contours      定义为“vector> contours”，是一个向量，并且是一个双重向量，向量内每个元素保存了一组由连续的Point点构成的点的集合的向量，
  				每一组Point点集就是一个轮廓。有多少轮廓，向量contours就有多少元素。
  * hierarchy     定义为“vector hierarchy”，先来看一下Vec4i的定义：typedef   Vec   Vec4i;
  				Vec4i是Vec的别名，定义了一个“向量内每一个元素包含了4个int型变量”的向量。
  				所以从定义上看，hierarchy也是一个向量，向量内每个元素保存了一个包含4个int整型的数组。
  				向量hiararchy内的元素和轮廓向量contours内的元素是一一对应的，向量的容量相同。
  				hierarchy向量内每一个元素的4个int型变量——hierarchy[i][0] ~hierarchy[i][3]，分别表示第
  				i个轮廓的后一个轮廓、前一个轮廓、父轮廓、内嵌轮廓的索引编号。如果当前轮廓没有对应的后一个
  				轮廓、前一个轮廓、父轮廓或内嵌轮廓的话，则hierarchy[i][0] ~hierarchy[i][3]的相应位被设置为默认值-1。
  * mode          定义轮廓的检索模式：取值一：CV_RETR_EXTERNAL只检测最外围轮廓，包含在外围轮廓内的内围轮廓被忽略
  									取值二：CV_RETR_LIST   检测所有的轮廓，包括内围、外围轮廓，但是检测到的轮廓不建立等级关
  									系，彼此之间独立，没有等级关系，这就意味着这个检索模式下不存在父轮廓或内嵌轮廓
  									所以hierarchy向量内所有元素的第3、第4个分量都会被置为-1，具体下文会讲到
  									取值三：CV_RETR_CCOMP  检测所有的轮廓，但所有轮廓只建立两个等级关系，外围为顶层，若外围
  									内的内围轮廓还包含了其他的轮廓信息，则内围内的所有轮廓均归属于顶层
  									取值四：CV_RETR_TREE， 检测所有轮廓，所有轮廓建立一个等级树结构。外层轮廓包含内层轮廓，内
  									层轮廓还可以继续包含内嵌轮廓。
  * method        定义轮廓的近似方法： 取值一：CV_CHAIN_APPROX_NONE 保存物体边界上所有连续的轮廓点到contours向量内
  									取值二：CV_CHAIN_APPROX_SIMPLE 仅保存轮廓的拐点信息，把所有轮廓拐点处的点保存入contours
  									向量内，拐点与拐点之间直线段上的信息点不予保留
  									取值三和四：CV_CHAIN_APPROX_TC89_L1，CV_CHAIN_APPROX_TC89_KCOS使用teh-Chinl chain 近似算法
  * Point         偏移量，所有的轮廓信息相对于原始图像对应点的偏移量，相当于在每一个检测出的轮廓点上加上该偏移量，并且Point还可以是负值
  **/
std::vector <std::vector<cv::Point>> contours;
std::vector <Vec4i> hierarchy;
cv::findContours(canny, contours, hierarchy, cv::RETR_LIST, cv::CHAIN_APPROX_NONE);

霍夫圆检测

/**
  * 霍夫圆检测
  * gray：输入图像（灰度）。
  *	circles：存储套3个的值的矢量：为每个检测到的圆。xcenter,ycenter,r 定义中心位置（xcenter,ycenter），r是半径
  *	HOUGH_GRADIENT：定义检测方法。目前这是OpenCV中唯一可用的。
  * dp = 1：分辨率的反比。
  * min_dist = gray.rows / 16：两个圆心之间的最小距离。若两圆心距离 < minDist，则认为是同一个圆。
  * param_1 = 200：边缘检测的高阈值，低阈值被自动置为高阈值的一半，默认为 100。
  * param_2 = 100 *：累加平面某点是否是圆心的判定阈值。它越大，能通过检测的圆就更接近完美的圆形，默认为 100。
  * min_radius = 0：要检测的最小半径。如果未知，则将零置为默认值。
  * max_radius = 0：要检测的最大半径。如果未知，则将零置为默认值。
  **/
std::vector<cv::Vec3f> pcircles;
cv::HoughCircles(__CircleGrayImage, pcircles, cv::HOUGH_GRADIENT, 1, 5, 100, 100, 0, 0);
for (size_t i = 0; i < pcircles.size(); i++)
{
	Vec3f c = pcircles[i];
	circle(inputImage, Point(c[0], c[1]), c[2], Scalar(0, 0, 255), 3, LINE_AA);
	circle(inputImage, Point(c[0], c[1]), 2, Scalar(0, 255, 0), 3, LINE_AA);
}

测试代码

#include 
#include 
#include 
#include 

using namespace std;

int main()
{
	cv::Mat inputImage = imread("test.png", cv::IMREAD_COLOR);
	// 转换图像类型
	cv::Mat __inputImage;
	cv::Mat __tmpImage;
	cvtColor(inputImage, __tmpImage, cv::COLOR_BGRA2RGB);
	__tmpImage.convertTo(__inputImage, CV_8UC1);

	// 克隆图像
	// 用于检测圆
	cv::Mat __useCircleImage = __inputImage.clone();
	// 用于检测其他图形
	cv::Mat __useOtherImage = __inputImage.clone();
	// 结果图像
	cv::Mat __resultImage = __inputImage.clone();

	// 高斯滤波
	cv::Mat __CircleGaussianBlurImage;
	cv::GaussianBlur(__useCircleImage, __CircleGaussianBlurImage, cv::Size(3, 3), 0);

		
	// 转换为灰度图像
	cv::Mat __CircleGrayImage;
	cv::cvtColor(__CircleGaussianBlurImage, __CircleGrayImage, cv::COLOR_BGR2GRAY);

	
	// Canny边缘检测
	cv::Mat __CircleCannyImage;
	cv::Canny(__CircleGrayImage, __CircleCannyImage, 100, 200);

	std::vector<cv::Vec3f> pcircles;

	// 霍夫圆检测
	/**
		* gray：输入图像（灰度）。
		*	circles：存储套3个的值的矢量：为每个检测到的圆。xcenter,ycenter,r 定义中心位置（xcenter,ycenter），r是半径
		*	HOUGH_GRADIENT：定义检测方法。目前这是OpenCV中唯一可用的。
		* dp = 1：分辨率的反比。
		* min_dist = gray.rows / 16：两个圆心之间的最小距离。若两圆心距离 < minDist，则认为是同一个圆。
		* param_1 = 200：边缘检测的高阈值，低阈值被自动置为高阈值的一半，默认为 100。
		* param_2 = 100 *：累加平面某点是否是圆心的判定阈值。它越大，能通过检测的圆就更接近完美的圆形，默认为 100。
		* min_radius = 0：要检测的最小半径。如果未知，则将零置为默认值。
		* max_radius = 0：要检测的最大半径。如果未知，则将零置为默认值。 
		*/
	//cv::HoughCircles(__CircleCannyImage, pcircles, cv::HOUGH_GRADIENT, 1.2, 100, 130, 38, 20, 100);
	//for (size_t i = 0; i < pcircles.size(); i++)
	//{
	//	cv::Vec3f c = pcircles[i];
	//	//画出圆形
	//	circle(__resultImage, cv::Point(c[0], c[1]), c[2], cv::Scalar(0, 0, 255), 3, cv::LINE_AA);
	//	//画出圆心
	//	circle(__resultImage, cv::Point(c[0], c[1]), 2, cv::Scalar(0, 255, 0), 3, cv::LINE_AA);
	//}

	/* 检测五边形，六边形、三角形 */

	// 转为灰度图像
	cv::Mat __OtherGrayImage;
	cv::cvtColor(__useOtherImage, __OtherGrayImage, cv::COLOR_BGR2GRAY);
   //图像二值化
	cv::Mat __OtherThresholdImage;
	cv::threshold(__OtherGrayImage, __OtherThresholdImage, 0, 255, cv::THRESH_BINARY_INV | cv::THRESH_OTSU);

	// 用于存储Point的向量
	std::vector<std::vector<cv::Point>> __contours;
	std::vector<cv::Vec4i> __hierarchy;

	//发现轮廓
	cv::findContours(__OtherThresholdImage, __contours, __hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
	std::vector<std::vector<cv::Point>> __contourPloy(__contours.size());

	for (size_t i = 0; i < __contours.size(); i++)
	{
		//计算轮廓周长
		double __epsion = 0.02 * cv::arcLength(__contours[i], true);

		/**
		  * approxPolyDP             多边拟合
		  * InputArray curv          输入的点集
		  * OutputArray approxCurve  输出的点集，当前点集是能最小包容指定点集的。画出来即是一个多边形；
		  * double epsilon           指定的精度，也即是原始曲线与近似曲线之间的最大距离。
		  * bool closed              若为true, 则说明近似曲线是闭合的，反之，若为false，则断开。
		  **/
			
		cv::approxPolyDP(cv::Mat(__contours[i]), __contourPloy[i], __epsion, true);
		// 计算中心距
		cv::Moments moment = cv::moments(__contours[i]);
		//重心
		int x = (int)(moment.m10 / moment.m00);
		int y = (int)(moment.m01 / moment.m00);

		// 定义多种种颜色
		const cv::Scalar blue  = cv::Scalar(255, 0, 0);     // 三角形
		const cv::Scalar green = cv::Scalar(0, 255, 0);     // 四边形
		const cv::Scalar red   = cv::Scalar(0, 0, 255);     // 五边形
		const cv::Scalar orange = cv::Scalar(255, 128, 0);  // 六边形
		const cv::Scalar violet = cv::Scalar(255, 0, 255);  // 星
		const cv::Scalar cyan = cv::Scalar(128, 138, 135);  // 圆

		//三角形检测
		if (__contourPloy[i].size() == 3)
		{
			string tempText = "triangle";
			putText(__resultImage, tempText, cv::Point(x - 20, y), cv::FONT_HERSHEY_PLAIN, 0.7, cv::Scalar(0, 0, 0), 1, 8, false);
			drawContours(__resultImage, __contours, i, blue, 2);
		}
		// 四边形检测
		else if (__contourPloy[i].size() == 4)
		{
			string tempText = "quadrangle";
			putText(__resultImage, tempText, cv::Point(x - 20, y), cv::FONT_HERSHEY_PLAIN, 0.7, cv::Scalar(0, 0, 0), 1, 8, false);
			drawContours(__resultImage, __contours, i, green, 2);
		}
		//判断为五边形
		else if (__contourPloy[i].size() == 5)
		{
			string tempText = "pentagon";
			putText(__resultImage, tempText, cv::Point(x - 20, y), cv::FONT_HERSHEY_PLAIN, 0.7, cv::Scalar(0, 0, 0), 1, 8, false);
			drawContours(__resultImage, __contours, i, red, 2);
		}
		//判断为六边形
		else if (__contourPloy[i].size() == 6)
		{
			string tempText = "hexagon";
			putText(__resultImage, tempText, cv::Point(x - 20, y), cv::FONT_HERSHEY_PLAIN, 0.7, cv::Scalar(0, 0, 0), 1, 8, false);
			drawContours(__resultImage, __contours, i, orange, 2);
		}
		// 判断为圆形或者是星星
		else if (__contourPloy[i].size() >= 10)
		{
			drawContours(__resultImage, __contours, i, violet, 2);

			double P = cv::arcLength(__contourPloy[i], true);
			double A = cv::contourArea(__contourPloy[i]);

			double K = pow(P, 2) / (4 * A * 3.1415926);
			

			if (K < 1.2)
			{
				string tempText = "circle";
				putText(__resultImage, tempText, cv::Point(x - 20, y), cv::FONT_HERSHEY_PLAIN, 0.7, cv::Scalar(0, 0, 0), 1, 8, false);
			}
			else
			{
				string tempText = "star";
				putText(__resultImage, tempText, cv::Point(x - 20, y), cv::FONT_HERSHEY_PLAIN, 0.7, cv::Scalar(0, 0, 0), 1, 8, false);
			}

		}
		// 无法判断或者误判断的图形
		else
		{
			drawContours(__resultImage, __contours, i, cyan, 2);

			double P = cv::arcLength(__contourPloy[i], true);
			double A = cv::contourArea(__contourPloy[i]);

			double K = pow(P, 2) / (4 * A * 3.1415926);


			if (K < 1.2)
			{
				string tempText = "circle";
				putText(__resultImage, tempText, cv::Point(x - 20, y), cv::FONT_HERSHEY_PLAIN, 0.7, cv::Scalar(0, 0, 0), 1, 8, false);
			}
		}
	}

	imshow("边缘检测结果", __resultImage);


	cv::waitKey();
	return 0;
}

效果图