boost Geometry

boost::Geometry

boost作为C++中最常用的第三方库，Geometry库里面拥有大量的开源算法。

函数	作用
get	获取几何图形（通常为点）的坐标值
get (with index)	获取框或段的坐标值
set	设置几何图形（通常为点）的坐标值
set (with index)	设置Box / Segment的坐标值
exterior_ring	获取多边形的外接多边形
interior_rings	获取多边形的内接多边形

bg::model::polygon<point> poly;
bg::exterior_ring(poly) = boost::assign::tuple_list_of(0, 0)(0, 3)(3, 3)(3, 0)(0, 0);

bg::model::polygon<point> poly;
bg::interior_rings(poly) = boost::assign::tuple_list_of(0, 0)(0, 3)(3, 3)(3, 0)(0, 0);

Boost.Array：适用于 Boost.Geometry中不同的点类型
Boost.Fusion：自定义不同的点的结构并适配 Boost.Geometry点的处理方法，因此，可以调用许多Boost.Geometry算法
Boost.Tuple：组成的点集也可以使用算术运算，元素可以用作 Boost.Geometry 内部的点

Boost.Polygon

函数	作用
point_data	Boost.Polygon点类型（boost::polygon::point_data）
rectangle_data	Boost.Polygon矩形类型
polygon_data	Boost.Polygon多边形类型
polygon_with_holes_data	Boost.Polygon多边形类型

Boost.Range

函数	作用
filtered	过滤不符合条件的数据
reversed	反转数据
sliced	指定在数据中切出一定部分的数据
strided	指定在数据以n为步长间接取值

area

函数	作用
area	计算几何图形的面积
area (with strategy)	使用指定的策略计算几何图形的面积

assign

函数	作用
assign	将一个几何图形指定给另一个几何图元
assign_inverse	利用assign_ inverse和expand方便地确定两点的边界三维框
assign_points	为 linestring, ring 或 polygon指定一系列点
assign_values	为几何图形指定两个坐标（通常为二维点，三维点和四维点这三种情况）
assign_zero	assign_zero函数初始化坐标为零的二维或三维点或框
append	将一个或多个点附加到linestring, ring, polygon, multi-geometry中

buffer

自由函数缓冲区计算几何体的缓冲区（多边形是距离几何体指定最大距离内的空间点集集合）。下图显示了策略在生成的缓冲区中的作用

return_buffer
return_ buffer函数计算几何体的缓冲区（多边形是距离几何体指定最大距离内的空间点集集合）。这个带有return_前缀的版本返回缓冲区，因此必须在调用中指定模板参数。这个个人感觉功能性没有buffer好

centroid

centroid
使用指定的策略计算几何图形的质心

return_centroid
使用指定的策略计算几何图形的质心。这两个求质心的方式类似。

Densify

线段插值

vector<Point2f> Densify(const Segment2f& seg, int num) {
  CHECK_GT(num, 0);
  CHECK(!bg::intersects(seg.s, seg.e));

  vector<Point2f> pts{seg.s};
  pts.reserve(num);
  boost::geometry::line_interpolate(seg, bg::length(seg) / num, pts);
  pts.emplace_back(seg.e);
  return pts;
}

部分函数

函数	作用
clear	清除 linestring, ring 或者 polygon (exterior+interiors) 和 multi*
convert	将一个几何图形转换为另一个几何图元
convex_hull	计算几何体的凸包
correct	纠正几何图形：所有相对于其预期方向错误定向的环都将反转。对于所有没有闭点且按其应有类型键入的环，将附加第一个点。也可以校正框。
covered_by	使用指定的策略检查第一个几何图形是否位于第二个几何图形的内部或边界上
crosses	检查两个几何图形是否相交
densify	使用指定的策略加密几何体
difference	计算两种几何图形的差异.通过差分计算两种几何的空间集合论差分
discrete_frechet_distance	使用指定的策略计算两个几何图形之间的离散Frechet距离（目前适用于LineString)
discrete_hausdorff_distance	使用指定的策略计算两个几何图形之间的离散Hausdorff距离（目前适用于 LineString-LineString, MultiPoint-MultiPoint, Point-MultiPoint, MultiLineString-MultiLineString)
disjoint	检查两个几何图形是否不相交
equals	检查几何体在空间上是否相等
expand	使用长方体来框选多个几何图形（长方体、点）的边界框
intersection	计算两个几何图形的交点
intersects	检查几何图形是否至少有一个交点（相交或自相切）
is_empty	检查几何图形是否为空集
is_simple	检查几何图形是否简单
is_valid	检查几何图形是否有效（在OGC意义上）
length	函数长度计算几何体的长度（连续点之间的距离之和）。它使用基于几何体坐标系的默认策略。
line_interpolate	返回沿LineString方向插值的一个或多个点
make	构造几何图形
make_inverse	用逆无穷坐标构造一个长方体
make_zero	构造一个坐标初始化为零的几何体
num_geometries	计算几何图形的几何图形数
num_interior_rings	计算几何图形的内解多边形数
num_points	计算几何图形的点数
num_segments	计算几何图形的线段数(segments)
overlaps	检查两个几何图形是否重叠
perimeter	计算几何图形的周长
relate	检查由遮罩定义的一对几何图形之间的关系
relation	计算DE-9IM中定义的一对几何图形之间的关系
reverse	反转几何图形中的点
simplify	简化几何图形
sym_difference	计算两种几何体的对称差
touches	检查几何图形是否至少有一个接触点（自相切）
transform	使用策略从一个几何图形转换到另一个几何图元
union_	组合两个相互关联的几何图形
unique	计算几何图形的最小集
within	检查第一个几何体是否完全位于第二个几何体内部

