boost::geometry
boost::geometry::add_const_if_c
boost::geometry::areal_tag
boost::geometry::box_tag
boost::geometry::box_view
boost::geometry::cartesian_tag
boost::geometry::centroid_exception
boost::geometry::closeable_view
boost::geometry::closing_iterator
boost::geometry::closure
boost::geometry::closure_as_bool
boost::geometry::closure_as_bool< closed >
boost::geometry::closure_as_bool< open >
boost::geometry::collected_vector
boost::geometry::comparable_distance_result
boost::geometry::comparable_distance_result< Geometry1, Geometry2, void >
boost::geometry::compress_variant
boost::geometry::concatenate_iterator
boost::geometry::coordinate_system
boost::geometry::coordinate_type
boost::geometry::cs_tag
boost::geometry::default_area_result
boost::geometry::default_comparable_distance_result
boost::geometry::default_distance_result
boost::geometry::default_length_result
boost::geometry::default_strategy
boost::geometry::degree
boost::geometry::dimension
boost::geometry::distance_result
boost::geometry::distance_result< Geometry1, Geometry2, void >
boost::geometry::empty_input_exception
boost::geometry::equal_to
boost::geometry::ever_circling_iterator
boost::geometry::ever_circling_range_iterator
boost::geometry::exception
boost::geometry::flatten_iterator
boost::geometry::fp_coordinate_type
boost::geometry::fraction_type
boost::geometry::geographic_tag
boost::geometry::geometry_collection_tag
boost::geometry::geometry_id
boost::geometry::geometry_not_recognized_tag
boost::geometry::greater
boost::geometry::helper_geometry
boost::geometry::identity_view
boost::geometry::inconsistent_turns_exception
boost::geometry::interior_return_type
boost::geometry::interior_type
boost::geometry::invalid_input_exception
boost::geometry::is_areal
boost::geometry::is_radian
boost::geometry::less
boost::geometry::linear_tag
boost::geometry::linestring_tag
boost::geometry::multi_linestring_tag
boost::geometry::multi_point_tag
boost::geometry::multi_polygon_tag
boost::geometry::multi_tag
boost::geometry::not_implemented
boost::geometry::order_as_direction
boost::geometry::order_as_direction< clockwise >
boost::geometry::order_as_direction< counterclockwise >
boost::geometry::overlay_invalid_input_exception
boost::geometry::parameter_type_of
boost::geometry::partition
boost::geometry::point_iterator
boost::geometry::point_order
boost::geometry::point_reverse_iterator
boost::geometry::point_tag
boost::geometry::point_type
boost::geometry::point_type< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >
boost::geometry::pointlike_tag
boost::geometry::polygon_tag
boost::geometry::polygonal_tag
boost::geometry::promote_floating_point
boost::geometry::promote_integral
boost::geometry::promote_integral< T, PromoteUnsignedToUnsigned, UseCheckedInteger, false >
boost::geometry::radian
boost::geometry::radius_type
boost::geometry::read_wkt_exception
boost::geometry::reverse_dispatch
boost::geometry::reversible_view
boost::geometry::ring_identifier
boost::geometry::ring_return_type
boost::geometry::ring_tag
boost::geometry::ring_type
boost::geometry::section
boost::geometry::sections
boost::geometry::segment_identifier
boost::geometry::segment_intersection_info
boost::geometry::segment_intersection_points
boost::geometry::segment_iterator
boost::geometry::segment_tag
boost::geometry::segment_view
boost::geometry::select_calculation_type
boost::geometry::select_calculation_type_alt
boost::geometry::select_coordinate_type
boost::geometry::select_coordinate_type< T1, T2, void >
boost::geometry::select_coordinate_type< T1, void, void >
boost::geometry::select_most_precise
boost::geometry::select_most_precise< boost::rational< T >, double >
boost::geometry::select_most_precise< boost::rational< T1 >, boost::rational< T2 > >
boost::geometry::select_most_precise< T1, T2, void >
boost::geometry::select_most_precise< T1, void, void >
boost::geometry::side_info
boost::geometry::single_tag
boost::geometry::single_tag_of
boost::geometry::single_tag_of< detail::buffer::buffered_ring_collection_tag >
boost::geometry::spherical_equatorial_tag
boost::geometry::spherical_polar_tag
boost::geometry::spherical_tag
boost::geometry::srs_sphere_tag
boost::geometry::srs_spheroid_tag
boost::geometry::strategy_compare
boost::geometry::strategy_convex_hull
boost::geometry::strategy_intersection
boost::geometry::strategy_intersection_empty
boost::geometry::strategy_tag_distance_box_box
boost::geometry::strategy_tag_distance_point_box
boost::geometry::strategy_tag_distance_point_point
boost::geometry::strategy_tag_distance_point_segment
boost::geometry::svg_manipulator
boost::geometry::svg_mapper
boost::geometry::tag
boost::geometry::tag_cast
boost::geometry::topological_dimension
boost::geometry::transform_variant
boost::geometry::transform_variant< variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Op, boost::mpl::na >
boost::geometry::turn_info_exception
boost::geometry::volumetric_tag
boost::geometry::wkt_manipulator
boost::geometry::traits
boost::geometry::cs
boost::geometry::srs
boost::geometry::resolve_variant
boost::geometry::resolve_strategy
boost::geometry::info
boost::geometry::nyi
boost::geometry::detail
boost::geometry::core_dispatch
boost::geometry::dispatch
boost::geometry::strategy
boost::geometry::de9im
boost::geometry::concept
boost::geometry::model
boost::geometry::detail_dispatch
boost::geometry::fusion_adapt_detail
boost::geometry::policies
boost::geometry::util
boost::geometry::math
boost::geometry::range
closure_selector
open
0

Rings are open: first point and last point are different, algorithms close them explicitly on the fly

closed
1

Rings are closed: first point and last point must be the same.

closure_undertermined
-1

(Not yet implemented): algorithms first figure out if ring must be closed on the fly

Enumerates options for defining if polygons are open or closed.

The enumeration closure_selector describes options for if a polygon is open or closed. In a closed polygon the very first point (per ring) should be equal to the very last point. The specific closing property of a polygon type is defined by the closure metafunction. The closure metafunction defines a value, which is one of the values enumerated in the closure_selector

[heading See also] [link geometry.reference.core.closure The closure metafunction]

iterate_direction
iterate_forward
iterate_reverse

Flag for iterating a reversible_view in forward or reverse direction.

order_selector
clockwise
1

Points are ordered clockwise.

counterclockwise
2

Points are ordered counter clockwise.

order_undetermined
0

Points might be stored in any order, algorithms will determine it on the fly (not yet supported)

Enumerates options for the order of points within polygons.

The enumeration order_selector describes options for the order of points within a polygon. Polygons can be ordered either clockwise or counterclockwise. The specific order of a polygon type is defined by the point_order metafunction. The point_order metafunction defines a value, which is one of the values enumerated in the order_selector

[heading See also] [link geometry.reference.core.point_order The point_order metafunction]

overlay_type
overlay_union
overlay_intersection
overlay_difference
overlay_dissolve
validity_failure_type
no_failure
0

The geometry is valid

failure_few_points
10

The geometry has a very small number of points, e.g., less than 2 for linestrings, less than 3 for open rings, a closed multi-polygon that contains a polygon with less than 4 points, etc. (applies to linestrings, rings, polygons, multi-linestrings and multi-polygons)

failure_wrong_topological_dimension
11

The topological dimension of the geometry is smaller than its dimension, e.g., a linestring with 3 identical points, an open polygon with an interior ring consisting of 3 collinear points, etc. (applies to linear and areal geometries, including segments and boxes)

failure_spikes
12

The geometry contains spikes (applies to linear and areal geometries)

failure_duplicate_points
13

The geometry has (consecutive) duplicate points (applies to areal geometries only)

failure_not_closed
20

The geometry is defined as closed, the starting/ending points are not equal (applies to areal geometries only)

failure_self_intersections
21

The geometry has invalid self-intersections. (applies to areal geometries only)

failure_wrong_orientation
22

The actual orientation of the geometry is different from the one defined (applies to areal geometries only)

failure_interior_rings_outside
30

The geometry contains interior rings that lie outside the exterior ring (applies to polygons and multi-polygons only)

failure_nested_interior_rings
31

The geometry has nested interior rings (applies to polygons and multi-polygons only)

failure_disconnected_interior
32

The interior of the geometry is disconnected (applies to polygons and multi-polygons only)

failure_intersecting_interiors
40

The multi-polygon contains polygons whose interiors are not disjoint (applies to multi-polygons only)

failure_wrong_corner_order
50

The top-right corner of the box is lexicographically smaller than its bottom-left corner (applies to boxes only)

failure_invalid_coordinate
60

The geometry has at least one point with an invalid coordinate (for example, the coordinate is a NaN)

Enumerates the possible validity failure types for a geometry.

The enumeration validity_failure_type enumerates the possible reasons for which a geometry may be found as invalid by the is_valid algorithm. Besides the values that indicate invalidity, there is an additional value (no_failure) that indicates validity.

[heading See also] [link geometry.reference.algorithms.is_valid The is_valid algorithm taking a reference to validity_failure_type as second argument]

boost::make_signed< std::size_t >::type typedef boost::make_signed<std::size_t>::type boost::geometry::signed_size_type signed_size_type
int const int const boost::geometry::max_corner max_corner 1

Index of maximum corner of the box.

int const int const boost::geometry::min_corner min_corner 0

Index of minimum corner of the box.

typename Point1
typename Point2
void void boost::geometry::add_point (Point1 &p1, Point2 const &p2) add_point Point1 & p1 Point2 const & p2

Adds a point to another.

