具有boost几何的内部边界区域的几何差分

我想用Boost Geometry计算两个几何对象的几何差。第一个几何图形是：

我总是用线段组成几何体。我有坐标和线段：

{{-1., -1.}, {1., -1.}, {1., 1.}, {-1., 1.}, {0.6, -1}, {0.6,1.}};
{Line[{{1, 5}, {5, 2}, {2, 3}, {3, 6}, {6, 4}, {4, 1}}], Line[{{5, 6}}]};

如果直线中的每个索引都指向坐标。任一几何图形都可以具有内部边界（和孔）

第二个几何体：

我希望得到这个：

我从多边形开始，但我不明白如何包含第一个几何对象的内部边界。虽然可以有内部孔，但我不知道如何有一个像直线一样的“退化”多边形。我也不清楚这两个多边形中的哪一个是外多边形。然后我想到了线，但在那里我不能添加内部段。Boost Geometry是否可以用于查找具有内部边界的几何体的几何布尔运算？那么，我该如何做呢

缺少内部边界的多边形方法的代码；注释掉的是线型方法；同样，在第一个几何对象中没有内部边界

#include <iostream>                                                             
#include <fstream>                                                              
#include <list>                                                                 

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

#include <boost/foreach.hpp>                                                    

int main()                                                                      
{                                                                               
    typedef boost::geometry::model::d2::point_xy<double> point_type;            
    typedef boost::geometry::model::polygon<point_type > polygon;               
    //typedef boost::geometry::model::linestring<point_type > line;             

    polygon p1, p2;                                                             
    //line l1, l2;                                                              

    boost::geometry::read_wkt(                                                  
        "POLYGON((-1 -1, 0.6 -1, 1 -1, 1 1, 0.6 1, -1 1))", p1);                

    boost::geometry::read_wkt(                                                  
        "POLYGON((-0.5 -0.5, 2 -0.5, 2 0.5, -0.5 0.5))", p2);                   

    /*                                                                          
    boost::geometry::read_wkt(                                                  
        "LINESTRING(-1 -1, 0.6 -1, 1 -1, 1 1, 0.6 1, -1 1)", l1);               

    boost::geometry::read_wkt(                                                  
        "LINESTRING(-0.5 -0.5, 2 -0.5, 2 0.5, -0.5 0.5)", l2);                  
    */                                                                          

    std::list<polygon> output;                                                  
    boost::geometry::difference(p2, p1, output);                                

    //std::list<line> loutput;                                                  
    //boost::geometry::difference(l2, l1, loutput);                             

    std::ofstream svg("my_map.svg");                                            
    boost::geometry::svg_mapper<point_type> mapper(svg, 400, 400);              

    int i = 0;                                                                  
    BOOST_FOREACH(polygon const& p, output)                                     
    {                                                                           
        mapper.add(p);                                                          
        mapper.map(p, "fill-opacity:0.3;fill:rgb(51,151,53);stroke:rgb(51,151,53);stroke-width:2");  
    }                                                                           

    /*                                                                          
    int i = 0;                                                                  
    BOOST_FOREACH(line const& l, loutput)                                       
    {                                                                           
        mapper.add(l);                                                          
        mapper.map(l, "opacity:0.4;fill:none;stroke:rgb(212,0,0);stroke-width:5");
    }                                                                           
    */                                                                          

    return 0;                                                                   
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
int main（）
{                                                                               
typedef boost:：geometry:：model:：d2:：point\u xy point\u type；
typedef boost:：geometry:：model:：polygon；
//typedef boost:：geometry:：model:：linestring行；
多边形p1，p2；
//l1、l2线；
boost:：geometry:：read_wkt（
“多边形（-1-1,0.6-1,1-1,11,0.61-11））”，p1）；
boost:：geometry:：read_wkt（
“多边形（-0.5-0.5,2-0.5,20.5，-0.50.5））”，p2）；
/*                                                                          
boost:：geometry:：read_wkt（
“字符串（-1-1,0.6-1,1-1,11,0.61-11）”，l1）；
boost:：geometry:：read_wkt（
“线串（-0.5-0.5,2-0.5,20.5，-0.50.5）”，l2）；
*/                                                                          
std：：列表输出；
升压：：几何：：差异（p2，p1，输出）；
//标准：列出百叶窗；
//增压：：几何：：差异（l2、l1、loutput）；
std：：流svg（“my_map.svg”）；
boost:：geometry:：svg\U映射器映射器（svg，400400）；
int i=0；
BOOST_FOREACH（多边形常量和p，输出）
{                                                                           
mapper.add（p）；
贴图（p，“填充不透明度：0.3；填充：rgb（51151,53）；笔划：rgb（51151,53）；笔划宽度：2”）；
}                                                                           
/*                                                                          
int i=0；
增压器（管线常数和l、百叶窗）
{                                                                           
添加（l）；
贴图（l，“不透明度：0.4；填充：无；笔划：rgb（212,0,0）；笔划宽度：5”）；
}                                                                           
*/                                                                          
返回0；
}

内线可以建模为底部的尖峰。此近似值适用于：

boost::geometry::read_wkt(
    "POLYGON((-1 -1, 0.6 -1, 0.6 1, 0.60000000000001 -1, 1 -1, 1 1, -1 1))", p1);

创建了两个多边形：右下角的小矩形

（0.6000000000001-1，1-1，1-0.5，0.6-0.5）

未连接到其余部分

这是一份精确的要点清单

boost::geometry::read_wkt(
    "POLYGON((-1 -1, 0.6 -1, 0.6 1, 0.6 -1, 1 -1, 1 1, -1 1))", p1);

由于自相交而引发异常。当跳过自相交检查时，我们会得到一个结果，但它是不完整的（只计算上面两个多边形中较大的一个）

当然，将多边形

p1

拆分为两个矩形也是可行的：

boost::geometry::read_wkt(
    "POLYGON((-1 -1, 0.6 -1, 0.6 1, -1 1))", p11);
boost::geometry::read_wkt(
    "POLYGON((0.6 -1, 1 -1, 1 1, 0.6 1))", p12);

---

然后用p2计算每一个差异，并将结果合并得到准确的预期答案（作为三个单独的矩形）。

您可以尝试将第一个几何体拆分为两个相互接触的矩形。内线实际上是两条重合的边。或者，您可以尝试将内线建模为一个刺入矩形，例如从底部到顶部，然后立即返回（退化的向内凹痕），即

多边形（（-1-1，0.6-1，0.6-1，0.6-1，1-1，1-1，-1））

谢谢您的回答和宝贵的时间。你的第二个建议看起来更可行。然而，我必须找到一种方法来转换原始版本