distance

comparable_distance
使用指定的策略计算两个几何图形的可比距离测量值，点在多边形内部，可以使用comparable_distance

double cmpDst = boost::geometry::comparable_distance(segment,pt);

distance
使用指定的策略计算两个几何图形之间的距离。distance可以正确处理多边形外部的点，但是似乎将多边形视为实体。因此，多边形内的每个点到多边形的距离显然为0。

double cmpDst = boost::geometry::distance(segment,pt);

envelope

envelope
自由函数包络计算几何体的包络（也称为轴对齐边界框、aabb或最小边界矩形、mbr）

return_envelope
自由函数return_envelope计算几何体的包络（也称为轴对齐边界框、aabb或最小边界矩形、mbr）。这个带有return_前缀的版本返回信封，因此必须在调用中指定模板参数

点云处理

函数	作用
add_point	将一个点添加到另一个点
add_value	将相同的值添加到点的每个坐标
assign_point	用另一个点指定一个点
assign_value	为点的每个坐标指定相同的值
cross_product	计算两个向量的叉积
divide_point	将一点除以另一点
divide_value	将同一点的每个坐标除以一个值
dot_product	计算2个矢量（点）的点积（或标量积）
multiply_point	将一个点乘以另一个点
multiply_value	将点的每个坐标乘以相同的值
subtract_point	将一点减去另一点
subtract_value	将相同的值减去点的每个坐标

常数控制

函数	作用
min_corner	指示要获取、设置或处理的框的最小角
max_corner	指示要获取、设置或处理的框的最大角

坐标系转换

函数	作用
cs::cartesian	笛卡尔坐标系
cs::spherical	球面（极坐标）坐标系，以度或弧度表示
cs::spherical_equatorial	球面赤道坐标系，以度或弧度表示
cs::geographic	地理坐标系，以度或弧度表示

核心元函数

函数	作用
closure	将值定义为指定几何图形类型的闭包（顺时针、逆时针）的函数
coordinate_system	函数将类型定义为构成指定几何类型的点类型的坐标系（笛卡尔坐标系、球面坐标系等）
coordinate_type	函数将类型定义为构成指定几何类型的点类型的坐标类型（int、float、double等）
cs_tag	函数返回任意几何体的坐标系标记（cs族）
degree	定义球面坐标系的平面角单位的标记。此标记指定坐标的定义单位为度（-180…180）。必须为某些坐标系指定它
dimension	将值定义为构成指定几何图形类型的点类型的函数
interior_type	将类型定义为指定几何类型的interior_ type（内环的容器类型）的函数
point_order	将值定义为指定几何图形类型的点顺序（顺时针、逆时针）的函数
point_type	将类型定义为指定几何体类型的point_ type的元函数
radian	平面角单位：弧度
ring_type	将类型定义为指定几何体类型的环_类型的函数
tag	将类型定义为指定几何体类型的标记的函数
tag_cast	标记转换，标记可以相互继承。例如，multi_ point继承multi_。通常，行为可以在不同的几何图形类型之间共享。由metafunction标记找到的标记可以转换为更基本的标记，然后由该标记分派

模型

