凸包求解

最新推荐文章于 2022-05-06 10:20:14 发布
最新推荐文章于 2022-05-06 10:20:14 发布
阅读量477 收藏 2
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LZEP2015/article/details/44979849
版权

做了一下在线测试，在匆忙中没把凸包代码很好的完善，下面给出源码和效果。

#ifndef _GRAHAM_H_
#define _GRAHAM_H_
#include <cstdlib>
#include <iostream>
#include <cv.h>
#include <cxcore.h>
#include <highgui.h>
#include<Math.h>
using namespace std;


#define MINUM 65536
const float val=3.1415926;
typedef float FPoint;
typedef struct
{
  FPoint x;
  FPoint y;
}p2d;

typedef struct
{
   float x;
   float y;
   float angle;
}SPoint;

void Swap(SPoint **m_Point,int i,int j);
int _Partition(SPoint* TPoint,int left,int right);
void Quick_Sort(SPoint* TPoint,int left,int right);
int Find_Minumy_Point(SPoint *m_Point,int nLen);
void Compute_Angles(SPoint *m_Point,SPoint *T_Point,int nLen,int index);
float distance(SPoint *T_Point,SPoint pt,int flag);
void sort_by_distance(SPoint *T_Point,SPoint pt,int start,int end);
void Adjustment(SPoint *T_Point,SPoint pt,int nLen);
int GraHam(SPoint *m_Point,SPoint *T_Point,p2d* CS,int nLen);

#endif

#include"Graham.h"