The coordinates of the second point will be added to those of the first point. The second point is not modified. Point1

Any type fulfilling a Point Concept

Point2

Any type fulfilling a Point Concept

p1

first point

p2

second point

typename Point
void void boost::geometry::add_value (Point &p, typename detail::param< Point >::type value) add_value Point & p typename detail::param< Point >::type value

Adds the same value to each coordinate of a point.

Point

Any type fulfilling a Point Concept

p

point

value

value to add

typename Geometry
typename RangeOrPoint
void void boost::geometry::append (Geometry &geometry, RangeOrPoint const &range_or_point, int ring_index=-1, int multi_index=0) append Geometry & geometry RangeOrPoint const & range_or_point int ring_index -1 int multi_index 0

Appends one or more points to a linestring, ring, polygon, multi-geometry.

Geometry

Any type fulfilling a Geometry Concept

RangeOrPoint

Either a range or a point, fullfilling Boost.Range concept or Boost.Geometry Point Concept

geometry

A model of the specified concept

range_or_point

The point or range to add

ring_index

The index of the ring in case of a polygon: exterior ring (-1, the default) or interior ring index

multi_index

The index of the geometry to which the points are appended

[include reference/algorithms/append.qbk] }
typename Geometry
default_area_result< Geometry >::type default_area_result<Geometry>::type boost::geometry::area (Geometry const &geometry) area Geometry const & geometry

Calculates the area of a geometry.

The free function area calculates the area of a geometry. It uses the default strategy, based on the coordinate system of the geometry.

The area algorithm calculates the surface area of all geometries having a surface, namely box, polygon, ring, multipolygon. The units are the square of the units used for the points defining the surface. If subject geometry is defined in meters, then area is calculated in square meters.

The area calculation can be done in all three common coordinate systems, Cartesian, Spherical and Geographic as well.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

The calculated \1

[include reference/algorithms/area.qbk] [heading Examples] [area] [area_output]
typename Geometry
typename Strategy
Strategy::return_type Strategy::return_type boost::geometry::area (Geometry const &geometry, Strategy const &strategy) area Geometry const & geometry Strategy const & strategy

Calculates the area of a geometry using the specified strategy.

The free function area calculates the area of a geometry using the specified strategy. Reasons to specify a strategy include: use another coordinate system for calculations; construct the strategy beforehand (e.g. with the radius of the Earth); select a strategy when there are more than one available for a calculation. Geometry

Any type fulfilling a Geometry Concept

Strategy

Any type fulfilling a Area Strategy Concept

geometry

A model of the specified concept

strategy

The strategy which will be used for area calculations

The calculated \1

with strategy

[include reference/algorithms/area.qbk] [heading Example] [area_with_strategy] [area_with_strategy_output] [heading Available Strategies] \* [link geometry.reference.strategies.strategy_area_surveyor Surveyor (cartesian)] \* [link geometry.reference.strategies.strategy_area_huiller Huiller (spherical)]

typename Geometry
int Dimensions Dimensions
void void boost::geometry::assert_dimension () assert_dimension

assert_dimension, enables compile-time checking if coordinate dimensions are as expected

typename G1
typename G2
void void boost::geometry::assert_dimension_equal () assert_dimension_equal

assert_dimension_equal, enables compile-time checking if coordinate dimensions of two geometries are equal

typename Geometry
int Dimensions Dimensions
void void boost::geometry::assert_dimension_greater_equal () assert_dimension_greater_equal
typename Geometry
int Dimensions Dimensions
void void boost::geometry::assert_dimension_less_equal () assert_dimension_less_equal

assert_dimension, enables compile-time checking if coordinate dimensions are as expected

typename Geometry1
typename Geometry2
void void boost::geometry::assign (Geometry1 &geometry1, Geometry2 const &geometry2) assign Geometry1 & geometry1 Geometry2 const & geometry2

Assigns one geometry to another geometry.

The assign algorithm assigns one geometry, e.g. a BOX, to another geometry, e.g. a RING. This only works if it is possible and applicable.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept (target)

geometry2

A model of the specified concept (source)

[heading Example] [assign] [assign_output] [heading See also] \* [link geometry.reference.algorithms.convert convert]
typename Geometry
void void boost::geometry::assign_inverse (Geometry &geometry) assign_inverse Geometry & geometry

assign to a box inverse infinite

The assign_inverse function initialize a 2D or 3D box with large coordinates, the min corner is very large, the max corner is very small. This is a convenient starting point to collect the minimum bounding box of a geometry.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

[heading Example] [assign_inverse] [assign_inverse_output] [heading See also] \* [link geometry.reference.algorithms.make.make_inverse make_inverse]
typename Point1
typename Point2
void void boost::geometry::assign_point (Point1 &p1, Point2 const &p2) assign_point Point1 & p1 Point2 const & p2

Assign a point with another.

The coordinates of the first point will be assigned those of the second point. The second point is not modified. Point1

Any type fulfilling a Point Concept

Point2

Any type fulfilling a Point Concept

p1

first point

p2

second point

typename Geometry
typename Range
void void boost::geometry::assign_points (Geometry &geometry, Range const &range) assign_points Geometry & geometry Range const & range

Assign a range of points to a linestring, ring or polygon.

The point-type of the range might be different from the point-type of the geometry

Geometry

Any type fulfilling a Geometry Concept

Range

Any type fulfilling a Range Concept where it range_value type fulfills the Point Concept

geometry

A model of the specified concept

range

A range containg points fulfilling range and point concepts

