多边形求并的简单算法

#include <boost/geometry.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <vector>

typedef boost::geometry::model::d2::point_xy<double> boost_point;
typedef boost::geometry::model::polygon<boost_point> boost_Polygon;

struct Point
{
    float x;
    float y;
    Point(float _x,float _y)
    {
        x = _x;
        y = _y;
    }
    Point(const boost_point & pt)
    {
        x = pt.x();
        y = pt.y();
    }
    operator boost_point()
    {
        return boost_point(x, y);
    }
};

bool PointInPolygon(std::vector<Point> vPoints,Point point)
{
    float testx = point.x;
    float testy = point.y;
    size_t nvert = vPoints.size();
    int c = 0;
    for (size_t i = 0, j = nvert - 1; i < nvert; j =i, ++i)
    {
        if (((vPoints[i].y > testy) != (vPoints[j].y > testy)) &&\
            (testx < (vPoints[j].x - vPoints[i].x) * (testy - vPoints[i].y)\
            / (vPoints[j].y - vPoints[i].y) + vPoints[i].x))
            c = !c;
    }
    return c;
}
double PolyRegionArea(const std::vector<Point> vecPt)
{
    int N = vecPt.size();
    int i, j;
    double area = 0;
    for (i = 0; i<N; i++) {
        j = (i + 1) % N;
        area += vecPt[i].x * vecPt[j].y;
        area -= vecPt[i].y * vecPt[j].x;
    }
    area /= 2;
    return(area < 0 ? -area : area);
}

double GetArea(std::vector<Point> &vPoints)
{
    double dArea;
    if (vPoints.size() < 3) return 0;
    dArea = vPoints[0].y*(vPoints[vPoints.size() - 1].x - vPoints[1].x);
    for (int i = 1; i < vPoints.size(); i++)
    {
        dArea += vPoints[i].y*(vPoints[(i - 1)].x - vPoints[(i + 1) % vPoints.size()].x);
    }
    return dArea / 2;
}

boost_Polygon vec2BoostPolygon(std::vector<Point> &vPoints)
{
        boost_Polygon rlt;
        if (vPoints.size() > 0)
        {
            if (GetArea(vPoints) > 0)//这里很重要，boost的多边形只有逆时针点序才能合并
            {
                for (std::vector<Point>::reverse_iterator iter = vPoints.rbegin(); iter != vPoints.rend(); iter++)
                {
                    boost::geometry::append(rlt, (boost_point)*iter);
                }
            }
            else
            {
                for (auto & pt : vPoints)
                {
                    boost::geometry::append(rlt, (boost_point)pt);
                }
            }
        }
        return rlt;
}

std::vector<Point> Merge(std::vector<Point> & lhs,std::vector<Point>& rhs)
{
    //判断两个多边形是否相交
    bool bCross = false;
    for (auto & pt : rhs)
    {
        if (PointInPolygon(lhs,pt))
        {
            bCross = true;
            break;
        }
    }
    if (!bCross)//不相交直接返回空向量
    {
//        return std::vector<Point>();
    }
    //进行并集计算
    std::vector<boost_Polygon> r;
    boost::geometry::union_(vec2BoostPolygon(lhs), vec2BoostPolygon(rhs), r);
    if (!r.empty())//有结果返回
    {
        std::vector<Point> vPoints;
        for (auto & pt : r[0].outer())
        {
            vPoints.push_back(pt);
            //std::cout<<"area:"<<boost::geometry::area(r)<<std::endl;
        }
        return vPoints;
    }
    //无结果直接返回空向量
    return std::vector<Point>();
}
int main()
{
    std::vector<Point> lhs;
    lhs.push_back(Point(0,0));
    lhs.push_back(Point(0,1));
    lhs.push_back(Point(1,1));
    lhs.push_back(Point(1,0));
    lhs.push_back(Point(0,0));


    std::vector<Point> rhs;
    rhs.push_back(Point(1,0));
    rhs.push_back(Point(1,1));
    rhs.push_back(Point(2,1));
    rhs.push_back(Point(2,0));
    rhs.push_back(Point(1,0));

    std::vector<Point> vecRet = Merge(lhs,rhs);

    std::cout<<"area:"<<PolyRegionArea(vecRet)<<std::endl;

    return 0;
}

【boost使用之多边形合并】_Yluo_D的博客-CSDN博客

union_ - 1.56.0

c++多边形求交集算法_c++ 多边形取交集_飞鸟真人的博客-CSDN博