opengl:凸包算法

最新推荐文章于 2020-12-13 18:52:38 发布
最新推荐文章于 2020-12-13 18:52:38 发布
阅读量2k 收藏 3
点赞数 1
分类专栏： opengl学习记录 文章标签： opengl 凸包 c++ 图形学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/majing19921103/article/details/45050831
版权

准备工作

判断点在有向线段的左侧

可以通过叉积判断，如下为k在有向线段ab的左侧代码描述：

double multiply(Point a, Point b, Point k)
{
    double x1 = b.x-a.x;
    double y1 = b.y-a.y;
    double x2 = k.x-a.x;
    double y2 = k.y-a.y;
    return x1*y2-x2*y1;
}

bool toLeft(Point a, Point b, Point k)
{
    return multiply(a,b,k)>0; 
}

判断点在三角形的内部

给三角形abc定义一定的次序，按照一般习惯，假设abc是逆时针的，则判断k是否在三角形内部，只需要判断k是否在有向线段ab,bc,ac的左侧：

bool inTriangle(Point a, Point b, Point c, Point k)
{
    bool abLeft = toLeft(a,b,k);
    bool bcLeft = toLeft(b,c,k);
    bool caLeft = toLeft(c,a,k);
    return (abLeft==bcLeft)&&(bcLeft==caLeft);
}

几种典型的算法

极点算法

凸包上的顶点称为极点，极点有一个特性，总可以找到过极点的一条直线使得其他所有的顶点，在这个直线的一侧。所以极点不可能在某一个顶点三角形的内部，则可以在初始化时，标示所有的顶点为极点，然后遍历所有的顶点组成的三角形，排除掉三角形内部的顶点，则剩下的顶点则为凸包的极点。该算法时间复杂度为O(N^4)，算法描述如下：
这里写图片描述

极边算法

凸包上的边称为极边，所有的顶点都在极边的一侧，所以可以遍历所有的边，检查它是否为极边，算法时间复杂度为O(N^3),算法描述如下：
这里写图片描述

GiftWrapping算法

两个相邻的极边之间有一个共同的极点，所以一条极边的尾端也是另一条极边的顶端。如果已知一个极点，则可以寻找以该极点作为顶端的极边的尾端极点。方法是任取一个点作为候选点，如果下一个点在已知点与候选点组成的有向线段的右端，则把这个点作为候选点，这样不断的更新。因为最下的点肯定是一个极点，所以可把最下点作为初始点。算法的复杂度为O(N*W)(W是凸包的边数)，算法描述如下：
这里写图片描述
这里写图片描述

Graham Scan算法

算法需要借助一次排序，和两个栈：
这里写图片描述

下图描述了整个流程：
这里写图片描述
这里写图片描述

opengl实现

geometry.h文件：

#include <GL/glut.h>
#include <vector>
#include <algorithm>
#include <stack>
using namespace std;


class Point
{
public:
    Point(){};
    Point(double a,double b,double c):x(a),y(b),z(c),extreme(true){};
public:
    double x;
    double y;
    double z; //平面凸包，此项为0
    bool extreme;   //EE算法中用到，标识该点是否为极点
    pair<double,double> ref; //Graham Scan算法中，排序的参考点
    bool operator < (const Point &a);

};

class Edge
{
public :
    Edge(Point a,Point b):s(a),e(b){};
    Point s,e;
};

enum  PLOTMODE
{
    EP=0,
    EE,
    GW,
    GS
};

double multiply(Point a, Point b, Point c);

bool toLeft(Point a, Point b, Point c);

bool inTriangle(Point a, Point b, Point c, Point k);

 void EPAlgorithm(vector<Point> &list);

 vector<Edge> EEAlgorithm(vector<Point> list);

 vector<Edge> GWAlgorithm(vector<Point> list);

 stack<Point> GSAlgorithm(vector<Point>list);

geometry.cpp文件：

#include "Geometry.h"

bool Point::operator<(const Point &a)
{
    Point p = Point(ref.first,ref.second,0);
    return toLeft(p,*this,a);
}

double multiply(Point a, Point b, Point k)
{
    double x1 = b.x-a.x;
    double y1 = b.y-a.y;
    double x2 = k.x-a.x;
    double y2 = k.y-a.y;
    return x1*y2-x2*y1;
}

bool toLeft(Point a, Point b, Point k)
{
    return multiply(a,b,k)>0; 
}

