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 
#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;

    //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 
#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;  // 0: 2.50205
                }


    return 0;
}

你可能感兴趣的:(boost,c++)