函数	作用
model::point	基点类，具有以中性方式定义的坐标
model::d2::point_xy	笛卡尔坐标系中的二维点
model::d3::point_xyz	笛卡尔坐标系中的三维点
model::linestring	linestring（由OGC命名）是点的集合（默认为向量）
model::polygon	多边形包含一个外圈和零个或多个内圈
model::multi_point	multi_point，点的集合
model::multi_linestring	multi_line，linestring的集合
model::multi_polygon	multi_ polygon，多边形的集合
model::box	类框：定义由两个描述点组成的框
model::ring	环（也称为线性环）是一条不应自相交的闭合线
model::segment	在几何学中，线段是由两个不同端点限定的直线的一部分，包含其端点之间直线上的每个点
model::referring_segment	类段：包含两个（模板化）点引用的小类

空间索引

boost::geometry::index::rtree

函数	作用
rtree()	rtree的构造函数
~rtree()	rtree的析构函数
operator=(rtree const &)	赋值运算符
swap(rtree &)	交换两个RTree的内容
insert(value_type const &)	在索引中插入一个值
remove(value_type const &)	从容器中删除值
query(Predicates const &, OutIter)	此查询函数执行空间和k近邻搜索。它允许传递一组数据。仅当满足所有数据时才会返回值
qbegin(Predicates const &)	返回指向查询范围开头的查询迭代器
qend()	返回一个指向查询范围末尾的查询迭代器
begin()	返回指向rtree值范围开头的迭代器
end()	返回指向rtree值范围末尾的迭代器
size()	返回存储值的数目
empty()	查询容器是否为空
clear()	删除存储在容器中的所有值
bounds()	返回能够包含容器中存储的所有值的框
count(ValueOrIndexable const &)	对于indexable_type，它返回可索引的值的数目等于参数。对于value_type，它返回等于参数的值的数量
parameters()	返回参数
indexable_get()	返回从值检索可索引的函数
value_eq()	返回比较值的函数
get_allocator()	返回rtree使用的分配器

R-tree parameters (boost::geometry::index)

函数	作用
boost::geometry::index::linear	线性r树创建算法参数
boost::geometry::index::quadratic	二次r树生成算法参数
boost::geometry::index::rstar	R*-树创建算法参数
boost::geometry::index::dynamic_linear	线性r树创建算法参数-运行时版本
boost::geometry::index::dynamic_quadratic	二次r树创建算法参数-运行时版本
boost::geometry::index::dynamic_rstar	R*-树创建算法参数-运行时版本

其他函数

函数	作用
boost::geometry::index::indexable	从值中提取可索引的函数对象，这个是override转换
boost::geometry::index::equal_to	函数对象比较值，这个是override转换
inserter(Container &)	插入迭代器生成器，这个是override转换
queried(Predicates const &)	查询索引适配器生成器

Predicates (boost::geometry::index)

Predicates (boost::geometry::index) 下面的这些都是与前文同名函数相同的意思，只是是适用于RTree的函数

函数
contains(Geometry const &)
covered_by(Geometry const &)
covers(Geometry const &)
disjoint(Geometry const &)
intersects(Geometry const &)
overlaps(Geometry const &)
within(Geometry const &)
satisfies(UnaryPredicate const &)
nearest(Geometry const &, unsigned)

Geometry策略方式

