C++ Opencv4.5.5 多边形拟合 findContours()检测物体轮廓 (三角形、圆形、四边形、五边形、六边形、星形)
文章目录
- 1 轮廓查找 findContours(）函数介绍
- 2 霍夫圆检测
- 3 测试代码
1 轮廓查找 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 > contours;
std::vector hierarchy;
cv::findContours(canny, contours, hierarchy, cv::RETR_LIST, cv::CHAIN_APPROX_NONE);
2 霍夫圆检测
/**
* 霍夫圆检测
* 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 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);
}
3 测试代码
#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 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> __contours;
std::vector __hierarchy;
//发现轮廓
cv::findContours(__OtherThresholdImage, __contours, __hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
std::vector> __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;
}
效果图
c++ opencv4.5.5多边形拟合 检测出物体轮廓 cv::findContours (三角形、圆形、四边形、五边形、六边形、星形)