[heading Notes] [note Assign automatically clears the geometry before assigning (use append if you don't want that)] [heading Example] [assign_points] [assign_points_output] [heading See also] \* [link geometry.reference.algorithms.append append]
typename Point
void void boost::geometry::assign_value (Point &p, typename detail::param< Point >::type value) assign_value Point & p typename detail::param< Point >::type value

Assign each coordinate of a point the same value.

Point

Any type fulfilling a Point Concept

p

point

value

value to assign

typename Geometry
typename Type
void void boost::geometry::assign_values (Geometry &geometry, Type const &c1, Type const &c2) assign_values Geometry & geometry Type const & c1 Type const & c2

Assign two coordinates to a geometry (usually a 2D point)

Geometry

Any type fulfilling a Geometry Concept

Type

numerical type (int, double, ttmath, ...) to specify the coordinates

geometry

A model of the specified concept

c1

First coordinate (usually x-coordinate)

c2

Second coordinate (usually y-coordinate)

2 coordinate values [heading Example] [assign_2d_point] [assign_2d_point_output] [heading See also] \* [link geometry.reference.algorithms.make.make_2_2_coordinate_values make]
typename Geometry
typename Type
void void boost::geometry::assign_values (Geometry &geometry, Type const &c1, Type const &c2, Type const &c3) assign_values Geometry & geometry Type const & c1 Type const & c2 Type const & c3

Assign three values to a geometry (usually a 3D point)

Geometry

Any type fulfilling a Geometry Concept

Type

numerical type (int, double, ttmath, ...) to specify the coordinates

geometry

A model of the specified concept

c1

First coordinate (usually x-coordinate)

c2

Second coordinate (usually y-coordinate)

c3

Third coordinate (usually z-coordinate)

3 coordinate values [heading Example] [assign_3d_point] [assign_3d_point_output] [heading See also] \* [link geometry.reference.algorithms.make.make_3_3_coordinate_values make]
typename Geometry
typename Type
void void boost::geometry::assign_values (Geometry &geometry, Type const &c1, Type const &c2, Type const &c3, Type const &c4) assign_values Geometry & geometry Type const & c1 Type const & c2 Type const & c3 Type const & c4

Assign four values to a geometry (usually a box or segment)

Geometry

Any type fulfilling a Geometry Concept

Type

numerical type (int, double, ttmath, ...) to specify the coordinates

geometry

A model of the specified concept

c1

First coordinate (usually x1)

c2

Second coordinate (usually y1)

c3

Third coordinate (usually x2)

c4

Fourth coordinate (usually y2)

4 coordinate values
typename Geometry
void void boost::geometry::assign_zero (Geometry &geometry) assign_zero Geometry & geometry

assign zero values to a box, point

The assign_zero function initializes a 2D or 3D point or box with coordinates of zero Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

typename Input
typename Output
typename Distance
void void boost::geometry::buffer (Input const &geometry_in, Output &geometry_out, Distance const &distance, Distance const &chord_length=-1) buffer Input const & geometry_in Output & geometry_out Distance const & distance Distance const & chord_length -1

Calculates the buffer of a geometry.

The free function buffer calculates the buffer (a polygon being the spatial point set collection within a specified maximum distance from a geometry) of a geometry. Input

Any type fulfilling a Geometry Concept

Output

Any type fulfilling a Geometry Concept

Distance

numerical type (int, double, ttmath, ...)

geometry_in

A model of the specified concept

geometry_out

A model of the specified concept

distance

The distance to be used for the buffer

chord_length

(optional) The length of the chord's in the generated arcs around points or bends

[include reference/algorithms/buffer.qbk]
typename GeometryIn
typename MultiPolygon
typename DistanceStrategy
typename SideStrategy
typename JoinStrategy
typename EndStrategy
typename PointStrategy
void void boost::geometry::buffer (GeometryIn const &geometry_in, MultiPolygon &geometry_out, DistanceStrategy const &distance_strategy, SideStrategy const &side_strategy, JoinStrategy const &join_strategy, EndStrategy const &end_strategy, PointStrategy const &point_strategy) buffer GeometryIn const & geometry_in MultiPolygon & geometry_out DistanceStrategy const & distance_strategy SideStrategy const & side_strategy JoinStrategy const & join_strategy EndStrategy const & end_strategy PointStrategy const & point_strategy

Calculates the buffer of a geometry.

The free function buffer calculates the buffer (a polygon being the spatial point set collection within a specified maximum distance from a geometry) of a geometry. GeometryIn

Any type fulfilling a Geometry Concept

MultiPolygon

A type fulfilling the MultiPolygon Concept

DistanceStrategy

A strategy defining distance (or radius)

SideStrategy

A strategy defining creation along sides

JoinStrategy

A strategy defining creation around convex corners

EndStrategy

A strategy defining creation at linestring ends

PointStrategy

A strategy defining creation around points

geometry_in

A model of the specified concept

geometry_out

output multi polygon (or std:: collection of polygons), will contain a buffered version of the input geometry

distance_strategy

The distance strategy to be used

side_strategy

The side strategy to be used

join_strategy

The join strategy to be used

end_strategy

The end strategy to be used

point_strategy

The point strategy to be used

with strategies [include reference/algorithms/buffer_with_strategies.qbk]
typename Geometry
typename Point
typename Strategy
void void boost::geometry::centroid (Geometry const &geometry, Point &c, Strategy const &strategy) centroid Geometry const & geometry Point & c Strategy const & strategy

Calculates the centroid of a geometry using the specified strategy.

The free function centroid calculates the geometric center (or: center of mass) of a geometry. Reasons to specify a strategy include: use another coordinate system for calculations; construct the strategy beforehand (e.g. with the radius of the Earth); select a strategy when there are more than one available for a calculation. Geometry

Any type fulfilling a Geometry Concept

Point

Any type fulfilling a Point Concept

Strategy

Any type fulfilling a Centroid Strategy Concept

geometry

A model of the specified concept

c

A model of the specified Point Concept which is set to the \1

strategy

The strategy which will be used for centroid calculations

with strategy [include reference/algorithms/centroid.qbk] [include reference/algorithms/centroid_strategies.qbk] }
typename Geometry
typename Point
void void boost::geometry::centroid (Geometry const &geometry, Point &c) centroid Geometry const & geometry Point & c

Calculates the centroid of a geometry.

The free function centroid calculates the geometric center (or: center of mass) of a geometry. It uses the default strategy, based on the coordinate system of the geometry. Geometry

Any type fulfilling a Geometry Concept

Point

Any type fulfilling a Point Concept

geometry

A model of the specified concept

c

The calculated centroid will be assigned to this point reference

[include reference/algorithms/centroid.qbk] [heading Example] [centroid] [centroid_output]
typename Geometry
void void boost::geometry::clear (Geometry &geometry) clear Geometry & geometry

Clears a linestring, ring or polygon (exterior+interiors) or multi*.

Generic function to clear a geometry. All points will be removed from the collection or collections making up the geometry. In most cases this is equivalent to the .clear() method of a std::vector<...>. In the case of a polygon, this clear functionality is automatically called for the exterior ring, and for the interior ring collection. In the case of a point, boxes and segments, nothing will happen.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept which will be cleared

points and boxes cannot be cleared, instead they can be set to zero by "assign_zero"

[include reference/algorithms/clear.qbk]
typename Collection
typename Geometry
void void boost::geometry::collect_vectors (Collection &collection, Geometry const &geometry) collect_vectors Collection & collection Geometry const & geometry

Collection

Collection type, should be e.g. std::vector<>

Geometry

geometry type

collection

the collection of vectors

geometry

the geometry to make collect_vectors

typename Geometry1
typename Geometry2
typename Strategy
comparable_distance_result< Geometry1, Geometry2, Strategy >::type comparable_distance_result<Geometry1, Geometry2, Strategy>::type boost::geometry::comparable_distance (Geometry1 const &geometry1, Geometry2 const &geometry2, Strategy const &strategy) comparable_distance Geometry1 const & geometry1 Geometry2 const & geometry2 Strategy const & strategy

Calculate the comparable distance measurement of two geometries using the specified strategy.

The free function comparable_distance does not necessarily calculate the distance, but it calculates a distance measure such that two distances are comparable to each other. For example: for the Cartesian coordinate system, Pythagoras is used but the square root is not taken, which makes it faster and the results of two point pairs can still be compared to each other. Geometry1

first geometry type

Geometry2

second geometry type

Strategy

Any type fulfilling a Distance Strategy Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

strategy

The strategy which will be used for distance calculations

The calculated \1

with strategy
typename Geometry1
typename Geometry2
default_comparable_distance_result< Geometry1, Geometry2 >::type default_comparable_distance_result<Geometry1, Geometry2>::type boost::geometry::comparable_distance (Geometry1 const &geometry1, Geometry2 const &geometry2) comparable_distance Geometry1 const & geometry1 Geometry2 const & geometry2

Calculate the comparable distance measurement of two geometries.

The free function comparable_distance does not necessarily calculate the distance, but it calculates a distance measure such that two distances are comparable to each other. For example: for the Cartesian coordinate system, Pythagoras is used but the square root is not taken, which makes it faster and the results of two point pairs can still be compared to each other. Geometry1

first geometry type

Geometry2

second geometry type

geometry1

A model of the specified concept

geometry2

A model of the specified concept

The calculated \1

[include reference/algorithms/comparable_distance.qbk]
typename Geometry1
typename Geometry2
void void boost::geometry::convert (Geometry1 const &geometry1, Geometry2 &geometry2) convert Geometry1 const & geometry1 Geometry2 & geometry2

Converts one geometry to another geometry.

The convert algorithm converts one geometry, e.g. a BOX, to another geometry, e.g. a RING. This only works if it is possible and applicable. If the point-order is different, or the closure is different between two geometry types, it will be converted correctly by explicitly reversing the points or closing or opening the polygon rings.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept (source)

geometry2

A model of the specified concept (target)

[include reference/algorithms/convert.qbk]
typename Geometry
typename OutputGeometry
typename Strategy
void void boost::geometry::convex_hull (Geometry const &geometry, OutputGeometry &out, Strategy const &strategy) convex_hull Geometry const & geometry OutputGeometry & out Strategy const & strategy
typename Geometry
typename OutputGeometry
void void boost::geometry::convex_hull (Geometry const &geometry, OutputGeometry &hull) convex_hull Geometry const & geometry OutputGeometry & hull

Calculates the convex hull of a geometry.

The free function convex_hull calculates the convex hull of a geometry. Geometry

the input geometry type

OutputGeometry

the output geometry type

geometry

A model of the specified concept, input geometry

hull

A model of the specified concept which is set to the \1

[include reference/algorithms/convex_hull.qbk]
bool Reverse Reverse
typename Geometry
typename SegmentIdentifier
typename PointOut
bool bool boost::geometry::copy_segment_point (Geometry const &geometry, SegmentIdentifier const &seg_id, int offset, PointOut &point_out) copy_segment_point Geometry const & geometry SegmentIdentifier const & seg_id int offset PointOut & point_out

Helper function, copies a point from a segment.

bool Reverse1 Reverse1
bool Reverse2 Reverse2
typename Geometry1
typename Geometry2
typename SegmentIdentifier
typename PointOut
bool bool boost::geometry::copy_segment_point (Geometry1 const &geometry1, Geometry2 const &geometry2, SegmentIdentifier const &seg_id, int offset, PointOut &point_out) copy_segment_point Geometry1 const & geometry1 Geometry2 const & geometry2 SegmentIdentifier const & seg_id int offset PointOut & point_out

Helper function, to avoid the same construct several times, copies a point, based on a source-index and two geometries.

bool Reverse1 Reverse1
bool Reverse2 Reverse2
typename Geometry1
typename Geometry2
typename SegmentIdentifier
typename PointOut
bool bool boost::geometry::copy_segment_points (Geometry1 const &geometry1, Geometry2 const &geometry2, SegmentIdentifier const &seg_id, PointOut &point1, PointOut &point2) copy_segment_points Geometry1 const & geometry1 Geometry2 const & geometry2 SegmentIdentifier const & seg_id PointOut & point1 PointOut & point2

Helper function, to avoid the same construct several times, copies a point, based on a source-index and two geometries.

bool Reverse1 Reverse1
bool Reverse2 Reverse2
typename Geometry1
typename Geometry2
typename SegmentIdentifier
typename PointOut
bool bool boost::geometry::copy_segment_points (Geometry1 const &geometry1, Geometry2 const &geometry2, SegmentIdentifier const &seg_id, PointOut &point1, PointOut &point2, PointOut &point3) copy_segment_points Geometry1 const & geometry1 Geometry2 const & geometry2 SegmentIdentifier const & seg_id PointOut & point1 PointOut & point2 PointOut & point3

Helper function, copies three points: two from the specified segment (from, to) and the next one.

bool Reverse Reverse
typename Geometry
typename SegmentIdentifier
typename RobustPolicy
typename RangeOut
void void boost::geometry::copy_segments (Geometry const &geometry, SegmentIdentifier const &seg_id, signed_size_type to_index, RobustPolicy const &robust_policy, RangeOut &range_out) copy_segments Geometry const & geometry SegmentIdentifier const & seg_id signed_size_type to_index RobustPolicy const & robust_policy RangeOut & range_out

Copy segments from a geometry, starting with the specified segment (seg_id) until the specified index (to_index)

typename Geometry
void void boost::geometry::correct (Geometry &geometry) correct Geometry & geometry

Corrects a geometry.

Corrects a geometry: all rings which are wrongly oriented with respect to their expected orientation are reversed. To all rings which do not have a closing point and are typed as they should have one, the first point is appended. Also boxes can be corrected.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept which will be corrected if necessary

[include reference/algorithms/correct.qbk]
typename Geometry1
typename Geometry2
bool bool boost::geometry::covered_by (Geometry1 const &geometry1, Geometry2 const &geometry2) covered_by Geometry1 const & geometry1 Geometry2 const & geometry2

Checks if the first geometry is inside or on border the second geometry.

The free function covered_by checks if the first geometry is inside or on border the second geometry. Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept which might be inside or on the border of the second geometry

geometry2

A model of the specified concept which might cover the first geometry

true if geometry1 is inside of or on the border of geometry2, else false

The default strategy is used for covered_by detection

[include reference/algorithms/covered_by.qbk]
typename Geometry1
typename Geometry2
typename Strategy
bool bool boost::geometry::covered_by (Geometry1 const &geometry1, Geometry2 const &geometry2, Strategy const &strategy) covered_by Geometry1 const & geometry1 Geometry2 const & geometry2 Strategy const & strategy

Checks if the first geometry is inside or on border the second geometry using the specified strategy.

The free function covered_by checks if the first geometry is inside or on border the second geometry, using the specified strategy. Reasons to specify a strategy include: use another coordinate system for calculations; construct the strategy beforehand (e.g. with the radius of the Earth); select a strategy when there are more than one available for a calculation. Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept which might be inside or on the border of the second geometry

geometry2

A model of the specified concept which might cover the first geometry

strategy

strategy to be used

true if geometry1 is inside of or on the border of geometry2, else false

with strategy [include reference/algorithms/covered_by.qbk]
typename Geometry1
typename Geometry2
bool bool boost::geometry::crosses (Geometry1 const &geometry1, Geometry2 const &geometry2) crosses Geometry1 const & geometry1 Geometry2 const & geometry2

Checks if two geometries \1.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

Returns true if two geometries \1

[include reference/algorithms/crosses.qbk]
typename Geometry1
typename Geometry2
typename Collection
void void boost::geometry::difference (Geometry1 const &geometry1, Geometry2 const &geometry2, Collection &output_collection) difference Geometry1 const & geometry1 Geometry2 const & geometry2 Collection & output_collection

Calculate the difference of two geometries

The free function difference calculates the spatial set theoretic difference of two geometries. Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

Collection

output collection, either a multi-geometry, or a std::vector<Geometry> / std::deque<Geometry> etc

geometry1

A model of the specified concept

geometry2

A model of the specified concept

output_collection

the output collection

[include reference/algorithms/difference.qbk]
typename Geometry1
typename Geometry2
bool bool boost::geometry::disjoint (Geometry1 const &geometry1, Geometry2 const &geometry2) disjoint Geometry1 const & geometry1 Geometry2 const & geometry2

Checks if two geometries \1.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

Returns true if two geometries \1

[include reference/algorithms/disjoint.qbk]
typename Geometry1
typename Geometry2
typename Strategy
distance_result< Geometry1, Geometry2, Strategy >::type distance_result<Geometry1, Geometry2, Strategy>::type boost::geometry::distance (Geometry1 const &geometry1, Geometry2 const &geometry2, Strategy const &strategy) distance Geometry1 const & geometry1 Geometry2 const & geometry2 Strategy const & strategy

Calculate the distance of two geometries using the specified strategy.

The free function area calculates the area of a geometry. using the specified strategy. Reasons to specify a strategy include: use another coordinate system for calculations; construct the strategy beforehand (e.g. with the radius of the Earth); select a strategy when there are more than one available for a calculation.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

Strategy

Any type fulfilling a Distance Strategy Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

strategy

The strategy which will be used for distance calculations

The calculated \1

The strategy can be a point-point strategy. In case of distance point-line/point-polygon it may also be a point-segment strategy.

with strategy

[heading Available Strategies] \* [link geometry.reference.strategies.strategy_distance_pythagoras Pythagoras (cartesian)] \* [link geometry.reference.strategies.strategy_distance_haversine Haversine (spherical)] \* [link geometry.reference.strategies.strategy_distance_cross_track Cross track (spherical, point-to-segment)] \* [link geometry.reference.strategies.strategy_distance_projected_point Projected point (cartesian, point-to-segment)] \* more (currently extensions): Vincenty, Andoyer (geographic)

typename Geometry1
typename Geometry2
default_distance_result< Geometry1, Geometry2 >::type default_distance_result<Geometry1, Geometry2>::type boost::geometry::distance (Geometry1 const &geometry1, Geometry2 const &geometry2) distance Geometry1 const & geometry1 Geometry2 const & geometry2

Calculate the distance of two geometries.

The default strategy is used, corresponding to the coordinate system of the geometries Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

The calculated \1

[include reference/algorithms/distance.qbk]
typename Point1
typename Point2
void void boost::geometry::divide_point (Point1 &p1, Point2 const &p2) divide_point Point1 & p1 Point2 const & p2

Divides a point by another.

The coordinates of the first point will be divided by those of the second point. The second point is not modified. Point1

Any type fulfilling a Point Concept

Point2

Any type fulfilling a Point Concept

p1

first point

p2

second point

typename Point
void void boost::geometry::divide_value (Point &p, typename detail::param< Point >::type value) divide_value Point & p typename detail::param< Point >::type value

Divides each coordinate of the same point by a value.

Point

Any type fulfilling a Point Concept

p

point

value

value to divide by

typename Point1
typename Point2
select_coordinate_type< Point1, Point2 >::type select_coordinate_type<Point1, Point2>::type boost::geometry::dot_product (Point1 const &p1, Point2 const &p2) dot_product Point1 const & p1 Point2 const & p2

Computes the dot product (or scalar product) of 2 vectors (points).

Point1

Any type fulfilling a Point Concept

Point2

Any type fulfilling a Point Concept

p1

first point

p2

second point

the dot product

bool Reverse1 Reverse1
bool Reverse2 Reverse2
overlay_type OverlayType OverlayType
typename Turns
typename Clusters
typename Geometry1
typename Geometry2
typename RobustPolicy
typename Strategy
void void boost::geometry::enrich_intersection_points (Turns &turns, Clusters &clusters, detail::overlay::operation_type for_operation, Geometry1 const &geometry1, Geometry2 const &geometry2, RobustPolicy const &robust_policy, Strategy const &strategy) enrich_intersection_points Turns & turns Clusters & clusters detail::overlay::operation_type for_operation Geometry1 const & geometry1 Geometry2 const & geometry2 RobustPolicy const & robust_policy Strategy const & strategy

All intersection points are enriched with successor information.

Turns

type of intersection container (e.g. vector of "intersection/turn point"'s)

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

Strategy

side strategy type

turns

container containing intersectionpoints

for_operation

operation_type (union or intersection)

geometry1

A model of the specified concept

geometry2

A model of the specified concept

robust_policy

policy to handle robustness issues

strategy

strategy

typename Geometry
typename Box
void void boost::geometry::envelope (Geometry const &geometry, Box &mbr) envelope Geometry const & geometry Box & mbr

Calculates the envelope of a geometry.

The free function envelope calculates the envelope (also known as axis aligned bounding box, aabb, or minimum bounding rectangle, mbr) of a geometry. Geometry

Any type fulfilling a Geometry Concept

Box

Any type fulfilling a Box Concept

geometry

A model of the specified concept

mbr

A model of the specified Box Concept which is set to the \1

[include reference/algorithms/envelope.qbk] [heading Example] [envelope] [envelope_output]
typename Geometry1
typename Geometry2
bool bool boost::geometry::equals (Geometry1 const &geometry1, Geometry2 const &geometry2) equals Geometry1 const & geometry1 Geometry2 const & geometry2

Checks if a geometry \1.

The free function equals checks if the first geometry is spatially equal the second geometry. Spatially equal means that the same point set is included. A box can therefore be spatially equal to a ring or a polygon, or a linestring can be spatially equal to a multi-linestring or a segment. This only works theoretically, not all combinations are implemented yet.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

Returns true if two geometries \1

[include reference/algorithms/equals.qbk]
typename Box
typename Geometry
void void boost::geometry::expand (Box &box, Geometry const &geometry) expand Box & box Geometry const & geometry

Expands a box using the bounding box (envelope) of another geometry (box, point)

Box

type of the box

Geometry

Any type fulfilling a Geometry Concept

box

box to be expanded using another geometry, mutable

geometry

A model of the specified concept geometry which envelope (bounding box) will be added to the box

[include reference/algorithms/expand.qbk]
typename Polygon
ring_return_type< Polygon >::type ring_return_type<Polygon>::type boost::geometry::exterior_ring (Polygon &polygon) exterior_ring Polygon & polygon

Function to get the exterior_ring ring of a polygon.

OGC compliance: instead of ExteriorRing

Polygon

polygon type

polygon

the polygon to get the exterior ring from

a reference to the exterior ring

typename Polygon
ring_return_type< Polygon const >::type ring_return_type<Polygon const>::type boost::geometry::exterior_ring (Polygon const &polygon) exterior_ring Polygon const & polygon

Function to get the exterior ring of a polygon (const version)

OGC compliance: instead of ExteriorRing

Polygon

polygon type

polygon

the polygon to get the exterior ring from

a const reference to the exterior ring

const version
std::size_t Edge Edge
typename Geometry
typename Extremes
typename Intruders
bool bool boost::geometry::extreme_points (Geometry const &geometry, Extremes &extremes, Intruders &intruders) extreme_points Geometry const & geometry Extremes & extremes Intruders & intruders

Returns extreme points (for Edge=1 in dimension 1, so the top, for Edge=0 in dimension 0, the right side)

We could specify a strategy (less/greater) to get bottom/left side too. However, until now we don't need that.

typename Point
typename Op
void void boost::geometry::for_each_coordinate (Point &point, Op operation) for_each_coordinate Point & point Op operation
typename Point
typename Op
Op Op boost::geometry::for_each_coordinate (Point const &point, Op operation) for_each_coordinate Point const & point Op operation
typename Geometry
typename Functor
Functor Functor boost::geometry::for_each_point (Geometry &geometry, Functor f) for_each_point Geometry & geometry Functor f

Applies function [*f] to each \1.

Applies a function [*f] (functor, having operator() defined) to each point making up the geometry

geometry

A model of the specified concept

f

Unary function, taking a point as argument

Geometry

Any type fulfilling a Geometry Concept

Functor

Function or class with operator()

[include reference/algorithms/for_each_point.qbk] [heading Example] [for_each_point] [for_each_point_output] [for_each_point_const] [for_each_point_const_output]
typename Geometry
typename Functor
Functor Functor boost::geometry::for_each_segment (Geometry &geometry, Functor f) for_each_segment Geometry & geometry Functor f

Applies function [*f] to each \1.

Applies a function [*f] (functor, having operator() defined) to each segment making up the geometry

geometry

A model of the specified concept

f

Unary function, taking a segment as argument

Geometry

Any type fulfilling a Geometry Concept

Functor

Function or class with operator()

[include reference/algorithms/for_each_segment.qbk] [heading Example] [for_each_segment_const] [for_each_segment_const_output]
std::size_t Dimension Dimension
typename Geometry
coordinate_type< Geometry >::type coordinate_type<Geometry>::type boost::geometry::get (Geometry const &geometry) get Geometry const & geometry

Get coordinate value of a geometry (usually a point)

The free functions [*get] and [*set] are two of the most important functions of Boost.Geometry, both within the library, as also for the library user. With these two functions you normally get and set coordinate values from and for a point, box, segment or sphere.

Dimension

Dimension, this template parameter is required. Should contain \[0 .. n-1\] for an n-dimensional geometry

Geometry

Any type fulfilling a Geometry Concept (usually a Point Concept)

geometry

A model of the specified concept (usually a point)

The coordinate value of specified dimension of specified geometry

[include reference/core/get_point.qbk]
std::size_t Index Index
std::size_t Dimension Dimension
typename Geometry
coordinate_type< Geometry >::type coordinate_type<Geometry>::type boost::geometry::get (Geometry const &geometry) get Geometry const & geometry

get coordinate value of a Box or Segment

The free functions [*get] and [*set] are two of the most important functions of Boost.Geometry, both within the library, as also for the library user. With these two functions you normally get and set coordinate values from and for a point, box, segment or sphere. Index

Index, this template parameter is required. For a Box: either min_corner or max_corner. For a Segment: either 0 or 1 for first or last point.

Dimension

Dimension, this template parameter is required. Should contain \[0 .. n-1\] for an n-dimensional geometry

Geometry

Any type fulfilling a Box Concept or a Segment Concept

geometry

A model of the specified concept

coordinate value

with index [include reference/core/get_box.qbk]
std::size_t Dimension Dimension
typename Geometry
fp_coordinate_type< Geometry >::type fp_coordinate_type<Geometry>::type boost::geometry::get_as_radian (Geometry const &geometry) get_as_radian Geometry const & geometry

get coordinate value of a point, result is in Radian

Result is in Radian, even if source coordinate system is in Degrees

coordinate value

Dimension

dimension

Geometry

geometry

geometry

geometry to get coordinate value from

Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems

typename Geometry1
typename Geometry2
typename RobustPolicy
typename Turns
void void boost::geometry::get_intersection_points (Geometry1 const &geometry1, Geometry2 const &geometry2, RobustPolicy const &robust_policy, Turns &turns) get_intersection_points Geometry1 const & geometry1 Geometry2 const & geometry2 RobustPolicy const & robust_policy Turns & turns
std::size_t I I
typename Geometry
radius_type< Geometry >::type radius_type<Geometry>::type boost::geometry::get_radius (Geometry const &geometry) get_radius Geometry const & geometry

Function to get radius of a circle / sphere / ellipse / etc.

radius The radius for a given axis

geometry

the geometry to get the radius from

I

index of the axis

bool Reverse1 Reverse1
bool Reverse2 Reverse2
typename AssignPolicy
typename Geometry1
typename Geometry2
typename RobustPolicy
typename Turns
typename InterruptPolicy
void void boost::geometry::get_turns (Geometry1 const &geometry1, Geometry2 const &geometry2, RobustPolicy const &robust_policy, Turns &turns, InterruptPolicy &interrupt_policy) get_turns Geometry1 const & geometry1 Geometry2 const & geometry2 RobustPolicy const & robust_policy Turns & turns InterruptPolicy & interrupt_policy

Calculate the turn points of two geometries.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

Turns

type of turn-container (e.g. vector of "intersection/turn point"'s)

geometry1

A model of the specified concept

geometry2

A model of the specified concept

robust_policy

policy to handle robustness issues

turns

container which will contain turn points

interrupt_policy

policy determining if process is stopped when intersection is found

typename Point
bool bool boost::geometry::has_infinite_coordinate (Point const &point) has_infinite_coordinate Point const & point
typename Point
bool bool boost::geometry::has_nan_coordinate (Point const &point) has_nan_coordinate Point const & point
typename Point
bool bool boost::geometry::has_non_finite_coordinate (Point const &point) has_non_finite_coordinate Point const & point
typename Iterator
bool bool boost::geometry::has_one_element (Iterator first, Iterator beyond) has_one_element Iterator first Iterator beyond
typename Polygon
interior_return_type< Polygon >::type interior_return_type<Polygon>::type boost::geometry::interior_rings (Polygon &polygon) interior_rings Polygon & polygon

Function to get the interior rings of a polygon (non const version)

OGC compliance: instead of InteriorRingN

Polygon

polygon type

polygon

the polygon to get the interior rings from

the interior rings (possibly a reference)

typename Polygon
interior_return_type< Polygon const >::type interior_return_type<Polygon const>::type boost::geometry::interior_rings (Polygon const &polygon) interior_rings Polygon const & polygon

Function to get the interior rings of a polygon (const version)

OGC compliance: instead of InteriorRingN

Polygon

polygon type

polygon

the polygon to get the interior rings from

the interior rings (possibly a const reference)

const version
typename Geometry1
typename Geometry2
typename GeometryOut
bool bool boost::geometry::intersection (Geometry1 const &geometry1, Geometry2 const &geometry2, GeometryOut &geometry_out) intersection Geometry1 const & geometry1 Geometry2 const & geometry2 GeometryOut & geometry_out

Calculate the intersection of two geometries.

The free function intersection calculates the spatial set theoretic intersection of two geometries. Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

GeometryOut

Collection of geometries (e.g. std::vector, std::deque, boost::geometry::multi*) of which the value_type fulfills a Point, LineString or Polygon concept, or it is the output geometry (e.g. for a box)

geometry1

A model of the specified concept

geometry2

A model of the specified concept

geometry_out

The output geometry, either a multi_point, multi_polygon, multi_linestring, or a box (for intersection of two boxes)

[include reference/algorithms/intersection.qbk]
typename Geometry
bool bool boost::geometry::intersects (Geometry const &geometry) intersects Geometry const & geometry

Checks if a geometry \1.

This function can be called for one geometry (self-intersection) and also for two geometries (intersection)

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

Returns true if the geometry \1

one geometry [def __one_parameter__] [include reference/algorithms/intersects.qbk]
typename Geometry1
typename Geometry2
bool bool boost::geometry::intersects (Geometry1 const &geometry1, Geometry2 const &geometry2) intersects Geometry1 const & geometry1 Geometry2 const & geometry2

Checks if two geometries \1.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

Returns true if two geometries \1

two geometries [include reference/algorithms/intersects.qbk]
typename Geometry
bool bool boost::geometry::is_convex (Geometry const &geometry) is_convex Geometry const & geometry
typename Geometry
bool bool boost::geometry::is_empty (Geometry const &geometry) is_empty Geometry const & geometry

Checks if a geometry \1.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

Returns true if the geometry \1

[include reference/algorithms/is_empty.qbk]
typename Geometry
bool bool boost::geometry::is_simple (Geometry const &geometry) is_simple Geometry const & geometry

Checks if a geometry \1.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

Returns true if the geometry \1

[include reference/algorithms/is_simple.qbk]
typename Geometry
typename VisitPolicy
bool bool boost::geometry::is_valid (Geometry const &geometry, VisitPolicy &visitor) is_valid Geometry const & geometry VisitPolicy & visitor
typename Geometry
bool bool boost::geometry::is_valid (Geometry const &geometry) is_valid Geometry const & geometry

Checks if a geometry \1.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

{is valid (in the OGC sense); furthermore, the following geometries are considered valid: multi-geometries with no elements, linear geometries containing spikes, areal geometries with duplicate (consecutive) points}

[include reference/algorithms/is_valid.qbk]
typename Geometry
bool bool boost::geometry::is_valid (Geometry const &geometry, validity_failure_type &failure) is_valid Geometry const & geometry validity_failure_type & failure

Checks if a geometry \1.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

failure

An enumeration value indicating that the geometry is valid or not, and if not valid indicating the reason why

{is valid (in the OGC sense); furthermore, the following geometries are considered valid: multi-geometries with no elements, linear geometries containing spikes, areal geometries with duplicate (consecutive) points}

with failure value [include reference/algorithms/is_valid_with_failure.qbk]
typename Geometry
bool bool boost::geometry::is_valid (Geometry const &geometry, std::string &message) is_valid Geometry const & geometry std::string & message

Checks if a geometry \1.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

message

A string containing a message stating if the geometry is valid or not, and if not valid a reason why

{is valid (in the OGC sense); furthermore, the following geometries are considered valid: multi-geometries with no elements, linear geometries containing spikes, areal geometries with duplicate (consecutive) points}

with message [include reference/algorithms/is_valid_with_message.qbk]
typename Geometry
default_length_result< Geometry >::type default_length_result<Geometry>::type boost::geometry::length (Geometry const &geometry) length Geometry const & geometry

Calculates the length of a geometry.

The free function length calculates the length (the sum of distances between consecutive points) of a geometry. It uses the default strategy, based on the coordinate system of the geometry. Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

The calculated \1

[include reference/algorithms/length.qbk] [length] [length_output]
typename Geometry
typename Strategy
default_length_result< Geometry >::type default_length_result<Geometry>::type boost::geometry::length (Geometry const &geometry, Strategy const &strategy) length Geometry const & geometry Strategy const & strategy

Calculates the length of a geometry using the specified strategy.

The free function length calculates the length (the sum of distances between consecutive points) of a geometry using the specified strategy. Reasons to specify a strategy include: use another coordinate system for calculations; construct the strategy beforehand (e.g. with the radius of the Earth); select a strategy when there are more than one available for a calculation. Geometry

Any type fulfilling a Geometry Concept

Strategy

Any type fulfilling a distance Strategy Concept

geometry

A model of the specified concept

strategy

The strategy which will be used for distance calculations

The calculated \1

with strategy [include reference/algorithms/length.qbk] [length_with_strategy] [length_with_strategy_output]
typename Geometry
typename Type
Geometry Geometry boost::geometry::make (Type const &c1, Type const &c2) make Type const & c1 Type const & c2

Construct a geometry.

It does not work with array-point types, like int[2]

Geometry

Any type fulfilling a Geometry Concept

Type

numerical type (int, double, ttmath, ...) to specify the coordinates

c1

First coordinate (usually x-coordinate)

c2

Second coordinate (usually y-coordinate)

The constructed geometry, here: a 2D point

2 coordinate values [heading Example] [make_2d_point] [make_2d_point_output] [heading See also] \* [link geometry.reference.algorithms.assign.assign_values_3_2_coordinate_values assign]
typename Geometry
typename Type
Geometry Geometry boost::geometry::make (Type const &c1, Type const &c2, Type const &c3) make Type const & c1 Type const & c2 Type const & c3

Construct a geometry.

Geometry

Any type fulfilling a Geometry Concept

Type

numerical type (int, double, ttmath, ...) to specify the coordinates

c1

First coordinate (usually x-coordinate)

c2

Second coordinate (usually y-coordinate)

c3

Third coordinate (usually z-coordinate)

The constructed geometry, here: a 3D point

3 coordinate values [heading Example] [make_3d_point] [make_3d_point_output] [heading See also] \* [link geometry.reference.algorithms.assign.assign_values_4_3_coordinate_values assign]
typename Geometry
typename Type
Geometry Geometry boost::geometry::make (Type const &c1, Type const &c2, Type const &c3, Type const &c4) make Type const & c1 Type const & c2 Type const & c3 Type const & c4
typename Geometry
Geometry Geometry boost::geometry::make_inverse () make_inverse

Construct a box with inverse infinite coordinates.

The make_inverse function initializes a 2D or 3D box with large coordinates, the min corner is very large, the max corner is very small. This is useful e.g. in combination with the expand function, to determine the bounding box of a series of geometries. Geometry

Any type fulfilling a Geometry Concept

The constructed geometry, here: a box

[heading Example] [make_inverse] [make_inverse_output] [heading See also] \* [link geometry.reference.algorithms.assign.assign_inverse assign_inverse]
typename Geometry
Geometry Geometry boost::geometry::make_zero () make_zero

Construct a geometry with its coordinates initialized to zero.

The make_zero function initializes a 2D or 3D point or box with coordinates of zero Geometry

Any type fulfilling a Geometry Concept

The constructed and zero-initialized geometry

typename RangeOfIntervals
typename T
boost::range_value< RangeOfIntervals >::type::difference_type boost::range_value<RangeOfIntervals>::type::difference_type boost::geometry::maximum_gap (RangeOfIntervals const &range_of_intervals, T &max_gap_left, T &max_gap_right) maximum_gap RangeOfIntervals const & range_of_intervals T & max_gap_left T & max_gap_right
typename RangeOfIntervals
boost::range_value< RangeOfIntervals >::type::difference_type boost::range_value<RangeOfIntervals>::type::difference_type boost::geometry::maximum_gap (RangeOfIntervals const &range_of_intervals) maximum_gap RangeOfIntervals const & range_of_intervals
char char boost::geometry::method_char (detail::overlay::method_type const &method) method_char detail::overlay::method_type const & method
typename Point1
typename Point2
void void boost::geometry::multiply_point (Point1 &p1, Point2 const &p2) multiply_point Point1 & p1 Point2 const & p2

Multiplies a point by another.

The coordinates of the first point will be multiplied by those of the second point. The second point is not modified. Point1

Any type fulfilling a Point Concept

Point2

Any type fulfilling a Point Concept

p1

first point

p2

second point

This is *not* a dot, cross or wedge product. It is a mere field-by-field multiplication.

typename Point
void void boost::geometry::multiply_value (Point &p, typename detail::param< Point >::type value) multiply_value Point & p typename detail::param< Point >::type value

Multiplies each coordinate of a point by the same value.

Point

Any type fulfilling a Point Concept

p

point

value

value to multiply by

typename Geometry
std::size_t std::size_t boost::geometry::num_geometries (Geometry const &geometry) num_geometries Geometry const & geometry

Calculates the number of geometries of a geometry.

The free function num_geometries calculates the number of geometries of a geometry. Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

The calculated \1

[include reference/algorithms/num_geometries.qbk]
typename Geometry
std::size_t std::size_t boost::geometry::num_interior_rings (Geometry const &geometry) num_interior_rings Geometry const & geometry

Calculates the number of interior rings of a geometry.

The free function num_interior_rings calculates the number of interior rings of a geometry. Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

The calculated \1

[include reference/algorithms/num_interior_rings.qbk]

Defined by OGC as "numInteriorRing". To be consistent with "numPoints" letter "s" is appended

typename Geometry
std::size_t std::size_t boost::geometry::num_points (Geometry const &geometry, bool add_for_open=false) num_points Geometry const & geometry bool add_for_open false

Calculates the number of points of a geometry.

The free function num_points calculates the number of points of a geometry. Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

add_for_open

add one for open geometries (i.e. polygon types which are not closed)

The calculated \1

[include reference/algorithms/num_points.qbk]
typename Geometry
std::size_t std::size_t boost::geometry::num_segments (Geometry const &geometry) num_segments Geometry const & geometry

Calculates the number of segments of a geometry.

The free function num_segments calculates the number of segments of a geometry. Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

The calculated \1

[include reference/algorithms/num_segments.qbk]
char char boost::geometry::operation_char (detail::overlay::operation_type const &operation) operation_char detail::overlay::operation_type const & operation
typename Geometry1
typename Geometry2
bool bool boost::geometry::overlaps (Geometry1 const &geometry1, Geometry2 const &geometry2) overlaps Geometry1 const & geometry1 Geometry2 const & geometry2

Checks if two geometries \1.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

Returns true if two geometries \1

[include reference/algorithms/overlaps.qbk]
typename Geometry
default_length_result< Geometry >::type default_length_result<Geometry>::type boost::geometry::perimeter (Geometry const &geometry) perimeter Geometry const & geometry

Calculates the perimeter of a geometry.

The function perimeter returns the perimeter of a geometry, using the default distance-calculation-strategy Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

The calculated \1

[include reference/algorithms/perimeter.qbk]
typename Geometry
typename Strategy
default_length_result< Geometry >::type default_length_result<Geometry>::type boost::geometry::perimeter (Geometry const &geometry, Strategy const &strategy) perimeter Geometry const & geometry Strategy const & strategy

Calculates the perimeter of a geometry using the specified strategy.

The function perimeter returns the perimeter of a geometry, using specified strategy Geometry

Any type fulfilling a Geometry Concept

Strategy

Any type fulfilling a distance Strategy Concept

geometry

A model of the specified concept

strategy

strategy to be used for distance calculations.

The calculated \1

with strategy [include reference/algorithms/perimeter.qbk]
typename Point
typename Geometry
bool bool boost::geometry::point_on_border (Point &point, Geometry const &geometry, bool midpoint=false) point_on_border Point & point Geometry const & geometry bool midpoint false

Take point on a border.

Geometry

geometry type. This also defines the type of the output point

point

to assign

geometry

geometry to take point from

midpoint

boolean flag, true if the point should not be a vertex, but some point in between of two vertices

TRUE if successful, else false. It is only false if polygon/line have no points

for a polygon, it is always a point on the exterior ring

for take_midpoint, it is not taken from two consecutive duplicate vertices, (unless there are no other).

typename Geometry
typename Point
void void boost::geometry::point_on_surface (Geometry const &geometry, Point &point) point_on_surface Geometry const & geometry Point & point

Assigns a Point guaranteed to lie on the surface of the Geometry.

Geometry

geometry type. This also defines the type of the output point

geometry

Geometry to take point from

point

Point to assign

typename Geometry
point_iterator< Geometry > point_iterator<Geometry> boost::geometry::points_begin (Geometry &geometry) points_begin Geometry & geometry
typename Geometry
point_iterator< Geometry > point_iterator<Geometry> boost::geometry::points_end (Geometry &geometry) points_end Geometry & geometry
typename Geometry
point_reverse_iterator< Geometry > point_reverse_iterator<Geometry> boost::geometry::points_rbegin (Geometry &geometry) points_rbegin Geometry & geometry
typename Geometry
point_reverse_iterator< Geometry > point_reverse_iterator<Geometry> boost::geometry::points_rend (Geometry &geometry) points_rend Geometry & geometry
typename Geometry
typename Section
ring_return_type< Geometry const >::type ring_return_type<Geometry const>::type boost::geometry::range_by_section (Geometry const &geometry, Section const &section) range_by_section Geometry const & geometry Section const & section

Get full ring (exterior, one of interiors, one from multi) indicated by the specified section.

Geometry

type

Section

type of section to get from

geometry

geometry to take section of

section

structure with section

typename Geometry
void void boost::geometry::read_wkt (std::string const &wkt, Geometry &geometry) read_wkt std::string const & wkt Geometry & geometry

Parses OGC Well-Known Text (WKT (Well-Known Text)) into a geometry (any geometry)

Geometry

Any type fulfilling a Geometry Concept

wkt

string containing WKT (Well-Known Text)

geometry

A model of the specified concept output geometry

[include reference/io/read_wkt.qbk]
typename Geometry1
typename Geometry2
typename Strategy
void void boost::geometry::recalculate (Geometry1 &geometry1, Geometry2 const &geometry2, Strategy const &strategy) recalculate Geometry1 & geometry1 Geometry2 const & geometry2 Strategy const & strategy
typename Geometry1
typename Geometry2
typename Mask
bool bool boost::geometry::relate (Geometry1 const &geometry1, Geometry2 const &geometry2, Mask const &mask) relate Geometry1 const & geometry1 Geometry2 const & geometry2 Mask const & mask

Checks relation between a pair of geometries defined by a mask.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

Mask

An intersection model Mask type.

geometry1

A model of the specified concept

geometry2

A model of the specified concept

mask

An intersection model mask object.

true if the relation is compatible with the mask, false otherwise.

[include reference/algorithms/relate.qbk]
typename Geometry1
typename Geometry2
de9im::matrix de9im::matrix boost::geometry::relation (Geometry1 const &geometry1, Geometry2 const &geometry2) relation Geometry1 const & geometry1 Geometry2 const & geometry2

Calculates the relation between a pair of geometries as defined in DE-9IM.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

The DE-9IM matrix expressing the relation between geometries.

[include reference/algorithms/relation.qbk]
typename Geometry
void void boost::geometry::remove_spikes (Geometry &geometry) remove_spikes Geometry & geometry

Geometry

geometry type

geometry

the geometry to make remove_spikes

typename Output
typename Input
typename Distance
Output Output boost::geometry::return_buffer (Input const &geometry, Distance const &distance, Distance const &chord_length=-1) return_buffer Input const & geometry Distance const & distance Distance const & chord_length -1

Calculates the buffer of a geometry.

The free function return_buffer calculates the buffer (a polygon being the spatial point set collection within a specified maximum distance from a geometry) of a geometry. This version with the return_ prefix returns the buffer, and a template parameter must therefore be specified in the call.. Input

Any type fulfilling a Geometry Concept

Output

Any type fulfilling a Geometry Concept

Distance

numerical type (int, double, ttmath, ...)

geometry

A model of the specified concept

distance

The distance to be used for the buffer

chord_length

(optional) The length of the chord's in the generated arcs around points or bends (RESERVED, NOT YET USED)

The calculated \1

typename Point
typename Geometry
Point Point boost::geometry::return_centroid (Geometry const &geometry) return_centroid Geometry const & geometry

Calculates the centroid of a geometry.

The free function centroid calculates the geometric center (or: center of mass) of a geometry. This version with the return_ prefix returns the centroid, and a template parameter must therefore be specified in the call.. Point

Any type fulfilling a Point Concept

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

The calculated \1

[include reference/algorithms/centroid.qbk]
typename Point
typename Geometry
typename Strategy
Point Point boost::geometry::return_centroid (Geometry const &geometry, Strategy const &strategy) return_centroid Geometry const & geometry Strategy const & strategy

Calculates the centroid of a geometry using the specified strategy.

The free function centroid calculates the geometric center (or: center of mass) of a geometry. This version with the return_ prefix returns the centroid, and a template parameter must therefore be specified in the call.. Reasons to specify a strategy include: use another coordinate system for calculations; construct the strategy beforehand (e.g. with the radius of the Earth); select a strategy when there are more than one available for a calculation. Point

Any type fulfilling a Point Concept

Geometry

Any type fulfilling a Geometry Concept

Strategy

Any type fulfilling a centroid Strategy Concept

geometry

A model of the specified concept

strategy

The strategy which will be used for centroid calculations

The calculated \1

with strategy [include reference/algorithms/centroid.qbk] [include reference/algorithms/centroid_strategies.qbk]
typename Box
typename Geometry
Box Box boost::geometry::return_envelope (Geometry const &geometry) return_envelope Geometry const & geometry

Calculates the envelope of a geometry.

The free function return_envelope calculates the envelope (also known as axis aligned bounding box, aabb, or minimum bounding rectangle, mbr) of a geometry. This version with the return_ prefix returns the envelope, and a template parameter must therefore be specified in the call. Box

Any type fulfilling a Box Concept

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

The calculated \1

[include reference/algorithms/envelope.qbk] [heading Example] [return_envelope] [return_envelope_output]
typename Geometry
geometry::point_type< Geometry >::type geometry::point_type<Geometry>::type boost::geometry::return_point_on_surface (Geometry const &geometry) return_point_on_surface Geometry const & geometry

Returns point guaranteed to lie on the surface of the Geometry.

Geometry

geometry type. This also defines the type of the output point

geometry

Geometry to take point from

The Point guaranteed to lie on the surface of the Geometry

typename Geometry
void void boost::geometry::reverse (Geometry &geometry) reverse Geometry & geometry

Reverses the points within a geometry.

Generic function to reverse a geometry. It resembles the std::reverse functionality, but it takes the geometry type into account. Only for a ring or for a linestring it is the same as the std::reverse.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept which will be reversed

[include reference/algorithms/reverse.qbk]
bool Reverse Reverse
typename DimensionVector
typename Geometry
typename Sections
typename RobustPolicy
void void boost::geometry::sectionalize (Geometry const &geometry, RobustPolicy const &robust_policy, Sections &sections, int source_index=0, std::size_t max_count=10) sectionalize Geometry const & geometry RobustPolicy const & robust_policy Sections & sections int source_index 0 std::size_t max_count 10

Split a geometry into monotonic sections.

Geometry

type of geometry to check

Sections

type of sections to create

geometry

geometry to create sections from

robust_policy

policy to handle robustness issues

sections

structure with sections

source_index

index to assign to the ring_identifiers

max_count

maximal number of points per section (defaults to 10, this seems to give the fastest results)

typename Geometry
segment_iterator< Geometry const > segment_iterator<Geometry const> boost::geometry::segments_begin (Geometry const &geometry) segments_begin Geometry const & geometry
typename Geometry
segment_iterator< Geometry const > segment_iterator<Geometry const> boost::geometry::segments_end (Geometry const &geometry) segments_end Geometry const & geometry
typename AssignPolicy
typename Geometry
typename RobustPolicy
typename Turns
typename InterruptPolicy
void void boost::geometry::self_turns (Geometry const &geometry, RobustPolicy const &robust_policy, Turns &turns, InterruptPolicy &interrupt_policy) self_turns Geometry const & geometry RobustPolicy const & robust_policy Turns & turns InterruptPolicy & interrupt_policy

Calculate self intersections of a geometry.

Geometry

geometry type

Turns

type of intersection container (e.g. vector of "intersection/turn point"'s)

geometry

geometry

robust_policy

policy to handle robustness issues

turns

container which will contain intersection points

interrupt_policy

policy determining if process is stopped when intersection is found

std::size_t Dimension Dimension
typename Geometry
void void boost::geometry::set (Geometry &geometry, typename coordinate_type< Geometry >::type const &value) set Geometry & geometry typename coordinate_type< Geometry >::type const & value

Set coordinate value of a geometry (usually a point)

The free functions [*get] and [*set] are two of the most important functions of Boost.Geometry, both within the library, as also for the library user. With these two functions you normally get and set coordinate values from and for a point, box, segment or sphere. Dimension

Dimension, this template parameter is required. Should contain \[0 .. n-1\] for an n-dimensional geometry

Geometry

Any type fulfilling a Geometry Concept (usually a Point Concept)

geometry

geometry to assign coordinate to

geometry

A model of the specified concept (usually a point)

value

The coordinate value to set

[include reference/core/set_point.qbk]
std::size_t Index Index
std::size_t Dimension Dimension
typename Geometry
void void boost::geometry::set (Geometry &geometry, typename coordinate_type< Geometry >::type const &value) set Geometry & geometry typename coordinate_type< Geometry >::type const & value

set coordinate value of a Box / Segment

The free functions [*get] and [*set] are two of the most important functions of Boost.Geometry, both within the library, as also for the library user. With these two functions you normally get and set coordinate values from and for a point, box, segment or sphere. Index

Index, this template parameter is required. For a Box: either min_corner or max_corner. For a Segment: either 0 or 1 for first or last point.

Dimension

Dimension, this template parameter is required. Should contain \[0 .. n-1\] for an n-dimensional geometry

Geometry

Any type fulfilling a Box Concept or a Segment Concept

geometry

geometry to assign coordinate to

geometry

A model of the specified concept

value

The coordinate value to set

with index [include reference/core/set_box.qbk]
std::size_t Dimension Dimension
typename Geometry
void void boost::geometry::set_from_radian (Geometry &geometry, typename fp_coordinate_type< Geometry >::type const &radians) set_from_radian Geometry & geometry typename fp_coordinate_type< Geometry >::type const & radians

set coordinate value (in radian) to a point

Coordinate value will be set correctly, if coordinate system of point is in Degree, Radian value will be converted to Degree

Dimension

dimension

Geometry

geometry

geometry

geometry to assign coordinate to

radians

coordinate value to assign

Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems

std::size_t I I
typename Geometry
void void boost::geometry::set_radius (Geometry &geometry, typename radius_type< Geometry >::type const &radius) set_radius Geometry & geometry typename radius_type< Geometry >::type const & radius

Function to set the radius of a circle / sphere / ellipse / etc.

I

index of the axis

geometry

the geometry to change

radius

the radius to set

typename Geometry
typename Distance
typename Strategy
void void boost::geometry::simplify (Geometry const &geometry, Geometry &out, Distance const &max_distance, Strategy const &strategy) simplify Geometry const & geometry Geometry & out Distance const & max_distance Strategy const & strategy

Simplify a geometry using a specified strategy.

Geometry

Any type fulfilling a Geometry Concept

Distance

A numerical distance measure

Strategy

A type fulfilling a SimplifyStrategy concept

strategy

A strategy to calculate simplification

geometry

input geometry, to be simplified

out

output geometry, simplified version of the input geometry

max_distance

distance (in units of input coordinates) of a vertex to other segments to be removed

strategy

simplify strategy to be used for simplification, might include point-distance strategy

The image below presents the simplified country with strategy
typename Geometry
typename Distance
void void boost::geometry::simplify (Geometry const &geometry, Geometry &out, Distance const &max_distance) simplify Geometry const & geometry Geometry & out Distance const & max_distance

Simplify a geometry.

Geometry

Any type fulfilling a Geometry Concept

Distance

numerical type (int, double, ttmath, ...)

This version of simplify simplifies a geometry using the default strategy (Douglas Peucker),

geometry

input geometry, to be simplified

out

output geometry, simplified version of the input geometry

max_distance

distance (in units of input coordinates) of a vertex to other segments to be removed

[include reference/algorithms/simplify.qbk]
typename Point1
typename Point2
void void boost::geometry::subtract_point (Point1 &p1, Point2 const &p2) subtract_point Point1 & p1 Point2 const & p2

Subtracts a point to another.

The coordinates of the second point will be subtracted to those of the first point. The second point is not modified. Point1

Any type fulfilling a Point Concept

Point2

Any type fulfilling a Point Concept

p1

first point

p2

second point

typename Point
void void boost::geometry::subtract_value (Point &p, typename detail::param< Point >::type value) subtract_value Point & p typename detail::param< Point >::type value

Subtracts the same value to each coordinate of a point.

Point

Any type fulfilling a Point Concept

p

point

value

value to subtract

typename Geometry
svg_manipulator< Geometry > svg_manipulator<Geometry> boost::geometry::svg (Geometry const &geometry, std::string const &style, int size=-1) svg Geometry const & geometry std::string const & style int size -1

Manipulator to stream geometries as SVG.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

style

String containing verbatim SVG style information

size

Optional size (used for SVG points) in SVG pixels. For linestrings, specify linewidth in the SVG style information

typename Geometry
typename TransformStrategy
void void boost::geometry::svg_map (std::ostream &stream, std::string const &style, int size, Geometry const &geometry, TransformStrategy const &strategy) svg_map std::ostream & stream std::string const & style int size Geometry const & geometry TransformStrategy const & strategy
typename Range
typename PriorityQueue
typename InitializationVisitor
typename EventVisitor
typename InterruptPolicy
void void boost::geometry::sweep (Range const &range, PriorityQueue &queue, InitializationVisitor &initialization_visitor, EventVisitor &event_visitor, InterruptPolicy const &interrupt_policy) sweep Range const & range PriorityQueue & queue InitializationVisitor & initialization_visitor EventVisitor & event_visitor InterruptPolicy const & interrupt_policy
typename Range
typename PriorityQueue
typename InitializationVisitor
typename EventVisitor
void void boost::geometry::sweep (Range const &range, PriorityQueue &queue, InitializationVisitor &initialization_visitor, EventVisitor &event_visitor) sweep Range const & range PriorityQueue & queue InitializationVisitor & initialization_visitor EventVisitor & event_visitor
typename Geometry1
typename Geometry2
typename Collection
void void boost::geometry::sym_difference (Geometry1 const &geometry1, Geometry2 const &geometry2, Collection &output_collection) sym_difference Geometry1 const & geometry1 Geometry2 const & geometry2 Collection & output_collection

Calculate the symmetric difference of two geometries.

The free function symmetric difference calculates the spatial set theoretic symmetric difference (XOR) of two geometries. Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

Collection

output collection, either a multi-geometry, or a std::vector<Geometry> / std::deque<Geometry> etc

geometry1

A model of the specified concept

geometry2

A model of the specified concept

output_collection

the output collection

[include reference/algorithms/sym_difference.qbk]
typename Geometry
bool bool boost::geometry::touches (Geometry const &geometry) touches Geometry const & geometry

Checks if a geometry \1.

This function can be called for one geometry (self-tangency) and also for two geometries (touch)

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

Returns true if the geometry \1

one geometry [def __one_parameter__] [include reference/algorithms/touches.qbk]
typename Geometry1
typename Geometry2
bool bool boost::geometry::touches (Geometry1 const &geometry1, Geometry2 const &geometry2) touches Geometry1 const & geometry1 Geometry2 const & geometry2

Checks if two geometries \1.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

Returns true if two geometries \1

two geometries [include reference/algorithms/touches.qbk]
typename Geometry1
typename Geometry2
typename Strategy
bool bool boost::geometry::transform (Geometry1 const &geometry1, Geometry2 &geometry2, Strategy const &strategy) transform Geometry1 const & geometry1 Geometry2 & geometry2 Strategy const & strategy

Transforms from one geometry to another geometry using the specified strategy.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

Strategy

strategy

geometry1

A model of the specified concept

geometry2

A model of the specified concept

strategy

The strategy to be used for transformation

True if the transformation could be done

with strategy

[include reference/algorithms/transform_with_strategy.qbk]

typename Geometry1
typename Geometry2
bool bool boost::geometry::transform (Geometry1 const &geometry1, Geometry2 &geometry2) transform Geometry1 const & geometry1 Geometry2 & geometry2

Transforms from one geometry to another geometry using a strategy.

Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept

geometry2

A model of the specified concept

True if the transformation could be done

[include reference/algorithms/transform.qbk]
typename Geometry1
typename Geometry2
typename Collection
void void boost::geometry::union_ (Geometry1 const &geometry1, Geometry2 const &geometry2, Collection &output_collection) union_ Geometry1 const & geometry1 Geometry2 const & geometry2 Collection & output_collection

Combines two geometries which each other.

The free function union calculates the spatial set theoretic union of two geometries. Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

Collection

output collection, either a multi-geometry, or a std::vector<Geometry> / std::deque<Geometry> etc

geometry1

A model of the specified concept

geometry2

A model of the specified concept

output_collection

the output collection

Called union_ because union is a reserved word.

[include reference/algorithms/union.qbk]
typename Geometry
void void boost::geometry::unique (Geometry &geometry) unique Geometry & geometry

Calculates the minimal set of a geometry.

The free function unique calculates the minimal set (where duplicate consecutive points are removed) of a geometry. Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept which will be made unique

[include reference/algorithms/unique.qbk]
char char boost::geometry::visited_char (detail::overlay::visit_info const &v) visited_char detail::overlay::visit_info const & v
typename Geometry1
typename Geometry2
bool bool boost::geometry::within (Geometry1 const &geometry1, Geometry2 const &geometry2) within Geometry1 const & geometry1 Geometry2 const & geometry2

Checks if the first geometry is completely inside the second geometry.

The free function within checks if the first geometry is completely inside the second geometry. Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept which might be within the second geometry

geometry2

A model of the specified concept which might contain the first geometry

true if geometry1 is completely contained within geometry2, else false

The default strategy is used for within detection

[include reference/algorithms/within.qbk]

[heading Example] [within] [within_output]

typename Geometry1
typename Geometry2
typename Strategy
bool bool boost::geometry::within (Geometry1 const &geometry1, Geometry2 const &geometry2, Strategy const &strategy) within Geometry1 const & geometry1 Geometry2 const & geometry2 Strategy const & strategy

Checks if the first geometry is completely inside the second geometry using the specified strategy.

The free function within checks if the first geometry is completely inside the second geometry, using the specified strategy. Reasons to specify a strategy include: use another coordinate system for calculations; construct the strategy beforehand (e.g. with the radius of the Earth); select a strategy when there are more than one available for a calculation. Geometry1

Any type fulfilling a Geometry Concept

Geometry2

Any type fulfilling a Geometry Concept

geometry1

A model of the specified concept which might be within the second geometry

geometry2

A model of the specified concept which might contain the first geometry

strategy

strategy to be used

true if geometry1 is completely contained within geometry2, else false

with strategy [include reference/algorithms/within.qbk] [heading Available Strategies] \* [link geometry.reference.strategies.strategy_within_winding Winding (coordinate system agnostic)] \* [link geometry.reference.strategies.strategy_within_franklin Franklin (cartesian)] \* [link geometry.reference.strategies.strategy_within_crossings_multiply Crossings Multiply (cartesian)] [heading Example] [within_strategy] [within_strategy_output]
typename Geometry
wkt_manipulator< Geometry > wkt_manipulator<Geometry> boost::geometry::wkt (Geometry const &geometry) wkt Geometry const & geometry

Main WKT-streaming function.

Geometry

Any type fulfilling a Geometry Concept

geometry

A model of the specified concept

[include reference/io/wkt.qbk]