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
#include
#include
#include
#include
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;
Distance = bg::distance(pt0, pt1);
Distance = bg::distance(Point(200, 100), sg0);
Distance = bg::distance(Point(100, 0), sg0);
Segment sg1(Point(0, 100), Point(100, 0));
Segment sg2(Point(100, 200), Point(200, 100));
bool bIntersect = false;
bIntersect = bg::intersects(sg0, sg1);
bIntersect = bg::intersects(sg0, sg2);
std::list<Point> lstPoints;
bg::intersection(sg0, sg1, lstPoints);
lstPoints.clear();
bg::intersection(sg0, sg2, lstPoints);
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);
bIntersect = bg::intersects(rc, rc1);
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);
bIntersect = bg::intersects(rc0, line0);
std::list<LineString> lstLines;
bg::intersection(rc, line0, lstLines);
Box rc7(Point(0, 0), Point(100, 100));
bool bInside = false;
bInside = bg::within(Point(50, 50), rc7);
bInside = bg::within(Point(0, 0), rc7);
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);
bIntersect = bg::intersects(line1, line3);
lstPoints.clear();
bg::intersection(line1, line2, lstPoints);
lstPoints.clear();
bg::intersection(line1, line3, lstPoints);
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);
lstPoints.clear();
bg::intersection(r0, r1, lstPoints);
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());
bIntersect = bg::intersects(poly1, poly2);
bIntersect = bg::intersects(poly1, poly3);
std::list<Polygon> lstPolygon;
bg::intersection(poly1, poly2, lstPolygon);
lstPolygon.clear();
bg::intersection(poly1, poly3, lstPolygon);
bInside = bg::within(Point(100, 100), poly1);
bInside = bg::within(Point(25, 25), poly1);
return 0;
}
#include
#include
#include
#include
#include
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;
}
return 0;
}
