Opencv moment contours PointTest

最新推荐文章于 2024-09-10 17:47:11 发布
最新推荐文章于 2024-09-10 17:47:11 发布
阅读量565 收藏
点赞数
分类专栏： 矩 ，轮廓、点 线，外接矩形， 三角形，圆，检测点与轮廓的关系 文章标签： opencv 关于矩 轮廓的函数调用示例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012917416/article/details/78623887
版权
本文详细介绍了OpenCV库中用于轮廓检测、矩计算的相关函数，包括approxPolyDP、arcLength、boundingRect、boxPoints、connectedComponents等，通过实例展示了如何使用这些函数进行图像分析和形状描述。
摘要由CSDN通过智能技术生成 
#include "stdafx.h"
#include "StructuralAnalysisAndShapeDescriptors.h"
using namespace cv;

StructuralAnalysisAndShapeDescriptors::StructuralAnalysisAndShapeDescriptors()
{
}


StructuralAnalysisAndShapeDescriptors::~StructuralAnalysisAndShapeDescriptors()
{
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_approxPolyDP(Mat &src)
{
	// 用指点的精度近似一个多边形
	// epsilon 的值越大，越接近多边形，越小越接近于圆
	Mat _src;
	cvtColor(src, _src, CV_BGR2GRAY);
	Mat blurMat, edgeMat, labels;
	GaussianBlur(_src, blurMat, Size(3, 3), 0.8);
	Canny(blurMat, edgeMat, 70, 155);
	std::vector<std::vector<Point>> contours;
	std::vector<std::vector<Point>> contoursDst;
	std::vector<Vec4i>hierarchy;
	findContours(edgeMat, contours, hierarchy, RetrievalModes::RETR_TREE, ContourApproximationModes::CHAIN_APPROX_SIMPLE);
	contoursDst.resize(contours.size());
	int k = 0;
	for (; k < contours.size(); k++)
	{
		approxPolyDP(Mat(contours[k]), contoursDst[k], 0.1, true);
	}
	for (k = 0; k < contoursDst.size(); k++)
	{
		drawContours(src, contoursDst, k, Scalar(0, 255, 0), 1, LineTypes::LINE_8, hierarchy);
	}
	imwrite("polylines.jpg", src);

}
void StructuralAnalysisAndShapeDescriptors::OpenCV_arcLength(Mat &src)
{
	Mat _src;
	cvtColor(src, _src, CV_BGR2GRAY);
	Mat blurMat, edgeMat, labels;
	GaussianBlur(_src, blurMat, Size(3, 3), 0.8);
	Canny(blurMat, edgeMat, 70, 155);
	std::vector<std::vector<Point>> contours;
	std::vector<Vec4i>hierarchy;
	findContours(edgeMat, contours, hierarchy, RetrievalModes::RETR_TREE, ContourApproximationModes::CHAIN_APPROX_NONE);

	for (int k = 0; k < contours.size(); k++)
	{
		polylines(src, contours[k], false, Scalar(0, 0, 255));

	}
	imwrite("polylines.jpg", src);
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_boundingRect(Mat &src)
{
	// 获取最大外接矩形
	// points 输入的点
	std::vector<Point> pt(10);
	for (int i = 0; i < 10; i++)
	{
		pt[i] = (Point((rand() &600), (rand() & 500)));
		drawMarker(src, pt[i], Scalar(255, 255, 255), MarkerTypes::MARKER_CROSS, 20, 5);
	}
	//Rect rect = boundingRect(Mat(pt));
	Rect rect = boundingRect(pt);
	rectangle(src, rect, Scalar(0, 0, 255));
	imwrite("OpenCV_boundingRect.jpg", src);
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_boxPoints(Mat &src)
{
	// 绘制旋转矩形
	RotatedRect rRect = RotatedRect(Point2f(300, 300), Size2f(100, 200), 30);
	
	//ellipse(src, rRect, Scalar(0, 255, 0));
	
	Mat mat;
	Point2f pt[4];
	rRect.points(pt);
	// boxPoints 这个函数封装有错误，这里直接调用 rRect.points(pt)就可以得到旋转矩形的四个顶点
	// 然后通过画首尾相连的线就可以绘制出旋转矩形了

	for (int r = 0; r < 4; r++)
	{
		line(src, pt[r], pt[(r + 1)%4], Scalar(0, 0, 255));
	}
	imwrite("boxPoints_Rect.jpg", src);
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_connectedComponents(Mat &src)
{
	Mat _src;
	cvtColor(src, _src, CV_BGR2GRAY);
	Mat blurMat, edgeMat, labels;
	GaussianBlur(_src, blurMat, Size(3, 3), 0.8);
	Canny(blurMat, edgeMat, 70, 155);
	std::vector<std::vector<Point>> contours;
	std::vector<Vec4i>hierarchy;
	int iNum = connectedComponents(edgeMat, labels, 8, CV_32S);
	normalize(labels, labels, 255);
	imwrite("normalize.jpg", labels);
	printf("%d", iNum);
	std::vector<Vec3b>colors(iNum);
	colors[0] = Vec3b(0, 0, 0); // 背景颜色
    // 生成随机颜色表，用来标记每个连通域
	for (int i = 1; i < iNum; i++)
	{
		colors[i] = Vec3b((rand() & 255), (rand() & 255), (rand() & 255));
	}
	Mat dst = Mat(src.size(), CV_8UC3);
	for (int r = 0; r < dst.rows; r++)
	{
		for (int c = 0; c < dst.cols; c++)
		{
			int label = labels.at<int>(r, c);
			Vec3b &pix = dst.at<Vec3b>(r, c);
			pix = colors[label];
		}
	}
	imwrite("boxPoints_Rect.jpg", dst);
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_connectedComponentsWithStats()
{
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_contourArea(Mat &src)
{
	Mat _src;
	cvtColor(src, _src, CV_BGR2GRAY);
	Mat blurMat, edgeMat, labels;
	GaussianBlur(_src, blurMat, Size(3, 3), 0.8);
	Canny(blurMat, edgeMat, 70, 155);
	std::vector<std::vector<Point>> contours;
	std::vector<Vec4i>hierarchy;
	findContours(edgeMat, contours, hierarchy, RetrievalModes::RETR_TREE, ContourApproximationModes::CHAIN_APPROX_NONE);

	for (int k = 0; k < contours.size(); k++)
	{
		double dArea = contourArea(contours[k]);
		printf("%lf\r\n", dArea);
	}
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_convexHull(Mat &src)
{
	Mat _src;
	cvtColor(src, _src, CV_BGR2GRAY);
	Mat blurMat, edgeMat, labels;
	GaussianBlur(_src, blurMat, Size(3, 3), 0.8);
	Canny(blurMat, edgeMat, 70, 155);
	std::vector<std::vector<Point>> contours;
	std::vector<Vec4i>hierarchy;
	findContours(edgeMat, contours, hierarchy, RetrievalModes::RETR_TREE, ContourApproximationModes::CHAIN_APPROX_NONE);
	std::vector<Point> hull;
	
	for (int k = 0; k < contours.size(); k++)
	{
		double dArea = contourArea(contours[k]);
		convexHull(contours[k], hull);
		int iNum = (int)hull.size();
		for (int i =0; i < iNum; i++)
		{
			if (i %3 == 0)
			{
				line(src, hull[i], hull[(i + 1) % iNum], Scalar(0, 255, 0));
			}
		}
		imwrite("OpenCV_convexHull.jpg", src);
	}
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_convexityDefects(Mat &src)
{
	Mat _src;
	cvtColor(src, _src, CV_BGR2GRAY);
	Mat blurMat, edgeMat, labels;
	GaussianBlur(_src, blurMat, Size(3, 3), 0.8);
	Canny(blurMat, edgeMat, 70, 155);
	std::vector<std::vector<Point>> contours;
	std::vector<Vec4i>hierarchy;
	findContours(edgeMat, contours, hierarchy, RetrievalModes::RETR_TREE, ContourApproximationModes::CHAIN_APPROX_NONE);


	std::vector<std::vector<Point> >hull(contours.size());
	// Int type hull  
	std::vector<std::vector<int>> hullsI(contours.size());
	// Convexity defects  
	std::vector<std::vector<Vec4i>> defects(contours.size());

	for (size_t i = 0; i < contours.size(); i++)
	{
		convexHull(Mat(contours[i]), hull[i], false);
		// find int type hull  
		convexHull(Mat(contours[i]), hullsI[i], false);
		// get convexity defects  
		convexityDefects(Mat(contours[i]), hullsI[i], defects[i]);
	}
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_findContours(Mat src, Mat &dst)
{
	Mat _src;
	cvtColor(src, _src, CV_BGR2GRAY);
	Mat blurMat, edgeMat,labels;
	GaussianBlur(_src, blurMat, Size(3, 3), 0.8);
	Canny(blurMat, edgeMat, 70, 155);
	std::vector<std::vector<Point>> contours;
	std::vector<Vec4i>hierarchy;
	findContours(edgeMat, contours, hierarchy, RetrievalModes::RETR_TREE, ContourApproximationModes::CHAIN_APPROX_NONE);

	for (int k = 0; k >= 0; k= hierarchy[k][3])
	{
		drawContours(src, contours, k, Scalar(0, 255, 0), FILLED, LineTypes::LINE_4, hierarchy);
		
		//rectangle(_src, boundingRect(contours[k]), Scalar(0, 0, 255));
	}
	dst = src;
	imwrite("rect.jpg", src);
	imshow("drawContours", src);
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_fitEllipse(Mat &src)
{
	std::vector<Point> pt(10);
	for (int i =0; i < 10; i++)
	{
		pt[i] = Point(rand()&200,rand()&300);
	}
	RotatedRect rRect = fitEllipse(pt);
	ellipse(src, rRect, Scalar(0, 255, 0),2);
	imwrite("fitEllipse.jpg", src);
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_fitLine(Mat &src)
{
	std::vector<Point> pt(10);
	Vec4f vec;
	for (int i = 0; i < 10; i++)
	{
		pt[i] = Point(rand() & 400, rand() & 200);
	}
	for (int j = 0; j < 10; j++)
	{
		drawMarker(src, pt[j], Scalar(0, 0, 255));
	}
	fitLine(pt, vec,DistanceTypes::DIST_L2,0,10,0.01);
	Point ptOri;
	ptOri.x = vec[2];
	ptOri.y = vec[3];
	double K = vec[1] / vec[0];

	Point pt1, pt2;
	pt1.x = 0;
	pt1.y = K *(pt1.x - ptOri.x) + ptOri.y;

	pt2.x = src.cols;
	pt2.y = K *(pt2.x - ptOri.x) + ptOri.y;
	line(src, pt1, pt2, Scalar(0, 0, 255),2);
	imwrite("fitLine.jpg", src);
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_HuMoments(Mat &src)
{
	// 通过hu矩，可以计算轮廓的相似度，hu矩的第一个值越接近，相似度越高。
	Mat _src;
	cvtColor(src, _src, CV_BGR2GRAY);
	Mat blurMat, edgeMat, labels;
	GaussianBlur(_src, blurMat, Size(3, 3), 0.8);
	Canny(blurMat, edgeMat, 70, 155);
	std::vector<std::vector<Point>> contours;
	std::vector<Vec4i>hierarchy;
	findContours(edgeMat, contours, hierarchy, RetrievalModes::RETR_TREE, ContourApproximationModes::CHAIN_APPROX_NONE);
	double hu[7];
	for (int k = 0; k < contours.size(); k++)
	{
		Moments mem = moments(contours[k]);
		//HuMoments(mem, hu);
		printf(" mem.m00: %lf,\r\n mem.m10: %lf,\r\n mem.m01: %lf,\r\n mem.m20: %lf,\r\n mem.m11: %lf,\r\n mem.m02: %lf, mem.m30: %lf,\r\n mem.m21: %lf,\r\n mem.m12: %lf,\r\n mem.m03: %lf\r\n", mem.m00, mem.m10, mem.m01, mem.m20, mem.m11, mem.m02, mem.m30, mem.m21, mem.m12, mem.m03);
		double dArea = contourArea(contours[k]);
		printf(" Area: %lf\r\n", dArea);
		HuMoments(mem, hu);
		printf(" hu[0]: %lf,\r\n hu[1]: %lf,\r\n hu[2]: %lf,\r\n hu[3]: %lf,\r\n hu[4]: %lf,\r\n hu[5]: %lf,\r\n hu[6]: %lf,\r\n", hu[0], hu[1], hu[2], hu[3], hu[4], hu[5], hu[6]);
		//for (int i = 0; i < 7; i++)
		//{
		//	
		//}
		getchar();
	}


}
void StructuralAnalysisAndShapeDescriptors::OpenCV_intersectConvexConvex(Mat &src)
{
	std::vector<Point> pt1(4), pt2(4), pt12;
	pt1[0] = Point(80, 150);
	pt1[1] = Point(200, 150);
	pt1[3] = Point(80, 300);
	pt1[2] = Point(200, 300);

	pt2[0] = Point(80, 150); 
	pt2[1] = Point(200, 150);
	pt2[3] = Point(80,300);
	pt2[2] = Point(200, 300);
	// 这里的返回值 i 就代表交集区域轮廓的周长
	float i = intersectConvexConvex(pt1, pt2, pt12);
	for (int j = 0; j < pt1.size(); j++)
	{
		line(src, pt1[j], pt1[(j + 1) % 4], Scalar(0, 255, 0));
	}
	for (int j = 0; j < pt2.size(); j++)
	{
		line(src, pt2[j], pt2[(j + 1) % 4], Scalar(255, 0, 0));
	}
	for (int j =0; j < pt12.size(); j++)
	{
		line(src, pt12[j], pt12[(j + 1) % 4], Scalar(0, 0, 255));
		printf("x: %d, y: %d\r\n", pt12[j].x, pt12[j].y);
	}
	imwrite("intersectConvexConvex.jpg", src);
	getchar();
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_isContourConvex(Mat &src)
{
	std::vector<Point> pt1(4), pt2(4), pt12;
	pt1[0] = Point(80, 150);
	pt1[1] = Point(200, 150);
	pt1[3] = Point(80, 300);
	pt1[2] = Point(200, 300);

	pt2[0] = Point(80, 150);
	pt2[1] = Point(200, 150);
	pt2[3] = Point(80, 300);
	pt2[2] = Point(200, 300);
	// 这里的返回值 i 就代表交集区域轮廓的周长
	float i = intersectConvexConvex(pt1, pt2, pt12);
	for (int j = 0; j < pt1.size(); j++)
	{
		line(src, pt1[j], pt1[(j + 1) % 4], Scalar(0, 255, 0));
	}
	for (int j = 0; j < pt2.size(); j++)
	{
		line(src, pt2[j], pt2[(j + 1) % 4], Scalar(255, 0, 0));
	}

	bool b = isContourConvex(pt12);
	if (b)
	{
		printf("Is Contour Convex");
	}
	imwrite("intersectConvexConvex.jpg", src);

	getchar();
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_matchShapes(Mat &src)
{
	std::vector<Point> pt1(4), pt2(4), pt12;
	pt1[0] = Point(60, 60);
	pt1[1] = Point(200, 60);
	pt1[2] = Point(200, 300);
	pt1[3] = Point(200, 300);

	pt2[0] = Point(80, 150);
	pt2[1] = Point(200, 150);
	pt2[3] = Point(80, 300);
	pt2[2] = Point(200, 300);
	// 这里的返回值 i 就代表交集区域轮廓的周长
	float i = intersectConvexConvex(pt1, pt2, pt12);
	for (int j = 0; j < pt1.size(); j++)
	{
		line(src, pt1[j], pt1[(j + 1) % 4], Scalar(0, 255, 0));
	}
	for (int j = 0; j < pt2.size(); j++)
	{
		line(src, pt2[j], pt2[(j + 1) % 4], Scalar(255, 0, 0));
	}
	for (int j = 0; j < pt12.size(); j++)
	{
		line(src, pt12[j], pt12[(j + 1) % pt12.size()], Scalar(0, 0, 255));
		printf("x: %d, y: %d\r\n", pt12[j].x, pt12[j].y);
	}
	// 返回值越大，说明两个轮廓的相似度越低
	double d = matchShapes(pt1, pt2, ShapeMatchModes::CONTOURS_MATCH_I1, 0);
	imwrite("intersectConvexConvex.jpg", src);
	printf("d: %lf", d);
	getchar();
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_minAreaRect(Mat &src)
{
	std::vector<Point> pt1(4), pt2(4), pt12;
	pt1[0] = Point(60, 60);
	pt1[1] = Point(200, 60);
	pt1[2] = Point(200, 300);
	pt1[3] = Point(200, 300);

	pt2[0] = Point(80, 150);
	pt2[1] = Point(200, 150);
	pt2[3] = Point(80, 300);
	pt2[2] = Point(200, 300);
	// 这里的返回值 i 就代表交集区域轮廓的周长
	float i = intersectConvexConvex(pt1, pt2, pt12);
	for (int j = 0; j < pt1.size(); j++)
	{
		line(src, pt1[j], pt1[(j + 1) % 4], Scalar(0, 255, 0));
	}
	for (int j = 0; j < pt2.size(); j++)
	{
		line(src, pt2[j], pt2[(j + 1) % 4], Scalar(255, 0, 0));
	}
	for (int j = 0; j < pt12.size(); j++)
	{
		line(src, pt12[j], pt12[(j + 1) % pt12.size()], Scalar(0, 0, 255));
		printf("x: %d, y: %d\r\n", pt12[j].x, pt12[j].y);
	}
	RotatedRect rRect = minAreaRect(pt12);
	Point2f pt[4];
	
	rRect.points(pt);
	for (int j = 0; j < 4; j++)
	{
		line(src, pt[j], pt[(j + 1) % 4], Scalar(0, 0, 255));
		printf("x: %lf, y: %lf\r\n", pt[j].x, pt[j].y);
	}
	imwrite("intersectConvexConvex.jpg", src);
	getchar();
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_minEnclosingCircle(Mat &src)
{
	std::vector<Point> pt1(4), pt2(4), pt12;
	pt1[0] = Point(60, 60);
	pt1[1] = Point(200, 60);
	pt1[2] = Point(200, 300);
	pt1[3] = Point(200, 300);

	pt2[0] = Point(80, 150);
	pt2[1] = Point(200, 150);
	pt2[3] = Point(80, 300);
	pt2[2] = Point(200, 300);
	// 这里的返回值 i 就代表交集区域轮廓的周长
	float i = intersectConvexConvex(pt1, pt2, pt12);
	for (int j = 0; j < pt1.size(); j++)
	{
		line(src, pt1[j], pt1[(j + 1) % 4], Scalar(0, 255, 0));
	}
	for (int j = 0; j < pt2.size(); j++)
	{
		line(src, pt2[j], pt2[(j + 1) % 4], Scalar(255, 0, 0));
	}
	for (int j = 0; j < pt12.size(); j++)
	{
		line(src, pt12[j], pt12[(j + 1) % pt12.size()], Scalar(0, 0, 255));
		printf("x: %d, y: %d\r\n", pt12[j].x, pt12[j].y);
	}
	Point2f pCenter;
	float r;
	// 获取点集的外接圆圆心和半径
	minEnclosingCircle(pt12, pCenter, r);
	circle(src, pCenter, r, Scalar(255, 0, 255));
	printf("x: %f, y: %f, R: %f\r\n", pCenter.x, pCenter.y, r);
	imwrite("intersectConvexConvex.jpg", src);
	getchar();
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_minEnclosingTriangle(Mat &src)
{
	std::vector<Point> pt1(4), pt2(4), pt12;
	pt1[0] = Point(60, 60);
	pt1[1] = Point(200, 60);
	pt1[2] = Point(200, 300);
	pt1[3] = Point(200, 300);

	pt2[0] = Point(80, 150);
	pt2[1] = Point(200, 150);
	pt2[3] = Point(80, 300);
	pt2[2] = Point(200, 300);
	// 这里的返回值 i 就代表交集区域轮廓的周长
	float i = intersectConvexConvex(pt1, pt2, pt12);
	for (int j = 0; j < pt1.size(); j++)
	{
		line(src, pt1[j], pt1[(j + 1) % 4], Scalar(0, 255, 0));
	}
	for (int j = 0; j < pt2.size(); j++)
	{
		line(src, pt2[j], pt2[(j + 1) % 4], Scalar(255, 0, 0));
	}
	for (int j = 0; j < pt12.size(); j++)
	{
		line(src, pt12[j], pt12[(j + 1) % pt12.size()], Scalar(0, 0, 255));
		printf("x: %d, y: %d\r\n", pt12[j].x, pt12[j].y);
	}
	std::vector<Point> ptTriangle;
	// 获取外接三角形的三个顶点
	minEnclosingTriangle(pt12, ptTriangle);
	for (int j = 0; j < ptTriangle.size(); j++)
	{
		line(src, ptTriangle[j], ptTriangle[(j + 1) % ptTriangle.size()], Scalar(255, 255, 255));
		printf("x: %d, y: %d\r\n", ptTriangle[j].x, ptTriangle[j].y);
	}
	imwrite("intersectConvexConvex.jpg", src);
	getchar();
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_moments(Mat &src)
{
	// 通过矩，可以计算轮廓的中心、面积等信息。
	Mat _src;
	cvtColor(src, _src, CV_BGR2GRAY);
	Mat blurMat, edgeMat, labels;
	GaussianBlur(_src, blurMat, Size(3, 3), 0.8);
	Canny(blurMat, edgeMat, 70, 155);
	std::vector<std::vector<Point>> contours;
	std::vector<Vec4i>hierarchy;
	findContours(edgeMat, contours, hierarchy, RetrievalModes::RETR_TREE, ContourApproximationModes::CHAIN_APPROX_NONE);
	double hu[7];
	for (int k = 0; k < contours.size(); k++)
	{
		Moments mem = moments(contours[k]);
		//HuMoments(mem, hu);
		printf(" mem.m00: %lf,\r\n mem.m10: %lf,\r\n mem.m01: %lf,\r\n mem.m20: %lf,\r\n mem.m11: %lf,\r\n mem.m02: %lf, mem.m30: %lf,\r\n mem.m21: %lf,\r\n mem.m12: %lf,\r\n mem.m03: %lf\r\n", mem.m00, mem.m10, mem.m01, mem.m20, mem.m11, mem.m02, mem.m30, mem.m21, mem.m12, mem.m03);
		double dArea = contourArea(contours[k]);
		printf(" Area: %lf\r\n", dArea);
		getchar();
	}

}
void StructuralAnalysisAndShapeDescriptors::OpenCV_pointPolygonTest(Mat &src)
{
	Mat _src;
	cvtColor(src, _src, CV_BGR2GRAY);
	Mat blurMat, edgeMat, labels;
	GaussianBlur(_src, blurMat, Size(3, 3), 0.8);
	Canny(blurMat, edgeMat, 70, 155);
	std::vector<std::vector<Point>> contours;
	std::vector<Vec4i>hierarchy;
	findContours(edgeMat, contours, hierarchy, RetrievalModes::RETR_TREE, ContourApproximationModes::CHAIN_APPROX_NONE);
	Point2f pCenter(_src.cols / 2,_src.rows/2);
	for (int k = 0; k < contours.size(); k++)
	{
		// 返回值 0 代表在轮廓上
		// -1 代表在轮廓外
		// 1 代表在轮廓内

		double d = pointPolygonTest(contours[k], pCenter, false);
		printf("d: %lf\r\n", d);
		getchar();
	}
	imwrite("intersectConvexConvex.jpg", src);
	
}
void StructuralAnalysisAndShapeDescriptors::OpenCV_rotatedRectangleIntersection(Mat &src)
{
	// 返回两个旋转矩形的的所有交点
	// 如果只是返回两个旋转矩形的所有交点，不绘制相交区域，可以调用函数
	// rotatedRectangleIntersection 得到交点坐标。
	// 返回值代表相交区域的个数

	// 如果要绘制相交区域，建议使用intersectConvexConvex函数，
	// 得到有序的交点坐标，便于标记相交区域
	RotatedRect rRect1 = RotatedRect(Point2f(200, 200), Size2f(100, 100), 30);
	RotatedRect rRect2 = RotatedRect(Point2f(250, 250), Size2f(200, 200), 90);
	std::vector
  
  
   
    vectorpt1(4), vectorpt2(4), pt,ptApproch;
	Point2f pt1[4];
	rRect1.points(pt1);
	for (int j = 0; j < 4; j++)
	{
		vectorpt1[j] = pt1[j];
		line(src, pt1[j], pt1[(j + 1) % 4], Scalar(0, 255, 0));
	}
	Point2f pt2[4];
	rRect2.points(pt2);
	for (int j = 0; j < 4; j++)
	{
		vectorpt2[j] = pt2[j];
		line(src, pt2[j], pt2[(j + 1) % 4], Scalar(255, 0, 0));
	}
	float f = intersectConvexConvex(vectorpt1, vectorpt2, pt);
	for (int j =0; j <  pt.size(); j++)
	{
		line(src, pt[j], pt[(j + 1) % pt.size()], Scalar(125, 125, 255));
	}
	imwrite("intersectConvexConvex.jpg", src);
	printf("f: %f\r\n", f);
	getchar();
}
  
  








                

        

        

    

  


    

      

        

            

              
                
                  一天一页回忆
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
opencv学习（二十五）①计算轮廓的矩moments()&面积contourArea()②分水岭算法函数watershed()！！待深入！！//③图像修补inpaint()

				
			

			

				

					Zeking的博客
				

				

					05-07
					
					992
					
				

			

		

		

			
				
1,计算轮廓的矩moments()&amp;amp;面积contourArea()

 
 
 
 




实例1，（从而求面积，长度）



待，对比参考书中程序发现错误



#include&amp;lt;opencv2/opencv.hpp&amp;gt;
using namespace cv;
using namespace std;

#define Windows_name1&quot;【原始图】&quot;
#define...

			
		

	



                

              
                



	

		

			

				
					
Opencv-contours、minAreaRect测量物体偏转角度（附代码段）

				
			

			

				

					T_just_for_tomorrow的博客
				

				

					01-26
					
					5330
					
				

			

		

		

			
				
Opencv-contours、minAreaRect测量物体偏转角度（附代码段）

			
		

	



                


  
              

                


	

		

			

				
					
Opencv ,contour moments

				
			

			

				

					NaxeXia的博客
				

				

					01-04
					
					1887
					
				

			

		

		

			
				
http://docs.opencv.org/trunk/dd/d49/tutorial_py_contour_features.html


Goal 
In this article, we will learn

To find the different features of contours, like area, perimeter, centroid, bounding

			
		

	





	

		

			

				
					
OpenCV结构分析与形状描述符（16）判断两个凸多边形是否相交的函数intersectConvexConvex()的使用

					
最新发布

				
			

			

				

					jndingxin的专栏
				

				

					09-10
					
					593
					
				

			

		

		

			
				
intersectConvexConvex 是一个在 OpenCV 中用于判断两个凸多边形是否相交的函数。此函数可以帮助我们确定两个二维凸多边形是否在平面上有重叠区域。

			
		

	



		

			
		



	

		

			

				
					
探究opencv中的moments函数和HuMoments函数

				
			

			

				

					傲笑风的博客
				

				

					11-26
					
					9385
					
				

			

		

		

			
				
用过opencv的人都可能接触过轮廓，一般获取轮廓后我们都需要根据轮廓的特征来筛选出我们要找的目标物体，而筛选轮廓的常用办法都是基于轮廓的周长和面积，然后返回目标轮廓的最小矩阵把目标在原图像上标框出来。

**
一、moment()
**
但是在轮廓特征函数有这样一个函数：moment()，这个函数是用来求图像的矩（注意：不是hu不变矩）。可能大家经常都看见过用这个函数来求轮廓的质心：
mu...

			
		

	





	

		

			

				
					
opencv-Point Polygon Test

				
			

			

				

					Ant for life.
				

				

					04-13
					
					3154
					
				

			

		

		

			
				
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include 
#include 
#include 

using namespace cv;
using namespace std;

int main( int argc, char** argv )
{
  
  const in

			
		

	





	

		

			

				
					
opencv 对hu不变矩的测试程序cvGetHuMoments

				
			

			

				

					DepaJun的专栏
				

				

					01-11
					
					1069
					
				

			

		

		

			
				
// mytesr1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include    
#include    
#include    
#include    
#include    
#include    
#include    
#include    
#

			
		

	





	

		

			

				
					
Opencv 图像处理-Contours函数提取轮廓及感兴趣区域ROI的必用且实用操作技巧-(涵盖Contours的一切使用基础，附代码段)

				
			

			

				

					T_just_for_tomorrow的博客
				

				

					01-26
					
					6761
					
				

			

		

		

			
				
Opencv 图像处理-Contours函数提取轮廓及感兴趣区域ROI的必用且实用操作技巧-(涵盖Contours的一切使用基础，附代码段)

			
		

	





	

		

			

				
					
opencv contours的问题

				
			

			

				

					yiqiudream的博客
				

				

					07-08
					
					2万+
					
				

			

		

		

			
				
第一个问题：
问题：假如我有如下一张图，我要把边上两个小点去除，又要保留大轮廓内部的空洞，怎么办？


函数原型：

C++: void findContours(InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=

			
		

	





	

		

			

				
					
Opencv contours找出最大轮廓

				
			

			

				

					Janine_1991的博客
				

				

					03-11
					
					8921
					
				

			

		

		

			
				
在处理二值图像时，常用 cv2.findContours 查找轮廓，如下所示:
# find all cohntours
contours,hierarchy=cv2.findContours(binary,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)

binary 代表二值图像；
之后可以用lambda 表达式对 contours 排序,如下所示:
contours.sort(key=lambda c: cv2.contourArea(c), reverse=True)

c

			
		

	





	

		

			

				
					
Opencv-Python Contour Shape Detection 轮廓形状检测

				
			

			

				

					qq_50394133的博客
				

				

					11-11
					
					4591
					
				

			

		

		

			
				
基本思路
首先，先将图像进行灰度处理，在借助模糊处理，得到边缘检测图像；接着，借用边缘检测图像，获取图像轮廓参数，通过面积，以及边框数，检测出图形的形状。OK,Let‘s go！
Opencv版本
这个opencv-contrib-python ，这是个辅助包，最好都装上且跟opencv同版本最优。

函数介绍
cv2.findContours（）
注意事项

读取的是二值图像，黑色为背景，白色为读取目标
该函数会修改原图像，需要先copy一份原图像
返回的参数，会随着opencv不同版本,返回参数个数不同

			
		

	





	

		

			

				
					
Android Opencv（四）

				
			

			

				

					danfengw的博客
				

				

					12-26
					
					523
					
				

			

		

		

			
				
图层金字塔与reSize

Pyramid中文金字塔，因此pyrDown和pyrUp函数也是十分形象的， 
pyrDown和pyrUp都是先进行了5x5的高斯模糊，之后 
pyrDown(src, dst, dstsize)；

角点检测

goodFeaturesToTrack(image, corners, maxCorners, qualityLevel, minDistance) 
ima

			
		

	





	

		

			

				
					
opencv-api moments

				
			

			

				

					Claroja
				

				

					11-02
					
					274
					
				

			

		

		

			
				
retval	=	cv.moments(	array[, binaryImage]	)





参数
描述




retval
返回值，空间矩，中心矩，中心归一化矩


array
轮廓数组


参考文献:
https://docs.opencv.org/3.4.3/d3/dc0/group__imgproc__shape.html#ga556a180f43cab22649c23ada36a8...

			
		

	





	

		

			

				
					
moments

				
			

			

				

					Allyli0022的专栏
				

				

					04-04
					
					919
					
				

			

		

		

			
				
dummy function that adds OpenCV C header files in C file8.4.2.29.0. (cvMoments array moments binary) 
(packages/opencv/moments.lsh)/*F///////////////////////////////////////////////////////////////////

			
		

	





	

		

			

				
					
【opencv练习36 - 图像moment】

				
			

			

				

					Mittens 的专栏
				

				

					09-14
					
					522
					
				

			

		

		

			
				
/*******************************************************************
    测试程序【目标面积】
    时间：2016年9月3日
********************************************************************/

			
		

	





	

		

			

				
					
opencv学习_10 (图像和轮廓的匹配(hu矩))

					
热门推荐

				
			

			

				

					小村长技术blog
				

				

					11-08
					
					12万+
					
				

			

		

		

			
				
图像和轮廓的匹配(hu矩) 
(1)hu矩的概念，我也总结了但是我不过多的阐述，因为我也不是太理解，只知道它具有平移，旋转，尺度不变性，详细见别人的这篇
blog：http://blog.csdn.net/wrj19860202/article/details/6327094
(2)opencv 的实现——计算hu矩
普通矩和中心矩的计算

    Void cvMoments（con

			
		

	





	

		

			

				
					
opencv里的Moments成员变量的理解

				
			

			

				

					qq_41839450的博客
				

				

					03-21
					
					724
					
				

			

		

		

			
				
https://blog.csdn.net/ZZS_SZZ/article/details/84778584


			
		

	





	

		

			

				
					
OpenCV4学习笔记（25）——凸包检测

				
			

			

				

					邱小兵的博客
				

				

					03-14
					
					8350
					
				

			

		

		

			
				
今天要整理的笔记是关于图像凸包检测的内容，首先需要了解什么是凸包。
1. 凸包的含义
凸包，是图形学中的一个概念，指的是一个完全凸起、没有凹处的多边形，也叫凸多边形，一般来说，凸包都是伴随着某个点集存在的，也被称为某个点集的凸包。
对于一个点集而言，如果存在一个凸多边形完全地包含了这个点集的所有点，也就是说该点集内的点要么在这个凸多边形的边上，要么就是在这个凸多边形的内部，那么就称这个凸多边形是这...

			
		

	





	

		

			

				
					
OpenCV 4.x API 详解与C++实例-结构分析和形状描述

				
			

			

				

					视觉与物联智能
				

				

					01-10
					
					1049
					
				

			

		

		

			
				
第九节 结构分析和形状描述
OpenCV的imgproc模块对物体描述提供了丰富的API，比如弧长计算、轮廓查找、质心查找等等。
1、cv::findContours

查找二值图像中的轮廓。
void cv::findContours(InputArray image,OutputArrayOfArrays contours,OutputArray hierarchy,int mode,int method,Point offset = Point())
该函数使用算法（Satoshi Suzuki an

			
		

	





	

		

			

				
					
opencv moment

				
			

			

				

					08-19
				

			

		

		

			
				
OpenCV 中的 Moment（矩）是用于计算图像的各种特征的数学工具。它们用于求解图像的中心、重心、面积、方向等属性。Moment 是图像的统计特征，可以被用于对象识别、形状分析和图像处理等应用中。

在 OpenCV 中，使用 `cv2.moments()` 函数来计算图像的矩。该函数接受一个二值化图像作为输入，并返回一个包含各种矩的字典。通过这些矩，可以计算出图像的中心坐标、重心坐标以及其他几何特征。

下面是一个简单的示例代码，演示了如何使用 OpenCV 的 Moment 函数计算图像的矩：

```python
import cv2

# 读取图像
image = cv2.imread('image.jpg', 0)

# 将图像二值化
ret, thresh = cv2.threshold(image, 127, 255, 0)

# 计算图像的矩
moments = cv2.moments(thresh)

# 提取图像的中心坐标
cX = int(moments["m10"] / moments["m00"])
cY = int(moments["m01"] / moments["m00"])

# 打印中心坐标
print("Center of mass: ({}, {})".format(cX, cY))
```

这是一个简单的例子，演示了如何计算图像的中心坐标。除了中心坐标，还可以通过 Moment 计算许多其他的图像特征，如面积、方向、轮廓等。这些特征对于图像处理和计算机视觉任务非常有用。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值