void Swap(SPoint **m_Point,int i,int j)
{
    SPoint temp;
    temp.x=(*m_Point)[i].x;
    temp.y=(*m_Point)[i].y;
    temp.angle=(*m_Point)[i].angle;
    (*m_Point)[i].x=(*m_Point)[j].x;
    (*m_Point)[i].y=(*m_Point)[j].y;
    (*m_Point)[i].angle=(*m_Point)[j].angle;
    (*m_Point)[j].x=temp.x;
    (*m_Point)[j].y=temp.y;
    (*m_Point)[j].angle=temp.angle;
}
int _Partition(SPoint* TPoint,int left,int right)
{
    int pivot=left;
    int i=left+1;
    int j=right;
    while(1)
    {
        while(TPoint[i].angle<TPoint[pivot].angle&&i<=right) {i=i+1;}
        while(TPoint[j].angle>TPoint[pivot].angle&&j>left) {j=j-1;}
        if(i<j) { Swap(&TPoint,i,j); }
        else break;
    }
    Swap(&TPoint,pivot,j);
    return j;
}
void Quick_Sort(SPoint* TPoint,int left,int right)
{
    if(left<right)
    {
       int Partition=_Partition(TPoint,left,right);
       Quick_Sort(TPoint,left,Partition-1);
       Quick_Sort(TPoint,Partition+1,right);
    }
}
int Find_Minumy_Point(SPoint *m_Point,int nLen)
{
    int mid=(nLen-1)/2;
    float minumy=(float)MINUM;
    int res=-1;
    for(int i=0;i<=mid;i++)
    {
      if(m_Point[i].y<m_Point[nLen-1-i].y)
      {
        if(m_Point[i].y<minumy)
        {
          minumy=m_Point[i].y;
          res=i;
        }
        else
        {
        if(m_Point[i].y==minumy&&res!=-1)
        {
          if(m_Point[i].x<=m_Point[res].x)
          {
              minumy=m_Point[i].y;
              res=i;
          }
        }
        }
      }
      else
      {
        if(m_Point[nLen-i-1].y<minumy)
          {
            minumy=m_Point[nLen-1-i].y;
            res=nLen-1-i;
          }
        else
        {
        if(m_Point[nLen-i-1].y==minumy&&res!=-1)
          {
            if(m_Point[nLen-1-i].x<=m_Point[res].x)
            {
            minumy=m_Point[nLen-1-i].y;
            res=nLen-1-i;
            }
          }
        }
      }
    }
    return res;
}
void Compute_Angles(SPoint *m_Point,SPoint *T_Point,int nLen,int index)
{
    float m_tan,x,y;
    Swap(&m_Point,0,index);
    for(int i=1;i<nLen;i++)
    {
       x=m_Point[i].x-m_Point[0].x;
       y=m_Point[i].y-m_Point[0].y;
       if(x>0&&y>0) m_tan=atan(y/x);
       if(x>=0&&y==0)m_tan=0;
       if(x>0&&y<0) m_tan=2*val-atan((-y)/x);
       if(x<0&&y==0)m_tan=-val;
       if(x<0&&y>0) m_tan=val-atan(y/(-x));
       if(x<0&&y<0) m_tan=val+atan((-y)/x);
       if(x==0&&y>0)m_tan=0.5*val;
       if(x==0&&y<0)m_tan=1.5*val;
       //m_Tan=atan2f(y,x);
       T_Point[i-1].x=m_Point[i].x;
       T_Point[i-1].y=m_Point[i].y;
       T_Point[i-1].angle=m_tan;
    }
     for(int i=0;i<nLen-1;i++)
     printf("%f,%f,%f\n",T_Point[i].x,T_Point[i].y,T_Point[i].angle);
     printf("\n\n\n");
    Quick_Sort(T_Point,0,nLen-2);
}
float distance(SPoint *T_Point,SPoint pt,int flag)
{
      float dis=(T_Point[flag].x-pt.x)*(T_Point[flag].x-pt.x)+(T_Point[flag].y-pt.y)*(T_Point[flag].y-pt.y);
      dis=sqrtf(dis);
      return dis;
}
void sort_by_distance(SPoint *T_Point,SPoint pt,int start,int end)
{
     float dis1,dis2;
     for(int m=start;m<end;m++)
     {
       for(int n=m+1;n<end;n++)
       {
         dis1=distance(T_Point,pt,m);
         dis2=distance(T_Point,pt,n);
         if(dis1>dis2) Swap(&T_Point,m,n);
       }
     }
}
void Adjustment(SPoint *T_Point,SPoint pt,int nLen)
{
     int p=0,q;
     int dis1,dis2;
     while(p<nLen)
     {
       q=p+1;
       if(q>=nLen) break;
       else
       {
           while(T_Point[p].angle==T_Point[q].angle&&q<nLen)
           {
              q=q+1;
           }
           if(p+1==q)
           {
             p=p+1;
           }
           else
           {
               sort_by_distance(T_Point,pt,p,q-1);
           }
       }
     }
}
int GraHam(SPoint *m_Point,SPoint *T_Point,p2d* CS,int nLen)
{
     int index=Find_Minumy_Point(m_Point,nLen);
     printf("The point x=%f,y=%f has minumy\n",m_Point[index].x,m_Point[index].y);
    
     Compute_Angles(m_Point,T_Point,nLen,index);
     Adjustment(T_Point,m_Point[0],nLen-1);
    
     for(int i=0;i<nLen-1;i++)
     printf("%f,%f,%f\n",T_Point[i].x,T_Point[i].y,T_Point[i].angle);
     CS[0].x=T_Point[nLen-2].x;
     CS[0].y=T_Point[nLen-2].y;
     CS[1].x=m_Point[0].x;
     CS[1].y=m_Point[0].y;
     int sp=1;
     int k=0;
     float D;
     while(k<nLen-1)
     {
       //栈顶两点以及扫描线上一点所构成的三角区符号
       //D=CS[sp-1].x*CS[sp].y+CS[sp].x*T_Point[k].y+T_Point[k].x*CS[sp-1].y
       //-CS[sp-1].y*CS[sp].x-CS[sp].y*T_Point[k].x-T_Point[k].y*CS[sp-1].x;
      
       D=(T_Point[k].x-CS[sp].x)*(CS[sp-1].y-CS[sp].y)-(CS[sp-1].x-CS[sp].x)*(T_Point[k].y-CS[sp].y);

       if(D>=0)
       {
         sp=sp+1;
         CS[sp].x=T_Point[k].x;
         CS[sp].y=T_Point[k].y;
         k=k+1;
       }
       else
       {
         sp=sp-1;
         /*if(sp==0)
         {
          CS[sp].x=T_Point[k].x;
          CS[sp].y=T_Point[k].y;
         }*/
       }
      
      
      
     }
     return (sp+1);
}