bool inTriangle(Point a, Point b, Point c, Point k)
{
    bool abLeft = toLeft(a,b,k);
    bool bcLeft = toLeft(b,c,k);
    bool caLeft = toLeft(c,a,k);
    return (abLeft==bcLeft)&&(bcLeft==caLeft);
}

//极点算法
void EPAlgorithm(vector<Point> &list)
{
    //三重循环遍历所有三角形
    for(int i=0;i<list.size();i++)
    {
        for(int j=i+1;j<list.size();j++)
        {
            for(int k=j+1;k<list.size();k++)
            {
                for(int m=0;m<list.size();m++)
                {
                    if(!list[m].extreme)
                        continue;
                    if(m==i||m==j||m==k)
                        continue;
                    if(inTriangle(list[i],list[j],list[k],list[m]))
                        list[m].extreme = false;
                }
            }
        }
    }
}

//极边算法
vector<Edge> EEAlgorithm(vector<Point> list)
{
    vector<Edge> res;
    //二重循环遍历所有边
    for(int i=0;i<list.size();i++)
    {
        for(int j=i+1;j<list.size();j++)
        {
            bool left = true, right = true;
            for(int k=0;k<list.size();k++)
            {
                if(k!=i&&k!=j)
                    (toLeft(list[i],list[j],list[k])>0?left:right) = false;
            }
            if(left|right)
                res.push_back(Edge(list[i],list[j]));
        }
    }
    return res;
}

//GiftWrapping算法
vector<Edge> GWAlgorithm(vector<Point> list)
{
    vector<Point> listCopy = list; 
    vector<Edge> res;
    if(listCopy.size()<=2)
        return res;
    int ltl = 0;
    //找出lowest-then-leftest的点
    for(int i=1;i<listCopy.size();i++)
    {
        if(listCopy[i].y<listCopy[ltl].y||(listCopy[i].y==listCopy[ltl].y&&listCopy[i].x<listCopy[ltl].x))
            ltl = i;
    }
    int p = ltl;
    //找出下一条极边
    while(1)
    {
        int q = -1;
        for(int i=0;i<listCopy.size();i++)
        {
            if(i!=p&&(q<0||!toLeft(listCopy[p],listCopy[q],listCopy[i])))
                q = i;
        }
        res.push_back(Edge(listCopy[p],listCopy[q]));
        if(q==ltl)
            break;
        p = q;
    }
    return res;
}

Point getPoint(stack<Point>s, int num)
{
    stack<Point> temp = s;
    for(int i=0;i<num;i++)
    {
        temp.pop();
    }
    return temp.top(); 
}

stack<Point> GSAlgorithm(vector<Point>list)
{
    vector<Point> listCopy = list;
    stack<Point> S,T;
    if(listCopy.size()<3)
        return S;
    int ltl = 0;
    //找出lowest-then-leftest的点
    for(int i=1;i<listCopy.size();i++)
    {
        if(listCopy[i].y<listCopy[ltl].y||(listCopy[i].y==listCopy[ltl].y&&listCopy[i].x<listCopy[ltl].x))
            ltl = i;
    }
    //给所有定点附加ref属性
    for(int i=0;i<listCopy.size();i++)
    {
        listCopy[i].ref = pair<double,double>(listCopy[ltl].x,listCopy[ltl].y);
    }
    S.push(listCopy[ltl]);
    listCopy.erase(listCopy.begin()+ltl);
    //对定点进行排序
    sort(listCopy.begin(),listCopy.end());
    //构造初始的S和T
    S.push(listCopy[0]);
    for(int i = listCopy.size()-1;i>=1;i--)
    {
        T.push(listCopy[i]);
    }
    while(!T.empty())
    {
        while(!toLeft(getPoint(S,1),getPoint(S,0),getPoint(T,0)))
        {
            S.pop();
        }
        S.push(getPoint(T,0));
        T.pop();
    }
    return S;
}

convexHull.cpp文件：

#include <iostream>
#include <vector>
#include <GL/glut.h>
#include "Geometry.h"

using namespace std;

GLsizei width = 600,height = 600;
vector<Point> list;

PLOTMODE mode ;

void init()
{
    glClearColor(0.0f,0.0f,0.0,1.0f);
    glViewport(0,0,width,height);
    glMatrixMode(GL_PROJECTION);
    gluOrtho2D(0,width,0,height);
}

