c++ 多边形求交集代码（凸多边形与凹多边形的交集）

最新推荐文章于 2023-02-13 13:36:15 发布
最新推荐文章于 2023-02-13 13:36:15 发布
阅读量5.3k 收藏 44
点赞数 19
分类专栏： C\C++ 文章标签： cpp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shanglianlm/article/details/89736950
版权

多边形求交集cpp代码

凸多边形与凹多边形的交集：c++ 多边形求交集代码（凸多边形与凹多边形的交集）
凸多边形与凸多边形的交集：c++ 多边形求交集代码（凸多边形与凸多边形的交集）
在这里插入图片描述

#include "stdafx.h"
#include <iostream>
#include <stdlib.h>

#include <opencv2\opencv.hpp>

using namespace std;
using namespace cv;

#define FREESPACENUM 64

//计算多边形面积
float PolygonArea(Point2f p[], int n)
{
	if (n < 3) return 0.0;
	float s = p[0].y * (p[n - 1].x - p[1].x);
	p[n] = p[0];
	for (int i = 1; i < n; ++i)
	{
		s += p[i].y * (p[i - 1].x - p[i + 1].x);
	}
	return fabs(s * 0.5);
}

int pointLineRelationship(int pt1x,int pt1y, int pt2x, int pt2y, int &pt0x, int &pt0y)
{
	//iValue=0,点在分割线上，iValue>0,点在直线Pt3顺时针那侧，iValue<0,点在直线Pt3逆时针那侧，
	return((pt2y - pt1y) * pt0x + (pt1x - pt2x) * pt0y + (pt2x*pt1y - pt1x*pt2y));
}

bool intersect(int pt1x, int pt1y, int pt2x, int pt2y, int pt3x, int pt3y, int pt4x, int pt4y, int &ptNodex, int &ptNodey)
{
	int ax = pt2x - pt1x, ay = pt2y - pt1y;
	int bx = pt3x - pt4x, by = pt3y - pt4y;
	int cx = pt1x - pt3x, cy = pt1y - pt3y;

	float fDenominator = ay * bx - ax * by;
	if (fDenominator == 0) return false;

	float fReciprocal = 1 / fDenominator;
	float na = (by * cx - bx * cy) * fReciprocal;
	ptNodex = ax * na + pt1x;
	ptNodey = ay * na + pt1y;

	if (na < 0 || na > 1) return true;

	float nb = (ax * cy - ay * cx) * fReciprocal;
	if (nb < 0 || nb > 1) return true;

	return true;
}


