测试代码:
#include "stdafx.h"
#include "polygon.h"
#include <iostream>
using namespace std;
const int N=4;
/* 判断圆是否与多边形相交*/
//bool CircleCrossConvexPolygon(int vcount,POINT center,float radius,POINT polygon[])
bool CircleCrossPolygon(int vcount,POINT center,float radius,POINT polygon[])
{
POINT P_0=POINT(center.x+radius,center.y);
int N=10;
for(int i=0;i<N;i++)
{
POINT P_i=rotate(center,i*2*PI/N,P_0);
//bool ret=InsideConvexPolygon(vcount,polygon,P_i);
bool ret=InsidePolygon(vcount,polygon,P_i);
if(ret)
return true;
}
P_0=rotate(center,PI/N,P_0);
for(int i=0;i<N;i++)
{
POINT P_i=rotate(center,i*2*PI/N,P_0);
//bool ret=InsideConvexPolygon(vcount,polygon,P_i);
bool ret=InsidePolygon(vcount,polygon,P_i);
if(ret)
return true;
}
return false;
}
/* 判断线段LINESEG laser所在直线LINE laser是否与简单多边形polygon相交*/
bool LineCrossPolygon(int vcount,LINESEG laser,POINT polygon[])
{
LINESEG u[MAXV];
for(int i=0;i<vcount-1;i++)
u[i]=LINESEG(polygon[i],polygon[i+1]);
if(vcount>2)
u[vcount-1]=LINESEG(polygon[vcount-1],polygon[0]);
for(int i=0;i<vcount;i++)
{
bool ret=intersect_l(u[i],laser);
if(ret)
return true;
}
return false;
}
int main(int argc,char* argv[])
{
不能构成凸多边形,但是简单多边形
//CPoint mathPointSet[4]={CPoint(0,0),CPoint(100,200),CPoint(300,400),CPoint(-200,600)};
不能构成凸多边形,但是简单多边形
//CPoint mathPointSet[4]={CPoint(0,0),CPoint(300,400),CPoint(100,200),CPoint(-200,600)};
//能构成凸多边形,且是凸多边形
//CPoint mathPointSet[4]={CPoint(0,0),CPoint(400,200),CPoint(300,400),CPoint(-200,600)};
//能构成凸多边形,但不是凸多边形,不是简单多边形
CPoint mathPointSet[4]={CPoint(0,0),CPoint(300,400),CPoint(400,200),CPoint(-200,600)};
//bool ret1=InsideConvexPolygon(sizeof(mathPointSet)/sizeof(CPoint),mathPointSet,CPoint(150,290));
bool ret1=InsidePolygon(sizeof(mathPointSet)/sizeof(CPoint),mathPointSet,CPoint(150,290));
//bool ret1=InsidePolygon(sizeof(mathPointSet)/sizeof(CPoint),mathPointSet,CPoint(230,290));
cout<<"ret1="<<ret1<<endl;
bool ret=CircleCrossPolygon(sizeof(mathPointSet)/sizeof(CPoint),CPoint(500,300),150,mathPointSet);
//bool ret=CircleCrossPolygon(sizeof(mathPointSet)/sizeof(CPoint),CPoint(500,300),130,mathPointSet);
cout<<"ret="<<ret<<endl;
system("pause");
return 0;
float p[N][2];
for(int i=0;i<N;i++)
{
p[i][0]=mathPointSet[i].x;
p[i][1]=mathPointSet[i].y;
}
if (isconvexEx(p,N))
cout<<"能";
else
cout<<"不能";
CPoint mathPointSet2[4]={};
//测试顶点顺序
int len=0;
cout<<endl;
cout<<"排序前";
cout<<endl;
for(int i=0;i<N;i++)
{
cout<<" 第"<<i<<"个点坐标:";
cout<<mathPointSet[i].x<<","<<mathPointSet[i].y<<endl;
}
if (issimple(N,mathPointSet))
cout<<"无序的多边形顶点集合pt,issimple=true";
else
cout<<"无序的多边形顶点集合pt,issimple=false";
cout<<endl;
if (isconvex(N,mathPointSet))
cout<<"是凸多边形";
else
cout<<"不是凸多边形";
Graham_scan(mathPointSet,mathPointSet2,N,len);
cout<<endl;
cout<<"排序后";
cout<<endl;
for(int i=0;i<N;i++)
{
cout<<" 第"<<i<<"个点坐标:";
cout<<mathPointSet[i].x<<","<<mathPointSet[i].y<<endl;
}
if (issimple(N,mathPointSet))
cout<<"排序成逆时针顺序后的顶点集合pt,issimple=true";
else
cout<<"排序成逆时针顺序后的顶点集合pt,issimple=false";
cout<<endl;
if (isconvex(N,mathPointSet))
cout<<"是凸多边形";
else
cout<<"不是凸多边形";
cout<<endl;
system("pause");
return 0;
}
//int main(int argc,char* argv[])
//{
// float p[N][2];
// char ch='y';
// while (ch=='y'||ch=='Y')
// {
// cout<<"请输入这"<<N<<"个点坐标:"<<endl;
// for(int i=0;i<N;i++)
// {
// cout<<" 第"<<i<<"个点坐标:";
// cin>>p[i][0]>>p[i][1];
// //cin>>**p>>*(*p+1);
// cout<<p[i][0]<<","<<p[i][1]<<endl;
// }
// if (isconvexEx(p,N))
// cout<<"能";
// else
// cout<<"不能";
// POINT pt[N],pt2[N];
// for(int i=0;i<N;i++)
// {
// pt[i].x=(float)p[i][0];
// pt[i].y=(float)p[i][1];
// }
// //测试顶点顺序
// int len=0;
// cout<<endl;
// cout<<"排序前";
// for(int i=0;i<N;i++)
// {
// cout<<" 第"<<i<<"个点坐标:";
// cout<<pt[i].x<<","<<pt[i].y<<endl;
// }
// if (issimple(N,pt))
// cout<<"无序的多边形顶点集合pt,issimple=true";
// else
// cout<<"无序的多边形顶点集合pt,issimple=false";
// cout<<endl;
// if (isconvex(N,pt))
// cout<<"是凸多边形";
// else
// cout<<"不是凸多边形";
// Graham_scan(pt,pt2,N,len);
// cout<<endl;
// cout<<"排序后";
// for(int i=0;i<N;i++)
// {
// cout<<" 第"<<i<<"个点坐标:";
// cout<<pt[i].x<<","<<pt[i].y<<endl;
// }
// if (issimple(N,pt))
// cout<<"排序成逆时针顺序后的顶点集合pt,issimple=true";
// else
// cout<<"排序成逆时针顺序后的顶点集合pt,issimple=false";
// cout<<endl;
// if (isconvex(N,pt))
// cout<<"是凸多边形";
// else
// cout<<"不是凸多边形";
// cout<<endl<<"是否继续判断?(继续请输入y&Y)";
// cin>>ch;
// }
// system("pause");
// return 0;
//}
C++计算几何库polygon.h的代码:
/*
计算几何目录----已测试算法模块
㈠ 点的基本运算
1. 平面上两点之间距离 1
2. 判断两点是否重合 1
3. 矢量叉乘 1
4. 矢量点乘 2
5. 判断点是否在线段上 2
6. 求一点饶某点旋转后的坐标 2
7. 求矢量夹角 2
㈡ 线段及直线的基本运算
1. 点与线段的关系 3
2. 求点到线段所在直线垂线的垂足 4
3. 点到线段的最近点 4
4. 点到线段所在直线的距离 4
5. 点到折线集的最近距离 4
6. 判断圆是否在多边形内 5
7. 求矢量夹角余弦 5
8. 求线段之间的夹角 5
9. 判断线段是否相交 6
10.判断线段是否相交但不交在端点处 6
11.求线段所在直线的方程 6
12.求直线的斜率 7
13.求直线的倾斜角 7
14.求点关于某直线的对称点 7
15.判断两条直线是否相交及求直线交点 7
16.判断线段是否相交,如果相交返回交点 7
㈢ 多边形常用算法模块
1. 判断多边形是否简单多边形----issimple(POINT polygon[]理解为一个确定的多边形对象或有序的顶点集,结合Graham_scan函数使用)
2. 检查多边形顶点的凸凹性 9
3. 判断多边形是否凸多边形----isconvex(POINT polygon[]理解为一个确定的多边形对象或有序的顶点集,结合Graham_scan函数使用),isconvexEx(POINT polygon[]理解为一个确定的简单多边形对象或无序的顶点集)
4. 求多边形面积 9
5. 判断多边形顶点的排列方向,方法一 10
6. 判断多边形顶点的排列方向,方法二 10
7. 射线法判断点是否在多边形内 10
8. 判断点是否在凸多边形内----InsideConvexPolygon
8a.判断点是否在平面多边形(可以是非简单多边形,可以是非凸多边形)内----InsidePolygon
9. 寻找点集的graham算法----Graham_scan
10.寻找点集凸包的卷包裹法 13
11.判断线段是否在多边形内 14
12.求简单多边形的重心 15
13.求凸多边形的重心 17
14.求肯定在给定多边形内的一个点 17
15.求从多边形外一点出发到该多边形的切线 18
16.判断多边形的核是否存在 19
㈣ 圆的基本运算
1 .点是否在圆内 20
2 .求不共线的三点所确定的圆 21
㈤ 矩形的基本运算
1.已知矩形三点坐标,求第4点坐标 22
㈥ 常用算法的描述 22
㈦ 补充
1.两圆关系: 24
2.判断圆是否在矩形内: 24
3.点到平面的距离: 25
4.点是否在直线同侧: 25
5.镜面反射线: 25
6.矩形包含: 26
7.两圆交点: 27
8.两圆公共面积: 28
9. 圆和直线关系: 29
10. 内切圆: 30
11. 求切点: 31
12. 线段的左右旋: 31
13.公式: 32
*/
#pragma once
#include<cmath>
#include<xutility>
using namespace std;
/* 常用的常量定义 */
const float INF = 1E20;//无穷大
const float EP = 1E-10;//无穷小
const int MAXV = 300;
const float PI = 3.14159265;
//float max(float x, float y)
//{
// return (x > y ? x : y);
//}
//
//float min(float x, float y)
//{
// return (x < y ? x : y);
//}
/* 基本几何结构 */
//struct POINT
//{
// float x;
// float y;
// POINT(float a=0, float b=0) { x=a; y=b;} //constructor
//};
struct qcPoint
{
float x, y;
qcPoint() : x(0), y(0) {}
qcPoint(float _x, float _y) : x(_x), y(_y) {}
qcPoint& operator= (const qcPoint& point) {x = point.x; y = point.y; return *this;}
};
typedef qcPoint TPoint;
typedef qcPoint POINT;
typedef qcPoint CPoint;
struct LINESEG
{
POINT s;
POINT e;
LINESEG(POINT a, POINT b) { s=a; e=b;}
LINESEG() { }
};
struct LINE // 直线的解析方程 a*x+b*y+c=0 为统一表示,约定 a >= 0
{
float a;
float b;
float c;
LINE(float d1=1, float d2=-1, float d3=0) {a=d1; b=d2; c=d3;}
};
/**********************
* *
* 点的基本运算 *
* *
**********************/
float dist(POINT p1,POINT p2) // 返回两点之间欧氏距离
{
return( sqrt( (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y) ) );
}
bool equal_point(POINT p1,POINT p2) // 判断两个点是否重合
{
return ( (abs(p1.x-p2.x)<EP)&&(abs(p1.y-p2.y)<EP) );
}
/******************************************************************************
r=multiply(sp,ep,op),得到(sp-op)和(ep-op)的叉积
r>0:ep在矢量opsp的逆时针方向;
r=0:opspep三点共线;
r<0:ep在矢量opsp的顺时针方向
*******************************************************************************/
float multiply(POINT sp,POINT ep,POINT op)
{
return((sp.x-op.x)*(ep.y-op.y)-(ep.x-op.x)*(sp.y-op.y));
}
/*
r=dotmultiply(p1,p2,op),得到矢量(p1-op)和(p2-op)的点积,如果两个矢量都非零矢量
r<0:两矢量夹角为锐角;
r=0:两矢量夹角为直角;
r>0:两矢量夹角为钝角
*******************************************************************************/
float dotmultiply(POINT p1,POINT p2,POINT p0)
{
return ((p1.x-p0.x)*(p2.x-p0.x)+(p1.y-p0.y)*(p2.y-p0.y));
}
/******************************************************************************
判断点p是否在线段l上
条件:(p在线段l所在的直线上) && (点p在以线段l为对角线的矩形内)
*******************************************************************************/
bool online(LINESEG l,POINT p)
{
return( (multiply(l.e,p,l.s)==0) &&( ( (p.x-l.s.x)*(p.x-l.e.x)<=0 )&&( (p.y-l.s.y)*(p.y-l.e.y)<=0 ) ) );
}
// 返回点p以点o为圆心逆时针旋转alpha(单位:弧度)后所在的位置
POINT rotate(POINT o,float alpha,POINT p)
{
POINT tp;
p.x-=o.x;
p.y-=o.y;
tp.x=p.x*cos(alpha)-p.y*sin(alpha)+o.x;
tp.y=p.y*cos(alpha)+p.x*sin(alpha)+o.y;
return tp;
}
/* 返回顶角在o点,起始边为os,终止边为oe的夹角(单位:弧度)
角度小于pi,返回正值
角