//选择菜单
void selectMenu(GLint option)
{
    switch (option)
    {
    case 1:
        list.clear();
        glutPostRedisplay();
        break;
    case 2:
        mode = EP;
        glutPostRedisplay();
        break;
    case 3:
        mode = EE;
        glutPostRedisplay();
        break;
    case 4:
        mode = GW;
        glutPostRedisplay();
        break;
    case 5:
        mode = GS;
        glutPostRedisplay();
        break;
    default:
        break;
    }
}

void plotPoints(vector<Point> list)
{
    glBegin(GL_POINTS);
    for(int i=0;i<list.size();i++)
    {
        glVertex2i(list[i].x,list[i].y);
    }
    glEnd();
}

void plotEP(vector<Point>list)
{
    EPAlgorithm(list);
    glPointSize(3.0);
    glBegin(GL_POINTS);
    for(int i=0;i<list.size();i++)
    {
        if(list[i].extreme)
            glVertex2d(list[i].x,list[i].y);
    }
    glEnd();
    glPointSize(1.0);
}

void plotEE(vector<Point>list)
{
    vector<Edge> edge = EEAlgorithm(list);
    glBegin(GL_LINES);
    for(int i=0;i<edge.size();i++)
    {
        glVertex2d(edge[i].s.x,edge[i].s.y);
        glVertex2d(edge[i].e.x,edge[i].e.y);
    }
    glEnd();
}

void plotGW(vector<Point>list)
{
    vector<Edge> edge = GWAlgorithm(list);
    glBegin(GL_LINES);
    for(int i=0;i<edge.size();i++)
    {
        glVertex2d(edge[i].s.x,edge[i].s.y);
        glVertex2d(edge[i].e.x,edge[i].e.y);
    }
    glEnd();
}

void plotGS(vector<Point> list)
{
    stack<Point> s = GSAlgorithm(list);
    glBegin(GL_LINE_LOOP);
    {
        while (!s.empty())
        {
            glVertex2d(s.top().x,s.top().y);
            s.pop();
        }
    }
    glEnd();
}

void displayFunc()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1.0,0.0,0.0);
    glPointSize(1.0);
    plotPoints(list);
    cout<<mode<<endl;
    switch (mode)
    {
    case EE:
        plotEE(list);
        break;
    case EP:
        plotEP(list);
        break;
    case GW:
        plotGW(list);
        break;
    case GS:
        plotGS(list);
        break;
    default:
        break;
    }
    glFlush();
}

void reshapeFunc(GLint newWidth,GLint newHeight)
{
    glViewport(0,0,newWidth,newHeight);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0,GLdouble(newWidth),0.0,GLdouble(newHeight));
    width = newWidth;
    height = newHeight;
}

void mouseFunc(GLint button, GLint action, GLint x,GLint y)
{
    if(button==GLUT_LEFT_BUTTON&&action==GLUT_DOWN)
    {
        list.push_back(Point(x,height-y,0));
        glutPostRedisplay();
    }
}