/**************************************************************
***Mail:zhjkobe2013@live.com
***Author: zhang jie
***Function: Graham algorithms
***cpp:main.cpp
***Create time:2015-04-10 12:26
***Last Modify Time: 2015-04-10
***************************************************************/
#include "Graham.h"
//凸壳问题的格雷厄姆
#define WIDTH 640
#define HEIGHT 480
#define N 10
const char* win_name="GraHam";
int nCount=0;
int re=0;
void Record_Point_CallBack(int event,int x,int y,int flags,void* param);
CvPoint pt;
int main(int argc, char *argv[])
{
   IplImage* Img=cvCreateImage(cvSize(WIDTH,HEIGHT),IPL_DEPTH_8U,3);
   cvZero(Img);
   cvNamedWindow(win_name);
   CvPoint* m_Point=new CvPoint[N];
   char c;
   cvSetMouseCallback(win_name,Record_Point_CallBack,(void*)Img);
loop:
   while(1)
   {
      if(nCount>=1&&nCount<=N)
      {
      m_Point[nCount-1].x=pt.x;
      m_Point[nCount-1].y=pt.y;
      }
      //printf("nCount=%d\n",nCount);
      cvShowImage(win_name,Img);
      c=cvWaitKey(100);
      if(c=='r') { nCount=0; cvZero(Img); } 
      if(nCount==N+1) break;  
   }
   
   SPoint *p_Point=new SPoint[N];
   SPoint *T_Point=new SPoint[N-1];
   p2d* CS=new p2d[N+1];
   for(int i=0;i<N;i++)
   {
      p_Point[i].x=(float)m_Point[i].x;
      p_Point[i].y=(float)m_Point[i].y;
      p_Point[i].angle=0.0;
      printf("x=%d,y=%d\n",m_Point[i].x,m_Point[i].y);
   }
   printf("start\n");
   int nIndex=GraHam(p_Point,T_Point,CS,N);
   printf("nIndex=%d\n",nIndex);
   CvPoint pt1,pt2;
   for(int i=0;i<nIndex;i++)
     {
     pt1.x=(int)CS[i%nIndex].x;
     pt1.y=(int)CS[i%nIndex].y;
     pt2.x=(int)CS[(i+1)%nIndex].x;
     pt2.y=(int)CS[(i+1)%nIndex].y;
     printf("cs[%d].x=%f,cs[%d].y=%f\n",i,CS[i].x,i,CS[i].y);
     cvLine(Img,pt1,pt2,cvScalar(0,0,255),1,8,0);
     }
       printf("Finish\n");
   cvShowImage(win_name,Img);
   re=re+1;
   if(re==3)
   cvSaveImage("res.bmp",Img);
   nCount=0;
   printf("nCount=%d,re=%d\n",nCount,re);
goto loop;
   cvWaitKey(0);
   cvDestroyAllWindows();
   cvReleaseImage(&Img);
   if(p_Point) delete[] p_Point;
   if(m_Point) delete[] m_Point;
   if(CS) delete[] CS;
   system("PAUSE");
   return EXIT_SUCCESS;
}

void Record_Point_CallBack(int event,int x,int y,int flags,void* param)
{
     IplImage* pImg=(IplImage*)param;
     switch(event)
     {
       case CV_EVENT_LBUTTONDOWN:
            {
               pt.x=x;
               pt.y=y;
               if(nCount<N) cvCircle(pImg,cvPoint(pt.x,pt.y),1,cvScalar(255,0,0),1,8,0);
               nCount+=1;
            }
       break;
       case CV_EVENT_RBUTTONDOWN:
            {
                nCount=-1;
                cvZero(pImg);
            }
       break;
       default: break;
     }
}