函数	作用
strategy::area::cartesian	笛卡尔面积计算
strategy::area::spherical	球面面积计算
strategy::area::geographic	地理区域计算
strategy::buffer::join_round	让缓冲区创建圆角
strategy::buffer::join_miter	让缓冲区创建锐角
strategy::buffer::end_round	让缓冲区创建圆角端点
strategy::buffer::end_flat	让缓冲区创建平端
strategy::buffer::distance_symmetric	让缓冲区算法创建具有相同距离的缓冲区
strategy::buffer::distance_asymmetric	让缓冲区是不对称
strategy::buffer::point_circle	围绕点创建圆形缓冲区
strategy::buffer::point_square	围绕点创建方形缓冲区
strategy::buffer::geographic_point_circle	在地球上的一个点周围创建一个圆形缓冲区
strategy::buffer::side_straight	让缓冲区沿线段使用直边（默认）
strategy::centroid::average	质心计算取点的平均值
strategy::centroid::bashein_detmer	使用Bashein/Detmer算法计算质心
strategy::convex_hull::graham_andrew	Graham扫描策略计算凸包
strategy::densify::cartesian	笛卡尔线段的致密化
strategy::densify::geographic	地理段的致密化，对应了上文的densify方法
strategy::densify::spherical	球形段的致密化，对应了上文的densify方法
strategy::distance::pythagoras	计算两点之间距离的策略，对应了上文的distance方法
strategy::distance::pythagoras_box_box	计算两个盒子之间距离的策略，对应了上文的distance方法
strategy::distance::pythagoras_point_box	计算点与长方体之间距离的策略，对应了上文的distance方法
strategy::distance::haversine	使用哈弗斯线计算完美球体上球坐标的距离
strategy::distance::projected_point	点到线段的距离策略
strategy::distance::cross_track	用于点到线段距离计算的策略函数
strategy::distance::cross_track_point_box	用于计算点到框的距离的策略函数
strategy::line_interpolate::cartesian	在笛卡尔线段上插值点，对应了上文的line_interpolate方法
strategy::line_interpolate::geographic	插值地理线段上的点，对应了上文的line_interpolate方法
strategy::line_interpolate::spherical	在球面段上插值点，对应了上文的line_interpolate方法
strategy::side::side_by_triangle	检查点位于线段的哪一侧：线段左侧（>0），线段右侧（<0），线段上（0）
strategy::side::side_by_cross_track	检查大圆线段的哪一侧有一个点位于线段左侧（>0），线段右侧（<0），线段（0）
strategy::side::spherical_side_formula	检查大圆线段的哪一侧有一个点位于线段左侧（>0），线段右侧（<0），线段（0）上
strategy::side::geographic	检查线段的哪一侧有一个点位于线段左侧（>0）、右侧（<0）和线段（0）上
strategy::simplify::douglas_peucker	实现简化算法
strategy::transform::inverse_transformer	在笛卡尔坐标系中进行逆变换的变换策略
strategy::transform::map_transformer	从一个笛卡尔坐标系映射到另一个笛卡儿坐标系的转换策略
strategy::transform::rotate_transformer	笛卡尔坐标系中的旋转变换策略
strategy::transform::scale_transformer	笛卡尔系统中的尺度变换策略
strategy::transform::translate_transformer	笛卡尔系统中的平移变换策略
strategy::transform::matrix_transformer	笛卡尔系统中的仿射变换策略
strategy::within::winding	在使用缠绕规则的检测范围内。根据点的坐标系选择内部使用的边策略。
strategy::within::franklin	在使用交叉计数的检测范围内
strategy::within::crossings_multiply	在使用交叉计数的检测范围内

示例

#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <boost/foreach.hpp>
#include <boost/assign/list_of.hpp>
namespace bg = boost::geometry;
typedef bg::model::d2::point_xy<double> Point;
typedef bg::model::segment<Point> Segment;
typedef bg::model::linestring<Point> LineString;
typedef bg::model::box<Point> Box;
typedef bg::model::ring<Point, false> Ring;
typedef bg::model::polygon<Point, false> Polygon;