int main(int argc,char* argv[])
{
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
    glutInitWindowPosition(100,100);
    glutInitWindowSize(width,height);
    glutCreateWindow("Convex Hull");

    init();
    glutCreateMenu(selectMenu);
    glutAddMenuEntry("清除点",1);
    glutAddMenuEntry("极点算法",2);
    glutAddMenuEntry("极边算法",3);
    glutAddMenuEntry("GiftWrapping算法",4);
    glutAddMenuEntry("Graham Scan算法",5);
    glutAttachMenu(GLUT_RIGHT_BUTTON);
    glutDisplayFunc(displayFunc);
    glutReshapeFunc(reshapeFunc);
    glutMouseFunc(mouseFunc);

    glutMainLoop();
}
溪水流不停
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGL凸包程序
03-27
此程序用C编写，利用OpenGL实现图形界面，实现了二维坐标系下的凸包算法，可以动态添加顶点，还可以自动生成。
OpenGL学习之求凸包
zhouzhouzf的专栏
12-08 1428
#include #include #include using namespace std; typedef struct{double x,y;} Point; void qsortpoint(Point s[],Point base,int start,int end); void sortstartedge(Point s[],int nums); void init() {
凸包算法
weixin_30394333的博客
08-01 275
凸包问题 下面有一系列的点,选择其中最少的点连接起来构成凸多边形并且包围所有的点假设不存在重合的点 通俗理解,假设下面每一个点都是钉在木板上的钉子,所求的多边形就是使用一根橡皮筋套在了所有钉子上的形状 凸多边形,红色圈起来的才是所求出来的点 步骤 找出所有点中y坐标最小的点(即最靠下的点)作为起始点 将其他点分别与起始点连接,按照逆时针方向分别给除起始点以外的每个点按照1,2,3.....
平面凸包算法opengl绘制
01-15
平面凸包算法opengl绘制 2维凸包算法 用opengl绘图
二维快速凸包算法代码（C++）
03-29
总之，二维快速凸包算法是解决二维几何问题的重要工具，通过C++实现并结合OpenGL进行可视化，可以帮助我们更好地理解和应用这一算法。在实际编码过程中，需要注意代码的可读性和效率，以及在适当的地方添加注释以...
Graham算法求平面散点集的凸包
01-16
本文参考自算法导论>>章节33.3,利用Graham算法寻找二位平面散点集的凸包,利用OpenGL将计算的结果绘制出来.算法主要利用向量的叉积判断点和线段的位置关系,详见 向量叉积,然后从左下角点按逆时针方向寻找最边缘的线段...
Graham Jarvis两种算法求散点集凸包
01-16
本篇文章将详细探讨两种用于求解平面散点集凸包的算法：Graham Jarvis算法和Jarvis步进法，并结合C++实现进行解析。 首先，我们来了解Graham Jarvis算法。这个算法以电脑科学家Ronald Graham命名，其核心思想是找到...
opengl多边形顶点排序，凸包计算，路径绘制
06-10
opengl多边形顶点排序，凸包计算，路径绘制 opengl多边形顶点排序，凸包计算，路径绘制 opengl多边形顶点排序，凸包计算，路径绘制
凸包算法详解1
04-08
共享资源，共同进步！共同开辟一片新天地！多谢多谢合作！
三维凸包（增量法）
04-02
三维凸包的增量算法，C++语言编写，供参考学习
最经典的凸包论文convex_hull
03-29
convex_hull： 最早，最经典的凸包论文 描述了凸包的原理，算法以及其证明
数学：凸包算法详解
xiong_min的博客
03-21 2064
一.概念： 凸包（Convex Hull）是一个计算几何（图形学）中的概念。 在一个实数向量空间V中，对于给定集合X，所有包含X的凸集的交集S被称为X的凸包。 X的凸包可以用X内所有点(X1，…Xn)的线性组合来构造. 在二维欧几里得空间中，凸包可想象为一条刚好包著所有点的橡皮圈。 用不严谨的话来讲，给定二维平面上的点集，凸包就是将最外层的点连接起来构成的凸多边型，它能包含点集中所有的点。 例子：...
凸包问题的五种解法
baningtao1470的博客
05-29 3047
前言： 首先，什么是凸包？ 假设平面上有p0~p12共13个点，过某些点作一个多边形，使这个多边形能把所有点都“包”起来。当这个多边形是凸多边形的时候，我们就叫它“凸包”。如下图： 然后，什么是凸包问题？ 我们把这些点放在二维坐标系里面，那么每个点都能用 (x,y) 来表示。 现给出点的数目13，和各个点的坐标。求构成凸包的点？ 解一：穷举法（...
opengl函数总结以及算法课程复习7
Duihanhan的博客
12-13 172
三维变换及三维观察 三维图形变换包括三维几何变换和投影变换 通过它可由简单图形得到复杂图形 可以用二维图形表示三维对象基于三维变换 可以在用户对图形进行交互式处理的过程中随时地对图形进行一系列连续地图形变换 达到用户的观察要求 三维变换的基本概念 几何变换 三维齐次坐标变换矩阵 平面几何投影 三维几何变换 三维基本几何变换 平移变换 比例变换 局部比例变换 整体比例变换 旋转变换 绕z轴旋转 绕x轴旋转 绕y轴旋转 对称变换 关于坐标平面对称 关于坐标轴对称 关于坐标原点对称 错切变换 沿x方向错切 沿y方
计算几何：凸包算法与退化情况分析
文中通过凸包算法SLOWCONVEXHULL为例，探讨了算法的时间复杂度和优化可能性，同时提到了处理退化情况和多点共线问题的挑战。此外，还涵盖了线段求交、多边形三角剖分、线性规划、正交区域查找、点定位、Voronoi图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值