LZEP2015
关注
专栏目录
凸包问题的五种解法
baningtao1470的博客
05-29 3093
前言： 首先，什么是凸包？ 假设平面上有p0~p12共13个点，过某些点作一个多边形，使这个多边形能把所有点都“包”起来。当这个多边形是凸多边形的时候，我们就叫它“凸包”。如下图： 然后，什么是凸包问题？ 我们把这些点放在二维坐标系里面，那么每个点都能用 (x,y) 来表示。 现给出点的数目13，和各个点的坐标。求构成凸包的点？ 解一：穷举法（...
求解凸包
futangxiang4793的博客
08-18 283
算法介绍 栈顶前一个位O 栈顶元素A 当前元素B 如果向量OA x OB <=0 说明A在OB左侧或者OB上 即：A不属于凸包上的点 /* 求凸包 * 即用一个最小的凸多边形包围所有的点 输出构成这个凸多边形的点 * graham扫描法 * 维护一个栈 保存可能属于凸多边形上的点 在接下来的验证中 如果不属于就出栈 * 初始化： 找一个y值最小的点（一定属于凸包） 然后放置到...
凸包问题求解
热门推荐
pandaww的博客
06-24 2万+
什么是凸包呢？ 凸包（Convex Hull）是一个计算几何（图形学）中的概念。 在一个实数向量空间V中，对于给定集合X，所有包含X的凸集的交集S被称为X的凸包。X的凸包可以用X内所有点(X1，...Xn)的凸组合来构造. 在二维欧几里得空间中，凸包可想象为一条刚好包著所有点的橡皮圈。 用不严谨的话来讲，给定二维平面上的点集，凸包就是将最外层的点连接起来构成的凸多边形，它能包含点集中所有的...
凸包问题及其求解方法
SJ1820161738的博客
07-08 1656
凸包问题什么是凸包问题？ 凸包：包含给定集合X的凸集的交集。 概念 -点集Q的凸包（convex hull）是指一个最小凸多边形，满足Q中的点或者在多边形边上或者在其内。下图中由红色线段表示的多边形就是点集Q={p0,p1,…p12}的凸包。 凸包问题：一组平面上的点，求一个包含所有点的最小的凸多边形。 -这可以形象地想成这样：在地上放置一些不可移动的木桩，用一根绳子把他们尽量紧地圈起来，并且为
怎么用凸包求解TSP问题？
最新发布
05-25
TSP问题是一个经典的组合优化问题，凸包求解TSP问题是一种常见的方法之一。具体步骤如下： 1. 将所有点的坐标作为点集，求出点集的凸包。 2. 在凸包上进行遍历，找到一个起点。 3. 对于起点，从它开始进行遍历。每次...
凸包算法 matlab程序
02-14
凸包算法在计算机科学中是一种重要的几何计算方法，特别是在机器学习和数据分析领域有着广泛的应用。在给定的标题和描述中，重点强调了"凸包算法"在解决"二元分类问题"时使用MATLAB编程的情况。下面我们将深入探讨...
安德鲁算法详解：计算几何凸包求解策略
总结来说，安德鲁算法是求解凸包问题的一种高效方法，它巧妙地利用向量的叉积来确定点的位置关系，从而构造出包含所有输入点的最小凸多边形。理解并掌握这个算法对于处理二维空间中的几何问题至关重要。
如何使用凸包求解图像轮廓
05-12
在图像处理中，凸包可以用于求解图像轮廓。 步骤如下： 1. 将图像转换为二值图像，即将图像转换为只包含黑色和白色两种颜色的图像。 2. 对二值图像进行边缘检测，得到边缘点集合。 3. 对边缘点集合进行凸包计算...
你能用c++编写凸包求解的代码吗
02-15
当然，我可以帮助您编写c语言求解凸包的代码。下面是一个简单的示例代码，它使用了计算几何中的Andrew算法： ``` #include #include #include #define MAX_POINTS 100000 #define INFINITY 1e9 #define eps 1e-...
凸包问题的算法
06-03
这个文档是描述凸包问题的算法，采用的是蛮力法
凸包求解三种实现
Roxannekkk的博客
03-20 536
定理依赖：如果一个点在平面上某三个点组成的三角形内，那么这个点不可能是凸包上的点 需要的基本知识 叉积的计算： a(x1,y1) b(x2,y2)=> axb=x1y2-x2y1 转换到代码中即为 ABxAC=(B[0]-A[0])*(C[1]-A[1])-(C[0]-A[0])*(B[1]-A[1]) 利用叉乘判断M是否在三角形ABC中： 若M在ABC中，则MA X MB,MB X MC,MC X MA 此三组的向量叉乘的结果都是同号的（或都正，或都负），即方向相同的，则说明点M在三角形每.
(转载)凸包问题的五种解法
门前大桥下，游过一群鸭，快来看一看，原来是C++
05-06 2333
前言： 首先，什么是凸包？ 假设平面上有p0~p12共13个点，过某些点作一个多边形，使这个多边形能把所有点都“包”起来。当这个多边形是凸多边形的时候，我们就叫它“凸包”。如下图： 然后，什么是凸包问题？ 我们把这些点放在二维坐标系里面，那么每个点都能用 (x,y) 来表示。 现给出点的数目13，和各个点的坐标。求构成凸包的点？ 解一：穷举法（蛮力法） 时间复杂度：O(n³）。 思路：两点确定一条直线，如果剩余的其它点都在这条直线的同一侧，则这两个点是凸包上的点，否则就不是。 步骤...
c语言中图形类的头文件#include <graphics.h>,graphics.h头文件是什么？graphics.h包含的函数一览...
weixin_42513522的博客
05-23 1万+
graphics.h头文件是C语言和visual studio的图形库文件，包含像素函数、线型函数、画线函数、相对画线函数等多种函数，可进行图形的快速编程，如果您的电脑缺少graphics.h头文件就需要下载安装一下，就可实现图形绘制功能了。graphics.h包含的函数线型函数line() 画线函数lineto() 画线函数linerel() 相对画线函数setlinestyle() 设置线型函...
凸包 —— 五种解法
lxt_Lucia的博客
10-17 7194
欢迎访问https://blog.csdn.net/lxt_Lucia～～ 宇宙第一小仙女\(^o^)/～～萌量爆表求带飞=≡Σ((( つ^o^)つ~ dalao们点个关注呗～～   关于凸包，之前一直漏掉了这一个，上周末组队赛，听说有一题就是凸包的模板，可惜不会，听说不算很难，正好这周空余的课很少，就顺便搞了8...    目录 前言 解一：穷举法（蛮力法） 解二：分治法 解三...
凸包算法
lihaidong的博客
12-27 8011
1、凸包定义 凸包问题可以描述为：给定一个点集P，求最小点集S，使得S构成的形状能包含这些点集。 凸包的定义为：平面的一个子集S被称为是“凸”的，当且进当对于任意两点p,q∈S，线段 都完全属于S。几何S的凸包CH(S)，就是包含S的最小凸集，更准确地说，它是包含S的所有凸集的交[2]。由此还可以推出凸包的很多性质，包括一条直线如果与凸包相交（不是相切）的话，最多交于两条边或者两个面 二...
凸包算法求解(C++)
Wyc_Vi的博客
09-23 4569
老师刚刚布置了个作业，让用quicksort实现凸包。但是我突然有一丝灵感，所以就写下我的想法，希望大家可以提出问题和改进，感谢。 我们知道Graham扫描法实现凸包是先找到纵坐标最小的点，基于这个想法我做了一些改进，也就是说Graham扫描法只是从一个方向发散出去，我们为何不从四个方向同时发散。也即找到x，y轴坐标最大或最小的四个点（也有可能是两个或者三个，这个先不讨论），以这四个点为基点，平...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值