int main()
{
    Point pt0(100, 100);
    Point pt1(200, 200);
    Segment sg0(pt0, pt1);

    double Distance = 0;

    //1、点到点的距离
    Distance = bg::distance(pt0, pt1);  // 141.421

    //2、点到线段的距离，如果点到直线的垂足不在线段上，所计算的距离为(点到直线的距离、线段到垂足延长的距离之和）
    Distance = bg::distance(Point(200, 100), sg0);  // 70.7107
    Distance = bg::distance(Point(100, 0), sg0);    // 100

    //3、判断线段是否相交
    Segment sg1(Point(0, 100), Point(100, 0));
    Segment sg2(Point(100, 200), Point(200, 100));
    bool bIntersect = false;
    bIntersect = bg::intersects(sg0, sg1);  // 0
    bIntersect = bg::intersects(sg0, sg2);  // 1

    //4、求线段与线段的交点
    std::list<Point> lstPoints;
    bg::intersection(sg0, sg1, lstPoints);
    lstPoints.clear();
    bg::intersection(sg0, sg2, lstPoints);  // (150, 150)


    //5、判断box是否相交
    Box rc(Point(0, 0), Point(200, 200));
    Box rc0(Point(250, 250), Point(450, 450));
    Box rc1(Point(100, 100), Point(300, 300));

    bIntersect = bg::intersects(rc, rc0);   // 0
    bIntersect = bg::intersects(rc, rc1);   // 1

    //6、判断box是否与LineString相交
    LineString line0;

    line0.push_back(Point(10, 250));
    line0.push_back(Point(100, 100));
    line0.push_back(Point(120, -10));
    line0.push_back(Point(210, 200));
    bIntersect = bg::intersects(rc, line0);     // 1
    bIntersect = bg::intersects(rc0, line0);    // 0

    //7、求box与linestring的交点
    std::list<LineString> lstLines;
    bg::intersection(rc, line0, lstLines);  // (40, 200),(100, 100),(118.18, 0), (124, 0),(200, 176.67)

    //8、点是否在box内
    Box rc7(Point(0, 0), Point(100, 100));
    bool bInside = false;
    bInside = bg::within(Point(50, 50), rc7);   // 1
    bInside = bg::within(Point(0, 0), rc7);     // 0

    //9、判断LineString与LineString是否相交
    LineString line1, line2, line3;

    line1.push_back(Point(50, 50));
    line1.push_back(Point(150, 50));
    line1.push_back(Point(50, 200));
    line1.push_back(Point(150, 200));
    line2.push_back(Point(100, 0));
    line2.push_back(Point(70, 100));
    line2.push_back(Point(150, 210));
    line3.push_back(Point(200, 0));
    line3.push_back(Point(200, 200));

    bIntersect = bg::intersects(line1, line2);  // 1
    bIntersect = bg::intersects(line1, line3);  // 0

    //10、求LineString与LineString的交点
    lstPoints.clear();
    bg::intersection(line1, line2, lstPoints);  // (85, 50), (94.35, 133.48), (142.72, 200)
    lstPoints.clear();
    bg::intersection(line1, line3, lstPoints);


    //11、判断ring与ring是否相交
    Point arDPoint0[6] = {Point(0, 0), Point(100, 0), Point(200, 100), Point(100, 200), Point(0, 200), Point(0, 0)};
    Point arDPoint1[6] = {Point(100, 100), Point(200, 0), Point(300, 0), Point(300, 200), Point(200, 200), Point(100, 100)};
    Ring r0(arDPoint0, arDPoint0 + 6);
    Ring r1(arDPoint1, arDPoint1 + 6);
    bIntersect = bg::intersects(r0, r1);    // 1

    //12、求ring与ring的交点
    lstPoints.clear();
    bg::intersection(r0, r1, lstPoints);    // (150, 30), (150, 150)

    Polygon poly1;
    Polygon poly2;
    Polygon poly3;

    auto lstOf = boost::assign::list_of(Point(0, 0))(Point(200, 0))(Point(200, 200))(Point(0, 200))(Point(0, 0));
    poly1.outer().assign(lstOf.begin(), lstOf.end());
    lstOf = boost::assign::list_of(Point(50, 50))(Point(150, 50))(Point(150, 150))(Point(50, 150))(Point(50, 50));
    poly1.inners().push_back(lstOf);
    lstOf = boost::assign::list_of(Point(100, 0))(Point(120, 0))(Point(120, 200))(Point(100, 200))(Point(100, 0));
    poly2.outer().assign(lstOf.begin(), lstOf.end());
    lstOf = boost::assign::list_of(Point(100, 60))(Point(120, 60))(Point(120, 140))(Point(100, 140))(Point(100, 60));
    poly3.outer().assign(lstOf.begin(), lstOf.end());

    //13、判断polygon与polygon是否相交
    bIntersect = bg::intersects(poly1, poly2);  // 1
    bIntersect = bg::intersects(poly1, poly3);  // 0

    //14、求polygon与polygon相交的区域
    std::list<Polygon> lstPolygon;

    bg::intersection(poly1, poly2, lstPolygon);
    lstPolygon.clear();
    bg::intersection(poly1, poly3, lstPolygon);

    //15、判断点是否在polygon内
    bInside = bg::within(Point(100, 100), poly1);   // 0
    bInside = bg::within(Point(25, 25), poly1);     // 1

    return 0;
}

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

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

    polygon green, blue;

    boost::geometry::read_wkt(
            "POLYGON((2 1.3,2.4 1.7,2.8 1.8,3.4 1.2,3.7 1.6,3.4 2,4.1 3,5.3 2.6,5.4 1.2,4.9 0.8,2.9 0.7,2 1.3)"
            "(4.0 2.0, 4.2 1.4, 4.8 1.9, 4.4 2.2, 4.0 2.0))", green);

    boost::geometry::read_wkt(
            "POLYGON((4.0 -0.5 , 3.5 1.0 , 2.0 1.5 , 3.5 2.0 , 4.0 3.5 , 4.5 2.0 , 6.0 1.5 , 4.5 1.0 , 4.0 -0.5))", blue);

    std::deque<polygon> output;
    boost::geometry::intersection(green, blue, output);

    int i = 0;
    std::cout << "green && blue:" << std::endl;
    BOOST_FOREACH(polygon const& p, output)
                {
                    std::cout << i++ << ": " << boost::geometry::area(p) << std::endl;  // 0： 2.50205
                }


    return 0;
}