精华内容
下载资源
问答
  • 计算多边形面积

    2017-12-04 15:45:59
    计算多边形面积计算多边形面积计算多边形面积计算多边形面积计算多边形面积
  • 我改进了计算图形直接定义的多边形计算程序,请试用,请将试用的评价贴出来。
  • 我又改进了这个程序,在读入图形文件后,可以在图形上任意定义多边形,然后计算面积,这在房地产开发,建设工程中有了广泛的用途,这也减少了输入数据给使用带来的不便,大大提高了运算效率。
  • 计算多边形面积

    千次阅读 2020-08-20 18:00:07
    计算任意多边形面积

    计算任意多边形的面积
    在这里插入图片描述
    在这里插入图片描述

    计算三角形面积 
    double getS(Point a,Point b,Point c)    
      {  
          return ((b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x)) / 2;   //应用叉积的定义推出的 
      }
    
    计算多边形面积。必须确保 n>=3,且多边形是凸多边形 
    double getPS(Point p[], int n)    
     {
         double sumS = 0;
         for(int i = 1; i <= n - 1; i++)
             sumS += getS(p[1], p[i], p[i + 1]);  // n-2个三角形的面积和
         return sumS;
     }
    

    参考: 计算凸多边形面积的算法

    计算任意多边形的面积
    首先判断图形是否是凸多边形,然后把它切割成多个三角形,然后利用叉乘定理,可以计算出他的面积。

    在这里插入图片描述
    计算几何之凸包(一) {卷包裹算法}
    Python求凸包及多边形面积
    在这里插入图片描述

    展开全文
  • 任意多边形面积计算

    万次阅读 多人点赞 2016-04-12 09:56:48
    任意给出一个三角形ΔABC,设其顶点坐标分别为A(x1, y1),B(x2, y2),C(x3, y3),那么根据线性代数的知识,Δ...我们知道任意的多边形都可以分割成多个三角形,根据以上三角形面积公式就可以求出任意多边形的面

    任意给出一个三角形ΔABC,设其顶点坐标分别为A(x1, y1),B(x2, y2),C(x3, y3),那么根据线性代数的知识,ΔABC的有向面积可表示为:


    其中,ΔABC顶点A、B、C逆时针给出时有向面积为正,顺时针给出时有向面积为负。如图1所示,S∆ABC>0、S∆ABD<0.


    图1

    我们知道任意的多边形都可以分割成多个三角形,根据以上三角形面积公式就可以求出任意多边形的面积。如图2所示的六边形顶点坐标分别为O(x0, y0),A(x1, y1),B(x2, y2),C(x3, y3),D(x4, y4),E(x5, y5),则其面积可以表示为四个三角形面积之和:S=S∆OAB+S∆OBC+S∆OCD+S∆ODE

    其中:

    所以



    图2

    在这里,前文给出的多边形示例是一个凸多边形,那么这一结论适用于凹多边形吗?下面我们看看如图3所示的凹多边形。

    图3

    按照上面的思路,这里的凹多边形面积表示为:S=S∆OAB+S∆OBC+S∆OCD,从前面介绍可以知道

    S∆OAB=-S∆OBA<0,所以很明显上式是成立的,即此公式也适用于凹多边形。

    经过以上分析,给出任意一个多边形,其顶点坐标依次为(x0,y0),(x1,y1),(x2,y2),...,(xn,yn)(其中n=2,3,4,…),则其面积可表示为:


    换句话说,若已知多边形边上的每一点坐标,我们就可以求出该多边形的面积,包括如图4所示的曲线图形,当从O点到A点到O点的曲线上每一点坐标都已知时就能求出该曲线图的面积。

    图4

    下面是代码示例

    <script>
        function square(x,y) {
    //数组x,y分别按顺序存储各点的横、纵坐标值
            var sum0=0;
            for (var i = 0; i < x.length - 1; i++) {
                sum0 += (x[i] * y[i + 1] - x[i + 1] * y[i]);
            }
            var square = (Math.abs(sum0 + (x[i] * y[0]) - (x[0] * y[i]))) / 2;
            return square;
        }
    </script>


    展开全文
  • 任意多边形面积计算

    万次阅读 2015-09-11 10:01:03
    之前,应朋友所托,完成个四边形面积计算程序... 后来想到用图形学中填充算法中的扫描线方法,切分成梯形与三角形,将交点存入活性边表后再计算面积,感觉也较复杂,放弃。  再然后,找到个计算几何大神O’Rourke在

    之前,应朋友所托,完成个四边形面积计算程序,于是不由自主考虑来个扩展,解决任意多边形面积的计算。

           一开始想到了某定点的三角形剖分,但遇到凹凸多边形引发的多种情况,过于复杂,放弃。

           后来想到用图形学中填充算法中的扫描线方法,切分成梯形与三角形,将交点存入活性边表后再计算面积,感觉也较复杂,放弃。

           再然后,找到个计算几何大神O’Rourke在1998年公开的成果。

    *(书名:Computational Geometry in C,第二版P20)*



    1-原理介绍

           上书中给出定理:

    任意多边形的面积可由任意一点与多边形上依次两点连线构成的三角形矢量面积求和得出。

           矢量面积=三角形两边矢量的叉乘。

           如下图:

     

    按定理,多边形面积由P点与A-G的各顶点连接所构成的三角形矢量面积构成,假定多边形顶点坐标顺序为A-G,逆时针为正方向,则有如下结论:

    PAB,PBC,PCD均为顺时针,面积为负;

    PDE,PEF,PFG,PGA均未逆时针,面积为正;

    但无论正负,均可通过P点与顶点连线的矢量叉乘完成,叉乘结果中已包含面积的正负。

     

    2-程序设计

    采用C++的vector(动态数组)存储顶点坐标。

    为方便计算,直接将P点定为原点(0,0),则多边形顶点xy坐标即为向量在xy上分量。

    循环计算多边形顶点坐标每一点与下一点之间的线段,及这两点与P连线的矢量所围成的三角形面积。

    计算面积的函数代码如下:

    复制代码
    iArea=iArea+(vecPoly[iCycle].x*vecPoly[(iCycle+1) % iCount].y-vecPoly[(iCycle+1) % iCount].x*vecPoly[iCycle].y);
    int intAreaCalc(vector<myPoint> &vecPoly)
    {
        int iCycle,iCount,iArea;
        iCycle=0;
        iArea=0;
        iCount=vecPoly.size();
    
        for(iCycle=0;iCycle<iCount;iCycle++)
        {    
            iArea=iArea+(vecPoly[iCycle].x*vecPoly[(iCycle+1) % iCount].y-vecPoly[(iCycle+1) % iCount].x*vecPoly[iCycle].y);
        }
        
        return abs(0.5*iArea);
    }
    复制代码

    注意,要注意的是最后一个顶点,要与第一个顶点练成三角形,可将循环变量对顶点总数求同余,则循环过程中的最后一点+1后,自然会成为第一个顶点,上述代码中的“% iCount”即为解决此问题。

     

    完整程序,请下载工程文件。

     http://files.cnblogs.com/vbspine/sdkPoly.rar

    Ps:上述程序在Win7x64,VS2008环境下编译通过。


    转载:http://www.cnblogs.com/vbspine/archive/2013/03/28/2987818.html


     方法:转自红黑联盟:http://www.2cto.com/kf/201210/162799.html

    题目:输入一个点列,顺次连接成一个封闭多边形,计算多边形的面积

    分析:方法一,计算面积可以考虑定积分的形式,定积分有正有负,顺次求和,重复部分相互抵消,最后剩下的总面积的绝对值就是多边形的面积。

    从线性积分后的结果可以容易的看出,直线段的积分实际上就是求该直线段与x轴所围成的区域的梯形的面积Int(P1, P2) = Int(k*x + b, P1.x, P2.x) = 0.5 * (P2.x - P1.x) * (P2.y + P1.y), 斜率k = (P1.y - P2.y) / (P1.x - P2.x),截距b = P1.y - k*P1.x

    算法的复杂度为:O(N)N为顶点的个数。

    [cpp code]
    struct Point {
    float x, y;
    };
    float LinearIntegration(const Point &p1, const Point &p2) {
    return 0.5 * (p2.x - p1.x) * (p2.y + p1.y);
    }
    float ComputePolygonArea(const Point points[], int N) {
    if (points == NULL || N <= 0) return 0.0;
    float area = 0.0;
    for (int i = 0; i < N - 1; ++ i) {
    area += LinearIntegration(points[i], points[i + 1]);
    }
    area += LinearIntegration(points[N - 1], points[0]);
    return area >= 0.0 ? area : -area;
    }


    方法二,考虑到平面上知道三角形三个顶点的坐标可以运用行列式det直接求解三角形的面积。如P1(x1,y1)P2(x2,y2)P3(x3,y3),则

    S(P1, P2, P3) = det[ x1 y1 1; x2 y2 1; x3 y3 1] * 0.5 = [(x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)] * 0.5;

    可以在多边形的平面中任意的找到一个点,与多边形的每条边形成有向三角形,并顺次求取有向三角形的面积,再加和,因为是有向面积同上述定积分类似,面积有正有负可抵消重复部分,剩下的面积的绝对值即为多边形的面积。

    [cpp code]
    struct Point {
    float x, y;
    Point() {x = 0.0; y = 0.0;}
    Point(float _x, float _y) {x = _x; y = _y;}
    };
    float ComputeTriangleArea(const Point &p1, const Point &p2, const Point &p3) {
    return 0.5 * ((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y));
    }
    float ComputePolygonAreaTri(const Point points[], int N) {
    if (points == NULL || N <= 0) return 0.0;
    Point p0(0.0, 0.0);
    float area = 0.0;
    for (int i = 0; i < N - 1; ++ i) {
    area += ComputeTriangleArea(p0, points[i], points[i + 1]);
    }
    area += ComputeTriangleArea(p0, points[N - 1], points[0]);
    return area >= 0.0 ? area : -area;
    }

     

    实例:

    [cpp test code]

    #include

    using namespace std;

     

    struct Point

    {  

        float x, y;  

    };  

    float LinearIntegration(const Point &p1, const Point &p2)

    {  

        return 0.5 * (p2.x - p1.x) * (p2.y + p1.y);  

    }  

    float ComputePolygonArea(const Point points[], int length)

    {  

        if (points == NULL || length <= 0) return 0.0;  

        float area = 0.0;  

        for (int i = 0; i < length - 1; ++ i)

        {  

            area += LinearIntegration(points[i], points[i + 1]);  

        }  

        area += LinearIntegration(points[length - 1], points[0]);  

        return area >= 0.0 ? area : -area;  

    }  

     

    int main()

    {

        int n;

        while(cin>>n && n!=0)

        {

           Point a[n];

           for(int i=0; i

               cin>>a[i].x>>a[i].y;

           float ans = ComputePolygonArea(a,n);

           cout<<ans<<endl;

        }

        return 0;

     

    }

    题目:http://acm.whu.edu.cn/learn/problem/detail?problem_id=1402

    Description

    Mr. Tenant is going to buy a new house. In fact, he is going to buy a piece of land and build his new house on it. In order to decide which piece of land to buy, Mr. Tenant needs a program which will give a score to each piece. Each candidate piece of land is a polygonal shape (not necessarily convex), and Mr. Tenant wonders what the best score is. Among possible scores, he considered the number of vertices, sum of angles, minimum number of required guards, and so forth. Finally, Mr. Tenant decided that the best score for a piece of land would simply be its area. Your task is to write the desired scoring program.

    Input
    The input file consists of multiple pieces of land. Each piece is a simple polygon (that is, a polygon which does not intersect itself). A polygon description starts with a positive integer number k, followed by k vertices, where each vertex consists of two coordinates (floating-point numbers): x and y. Naturally, the last vertex is connected by an edge to the first vertex. Note that each polygon can be ordered either clockwise or counterclockwise. The input ends with a "0" (the number zero).
    Output
    For each piece of land, the output should consist of exactly one line containing the score of that piece, rounded to the nearest integer number. (Halves should be rounded up, but Mr. Tenant never faced such cases.) Hint: The scoring program has to handle well degenerate cases, such as, polygons with only one or two vertices.
    Sample Input
    1 123.45 67.890
    3 0.001 0 1.999 0 0 2
    5 10 10 10 12 11 11 12 12 12.0 10.0
    0
    Sample Output

     

    0
    2
    3

    转载:http://blog.sina.com.cn/s/blog_a2ae2da90101ofk7.html

    展开全文
  • 该demo实现了将坐标系中无序的坐标点排列位有序的坐标点,并按照排序后的坐标点组成多边形,并计算多边形面积。其中也包含坐标系中点在坐标中象限的划分和qt的路径绘图,通过QPainterPath和QPainter绘制图形和QMap...
  • 图像处理中经常遇到,两个凹多边形交叉的面积计算。python实现多边形交叉面积计算。实例
  • 多边形面积周长计算C++源码

    热门讨论 2013-03-20 20:59:04
    多边形计算周长面积的源码 C++编写 可用于导线的计算
  • //求任意多边形面积 /*语法:result = polygonarea(vector<Point>&polygon, int N); 参数: polygon:多变形顶点数组 N:多边形顶点数目 返回值:多边形面积 注意: 支持任意多边形,凹、凸皆可 多边形...

     

    //求任意多边形的面积
    /*语法:result = polygonarea(vector<Point>&polygon, int N);
    参数:
    polygon:多变形顶点数组
    N:多边形顶点数目
    返回值:多边形面积
    注意:
    支持任意多边形,凹、凸皆可
    多边形顶点输入时按顺时针顺序排列
    
    */
    #include <iostream>
    #include <vector>
    using namespace std;
    typedef struct  Point{
        double x, y;
        Point(){}
    } Point;
    double polygonarea(vector<Point>&polygon, int N)
    {
        int i, j;
        double area = 0;
        for (i = 0; i<N; i++) {
            j = (i + 1) % N;
            area += polygon[i].x * polygon[j].y;
            area -= polygon[i].y * polygon[j].x;
        }
        area /= 2;
        return(area < 0 ? -area : area);
    }
    
    //测试函数
    int main(){
    
        vector<Point> polygon;
        int n;
        cin >> n;
        polygon.resize(n);
        int i = 0;
        while (n--){
            double x, y;
            cin >> x >> y;
            polygon[i].x = x;
            polygon[i].y = y;
            ++i;
        }
        cout << "此多边形的面积为" << polygonarea(polygon, polygon.size()) << endl;
    
    
        return 0;
    }
    
    
    

    参考:C++实现——任意多边形的面积

    参考:C++实现多边形面积的计算

    参考:C++ 描述任意多边形的类及计算其面积和周长

     

    计算IOU代码稍后补充。

    计算IOU最初只计算正矩形的IOU,当矩形有角度或者任意四边形的IOU计算就比较困难。一般见到的计算IOU都是python直接调用封装好的库。如下,下面代码从shapely中导出Polygon库,其实可以直接导入Polygon库。

    看到一篇clipper和Polygon的文章:python多边形裁剪库效果对比

    背景:在进行目标检测时,常常会用到交并比的概念(IoU(Intersection over Union))

                                                                 IoU=\frac{Area\, of\, Overlap}{Area\, of\, Union}

    一般来说,这个IoU > 0.5 就可以被认为是一个不错的结果

    1.规则矩形框的IoU计算

    有些目标检测中,预测的边界框为规则的矩形,则只需要知道矩形的左上角和右下角的坐标信息,就可以得到矩形框所有想要的信息。对于这种情况,IoU的python实现如下(python3.5)

    def IoU(box1, box2):
        '''
        计算两个矩形框的交并比
        :param box1: list,第一个矩形框的左上角和右下角坐标
        :param box2: list,第二个矩形框的左上角和右下角坐标
        :return: 两个矩形框的交并比iou
        '''
        x1 = max(box1[0], box2[0])   # 交集左上角x
        x2 = min(box1[2], box2[2])   # 交集右下角x
        y1 = max(box1[1], box2[1])   # 交集左上角y
        y2 = min(box1[3], box2[3])   # 交集右下角y
     
        overlap = max(0., x2-x1) * max(0., y2-y1)
        union = (box1[2]-box1[0]) * (box1[3]-box1[1]) \
                + (box2[2]-box2[0]) * (box2[3]-box2[1]) \
                - overlap
     
        return overlap/union
    if __name__ == '__main__':
        # box = [左上角x1,左上角y1,右下角x2,右下角y2]
        box1 = [10, 0, 15, 10]
        box2 = [12, 5, 20, 15]
        iou = IoU(box1, box2)

    2. 非矩形框IoU计算

    在有些目标检测中,检测框并不是规则的矩形框,例如自然场景下的文本检测,有些呈现平行四边形,梯形等情况,这时计算IoU时,就比较复杂一些。这时可以借助于python的一些库实现多边形的面积计算

    import shapely
    import numpy as np
    from shapely.geometry import Polygon, MultiPoint  # 多边形
     
    def bbox_iou_eval(box1, box2):
        '''
        利用python的库函数实现非矩形的IoU计算
        :param box1: list,检测框的四个坐标[x1,y1,x2,y2,x3,y3,x4,y4]
        :param box2: lsit,检测框的四个坐标[x1,y1,x2,y2,x3,y3,x4,y4]
        :return: IoU
        '''
        box1 = np.array(box1).reshape(4, 2)  # 四边形二维坐标表示
        # python四边形对象,会自动计算四个点,并将四个点重新排列成
        # 左上,左下,右下,右上,左上(没错左上排了两遍)
        poly1 = Polygon(box1).convex_hull
        box2 = np.array(box2).reshape(4, 2)
        poly2 = Polygon(box2).convex_hull
     
        if not poly1.intersects(poly2):  # 如果两四边形不相交
            iou = 0
        else:
            try:
                inter_area = poly1.intersection(poly2).area  # 相交面积
                iou = float(inter_area) / (poly1.area + poly2.area - inter_area)
            except shapely.geos.TopologicalError:
                print('shapely.geos.TopologicalError occured, iou set to 0')
                iou = 0
     
        return iou
     
    if __name__ == '__main__':
        # box = [四个点的坐标,顺序无所谓]
        box3 = [10, 0, 15, 0, 15, 10, 10, 10]   # 左上,右上,右下,左下
        box4 = [12, 5, 20, 2, 20, 15, 12, 15]
        iou = bbox_iou_eval(box3, box4)
        print(iou)

     

    参考:IOU交并比的计算

    关于计算交集面积的代码看到一篇,还没有验证:Gym 100952J&&2015 HIAST Collegiate Programming Contest J. Polygons Intersection【计算几何求解两个凸多边形的相交面积板子题】

    #include "iostream"
    #include "string.h"
    #include "stack"
    #include "queue"
    #include "string"
    #include "vector"
    #include "set"
    #include "map"
    #include "algorithm"
    #include "stdio.h"
    #include "math.h"
    #define ll long long
    #define bug(x) cout<<x<<" "<<"UUUUU"<<endl;
    #define mem(a) memset(a,0,sizeof(a))
    #define mp(x,y) make_pair(x,y)
    using namespace std;
    const long long INF = 1e18+1LL;
    const int inf = 1e9+1e8;
    const int N=1e5+100;
    #define maxn 510
    const double eps=1E-8;
    int sig(double d){
        return(d>eps)-(d<-eps);
    }
    struct Point{
        double x,y; Point(){}
        Point(double x,double y):x(x),y(y){}
        bool operator==(const Point&p)const{
            return sig(x-p.x)==0&&sig(y-p.y)==0;
        }
    };
    double cross(Point o,Point a,Point b){
        return(a.x-o.x)*(b.y-o.y)-(b.x-o.x)*(a.y-o.y);
    }
    double area(Point* ps,int n){
        ps[n]=ps[0];
        double res=0;
        for(int i=0;i<n;i++){
            res+=ps[i].x*ps[i+1].y-ps[i].y*ps[i+1].x;
        }
        return res/2.0;
    }
    int lineCross(Point a,Point b,Point c,Point d,Point&p){
        double s1,s2;
        s1=cross(a,b,c);
        s2=cross(a,b,d);
        if(sig(s1)==0&&sig(s2)==0) return 2;
        if(sig(s2-s1)==0) return 0;
        p.x=(c.x*s2-d.x*s1)/(s2-s1);
        p.y=(c.y*s2-d.y*s1)/(s2-s1);
        return 1;
    }
    //多边形切割
    //用直线ab切割多边形p,切割后的在向量(a,b)的左侧,并原地保存切割结果
    //如果退化为一个点,也会返回去,此时n为1
    void polygon_cut(Point*p,int&n,Point a,Point b){
        static Point pp[maxn];
        int m=0;p[n]=p[0];
        for(int i=0;i<n;i++){
            if(sig(cross(a,b,p[i]))>0) pp[m++]=p[i];
            if(sig(cross(a,b,p[i]))!=sig(cross(a,b,p[i+1])))
                lineCross(a,b,p[i],p[i+1],pp[m++]);
        }
        n=0;
        for(int i=0;i<m;i++)
            if(!i||!(pp[i]==pp[i-1]))
                p[n++]=pp[i];
        while(n>1&&p[n-1]==p[0])n--;
    }
    //---------------华丽的分隔线-----------------//
    //返回三角形oab和三角形ocd的有向交面积,o是原点//
    double intersectArea(Point a,Point b,Point c,Point d){
        Point o(0,0);
        int s1=sig(cross(o,a,b));
        int s2=sig(cross(o,c,d));
        if(s1==0||s2==0)return 0.0;//退化,面积为0
        if(s1==-1) swap(a,b);
        if(s2==-1) swap(c,d);
        Point p[10]={o,a,b};
        int n=3;
        polygon_cut(p,n,o,c);
        polygon_cut(p,n,c,d);
        polygon_cut(p,n,d,o);
        double res=fabs(area(p,n));
        if(s1*s2==-1) res=-res;return res;
    }
    //求两多边形的交面积
    double intersectArea(Point*ps1,int n1,Point*ps2,int n2){
        if(area(ps1,n1)<0) reverse(ps1,ps1+n1);
        if(area(ps2,n2)<0) reverse(ps2,ps2+n2);
        ps1[n1]=ps1[0];
        ps2[n2]=ps2[0];
        double res=0;
        for(int i=0;i<n1;i++){
            for(int j=0;j<n2;j++){
                res+=intersectArea(ps1[i],ps1[i+1],ps2[j],ps2[j+1]);
            }
        }
        return res;//assumeresispositive!
    }
    //hdu-3060求两个任意简单多边形的并面积
    Point ps1[maxn],ps2[maxn];
    int n1,n2;
    int main(){
        int t;
        cin>>t;
        while(t--){
            scanf("%d%d",&n1,&n2);
            for(int i=0;i<n1;i++)
                scanf("%lf%lf",&ps1[i].x,&ps1[i].y);
            for(int i=0;i<n2;i++)
                scanf("%lf%lf",&ps2[i].x,&ps2[i].y);
            double ans=intersectArea(ps1,n1,ps2,n2);
            //ans=fabs(area(ps1,n1))+fabs(area(ps2,n2))-ans;//容斥
            printf("%.4f\n",ans);
        }
        return 0;
    }

    运行输入和结果如下(其中前四行是输入,最后一行是输出):

    另外还看到一篇计算IOU的代码:https://github.com/CAPTAIN-WHU/DOTA_devkit/blob/master/polyiou.cpp

     

    #include<cstdio>
    #include<iostream>
    #include<algorithm>
    #include<cmath>
    #include <vector>
    using namespace std;
    #define maxn 51
    const double eps=1E-8;
    int sig(double d){
        return(d>eps)-(d<-eps);
    }
    struct Point{
        double x,y; Point(){}
        Point(double x,double y):x(x),y(y){}
        bool operator==(const Point&p)const{
            return sig(x-p.x)==0&&sig(y-p.y)==0;
        }
    };
    double cross(Point o,Point a,Point b){  //叉积
        return(a.x-o.x)*(b.y-o.y)-(b.x-o.x)*(a.y-o.y);
    }
    double area(Point* ps,int n){
        ps[n]=ps[0];
        double res=0;
        for(int i=0;i<n;i++){
            res+=ps[i].x*ps[i+1].y-ps[i].y*ps[i+1].x;
        }
        return res/2.0;
    }
    int lineCross(Point a,Point b,Point c,Point d,Point&p){
        double s1,s2;
        s1=cross(a,b,c);
        s2=cross(a,b,d);
        if(sig(s1)==0&&sig(s2)==0) return 2;
        if(sig(s2-s1)==0) return 0;
        p.x=(c.x*s2-d.x*s1)/(s2-s1);
        p.y=(c.y*s2-d.y*s1)/(s2-s1);
        return 1;
    }
    //多边形切割
    //用直线ab切割多边形p,切割后的在向量(a,b)的左侧,并原地保存切割结果
    //如果退化为一个点,也会返回去,此时n为1
    //void polygon_cut(Point*p,int&n,Point a,Point b){
    //    static Point pp[maxn];
    //    int m=0;p[n]=p[0];
    //    for(int i=0;i<n;i++){
    //        if(sig(cross(a,b,p[i]))>0) pp[m++]=p[i];
    //        if(sig(cross(a,b,p[i]))!=sig(cross(a,b,p[i+1])))
    //            lineCross(a,b,p[i],p[i+1],pp[m++]);
    //    }
    //    n=0;
    //    for(int i=0;i<m;i++)
    //        if(!i||!(pp[i]==pp[i-1]))
    //            p[n++]=pp[i];
    //    while(n>1&&p[n-1]==p[0])n--;
    //}
    void polygon_cut(Point*p,int&n,Point a,Point b, Point* pp){
    //    static Point pp[maxn];
        int m=0;p[n]=p[0];
        for(int i=0;i<n;i++){
            if(sig(cross(a,b,p[i]))>0) pp[m++]=p[i];
            if(sig(cross(a,b,p[i]))!=sig(cross(a,b,p[i+1])))
                lineCross(a,b,p[i],p[i+1],pp[m++]);
        }
        n=0;
        for(int i=0;i<m;i++)
            if(!i||!(pp[i]==pp[i-1]))
                p[n++]=pp[i];
        while(n>1&&p[n-1]==p[0])n--;
    }
    //---------------华丽的分隔线-----------------//
    //返回三角形oab和三角形ocd的有向交面积,o是原点//
    double intersectArea(Point a,Point b,Point c,Point d){
        Point o(0,0);
        int s1=sig(cross(o,a,b));
        int s2=sig(cross(o,c,d));
        if(s1==0||s2==0)return 0.0;//退化,面积为0
        if(s1==-1) swap(a,b);
        if(s2==-1) swap(c,d);
        Point p[10]={o,a,b};
        int n=3;
        Point pp[maxn];
        polygon_cut(p,n,o,c, pp);
        polygon_cut(p,n,c,d, pp);
        polygon_cut(p,n,d,o, pp);
        double res=fabs(area(p,n));
        if(s1*s2==-1) res=-res;return res;
    }
    //求两多边形的交面积
    double intersectArea(Point*ps1,int n1,Point*ps2,int n2){
        if(area(ps1,n1)<0) reverse(ps1,ps1+n1);
        if(area(ps2,n2)<0) reverse(ps2,ps2+n2);
        ps1[n1]=ps1[0];
        ps2[n2]=ps2[0];
        double res=0;
        for(int i=0;i<n1;i++){
            for(int j=0;j<n2;j++){
                res+=intersectArea(ps1[i],ps1[i+1],ps2[j],ps2[j+1]);
            }
        }
        return res;//assumeresispositive!
    }
    
    
    
    
    double iou_poly(vector<double> p, vector<double> q) {
        Point ps1[maxn],ps2[maxn];
        int n1 = 4;
        int n2 = 4;
        for (int i = 0; i < 4; i++) {
            ps1[i].x = p[i * 2];
            ps1[i].y = p[i * 2 + 1];
    
            ps2[i].x = q[i * 2];
            ps2[i].y = q[i * 2 + 1];
        }
        double inter_area = intersectArea(ps1, n1, ps2, n2);
        double union_area = fabs(area(ps1, n1)) + fabs(area(ps2, n2)) - inter_area;
        double iou = inter_area / union_area;
    
    //    cout << "inter_area:" << inter_area << endl;
    //    cout << "union_area:" << union_area << endl;
    //    cout << "iou:" << iou << endl;
    
        return iou;
    }
    //
    //int main(){
    //    double p[8] = {0, 0, 1, 0, 1, 1, 0, 1};
    //    double q[8] = {0.5, 0.5, 1.5, 0.5, 1.5, 1.5, 0.5, 1.5};
    //    vector<double> P(p, p + 8);
    //    vector<double> Q(q, q + 8);
    //    iou_poly(P, Q);
    //    return 0;
    //}
    
    //int main(){
    //    double p[8] = {0, 0, 1, 0, 1, 1, 0, 1};
    //    double q[8] = {0.5, 0.5, 1.5, 0.5, 1.5, 1.5, 0.5, 1.5};
    //    iou_poly(p, q);
    //    return 0;
    //}

    其头文件:https://github.com/CAPTAIN-WHU/DOTA_devkit/blob/master/polyiou.h

    //
    // Created by dingjian on 18-2-3.
    //
    
    #ifndef POLYIOU_POLYIOU_H
    #define POLYIOU_POLYIOU_H
    
    #include <vector>
    double iou_poly(std::vector<double> p, std::vector<double> q);
    #endif //POLYIOU_POLYIOU_H

     

    展开全文
  • 还记得我们是怎么计算多边形面积的么? 让你先思考10秒钟,Any good idea? 好吧相信你心中已经有了想法。 还记得我们学过的叉乘么,两个向量同一起点的叉乘积再乘1/2就是三角形的面积(哦哦哦,我知道,把...
  • geojson-area, 计算geojson多边形或者多重多边形面积 geojson区域计算任意 GeoJSON 几何图形内的区域。用法npm install @mapbox/geojson-area示例var geojsonArea = require('@mapb
  • 计算不规则多边形面积、中心、重心 最近项目用到:在不规则多边形的中心点加一个图标。(e.g: xx地区发生暴雪,暴雪区域是多边形,给多边形中心加一个暴雪的图标) 之前的设计是,计算不规则多边形范围矩形...
  • 向量法计算多边形面积

    千次阅读 2019-10-22 09:59:53
    计算多边形面积的方法为将多边形分解... * 平面多边形面积算法3,用原点为基点(不需要从图形边线上取点)<br/> * 多计算一条线段,但减少了每一步的两次减法(起于原点的向量等于节点的坐标),使误差减小...
  • 证明过程就略过了,有好多大佬已经都写过了。我只是在这复习一下。比较粗浅。首先给公式:这里以一个题目演示是一下:链接:...指着一张图片上的多边形,问小X知道这个图形面积么,这可把小X难住了,...
  • 在MFC中实现求多边形面积的一个简单例子
  • 不规则封闭多边形面积计算

    热门讨论 2011-07-21 09:39:01
    简单的不规则封闭多边形面积计算方法。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • 参考文章中的介绍方法任意多边形面积计算公式 用代码的形式表达 /** * 根据鞋带定理计算 * @author YiDianDian */ public class Area { public static void main(String[] args) { Point point1 = new Point(3...
  • 多边形面积计算

    千次阅读 2005-10-10 16:43:00
    多边形面积计算 由于多边形可以分解为多个三角形来计算,因此首先讨论三角形面积问题。 假设三角形三个顶点坐标为 (x1, y1), (x2, y2), (x3, y3) 则三角形的面积可以由以下的行列式计算 | x1, y1, 1 | | x2, y2...
  • 多边形面积计算器

    2015-09-05 14:37:58
    多边形面积计算器,由坐标计算面积。有图形,很直观
  • 多边形面积.zip

    2019-08-11 02:56:29
    通过“微积分”思想计算不规则多边形面积,通过GDI技术可视化结果。 案例地址:https://blog.csdn.net/shijie_nihao/article/details/99067597
  • 多边形面积

    2019-09-20 10:06:41
    目录 第1章多边形面积1 1.1 三角形面积1 1.2 多边形面积2 1.3 递推公式3 1.4 精度评定4 第2章坡面面积6 2.1 坡面面积6 2.2 模型验算7 第1章多边形面积 1.1 三角形...
  • 第三章课后习题(判断是否为多边形图形,求多边形面积)——程序设计艺术与方法实验三 计算几何的发现 分析: 判断能否构成多边形,即判断是否存在两直线相交:两直线互相跨立;或一条线段的一个端点在另一条线段上 ...
  • matlab计算任意多边形面积

    万次阅读 2017-11-08 09:38:53
    首先根据计算多边形面积计算公式,用向量法计算比较方便。两向量叉乘为这俩向量组成的三角形面积的两倍,所以多边形面积公式为: S = 0.5 * (OA 叉乘 OB +OB 叉乘 OC +…O** 叉乘 OA) matlab代码实现:第一步...
  • leaflet计算多边形面积

    2018-08-22 03:51:00
    上一篇介绍了使用leaflet绘制圆形,那如何计算圆形的面积呢? 1、使用数学公式计算,绘制好圆形后,获取中心点以及半径即可 2、使用第三方工具计算,如turf.js. 这里turf的area方法入参为geojson对象 3、使用超图...
  • 这里有个前提是:你的经纬度点是依次相连接的点,不是无序的,可以是顺时针,或者逆时针都可以。 附python代码: import mathdef ConvertToRadian(input): return input * math.pi / 180; def ...
  • C++代码计算任意多边形面积

    万次阅读 多人点赞 2017-05-16 20:30:26
     今天写了一个小代码:计算任意多边形面积。临近毕业,毕设也忙得很,还好最近完成的差不多了,就差写论文了,今天突然想到写博客是个挺有趣的东西,于是就过来写我的第一篇。   好!步入正题,不过还是先介绍...
  • 主要介绍了Java计算几何图形面积的实例代码,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,821
精华内容 2,328
关键字:

多边形计算面积图形