int main()
{
	Mat img = imread("7487939.jpg");

	// init park
	vector<vector<int>> parkList(6);
	parkList[0] = {160,180,140,90,24,89,23,171 };
	parkList[1] = {192,458,188,368,27,362,10,480};
	parkList[2] = {451,173,444,332,617,318,621,199};
	parkList[3] = {439,372,429,478,620,446,632,320};
	parkList[4] = {427,490,358,500,336,616,476,616};
	parkList[5] = {248,505,158,486,118,612,236,620};

	for (vector<int> park: parkList)
	{
		cv::line(img,Point2i(park[0], park[1]), Point2i(park[2], park[3]), Scalar(0, 0,255),2,8);
		cv::line(img, Point2i(park[2], park[3]), Point2i(park[4], park[5]), Scalar(0, 0, 255), 2, 8);
		cv::line(img, Point2i(park[4], park[5]), Point2i(park[6], park[7]), Scalar(0, 0, 255), 2, 8);
		cv::line(img, Point2i(park[6], park[7]), Point2i(park[0], park[1]), Scalar(0, 0, 255), 2, 8);
	}

	// init freespace
	vector<Point2i> leftFreespace, rightFreespace, backFreespace;
	for (int i=0;i<FREESPACENUM;++i)
	{
		leftFreespace.push_back(Point2i(rand() % 200, 640-i * 10));
	}

	for (int i = 0; i < FREESPACENUM; ++i)
	{
		cv::circle(img, Point2i(leftFreespace[i].x, leftFreespace[i].y), 2, Scalar(0, 255, 0),4,8);
	}
	for (int i = 0; i < FREESPACENUM-1; ++i)
	{
		cv::line(img, Point2i(leftFreespace[i].x, leftFreespace[i].y), Point2i(leftFreespace[i+1].x, leftFreespace[i+1].y), Scalar(0, 255, 0), 2, 8);
	}

	//begin
	int poly_j_begin = -1, poly_j_end = -1;
	int n_flag = -1; 
	int min_x, max_x, min_y, max_y;
	int min_x_p0167, max_x_p0167, min_y_p0167, max_y_p0167;
	int min_x_p0123, max_x_p0123, min_y_p0123, max_y_p0123;
	int min_x_p2345, max_x_p2345, min_y_p2345, max_y_p2345;
	int min_x_p4567, max_x_p4567, min_y_p4567, max_y_p4567;
	int min_x_freespace, max_x_freespace, min_y_freespace, max_y_freespace;
	int cross_x_p0167, cross_y_p0167, cross_x_p0123, cross_y_p0123, cross_x_p2345, cross_y_p2345, cross_x_p4567=0, cross_y_p4567=0/*, cross_x, cross_y*/;
	float fAllArea = 0.f, fParkArea=0.f;
	Point2f pParkSet[10];
	Point2f pPolygonSet[FREESPACENUM];
	int pPolygonSetAttribute[FREESPACENUM];
	int pPolygonIndex;
	for (int i= parkList.size()-1;i>=0;--i)
	{
		pParkSet[0] = Point2f(parkList[i][0], parkList[i][1]);
		pParkSet[1] = Point2f(parkList[i][2], parkList[i][3]);
		pParkSet[2] = Point2f(parkList[i][4], parkList[i][5]);
		pParkSet[3] = Point2f(parkList[i][6], parkList[i][7]);

		fParkArea = PolygonArea(pParkSet,4);

		poly_j_begin = -1, poly_j_end = -1;
		min_x = min(min(parkList[i][0], parkList[i][2]), min(parkList[i][4], parkList[i][6]));
		max_x = max(max(parkList[i][0], parkList[i][2]), max(parkList[i][4], parkList[i][6]));
		min_y = min(min(parkList[i][1], parkList[i][3]), min(parkList[i][5], parkList[i][7]));
		max_y = max(max(parkList[i][1], parkList[i][3]), max(parkList[i][5], parkList[i][7]));

		min_x_p0167 = min(parkList[i][0], parkList[i][6]);
		max_x_p0167 = max(parkList[i][0], parkList[i][6]);
		min_y_p0167 = min(parkList[i][1], parkList[i][7]);
		max_y_p0167 = max(parkList[i][1], parkList[i][7]);

		min_x_p0123 = min(parkList[i][0], parkList[i][2]);
		max_x_p0123 = max(parkList[i][0], parkList[i][2]);
		min_y_p0123 = min(parkList[i][1], parkList[i][3]);
		max_y_p0123 = max(parkList[i][1], parkList[i][3]);

		min_x_p2345 = min(parkList[i][2], parkList[i][4]);
		max_x_p2345 = max(parkList[i][2], parkList[i][4]);
		min_y_p2345 = min(parkList[i][3], parkList[i][5]);
		max_y_p2345 = max(parkList[i][3], parkList[i][5]);

		min_x_p4567 = min(parkList[i][4], parkList[i][6]);
		max_x_p4567 = max(parkList[i][4], parkList[i][6]);
		min_y_p4567 = min(parkList[i][5], parkList[i][7]);
		max_y_p4567 = max(parkList[i][5], parkList[i][7]);

		pPolygonIndex = 0;
		for (int j=0;j<FREESPACENUM-1;++j)
		{
			//cout << j << endl;
			if (min_x <=leftFreespace[j].x&&max_x >=leftFreespace[j].x&& min_y <=leftFreespace[j].y&& max_y >=leftFreespace[j].y)
			{
				n_flag = 0;
				//cout <<j<<" "<< leftFreespace[j].x << " " << leftFreespace[j].y << endl;
				min_x_freespace = min(leftFreespace[j].x, leftFreespace[j + 1].x);
				max_x_freespace = max(leftFreespace[j].x, leftFreespace[j + 1].x);
				min_y_freespace = min(leftFreespace[j].y, leftFreespace[j + 1].y);
				max_y_freespace = max(leftFreespace[j].y, leftFreespace[j + 1].y);

				//01-67
				intersect(parkList[i][0], parkList[i][1], parkList[i][6], parkList[i][7], 
					leftFreespace[j].x, leftFreespace[j].y,leftFreespace[j+1].x, leftFreespace[j+1].y, cross_x_p0167, cross_y_p0167);
				//01-67边有交点
				if (min_x_p0167 <= cross_x_p0167&& max_x_p0167 >= cross_x_p0167 && min_y_p0167 <= cross_y_p0167 && max_y_p0167 >= cross_y_p0167
					&& min_x_freespace <= cross_x_p0167&& max_x_freespace >= cross_x_p0167 && min_y_freespace <= cross_y_p0167&& max_y_freespace >= cross_y_p0167)
				{
					cout<<"p0167 ===== "<< cross_x_p0167 << " " << cross_y_p0167 << endl;
					n_flag = 1;

					pPolygonSet[pPolygonIndex] = Point2f(cross_x_p0167, cross_y_p0167);
					pPolygonSetAttribute[pPolygonIndex] = n_flag;
					++pPolygonIndex;
				}

				//01-23
				intersect(parkList[i][0], parkList[i][1], parkList[i][2], parkList[i][3], 
					leftFreespace[j].x, leftFreespace[j].y,leftFreespace[j + 1].x, leftFreespace[j + 1].y, cross_x_p0123, cross_y_p0123);
				//01-23边有交点
				if (min_x_p0123 <= cross_x_p0123&& max_x_p0123  >= cross_x_p0123 && min_y_p0123 <= cross_y_p0123 && max_y_p0123 >= cross_y_p0123
					&& min_x_freespace <= cross_x_p0123 && max_x_freespace >= cross_x_p0123 && min_y_freespace <= cross_y_p0123 && max_y_freespace >= cross_y_p0123)
				{
					cout << "p0123 ===== " << cross_x_p0123 << " " << cross_y_p0123 << endl;
					n_flag = 2;

					pPolygonSet[pPolygonIndex] = Point2f(cross_x_p0123, cross_y_p0123);
					pPolygonSetAttribute[pPolygonIndex] = n_flag;
					++pPolygonIndex;
				}

				//23-45
				intersect(parkList[i][2], parkList[i][3], parkList[i][4], parkList[i][5], 
					leftFreespace[j].x, leftFreespace[j].y,leftFreespace[j + 1].x, leftFreespace[j + 1].y, cross_x_p2345, cross_y_p2345);
				//23-45边有交点
				if (min_x_p2345 <= cross_x_p2345 && max_x_p2345 >= cross_x_p2345 && min_y_p2345 <= cross_y_p2345 && max_y_p2345 >= cross_y_p2345
					&& min_x_freespace <= cross_x_p2345 && max_x_freespace >= cross_x_p2345 && min_y_freespace <= cross_y_p2345 && max_y_freespace >= cross_y_p2345)
				{
					cout << "p2345 ===== " << cross_x_p2345 << " " << cross_y_p2345 << endl;
					n_flag = 3;

					pPolygonSet[pPolygonIndex] = Point2f(cross_x_p2345, cross_y_p2345);
					pPolygonSetAttribute[pPolygonIndex] = n_flag;
					++pPolygonIndex;
				}

				//45-67
				intersect(parkList[i][4], parkList[i][5], parkList[i][6], parkList[i][7], 
					leftFreespace[j].x, leftFreespace[j].y,leftFreespace[j + 1].x, leftFreespace[j + 1].y, cross_x_p4567, cross_y_p4567);
				//45-67边有交点
				if (min_x_p4567 <= cross_x_p4567 && max_x_p4567 >= cross_x_p4567 && min_y_p4567 <= cross_y_p4567 && max_y_p4567 >= cross_y_p4567
					&& min_x_freespace <= cross_x_p4567 && max_x_freespace >= cross_x_p4567 && min_y_freespace <= cross_y_p4567 && max_y_freespace >= cross_y_p4567)
				{
					cout << "p4567 ===== " << cross_x_p4567 << " " << cross_y_p4567 << endl;
					n_flag = 4;

					pPolygonSet[pPolygonIndex] = Point2f(cross_x_p4567, cross_y_p4567);
					pPolygonSetAttribute[pPolygonIndex] = n_flag;
					++pPolygonIndex;
				}

				if (n_flag<1)
				{
					pPolygonSet[pPolygonIndex] = Point2f(leftFreespace[j].x, leftFreespace[j].y);
					pPolygonSetAttribute[pPolygonIndex] = n_flag;
					++pPolygonIndex;
				}

			} // end if 
		}// end for

		poly_j_begin = pPolygonSetAttribute[0];
		poly_j_end = pPolygonSetAttribute[pPolygonIndex-1];
		if (poly_j_begin>-1&& poly_j_end>-1)
		{
			if (poly_j_begin == 1)
			{
				if (poly_j_end == 2)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[1];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[2];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[3];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
				else if (poly_j_end == 3)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[2];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[3];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
				else  if (poly_j_end == 4)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[3];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
			}
			else if (poly_j_begin == 2)
			{
				if (poly_j_end == 1)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[0];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
				else if (poly_j_end == 3)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[2];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[3];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[0];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
				else if (poly_j_end == 4)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[3];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[0];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
			}
			else if (poly_j_begin == 3)
			{
				if (poly_j_end == 1)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[0];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[1];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
				else if (poly_j_end == 2)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[1];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
				else if (poly_j_end == 4)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[3];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[0];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[1];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
			}
			else
			{
				if (poly_j_end == 1)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[0];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[1];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[2];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
				else if (poly_j_end == 2)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[1];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;

					pPolygonSet[pPolygonIndex] = pParkSet[2];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
				else if (poly_j_end == 3)
				{
					pPolygonSet[pPolygonIndex] = pParkSet[2];
					pPolygonSetAttribute[pPolygonIndex] = -1;
					++pPolygonIndex;
				}
			}
		}

		cout << "***************" << endl;
		/*for (int n=0;n<pPolygonIndex;++n)
		{
			cout << pPolygonSet[n].x << " " << pPolygonSet[n].y << " " << pPolygonSetAttribute[n] << endl;
		}
		cout <<"---------------" <<endl;*/


		fAllArea = PolygonArea(pPolygonSet, pPolygonIndex);

		cout << fParkArea << " " << fAllArea << " "<<fAllArea / fParkArea << endl;

		cout << "---------------" << endl;
	}

	imshow("img", img);
	waitKey(0);
    return 0;
}
mingo_敏
关注
专栏目录
opencv和图形计算求取图形交集
02-26
个人实现的求取图形交集的工程，效果见链接： http://blog.csdn.net/qq_24038299/article/details/79382418，大家相互学习借鉴
C++ 多边形相交、多边形合并算法，支持凹凸多边形
06-08
简单多边形的相交、合并算法。仅支持简单凹凸多边形。所谓简单多边形即多边形内部不含环的多边形。这个demo程序只是介绍了多边形相交、合并的算法，针对简单凹凸多边形可以正常处理。算法仅供参考！ 如需要支持内部有环的复杂多边形相交合并，请使用boost::polygon。
【C++】任意两个多边形相交问题
qq_35504602的博客
07-23 4151
标题
c++多边形求交集算法
robinfoxnan的专栏
06-11 1696
https://www.boost.org/doc/libs/1_56_0/libs/geometry/doc/html/geometry/reference/algorithms/intersection.html
【计算几何】多边形交集
weixin_33872566的博客
08-02 1488
问题描述：已知两个多边形Poly1和Poly2，分别由点集C1={P1,P2,...,Pm}和C2={Q1,Q2,...,Qn}表示，求这两个多边形的交集。 算法思想： 两个多边形相交后，其顶点要么是两个多边形边的交点，要么是在多边形内部的点。 算法步骤： 1.计算两个多边形每条边之间的交点。 2.计算包含在多边形内部的点。 3.将交点和多边形内部的点，按逆时针(或顺时针)排序，得出最...
编写一段c++代码，输入两个坐标数组，输出布尔值，实现判断两个多边形是否存在交集...
weixin_42594427的博客
02-13 325
下面是一段使用C语言实现判断两个多边形是否存在交集的代码示例： #include <stdbool.h> #define MAX_POINTS 100 typedef struct { int x; int y; } Point; bool isIntersect(Point a[], int n, Point b[], int m) { int i, j...
c++ 多边形求交集代码（凸多边形与凸多边形交集）
mingo_敏
11-02 6298
/* * 多边形的交，多边形的边一定是要按逆时针方向给出 * 还要判断是凸包还是凹包，调用相应的函数 * 面积并，只要和面积减去交即可 */ #include &amp;lt;bits/stdc++.h&amp;gt; using namespace std; const int maxn = //300; const double eps = 1e-8; int dcmp(double x) { ...
Delphi 两个多边形求交集、并集、差集的源码
07-16
Delphi 两个多边形求交集、并集、差集的源码，使用的是D5，非常古老的版本了，但能解决问题，程序使用标记法，速度非常快，解决了C语言中关于高精度重叠边的问题，示例程序是从CAD中读取多边形数据，方便演示各种...
凹多边形凸分解源码和使用说明
12-29
"二维简单多边形凸分解源代码及使用说明"提供的资源包含了一个实现凹多边形凸分解的源码和相关的使用指南。这个源码可能是用C++或Python等编程语言编写的，用于将输入的凹多边形拆分成一系列非交叠的凸多边形。通常...
基于顶点的复杂多边形求交算法的实现
03-09
在计算机图形学中，多边形的求交问题是一个重要的计算任务，特别是在碰撞检测、几何运算、游戏开发等领域。基于顶点的复杂多边形求交算法是一种解决此类问题的有效方法。本文将深入探讨这个算法的原理、实现过程以及...
多边形求交算法
04-11
计算几何常用方法，主要是和计算机图形学对应-computational geometry commonly used methods, mainly computer graphics and counterparts
多边形相关算法(面积、凹凸性、凸包、两多边形相交等)
12-12
自己用VC++作的多边形程序，包括求面积、凹凸性、凸包、两多边形相交等。
检测多边形相交的VC小程序
10-13
可移动多边形，可改变多边形形状、顶点数量，最主要的是检测相交情况。
C/C++ 凸多边形求对角线交点
SPSITA
11-05 1476
题目描述 对于一个 n 个顶点的凸多边形，它的任何三条对角线都不会交于一点。请求出图形中对角线交点的个数。 例如，6 边形： 这里可以注意到并没有出现多条对角线交叉在一个点的情况。 输入格式 输入只有一行一个整数 n，代表边数。 输出格式 输出一行一个整数代表答案。 数据规模与约定 这里给出一个特别的例子 输入是： 98765 输出是： 3964374251598225115 特别注意，在这种情况下，答案的值已经非常逼近longlong类型的最大表示范围，所以在计算的过程当中要特别注意，下面给出代码
判断2个多边形相交
jacke121的专栏
03-06 4644
需要判断2个条件 边相交。2个多边形的边是否相交。 点在内部。2个多边形的顶点是否在另一个多边形的内部。 关于这2个条件的判断： 《碰撞检测：判断点是否在多边形内部》 https://blog.csdn.net/StevenKyleLee/article/details/88044589 《碰撞检测：判断线段相交》 https://blog.csdn.net/StevenKyleLee/a...
判断两条线段是否相交、点是否在多边形内（C++）
jadesl的专栏
05-28 2625
转自https://www.cnblogs.com/charlee44/p/10704156.html 目录 1. 算法思路 2. 具体实现 3. 改进空间 1. 算法思路 判断平面内点是否在多边形内有多种算法，其中射线法是其中比较好理解的一种，而且能够支持凹多边形的情况。该算法的思路很简单，就是从目标点出发引一条射线，看这条射线和多边形所有边的交点数目。如果有奇数个交点，则说明在内部，如果有偶数个交点，则说明在外部。如下图所示： 算法步骤如下： 已知点point(x,y)和多边形P..
多边形之间的交差并补....
weixin_30628801的博客
09-30 651
　　以前接触二维图形的操作比较多，多边形之间的交差并补是一个难点，算法也颇为复杂，幸好有一些现成的源代码文件，比如这个gpc.c和gpc.h。 　　首先先将gpc.c和gpc.h加入到工程，我用的是mfc vc6.0（好古老）...需要将gpc.c改成gpc.cpp，然后添加到工程，似乎出现过一些问题，具体忘了，蛮简单最后配置成功，就可以用gpc的算法了。 　　整个文件不算难，很容易看懂，这里...
计算几何 多边形的交与并
bitwater的空间
09-03 6693
/* * 多边形的交，多边形的边一定是要按逆时针方向给出 * 还要判断是凸包还是凹包，调用相应的函数 * 面积并，只要和面积减去交即可 */ #include using namespace std; const int maxn = //300; const double eps = 1e-8; int dcmp(double x) { if(x > eps) return
C++ OPENCV 获得两矩形的交集矩形
zisuina_2的博客
07-22 3184
获得两个矩形的交集，该交集类型也是矩形 这种情况就范围交集的矩形，蓝色部分； 这种情况返回 cv::Rect(cv::Point(0,0),cv::Point(0,0) ); 欢迎测试，提BUG； /** @brief 获得两个矩形的交集 @param rect1；　rect2 is lds range. @output cv::Rect 交集 */ cv::Rect get_IOU(cv::Rect rect1, cv::Rect rect2){ // 横向和纵向距离 cout
c++ opencv 判断矩形是否与多边形有交集
最新发布
06-08
要判断一个矩形和一个多边形是否有交集，可以使用 OpenCV 中提供的函数 `cv::intersectConvexConvex`。 首先，将矩形转换为一个四边形，并将多边形转换为一个凸多边形。然后，使用 `cv::intersectConvexConvex` 函数判断这两个凸多边形是否有交集。如果有交集，说明矩形和多边形有交集。 以下是示例代码： ```c++ #include <opencv2/opencv.hpp> using namespace cv; bool isRectIntersectPoly(const Rect& rect, const std::vector<Point>& poly) { // 将矩形转换为一个四边形 std::vector<Point> rect_poly(4); rect_poly[0] = rect.tl(); rect_poly[1] = Point(rect.x + rect.width, rect.y); rect_poly[2] = rect.br(); rect_poly[3] = Point(rect.x, rect.y + rect.height); // 将多边形转换为一个凸多边形 std::vector<Point> convex_poly; convexHull(poly, convex_poly); // 判断凸多边形和四边形是否有交集 std::vector<Point2f> intersect_points; bool intersect = intersectConvexConvex(convex_poly, rect_poly, intersect_points); return intersect; } ``` 其中，`Rect` 表示矩形，`std::vector<Point>` 表示多边形。函数返回值为 `bool` 类型，表示矩形和多边形是否有交集。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

mingo_敏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值