|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r60573 - sandbox/geometry/libs/geometry/doc/quickbook
From: mateusz_at_[hidden]
Date: 2010-03-13 23:30:42
Author: mloskot
Date: 2010-03-13 23:30:40 EST (Sat, 13 Mar 2010)
New Revision: 60573
URL: http://svn.boost.org/trac/boost/changeset/60573
Log:
Geometry: in quickbook docs moved Arithmetic sectoin below Algorithms and added two sections Strategy Concepts and Strategies - part of docs review suggestions. Fixed rendering of class details, added heading.
Text files modified:
sandbox/geometry/libs/geometry/doc/quickbook/quickref.xml | 37
sandbox/geometry/libs/geometry/doc/quickbook/reference.qbk | 16333 ++++++++++++++++++++++++++++++++-------
sandbox/geometry/libs/geometry/doc/quickbook/reference.xsl | 18
3 files changed, 13137 insertions(+), 3251 deletions(-)
Modified: sandbox/geometry/libs/geometry/doc/quickbook/quickref.xml
==============================================================================
--- sandbox/geometry/libs/geometry/doc/quickbook/quickref.xml (original)
+++ sandbox/geometry/libs/geometry/doc/quickbook/quickref.xml 2010-03-13 23:30:40 EST (Sat, 13 Mar 2010)
@@ -362,8 +362,41 @@
</tbody>
</tgroup>
+<!-- ###### STRATEGY CONCEPTS ################################################################## -->
+<tgroup cols="2">
+ <colspec colname="a"/>
+ <colspec colname="b"/>
+ <thead>
+ <row>
+ <entry valign="center" namest="a" nameend="b">
+ <bridgehead renderas="sect2">Strategy Concepts</bridgehead>
+ </entry>
+ </row>
+ </thead>
+ <tbody>
+ <row>
+ <entry valign="top">
+ <simplelist type="vert" columns="1">
+ <member><link linkend="boost_geometry.reference.concept__AreaStrategy">boost::geometry::concept::AreaStrategy</link></member>
+ <member><link linkend="boost_geometry.reference.concept__CentroidStrategy">boost::geometry::concept::CentroidStrategy</link></member>
+ <member><link linkend="boost_geometry.reference.concept__ConvexHullStrategy">boost::geometry::concept::ConvexHullStrategy</link></member>
+ <member><link linkend="boost_geometry.reference.concept__PointDistanceStrategy">boost::geometry::concept::PointDistanceStrategy</link></member>
+ <member><link linkend="boost_geometry.reference.concept__PointSegmentDistanceStrategy">boost::geometry::concept::PointSegmentDistanceStrategy</link></member>
+ </simplelist>
+ </entry>
+ <entry valign="top">
+ <simplelist type="vert" columns="1">
+ <member><link linkend="boost_geometry.reference.concept__SegmentIntersectStrategy">boost::geometry::concept::SegmentIntersectStrategy</link></member>
+ <member><link linkend="boost_geometry.reference.concept__SimplifyStrategy">boost::geometry::concept::SimplifyStrategy</link></member>
+ <member><link linkend="boost_geometry.reference.concept__WithinStrategy">boost::geometry::concept::WithinStrategy</link></member>
+ </simplelist>
+ </entry>
+ </row>
+ </tbody>
+</tgroup>
+
<!-- ###### STRATEGIES ######################################################################### -->
-<tgroup cols="4">
+<tgroup cols="3">
<colspec colname="a"/>
<colspec colname="b"/>
<colspec colname="c"/>
@@ -379,6 +412,8 @@
<entry valign="top">
<bridgehead renderas="sect3">Area</bridgehead>
<simplelist type="vert" columns="1">
+ <member><link linkend="boost_geometry.reference.strategy_area">boost::geometry::strategy_area</link></member>
+
<member><link linkend="boost_geometry.reference.strategy_area">boost::geometry::strategy_area</link></member>
<member><link linkend="boost_geometry.reference.area_result">boost::geometry::area_result</link></member>
<member><link linkend="boost_geometry.reference.strategy__area__by_triangles">boost::geometry::strategy::area::by_triangles</link></member>
Modified: sandbox/geometry/libs/geometry/doc/quickbook/reference.qbk
==============================================================================
--- sandbox/geometry/libs/geometry/doc/quickbook/reference.qbk (original)
+++ sandbox/geometry/libs/geometry/doc/quickbook/reference.qbk 2010-03-13 23:30:40 EST (Sat, 13 Mar 2010)
@@ -17,7 +17,7 @@
[section:add_point add_point]
[indexterm1 add_point]
-Adds a point to another.
+Adds a [link boost_geometry.reference.point `point`] to another.
template<
@@ -28,15 +28,15 @@
Point2 const & p2);
-The coordinates of the second point will be added to those of the first point. The second point is not modified.
+The coordinates of the second [link boost_geometry.reference.point `point`] will be added to those of the first [link boost_geometry.reference.point `point`]. The second [link boost_geometry.reference.point `point`] is not modified.
[heading Parameters]
[variablelist
-[[p1][first point ]]
+[[p1][first [link boost_geometry.reference.point `point`] ]]
-[[p2][second point ]]
+[[p2][second [link boost_geometry.reference.point `point`] ]]
]
@@ -56,7 +56,7 @@
[section:add_value add_value]
[indexterm1 add_value]
-Adds a value to each coordinate of a point.
+Adds a value to each coordinate of a [link boost_geometry.reference.point `point`].
template<
@@ -72,7 +72,7 @@
[variablelist
-[[p][point ]]
+[[p][[link boost_geometry.reference.point `point`] ]]
[[value][value to add ]]
@@ -94,7 +94,7 @@
[section:append append]
[indexterm1 append]
-Appends one or more points to a linestring, ring, polygon, multi.
+Appends one or more points to a [link boost_geometry.reference.linestring `linestring`], ring, [link boost_geometry.reference.polygon `polygon`], multi.
template<
@@ -113,11 +113,11 @@
[variablelist
-[[geometry][a geometry ]]
+[[geometry][a [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[range_or_point][the point or range to add ]]
+[[range_or_point][the [link boost_geometry.reference.point `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 ]]
+[[ring_index][the index of the ring in case of a [link boost_geometry.reference.polygon `polygon`]: exterior ring (-1, the default) or interior ring index ]]
[[multi_index][reserved for multi polygons ]]
@@ -189,7 +189,7 @@
[section:overload1 area (1 of 2 overloads)]
-Calculate area of a geometry.
+Calculate area of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
template<
@@ -198,13 +198,13 @@
Geometry const & geometry);
-The function area returns the area of a polygon, ring, box using the default area-calculation strategy. Strategies are provided for cartesian and spherical coordinate systems The geometries should correct, polygons should be closed and according to the specified orientation (clockwise/counter clockwise)
+The function area returns the area of a [link boost_geometry.reference.polygon `polygon`], ring, [link boost_geometry.reference.box `box`] using the default area-calculation [link boost_geometry.reference.strategy `strategy`]. Strategies are provided for cartesian and spherical coordinate systems The geometries should correct, polygons should be closed and according to the specified orientation (clockwise/counter clockwise)
[heading Parameters]
[variablelist
-[[geometry][a geometry ]]
+[[geometry][a [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -223,7 +223,7 @@
[section:overload2 area (2 of 2 overloads)]
-Calculate area of a geometry using a specified strategy.
+Calculate area of a [link boost_geometry.reference.boost__geometry `boost::geometry`] using a specified [link boost_geometry.reference.strategy `strategy`].
template<
@@ -234,15 +234,15 @@
Strategy const & strategy);
-This version of area calculation takes a strategy
+This version of area calculation takes a [link boost_geometry.reference.strategy `strategy`]
[heading Parameters]
[variablelist
-[[geometry][a geometry ]]
+[[geometry][a [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[strategy][the strategy to calculate area. Especially for spherical areas there are some approaches. ]]
+[[strategy][the [link boost_geometry.reference.strategy `strategy`] to calculate area. Especially for spherical areas there are some approaches. ]]
]
@@ -259,6 +259,173 @@
[endsect]
+[section:area_result area_result]
+
+
+Meta-function defining return type of area function.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename ``[link boost_geometry.reference.Geometry Geometry]``>
+ struct area_result
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.area_result.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.area_result.strategy_type [*strategy_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.area_result.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Description]
+
+
+[heading Remarks]
+
+The [link boost_geometry.reference.strategy `strategy`] defines the return-type (so this situation is different from length, where distance is sqr/sqrt, but length always squared)
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/area_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:point_type area_result::point_type]
+
+[indexterm2 point_type..area_result]
+
+ typedef point_type< Geometry >::type point_type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point_type.ncg [*ncg]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/area_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:strategy_type area_result::strategy_type]
+
+[indexterm2 strategy_type..area_result]
+
+ typedef strategy_area< typename cs_tag< point_type >::type, point_type >::type strategy_type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy_area.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system ]]
+
+[[PointOfSegment][point-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/area_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:type area_result::type]
+
+[indexterm2 type..area_result]
+
+ typedef strategy_type::return_type type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/area_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
[section:assert_dimension assert_dimension]
@@ -352,7 +519,7 @@
[section:assign assign]
[indexterm1 assign]
-assign two values to a 2D point
+assign two values to a 2D [link boost_geometry.reference.point `point`]
template<
@@ -403,7 +570,7 @@
[section:overload1 assign (1 of 4 overloads)]
-assign two values to a 2D point
+assign two values to a 2D [link boost_geometry.reference.point `point`]
template<
@@ -423,7 +590,7 @@
[section:overload2 assign (2 of 4 overloads)]
-assign three values to a 3D point [or the center + radius to a circle]
+assign three values to a 3D [link boost_geometry.reference.point `point`] [or the center + radius to a circle]
template<
@@ -466,7 +633,7 @@
[section:overload4 assign (4 of 4 overloads)]
-assign a range of points to a linestring, ring or polygon
+assign a range of points to a [link boost_geometry.reference.linestring `linestring`], ring or [link boost_geometry.reference.polygon `polygon`]
template<
@@ -480,7 +647,7 @@
[heading Remarks]
-The point-type of the range might be different from the point-type of the geometry
+The point-type of the range might be different from the point-type of the [link boost_geometry.reference.boost__geometry `boost::geometry`]
@@ -494,7 +661,7 @@
[section:assign_box_corners assign_box_corners]
[indexterm1 assign_box_corners]
-Assign the 4 points of a 2D box.
+Assign the 4 points of a 2D [link boost_geometry.reference.box `box`].
template<
@@ -529,7 +696,7 @@
[section:assign_inverse assign_inverse]
[indexterm1 assign_inverse]
-assign to a box inverse infinite
+assign to a [link boost_geometry.reference.box `box`] inverse infinite
template<
@@ -538,7 +705,7 @@
Geometry & geometry);
-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.
+The assign\_inverse function initialize a 2D or 3D [link boost_geometry.reference.box `box`] with large coordinates, the min corner is very large, the max corner is very small. This is a convenient `starting` [link boost_geometry.reference.point `point`] to collect the minimum bounding [link boost_geometry.reference.box `box`] of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
[heading Requirements]
@@ -554,7 +721,7 @@
[section:assign_point_from_index assign_point_from_index]
[indexterm1 assign_point_from_index]
-Assign a point with a point of a box or segment.
+Assign a [link boost_geometry.reference.point `point`] with a [link boost_geometry.reference.point `point`] of a [link boost_geometry.reference.box `box`] or [link boost_geometry.reference.segment `segment`].
template<
@@ -570,7 +737,7 @@
[variablelist
-[[Index][indicates which box-corner, min\_corner (0) or max\_corner (1) or which point of segment (0/1) ]]
+[[Index][indicates which box-corner, min\_corner (0) or max\_corner (1) or which [link boost_geometry.reference.point `point`] of [link boost_geometry.reference.segment `segment`] (0/1) ]]
]
@@ -590,7 +757,7 @@
[section:assign_point_to_index assign_point_to_index]
[indexterm1 assign_point_to_index]
-Assign a box or segment with the value of a point.
+Assign a [link boost_geometry.reference.box `box`] or [link boost_geometry.reference.segment `segment`] with the value of a [link boost_geometry.reference.point `point`].
template<
@@ -606,7 +773,7 @@
[variablelist
-[[Index][indicates which box-corner, min\_corner (0) or max\_corner (1) or which point of segment (0/1) ]]
+[[Index][indicates which box-corner, min\_corner (0) or max\_corner (1) or which [link boost_geometry.reference.point `point`] of [link boost_geometry.reference.segment `segment`] (0/1) ]]
]
@@ -626,7 +793,7 @@
[section:assign_zero assign_zero]
[indexterm1 assign_zero]
-assign zero values to a box, point
+assign zero values to a [link boost_geometry.reference.box `box`], [link boost_geometry.reference.point `point`]
template<
@@ -635,11 +802,11 @@
Geometry & geometry);
-The assign\_zero function initializes a 2D or 3D point or box with coordinates of zero
+The assign\_zero function initializes a 2D or 3D [link boost_geometry.reference.point `point`] or [link boost_geometry.reference.box `box`] with coordinates of zero
[variablelist
-[[Geometry][the geometry type ]]
+[[Geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
]
@@ -658,12 +825,16 @@
[section:box box]
-Class box: defines a box made of two describing points.
+Class [link boost_geometry.reference.box `box`]: defines a [link boost_geometry.reference.box `box`] made of two describing points.
+
+
+[heading Synopsis]
template<
typename Point >
class box
+
[heading Public Member Functions]
[table
[[Name][Description]]
@@ -687,16 +858,19 @@
]
-Box is always described by a `min_corner()` and a `max_corner()` point. If another rectangle is used, use [link boost_geometry.reference.linear_ring `linear_ring`] or polygon.
+
+[heading Description]
+
+Box is always described by a `min_corner()` and a `max_corner()` [link boost_geometry.reference.point `point`]. If another rectangle is used, use [link boost_geometry.reference.linear_ring `linear_ring`] or [link boost_geometry.reference.polygon `polygon`].
[heading Remarks]
-Boxes are for selections and for calculating the envelope of geometries. Not all algorithms are implemented for box. Boxes are also used in Spatial Indexes.
+Boxes are for selections and for calculating the envelope of geometries. Not all algorithms are implemented for [link boost_geometry.reference.box `box`]. Boxes are also used in Spatial Indexes.
[variablelist
-[[Point][point type. The box takes a point type as template parameter. The point type can be any point type. It can be 2D but can also be 3D or more dimensional. The box can also take a latlong point type as template parameter. ]]
+[[Point][[link boost_geometry.reference.point `point`] type. The [link boost_geometry.reference.box `box`] takes a [link boost_geometry.reference.point `point`] type as template parameter. The [link boost_geometry.reference.point `point`] type can be any [link boost_geometry.reference.point `point`] type. It can be 2D but can also be 3D or more dimensional. The [link boost_geometry.reference.box `box`] can also take a latlong [link boost_geometry.reference.point `point`] type as template parameter. ]]
]
@@ -716,7 +890,7 @@
`` [''''»''' [link boost_geometry.reference.box.box.overload1 more...]]``
-Constructor taking the minimum corner point and the maximum corner point.
+Constructor taking the minimum corner [link boost_geometry.reference.point `point`] and the maximum corner [link boost_geometry.reference.point `point`].
``[link boost_geometry.reference.box.box.overload2 box]``(
@@ -740,7 +914,7 @@
[section:overload2 box::box (2 of 2 overloads)]
-Constructor taking the minimum corner point and the maximum corner point.
+Constructor taking the minimum corner [link boost_geometry.reference.point `point`] and the maximum corner [link boost_geometry.reference.point `point`].
box(
@@ -837,6 +1011,7 @@
typedef box< point_2d > box_2d;
+
[heading Public Member Functions]
[table
[[Name][Description]]
@@ -862,16 +1037,16 @@
[heading Typedef Description]
-Box is always described by a `min_corner()` and a `max_corner()` point. If another rectangle is used, use [link boost_geometry.reference.linear_ring `linear_ring`] or polygon.
+Box is always described by a `min_corner()` and a `max_corner()` [link boost_geometry.reference.point `point`]. If another rectangle is used, use [link boost_geometry.reference.linear_ring `linear_ring`] or [link boost_geometry.reference.polygon `polygon`].
[heading Remarks]
-Boxes are for selections and for calculating the envelope of geometries. Not all algorithms are implemented for box. Boxes are also used in Spatial Indexes.
+Boxes are for selections and for calculating the envelope of geometries. Not all algorithms are implemented for [link boost_geometry.reference.box `box`]. Boxes are also used in Spatial Indexes.
[variablelist
-[[Point][point type. The box takes a point type as template parameter. The point type can be any point type. It can be 2D but can also be 3D or more dimensional. The box can also take a latlong point type as template parameter. ]]
+[[Point][[link boost_geometry.reference.point `point`] type. The [link boost_geometry.reference.box `box`] takes a [link boost_geometry.reference.point `point`] type as template parameter. The [link boost_geometry.reference.point `point`] type can be any [link boost_geometry.reference.point `point`] type. It can be 2D but can also be 3D or more dimensional. The [link boost_geometry.reference.box `box`] can also take a latlong [link boost_geometry.reference.point `point`] type as template parameter. ]]
]
@@ -896,6 +1071,7 @@
typedef box< point_3d > box_3d;
+
[heading Public Member Functions]
[table
[[Name][Description]]
@@ -921,16 +1097,16 @@
[heading Typedef Description]
-Box is always described by a `min_corner()` and a `max_corner()` point. If another rectangle is used, use [link boost_geometry.reference.linear_ring `linear_ring`] or polygon.
+Box is always described by a `min_corner()` and a `max_corner()` [link boost_geometry.reference.point `point`]. If another rectangle is used, use [link boost_geometry.reference.linear_ring `linear_ring`] or [link boost_geometry.reference.polygon `polygon`].
[heading Remarks]
-Boxes are for selections and for calculating the envelope of geometries. Not all algorithms are implemented for box. Boxes are also used in Spatial Indexes.
+Boxes are for selections and for calculating the envelope of geometries. Not all algorithms are implemented for [link boost_geometry.reference.box `box`]. Boxes are also used in Spatial Indexes.
[variablelist
-[[Point][point type. The box takes a point type as template parameter. The point type can be any point type. It can be 2D but can also be 3D or more dimensional. The box can also take a latlong point type as template parameter. ]]
+[[Point][[link boost_geometry.reference.point `point`] type. The [link boost_geometry.reference.box `box`] takes a [link boost_geometry.reference.point `point`] type as template parameter. The [link boost_geometry.reference.point `point`] type can be any [link boost_geometry.reference.point `point`] type. It can be 2D but can also be 3D or more dimensional. The [link boost_geometry.reference.box `box`] can also take a latlong [link boost_geometry.reference.point `point`] type as template parameter. ]]
]
@@ -950,10 +1126,16 @@
[section:box_tag box_tag]
-Convenience 2D or 3D box (mbr) identifying tag.
+Convenience 2D or 3D [link boost_geometry.reference.box `box`] (mbr) identifying [link boost_geometry.reference.tag `tag`].
+
+
+[heading Synopsis]
struct box_tag
+
+[heading Description]
+
[heading Requirements]
[*Header: ][^boost/geometry/core/tags.hpp]
@@ -967,7 +1149,7 @@
[section:buffer buffer]
[indexterm1 buffer]
-Calculate buffer (= new geometry) around specified distance of geometry.
+Calculate buffer (= new [link boost_geometry.reference.boost__geometry `boost::geometry`]) around specified distance of [link boost_geometry.reference.boost__geometry `boost::geometry`].
template<
@@ -987,20 +1169,20 @@
[variablelist
-[[geometry_in][input geometry ]]
+[[geometry_in][input [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
[[distance][the distance used in buffer ]]
[[chord_length][length of the chord's in the generated arcs around points or bends ]]
-[[geometry_out][buffered geometry ]]
+[[geometry_out][buffered [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
[heading Remarks]
-Currently only implemented for box, the trivial case, but still useful
+Currently only implemented for [link boost_geometry.reference.box `box`], the trivial case, but still useful
[heading Use case:]
@@ -1019,121 +1201,330 @@
[endsect]
-[section:cartesian_tag cartesian_tag]
-
-
-Tag indicating Cartesian coordinate system family (cartesian,epsg).
-
-
- struct cartesian_tag
-[heading Requirements]
-
-[*Header: ][^boost/geometry/core/tags.hpp]
+[section:cartesian_distance cartesian_distance]
-[*Convenience header: ][^boost/geometry.hpp]
+Encapsulate the results of distance calculation.
-[endsect]
-[section:centroid centroid]
-[indexterm1 centroid]
-
- template<
- typename Geometry ,
- typename Point ,
- typename Strategy >
- void ``[link boost_geometry.reference.centroid.overload1 centroid]``(
- Geometry const & geometry,
- Point & c,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.centroid.overload1 more...]]``
+[heading Synopsis]
template<
- typename Geometry ,
- typename Point >
- void ``[link boost_geometry.reference.centroid.overload2 centroid]``(
- Geometry const & geometry,
- Point & c);
- `` [''''»''' [link boost_geometry.reference.centroid.overload2 more...]]``
+ typename T = double>
+ struct cartesian_distance
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
-[heading Source descriptions:]
+ [
+ [[link boost_geometry.reference.cartesian_distance.cartesian_distance [*cartesian_distance]]]
+ [Constructor with a value. ]
+ ]
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_cast_type [*operator cast_type]]]
+ [Automatic conversion to double or higher precision, taking squareroot if necessary. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_lt_ [*operator<]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_eq__eq_ [*operator==]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_gt_ [*operator>]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.squared_value [*squared_value]]]
+ [The "squared_value" method returns the internal squared value. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.very_small [*very_small]]]
+ []
+ ]
+
+]
-* OGC description: The mathematical centroid for this Surface as a Point. The result is not guaranteed to be on this Surface.
-
-* From Wikipedia: Informally, it is the "average" of all points
-
+[heading Friends]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_lt__lt_ [*operator<<]]]
+ [Make streamable to enable std::cout << geometry::distance( ). ]
+ ]
+
+]
+[heading Description]
+Distance calculation for xy points or xyz points is done by taking the square root. However, for distance comparison drawing the square root is not necessary. Therefore the distance strategies are allowed to return the squares of the distance. This structure contains the distance, and a boolean to indicate if it is squared. It has an automatic conversion to a double value, which does the square root if necessary.
[heading Remarks]
-Polygon should be closed, and can be orientated either way
+Thanks to Phil Endecott for his suggestion to change the pair to the double-convertable http://article.gmane.org/gmane.comp.lib.boost.devel/172709/match=greatcircle\_distance
-The "centroid" functions are taking a non const reference to the centroid. The "make\_centroid" functions return the centroid, the type has to be specified.
-Both of them have an overloaded version where a centroid calculation strategy can be specified
+[heading Requirements]
-[heading Exceptions]
-
+[*Header: ][^boost/geometry/strategies/distance_result.hpp]
-[variablelist
-
-[[centroid_exception][if calculation is not successful, e.g. because polygon didn't contain points]]
+[*Convenience header: ][^boost/geometry.hpp]
-]
+[section:cartesian_distance cartesian_distance::cartesian_distance]
-[heading Example:]
-
-Example showing centroid calculation
+[indexterm2 cartesian_distance..cartesian_distance]
+Constructor with a value.
+ cartesian_distance(
+ T const & v);
+[endsect]
-[heading Performance]
-
-2776 * 1000 centroid calculations are done in 0.16 seconds (http://trac.osgeo.org/ggl/wiki/Performance#Centroid1)
-[heading Geometries:]
-
+[section:operator_cast_type cartesian_distance::operator cast_type]
-* RING:
+[indexterm2 operator cast_type..cartesian_distance]
+Automatic conversion to double or higher precision, taking squareroot if necessary.
-* BOX: the centroid of a 2D or 3D box is the center of the box
+ operator cast_type() const;
-* POLYGON
-* POINT: the point is the centroid
+[endsect]
-* LINESTRING: the average of the centers of its segments
-* MULTIPOINT: the average of the points
+[section:operator_lt_ cartesian_distance::operator<]
+[indexterm2 operator<..cartesian_distance]
+ bool operator<(
+ cartesian_distance< T > const & other) const;
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/centroid.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 centroid (1 of 2 overloads)]
+[section:operator_lt__lt_ cartesian_distance::operator<<]
+
+[indexterm2 operator<<..cartesian_distance]
+Make streamable to enable std::cout << `geometry::distance( )`.
+
+
+ template<
+ typename Char ,
+ typename Traits >
+ friend std::basic_ostream< Char, Traits > & operator<<(
+ std::basic_ostream< Char, Traits > & os,
+ cartesian_distance< T > const & d);
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/distance_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:operator_eq__eq_ cartesian_distance::operator==]
+
+[indexterm2 operator==..cartesian_distance]
+
+ bool operator==(
+ cartesian_distance< T > const & other) const;
+
+
+
+[endsect]
+
+
+
+[section:operator_gt_ cartesian_distance::operator>]
+
+[indexterm2 operator>..cartesian_distance]
+
+ bool operator>(
+ cartesian_distance< T > const & other) const;
+
+
+
+[endsect]
+
+
+
+[section:squared_value cartesian_distance::squared_value]
+
+[indexterm2 squared_value..cartesian_distance]
+The "squared\_value" method returns the internal squared value.
+
+
+ T squared_value() const;
+
+
+
+[endsect]
+
+
+
+[section:very_small cartesian_distance::very_small]
+
+[indexterm2 very_small..cartesian_distance]
+
+ bool very_small() const;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:cartesian_tag cartesian_tag]
+
+
+Tag indicating Cartesian coordinate system family (cartesian,epsg).
+
+
+
+
+[heading Synopsis]
+ struct cartesian_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:centroid centroid]
+
+[indexterm1 centroid]
+
+ template<
+ typename Geometry ,
+ typename Point ,
+ typename Strategy >
+ void ``[link boost_geometry.reference.centroid.overload1 centroid]``(
+ Geometry const & geometry,
+ Point & c,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.centroid.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename Point >
+ void ``[link boost_geometry.reference.centroid.overload2 centroid]``(
+ Geometry const & geometry,
+ Point & c);
+ `` [''''»''' [link boost_geometry.reference.centroid.overload2 more...]]``
+
+
+[heading Source descriptions:]
+
+
+* OGC description: The mathematical centroid for this Surface as a Point. The result is not guaranteed to be on this Surface.
+
+* From Wikipedia: Informally, it is the "average" of all points
+
+
+
+
+
+[heading Remarks]
+
+Polygon should be closed, and can be orientated either way
+
+The "centroid" functions are taking a non const reference to the centroid. The "make\_centroid" functions return the centroid, the type has to be specified.
+
+Both of them have an overloaded version where a centroid calculation strategy can be specified
+
+
+[heading Exceptions]
+
+
+[variablelist
+
+[[centroid_exception][if calculation is not successful, e.g. because polygon didn't contain points]]
+
+]
+
+
+[heading Example:]
+
+Example showing centroid calculation
+
+
+
+
+
+
+[heading Performance]
+
+2776 * 1000 centroid calculations are done in 0.16 seconds (http://trac.osgeo.org/ggl/wiki/Performance#Centroid1)
+
+
+[heading Geometries:]
+
+
+* RING:
+
+
+* BOX: the centroid of a 2D or 3D box is the center of the box
+
+* POLYGON
+
+
+* POINT: the point is the centroid
+
+* LINESTRING: the average of the centers of its segments
+
+* MULTIPOINT: the average of the points
+
-Calculate centroid using a specified strategy.
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/centroid.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 centroid (1 of 2 overloads)]
+
+
+Calculate centroid using a specified [link boost_geometry.reference.strategy `strategy`].
template<
@@ -1152,11 +1543,11 @@
[variablelist
-[[geometry][the geometry to calculate centroid from ]]
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate centroid from ]]
-[[c][reference to point which will contain the centroid ]]
+[[c][reference to [link boost_geometry.reference.point `point`] which will contain the centroid ]]
-[[strategy][Calculation strategy for centroid ]]
+[[strategy][Calculation [link boost_geometry.reference.strategy `strategy`] for centroid ]]
]
@@ -1187,9 +1578,9 @@
[variablelist
-[[geometry][a geometry (e.g. closed ring or polygon) ]]
+[[geometry][a [link boost_geometry.reference.boost__geometry `boost::geometry`] (e.g. closed ring or [link boost_geometry.reference.polygon `polygon`]) ]]
-[[c][reference to point which will contain the centroid ]]
+[[c][reference to [link boost_geometry.reference.point `point`] which will contain the centroid ]]
]
@@ -1205,7 +1596,11 @@
+
+
+[heading Synopsis]
class centroid_exception : public exception
+
[heading Public Member Functions]
[table
[[Name][Description]]
@@ -1222,6 +1617,9 @@
]
+
+[heading Description]
+
[heading Requirements]
[*Header: ][^boost/geometry/algorithms/centroid.hpp]
@@ -1259,7 +1657,7 @@
[section:clear clear]
[indexterm1 clear]
-Clears a linestring, linear ring or polygon (exterior+interiors) or multi*.
+Clears a [link boost_geometry.reference.linestring `linestring`], linear ring or [link boost_geometry.reference.polygon `polygon`] (exterior+interiors) or multi*.
template<
@@ -1268,7 +1666,7 @@
Geometry & geometry);
-Generic function to clear a geometry
+Generic function to clear a [link boost_geometry.reference.boost__geometry `boost::geometry`]
[heading Remarks]
@@ -1288,27 +1686,23 @@
-[section:combine combine]
+[section:close_to_zero close_to_zero]
-[indexterm1 combine]
-Combines a box with another geometry (box, point).
+[indexterm1 close_to_zero]
+Utility function to check if a distance is very small.
template<
- typename Box ,
- typename Geometry >
- void combine(
- Box & box,
- Geometry const & geometry);
-
+ typename T >
+ bool close_to_zero(
+ T const & value);
+Depending on the "distance result" type it checks if it is smaller than epsilon, or (for Cartesian distances) if the square is smaller than epsilon
[variablelist
-[[Box][type of the box ]]
-
-[[Geometry][of second geometry, to be combined with the box ]]
+[[R][the distance result type, either arithmetic or cartesian distance ]]
]
@@ -1318,9 +1712,7 @@
[variablelist
-[[box][box to combine another geometry with, might be changed ]]
-
-[[geometry][other geometry ]]
+[[value][the distance result to check ]]
]
@@ -1328,7 +1720,7 @@
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/combine.hpp]
+[*Header: ][^boost/geometry/strategies/distance_result.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -1336,129 +1728,262 @@
[endsect]
-[section:concept__Box concept::Box]
+[section:combine combine]
-[link boost_geometry.reference.concept__Box `concept::Box`] concept.
+[indexterm1 combine]
+Combines a [link boost_geometry.reference.box `box`] with another [link boost_geometry.reference.boost__geometry `boost::geometry`] ([link boost_geometry.reference.box `box`], [link boost_geometry.reference.point `point`]).
template<
+ typename Box ,
typename Geometry >
- class Box
+ void combine(
+ Box & box,
+ Geometry const & geometry);
-[heading Formal definition:]
+
+
+
+[variablelist
-The box concept is defined as following:
-* there must be a specialization of traits::tag defining box_tag as type
+[[Box][type of the [link boost_geometry.reference.box `box`] ]]
-* there must be a specialization of traits::point_type to define the underlying point type (even if it does not consist of points, it should define this type, to indicate the points it can work with)
+[[Geometry][of second [link boost_geometry.reference.boost__geometry `boost::geometry`], to be combined with the [link boost_geometry.reference.box `box`] ]]
-* there must be a specialization of traits::indexed_access, per index (min_corner, max_corner) and per dimension, with two functions:get to get a coordinate valueset to set a coordinate value (this one is not checked for ConstBox)
+]
+
+
+[heading Parameters]
+
+[variablelist
+
+[[box][[link boost_geometry.reference.box `box`] to combine another [link boost_geometry.reference.boost__geometry `boost::geometry`] with, might be changed ]]
+[[geometry][other [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+]
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/concepts/box_concept.hpp]
+[*Header: ][^boost/geometry/algorithms/combine.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:concept__ConstBox concept::ConstBox]
+[section:concept__AreaStrategy concept::AreaStrategy]
-[link boost_geometry.reference.concept__Box `concept::Box`] concept (const version).
+Checks [link boost_geometry.reference.strategy `strategy`] for area.
+
+
+
+[heading Synopsis]
template<
- typename Geometry >
- class ConstBox
-The [link boost_geometry.reference.concept__ConstBox `concept::ConstBox`] concept apply the same as the [link boost_geometry.reference.concept__Box `concept::Box`] concept, but does not apply write access.
+ typename Strategy >
+ class AreaStrategy
+
+[heading Description]
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/concepts/box_concept.hpp]
+[*Header: ][^boost/geometry/strategies/concepts/area_concept.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:concept__ConstLinestring concept::ConstLinestring]
+[section:concept__Box concept::Box]
+
+
+[link boost_geometry.reference.concept__Box `concept::Box`] [link boost_geometry.reference.concept `concept`].
-[link boost_geometry.reference.concept__Linestring `concept::Linestring`] concept (const version).
+[heading Synopsis]
template<
typename Geometry >
- class ConstLinestring
-The [link boost_geometry.reference.concept__ConstLinestring `concept::ConstLinestring`] concept check the same as the [link boost_geometry.reference.concept__Linestring `concept::Linestring`] concept, but does not check write access.
+ class Box
-[heading Requirements]
+[heading Description]
-[*Header: ][^boost/geometry/geometries/concepts/linestring_concept.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[heading Formal definition:]
+
+The [link boost_geometry.reference.box `box`] [link boost_geometry.reference.concept `concept`] is defined as following:
+* there must be a specialization of traits::tag defining box_tag as type
+* there must be a specialization of traits::point_type to define the underlying point type (even if it does not consist of points, it should define this type, to indicate the points it can work with)
-[endsect]
+* there must be a specialization of traits::indexed_access, per index (min_corner, max_corner) and per dimension, with two functions:get to get a coordinate valueset to set a coordinate value (this one is not checked for ConstBox)
-[section:concept__ConstPoint concept::ConstPoint]
-point concept (const version)
- template<
- typename Geometry >
- class ConstPoint
-The [link boost_geometry.reference.concept__ConstPoint `concept::ConstPoint`] concept apply the same as the [link boost_geometry.reference.concept__Point `concept::Point`] concept, but does not apply write access.
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/concepts/point_concept.hpp]
+[*Header: ][^boost/geometry/geometries/concepts/box_concept.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:concept__ConstPolygon concept::ConstPolygon]
+[section:concept__CentroidStrategy concept::CentroidStrategy]
+
+
+Checks [link boost_geometry.reference.strategy `strategy`] for centroid.
-[link boost_geometry.reference.concept__Polygon `concept::Polygon`] concept (const version).
+[heading Synopsis]
template<
- typename Geometry >
- class ConstPolygon
-The [link boost_geometry.reference.concept__ConstPolygon `concept::ConstPolygon`] concept check the same as the [link boost_geometry.reference.concept__Polygon `concept::Polygon`] concept, but does not check write access.
+ typename Strategy >
+ class CentroidStrategy
+
+[heading Description]
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/concepts/polygon_concept.hpp]
+[*Header: ][^boost/geometry/strategies/concepts/centroid_concept.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:concept__ConstRing concept::ConstRing]
+[section:concept__ConstBox concept::ConstBox]
-(linear) ring concept (const version)
+[link boost_geometry.reference.concept__Box `concept::Box`] [link boost_geometry.reference.concept `concept`] (const version).
- template<
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ class ConstBox
+
+[heading Description]
+
+The [link boost_geometry.reference.concept__ConstBox `concept::ConstBox`] [link boost_geometry.reference.concept `concept`] apply the same as the [link boost_geometry.reference.concept__Box `concept::Box`] [link boost_geometry.reference.concept `concept`], but does not apply write access.
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/concepts/box_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:concept__ConstLinestring concept::ConstLinestring]
+
+
+[link boost_geometry.reference.concept__Linestring `concept::Linestring`] [link boost_geometry.reference.concept `concept`] (const version).
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ class ConstLinestring
+
+[heading Description]
+
+The [link boost_geometry.reference.concept__ConstLinestring `concept::ConstLinestring`] [link boost_geometry.reference.concept `concept`] check the same as the [link boost_geometry.reference.concept__Linestring `concept::Linestring`] [link boost_geometry.reference.concept `concept`], but does not check write access.
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/concepts/linestring_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:concept__ConstPoint concept::ConstPoint]
+
+
+[link boost_geometry.reference.point `point`] [link boost_geometry.reference.concept `concept`] (const version).
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ class ConstPoint
+
+[heading Description]
+
+The [link boost_geometry.reference.concept__ConstPoint `concept::ConstPoint`] [link boost_geometry.reference.concept `concept`] apply the same as the [link boost_geometry.reference.concept__Point `concept::Point`] [link boost_geometry.reference.concept `concept`], but does not apply write access.
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/concepts/point_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:concept__ConstPolygon concept::ConstPolygon]
+
+
+[link boost_geometry.reference.concept__Polygon `concept::Polygon`] [link boost_geometry.reference.concept `concept`] (const version).
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ class ConstPolygon
+
+[heading Description]
+
+The [link boost_geometry.reference.concept__ConstPolygon `concept::ConstPolygon`] [link boost_geometry.reference.concept `concept`] check the same as the [link boost_geometry.reference.concept__Polygon `concept::Polygon`] [link boost_geometry.reference.concept `concept`], but does not check write access.
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/concepts/polygon_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:concept__ConstRing concept::ConstRing]
+
+
+(linear) ring [link boost_geometry.reference.concept `concept`] (const version)
+
+
+
+
+[heading Synopsis]
+ template<
typename Geometry >
class ConstRing
-The ConstLinearRing concept check the same as the Geometry concept, but does not check write access.
+
+[heading Description]
+
+The ConstLinearRing [link boost_geometry.reference.concept `concept`] check the same as the Geometry [link boost_geometry.reference.concept `concept`], but does not check write access.
[heading Requirements]
@@ -1472,13 +1997,19 @@
[section:concept__ConstSegment concept::ConstSegment]
-[link boost_geometry.reference.concept__Segment `concept::Segment`] concept (const version).
+[link boost_geometry.reference.concept__Segment `concept::Segment`] [link boost_geometry.reference.concept `concept`] (const version).
+
+
+[heading Synopsis]
template<
typename Geometry >
class ConstSegment
-The [link boost_geometry.reference.concept__ConstSegment `concept::ConstSegment`] concept verifies the same as the [link boost_geometry.reference.concept__Segment `concept::Segment`] concept, but does not verify write access.
+
+[heading Description]
+
+The [link boost_geometry.reference.concept__ConstSegment `concept::ConstSegment`] [link boost_geometry.reference.concept `concept`] verifies the same as the [link boost_geometry.reference.concept__Segment `concept::Segment`] [link boost_geometry.reference.concept `concept`], but does not verify write access.
[heading Requirements]
@@ -1489,19 +2020,49 @@
[endsect]
+[section:concept__ConvexHullStrategy concept::ConvexHullStrategy]
+
+
+Checks [link boost_geometry.reference.strategy `strategy`] for convex\_hull.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Strategy >
+ class ConvexHullStrategy
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/concepts/convex_hull_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
[section:concept__Linestring concept::Linestring]
-[link boost_geometry.reference.concept__Linestring `concept::Linestring`] concept.
+[link boost_geometry.reference.concept__Linestring `concept::Linestring`] [link boost_geometry.reference.concept `concept`].
+
+
+[heading Synopsis]
template<
typename Geometry >
class Linestring
+[heading Description]
+
+
[heading Formal definition:]
-The linestring concept is defined as following:
+The [link boost_geometry.reference.linestring `linestring`] [link boost_geometry.reference.concept `concept`] is defined as following:
* there must be a specialization of traits::tag defining linestring_tag as type
* it must behave like a Boost.Range
@@ -1516,22 +2077,22 @@
[heading Remarks]
-to fulfil the concepts, no traits class has to be specialized to define the point type. The point type is taken using boost::range\_value<X>::type
+to fulfil the concepts, no [link boost_geometry.reference.traits `traits`] class has to be specialized to define the [link boost_geometry.reference.point `point`] type. The [link boost_geometry.reference.point `point`] type is taken using boost::range\_value<X>::type
[heading Example:]
-A custom linestring, defining the necessary specializations to fulfil to the concept.
+A custom [link boost_geometry.reference.linestring `linestring`], defining the necessary specializations to fulfil to the [link boost_geometry.reference.concept `concept`].
-Suppose that the following linestring is defined:
+Suppose that the following [link boost_geometry.reference.linestring `linestring`] is defined:
-It can then be adapted to the concept as following:
+It can then be adapted to the [link boost_geometry.reference.concept `concept`] as following:
@@ -1561,16 +2122,22 @@
[section:concept__Point concept::Point]
-[link boost_geometry.reference.concept__Point `concept::Point`] concept.
+[link boost_geometry.reference.concept__Point `concept::Point`] [link boost_geometry.reference.concept `concept`].
+
+
+[heading Synopsis]
template<
typename Geometry >
class Point
+[heading Description]
+
+
[heading Formal definition:]
-The point concept is defined as following:
+The [link boost_geometry.reference.point `point`] [link boost_geometry.reference.concept `concept`] is defined as following:
* there must be a specialization of traits::tag defining point_tag as type
* there must be a specialization of traits::coordinate_type defining the type of its coordinates
@@ -1589,15 +2156,15 @@
-A legacy point, defining the necessary specializations to fulfil to the concept.
+A legacy [link boost_geometry.reference.point `point`], defining the necessary specializations to fulfil to the [link boost_geometry.reference.concept `concept`].
-Suppose that the following point is defined:
+Suppose that the following [link boost_geometry.reference.point `point`] is defined:
-It can then be adapted to the concept as following:
+It can then be adapted to the [link boost_geometry.reference.concept `concept`] as following:
@@ -1610,9 +2177,9 @@
-A read-only legacy point, using a macro to fulfil to the [link boost_geometry.reference.concept__ConstPoint `concept::ConstPoint`] concept. It cannot be modified by the library but can be used in all algorithms where points are not modified.
+A read-only legacy [link boost_geometry.reference.point `point`], using a macro to fulfil to the [link boost_geometry.reference.concept__ConstPoint `concept::ConstPoint`] [link boost_geometry.reference.concept `concept`]. It cannot be modified by the library but can be used in all algorithms where points are not modified.
-The point looks like the following:
+The [link boost_geometry.reference.point `point`] looks like the following:
@@ -1635,19 +2202,73 @@
[endsect]
+[section:concept__PointDistanceStrategy concept::PointDistanceStrategy]
+
+
+Checks [link boost_geometry.reference.strategy `strategy`] for point-segment-distance.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Strategy >
+ struct PointDistanceStrategy
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/concepts/distance_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:concept__PointSegmentDistanceStrategy concept::PointSegmentDistanceStrategy]
+
+
+Checks [link boost_geometry.reference.strategy `strategy`] for point-segment-distance.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Strategy >
+ struct PointSegmentDistanceStrategy
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/concepts/distance_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
[section:concept__Polygon concept::Polygon]
-[link boost_geometry.reference.concept__Polygon `concept::Polygon`] concept.
+[link boost_geometry.reference.concept__Polygon `concept::Polygon`] [link boost_geometry.reference.concept `concept`].
+
+
+[heading Synopsis]
template<
typename Geometry >
class Polygon
+[heading Description]
+
+
[heading Formal definition:]
-The polygon concept is defined as following:
+The [link boost_geometry.reference.polygon `polygon`] [link boost_geometry.reference.concept `concept`] is defined as following:
* there must be a specialization of traits::tag defining polygon_tag as type
* there must be a specialization of traits::ring_type defining the type of its exterior ring and interior rings as type
@@ -1663,7 +2284,7 @@
[heading Remarks]
-to fulfil the concepts, no traits class has to be specialized to define the point type. The point type is automatically defined as typename range\_value<typename `ring_type<P>::type`>type
+to fulfil the concepts, no [link boost_geometry.reference.traits `traits`] class has to be specialized to define the [link boost_geometry.reference.point `point`] type. The [link boost_geometry.reference.point `point`] type is automatically defined as typename range\_value<typename `ring_type<P>::type`>type
@@ -1679,16 +2300,22 @@
[section:concept__Ring concept::Ring]
-ring concept
+ring [link boost_geometry.reference.concept `concept`]
+
+
+[heading Synopsis]
template<
typename Geometry >
class Ring
+[heading Description]
+
+
[heading Formal definition:]
-The ring concept is defined as following:
+The ring [link boost_geometry.reference.concept `concept`] is defined as following:
* there must be a specialization of traits::tag defining ring_tag as type
* it must behave like a Boost.Range
@@ -1704,7 +2331,7 @@
[heading Remarks]
-to fulfil the concepts, no traits class has to be specialized to define the point type. The point type is taken using boost::range\_value<X>::type
+to fulfil the concepts, no [link boost_geometry.reference.traits `traits`] class has to be specialized to define the [link boost_geometry.reference.point `point`] type. The [link boost_geometry.reference.point `point`] type is taken using boost::range\_value<X>::type
@@ -1720,16 +2347,19 @@
[section:concept__Segment concept::Segment]
-segment concept
+[link boost_geometry.reference.concept__Segment `concept::Segment`] [link boost_geometry.reference.concept `concept`].
+
+
+[heading Synopsis]
template<
typename Geometry >
class Segment
-[heading Formal definition:]
-
-The segment concept is defined as following:
+[heading Description]
+
+Formal definition: The [link boost_geometry.reference.segment `segment`] [link boost_geometry.reference.concept `concept`] is defined as following:
* there must be a specialization of traits::tag defining segment_tag as type
* there must be a specialization of traits::point_type to define the underlying point type (even if it does not consist of points, it should define this type, to indicate the points it can work with)
@@ -1742,7 +2372,7 @@
[heading Remarks]
-The segment concept is similar to the box concept, defining another tag. However, the box concept assumes the index as min\_corner, max\_corner, while for the segment concept there is no assumption.
+The [link boost_geometry.reference.segment `segment`] [link boost_geometry.reference.concept `concept`] is similar to the [link boost_geometry.reference.box `box`] [link boost_geometry.reference.concept `concept`], defining another [link boost_geometry.reference.tag `tag`]. However, the [link boost_geometry.reference.box `box`] [link boost_geometry.reference.concept `concept`] assumes the index as min\_corner, max\_corner, while for the [link boost_geometry.reference.segment `segment`] [link boost_geometry.reference.concept `concept`] there is no assumption.
@@ -1755,11 +2385,83 @@
[endsect]
+[section:concept__SegmentIntersectStrategy concept::SegmentIntersectStrategy]
+
+
+Checks [link boost_geometry.reference.strategy `strategy`] for [link boost_geometry.reference.segment `segment`] intersection.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Strategy >
+ class SegmentIntersectStrategy
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/concepts/segment_intersect_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:concept__SimplifyStrategy concept::SimplifyStrategy]
+
+
+Checks [link boost_geometry.reference.strategy `strategy`] for simplify.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Strategy >
+ struct SimplifyStrategy
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/concepts/simplify_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:concept__WithinStrategy concept::WithinStrategy]
+
+
+Checks [link boost_geometry.reference.strategy `strategy`] for within (point-in-polygon).
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Strategy >
+ class WithinStrategy
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/concepts/within_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
[section:concept__check concept::check]
[indexterm1 concept::check]
-Checks, in compile-time, the concept of any geometry.
+Checks, in compile-time, the [link boost_geometry.reference.concept `concept`] of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
template<
@@ -1781,7 +2483,7 @@
[section:concept__check_concepts_and_equal_dimensions concept::check_concepts_and_equal_dimensions]
[indexterm1 concept::check_concepts_and_equal_dimensions]
-Checks, in compile-time, the concept of two geometries, and if they have equal dimensions.
+Checks, in compile-time, the [link boost_geometry.reference.concept `concept`] of two geometries, and if they have equal dimensions.
template<
@@ -1804,7 +2506,7 @@
[section:convert convert]
[indexterm1 convert]
-Converts one geometry to another geometry.
+Converts one [link boost_geometry.reference.boost__geometry `boost::geometry`] to another [link boost_geometry.reference.boost__geometry `boost::geometry`].
template<
@@ -1815,15 +2517,15 @@
Geometry2 & geometry2);
-The convert algorithm converts one geometry, e.g. a BOX, to another geometry, e.g. a RING. This only if it is possible and applicable.
+The convert algorithm converts one [link boost_geometry.reference.boost__geometry `boost::geometry`], e.g. a BOX, to another [link boost_geometry.reference.boost__geometry `boost::geometry`], e.g. a RING. This only if it is possible and applicable.
[variablelist
-[[Geometry1][first geometry type ]]
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Geometry2][second geometry type ]]
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
]
@@ -1833,9 +2535,9 @@
[variablelist
-[[geometry1][first geometry (source) ]]
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] (source) ]]
-[[geometry2][second geometry (target) ]]
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] (target) ]]
]
@@ -1978,7 +2680,7 @@
[section:overload2 convex_hull (2 of 2 overloads)]
-Calculate the convex hull of a geometry.
+Calculate the convex hull of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
template<
@@ -1993,9 +2695,9 @@
[variablelist
-[[Geometry1][the input geometry type ]]
+[[Geometry1][the input [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Geometry2:][the output geometry type ]]
+[[Geometry2:][the output [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
]
@@ -2005,9 +2707,9 @@
[variablelist
-[[geometry][the geometry to calculate convex hull from ]]
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate convex hull from ]]
-[[out][a geometry receiving points of the convex hull ]]
+[[out][a [link boost_geometry.reference.boost__geometry `boost::geometry`] receiving points of the convex hull ]]
]
@@ -2070,7 +2772,7 @@
[section:overload2 convex_hull_inserter (2 of 2 overloads)]
-Calculate the convex hull of a geometry, output-iterator version.
+Calculate the convex hull of a [link boost_geometry.reference.boost__geometry `boost::geometry`], output-iterator version.
template<
@@ -2085,7 +2787,7 @@
[variablelist
-[[Geometry][the input geometry type ]]
+[[Geometry][the input [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
[[OutputIterator:][an output-iterator ]]
@@ -2097,7 +2799,7 @@
[variablelist
-[[geometry][the geometry to calculate convex hull from ]]
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate convex hull from ]]
[[out][an output iterator outputing points of the convex hull ]]
@@ -2119,9 +2821,12 @@
[section:coordinate_system coordinate_system]
-Meta-function which defines coordinate system for any geometry.
+Meta-function which defines coordinate system for any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+[heading Synopsis]
template<
typename G >
struct coordinate_system
@@ -2146,6 +2851,9 @@
]
+
+[heading Description]
+
[heading Requirements]
[*Header: ][^boost/geometry/core/coordinate_system.hpp]
@@ -2195,11 +2903,11 @@
[heading Typedef Description]
-All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type ([link boost_geometry.reference.point `point`], [link boost_geometry.reference.linestring `linestring`], [link boost_geometry.reference.polygon `polygon`], etc) by implementing a [link boost_geometry.reference.tag `tag`] [link boost_geometry.reference.traits `traits`] class. This meta-function uses that [link boost_geometry.reference.traits `traits`] class to retrieve the [link boost_geometry.reference.tag `tag`]. If the input type is not a [link boost_geometry.reference.boost__geometry `boost::geometry`] at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
[variablelist
-[[Geometry][geometry ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -2222,9 +2930,12 @@
[section:coordinate_type coordinate_type]
-Meta-function which defines coordinate type (int, float, double, etc) of any geometry.
+Meta-function which defines coordinate type (int, float, double, etc) of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+[heading Synopsis]
template<
typename ``[link boost_geometry.reference.G G]``>
struct coordinate_type
@@ -2249,6 +2960,9 @@
]
+
+[heading Description]
+
[heading Requirements]
[*Header: ][^boost/geometry/core/coordinate_type.hpp]
@@ -2298,11 +3012,11 @@
[heading Typedef Description]
-All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type ([link boost_geometry.reference.point `point`], [link boost_geometry.reference.linestring `linestring`], [link boost_geometry.reference.polygon `polygon`], etc) by implementing a [link boost_geometry.reference.tag `tag`] [link boost_geometry.reference.traits `traits`] class. This meta-function uses that [link boost_geometry.reference.traits `traits`] class to retrieve the [link boost_geometry.reference.tag `tag`]. If the input type is not a [link boost_geometry.reference.boost__geometry `boost::geometry`] at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
[variablelist
-[[Geometry][geometry ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -2325,7 +3039,7 @@
[section:copy_segment_point copy_segment_point]
[indexterm1 copy_segment_point]
-Helper function, copies a point from a segment.
+Helper function, copies a [link boost_geometry.reference.point `point`] from a [link boost_geometry.reference.segment `segment`].
template<
@@ -2362,7 +3076,7 @@
[section:overload1 copy_segment_point (1 of 2 overloads)]
-Helper function, copies a point from a segment.
+Helper function, copies a [link boost_geometry.reference.point `point`] from a [link boost_geometry.reference.segment `segment`].
template<
@@ -2384,7 +3098,7 @@
[section:overload2 copy_segment_point (2 of 2 overloads)]
-Helper function, to avoid the same construct several times, copies a point, based on a source-index and two geometries.
+Helper function, to avoid the same construct several times, copies a [link boost_geometry.reference.point `point`], based on a source-index and two geometries.
template<
@@ -2410,7 +3124,7 @@
[section:copy_segment_points copy_segment_points]
[indexterm1 copy_segment_points]
-Helper function, to avoid the same construct several times, copies a point, based on a source-index and two geometries.
+Helper function, to avoid the same construct several times, copies a [link boost_geometry.reference.point `point`], based on a source-index and two geometries.
template<
@@ -2537,7 +3251,13 @@
Cartesian coordinate system.
+
+
+[heading Synopsis]
struct cartesian
+
+[heading Description]
+
Defines the Cartesian or rectangular coordinate system where points are defined in 2 or 3 (or more) dimensions and usually (but not always) known as x,y,z
@@ -2553,9 +3273,12 @@
[section:cs__geographic cs::geographic]
-Geographic coordinate system, in degree or in radian.
+Geographic coordinate system, in [link boost_geometry.reference.degree `degree`] or in [link boost_geometry.reference.radian `radian`].
+
+
+[heading Synopsis]
template<
typename DegreeOrRadian >
struct geographic
@@ -2573,7 +3296,10 @@
]
-Defines the geographic coordinate system where points are defined in two angles and usually known as lat,long or lo,la or phi,lambda
+
+[heading Description]
+
+Defines the [link boost_geometry.reference.cs__geographic `cs::geographic`] coordinate system where points are defined in two angles and usually known as lat,long or lo,la or phi,lambda
[heading Remarks]
@@ -2615,6 +3341,9 @@
Polar coordinate system.
+
+
+[heading Synopsis]
template<
typename DegreeOrRadian >
struct polar
@@ -2632,7 +3361,10 @@
]
-Defines the polar coordinate system "in which each point
+
+[heading Description]
+
+Defines the [link boost_geometry.reference.cs__polar `cs::polar`] coordinate system "in which each point
on a plane is determined by an angle and a distance"
@@ -2667,9 +3399,12 @@
[section:cs__spherical cs::spherical]
-Spherical coordinate system, in degree or in radian.
+Spherical coordinate system, in [link boost_geometry.reference.degree `degree`] or in [link boost_geometry.reference.radian `radian`].
+
+
+[heading Synopsis]
template<
typename DegreeOrRadian >
struct spherical
@@ -2687,7 +3422,10 @@
]
-Defines the spherical coordinate system where points are defined in two angles and an optional radius usually known as r, theta, phi
+
+[heading Description]
+
+Defines the [link boost_geometry.reference.cs__spherical `cs::spherical`] coordinate system where points are defined in two angles and an optional radius usually known as r, theta, phi
[heading Coordinates:]
@@ -2733,11 +3471,14 @@
[section:cs_tag cs_tag]
-Meta-function returning coordinate system tag (cs family) of any geometry.
+Meta-function returning coordinate system [link boost_geometry.reference.tag `tag`] ([link boost_geometry.reference.cs `cs`] family) of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+[heading Synopsis]
template<
- typename G >
+ typename ``[link boost_geometry.reference.G G]``>
struct cs_tag
[heading Public Types]
@@ -2753,6 +3494,9 @@
]
+
+[heading Description]
+
[heading Requirements]
[*Header: ][^boost/geometry/core/cs.hpp]
@@ -2793,725 +3537,772 @@
[endsect]
-[section:degree degree]
-
+[section:de9im de9im]
-Unit of plane angle: Degrees.
+Dimensionally Extended 9 Intersection Matrix.
- class degree
-[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[heading Synopsis]
+ struct de9im
-[endsect]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.de9im.as_char [*as_char]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im.contains [*contains]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im.crosses [*crosses]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im.de9im [*de9im]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im.disjoint [*disjoint]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im.equals [*equals]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im.intersects [*intersects]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im.overlaps [*overlaps]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im.touches [*touches]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im.within [*within]]]
+ []
+ ]
+
+]
-[section:difference difference]
-[indexterm1 difference]
+[heading Public Data Members]
+[table
+ [[Name][Description]]
- template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename Collection >
- void difference(
- Geometry1 const & geometry1,
- Geometry2 geometry2,
- Collection & output_collection);
+ [
+ [[link boost_geometry.reference.de9im.bb [*bb]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im.be [*be]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im.bi [*bi]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im.eb [*eb]]]
+ []
+ ]
-[variablelist
-
-[[Geometry][geometry type ]]
+ [
+ [[link boost_geometry.reference.de9im.ee [*ee]]]
+ []
+ ]
-]
+ [
+ [[link boost_geometry.reference.de9im.ei [*ei]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im.ib [*ib]]]
+ []
+ ]
-[heading Parameters]
-
+ [
+ [[link boost_geometry.reference.de9im.ie [*ie]]]
+ []
+ ]
-[variablelist
-
-[[geometry][the geometry to make difference ]]
+ [
+ [[link boost_geometry.reference.de9im.ii [*ii]]]
+ []
+ ]
]
+[heading Description]
+
+
+
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/difference.hpp]
+[*Header: ][^boost/geometry/strategies/intersection_result.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:as_char de9im::as_char]
+[indexterm2 as_char..de9im]
-[section:dimension dimension]
+ static char as_char(
+ int v);
-Meta-function which defines coordinate dimensions, i.e. the number of axes of any geometry.
+[endsect]
- template<
- typename G >
- struct dimension
-[heading Requirements]
-[*Header: ][^boost/geometry/core/coordinate_dimension.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:bb de9im::bb]
+[indexterm2 bb..de9im]
-[endsect]
+ int bb;
-[section:disjoint disjoint]
-[indexterm1 disjoint]
-Calculate if two geometries are disjoint.
+[endsect]
- template<
- typename Geometry1 ,
- typename Geometry2 >
- bool disjoint(
- const Geometry1 & geometry1,
- const Geometry2 & geometry2);
+[section:be de9im::be]
+[indexterm2 be..de9im]
+ int be;
-[variablelist
-
-[[Geometry1][first geometry type ]]
-[[Geometry2][second geometry type ]]
-]
+[endsect]
-[heading Parameters]
-
-[variablelist
-
-[[geometry1][first geometry ]]
+[section:bi de9im::bi]
-[[geometry2][second geometry ]]
+[indexterm2 bi..de9im]
-]
+ int bi;
-[heading Return Value]
-
-true if disjoint, else false
+
+[endsect]
-[heading Requirements]
+[section:contains de9im::contains]
-[*Header: ][^boost/geometry/algorithms/disjoint.hpp]
+[indexterm2 contains..de9im]
+
+ bool contains() const;
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:dissolve dissolve]
+[section:crosses de9im::crosses]
-[indexterm1 dissolve]
-Removes self intersections from a geometry.
+[indexterm2 crosses..de9im]
+ bool crosses() const;
- template<
- typename Geometry ,
- typename OutputIterator >
- OutputIterator dissolve(
- Geometry const & geometry,
- OutputIterator output);
+[endsect]
-[variablelist
-
-[[Geometry][geometry type ]]
+[section:de9im de9im::de9im]
-[[OutputIterator][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
+[indexterm2 de9im..de9im]
-]
+ ``[link boost_geometry.reference.de9im.de9im.overload1 de9im]``();
+ `` [''''»''' [link boost_geometry.reference.de9im.de9im.overload1 more...]]``
+ ``[link boost_geometry.reference.de9im.de9im.overload2 de9im]``(
+ int ii0,
+ int ib0,
+ int ie0,
+ int bi0,
+ int bb0,
+ int be0,
+ int ei0,
+ int eb0,
+ int ee0);
+ `` [''''»''' [link boost_geometry.reference.de9im.de9im.overload2 more...]]``
-[heading Parameters]
-
-[variablelist
-
-[[geometry][first geometry ]]
+[section:overload1 de9im::de9im (1 of 2 overloads)]
-[[output][container which will contain intersection points ]]
-]
+ de9im();
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/dissolve.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:overload2 de9im::de9im (2 of 2 overloads)]
-[section:distance distance]
-[indexterm1 distance]
-
- template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename Strategy >
- Strategy::return_type ``[link boost_geometry.reference.distance.overload1 distance]``(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.distance.overload1 more...]]``
+ de9im(
+ int ii0,
+ int ib0,
+ int ie0,
+ int bi0,
+ int bb0,
+ int be0,
+ int ei0,
+ int eb0,
+ int ee0);
- template<
- typename Geometry1 ,
- typename Geometry2 >
- distance_result< Geometry1, Geometry2 >::type ``[link boost_geometry.reference.distance.overload2 distance]``(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
- `` [''''»''' [link boost_geometry.reference.distance.overload2 more...]]``
-The distance algorithm returns the distance between two geometries.
-[heading Coordinate systems and strategies:]
-
-With help of strategies the distance function returns the appropriate distance. If the input is in cartesian coordinates, the Euclidian distance (Pythagoras) is calculated. If the input is in spherical coordinates (either degree or radian), the distance over the sphere is returned. If the input is in geographic coordinates, distance is calculated over the globe and returned in meters.
+[endsect]
-[heading Distance result:]
-
-Depending on calculation type the distance result is either a structure, convertable to a double, or a double value. In case of Pythagoras it makes sense to not draw the square root in the strategy itself. Taking a square root is relative expensive and is not necessary when comparing distances.
+[endsect]
-[heading Geometries:]
-
-Currently implemented, for both cartesian and spherical/geographic:
-* POINT - POINT
-* POINT - SEGMENT and v.v.
+[section:disjoint de9im::disjoint]
-* POINT - LINESTRING and v.v.
+[indexterm2 disjoint..de9im]
+ bool disjoint() const;
-Not yet implemented:
-* POINT - RING etc, note that it will return a zero if the point is anywhere within the ring
+[endsect]
-[heading Example:]
-
-Example showing distance calculation of two points, in xy and in latlong coordinates
+[section:eb de9im::eb]
+[indexterm2 eb..de9im]
+ int eb;
+[endsect]
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/distance.hpp]
+[section:ee de9im::ee]
-[*Convenience header: ][^boost/geometry.hpp]
+[indexterm2 ee..de9im]
+ int ee;
-[section:overload1 distance (1 of 2 overloads)]
-Calculate distance between two geometries with a specified strategy.
+[endsect]
- template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename Strategy >
- Strategy::return_type distance(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- Strategy const & strategy);
+[section:ei de9im::ei]
+[indexterm2 ei..de9im]
+ int ei;
-[variablelist
-
-[[Geometry1][first geometry type ]]
-[[Geometry2][second geometry type ]]
-[[S][point-point-distance strategy type ]]
+[endsect]
-]
-[heading Parameters]
-
+[section:equals de9im::equals]
-[variablelist
-
-[[geometry1][first geometry ]]
+[indexterm2 equals..de9im]
-[[geometry2][second geometry ]]
+ bool equals() const;
-[[strategy][strategy to calculate distance between two points ]]
-]
+[endsect]
-[heading Return Value]
-
-the distance (either a double or a distance\_result, (convertable to double))
-[heading Remarks]
-
-The strategy can be a point-point strategy. In case of distance point-line/point-polygon it may also be a point-segment strategy.
+[section:ib de9im::ib]
+[indexterm2 ib..de9im]
-[heading Example:]
-
-Example showing distance calculation of two lat long points, using the accurate Vincenty approximation
+ int ib;
+[endsect]
+[section:ie de9im::ie]
+[indexterm2 ie..de9im]
-[endsect]
+ int ie;
-[section:overload2 distance (2 of 2 overloads)]
+[endsect]
-Calculate distance between two geometries.
+[section:ii de9im::ii]
- template<
- typename Geometry1 ,
- typename Geometry2 >
- distance_result< Geometry1, Geometry2 >::type distance(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
+[indexterm2 ii..de9im]
+ int ii;
-The default strategy is used, belonging to the corresponding coordinate system of the geometries
-[variablelist
-
-[[G1][first geometry type ]]
-[[G2][second geometry type ]]
+[endsect]
-]
-[heading Parameters]
-
+[section:intersects de9im::intersects]
-[variablelist
-
-[[geometry1][first geometry ]]
+[indexterm2 intersects..de9im]
-[[geometry2][second geometry ]]
+ bool intersects() const;
-]
-[heading Return Value]
-
-the distance (either a double or a distance result, convertable to double)
+[endsect]
+[section:overlaps de9im::overlaps]
-[endsect]
+[indexterm2 overlaps..de9im]
+ bool overlaps() const;
-[endsect]
-[section:divide_point divide_point]
+[endsect]
-[indexterm1 divide_point]
-Divides a point by another.
- template<
- typename Point1 ,
- typename Point2 >
- void divide_point(
- Point1 & p1,
- Point2 const & p2);
+[section:touches de9im::touches]
+[indexterm2 touches..de9im]
-The coordinates of the second point will be divided by those of the first point. The second point is not modified.
-[heading Parameters]
-
+ bool touches() const;
-[variablelist
-
-[[p1][first point ]]
-[[p2][second point ]]
-]
+[endsect]
-[heading Requirements]
+[section:within de9im::within]
-[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+[indexterm2 within..de9im]
+
+ bool within() const;
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:divide_value divide_value]
+[endsect]
-[indexterm1 divide_value]
-Divides each coordinate of a point by a value.
+[section:de9im_segment de9im_segment]
- template<
- typename Point >
- void divide_value(
- Point & p,
- typename detail::param< Point >::type value);
-[heading Parameters]
-
+[heading Synopsis]
+ struct de9im_segment : public de9im
-[variablelist
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.as_char [*as_char]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.contains [*contains]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.crosses [*crosses]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.de9im_segment [*de9im_segment]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.disjoint [*disjoint]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.equals [*equals]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.intersects [*intersects]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.overlaps [*overlaps]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.touches [*touches]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.within [*within]]]
+ []
+ ]
-[[p][point ]]
+]
-[[value][value to divide by ]]
-]
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.de9im_segment.bb [*bb]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im_segment.be [*be]]]
+ []
+ ]
-[heading Requirements]
+ [
+ [[link boost_geometry.reference.de9im_segment.bi [*bi]]]
+ []
+ ]
-[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+ [
+ [[link boost_geometry.reference.de9im_segment.collinear [*collinear]]]
+ []
+ ]
-[*Convenience header: ][^boost/geometry.hpp]
+ [
+ [[link boost_geometry.reference.de9im_segment.degenerate [*degenerate]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im_segment.eb [*eb]]]
+ []
+ ]
-[endsect]
+ [
+ [[link boost_geometry.reference.de9im_segment.ee [*ee]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im_segment.ei [*ei]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im_segment.ib [*ib]]]
+ []
+ ]
-[section:dot_product dot_product]
+ [
+ [[link boost_geometry.reference.de9im_segment.ie [*ie]]]
+ []
+ ]
-[indexterm1 dot_product]
-Computes the dot product (or scalar product) of 2 vectors (points).
+ [
+ [[link boost_geometry.reference.de9im_segment.ii [*ii]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im_segment.opposite [*opposite]]]
+ []
+ ]
- template<
- typename P1 ,
- typename P2 >
- select_coordinate_type< P1, P2 >::type dot_product(
- P1 const & p1,
- P2 const & p2);
+ [
+ [[link boost_geometry.reference.de9im_segment.parallel [*parallel]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im_segment.ra [*ra]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.de9im_segment.rb [*rb]]]
+ []
+ ]
-[heading Parameters]
-
+]
-[variablelist
-
-[[p1][first point ]]
-[[p2][second point ]]
+[heading Description]
-]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/intersection_result.hpp]
-[heading Return Value]
-
-the dot product
+[*Convenience header: ][^boost/geometry.hpp]
+[section:as_char de9im_segment::as_char]
-[heading Requirements]
-[*Header: ][^boost/geometry/arithmetic/dot_product.hpp]
+['Inherited from de9im.]
-[*Convenience header: ][^boost/geometry.hpp]
+[indexterm2 as_char..de9im_segment]
+ static char as_char(
+ int v);
-[endsect]
+[endsect]
-[section:enrich_intersection_points enrich_intersection_points]
-[indexterm1 enrich_intersection_points]
-All intersection points are enriched with successor information.
+[section:bb de9im_segment::bb]
- template<
- typename TurnPoints ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename Strategy >
- void enrich_intersection_points(
- TurnPoints & turn_points,
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- Strategy const & strategy);
+['Inherited from de9im.]
+[indexterm2 bb..de9im_segment]
+ int bb;
-[variablelist
-
-[[TurnPoints][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
-]
+[endsect]
-[heading Parameters]
-
-[variablelist
-
-[[turn_points][container containing intersectionpoints ]]
-]
+[section:be de9im_segment::be]
+['Inherited from de9im.]
-[heading Requirements]
+[indexterm2 be..de9im_segment]
-[*Header: ][^boost/geometry/algorithms/overlay/enrich_intersection_points.hpp]
+ int be;
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:envelope envelope]
+[section:bi de9im_segment::bi]
-[indexterm1 envelope]
-Calculate envelope of a geometry.
+['Inherited from de9im.]
- template<
- typename Geometry ,
- typename Box >
- void envelope(
- Geometry const & geometry,
- Box & mbr);
+[indexterm2 bi..de9im_segment]
+ int bi;
-[heading Parameters]
-
-[variablelist
-
-[[geometry][the geometry ]]
+[endsect]
-[[mbr][the box receiving the envelope ]]
-]
+[section:collinear de9im_segment::collinear]
-[heading Example:]
-
-Example showing envelope calculation, using point\_ll latlong points
+[indexterm2 collinear..de9im_segment]
+ bool collinear;
+[endsect]
-[heading Requirements]
+[section:contains de9im_segment::contains]
-[*Header: ][^boost/geometry/algorithms/envelope.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+['Inherited from de9im.]
+[indexterm2 contains..de9im_segment]
-[endsect]
+ bool contains() const;
-[section:equals equals]
+[endsect]
-[indexterm1 equals]
-Detect if two geometries are spatially equal.
- template<
- typename Geometry1 ,
- typename Geometry2 >
- bool equals(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
+[section:crosses de9im_segment::crosses]
+['Inherited from de9im.]
+[indexterm2 crosses..de9im_segment]
-[variablelist
-
-[[Geometry1][first geometry type ]]
+ bool crosses() const;
-[[Geometry2][second geometry type ]]
-]
+[endsect]
-[heading Parameters]
-
-[variablelist
-
-[[geometry1][first geometry ]]
+[section:de9im_segment de9im_segment::de9im_segment]
-[[geometry2][second geometry ]]
+[indexterm2 de9im_segment..de9im_segment]
-]
+ ``[link boost_geometry.reference.de9im_segment.de9im_segment.overload1 de9im_segment]``();
+ `` [''''»''' [link boost_geometry.reference.de9im_segment.de9im_segment.overload1 more...]]``
+ ``[link boost_geometry.reference.de9im_segment.de9im_segment.overload2 de9im_segment]``(
+ double a,
+ double b,
+ int ii0,
+ int ib0,
+ int ie0,
+ int bi0,
+ int bb0,
+ int be0,
+ int ei0,
+ int eb0,
+ int ee0,
+ bool c = false,
+ bool o = false,
+ bool p = false,
+ bool d = false);
+ `` [''''»''' [link boost_geometry.reference.de9im_segment.de9im_segment.overload2 more...]]``
-[heading Return Value]
-
-true if geometries are spatially equal, else false
+[section:overload1 de9im_segment::de9im_segment (1 of 2 overloads)]
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/equals.hpp]
+ de9im_segment();
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:exception exception]
-
-Base exception class for GGL.
+[section:overload2 de9im_segment::de9im_segment (2 of 2 overloads)]
- struct exception
-[heading Requirements]
-[*Header: ][^boost/geometry/core/exception.hpp]
+ de9im_segment(
+ double a,
+ double b,
+ int ii0,
+ int ib0,
+ int ie0,
+ int bi0,
+ int bb0,
+ int be0,
+ int ei0,
+ int eb0,
+ int ee0,
+ bool c = false,
+ bool o = false,
+ bool p = false,
+ bool d = false);
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:exterior_ring exterior_ring]
-[indexterm1 exterior_ring]
-Function to get the exterior\_ring ring of a polygon.
+[endsect]
-
- template<
- typename Polygon >
- ring_type< Polygon >::type & ``[link boost_geometry.reference.exterior_ring.overload1 exterior_ring]``(
- Polygon & polygon);
- `` [''''»''' [link boost_geometry.reference.exterior_ring.overload1 more...]]``
- template<
- typename Polygon >
- const ring_type< Polygon >::type & ``[link boost_geometry.reference.exterior_ring.overload2 exterior_ring]``(
- Polygon const & polygon);
- `` [''''»''' [link boost_geometry.reference.exterior_ring.overload2 more...]]``
+[section:degenerate de9im_segment::degenerate]
-[heading Requirements]
+[indexterm2 degenerate..de9im_segment]
-[*Header: ][^boost/geometry/core/exterior_ring.hpp]
+ bool degenerate;
-[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 exterior_ring (1 of 2 overloads)]
-
+[endsect]
-Function to get the exterior\_ring ring of a polygon.
- template<
- typename Polygon >
- ring_type< Polygon >::type & exterior_ring(
- Polygon & polygon);
+[section:disjoint de9im_segment::disjoint]
+['Inherited from de9im.]
-[heading Remarks]
-
-OGC compliance: instead of ExteriorRing
+[indexterm2 disjoint..de9im_segment]
+ bool disjoint() const;
-[variablelist
-
-[[P][polygon type ]]
-]
+[endsect]
-[heading Parameters]
-
-[variablelist
-
-[[polygon][the polygon to get the exterior ring from ]]
+[section:eb de9im_segment::eb]
-]
+['Inherited from de9im.]
-[heading Return Value]
-
-a reference to the exterior ring
+[indexterm2 eb..de9im_segment]
+ int eb;
@@ -3519,351 +4310,248 @@
-[section:overload2 exterior_ring (2 of 2 overloads)]
+[section:ee de9im_segment::ee]
-Function to get the exterior ring of a polygon (const version).
+['Inherited from de9im.]
+[indexterm2 ee..de9im_segment]
- template<
- typename Polygon >
- const ring_type< Polygon >::type & exterior_ring(
- Polygon const & polygon);
+ int ee;
-[heading Remarks]
-
-OGC compliance: instead of ExteriorRing
+[endsect]
-[variablelist
-
-[[Polygon][polygon type ]]
+[section:ei de9im_segment::ei]
-]
+['Inherited from de9im.]
-[heading Parameters]
-
+[indexterm2 ei..de9im_segment]
-[variablelist
-
-[[polygon][the polygon to get the exterior ring from ]]
+ int ei;
-]
-[heading Return Value]
-
-a const reference to the exterior ring
+[endsect]
+[section:equals de9im_segment::equals]
-[endsect]
+['Inherited from de9im.]
-[endsect]
+[indexterm2 equals..de9im_segment]
-[section:for_each_point for_each_point]
+ bool equals() const;
-[indexterm1 for_each_point]
-Calls functor for geometry.
-
- template<
- typename Geometry ,
- typename Functor >
- Functor ``[link boost_geometry.reference.for_each_point.overload1 for_each_point]``(
- Geometry const & geometry,
- Functor f);
- `` [''''»''' [link boost_geometry.reference.for_each_point.overload1 more...]]``
- template<
- typename Geometry ,
- typename Functor >
- Functor ``[link boost_geometry.reference.for_each_point.overload2 for_each_point]``(
- Geometry & geometry,
- Functor f);
- `` [''''»''' [link boost_geometry.reference.for_each_point.overload2 more...]]``
+[endsect]
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/for_each.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:ib de9im_segment::ib]
-[section:overload1 for_each_point (1 of 2 overloads)]
+['Inherited from de9im.]
+[indexterm2 ib..de9im_segment]
-Calls functor for geometry.
+ int ib;
- template<
- typename Geometry ,
- typename Functor >
- Functor for_each_point(
- Geometry const & geometry,
- Functor f);
+[endsect]
-[heading Parameters]
-
-[variablelist
-
-[[geometry][geometry to loop through ]]
+[section:ie de9im_segment::ie]
-[[f][functor to use]]
-]
+['Inherited from de9im.]
-Calls the functor the specified const geometry
+[indexterm2 ie..de9im_segment]
+ int ie;
-[endsect]
+[endsect]
-[section:overload2 for_each_point (2 of 2 overloads)]
-Calls functor for geometry.
+[section:ii de9im_segment::ii]
- template<
- typename Geometry ,
- typename Functor >
- Functor for_each_point(
- Geometry & geometry,
- Functor f);
+['Inherited from de9im.]
+[indexterm2 ii..de9im_segment]
+ int ii;
-[heading Parameters]
-
-[variablelist
-
-[[geometry][geometry to loop through ]]
-[[f][functor to use]]
+[endsect]
-]
-Calls the functor for the specified geometry
+[section:intersects de9im_segment::intersects]
-[endsect]
+['Inherited from de9im.]
-[endsect]
+[indexterm2 intersects..de9im_segment]
-[section:for_each_segment for_each_segment]
+ bool intersects() const;
-[indexterm1 for_each_segment]
-Calls functor for segments on linestrings, rings, polygons, ...
-
- template<
- typename Geometry ,
- typename Functor >
- Functor ``[link boost_geometry.reference.for_each_segment.overload1 for_each_segment]``(
- Geometry const & geometry,
- Functor f);
- `` [''''»''' [link boost_geometry.reference.for_each_segment.overload1 more...]]``
- template<
- typename Geometry ,
- typename Functor >
- Functor ``[link boost_geometry.reference.for_each_segment.overload2 for_each_segment]``(
- Geometry & geometry,
- Functor f);
- `` [''''»''' [link boost_geometry.reference.for_each_segment.overload2 more...]]``
+[endsect]
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/for_each.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:opposite de9im_segment::opposite]
+[indexterm2 opposite..de9im_segment]
-[section:overload1 for_each_segment (1 of 2 overloads)]
+ bool opposite;
-Calls functor for segments on linestrings, rings, polygons, ...
+[endsect]
- template<
- typename Geometry ,
- typename Functor >
- Functor for_each_segment(
- Geometry const & geometry,
- Functor f);
+[section:overlaps de9im_segment::overlaps]
-[heading Parameters]
-
-[variablelist
-
-[[geometry][geometry to loop through ]]
+['Inherited from de9im.]
-[[f][functor to use]]
+[indexterm2 overlaps..de9im_segment]
-]
+ bool overlaps() const;
-Calls the functor all const segments of the specified const geometry
[endsect]
-[section:overload2 for_each_segment (2 of 2 overloads)]
+[section:parallel de9im_segment::parallel]
+[indexterm2 parallel..de9im_segment]
-Calls functor for segments on linestrings, rings, polygons, ...
+ bool parallel;
- template<
- typename Geometry ,
- typename Functor >
- Functor for_each_segment(
- Geometry & geometry,
- Functor f);
+[endsect]
-[heading Parameters]
-
-[variablelist
-
-[[geometry][geometry to loop through ]]
+[section:ra de9im_segment::ra]
-[[f][functor to use]]
+[indexterm2 ra..de9im_segment]
-]
+ double ra;
-Calls the functor all segments of the specified geometry
[endsect]
-[endsect]
-[section:geographic_tag geographic_tag]
+[section:rb de9im_segment::rb]
+[indexterm2 rb..de9im_segment]
-Tag indicating Geographic coordinate system family (geographic).
+ double rb;
- struct geographic_tag
-[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:touches de9im_segment::touches]
-[section:geometry_id geometry_id]
+['Inherited from de9im.]
-Meta-function the id for a geometry type.
+[indexterm2 touches..de9im_segment]
+ bool touches() const;
- template<
- typename Geometry >
- struct geometry_id
-[heading Remarks]
-
-Used for e.g. reverse meta-function
+[endsect]
-[heading Requirements]
-[*Header: ][^boost/geometry/core/geometry_id.hpp]
+[section:within de9im_segment::within]
-[*Convenience header: ][^boost/geometry.hpp]
+['Inherited from de9im.]
-[endsect]
+[indexterm2 within..de9im_segment]
-[section:geometry_not_recognized_tag geometry_not_recognized_tag]
+ bool within() const;
-"default" tag
+[endsect]
- struct geometry_not_recognized_tag
-[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
+[section:degree degree]
-[endsect]
-[section:get get]
+Unit of plane angle: Degrees.
-[indexterm1 get]
-get coordinate value of a Point ( / Sphere)
-
- template<
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- coordinate_type< Geometry >::type ``[link boost_geometry.reference.get.overload1 get]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.get.overload1 more...]]``
- template<
- std::size_t ``[link boost_geometry.reference.Index Index]``,
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- coordinate_type< Geometry >::type ``[link boost_geometry.reference.get.overload2 get]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.get.overload2 more...]]``
+
+[heading Synopsis]
+ class degree
+
+[heading Description]
[heading Requirements]
-[*Header: ][^boost/geometry/core/access.hpp]
+[*Header: ][^boost/geometry/core/cs.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 get (1 of 2 overloads)]
+[endsect]
-get coordinate value of a Point ( / Sphere)
+[section:difference difference]
+[indexterm1 difference]
template<
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- coordinate_type< Geometry >::type get(
- Geometry const & geometry);
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Collection >
+ void difference(
+ Geometry1 const & geometry1,
+ Geometry2 geometry2,
+ Collection & output_collection);
[variablelist
-[[Dimension][dimension ]]
-
-[[Geometry][geometry ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
]
@@ -3873,98 +4561,68 @@
[variablelist
-[[geometry][geometry to query coordinate value from ]]
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make difference ]]
]
-[heading Return Value]
-
-coordinate value
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/difference.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:dimension dimension]
-[section:overload2 get (2 of 2 overloads)]
+Meta-function which defines coordinate dimensions, i.e. the number of axes of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
-get coordinate value of a Box / Segment
- template<
- std::size_t ``[link boost_geometry.reference.Index Index]``,
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- coordinate_type< Geometry >::type get(
- Geometry const & geometry);
+[heading Synopsis]
+ template<
+ typename G >
+ struct dimension
+[heading Description]
+[heading Requirements]
-[variablelist
-
-[[Index][for Point: do not specifyfor Box: min\_corner or max\_cornerfor Segment: 0 / 1
-]]
+[*Header: ][^boost/geometry/core/coordinate_dimension.hpp]
-[[Dimension][dimension ]]
+[*Convenience header: ][^boost/geometry.hpp]
-[[Geometry][geometry ]]
-]
+[endsect]
-[heading Parameters]
-
+[section:disjoint disjoint]
-[variablelist
-
-[[geometry][geometry to query coordinate value from ]]
-
-]
-
-
-[heading Return Value]
-
-coordinate value
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_as_radian get_as_radian]
-
-[indexterm1 get_as_radian]
-get coordinate value of a point, result is in Radian
+[indexterm1 disjoint]
+Calculate if two geometries are disjoint.
template<
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- coordinate_type< Geometry >::type get_as_radian(
- const Geometry & geometry);
-
+ typename Geometry1 ,
+ typename Geometry2 >
+ bool disjoint(
+ const Geometry1 & geometry1,
+ const Geometry2 & geometry2);
-Result is in Radian, even if source coordinate system is in Degrees
-[heading Return Value]
-
-coordinate value
[variablelist
-[[Dimension][dimension ]]
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Geometry][geometry ]]
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
]
@@ -3974,20 +4632,22 @@
[variablelist
-[[geometry][geometry to get coordinate value from ]]
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
-[heading Remarks]
+[heading Return Value]
-Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems
+true if disjoint, else false
[heading Requirements]
-[*Header: ][^boost/geometry/core/radian_access.hpp]
+[*Header: ][^boost/geometry/algorithms/disjoint.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -3996,29 +4656,27 @@
-[section:get_section get_section]
+[section:dissolve dissolve]
-[indexterm1 get_section]
-Get iterators for a specified section.
+[indexterm1 dissolve]
+Removes self intersections from a [link boost_geometry.reference.boost__geometry `boost::geometry`].
template<
typename Geometry ,
- typename Section >
- void get_section(
+ typename OutputIterator >
+ OutputIterator dissolve(
Geometry const & geometry,
- Section const & section,
- typename boost::range_const_iterator< typename geometry::range_type< Geometry >::type >::type & begin,
- typename boost::range_const_iterator< typename geometry::range_type< Geometry >::type >::type & end);
+ OutputIterator output);
[variablelist
-[[Geometry][type ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Section][type of section to get from ]]
+[[OutputIterator][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
]
@@ -4028,13 +4686,9 @@
[variablelist
-[[geometry][geometry which might be located in the neighborhood ]]
-
-[[section][structure with section ]]
-
-[[begin][begin-iterator (const iterator over points of section) ]]
+[[geometry][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[end][end-iterator (const iterator over points of section) ]]
+[[output][container which will contain intersection points ]]
]
@@ -4042,7 +4696,7 @@
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/get_section.hpp]
+[*Header: ][^boost/geometry/algorithms/dissolve.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -4050,119 +4704,98 @@
[endsect]
-[section:get_turns get_turns]
-
-[indexterm1 get_turns]
-Calculate intersection points of two geometries.
+[section:distance distance]
-
+[indexterm1 distance]
+
template<
- typename AssignPolicy ,
typename Geometry1 ,
typename Geometry2 ,
- typename Turns ,
- typename InterruptPolicy >
- void ``[link boost_geometry.reference.get_turns.overload1 get_turns]``(
+ typename Strategy >
+ Strategy::return_type ``[link boost_geometry.reference.distance.overload1 distance]``(
Geometry1 const & geometry1,
Geometry2 const & geometry2,
- Turns & turns,
- InterruptPolicy & interrupt_policy);
- `` [''''»''' [link boost_geometry.reference.get_turns.overload1 more...]]``
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.distance.overload1 more...]]``
template<
- typename AssignPolicy ,
- typename Geometry ,
- typename Turns ,
- typename InterruptPolicy >
- void ``[link boost_geometry.reference.get_turns.overload2 get_turns]``(
- Geometry const & geometry,
- Turns & turns,
- InterruptPolicy & interrupt_policy);
- `` [''''»''' [link boost_geometry.reference.get_turns.overload2 more...]]``
-
-[heading Requirements]
-
-[*Header: ][^boost/geometry/algorithms/overlay/get_turns.hpp]
-
-[*Convenience header: ][^boost/geometry.hpp]
-
-
-[section:overload1 get_turns (1 of 2 overloads)]
+ typename Geometry1 ,
+ typename Geometry2 >
+ distance_result< Geometry1, Geometry2 >::type ``[link boost_geometry.reference.distance.overload2 distance]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
+ `` [''''»''' [link boost_geometry.reference.distance.overload2 more...]]``
+The distance algorithm returns the distance between two geometries.
+[heading Coordinate systems and strategies:]
+
+With help of strategies the distance function returns the appropriate distance. If the input is in cartesian coordinates, the Euclidian distance (Pythagoras) is calculated. If the input is in spherical coordinates (either degree or radian), the distance over the sphere is returned. If the input is in geographic coordinates, distance is calculated over the globe and returned in meters.
-Calculate intersection points of two geometries.
+[heading Distance result:]
+
+Depending on calculation type the distance result is either a structure, convertable to a double, or a double value. In case of Pythagoras it makes sense to not draw the square root in the strategy itself. Taking a square root is relative expensive and is not necessary when comparing distances.
- template<
- typename AssignPolicy ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename Turns ,
- typename InterruptPolicy >
- void get_turns(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- Turns & turns,
- InterruptPolicy & interrupt_policy);
+[heading Geometries:]
+
+Currently implemented, for both cartesian and spherical/geographic:
+* POINT - POINT
+* POINT - SEGMENT and v.v.
+* POINT - LINESTRING and v.v.
-[variablelist
-
-[[Geometry1][first geometry type ]]
-[[Geometry2][second geometry type ]]
-[[Turns][type of turn-container (e.g. vector of "intersection/turn point"'s) ]]
+Not yet implemented:
+* POINT - RING etc, note that it will return a zero if the point is anywhere within the ring
-]
-[heading Parameters]
-
-[variablelist
+[heading Example:]
-[[geometry1][first geometry ]]
+Example showing distance calculation of two points, in xy and in latlong coordinates
-[[geometry2][second geometry ]]
-[[turns][container which will contain intersection points ]]
-]
-[endsect]
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/distance.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:overload2 get_turns (2 of 2 overloads)]
+[section:overload1 distance (1 of 2 overloads)]
-Calculate self intersections of a geometry.
+Calculate distance between two geometries with a specified [link boost_geometry.reference.strategy `strategy`].
template<
- typename AssignPolicy ,
- typename Geometry ,
- typename Turns ,
- typename InterruptPolicy >
- void get_turns(
- Geometry const & geometry,
- Turns & turns,
- InterruptPolicy & interrupt_policy);
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Strategy >
+ Strategy::return_type distance(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ Strategy const & strategy);
[variablelist
-[[Geometry][geometry type ]]
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Turns][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[S][point-point-distance [link boost_geometry.reference.strategy `strategy`] type ]]
]
@@ -4172,67 +4805,61 @@
[variablelist
-[[geometry][geometry ]]
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[turns][container which will contain intersection points ]]
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-]
+[[strategy][[link boost_geometry.reference.strategy `strategy`] to calculate distance between two points ]]
+]
+[heading Return Value]
+
+the distance (either a double or a [link boost_geometry.reference.distance_result `distance_result`], (convertable to double))
-[endsect]
+[heading Remarks]
+
+The [link boost_geometry.reference.strategy `strategy`] can be a point-point [link boost_geometry.reference.strategy `strategy`]. In case of distance point-line/point-polygon it may also be a point-segment [link boost_geometry.reference.strategy `strategy`].
-[endsect]
-[section:interior_rings interior_rings]
+[heading Example:]
+
+Example showing distance calculation of two lat long points, using the accurate Vincenty approximation
-[indexterm1 interior_rings]
-Function to get the interior rings of a polygon (non const version).
-
- template<
- typename Polygon >
- interior_type< Polygon >::type & ``[link boost_geometry.reference.interior_rings.overload1 interior_rings]``(
- Polygon & polygon);
- `` [''''»''' [link boost_geometry.reference.interior_rings.overload1 more...]]``
- template<
- typename Polygon >
- const interior_type< Polygon >::type & ``[link boost_geometry.reference.interior_rings.overload2 interior_rings]``(
- Polygon const & polygon);
- `` [''''»''' [link boost_geometry.reference.interior_rings.overload2 more...]]``
-[heading Requirements]
-[*Header: ][^boost/geometry/core/interior_rings.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 interior_rings (1 of 2 overloads)]
+[endsect]
-Function to get the interior rings of a polygon (non const version).
+[section:overload2 distance (2 of 2 overloads)]
- template<
- typename Polygon >
- interior_type< Polygon >::type & interior_rings(
- Polygon & polygon);
+Calculate distance between two geometries.
-[heading Remarks]
-
-OGC compliance: instead of InteriorRingN
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ distance_result< Geometry1, Geometry2 >::type distance(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
+The default [link boost_geometry.reference.strategy `strategy`] is used, belonging to the corresponding coordinate system of the geometries
[variablelist
-[[P][polygon type ]]
+[[G1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[G2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
]
@@ -4242,14 +4869,16 @@
[variablelist
-[[polygon][the polygon to get the interior rings from ]]
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
[heading Return Value]
-a reference to the interior rings
+the distance (either a double or a distance result, convertable to double)
@@ -4257,64 +4886,85 @@
[endsect]
+[endsect]
-[section:overload2 interior_rings (2 of 2 overloads)]
+[section:distance_result distance_result]
-Function to get the interior rings of a polygon (const version).
+Shortcut to define return type of distance [link boost_geometry.reference.strategy `strategy`].
- template<
- typename Polygon >
- const interior_type< Polygon >::type & interior_rings(
- Polygon const & polygon);
+[heading Synopsis]
+ template<
+ typename ``[link boost_geometry.reference.Geometry1 Geometry1]``,
+ typename ``[link boost_geometry.reference.Geometry2 Geometry2]`` = Geometry1>
+ struct distance_result
-[heading Remarks]
-
-OGC compliance: instead of InteriorRingN
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.distance_result.point_type1 [*point_type1]]]
+ []
+
+ ]
-[variablelist
+ [
+
+ [[link boost_geometry.reference.distance_result.point_type2 [*point_type2]]]
+ []
-[[P][polygon type ]]
+ ]
-]
+ [
+ [[link boost_geometry.reference.distance_result.strategy_type [*strategy_type]]]
+ []
+
+ ]
-[heading Parameters]
-
+ [
-[variablelist
+ [[link boost_geometry.reference.distance_result.type [*type]]]
+ []
-[[polygon][the polygon to get the interior rings from ]]
+ ]
]
-[heading Return Value]
-
-a const reference to the interior rings
+[heading Description]
+[variablelist
+
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[endsect]
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+]
-[endsect]
-[section:interior_type interior_type]
+[heading Requirements]
-Meta-function defining container type of inner rings of (multi)polygon geometriy.
+[*Header: ][^boost/geometry/strategies/distance_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:point_type1 distance_result::point_type1]
+
+[indexterm2 point_type1..distance_result]
+
+ typedef point_type< Geometry1 >::type point_type1;
- template<
- typename Geometry >
- struct interior_type
[heading Public Types]
[table
@@ -4322,27 +4972,39 @@
[
- [[link boost_geometry.reference.interior_type.type [*type]]]
+ [[link boost_geometry.reference.point_type.ncg [*ncg]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point_type.type [*type]]]
[]
]
]
-the interior rings should be organized as a container (std::vector, std::deque, boost::array) with boost range support. This meta function defines the type of that container.
+[heading Typedef Description]
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/interior_rings.hpp]
+[*Header: ][^boost/geometry/strategies/distance_result.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:type interior_type::type]
+[endsect]
-[indexterm2 type..interior_type]
- typedef core_dispatch::interior_type< typename tag< Geometry >::type, Geometry >::type type;
+
+[section:point_type2 distance_result::point_type2]
+
+[indexterm2 point_type2..distance_result]
+
+ typedef point_type< Geometry2 >::type point_type2;
@@ -4352,29 +5014,26 @@
[
- [[link boost_geometry.reference.tag.type [*type]]]
+ [[link boost_geometry.reference.point_type.ncg [*ncg]]]
[]
]
-]
-
-[heading Typedef Description]
-
-All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+ [
-[variablelist
+ [[link boost_geometry.reference.point_type.type [*type]]]
+ []
-[[Geometry][geometry ]]
+ ]
]
-
-
+[heading Typedef Description]
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/interior_rings.hpp]
+[*Header: ][^boost/geometry/strategies/distance_result.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -4383,61 +5042,49 @@
-[endsect]
-
+[section:strategy_type distance_result::strategy_type]
-[section:intersection intersection]
+[indexterm2 strategy_type..distance_result]
-[indexterm1 intersection]
-Intersects two geometries.
+ typedef strategy_distance< typename cs_tag< point_type1 >::type, typename cs_tag< point_type2 >::type, point_type1, point_type2 >::type strategy_type;
- template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename Collection >
- void intersection(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- Collection & output_collection);
+[heading Public Types]
+[table
+ [[Name][Description]]
-The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are added to the specified collection.
+ [
-[variablelist
+ [[link boost_geometry.reference.strategy_distance.type [*type]]]
+ []
-[[Geometry1][first geometry type ]]
-
-[[Geometry2][second geometry type ]]
-
-[[Collection][collection of rings, polygons (e.g. a vector<polygon> or a multi\_polygon) ]]
+ ]
]
-
-[heading Parameters]
+[heading Typedef Description]
+
[variablelist
-[[geometry1][first geometry ]]
+[[T1][[link boost_geometry.reference.tag `tag`] of coordinate system of first [link boost_geometry.reference.point `point`] type ]]
-[[geometry2][second geometry ]]
+[[T2][[link boost_geometry.reference.tag `tag`] of coordinate system of second [link boost_geometry.reference.point `point`] type ]]
-[[output_collection][the collection ]]
+[[P1][first point-type ]]
-]
+[[P2][second point-type ]]
+]
-[heading Return Value]
-
-true if successful
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/intersection.hpp]
+[*Header: ][^boost/geometry/strategies/distance_result.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -4445,136 +5092,119 @@
[endsect]
-[section:intersection_inserter intersection_inserter]
-[indexterm1 intersection_inserter]
-Intersects two geometries.
+[section:type distance_result::type]
+
+[indexterm2 type..distance_result]
+
+ typedef strategy_type::return_type type;
-
- template<
- typename GeometryOut ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename OutputIterator ,
- typename Strategy >
- OutputIterator ``[link boost_geometry.reference.intersection_inserter.overload1 intersection_inserter]``(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- OutputIterator out,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.intersection_inserter.overload1 more...]]``
- template<
- typename GeometryOut ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename OutputIterator >
- OutputIterator ``[link boost_geometry.reference.intersection_inserter.overload2 intersection_inserter]``(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- OutputIterator out);
- `` [''''»''' [link boost_geometry.reference.intersection_inserter.overload2 more...]]``
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/intersection.hpp]
+[*Header: ][^boost/geometry/strategies/distance_result.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 intersection_inserter (1 of 2 overloads)]
+[endsect]
-Intersects two geometries.
+
+[endsect]
+
+
+[section:divide_point divide_point]
+
+[indexterm1 divide_point]
+Divides a [link boost_geometry.reference.point `point`] by another.
template<
- typename GeometryOut ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename OutputIterator ,
- typename Strategy >
- OutputIterator intersection_inserter(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- OutputIterator out,
- Strategy const & strategy);
+ typename Point1 ,
+ typename Point2 >
+ void divide_point(
+ Point1 & p1,
+ Point2 const & p2);
-The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are sent to the specified output operator.
+The coordinates of the second [link boost_geometry.reference.point `point`] will be divided by those of the first [link boost_geometry.reference.point `point`]. The second [link boost_geometry.reference.point `point`] is not modified.
+[heading Parameters]
+
[variablelist
-[[GeometryOut][output geometry type, must be specified ]]
+[[p1][first [link boost_geometry.reference.point `point`] ]]
-[[Geometry1][first geometry type ]]
+[[p2][second [link boost_geometry.reference.point `point`] ]]
-[[Geometry2][second geometry type ]]
+]
-[[OutputIterator][output iterator ]]
-[[Strategy][compound strategy for intersection ]]
-]
+[heading Requirements]
+[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
-[heading Parameters]
-
+[*Convenience header: ][^boost/geometry.hpp]
-[variablelist
-
-[[geometry1][first geometry ]]
-[[geometry2][second geometry ]]
+[endsect]
-[[out][the output iterator, outputting linestrings or polygons ]]
-[[strategy][the strategy ]]
-]
+[section:divide_value divide_value]
+[indexterm1 divide_value]
+Divides each coordinate of a [link boost_geometry.reference.point `point`] by a value.
-[heading Return Value]
-
-the output iterator
+ template<
+ typename Point >
+ void divide_value(
+ Point & p,
+ typename detail::param< Point >::type value);
-[endsect]
+[heading Parameters]
+
+[variablelist
+
+[[p][[link boost_geometry.reference.point `point`] ]]
+[[value][value to divide by ]]
-[section:overload2 intersection_inserter (2 of 2 overloads)]
+]
-Intersects two geometries.
+[heading Requirements]
- template<
- typename GeometryOut ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename OutputIterator >
- OutputIterator intersection_inserter(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- OutputIterator out);
+[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are sent to the specified output operator.
-[variablelist
-
-[[GeometryOut][output geometry type, must be specified ]]
+[endsect]
-[[Geometry1][first geometry type ]]
-[[Geometry2][second geometry type ]]
-[[OutputIterator][output iterator ]]
+[section:dot_product dot_product]
+
+[indexterm1 dot_product]
+Computes the dot product (or scalar product) of 2 vectors (points).
+
+
+ template<
+ typename P1 ,
+ typename P2 >
+ select_coordinate_type< P1, P2 >::type dot_product(
+ P1 const & p1,
+ P2 const & p2);
-]
[heading Parameters]
@@ -4582,148 +5212,137 @@
[variablelist
-[[geometry1][first geometry ]]
+[[p1][first [link boost_geometry.reference.point `point`] ]]
-[[geometry2][second geometry ]]
-
-[[out][the output iterator, outputting linestrings or polygons ]]
+[[p2][second [link boost_geometry.reference.point `point`] ]]
]
[heading Return Value]
-the output iterator
+the dot product
+[heading Requirements]
-[endsect]
+[*Header: ][^boost/geometry/arithmetic/dot_product.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:intersects intersects]
-[indexterm1 intersects]
-
- template<
- typename Geometry >
- bool ``[link boost_geometry.reference.intersects.overload1 intersects]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.intersects.overload1 more...]]``
+
+[section:enrich_intersection_points enrich_intersection_points]
+
+[indexterm1 enrich_intersection_points]
+All intersection points are enriched with successor information.
+
template<
+ typename TurnPoints ,
typename Geometry1 ,
- typename Geometry2 >
- bool ``[link boost_geometry.reference.intersects.overload2 intersects]``(
+ typename Geometry2 ,
+ typename Strategy >
+ void enrich_intersection_points(
+ TurnPoints & turn_points,
Geometry1 const & geometry1,
- Geometry2 const & geometry2);
- `` [''''»''' [link boost_geometry.reference.intersects.overload2 more...]]``
+ Geometry2 const & geometry2,
+ Strategy const & strategy);
-[heading Source descriptions:]
+
+
+[variablelist
+[[TurnPoints][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
-* OGC description: Returns 1 (TRUE) if this geometric object spatially intersects anotherGeometry.
+]
-* OGC: a.Intersects(b) <=> ! a.Disjoint(b)
+[heading Parameters]
+
+[variablelist
+
+[[turn_points][container containing intersectionpoints ]]
+]
-[heading Remarks]
-
-There are two overloaded versions:
-* with one geometry, detecting self-intersections
-* with two geometries, deferring to disjoint, returning !disjoint
+[heading Requirements]
+[*Header: ][^boost/geometry/algorithms/overlay/enrich_intersection_points.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Geometries:]
-
-* ring
-
-* polygon
-
-* for two geometries: same is disjoint
-
-
-
-
-[heading Remarks]
-
-if one geometry is completely within another geometry, it "intersects"
-
-
-
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/algorithms/intersects.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:envelope envelope]
-[section:overload1 intersects (1 of 2 overloads)]
+[indexterm1 envelope]
+Calculate envelope of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
-Determine if there is at least one intersection (crossing or self-tangency).
+ template<
+ typename Geometry ,
+ typename Box >
+ void envelope(
+ Geometry const & geometry,
+ Box & mbr);
- template<
- typename Geometry >
- bool intersects(
- Geometry const & geometry);
+[heading Parameters]
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[heading Remarks]
-
-This function can be called for one geometry (self-intersection) and also for two geometries (intersection)
+[[mbr][the [link boost_geometry.reference.box `box`] receiving the envelope ]]
+]
-[variablelist
+[heading Example:]
-[[Geometry][geometry type ]]
+Example showing envelope calculation, using point\_ll latlong points
-]
-[heading Parameters]
-
-[variablelist
-
-[[geometry][geometry ]]
-]
-[heading Return Value]
-
-true if there are intersections, else false
+[heading Requirements]
+[*Header: ][^boost/geometry/algorithms/envelope.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:overload2 intersects (2 of 2 overloads)]
-
+[section:equals equals]
-Determine if there is at least one intersection.
+[indexterm1 equals]
+Detect if two geometries are spatially equal.
template<
typename Geometry1 ,
typename Geometry2 >
- bool intersects(
+ bool equals(
Geometry1 const & geometry1,
Geometry2 const & geometry2);
@@ -4732,9 +5351,9 @@
[variablelist
-[[Geometry1][first geometry type ]]
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Geometry2][second geometry type ]]
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
]
@@ -4744,307 +5363,378 @@
[variablelist
-[[geometry1][first geometry ]]
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[geometry2][second geometry ]]
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
[heading Return Value]
-true if there are intersection(s), else false
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:is_linear is_linear]
-
-
-Meta-function defining "true" for linear types (linestring,ring), "false" for non-linear typse.
-
-
- template<
- typename Geometry >
- struct is_linear
-
-[heading Remarks]
-
-Used for tag dispatching and meta-function finetuning
+true if geometries are spatially equal, else false
[heading Requirements]
-[*Header: ][^boost/geometry/core/is_linear.hpp]
+[*Header: ][^boost/geometry/algorithms/equals.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:is_multi is_multi]
-
-
-Meta-function defining "true" for multi geometries (multi\_point, etc).
-
-
- template<
- typename Geometry >
- struct is_multi
-[heading Requirements]
-[*Header: ][^boost/geometry/core/is_multi.hpp]
+[section:exception exception]
-[*Convenience header: ][^boost/geometry.hpp]
+Base [link boost_geometry.reference.exception `exception`] class for GGL.
-[endsect]
-[section:is_radian is_radian]
-Meta-function to verify if a coordinate system is radian.
+[heading Synopsis]
+ struct exception
+[heading Description]
- template<
- typename CoordinateSystem >
- struct is_radian
[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
+[*Header: ][^boost/geometry/core/exception.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:length length]
+[section:exterior_ring exterior_ring]
-[indexterm1 length]
-
+[indexterm1 exterior_ring]
+Function to get the exterior\_ring ring of a [link boost_geometry.reference.polygon `polygon`].
+
+
template<
- typename Geometry >
- length_result< Geometry >::type ``[link boost_geometry.reference.length.overload1 length]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.length.overload1 more...]]``
+ typename Polygon >
+ ring_type< Polygon >::type & ``[link boost_geometry.reference.exterior_ring.overload1 exterior_ring]``(
+ Polygon & polygon);
+ `` [''''»''' [link boost_geometry.reference.exterior_ring.overload1 more...]]``
template<
- typename Geometry ,
- typename Strategy >
- length_result< Geometry >::type ``[link boost_geometry.reference.length.overload2 length]``(
- Geometry const & geometry,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.length.overload2 more...]]``
+ typename Polygon >
+ const ring_type< Polygon >::type & ``[link boost_geometry.reference.exterior_ring.overload2 exterior_ring]``(
+ Polygon const & polygon);
+ `` [''''»''' [link boost_geometry.reference.exterior_ring.overload2 more...]]``
-The length algorithm is implemented for the linestring and the multi\_linestring geometry and results in the length of the linestring. If the points of a linestring have coordinates expressed in kilometers, the length of the line is expressed in kilometers as well.
-[heading Example:]
-
-Example showing length calculation
+[heading Requirements]
+[*Header: ][^boost/geometry/core/exterior_ring.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
+[section:overload1 exterior_ring (1 of 2 overloads)]
+Function to get the exterior\_ring ring of a [link boost_geometry.reference.polygon `polygon`].
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/length.hpp]
+ template<
+ typename Polygon >
+ ring_type< Polygon >::type & exterior_ring(
+ Polygon & polygon);
-[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 length (1 of 2 overloads)]
+[heading Remarks]
+
+OGC compliance: instead of ExteriorRing
-Calculate length of a geometry.
+[variablelist
+
+[[P][[link boost_geometry.reference.polygon `polygon`] type ]]
- template<
- typename Geometry >
- length_result< Geometry >::type length(
- Geometry const & geometry);
+]
-The function length returns the length of a geometry, using the default distance-calculation-strategy
[heading Parameters]
[variablelist
-[[geometry][the geometry, being a [link boost_geometry.reference.linestring `linestring`], vector, iterator pair, or any other boost compatible range ]]
+[[polygon][the [link boost_geometry.reference.polygon `polygon`] to get the exterior ring from ]]
]
[heading Return Value]
-the length Example showing length calculation on a vector
+a reference to the exterior ring
+[endsect]
+[section:overload2 exterior_ring (2 of 2 overloads)]
-[endsect]
+Function to get the exterior ring of a [link boost_geometry.reference.polygon `polygon`] (const version).
-[section:overload2 length (2 of 2 overloads)]
+ template<
+ typename Polygon >
+ const ring_type< Polygon >::type & exterior_ring(
+ Polygon const & polygon);
-Calculate length of a geometry.
+[heading Remarks]
+
+OGC compliance: instead of ExteriorRing
- template<
- typename Geometry ,
- typename Strategy >
- length_result< Geometry >::type length(
- Geometry const & geometry,
- Strategy const & strategy);
-The function length returns the length of a geometry, using specified strategy
+[variablelist
+
+[[Polygon][[link boost_geometry.reference.polygon `polygon`] type ]]
+
+]
+
+
[heading Parameters]
[variablelist
-[[geometry][the geometry, being a [link boost_geometry.reference.linestring `linestring`], vector, iterator pair, or any other boost compatible range ]]
-
-[[strategy][strategy to be used for distance calculations. ]]
+[[polygon][the [link boost_geometry.reference.polygon `polygon`] to get the exterior ring from ]]
]
[heading Return Value]
-the length
+a const reference to the exterior ring
-[heading Example:]
-
-Example showing length calculation using iterators and the Vincenty strategy
+[endsect]
+
+
+[endsect]
+[section:for_each_point for_each_point]
+[indexterm1 for_each_point]
+Calls functor for [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor ``[link boost_geometry.reference.for_each_point.overload1 for_each_point]``(
+ Geometry const & geometry,
+ Functor f);
+ `` [''''»''' [link boost_geometry.reference.for_each_point.overload1 more...]]``
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor ``[link boost_geometry.reference.for_each_point.overload2 for_each_point]``(
+ Geometry & geometry,
+ Functor f);
+ `` [''''»''' [link boost_geometry.reference.for_each_point.overload2 more...]]``
+[heading Requirements]
-[endsect]
+[*Header: ][^boost/geometry/algorithms/for_each.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
-[section:linear_ring linear_ring]
+[section:overload1 for_each_point (1 of 2 overloads)]
-A [link boost_geometry.reference.linear_ring `linear_ring`] (linear [link boost_geometry.reference.linear_ring `linear_ring`]) is a closed line which should not be selfintersecting.
+Calls functor for [link boost_geometry.reference.boost__geometry `boost::geometry`].
template<
- typename ``[link boost_geometry.reference.P P]``,
- template< typename, typename > class ``[link boost_geometry.reference.V V]`` = std::vector,
- bool ``[link boost_geometry.reference.ClockWise ClockWise]`` = true,
- template< typename > class ``[link boost_geometry.reference.A A]`` = std::allocator>
- class linear_ring
+ typename Geometry ,
+ typename Functor >
+ Functor for_each_point(
+ Geometry const & geometry,
+ Functor f);
+
+[heading Parameters]
+
+
[variablelist
-[[P][point type ]]
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]]
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
-
-[[A][optional container-allocator-type ]]
+[[f][functor to use]]
]
+Calls the functor the specified const [link boost_geometry.reference.boost__geometry `boost::geometry`]
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/geometries/linear_ring.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:overload2 for_each_point (2 of 2 overloads)]
-[endsect]
-[section:linestring linestring]
+Calls functor for [link boost_geometry.reference.boost__geometry `boost::geometry`].
-A linestring (named so by OGC) is a collection (default a vector) of points.
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor for_each_point(
+ Geometry & geometry,
+ Functor f);
- template<
- typename P ,
- template< typename, typename > class ``[link boost_geometry.reference.V V]`` = std::vector,
- template< typename > class ``[link boost_geometry.reference.A A]`` = std::allocator>
- class linestring
+[heading Parameters]
+
[variablelist
-[[P][point type ]]
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]]
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
-
-[[A][optional container-allocator-type (see http://accu.org/index.php/journals/427#ftn.d0e249 ) ]]
+[[f][functor to use]]
]
+Calls the functor for the specified [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
+
+[endsect]
+
+[endsect]
+
+[section:for_each_segment for_each_segment]
+
+[indexterm1 for_each_segment]
+Calls functor for segments on linestrings, rings, polygons, ...
+
+
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor ``[link boost_geometry.reference.for_each_segment.overload1 for_each_segment]``(
+ Geometry const & geometry,
+ Functor f);
+ `` [''''»''' [link boost_geometry.reference.for_each_segment.overload1 more...]]``
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor ``[link boost_geometry.reference.for_each_segment.overload2 for_each_segment]``(
+ Geometry & geometry,
+ Functor f);
+ `` [''''»''' [link boost_geometry.reference.for_each_segment.overload2 more...]]``
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/linestring.hpp]
+[*Header: ][^boost/geometry/algorithms/for_each.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:overload1 for_each_segment (1 of 2 overloads)]
-[section:linestring_2d linestring_2d]
+Calls functor for segments on linestrings, rings, polygons, ...
-[indexterm1 linestring_2d]
- typedef linestring< point_2d > linestring_2d;
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor for_each_segment(
+ Geometry const & geometry,
+ Functor f);
-[heading Typedef Description]
-
+[heading Parameters]
+
[variablelist
-[[P][point type ]]
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]]
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
+[[f][functor to use]]
+
+]
+
+Calls the functor all const segments of the specified const [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
+
+[endsect]
+
+
+
+[section:overload2 for_each_segment (2 of 2 overloads)]
+
+
+Calls functor for segments on linestrings, rings, polygons, ...
-[[A][optional container-allocator-type (see http://accu.org/index.php/journals/427#ftn.d0e249 ) ]]
+
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor for_each_segment(
+ Geometry & geometry,
+ Functor f);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]]
+
+[[f][functor to use]]
]
+Calls the functor all segments of the specified [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
+
+[endsect]
+
+
+[endsect]
+
+[section:fuzzy_equals fuzzy_equals]
+[indexterm1 fuzzy_equals]
+
+ template<
+ typename T >
+ bool fuzzy_equals(
+ T const & left,
+ T const & right);
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+[*Header: ][^boost/geometry/strategies/distance_result.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -5052,583 +5742,9388 @@
[endsect]
+[section:geographic_tag geographic_tag]
-[section:linestring_3d linestring_3d]
-[indexterm1 linestring_3d]
+Tag indicating Geographic coordinate system family (geographic).
- typedef linestring< point_3d > linestring_3d;
-[heading Typedef Description]
+
+[heading Synopsis]
+ struct geographic_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:geometry_id geometry_id]
+
+
+Meta-function the id for a [link boost_geometry.reference.boost__geometry `boost::geometry`] type.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ struct geometry_id
+
+[heading Description]
+
+
+[heading Remarks]
+
+Used for e.g. reverse meta-function
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/geometry_id.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:geometry_not_recognized_tag geometry_not_recognized_tag]
+
+
+"default" [link boost_geometry.reference.tag `tag`]
+
+
+
+
+[heading Synopsis]
+ struct geometry_not_recognized_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:get get]
+
+[indexterm1 get]
+get coordinate value of a Point ( / Sphere)
+
+ template<
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ coordinate_type< Geometry >::type ``[link boost_geometry.reference.get.overload1 get]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.get.overload1 more...]]``
+
+ template<
+ std::size_t ``[link boost_geometry.reference.Index Index]``,
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ coordinate_type< Geometry >::type ``[link boost_geometry.reference.get.overload2 get]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.get.overload2 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/access.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 get (1 of 2 overloads)]
+
+
+get coordinate value of a Point ( / Sphere)
+
+
+ template<
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ coordinate_type< Geometry >::type get(
+ Geometry const & geometry);
+
+
[variablelist
-[[P][point type ]]
-
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
+[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
-[[A][optional container-allocator-type (see http://accu.org/index.php/journals/427#ftn.d0e249 ) ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
+[heading Parameters]
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to query coordinate value from ]]
+]
-[heading Requirements]
-[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+[heading Return Value]
+
+coordinate value
+
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:linestring_tag linestring_tag]
+
+[section:overload2 get (2 of 2 overloads)]
+
+
+get coordinate value of a Box / Segment
+
+
+ template<
+ std::size_t ``[link boost_geometry.reference.Index Index]``,
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ coordinate_type< Geometry >::type get(
+ Geometry const & geometry);
+
+
+
+
+[variablelist
+
+[[Index][for Point: do not specifyfor Box: min\_corner or max\_cornerfor Segment: 0 / 1
+]]
+
+[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to query coordinate value from ]]
+
+]
-OGC Linestring identifying tag.
+[heading Return Value]
+
+coordinate value
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:get_as_radian get_as_radian]
+
+[indexterm1 get_as_radian]
+get coordinate value of a [link boost_geometry.reference.point `point`], result is in Radian
+
+
+ template<
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ coordinate_type< Geometry >::type get_as_radian(
+ const Geometry & geometry);
+
+
+Result is in Radian, even if source coordinate system is in Degrees
+[heading Return Value]
+
+coordinate value
+
+
+
+[variablelist
+
+[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to get coordinate value from ]]
+
+]
+
+
+[heading Remarks]
+
+Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/radian_access.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:get_section get_section]
+
+[indexterm1 get_section]
+Get iterators for a specified [link boost_geometry.reference.section `section`].
+
+
+ template<
+ typename Geometry ,
+ typename Section >
+ void get_section(
+ Geometry const & geometry,
+ Section const & section,
+ typename boost::range_const_iterator< typename geometry::range_type< Geometry >::type >::type & begin,
+ typename boost::range_const_iterator< typename geometry::range_type< Geometry >::type >::type & end);
+
+
+
+
+[variablelist
+
+[[Geometry][type ]]
+
+[[Section][type of [link boost_geometry.reference.section `section`] to get from ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might be located in the neighborhood ]]
+
+[[section][structure with [link boost_geometry.reference.section `section`] ]]
+
+[[begin][begin-iterator (const iterator over points of [link boost_geometry.reference.section `section`]) ]]
+
+[[end][end-iterator (const iterator over points of [link boost_geometry.reference.section `section`]) ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/get_section.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:get_turns get_turns]
+
+[indexterm1 get_turns]
+Calculate intersection points of two geometries.
+
+
+ template<
+ typename AssignPolicy ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Turns ,
+ typename InterruptPolicy >
+ void ``[link boost_geometry.reference.get_turns.overload1 get_turns]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ Turns & turns,
+ InterruptPolicy & interrupt_policy);
+ `` [''''»''' [link boost_geometry.reference.get_turns.overload1 more...]]``
+
+ template<
+ typename AssignPolicy ,
+ typename Geometry ,
+ typename Turns ,
+ typename InterruptPolicy >
+ void ``[link boost_geometry.reference.get_turns.overload2 get_turns]``(
+ Geometry const & geometry,
+ Turns & turns,
+ InterruptPolicy & interrupt_policy);
+ `` [''''»''' [link boost_geometry.reference.get_turns.overload2 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/overlay/get_turns.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 get_turns (1 of 2 overloads)]
+
+
+Calculate intersection points of two geometries.
+
+
+ template<
+ typename AssignPolicy ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Turns ,
+ typename InterruptPolicy >
+ void get_turns(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ Turns & turns,
+ InterruptPolicy & interrupt_policy);
+
+
+
+
+[variablelist
+
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[Turns][type of turn-container (e.g. vector of "intersection/turn point"'s) ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[turns][container which will contain intersection points ]]
+
+]
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 get_turns (2 of 2 overloads)]
+
+
+Calculate self intersections of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename AssignPolicy ,
+ typename Geometry ,
+ typename Turns ,
+ typename InterruptPolicy >
+ void get_turns(
+ Geometry const & geometry,
+ Turns & turns,
+ InterruptPolicy & interrupt_policy);
+
+
+
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[Turns][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[turns][container which will contain intersection points ]]
+
+]
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:interior_rings interior_rings]
+
+[indexterm1 interior_rings]
+Function to get the interior rings of a [link boost_geometry.reference.polygon `polygon`] (non const version).
+
+
+ template<
+ typename Polygon >
+ interior_type< Polygon >::type & ``[link boost_geometry.reference.interior_rings.overload1 interior_rings]``(
+ Polygon & polygon);
+ `` [''''»''' [link boost_geometry.reference.interior_rings.overload1 more...]]``
+
+ template<
+ typename Polygon >
+ const interior_type< Polygon >::type & ``[link boost_geometry.reference.interior_rings.overload2 interior_rings]``(
+ Polygon const & polygon);
+ `` [''''»''' [link boost_geometry.reference.interior_rings.overload2 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/interior_rings.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 interior_rings (1 of 2 overloads)]
+
+
+Function to get the interior rings of a [link boost_geometry.reference.polygon `polygon`] (non const version).
+
+
+ template<
+ typename Polygon >
+ interior_type< Polygon >::type & interior_rings(
+ Polygon & polygon);
+
+
+
+[heading Remarks]
+
+OGC compliance: instead of InteriorRingN
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.polygon `polygon`] type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[polygon][the [link boost_geometry.reference.polygon `polygon`] to get the interior rings from ]]
+
+]
+
+
+[heading Return Value]
+
+a reference to the interior rings
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 interior_rings (2 of 2 overloads)]
+
+
+Function to get the interior rings of a [link boost_geometry.reference.polygon `polygon`] (const version).
+
+
+ template<
+ typename Polygon >
+ const interior_type< Polygon >::type & interior_rings(
+ Polygon const & polygon);
+
+
+
+[heading Remarks]
+
+OGC compliance: instead of InteriorRingN
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.polygon `polygon`] type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[polygon][the [link boost_geometry.reference.polygon `polygon`] to get the interior rings from ]]
+
+]
+
+
+[heading Return Value]
+
+a const reference to the interior rings
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:interior_type interior_type]
+
+
+Meta-function defining container type of inner rings of (multi)[link boost_geometry.reference.polygon `polygon`] geometriy.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ struct interior_type
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.interior_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Description]
+
+the interior rings should be organized as a container (std::vector, std::deque, boost::array) with `boost` range support. This meta function defines the type of that container.
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/interior_rings.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:type interior_type::type]
+
+[indexterm2 type..interior_type]
+
+ typedef core_dispatch::interior_type< typename tag< Geometry >::type, Geometry >::type type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.tag.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type ([link boost_geometry.reference.point `point`], [link boost_geometry.reference.linestring `linestring`], [link boost_geometry.reference.polygon `polygon`], etc) by implementing a [link boost_geometry.reference.tag `tag`] [link boost_geometry.reference.traits `traits`] class. This meta-function uses that [link boost_geometry.reference.traits `traits`] class to retrieve the [link boost_geometry.reference.tag `tag`]. If the input type is not a [link boost_geometry.reference.boost__geometry `boost::geometry`] at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/interior_rings.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:intersection intersection]
+
+[indexterm1 intersection]
+Intersects two geometries.
+
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Collection >
+ void intersection(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ Collection & output_collection);
+
+
+The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are added to the specified collection.
+
+[variablelist
+
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[Collection][collection of rings, polygons (e.g. a vector<polygon> or a multi\_polygon) ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[output_collection][the collection ]]
+
+]
+
+
+[heading Return Value]
+
+true if successful
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/intersection.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:intersection_inserter intersection_inserter]
+
+[indexterm1 intersection_inserter]
+Intersects two geometries.
+
+
+ template<
+ typename GeometryOut ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename OutputIterator ,
+ typename Strategy >
+ OutputIterator ``[link boost_geometry.reference.intersection_inserter.overload1 intersection_inserter]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ OutputIterator out,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.intersection_inserter.overload1 more...]]``
+
+ template<
+ typename GeometryOut ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename OutputIterator >
+ OutputIterator ``[link boost_geometry.reference.intersection_inserter.overload2 intersection_inserter]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ OutputIterator out);
+ `` [''''»''' [link boost_geometry.reference.intersection_inserter.overload2 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/intersection.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 intersection_inserter (1 of 2 overloads)]
+
+
+Intersects two geometries.
+
+
+ template<
+ typename GeometryOut ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename OutputIterator ,
+ typename Strategy >
+ OutputIterator intersection_inserter(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ OutputIterator out,
+ Strategy const & strategy);
+
+
+The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are sent to the specified output operator.
+
+[variablelist
+
+[[GeometryOut][output [link boost_geometry.reference.boost__geometry `boost::geometry`] type, must be specified ]]
+
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[OutputIterator][output iterator ]]
+
+[[Strategy][compound [link boost_geometry.reference.strategy `strategy`] for intersection ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[out][the output iterator, outputting linestrings or polygons ]]
+
+[[strategy][the [link boost_geometry.reference.strategy `strategy`] ]]
+
+]
+
+
+[heading Return Value]
+
+the output iterator
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 intersection_inserter (2 of 2 overloads)]
+
+
+Intersects two geometries.
+
+
+ template<
+ typename GeometryOut ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename OutputIterator >
+ OutputIterator intersection_inserter(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ OutputIterator out);
+
+
+The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are sent to the specified output operator.
+
+[variablelist
+
+[[GeometryOut][output [link boost_geometry.reference.boost__geometry `boost::geometry`] type, must be specified ]]
+
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[OutputIterator][output iterator ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[out][the output iterator, outputting linestrings or polygons ]]
+
+]
+
+
+[heading Return Value]
+
+the output iterator
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:intersects intersects]
+
+[indexterm1 intersects]
+
+ template<
+ typename Geometry >
+ bool ``[link boost_geometry.reference.intersects.overload1 intersects]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.intersects.overload1 more...]]``
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ bool ``[link boost_geometry.reference.intersects.overload2 intersects]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
+ `` [''''»''' [link boost_geometry.reference.intersects.overload2 more...]]``
+
+
+[heading Source descriptions:]
+
+
+* OGC description: Returns 1 (TRUE) if this geometric object spatially intersects anotherGeometry.
+
+* OGC: a.Intersects(b) <=> ! a.Disjoint(b)
+
+
+
+
+[heading Remarks]
+
+There are two overloaded versions:
+* with one geometry, detecting self-intersections
+
+* with two geometries, deferring to disjoint, returning !disjoint
+
+
+
+
+[heading Geometries:]
+
+
+* ring
+
+* polygon
+
+* for two geometries: same is disjoint
+
+
+
+
+[heading Remarks]
+
+if one geometry is completely within another geometry, it "intersects"
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/intersects.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 intersects (1 of 2 overloads)]
+
+
+Determine if there is at least one intersection (crossing or self-tangency).
+
+
+ template<
+ typename Geometry >
+ bool intersects(
+ Geometry const & geometry);
+
+
+
+[heading Remarks]
+
+This function can be called for one [link boost_geometry.reference.boost__geometry `boost::geometry`] (self-intersection) and also for two geometries (intersection)
+
+
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+[heading Return Value]
+
+true if there are intersections, else false
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 intersects (2 of 2 overloads)]
+
+
+Determine if there is at least one intersection.
+
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ bool intersects(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
+
+
+
+
+[variablelist
+
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+[heading Return Value]
+
+true if there are intersection(s), else false
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:is_linear is_linear]
+
+
+Meta-function defining "true" for linear types ([link boost_geometry.reference.linestring `linestring`],ring), "false" for non-linear typse.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ struct is_linear
+
+[heading Description]
+
+
+[heading Remarks]
+
+Used for [link boost_geometry.reference.tag `tag`] dispatching and meta-function finetuning
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/is_linear.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:is_multi is_multi]
+
+
+Meta-function defining "true" for multi geometries (multi\_point, etc).
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ struct is_multi
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/is_multi.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:is_radian is_radian]
+
+
+Meta-function to verify if a coordinate system is [link boost_geometry.reference.radian `radian`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename CoordinateSystem >
+ struct is_radian
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/cs.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:length length]
+
+[indexterm1 length]
+
+ template<
+ typename Geometry >
+ length_result< Geometry >::type ``[link boost_geometry.reference.length.overload1 length]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.length.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename Strategy >
+ length_result< Geometry >::type ``[link boost_geometry.reference.length.overload2 length]``(
+ Geometry const & geometry,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.length.overload2 more...]]``
+
+The length algorithm is implemented for the linestring and the multi\_linestring geometry and results in the length of the linestring. If the points of a linestring have coordinates expressed in kilometers, the length of the line is expressed in kilometers as well.
+[heading Example:]
+
+Example showing length calculation
+
+
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/length.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 length (1 of 2 overloads)]
+
+
+Calculate length of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename Geometry >
+ length_result< Geometry >::type length(
+ Geometry const & geometry);
+
+
+The function length returns the length of a [link boost_geometry.reference.boost__geometry `boost::geometry`], using the default distance-calculation-strategy
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`], being a [link boost_geometry.reference.linestring `linestring`], vector, iterator pair, or any other `boost` compatible range ]]
+
+]
+
+
+[heading Return Value]
+
+the length Example showing length calculation on a vector
+
+
+
+
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 length (2 of 2 overloads)]
+
+
+Calculate length of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename Geometry ,
+ typename Strategy >
+ length_result< Geometry >::type length(
+ Geometry const & geometry,
+ Strategy const & strategy);
+
+
+The function length returns the length of a [link boost_geometry.reference.boost__geometry `boost::geometry`], using specified [link boost_geometry.reference.strategy `strategy`]
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`], being a [link boost_geometry.reference.linestring `linestring`], vector, iterator pair, or any other `boost` compatible range ]]
+
+[[strategy][[link boost_geometry.reference.strategy `strategy`] to be used for distance calculations. ]]
+
+]
+
+
+[heading Return Value]
+
+the length
+
+
+[heading Example:]
+
+Example showing length calculation using iterators and the Vincenty [link boost_geometry.reference.strategy `strategy`]
+
+
+
+
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:length_result length_result]
+
+
+Meta-function defining return type of length function.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename ``[link boost_geometry.reference.Geometry Geometry]``>
+ struct length_result
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.length_result.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Description]
+
+
+[heading Remarks]
+
+Length of a line of integer coordinates can be double. So we take at least a double. If Big Number types are used, we take that type.
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/length_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:type length_result::type]
+
+[indexterm2 type..length_result]
+
+ typedef select_most_precise< typename coordinate_type< Geometry >::type, long double >::type type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.coordinate_type.ncg [*ncg]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/length_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:linear_ring linear_ring]
+
+
+A [link boost_geometry.reference.linear_ring `linear_ring`] (linear [link boost_geometry.reference.linear_ring `linear_ring`]) is a closed line which should not be selfintersecting.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename ``[link boost_geometry.reference.P P]``,
+ template< typename, typename > class ``[link boost_geometry.reference.V V]`` = std::vector,
+ bool ``[link boost_geometry.reference.ClockWise ClockWise]`` = true,
+ template< typename > class ``[link boost_geometry.reference.A A]`` = std::allocator>
+ class linear_ring
+
+[heading Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/linear_ring.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:linestring linestring]
+
+
+A [link boost_geometry.reference.linestring `linestring`] (named so by OGC) is a collection (default a vector) of points.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename P ,
+ template< typename, typename > class ``[link boost_geometry.reference.V V]`` = std::vector,
+ template< typename > class ``[link boost_geometry.reference.A A]`` = std::allocator>
+ class linestring
+
+[heading Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type (see http://accu.org/index.php/journals/427#ftn.d0e249 ) ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/linestring.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:linestring_2d linestring_2d]
+
+[indexterm1 linestring_2d]
+
+ typedef linestring< point_2d > linestring_2d;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type (see http://accu.org/index.php/journals/427#ftn.d0e249 ) ]]
+
+]
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:linestring_3d linestring_3d]
+
+[indexterm1 linestring_3d]
+
+ typedef linestring< point_3d > linestring_3d;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type (see http://accu.org/index.php/journals/427#ftn.d0e249 ) ]]
+
+]
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:linestring_tag linestring_tag]
+
+
+OGC Linestring identifying [link boost_geometry.reference.tag `tag`].
+
+
+
+
+[heading Synopsis]
+ struct linestring_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:make make]
+
+[indexterm1 make]
+Make a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry ``[link boost_geometry.reference.make.overload1 make]``(
+ T const & c1,
+ T const & c2);
+ `` [''''»''' [link boost_geometry.reference.make.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry ``[link boost_geometry.reference.make.overload2 make]``(
+ T const & c1,
+ T const & c2,
+ T const & c3);
+ `` [''''»''' [link boost_geometry.reference.make.overload2 more...]]``
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry ``[link boost_geometry.reference.make.overload3 make]``(
+ T const & c1,
+ T const & c2,
+ T const & c3,
+ T const & c4);
+ `` [''''»''' [link boost_geometry.reference.make.overload3 more...]]``
+
+ template<
+ typename Geometry ,
+ typename Range >
+ Geometry ``[link boost_geometry.reference.make.overload4 make]``(
+ Range const & range);
+ `` [''''»''' [link boost_geometry.reference.make.overload4 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/make.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 make (1 of 4 overloads)]
+
+
+Make a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry make(
+ T const & c1,
+ T const & c2);
+
+
+the Generic Geometry Library uses concepts for all its geometries. Therefore it does not rely on constructors. The "make" functions are object generators creating geometries. There are overloads with two, three, four or six values, which are implemented depending on the [link boost_geometry.reference.boost__geometry `boost::geometry`] specified.
+[heading Remarks]
+
+It does not work with array-point types, like int[2]
+
+
+
+[variablelist
+
+[[G][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+[[T][the coordinate type ]]
+
+]
+
+
+[heading Return Value]
+
+the [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 make (2 of 4 overloads)]
+
+
+Make a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry make(
+ T const & c1,
+ T const & c2,
+ T const & c3);
+
+
+
+[heading Return Value]
+
+a 3D [link boost_geometry.reference.point `point`]
+
+
+
+
+[endsect]
+
+
+
+[section:overload3 make (3 of 4 overloads)]
+
+
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry make(
+ T const & c1,
+ T const & c2,
+ T const & c3,
+ T const & c4);
+
+
+
+[endsect]
+
+
+
+[section:overload4 make (4 of 4 overloads)]
+
+
+
+ template<
+ typename Geometry ,
+ typename Range >
+ Geometry make(
+ Range const & range);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:make_buffer make_buffer]
+
+[indexterm1 make_buffer]
+Calculate and return buffer (= new [link boost_geometry.reference.boost__geometry `boost::geometry`]) around specified distance of [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename Output ,
+ typename Input ,
+ typename T >
+ Output make_buffer(
+ Input const & geometry,
+ T const & distance,
+ T const & chord_length = -1);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[distance][the distance used in buffer ]]
+
+[[chord_length][length of the chord's in the generated arcs around points or bends ]]
+
+]
+
+
+[heading Return Value]
+
+the buffered [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
+
+[heading Remarks]
+
+See also: buffer
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/buffer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:make_centroid make_centroid]
+
+[indexterm1 make_centroid]
+Calculate and return centroid.
+
+
+ template<
+ typename Point ,
+ typename Geometry >
+ Point ``[link boost_geometry.reference.make_centroid.overload1 make_centroid]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.make_centroid.overload1 more...]]``
+
+ template<
+ typename Point ,
+ typename Geometry ,
+ typename Strategy >
+ Point ``[link boost_geometry.reference.make_centroid.overload2 make_centroid]``(
+ Geometry const & geometry,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.make_centroid.overload2 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/centroid.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 make_centroid (1 of 2 overloads)]
+
+
+Calculate and return centroid.
+
+
+ template<
+ typename Point ,
+ typename Geometry >
+ Point make_centroid(
+ Geometry const & geometry);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate centroid from ]]
+
+]
+
+
+[heading Return Value]
+
+the centroid
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 make_centroid (2 of 2 overloads)]
+
+
+Calculate and return centroid, using a specified [link boost_geometry.reference.strategy `strategy`].
+
+
+ template<
+ typename Point ,
+ typename Geometry ,
+ typename Strategy >
+ Point make_centroid(
+ Geometry const & geometry,
+ Strategy const & strategy);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate centroid from ]]
+
+[[strategy][Calculation [link boost_geometry.reference.strategy `strategy`] for centroid ]]
+
+]
+
+
+[heading Return Value]
+
+the centroid
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:make_distance_result make_distance_result]
+
+[indexterm1 make_distance_result]
+Object generator to create instance which can be compared.
+
+
+ template<
+ typename R ,
+ typename T >
+ R make_distance_result(
+ T const & value);
+
+
+If distance results have to be compared to a certain value it makes sense to use this function to generate a distance result of a certain value, and compare the distance result with this instance. SQRT calculations are then avoided
+
+[variablelist
+
+[[R][distance result type ]]
+
+[[T][arithmetic type, e.g. double ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[value][the distance to compare with ]]
+
+]
+
+
+[heading Return Value]
+
+the distance result
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/distance_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:make_envelope make_envelope]
+
+[indexterm1 make_envelope]
+Calculate and return envelope of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename Box ,
+ typename Geometry >
+ Box make_envelope(
+ Geometry const & geometry);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/envelope.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:make_inverse make_inverse]
+
+[indexterm1 make_inverse]
+Create a [link boost_geometry.reference.box `box`] with inverse infinite coordinates.
+
+
+ template<
+ typename Geometry >
+ Geometry make_inverse();
+
+
+The make\_inverse function initialize a 2D or 3D [link boost_geometry.reference.box `box`] with large coordinates, the min corner is very large, the max corner is very small
+
+[variablelist
+
+[[Geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+]
+
+
+[heading Return Value]
+
+the [link boost_geometry.reference.box `box`]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/make.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:make_zero make_zero]
+
+[indexterm1 make_zero]
+Create a [link boost_geometry.reference.boost__geometry `boost::geometry`] with "zero" coordinates.
+
+
+ template<
+ typename Geometry >
+ Geometry make_zero();
+
+
+The make\_zero function initializes a 2D or 3D [link boost_geometry.reference.point `point`] or [link boost_geometry.reference.box `box`] with coordinates of zero
+
+[variablelist
+
+[[Geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+]
+
+
+[heading Return Value]
+
+the [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/make.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:max_corner max_corner]
+
+[indexterm1 max_corner]
+Index of maximum corner of the [link boost_geometry.reference.box `box`].
+
+
+ const int max_corner = 1;
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/access.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:min_corner min_corner]
+
+[indexterm1 min_corner]
+Index of minimum corner of the [link boost_geometry.reference.box `box`].
+
+
+ const int min_corner = 0;
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/access.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:multiply_point multiply_point]
+
+[indexterm1 multiply_point]
+Multiplies a [link boost_geometry.reference.point `point`] by another.
+
+
+ template<
+ typename Point1 ,
+ typename Point2 >
+ void multiply_point(
+ Point1 & p1,
+ Point2 const & p2);
+
+
+The coordinates of the second [link boost_geometry.reference.point `point`] will be multiplied by those of the first [link boost_geometry.reference.point `point`]. The second [link boost_geometry.reference.point `point`] is not modified.
+[heading Parameters]
+
+
+[variablelist
+
+[[p1][first [link boost_geometry.reference.point `point`] ]]
+
+[[p2][second [link boost_geometry.reference.point `point`] ]]
+
+]
+
+
+[heading Remarks]
+
+This is *not* a dot, cross or wedge product. It is a mere field-by-field multiplication.
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:multiply_value multiply_value]
+
+[indexterm1 multiply_value]
+Multiplies each coordinate of a [link boost_geometry.reference.point `point`] by a value.
+
+
+ template<
+ typename Point >
+ void multiply_value(
+ Point & p,
+ typename detail::param< Point >::type value);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[p][[link boost_geometry.reference.point `point`] ]]
+
+[[value][value to multiply by ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:num_geometries num_geometries]
+
+[indexterm1 num_geometries]
+Function to get the number of geometries of a composite [link boost_geometry.reference.boost__geometry `boost::geometry`]. For a single [link boost_geometry.reference.boost__geometry `boost::geometry`] it is always 0 (also for a [link boost_geometry.reference.polygon `polygon`] with holes).
+
+
+ template<
+ typename Geometry >
+ std::size_t num_geometries(
+ Geometry const & geometry);
+
+
+
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.polygon `polygon`] or other [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+[heading Return Value]
+
+the number of interior rings of the [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/num_geometries.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:num_interior_rings num_interior_rings]
+
+[indexterm1 num_interior_rings]
+Function to get the number of interior rings of a [link boost_geometry.reference.polygon `polygon`].
+
+
+ template<
+ typename Geometry >
+ std::size_t num_interior_rings(
+ Geometry const & geometry);
+
+
+
+[heading Remarks]
+
+Defined by OGC as "numInteriorRing". To be consistent with "numPoints" letter "s" is appended
+
+Can be used for any [link boost_geometry.reference.boost__geometry `boost::geometry`], returning 0 for geometries not having interior rings
+
+
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.polygon `polygon`] or other [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+[heading Return Value]
+
+the number of interior rings of the [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/interior_rings.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:num_points num_points]
+
+[indexterm1 num_points]
+get number of points
+
+
+ template<
+ typename Geometry >
+ std::size_t num_points(
+ Geometry const & geometry);
+
+
+
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to get number of points from ]]
+
+]
+
+
+[heading Return Value]
+
+number of points
+
+
+[heading Remarks]
+
+For linestrings/rings also boost::size or .size() could be used, however, for polygons this is less obvious. So this function is provided. Besides that it is described by OGC (numPoints)
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/num_points.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:order_selector order_selector]
+
+[indexterm1 order_selector]
+
+ enum order_selector
+
+[indexterm2 clockwise..order_selector]
+[indexterm2 counterclockwise..order_selector]
+[indexterm2 order_undetermined..order_selector]
+
+[heading Values]
+[variablelist
+
+ [
+ [clockwise]
+ []
+ ]
+
+ [
+ [counterclockwise]
+ []
+ ]
+
+ [
+ [order_undetermined]
+ []
+ ]
+
+]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_order.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:overlaps overlaps]
+
+[indexterm1 overlaps]
+Determines overlap between two geometries.
+
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ bool overlaps(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
+
+
+
+[heading Return Value]
+
+true if there is overlap
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/overlaps.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:parse parse]
+
+[indexterm1 parse]
+
+ template<
+ typename Geometry >
+ void ``[link boost_geometry.reference.parse.overload1 parse]``(
+ Geometry & geometry,
+ std::string const & c1,
+ std::string const & c2);
+ `` [''''»''' [link boost_geometry.reference.parse.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename S >
+ void ``[link boost_geometry.reference.parse.overload2 parse]``(
+ Geometry & geometry,
+ std::string const & c1,
+ std::string const & c2,
+ S const & strategy);
+ `` [''''»''' [link boost_geometry.reference.parse.overload2 more...]]``
+
+ template<
+ typename Geometry >
+ Geometry ``[link boost_geometry.reference.parse.overload3 parse]``(
+ std::string const & c1,
+ std::string const & c2);
+ `` [''''»''' [link boost_geometry.reference.parse.overload3 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/parse.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 parse (1 of 3 overloads)]
+
+
+parse two strings to a spherical/geographic [link boost_geometry.reference.point `point`], using W/E/N/S
+
+
+ template<
+ typename Geometry >
+ void parse(
+ Geometry & geometry,
+ std::string const & c1,
+ std::string const & c2);
+
+
+
+[endsect]
+
+
+
+[section:overload2 parse (2 of 3 overloads)]
+
+
+parse two strings to a spherical/geographic [link boost_geometry.reference.point `point`], using a specified [link boost_geometry.reference.strategy `strategy`]
+
+
+ template<
+ typename Geometry ,
+ typename S >
+ void parse(
+ Geometry & geometry,
+ std::string const & c1,
+ std::string const & c2,
+ S const & strategy);
+
+
+user can use N/E/S/O or N/O/Z/W or other formats
+
+
+[endsect]
+
+
+
+[section:overload3 parse (3 of 3 overloads)]
+
+
+
+ template<
+ typename Geometry >
+ Geometry parse(
+ std::string const & c1,
+ std::string const & c2);
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:perimeter perimeter]
+
+[indexterm1 perimeter]
+
+ template<
+ typename Geometry >
+ length_result< Geometry >::type ``[link boost_geometry.reference.perimeter.overload1 perimeter]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.perimeter.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename Strategy >
+ length_result< Geometry >::type ``[link boost_geometry.reference.perimeter.overload2 perimeter]``(
+ Geometry const & geometry,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.perimeter.overload2 more...]]``
+
+
+[heading Geometries:]
+
+
+* polygon
+
+* box
+
+* linear_ring
+
+* multi_polygon
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/perimeter.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 perimeter (1 of 2 overloads)]
+
+
+Calculate perimeter of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename Geometry >
+ length_result< Geometry >::type perimeter(
+ Geometry const & geometry);
+
+
+The function perimeter returns the perimeter of a [link boost_geometry.reference.boost__geometry `boost::geometry`], using the default distance-calculation-strategy
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`], be it a geometry::ring, vector, iterator pair, or any other `boost` compatible range ]]
+
+]
+
+
+[heading Return Value]
+
+the perimeter
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 perimeter (2 of 2 overloads)]
+
+
+Calculate perimeter of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename Geometry ,
+ typename Strategy >
+ length_result< Geometry >::type perimeter(
+ Geometry const & geometry,
+ Strategy const & strategy);
+
+
+The function perimeter returns the perimeter of a [link boost_geometry.reference.boost__geometry `boost::geometry`], using specified [link boost_geometry.reference.strategy `strategy`]
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`], be it a geometry::ring, vector, iterator pair, or any other `boost` compatible range ]]
+
+[[strategy][[link boost_geometry.reference.strategy `strategy`] to be used for distance calculations. ]]
+
+]
+
+
+[heading Return Value]
+
+the perimeter
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:point point]
+
+
+Basic [link boost_geometry.reference.point `point`] class, having coordinates defined in a neutral way.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename T,
+ std::size_t ``[link boost_geometry.reference.D D]``,
+ typename ``[link boost_geometry.reference.C C]``>
+ class point
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point.coordinate_system [*coordinate_system]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point.get [*get]]]
+ [Compile time access to coordinate values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point.point [*point]]]
+ [Default constructor, no initialization at all.
+
+ Constructs with one, or optionally two or three values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point.set [*set]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point.coordinate_count [*coordinate_count]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[T][numeric type, for example double, float, int ]]
+
+[[D][coordinate [link boost_geometry.reference.dimension `dimension`] as number of coordinates, for example 2 ]]
+
+[[C][coordinate system, for example [link boost_geometry.reference.cs__cartesian `cs::cartesian`] ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:coordinate_count point::coordinate_count]
+
+[indexterm2 coordinate_count..point]
+
+ static const std::size_t coordinate_count = D;
+
+
+
+[endsect]
+
+
+
+[section:coordinate_system point::coordinate_system]
+
+[indexterm2 coordinate_system..point]
+
+ typedef C coordinate_system;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:coordinate_type point::coordinate_type]
+
+[indexterm2 coordinate_type..point]
+
+ typedef T coordinate_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:get point::get]
+
+[indexterm2 get..point]
+Compile time access to coordinate values.
+
+
+ template<
+ std::size_t ``[link boost_geometry.reference.K K]``>
+ T const & get() const;
+
+
+
+[endsect]
+
+
+[section:point point::point]
+
+[indexterm2 point..point]
+Default constructor, no initialization at all.
+
+
+ ``[link boost_geometry.reference.point.point.overload1 point]``();
+ `` [''''»''' [link boost_geometry.reference.point.point.overload1 more...]]``
+
+
+Constructs with one, or optionally two or three values.
+
+
+ ``[link boost_geometry.reference.point.point.overload2 point]``(
+ T const & v0,
+ T const & v1 = 0,
+ T const & v2 = 0);
+ `` [''''»''' [link boost_geometry.reference.point.point.overload2 more...]]``
+
+
+[section:overload1 point::point (1 of 2 overloads)]
+
+
+Default constructor, no initialization at all.
+
+
+ point();
+
+
+
+[endsect]
+
+
+
+[section:overload2 point::point (2 of 2 overloads)]
+
+
+Constructs with one, or optionally two or three values.
+
+
+ point(
+ T const & v0,
+ T const & v1 = 0,
+ T const & v2 = 0);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:set point::set]
+
+[indexterm2 set..point]
+
+ template<
+ std::size_t ``[link boost_geometry.reference.K K]``>
+ void set(
+ T value);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:point_2d point_2d]
+
+[indexterm1 point_2d]
+
+ typedef point_xy< double, cs::cartesian > point_2d;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point_xy.coordinate_system [*coordinate_system]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point_xy.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point_xy.get [*get]]]
+ [Compile time access to coordinate values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.point_xy [*point_xy]]]
+ [Default constructor, does not initialize anything.
+
+ Constructor with x/y values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.set [*set]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.x [*x]]]
+ [Get x-value.
+
+ Set x-value. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.y [*y]]]
+ [Get y-value.
+
+ Set y-value. ]
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point_xy.coordinate_count [*coordinate_count]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[T][numeric type, arguments can be, for example, double, float, int ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:point_3d point_3d]
+
+[indexterm1 point_3d]
+
+ typedef point< double, 3, cs::cartesian > point_3d;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point.coordinate_system [*coordinate_system]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point.get [*get]]]
+ [Compile time access to coordinate values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point.point [*point]]]
+ [Default constructor, no initialization at all.
+
+ Constructs with one, or optionally two or three values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point.set [*set]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point.coordinate_count [*coordinate_count]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[T][numeric type, for example double, float, int ]]
+
+[[D][coordinate [link boost_geometry.reference.dimension `dimension`] as number of coordinates, for example 2 ]]
+
+[[C][coordinate system, for example [link boost_geometry.reference.cs__cartesian `cs::cartesian`] ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:point_order point_order]
+
+
+Meta-function which defines [link boost_geometry.reference.point `point`] type of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ struct point_order
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point_order.ncg [*ncg]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point_order.value [*value]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_order.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:ncg point_order::ncg]
+
+[indexterm2 ncg..point_order]
+
+ typedef boost::remove_const< Geometry >::type ncg;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_order.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:value point_order::value]
+
+[indexterm2 value..point_order]
+
+ static const order_selector value = core_dispatch::point_order
+ <
+ typename tag<Geometry>::type,
+ ncg
+ >::value;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:point_tag point_tag]
+
+
+OGC Point identifying [link boost_geometry.reference.tag `tag`].
+
+
+
+
+[heading Synopsis]
+ struct point_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:point_type point_type]
+
+
+Meta-function which defines [link boost_geometry.reference.point `point`] type of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename ``[link boost_geometry.reference.Geometry Geometry]``>
+ struct point_type
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point_type.ncg [*ncg]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:ncg point_type::ncg]
+
+[indexterm2 ncg..point_type]
+
+ typedef boost::remove_const< Geometry >::type ncg;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:type point_type::type]
+
+[indexterm2 type..point_type]
+
+ typedef core_dispatch::point_type< typename tag< Geometry >::type, ncg >::type type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.tag.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type ([link boost_geometry.reference.point `point`], [link boost_geometry.reference.linestring `linestring`], [link boost_geometry.reference.polygon `polygon`], etc) by implementing a [link boost_geometry.reference.tag `tag`] [link boost_geometry.reference.traits `traits`] class. This meta-function uses that [link boost_geometry.reference.traits `traits`] class to retrieve the [link boost_geometry.reference.tag `tag`]. If the input type is not a [link boost_geometry.reference.boost__geometry `boost::geometry`] at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:point_xy point_xy]
+
+
+2D [link boost_geometry.reference.point `point`] in Cartesian coordinate system
+
+
+
+
+[heading Synopsis]
+ template<
+ typename T ,
+ typename C = cs::cartesian>
+ class point_xy : public point< T, 2, C >
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point_xy.coordinate_system [*coordinate_system]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point_xy.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point_xy.get [*get]]]
+ [Compile time access to coordinate values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.point_xy [*point_xy]]]
+ [Default constructor, does not initialize anything.
+
+ Constructor with x/y values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.set [*set]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.x [*x]]]
+ [Get x-value.
+
+ Set x-value. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.y [*y]]]
+ [Get y-value.
+
+ Set y-value. ]
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point_xy.coordinate_count [*coordinate_count]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[T][numeric type, arguments can be, for example, double, float, int ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/point_xy.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:coordinate_count point_xy::coordinate_count]
+
+
+['Inherited from point.]
+
+[indexterm2 coordinate_count..point_xy]
+
+ static const std::size_t coordinate_count;
+
+
+
+[endsect]
+
+
+
+[section:coordinate_system point_xy::coordinate_system]
+
+
+['Inherited from point.]
+
+[indexterm2 coordinate_system..point_xy]
+
+ typedef C coordinate_system;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/point_xy.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:coordinate_type point_xy::coordinate_type]
+
+
+['Inherited from point.]
+
+[indexterm2 coordinate_type..point_xy]
+
+ typedef T coordinate_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/point_xy.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:get point_xy::get]
+
+
+['Inherited from point.]
+
+[indexterm2 get..point_xy]
+Compile time access to coordinate values.
+
+
+ Tconst & get() const;
+
+
+
+[endsect]
+
+
+[section:point_xy point_xy::point_xy]
+
+[indexterm2 point_xy..point_xy]
+Default constructor, does not initialize anything.
+
+
+ ``[link boost_geometry.reference.point_xy.point_xy.overload1 point_xy]``();
+ `` [''''»''' [link boost_geometry.reference.point_xy.point_xy.overload1 more...]]``
+
+
+Constructor with x/y values.
+
+
+ ``[link boost_geometry.reference.point_xy.point_xy.overload2 point_xy]``(
+ T const & x,
+ T const & y);
+ `` [''''»''' [link boost_geometry.reference.point_xy.point_xy.overload2 more...]]``
+
+
+[section:overload1 point_xy::point_xy (1 of 2 overloads)]
+
+
+Default constructor, does not initialize anything.
+
+
+ point_xy();
+
+
+
+[endsect]
+
+
+
+[section:overload2 point_xy::point_xy (2 of 2 overloads)]
+
+
+Constructor with x/y values.
+
+
+ point_xy(
+ T const & x,
+ T const & y);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:set point_xy::set]
+
+
+['Inherited from point.]
+
+[indexterm2 set..point_xy]
+
+ void set(
+ Tvalue );
+
+
+
+[endsect]
+
+
+[section:x point_xy::x]
+
+[indexterm2 x..point_xy]
+Get x-value.
+
+
+ T const & ``[link boost_geometry.reference.point_xy.x.overload1 x]``() const;
+ `` [''''»''' [link boost_geometry.reference.point_xy.x.overload1 more...]]``
+
+
+Set x-value.
+
+
+ void ``[link boost_geometry.reference.point_xy.x.overload2 x]``(
+ T const & v);
+ `` [''''»''' [link boost_geometry.reference.point_xy.x.overload2 more...]]``
+
+
+[section:overload1 point_xy::x (1 of 2 overloads)]
+
+
+Get x-value.
+
+
+ T const & x() const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 point_xy::x (2 of 2 overloads)]
+
+
+Set x-value.
+
+
+ void x(
+ T const & v);
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:y point_xy::y]
+
+[indexterm2 y..point_xy]
+Get y-value.
+
+
+ T const & ``[link boost_geometry.reference.point_xy.y.overload1 y]``() const;
+ `` [''''»''' [link boost_geometry.reference.point_xy.y.overload1 more...]]``
+
+
+Set y-value.
+
+
+ void ``[link boost_geometry.reference.point_xy.y.overload2 y]``(
+ T const & v);
+ `` [''''»''' [link boost_geometry.reference.point_xy.y.overload2 more...]]``
+
+
+[section:overload1 point_xy::y (1 of 2 overloads)]
+
+
+Get y-value.
+
+
+ T const & y() const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 point_xy::y (2 of 2 overloads)]
+
+
+Set y-value.
+
+
+ void y(
+ T const & v);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[endsect]
+
+[section:polygon polygon]
+
+
+The [link boost_geometry.reference.polygon `polygon`] contains an outer ring and zero or more inner rings.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Point ,
+ template< typename, typename > class ``[link boost_geometry.reference.PointList PointList]`` = std::vector,
+ template< typename, typename > class ``[link boost_geometry.reference.RingList RingList]`` = std::vector,
+ bool ``[link boost_geometry.reference.ClockWise ClockWise]`` = true,
+ template< typename > class ``[link boost_geometry.reference.PointAlloc PointAlloc]`` = std::allocator,
+ template< typename > class ``[link boost_geometry.reference.RingAlloc RingAlloc]`` = std::allocator>
+ class polygon
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.polygon.clear [*clear]]]
+ [Utility method, clears outer and inner rings. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.inners [*inners]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.outer [*outer]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+
+[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+
+[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
+
+[[PointAlloc][container-allocator-type ]]
+
+[[RingAlloc][container-allocator-type ]]
+
+]
+
+
+[heading Remarks]
+
+The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:clear polygon::clear]
+
+[indexterm2 clear..polygon]
+Utility method, clears outer and inner rings.
+
+
+ void clear();
+
+
+
+[endsect]
+
+
+
+[section:inner_container_type polygon::inner_container_type]
+
+[indexterm2 inner_container_type..polygon]
+
+ typedef RingList< ring_type, RingAlloc< ring_type > > inner_container_type;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:inners polygon::inners]
+
+[indexterm2 inners..polygon]
+
+ inner_container_type const & ``[link boost_geometry.reference.polygon.inners.overload1 inners]``() const;
+ `` [''''»''' [link boost_geometry.reference.polygon.inners.overload1 more...]]``
+
+ inner_container_type & ``[link boost_geometry.reference.polygon.inners.overload2 inners]``();
+ `` [''''»''' [link boost_geometry.reference.polygon.inners.overload2 more...]]``
+
+
+[section:overload1 polygon::inners (1 of 2 overloads)]
+
+
+
+ inner_container_type const & inners() const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 polygon::inners (2 of 2 overloads)]
+
+
+
+ inner_container_type & inners();
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:outer polygon::outer]
+
+[indexterm2 outer..polygon]
+
+ ring_type const & ``[link boost_geometry.reference.polygon.outer.overload1 outer]``() const;
+ `` [''''»''' [link boost_geometry.reference.polygon.outer.overload1 more...]]``
+
+ ring_type & ``[link boost_geometry.reference.polygon.outer.overload2 outer]``();
+ `` [''''»''' [link boost_geometry.reference.polygon.outer.overload2 more...]]``
+
+
+[section:overload1 polygon::outer (1 of 2 overloads)]
+
+
+
+ ring_type const & outer() const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 polygon::outer (2 of 2 overloads)]
+
+
+
+ ring_type & outer();
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:point_type polygon::point_type]
+
+[indexterm2 point_type..polygon]
+
+ typedef Point point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:ring_type polygon::ring_type]
+
+[indexterm2 ring_type..polygon]
+
+ typedef linear_ring< Point, PointList, ClockWise, PointAlloc > ring_type;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:polygon_2d polygon_2d]
+
+[indexterm1 polygon_2d]
+
+ typedef polygon< point_2d > polygon_2d;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.polygon.clear [*clear]]]
+ [Utility method, clears outer and inner rings. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.inners [*inners]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.outer [*outer]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+
+[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+
+[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
+
+[[PointAlloc][container-allocator-type ]]
+
+[[RingAlloc][container-allocator-type ]]
+
+]
+
+
+[heading Remarks]
+
+The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:polygon_3d polygon_3d]
+
+[indexterm1 polygon_3d]
+
+ typedef polygon< point_3d > polygon_3d;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.polygon.clear [*clear]]]
+ [Utility method, clears outer and inner rings. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.inners [*inners]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.outer [*outer]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+
+[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+
+[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
+
+[[PointAlloc][container-allocator-type ]]
+
+[[RingAlloc][container-allocator-type ]]
+
+]
+
+
+[heading Remarks]
+
+The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:polygon_tag polygon_tag]
+
+
+OGC Polygon identifying [link boost_geometry.reference.tag `tag`].
+
+
+
+
+[heading Synopsis]
+ struct polygon_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:radian radian]
+
+
+Unit of plane angle: Radians.
+
+
+
+
+[heading Synopsis]
+ class radian
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/cs.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:replace_point_type replace_point_type]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry ,
+ typename NewPointType >
+ struct replace_point_type
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/replace_point_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:reverse reverse]
+
+[indexterm1 reverse]
+
+ template<
+ typename Geometry >
+ void reverse(
+ Geometry & geometry);
+
+
+
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make reverse ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/reverse.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:reverse_dispatch reverse_dispatch]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ struct reverse_dispatch
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/reverse_dispatch.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:ring_2d ring_2d]
+
+[indexterm1 ring_2d]
+
+ typedef linear_ring< point_2d > ring_2d;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:ring_3d ring_3d]
+
+[indexterm1 ring_3d]
+
+ typedef linear_ring< point_3d > ring_3d;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:ring_tag ring_tag]
+
+
+Convenience (linear) ring identifying [link boost_geometry.reference.tag `tag`].
+
+
+
+
+[heading Synopsis]
+ struct ring_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:ring_type ring_type]
+
+
+Meta-function which defines ring type of (multi)[link boost_geometry.reference.polygon `polygon`] [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ struct ring_type
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.ring_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Description]
+
+a [link boost_geometry.reference.polygon `polygon`] contains one exterior ring and zero or more interior rings (holes). This meta function retrieves the type of the rings
+[heading Remarks]
+
+Exterior ring and interior rings must have the same ring-type.
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/ring_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:type ring_type::type]
+
+[indexterm2 type..ring_type]
+
+ typedef core_dispatch::ring_type< typename tag< Geometry >::type, Geometry >::type type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.tag.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type ([link boost_geometry.reference.point `point`], [link boost_geometry.reference.linestring `linestring`], [link boost_geometry.reference.polygon `polygon`], etc) by implementing a [link boost_geometry.reference.tag `tag`] [link boost_geometry.reference.traits `traits`] class. This meta-function uses that [link boost_geometry.reference.traits `traits`] class to retrieve the [link boost_geometry.reference.tag `tag`]. If the input type is not a [link boost_geometry.reference.boost__geometry `boost::geometry`] at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/ring_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:section section]
+
+
+Structure containing [link boost_geometry.reference.section `section`] information.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Box ,
+ std::size_t ``[link boost_geometry.reference.DimensionCount DimensionCount]``>
+ struct section
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.section.box_type [*box_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.section.section [*section]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.section.begin_index [*begin_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.bounding_box [*bounding_box]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.count [*count]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.directions [*directions]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.duplicate [*duplicate]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.end_index [*end_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.id [*id]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.multi_index [*multi_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.non_duplicate_index [*non_duplicate_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.range_count [*range_count]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.ring_index [*ring_index]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+Section information consists of a bounding [link boost_geometry.reference.box `box`], direction information (if it is increasing or decreasing, per [link boost_geometry.reference.dimension `dimension`]), index information (begin-end, ring, multi) and the number of segments in this [link boost_geometry.reference.section `section`]
+
+
+
+[variablelist
+
+[[Box][box-type ]]
+
+[[DimensionCount][number of dimensions for this [link boost_geometry.reference.section `section`] ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:begin_index section::begin_index]
+
+[indexterm2 begin_index..section]
+
+ int begin_index;
+
+
+
+[endsect]
+
+
+
+[section:bounding_box section::bounding_box]
+
+[indexterm2 bounding_box..section]
+
+ Box bounding_box;
+
+
+
+[endsect]
+
+
+
+[section:box_type section::box_type]
+
+[indexterm2 box_type..section]
+
+ typedef Box box_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:count section::count]
+
+[indexterm2 count..section]
+
+ std::size_t count;
+
+
+
+[endsect]
+
+
+
+[section:directions section::directions]
+
+[indexterm2 directions..section]
+
+ int directions;
+
+
+
+[endsect]
+
+
+
+[section:duplicate section::duplicate]
+
+[indexterm2 duplicate..section]
+
+ bool duplicate;
+
+
+
+[endsect]
+
+
+
+[section:end_index section::end_index]
+
+[indexterm2 end_index..section]
+
+ int end_index;
+
+
+
+[endsect]
+
+
+
+[section:id section::id]
+
+[indexterm2 id..section]
+
+ int id;
+
+
+
+[endsect]
+
+
+
+[section:multi_index section::multi_index]
+
+[indexterm2 multi_index..section]
+
+ int multi_index;
+
+
+
+[endsect]
+
+
+
+[section:non_duplicate_index section::non_duplicate_index]
+
+[indexterm2 non_duplicate_index..section]
+
+ int non_duplicate_index;
+
+
+
+[endsect]
+
+
+
+[section:range_count section::range_count]
+
+[indexterm2 range_count..section]
+
+ std::size_t range_count;
+
+
+
+[endsect]
+
+
+
+[section:ring_index section::ring_index]
+
+[indexterm2 ring_index..section]
+
+ int ring_index;
+
+
+
+[endsect]
+
+
+
+[section:section section::section]
+
+[indexterm2 section..section]
+
+ section();
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:sectionalize sectionalize]
+
+[indexterm1 sectionalize]
+Split a [link boost_geometry.reference.boost__geometry `boost::geometry`] into monotonic [link boost_geometry.reference.sections `sections`].
+
+
+ template<
+ typename Geometry ,
+ typename Sections >
+ void sectionalize(
+ Geometry const & geometry,
+ Sections & sections);
+
+
+
+
+[variablelist
+
+[[Geometry][type of [link boost_geometry.reference.boost__geometry `boost::geometry`] to check ]]
+
+[[Sections][type of [link boost_geometry.reference.sections `sections`] to create ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to create [link boost_geometry.reference.sections `sections`] from ]]
+
+[[sections][structure with [link boost_geometry.reference.sections `sections`] ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:sections sections]
+
+
+Structure containing a collection of [link boost_geometry.reference.sections `sections`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Box ,
+ std::size_t ``[link boost_geometry.reference.DimensionCount DimensionCount]``>
+ struct sections
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.sections.box_type [*box_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.sections.value [*value]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+[heading Remarks]
+
+Derived from a vector, proves to be faster than of deque
+
+vector might be templated in the future
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:box_type sections::box_type]
+
+[indexterm2 box_type..sections]
+
+ typedef Box box_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:value sections::value]
+
+[indexterm2 value..sections]
+
+ static const std::size_t value = DimensionCount;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:segment segment]
+
+
+Class [link boost_geometry.reference.segment `segment`]: small class containing two (templatized) [link boost_geometry.reference.point `point`] references.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename ConstOrNonConstPoint >
+ class segment
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment.segment [*segment]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment.first [*first]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment.second [*second]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+From Wikipedia: In [link boost_geometry.reference.boost__geometry `boost::geometry`], a line [link boost_geometry.reference.segment `segment`] is a part of a line that is bounded by two distinct end points, and contains every [link boost_geometry.reference.point `point`] on the line between its end points.
+[heading Remarks]
+
+The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
+
+Like std::pair, points are public available.
+
+type is const or non const, so geometry::segment<P> or geometry::segment<const P>
+
+We cannot derive from std::pair<P&, P&> because of reference assignments.
+
+
+
+[variablelist
+
+[[ConstOrNonConstPoint][[link boost_geometry.reference.point `point`] type of the [link boost_geometry.reference.segment `segment`], maybe a [link boost_geometry.reference.point `point`] or a const [link boost_geometry.reference.point `point`] ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/segment.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:first segment::first]
+
+[indexterm2 first..segment]
+
+ point_type & first;
+
+
+
+[endsect]
+
+
+
+[section:second segment::second]
+
+[indexterm2 second..segment]
+
+ point_type & second;
+
+
+
+[endsect]
+
+
+
+[section:segment segment::segment]
+
+[indexterm2 segment..segment]
+
+ segment(
+ point_type & p1,
+ point_type & p2);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:segment_2d segment_2d]
+
+[indexterm1 segment_2d]
+
+ typedef segment< point_2d > segment_2d;
+
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment.segment [*segment]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment.first [*first]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment.second [*second]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+From Wikipedia: In [link boost_geometry.reference.boost__geometry `boost::geometry`], a line [link boost_geometry.reference.segment `segment`] is a part of a line that is bounded by two distinct end points, and contains every [link boost_geometry.reference.point `point`] on the line between its end points.
+[heading Remarks]
+
+The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
+
+Like std::pair, points are public available.
+
+type is const or non const, so geometry::segment<P> or geometry::segment<const P>
+
+We cannot derive from std::pair<P&, P&> because of reference assignments.
+
+
+
+[variablelist
+
+[[ConstOrNonConstPoint][[link boost_geometry.reference.point `point`] type of the [link boost_geometry.reference.segment `segment`], maybe a [link boost_geometry.reference.point `point`] or a const [link boost_geometry.reference.point `point`] ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:segment_identifier segment_identifier]
+
+
+
+
+
+[heading Synopsis]
+ struct segment_identifier
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment_identifier.operator_lt_ [*operator<]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_identifier.operator_eq__eq_ [*operator==]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_identifier.segment_identifier [*segment_identifier]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment_identifier.multi_index [*multi_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_identifier.ring_index [*ring_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_identifier.segment_index [*segment_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_identifier.source_index [*source_index]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/overlay/segment_identifier.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:multi_index segment_identifier::multi_index]
+
+[indexterm2 multi_index..segment_identifier]
+
+ int multi_index;
+
+
+
+[endsect]
+
+
+
+[section:operator_lt_ segment_identifier::operator<]
+
+[indexterm2 operator<..segment_identifier]
+
+ bool operator<(
+ segment_identifier const & other) const;
+
+
+
+[endsect]
+
+
+
+[section:operator_eq__eq_ segment_identifier::operator==]
+
+[indexterm2 operator==..segment_identifier]
+
+ bool operator==(
+ segment_identifier const & other) const;
+
+
+
+[endsect]
+
+
+
+[section:ring_index segment_identifier::ring_index]
+
+[indexterm2 ring_index..segment_identifier]
+
+ int ring_index;
+
+
+
+[endsect]
+
+
+[section:segment_identifier segment_identifier::segment_identifier]
+
+[indexterm2 segment_identifier..segment_identifier]
+
+ ``[link boost_geometry.reference.segment_identifier.segment_identifier.overload1 segment_identifier]``();
+ `` [''''»''' [link boost_geometry.reference.segment_identifier.segment_identifier.overload1 more...]]``
+
+ ``[link boost_geometry.reference.segment_identifier.segment_identifier.overload2 segment_identifier]``(
+ int src,
+ int mul,
+ int rin,
+ int seg);
+ `` [''''»''' [link boost_geometry.reference.segment_identifier.segment_identifier.overload2 more...]]``
+
+
+[section:overload1 segment_identifier::segment_identifier (1 of 2 overloads)]
+
+
+
+ segment_identifier();
+
+
+
+[endsect]
+
+
+
+[section:overload2 segment_identifier::segment_identifier (2 of 2 overloads)]
+
+
+
+ segment_identifier(
+ int src,
+ int mul,
+ int rin,
+ int seg);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:segment_index segment_identifier::segment_index]
+
+[indexterm2 segment_index..segment_identifier]
+
+ int segment_index;
+
+
+
+[endsect]
+
+
+
+[section:source_index segment_identifier::source_index]
+
+[indexterm2 source_index..segment_identifier]
+
+ int source_index;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:segment_intersection_points segment_intersection_points]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Point >
+ struct segment_intersection_points
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.segment_intersection_points.point_type [*point_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment_intersection_points.segment_intersection_points [*segment_intersection_points]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment_intersection_points.count [*count]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_intersection_points.intersections [*intersections]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/intersection_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:count segment_intersection_points::count]
+
+[indexterm2 count..segment_intersection_points]
+
+ std::size_t count;
+
+
+
+[endsect]
+
+
+
+[section:intersections segment_intersection_points::intersections]
+
+[indexterm2 intersections..segment_intersection_points]
+
+ Point intersections;
+
+
+
+[endsect]
+
+
+
+[section:point_type segment_intersection_points::point_type]
+
+[indexterm2 point_type..segment_intersection_points]
+
+ typedef Point point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/intersection_result.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_intersection_points segment_intersection_points::segment_intersection_points]
+
+[indexterm2 segment_intersection_points..segment_intersection_points]
+
+ segment_intersection_points();
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:segment_tag segment_tag]
+
+
+Convenience [link boost_geometry.reference.segment `segment`] (2-points) identifying [link boost_geometry.reference.tag `tag`].
+
+
+
+
+[heading Synopsis]
+ struct segment_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:set set]
+
+[indexterm1 set]
+set coordinate value of a Point ( / Sphere)
+
+
+ template<
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ void ``[link boost_geometry.reference.set.overload1 set]``(
+ Geometry & geometry,
+ typename coordinate_type< Geometry >::type const & value);
+ `` [''''»''' [link boost_geometry.reference.set.overload1 more...]]``
+
+ template<
+ std::size_t ``[link boost_geometry.reference.Index Index]``,
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ void ``[link boost_geometry.reference.set.overload2 set]``(
+ Geometry & geometry,
+ typename coordinate_type< Geometry >::type const & value);
+ `` [''''»''' [link boost_geometry.reference.set.overload2 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/access.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 set (1 of 2 overloads)]
+
+
+set coordinate value of a Point ( / Sphere)
+
+
+ template<
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ void set(
+ Geometry & geometry,
+ typename coordinate_type< Geometry >::type const & value);
+
+
+
+
+[variablelist
+
+[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to assign coordinate to ]]
+
+[[value][coordinate value to assign ]]
+
+]
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 set (2 of 2 overloads)]
+
+
+set coordinate value of a Box / Segment
+
+
+ template<
+ std::size_t ``[link boost_geometry.reference.Index Index]``,
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ void set(
+ Geometry & geometry,
+ typename coordinate_type< Geometry >::type const & value);
+
+
+
+
+[variablelist
+
+[[Index][for Point: do not specifyfor Box: min\_corner or max\_cornerfor Segment: 0 / 1
+]]
+
+[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to assign coordinate to ]]
+
+[[value][coordinate value to assign ]]
+
+]
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:set_from_radian set_from_radian]
+
+[indexterm1 set_from_radian]
+set coordinate value (in [link boost_geometry.reference.radian `radian`]) to a [link boost_geometry.reference.point `point`]
+
+
+ template<
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ void set_from_radian(
+ Geometry & geometry,
+ const typename coordinate_type< Geometry >::type & radians);
+
+
+Coordinate value will be set correctly, if coordinate system of [link boost_geometry.reference.point `point`] is in Degree, Radian value will be converted to Degree
+
+
+
+[variablelist
+
+[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to assign coordinate to ]]
+
+[[radians][coordinate value to assign ]]
+
+]
+
+
+[heading Remarks]
+
+Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/radian_access.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:side_info side_info]
+
+
+Class [link boost_geometry.reference.side_info `side_info`]: small class wrapping for sides (-1,0,1).
+
+
+
+
+[heading Synopsis]
+ class side_info
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.side_info.as_collinear [*as_collinear]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.side_info.collinear [*collinear]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.side_info.get [*get]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.side_info.reverse [*reverse]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.side_info.same [*same]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.side_info.set [*set]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.side_info.side_info [*side_info]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/side_info.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:as_collinear side_info::as_collinear]
+
+[indexterm2 as_collinear..side_info]
+
+ bool as_collinear() const;
+
+
+
+[endsect]
+
+
+
+[section:collinear side_info::collinear]
+
+[indexterm2 collinear..side_info]
+
+ bool collinear() const;
+
+
+
+[endsect]
+
+
+
+[section:get side_info::get]
+
+[indexterm2 get..side_info]
+
+ template<
+ int ``[link boost_geometry.reference.Which Which]``,
+ int ``[link boost_geometry.reference.Index Index]``>
+ int get() const;
+
+
+
+[endsect]
+
+
+
+[section:reverse side_info::reverse]
+
+[indexterm2 reverse..side_info]
+
+ void reverse();
+
+
+
+[endsect]
+
+
+
+[section:same side_info::same]
+
+[indexterm2 same..side_info]
+
+ template<
+ int ``[link boost_geometry.reference.Which Which]``>
+ bool same() const;
+
+
+
+[endsect]
+
+
+
+[section:set side_info::set]
+
+[indexterm2 set..side_info]
+
+ template<
+ int ``[link boost_geometry.reference.Which Which]``>
+ void set(
+ int first,
+ int second);
+
+
+
+[endsect]
+
+
+
+[section:side_info side_info::side_info]
+
+[indexterm2 side_info..side_info]
+
+ side_info(
+ int side_a1 = 0,
+ int side_a2 = 0,
+ int side_b1 = 0,
+ int side_b2 = 0);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:simplify simplify]
+
+[indexterm1 simplify]
+
+ template<
+ typename Geometry ,
+ typename Strategy >
+ void ``[link boost_geometry.reference.simplify.overload1 simplify]``(
+ Geometry const & geometry,
+ Geometry & out,
+ double max_distance,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.simplify.overload1 more...]]``
+
+ template<
+ typename Geometry >
+ void ``[link boost_geometry.reference.simplify.overload2 simplify]``(
+ Geometry const & geometry,
+ Geometry & out,
+ double max_distance);
+ `` [''''»''' [link boost_geometry.reference.simplify.overload2 more...]]``
+
+
+[heading Source description:]
+
+
+* Wikipedia: given a 'curve' composed of line segments to find a curve not too dissimilar but that has fewer points
+
+
+
+
+
+[heading Performance]
+
+
+* Performance is measured on simplification of a collection of rings, such that 10% of the points is kept.
+
+* 2776 counties of US are simplified in 0.7 seconds (http://trac.osgeo.org/ggl/wiki/Performance#Simplify1)
+
+
+
+
+[heading Geometries]
+
+
+* linestring:
+ This US Road originally contained 34 points, the simplified version contains 7 points
+
+
+
+
+* polygon:
+ This country (Belgium) originally contained 55 points, the simplified version contains 24 points
+
+
+
+
+[heading Remarks]
+
+simplifying a valid simple polygon (which never intersects itself) might result in an invalid polygon, where the simplified rings intersect themselves or one of the other outer or inner rings. Efficient simplification of a ring/polygon is still an "Open Problem" (http://maven.smith.edu/~orourke/TOPP/P24.html#Problem.24)
+
+
+* multi_linestring
+
+* multi_polygon
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/simplify.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 simplify (1 of 2 overloads)]
+
+
+Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`] using a specified [link boost_geometry.reference.strategy `strategy`].
+
+
+ template<
+ typename Geometry ,
+ typename Strategy >
+ void simplify(
+ Geometry const & geometry,
+ Geometry & out,
+ double max_distance,
+ Strategy const & strategy);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]]
+
+[[out][output [link boost_geometry.reference.boost__geometry `boost::geometry`], simplified version of the input [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[max_distance][distance (in units of input coordinates) of a vertex to other segments to be removed ]]
+
+[[strategy][simplify [link boost_geometry.reference.strategy `strategy`] to be used for simplification, might include point-distance [link boost_geometry.reference.strategy `strategy`] ]]
+
+]
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 simplify (2 of 2 overloads)]
+
+
+Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+ template<
+ typename Geometry >
+ void simplify(
+ Geometry const & geometry,
+ Geometry & out,
+ double max_distance);
+
+
+
+[heading Remarks]
+
+This version of simplify simplifies a [link boost_geometry.reference.boost__geometry `boost::geometry`] using the default [link boost_geometry.reference.strategy `strategy`] (Douglas Peucker),
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]]
+
+[[out][output [link boost_geometry.reference.boost__geometry `boost::geometry`], simplified version of the input [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+[[max_distance][distance (in units of input coordinates) of a vertex to other segments to be removed ]]
+
+]
+
+
+[heading Example:]
+
+The simplify algorithm can be used as following:
+
+
+
+
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:simplify_inserter simplify_inserter]
+
+[indexterm1 simplify_inserter]
+Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`], using an output iterator and a specified [link boost_geometry.reference.strategy `strategy`].
+
+
+ template<
+ typename Geometry ,
+ typename OutputIterator ,
+ typename Strategy >
+ void ``[link boost_geometry.reference.simplify_inserter.overload1 simplify_inserter]``(
+ Geometry const & geometry,
+ OutputIterator out,
+ double max_distance,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.simplify_inserter.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename OutputIterator >
+ void ``[link boost_geometry.reference.simplify_inserter.overload2 simplify_inserter]``(
+ Geometry const & geometry,
+ OutputIterator out,
+ double max_distance);
+ `` [''''»''' [link boost_geometry.reference.simplify_inserter.overload2 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/simplify.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 simplify_inserter (1 of 2 overloads)]
+
+
+Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`], using an output iterator and a specified [link boost_geometry.reference.strategy `strategy`].
+
+
+ template<
+ typename Geometry ,
+ typename OutputIterator ,
+ typename Strategy >
+ void simplify_inserter(
+ Geometry const & geometry,
+ OutputIterator out,
+ double max_distance,
+ Strategy const & strategy);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]]
+
+[[out][output iterator, outputs all simplified points ]]
+
+[[max_distance][distance (in units of input coordinates) of a vertex to other segments to be removed ]]
+
+[[strategy][simplify [link boost_geometry.reference.strategy `strategy`] to be used for simplification, might include point-distance [link boost_geometry.reference.strategy `strategy`] ]]
+
+]
+
+
+[heading Example:]
+
+simplify\_inserter with [link boost_geometry.reference.strategy `strategy`] is used as following:
+
+
+
+
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 simplify_inserter (2 of 2 overloads)]
+
+
+Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`], using an output iterator.
+
+
+ template<
+ typename Geometry ,
+ typename OutputIterator >
+ void simplify_inserter(
+ Geometry const & geometry,
+ OutputIterator out,
+ double max_distance);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]]
+
+[[out][output iterator, outputs all simplified points ]]
+
+[[max_distance][distance (in units of input coordinates) of a vertex to other segments to be removed ]]
+
+]
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:spherical_tag spherical_tag]
+
+
+Tag indicating Spherical coordinate system family (spherical,celestial,...).
+
+
+
+
+[heading Synopsis]
+ struct spherical_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:strategy__area__by_triangles strategy::area::by_triangles]
+
+
+Strategy functor for [link boost_geometry.reference.strategy__area `strategy::area`] calculation on [link boost_geometry.reference.point_xy `point_xy`] points.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename PointOfSegment ,
+ typename CalculationType = void>
+ class by_triangles
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy__area__by_triangles.return_type [*return_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__area__by_triangles.segment_point_type [*segment_point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__area__by_triangles.state_type [*state_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__area__by_triangles.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__area__by_triangles.result [*result]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+Calculates [link boost_geometry.reference.strategy__area `strategy::area`] using well-known triangulation algorithm
+
+[variablelist
+
+[[PointOfSegment][[link boost_geometry.reference.point `point`] type of segments ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/area_by_triangles.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::area::by_triangles::apply]
+
+[indexterm2 apply..strategy::area::by_triangles]
+
+ static void apply(
+ PointOfSegment const & p1,
+ PointOfSegment const & p2,
+ summation & state);
+
+
+
+[endsect]
+
+
+
+[section:result strategy::area::by_triangles::result]
+
+[indexterm2 result..strategy::area::by_triangles]
+
+ static return_type result(
+ summation const & state);
+
+
+
+[endsect]
+
+
+
+[section:return_type strategy::area::by_triangles::return_type]
+
+[indexterm2 return_type..strategy::area::by_triangles]
+
+ typedef boost::mpl::if_c< boost::is_void< CalculationType >::type::value, typename select_most_precise< typename coordinate_type< PointOfSegment >::type, double >::type, CalculationType >::type return_type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.coordinate_type.ncg [*ncg]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/area_by_triangles.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_point_type strategy::area::by_triangles::segment_point_type]
+
+[indexterm2 segment_point_type..strategy::area::by_triangles]
+
+ typedef PointOfSegment segment_point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/area_by_triangles.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:state_type strategy::area::by_triangles::state_type]
+
+[indexterm2 state_type..strategy::area::by_triangles]
+
+ typedef summation state_type;
+
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__area__by_triangles__summation.area [*area]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__area__by_triangles__summation.summation [*summation]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/area_by_triangles.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__area__by_triangles__summation strategy::area::by_triangles::summation]
+
+
+
+
+
+[heading Synopsis]
+ class summation
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__area__by_triangles__summation.area [*area]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__area__by_triangles__summation.summation [*summation]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/area_by_triangles.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:area strategy::area::by_triangles::summation::area]
+
+[indexterm2 area..strategy::area::by_triangles::summation]
+
+ return_type area() const;
+
+
+
+[endsect]
+
+
+
+[section:summation strategy::area::by_triangles::summation::summation]
+
+[indexterm2 summation..strategy::area::by_triangles::summation]
+
+ summation();
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__area__huiller strategy::area::huiller]
+
+
+Area calculation by spherical excess / Huiller's formula.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename PointOfSegment ,
+ typename CalculationType = void>
+ class huiller
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy__area__huiller.return_type [*return_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__area__huiller.segment_point_type [*segment_point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__area__huiller.state_type [*state_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller.huiller [*huiller]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller.result [*result]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[P][type of points of rings/polygons ]]
+
+]
+
+
+Barend Gehrels. Adapted from:
+* http://www.soe.ucsc.edu/~pang/160/f98/Gems/GemsIV/sph_poly.c
+
+* http://williams.best.vwh.net/avform.htm
+
+
+
+
+[heading Remarks]
+
+The version in Gems didn't account for polygons crossing the 180 meridian.
+
+This version works for convex and non-convex polygons, for 180 meridian crossing polygons and for polygons with holes. However, some cases (especially 180 meridian cases) must still be checked.
+
+The version which sums angles, which is often seen, doesn't handle non-convex polygons correctly.
+
+The version which sums longitudes, see http://trs-new.jpl.nasa.gov/dspace/bitstream/2014/40409/1/07-03.pdf, is simple and works well in most cases but not in 180 meridian crossing cases. This probably could be solved.
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/area_huiller.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::area::huiller::apply]
+
+[indexterm2 apply..strategy::area::huiller]
+
+ void apply(
+ PointOfSegment const & p1,
+ PointOfSegment const & p2,
+ excess_sum & state) const;
+
+
+
+[endsect]
+
+
+
+[section:huiller strategy::area::huiller::huiller]
+
+[indexterm2 huiller..strategy::area::huiller]
+
+ huiller(
+ double radius = 1.0);
+
+
+
+[endsect]
+
+
+
+[section:result strategy::area::huiller::result]
+
+[indexterm2 result..strategy::area::huiller]
+
+ return_type result(
+ excess_sum const & state) const;
+
+
+
+[endsect]
+
+
+
+[section:return_type strategy::area::huiller::return_type]
+
+[indexterm2 return_type..strategy::area::huiller]
+
+ typedef double return_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/area_huiller.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_point_type strategy::area::huiller::segment_point_type]
+
+[indexterm2 segment_point_type..strategy::area::huiller]
+
+ typedef PointOfSegment segment_point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/area_huiller.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:state_type strategy::area::huiller::state_type]
+
+[indexterm2 state_type..strategy::area::huiller]
+
+ typedef excess_sum state_type;
+
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller__excess_sum.area [*area]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller__excess_sum.excess_sum [*excess_sum]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller__excess_sum.distance_over_unit_sphere [*distance_over_unit_sphere]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller__excess_sum.sum [*sum]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/area_huiller.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__area__huiller__excess_sum strategy::area::huiller::excess_sum]
+
+
+
+
+
+[heading Synopsis]
+ struct excess_sum
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller__excess_sum.area [*area]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller__excess_sum.excess_sum [*excess_sum]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller__excess_sum.distance_over_unit_sphere [*distance_over_unit_sphere]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__area__huiller__excess_sum.sum [*sum]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/area_huiller.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:area strategy::area::huiller::excess_sum::area]
+
+[indexterm2 area..strategy::area::huiller::excess_sum]
+
+ double area(
+ double radius) const;
+
+
+
+[endsect]
+
+
+
+[section:distance_over_unit_sphere strategy::area::huiller::excess_sum::distance_over_unit_sphere]
+
+[indexterm2 distance_over_unit_sphere..strategy::area::huiller::excess_sum]
+
+ strategy::distance::haversine< PointOfSegment, PointOfSegment > distance_over_unit_sphere;
+
+
+
+[endsect]
+
+
+
+[section:excess_sum strategy::area::huiller::excess_sum::excess_sum]
+
+[indexterm2 excess_sum..strategy::area::huiller::excess_sum]
+
+ excess_sum();
+
+
+
+[endsect]
+
+
+
+[section:sum strategy::area::huiller::excess_sum::sum]
+
+[indexterm2 sum..strategy::area::huiller::excess_sum]
+
+ double sum;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__buffer__join_bevel strategy::buffer::join_bevel]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename PointIn ,
+ typename PointOut >
+ struct join_bevel
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__buffer__join_bevel.apply [*apply]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/buffer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::buffer::join_bevel::apply]
+
+[indexterm2 apply..strategy::buffer::join_bevel]
+
+ template<
+ typename Ring >
+ void apply(
+ PointIn const & ip,
+ PointIn const & vertex,
+ PointIn const & perp1,
+ PointIn const & perp2,
+ double buffer_distance,
+ Ring & buffered) const;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__buffer__join_miter strategy::buffer::join_miter]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename PointIn ,
+ typename PointOut >
+ struct join_miter
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy__buffer__join_miter.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__buffer__join_miter.side [*side]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__buffer__join_miter.apply [*apply]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/buffer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::buffer::join_miter::apply]
+
+[indexterm2 apply..strategy::buffer::join_miter]
+
+ template<
+ typename Ring >
+ void apply(
+ PointIn const & ip,
+ PointIn const & vertex,
+ PointIn const & perp1,
+ PointIn const & perp2,
+ double buffer_distance,
+ Ring & buffered) const;
+
+
+
+[endsect]
+
+
+
+[section:coordinate_type strategy::buffer::join_miter::coordinate_type]
+
+[indexterm2 coordinate_type..strategy::buffer::join_miter]
+
+ typedef coordinate_type< PointIn >::type coordinate_type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.coordinate_type.ncg [*ncg]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/buffer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:side strategy::buffer::join_miter::side]
+
+[indexterm2 side..strategy::buffer::join_miter]
+
+ typedef strategy_side< typename cs_tag< PointIn >::type >::type side;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy_side.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system of point-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/buffer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__buffer__join_round strategy::buffer::join_round]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename PointIn ,
+ typename PointOut >
+ struct join_round
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__buffer__join_round.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__buffer__join_round.join_round [*join_round]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__buffer__join_round.mid_points [*mid_points]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__buffer__join_round.m_max_level [*m_max_level]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/buffer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::buffer::join_round::apply]
+
+[indexterm2 apply..strategy::buffer::join_round]
+
+ template<
+ typename Ring >
+ void apply(
+ PointIn const & ip,
+ PointIn const & vertex,
+ PointIn const & perp1,
+ PointIn const & perp2,
+ double buffer_distance,
+ Ring & buffered) const;
+
+
+
+[endsect]
+
+
+
+[section:join_round strategy::buffer::join_round::join_round]
+
+[indexterm2 join_round..strategy::buffer::join_round]
+
+ join_round(
+ int max_level = 4);
+
+
+
+[endsect]
+
+
+
+[section:m_max_level strategy::buffer::join_round::m_max_level]
+
+[indexterm2 m_max_level..strategy::buffer::join_round]
+
+ int m_max_level;
+
+
+
+[endsect]
+
+
+
+[section:mid_points strategy::buffer::join_round::mid_points]
+
+[indexterm2 mid_points..strategy::buffer::join_round]
+
+ template<
+ typename Ring >
+ void mid_points(
+ PointIn const & vertex,
+ PointIn const & p1,
+ PointIn const & p2,
+ double buffer_distance,
+ Ring & buffered,
+ int level = 1) const;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__centroid___bashein_detmer strategy::centroid_::bashein_detmer]
+
+
+Centroid calculation using algorith Bashein / Detmer.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Point ,
+ typename PointOfSegment = Point,
+ typename CalculationType = void>
+ class bashein_detmer
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy__centroid___bashein_detmer.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__centroid___bashein_detmer.segment_point_type [*segment_point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__centroid___bashein_detmer.state_type [*state_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__centroid___bashein_detmer.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__centroid___bashein_detmer.result [*result]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+Calculates centroid using triangulation method published by Bashein / Detmer
+
+[variablelist
+
+[[Point][[link boost_geometry.reference.point `point`] type of centroid to calculate ]]
+
+[[PointOfSegment][[link boost_geometry.reference.point `point`] type of segments, defaults to Point ]]
+
+]
+
+
+[heading Concepts for Point and PointOfSegment:]
+
+
+* specialized point_traits class
+
+
+
+
+Adapted from "Centroid of a Polygon" by Gerard Bashein and Paul R. Detmer[*, in "Graphics Gems IV", Academic Press, 1994]
+
+
+[heading Research notes]
+
+The algorithm gives the same results as Oracle and PostGIS but differs from MySQL (tried 5.0.21 / 5.0.45 / 5.0.51a / 5.1.23).
+
+Without holes:
+* this: POINT(4.06923363095238 1.65055803571429)
+
+* geolib: POINT(4.07254 1.66819)
+
+* MySQL: POINT(3.6636363636364 1.6272727272727)'
+
+* PostGIS: POINT(4.06923363095238 1.65055803571429)
+
+* Oracle: 4.06923363095238 1.65055803571429
+
+* SQL Server: POINT(4.06923362245959 1.65055804168294)
+
+
+
+Statements:
+* MySQL/PostGIS: select AsText(Centroid(GeomFromText( '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))')))
+
+* Oracle: select sdo_geom.sdo_centroid(sdo_geometry(2003, null, null, sdo_elem_info_array(1, 1003, 1), sdo_ordinate_array( 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)) , mdsys.sdo_dim_array(mdsys.sdo_dim_element('x',0,10,.00000005) ,mdsys.sdo_dim_element('y',0,10,.00000005))) from dual
+
+* SQL Server 2008: select geometry::STGeomFromText( '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))',0) .STCentroid() .STAsText()
+
+
+
+With holes:
+* this: POINT(4.04663 1.6349)
+
+* geolib: POINT(4.04675 1.65735)
+
+* MySQL: POINT(3.6090580503834 1.607573932092)
+
+* PostGIS: POINT(4.0466265060241 1.63489959839357)
+
+* Oracle: 4.0466265060241 1.63489959839357
+
+* SQL Server: POINT(4.0466264962959677 1.6348996057331333)
+
+
+
+Statements:
+* MySQL/PostGIS: select AsText(Centroid(GeomFromText( '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 2,4.2 1.4,4.8 1.9,4.4 2.2,4 2))')));
+
+* Oracle: select sdo_geom.sdo_centroid(sdo_geometry(2003, null, null , sdo_elem_info_array(1, 1003, 1, 25, 2003, 1) , sdo_ordinate_array(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,2, 4.2,1.4, 4.8,1.9, 4.4,2.2, 4,2)) , mdsys.sdo_dim_array(mdsys.sdo_dim_element('x',0,10,.00000005) ,mdsys.sdo_dim_element('y',0,10,.00000005))) from dual
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::centroid_::bashein_detmer::apply]
+
+[indexterm2 apply..strategy::centroid_::bashein_detmer]
+
+ static void apply(
+ PointOfSegment const & p1,
+ PointOfSegment const & p2,
+ sums & state);
+
+
+
+[endsect]
+
+
+
+[section:point_type strategy::centroid_::bashein_detmer::point_type]
+
+[indexterm2 point_type..strategy::centroid_::bashein_detmer]
+
+ typedef Point point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:result strategy::centroid_::bashein_detmer::result]
+
+[indexterm2 result..strategy::centroid_::bashein_detmer]
+
+ static bool result(
+ sums const & state,
+ Point & centroid);
+
+
+
+[endsect]
+
+
+
+[section:segment_point_type strategy::centroid_::bashein_detmer::segment_point_type]
+
+[indexterm2 segment_point_type..strategy::centroid_::bashein_detmer]
+
+ typedef PointOfSegment segment_point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:state_type strategy::centroid_::bashein_detmer::state_type]
+
+[indexterm2 state_type..strategy::centroid_::bashein_detmer]
+
+ typedef sums state_type;
+
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__centroid___bashein_detmer__sums.sums [*sums]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+subclass to keep state
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__centroid___bashein_detmer__sums strategy::centroid_::bashein_detmer::sums]
+
+
+
+
+
+[heading Synopsis]
+ class sums
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__centroid___bashein_detmer__sums.sums [*sums]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+subclass to keep state
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:sums strategy::centroid_::bashein_detmer::sums::sums]
+
+[indexterm2 sums..strategy::centroid_::bashein_detmer::sums]
+
+ sums();
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__compare__circular_comparator strategy::compare::circular_comparator]
+
+
+Compare (in one direction) [link boost_geometry.reference.strategy `strategy`] for spherical coordinates.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename CoordinateType ,
+ typename Units ,
+ typename Compare >
+ struct circular_comparator
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__compare__circular_comparator.operator() [*operator()]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__compare__circular_comparator.put_in_range [*put_in_range]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[Point][point-type ]]
+
+[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/compare_circular.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:operator() strategy::compare::circular_comparator::operator()]
+
+[indexterm2 operator()..strategy::compare::circular_comparator]
+
+ bool operator()(
+ CoordinateType const & c1,
+ CoordinateType const & c2) const;
+
+
+
+[endsect]
+
+
+
+[section:put_in_range strategy::compare::circular_comparator::put_in_range]
+
+[indexterm2 put_in_range..strategy::compare::circular_comparator]
+
+ static CoordinateType put_in_range(
+ CoordinateType const & c,
+ double min_border,
+ double max_border);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__compare__default_strategy strategy::compare::default_strategy]
+
+
+Default [link boost_geometry.reference.strategy `strategy`], indicates the default [link boost_geometry.reference.strategy `strategy`] for comparisons.
+
+
+
+
+[heading Synopsis]
+ struct default_strategy
+
+[heading Description]
+
+The default [link boost_geometry.reference.strategy `strategy`] for comparisons defer in most cases to std::less (for ascending) and std::greater (for descending). However, if a spherical coordinate system is used, and comparison is done on longitude, it will take another [link boost_geometry.reference.strategy `strategy`] handling circular
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/compare.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:strategy__convex_hull__graham_andrew strategy::convex_hull::graham_andrew]
+
+
+Graham scan [link boost_geometry.reference.strategy `strategy`] to calculate convex hull.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename InputGeometry ,
+ typename OutputPoint >
+ class graham_andrew
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy__convex_hull__graham_andrew.geometry_type [*geometry_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__convex_hull__graham_andrew.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__convex_hull__graham_andrew.state_type [*state_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__convex_hull__graham_andrew.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__convex_hull__graham_andrew.result [*result]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+[heading Remarks]
+
+Completely reworked version inspired on the sources listed below
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/agnostic/hull_graham_andrew.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::convex_hull::graham_andrew::apply]
+
+[indexterm2 apply..strategy::convex_hull::graham_andrew]
+
+ void apply(
+ InputGeometry const & geometry,
+ partitions & state) const;
+
+
+
+[endsect]
+
+
+
+[section:geometry_type strategy::convex_hull::graham_andrew::geometry_type]
+
+[indexterm2 geometry_type..strategy::convex_hull::graham_andrew]
+
+ typedef InputGeometry geometry_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/agnostic/hull_graham_andrew.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:point_type strategy::convex_hull::graham_andrew::point_type]
+
+[indexterm2 point_type..strategy::convex_hull::graham_andrew]
+
+ typedef OutputPoint point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/agnostic/hull_graham_andrew.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:result strategy::convex_hull::graham_andrew::result]
+
+[indexterm2 result..strategy::convex_hull::graham_andrew]
+
+ template<
+ typename OutputIterator >
+ void result(
+ partitions const & state,
+ OutputIterator out,
+ bool clockwise) const;
+
+
+
+[endsect]
+
+
+
+[section:state_type strategy::convex_hull::graham_andrew::state_type]
+
+[indexterm2 state_type..strategy::convex_hull::graham_andrew]
+
+ typedef partitions state_type;
+
+
+[heading Typedef Description]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/agnostic/hull_graham_andrew.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__convex_hull__graham_andrew__partitions strategy::convex_hull::graham_andrew::partitions]
+
+
+
+
+
+[heading Synopsis]
+ class partitions
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/agnostic/hull_graham_andrew.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:strategy__distance__cross_track strategy::distance::cross_track]
+
+
+Strategy functor for [link boost_geometry.reference.strategy__distance `strategy::distance`] [link boost_geometry.reference.point `point`] to [link boost_geometry.reference.segment `segment`] calculation.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Point ,
+ typename PointOfSegment >
+ class cross_track
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__cross_track.point_strategy_type [*point_strategy_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__cross_track.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__cross_track.return_type [*return_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__cross_track.segment_point_type [*segment_point_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__distance__cross_track.BOOST_CONCEPT_ASSERT [*BOOST_CONCEPT_ASSERT]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__distance__cross_track.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__distance__cross_track.cross_track [*cross_track]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+Class which calculates the [link boost_geometry.reference.strategy__distance `strategy::distance`] of a [link boost_geometry.reference.point `point`] to a [link boost_geometry.reference.segment `segment`], using latlong points
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[S][[link boost_geometry.reference.segment `segment`] type ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/distance_cross_track.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:BOOST_CONCEPT_ASSERT strategy::distance::cross_track::BOOST_CONCEPT_ASSERT]
+
+[indexterm2 BOOST_CONCEPT_ASSERT..strategy::distance::cross_track]
+
+ BOOST_CONCEPT_ASSERT(
+ (geometry::concept::PointDistanceStrategy< point_strategy_type >) );
+
+
+
+[endsect]
+
+
+
+[section:apply strategy::distance::cross_track::apply]
+
+[indexterm2 apply..strategy::distance::cross_track]
+
+ return_type apply(
+ Point const & p,
+ PointOfSegment const & sp1,
+ PointOfSegment const & sp2) const;
+
+
+
+[endsect]
+
+
+
+[section:cross_track strategy::distance::cross_track::cross_track]
+
+[indexterm2 cross_track..strategy::distance::cross_track]
+
+ cross_track(
+ double r = 1.0);
+
+
+
+[endsect]
+
+
+
+[section:point_strategy_type strategy::distance::cross_track::point_strategy_type]
+
+[indexterm2 point_strategy_type..strategy::distance::cross_track]
+
+ typedef strategy_distance< typename geometry::cs_tag< Point >::type, typename geometry::cs_tag< Point >::type, Point, Point >::type point_strategy_type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy_distance.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[T1][[link boost_geometry.reference.tag `tag`] of coordinate system of first [link boost_geometry.reference.point `point`] type ]]
+
+[[T2][[link boost_geometry.reference.tag `tag`] of coordinate system of second [link boost_geometry.reference.point `point`] type ]]
+
+[[P1][first point-type ]]
+
+[[P2][second point-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/distance_cross_track.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:point_type strategy::distance::cross_track::point_type]
+
+[indexterm2 point_type..strategy::distance::cross_track]
+
+ typedef Point point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/distance_cross_track.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:return_type strategy::distance::cross_track::return_type]
+
+[indexterm2 return_type..strategy::distance::cross_track]
+
+ typedef double return_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/distance_cross_track.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_point_type strategy::distance::cross_track::segment_point_type]
+
+[indexterm2 segment_point_type..strategy::distance::cross_track]
+
+ typedef PointOfSegment segment_point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/distance_cross_track.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__distance__haversine strategy::distance::haversine]
+
+
+Distance calculation for spherical coordinates on a perfect sphere using [link boost_geometry.reference.strategy__distance__haversine `strategy::distance::haversine`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename ``[link boost_geometry.reference.Point1 Point1]``,
+ typename ``[link boost_geometry.reference.Point2 Point2]`` = Point1>
+ class haversine
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__haversine.first_point_type [*first_point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__haversine.return_type [*return_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__haversine.second_point_type [*second_point_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__distance__haversine.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__distance__haversine.haversine [*haversine]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
+
+[[P2][optional second [link boost_geometry.reference.point `point`] type ]]
+
+]
+
+
+Adapted from: http://williams.best.vwh.net/avform.htm
+
+
+
+[heading Remarks]
+
+It says: [*The great circle distance d between two points with coordinates {lat1,lon1} and {lat2,lon2} is given by: d=acos(sin(lat1)*sin(lat2)+cos(lat1)*cos(lat2)*cos(lon1-lon2)) A mathematically equivalent formula, which is less subject to rounding error for short distances is: d=2*asin(sqrt((sin((lat1-lat2)/2))^2 + cos(lat1)*cos(lat2)*(sin((lon1-lon2)/2))^2)) ]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/distance_haversine.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::distance::haversine::apply]
+
+[indexterm2 apply..strategy::distance::haversine]
+
+ return_type apply(
+ Point1 const & p1,
+ Point2 const & p2) const;
+
+
+
+[endsect]
+
+
+
+[section:first_point_type strategy::distance::haversine::first_point_type]
+
+[indexterm2 first_point_type..strategy::distance::haversine]
+
+ typedef Point1 first_point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/distance_haversine.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:haversine strategy::distance::haversine::haversine]
+
+[indexterm2 haversine..strategy::distance::haversine]
+
+ haversine(
+ double r = 1.0);
+
+
+
+[endsect]
+
+
+
+[section:return_type strategy::distance::haversine::return_type]
+
+[indexterm2 return_type..strategy::distance::haversine]
+
+ typedef double return_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/distance_haversine.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:second_point_type strategy::distance::haversine::second_point_type]
+
+[indexterm2 second_point_type..strategy::distance::haversine]
+
+ typedef Point2 second_point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/distance_haversine.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__distance__projected_point strategy::distance::projected_point]
+
+
+Strategy for [link boost_geometry.reference.strategy__distance `strategy::distance`] [link boost_geometry.reference.point `point`] to [link boost_geometry.reference.segment `segment`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Point ,
+ typename PointOfSegment ,
+ typename Strategy = pythagoras < Point, typename point_type<PointOfSegment>::type >>
+ struct projected_point
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__projected_point.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__projected_point.point_strategy_type [*point_strategy_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__projected_point.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__projected_point.return_type [*return_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__projected_point.segment_point_type [*segment_point_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__distance__projected_point.apply [*apply]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+Calculates [link boost_geometry.reference.strategy__distance `strategy::distance`] using projected-point method, and (optionally) Pythagoras
+Adapted from: http://geometryalgorithms.com/Archive/algorithm\_0102/algorithm\_0102.htm
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[PointOfSegment][[link boost_geometry.reference.segment `segment`] type ]]
+
+[[Strategy][[link boost_geometry.reference.strategy `strategy`], optional, defaults to [link boost_geometry.reference.strategy__distance__pythagoras `strategy::distance::pythagoras`] ]]
+
+]
+
+
+[heading Concepts for Strategy:]
+
+
+* cartesian_distance operator(Point,Point)
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_projected_point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::distance::projected_point::apply]
+
+[indexterm2 apply..strategy::distance::projected_point]
+
+ return_type apply(
+ Point const & p,
+ PointOfSegment const & p1,
+ PointOfSegment const & p2) const;
+
+
+
+[endsect]
+
+
+
+[section:coordinate_type strategy::distance::projected_point::coordinate_type]
+
+[indexterm2 coordinate_type..strategy::distance::projected_point]
+
+ typedef select_coordinate_type< Point, PointOfSegment >::type coordinate_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_projected_point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:point_strategy_type strategy::distance::projected_point::point_strategy_type]
+
+[indexterm2 point_strategy_type..strategy::distance::projected_point]
+
+ typedef Strategy point_strategy_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_projected_point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:point_type strategy::distance::projected_point::point_type]
+
+[indexterm2 point_type..strategy::distance::projected_point]
+
+ typedef Point point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_projected_point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:return_type strategy::distance::projected_point::return_type]
+
+[indexterm2 return_type..strategy::distance::projected_point]
+
+ typedef cartesian_distance< coordinate_type > return_type;
+
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.cartesian_distance [*cartesian_distance]]]
+ [Constructor with a value. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_cast_type [*operator cast_type]]]
+ [Automatic conversion to double or higher precision, taking squareroot if necessary. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_lt_ [*operator<]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_eq__eq_ [*operator==]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_gt_ [*operator>]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.squared_value [*squared_value]]]
+ [The "squared_value" method returns the internal squared value. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.very_small [*very_small]]]
+ []
+ ]
+
+]
+
+[heading Friends]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_lt__lt_ [*operator<<]]]
+ [Make streamable to enable std::cout << geometry::distance( ). ]
+ ]
+
+]
+
+[heading Typedef Description]
+
+Distance calculation for xy points or xyz points is done by taking the square root. However, for distance comparison drawing the square root is not necessary. Therefore the distance strategies are allowed to return the squares of the distance. This structure contains the distance, and a boolean to indicate if it is squared. It has an automatic conversion to a double value, which does the square root if necessary.
+[heading Remarks]
+
+Thanks to Phil Endecott for his suggestion to change the pair to the double-convertable http://article.gmane.org/gmane.comp.lib.boost.devel/172709/match=greatcircle\_distance
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_projected_point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_point_type strategy::distance::projected_point::segment_point_type]
+
+[indexterm2 segment_point_type..strategy::distance::projected_point]
+
+ typedef PointOfSegment segment_point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_projected_point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__distance__pythagoras strategy::distance::pythagoras]
+
+
+Strategy for [link boost_geometry.reference.strategy__distance `strategy::distance`] [link boost_geometry.reference.point `point`] to [link boost_geometry.reference.point `point`]: [link boost_geometry.reference.strategy__distance__pythagoras `strategy::distance::pythagoras`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Point1 ,
+ typename Point2 = Point1,
+ typename CalculationType = void>
+ struct pythagoras
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__pythagoras.calculation_type [*calculation_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__pythagoras.first_point_type [*first_point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__pythagoras.return_type [*return_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__distance__pythagoras.second_point_type [*second_point_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__distance__pythagoras.apply [*apply]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[Point1][first [link boost_geometry.reference.point `point`] type ]]
+
+[[Point2][optional, second [link boost_geometry.reference.point `point`] type, defaults to first [link boost_geometry.reference.point `point`] type ]]
+
+]
+
+
+[heading Concepts for Point1 and Point2:]
+
+
+* specialized point_traits class
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_pythagoras.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::distance::pythagoras::apply]
+
+[indexterm2 apply..strategy::distance::pythagoras]
+
+ return_type apply(
+ Point1 const & p1,
+ Point2 const & p2) const;
+
+
+
+[endsect]
+
+
+
+[section:calculation_type strategy::distance::pythagoras::calculation_type]
+
+[indexterm2 calculation_type..strategy::distance::pythagoras]
+
+ typedef select_calculation_type< Point1, Point2, CalculationType >::type calculation_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_pythagoras.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:first_point_type strategy::distance::pythagoras::first_point_type]
+
+[indexterm2 first_point_type..strategy::distance::pythagoras]
+
+ typedef Point1 first_point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_pythagoras.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:return_type strategy::distance::pythagoras::return_type]
+
+[indexterm2 return_type..strategy::distance::pythagoras]
+
+ typedef cartesian_distance< calculation_type > return_type;
+
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.cartesian_distance [*cartesian_distance]]]
+ [Constructor with a value. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_cast_type [*operator cast_type]]]
+ [Automatic conversion to double or higher precision, taking squareroot if necessary. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_lt_ [*operator<]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_eq__eq_ [*operator==]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_gt_ [*operator>]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.squared_value [*squared_value]]]
+ [The "squared_value" method returns the internal squared value. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.very_small [*very_small]]]
+ []
+ ]
+
+]
+
+[heading Friends]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.cartesian_distance.operator_lt__lt_ [*operator<<]]]
+ [Make streamable to enable std::cout << geometry::distance( ). ]
+ ]
+
+]
+
+[heading Typedef Description]
+
+Distance calculation for xy points or xyz points is done by taking the square root. However, for distance comparison drawing the square root is not necessary. Therefore the distance strategies are allowed to return the squares of the distance. This structure contains the distance, and a boolean to indicate if it is squared. It has an automatic conversion to a double value, which does the square root if necessary.
+[heading Remarks]
+
+Thanks to Phil Endecott for his suggestion to change the pair to the double-convertable http://article.gmane.org/gmane.comp.lib.boost.devel/172709/match=greatcircle\_distance
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_pythagoras.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:second_point_type strategy::distance::pythagoras::second_point_type]
+
+[indexterm2 second_point_type..strategy::distance::pythagoras]
+
+ typedef Point2 second_point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/distance_pythagoras.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__intersection__liang_barsky strategy::intersection::liang_barsky]
+
+
+Strategy: line clipping algorithm after Liang Barsky.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Box ,
+ typename Point >
+ class liang_barsky
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__intersection__liang_barsky.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__intersection__liang_barsky.clip_segment [*clip_segment]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+The Liang-Barsky line clipping algorithm clips a line with a clipping [link boost_geometry.reference.box `box`]. It is slightly adapted in the sense that it returns which points are clipped
+
+[variablelist
+
+[[B][input [link boost_geometry.reference.box `box`] type of clipping [link boost_geometry.reference.box `box`] ]]
+
+[[P][input/output point-type of segments to be clipped ]]
+
+]
+
+
+[heading Remarks]
+
+The algorithm is currently only implemented for 2D Cartesian points
+
+Though it is implemented in namespace [link boost_geometry.reference.strategy `strategy`], and theoretically another [link boost_geometry.reference.strategy `strategy`] could be used, it is not (yet) updated to the general [link boost_geometry.reference.strategy `strategy`] concepts, and not (yet) splitted into a file in folder strategies
+
+
+Barend Gehrels, and the following recourses
+* A tutorial: http://www.skytopia.com/project/articles/compsci/clipping.html
+
+* a German applet (link broken): http://ls7-www.cs.uni-dortmund.de/students/projectgroups/acit/lineclip.shtml
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/overlay/clip_linestring.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::intersection::liang_barsky::apply]
+
+[indexterm2 apply..strategy::intersection::liang_barsky]
+
+ template<
+ typename Linestring ,
+ typename OutputIterator >
+ void apply(
+ Linestring & line_out,
+ OutputIterator out) const;
+
+
+
+[endsect]
+
+
+
+[section:clip_segment strategy::intersection::liang_barsky::clip_segment]
+
+[indexterm2 clip_segment..strategy::intersection::liang_barsky]
+
+ bool clip_segment(
+ Box const & b,
+ segment_type & s,
+ bool & sp1_clipped,
+ bool & sp2_clipped) const;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__intersection__relate_cartesian_segments strategy::intersection::relate_cartesian_segments]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Policy ,
+ typename CalculationType = void>
+ struct relate_cartesian_segments
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.return_type [*return_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.segment_type1 [*segment_type1]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.segment_type2 [*segment_type2]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.BOOST_CONCEPT_ASSERT [*BOOST_CONCEPT_ASSERT]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.apply [*apply]]]
+ [Relate segments a and b.
+
+ ]
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/cart_intersect.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+[section:BOOST_CONCEPT_ASSERT strategy::intersection::relate_cartesian_segments::BOOST_CONCEPT_ASSERT]
+
+[indexterm2 BOOST_CONCEPT_ASSERT..strategy::intersection::relate_cartesian_segments]
+
+ ``[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.BOOST_CONCEPT_ASSERT.overload1 BOOST_CONCEPT_ASSERT]``(
+ (concept::ConstSegment< segment_type1 >) );
+ `` [''''»''' [link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.BOOST_CONCEPT_ASSERT.overload1 more...]]``
+
+ ``[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.BOOST_CONCEPT_ASSERT.overload2 BOOST_CONCEPT_ASSERT]``(
+ (concept::ConstSegment< segment_type2 >) );
+ `` [''''»''' [link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.BOOST_CONCEPT_ASSERT.overload2 more...]]``
+
+
+[section:overload1 strategy::intersection::relate_cartesian_segments::BOOST_CONCEPT_ASSERT (1 of 2 overloads)]
+
+
+
+ BOOST_CONCEPT_ASSERT(
+ (concept::ConstSegment< segment_type1 >) );
+
+
+
+[endsect]
+
+
+
+[section:overload2 strategy::intersection::relate_cartesian_segments::BOOST_CONCEPT_ASSERT (2 of 2 overloads)]
+
+
+
+ BOOST_CONCEPT_ASSERT(
+ (concept::ConstSegment< segment_type2 >) );
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:apply strategy::intersection::relate_cartesian_segments::apply]
+
+[indexterm2 apply..strategy::intersection::relate_cartesian_segments]
+Relate segments a and b.
+
+
+ static return_type ``[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.apply.overload1 apply]``(
+ segment_type1 const & a,
+ segment_type2 const & b);
+ `` [''''»''' [link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.apply.overload1 more...]]``
+
+
+
+ static return_type ``[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.apply.overload2 apply]``(
+ segment_type1 const & a,
+ segment_type2 const & b,
+ coordinate_type const & dx_a,
+ coordinate_type const & dy_a,
+ coordinate_type const & dx_b,
+ coordinate_type const & dy_b);
+ `` [''''»''' [link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.apply.overload2 more...]]``
+
+
+[section:overload1 strategy::intersection::relate_cartesian_segments::apply (1 of 2 overloads)]
+
+
+Relate segments a and b.
+
+
+ static return_type apply(
+ segment_type1 const & a,
+ segment_type2 const & b);
+
+
+
+[endsect]
+
+
+
+[section:overload2 strategy::intersection::relate_cartesian_segments::apply (2 of 2 overloads)]
+
+
+
+ static return_type apply(
+ segment_type1 const & a,
+ segment_type2 const & b,
+ coordinate_type const & dx_a,
+ coordinate_type const & dy_a,
+ coordinate_type const & dx_b,
+ coordinate_type const & dy_b);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:coordinate_type strategy::intersection::relate_cartesian_segments::coordinate_type]
+
+[indexterm2 coordinate_type..strategy::intersection::relate_cartesian_segments]
+
+ typedef select_calculation_type< segment_type1, segment_type2, CalculationType >::type coordinate_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/cart_intersect.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:return_type strategy::intersection::relate_cartesian_segments::return_type]
+
+[indexterm2 return_type..strategy::intersection::relate_cartesian_segments]
+
+ typedef Policy::return_type return_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/cart_intersect.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_type1 strategy::intersection::relate_cartesian_segments::segment_type1]
+
+[indexterm2 segment_type1..strategy::intersection::relate_cartesian_segments]
+
+ typedef Policy::segment_type1 segment_type1;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/cart_intersect.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_type2 strategy::intersection::relate_cartesian_segments::segment_type2]
+
+[indexterm2 segment_type2..strategy::intersection::relate_cartesian_segments]
+
+ typedef Policy::segment_type2 segment_type2;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/cart_intersect.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__not_implemented strategy::not_implemented]
+
+
+Indicate compiler/library user that [link boost_geometry.reference.strategy `strategy`] is not implemented.
+
+
+
+
+[heading Synopsis]
+ struct not_implemented
+
+[heading Description]
+
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:strategy__side__course strategy::side::course]
+
+[indexterm1 strategy::side::course]
+Calculate course (bearing) between two points. Might be moved to a "course formula" ...
+
+
+ template<
+ typename Point >
+ static double course(
+ Point const & p1,
+ Point const & p2);
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/side_by_cross_track.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:strategy__side__side_by_cross_track strategy::side::side_by_cross_track]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename CalculationType >
+ struct side_by_cross_track
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__side__side_by_cross_track.apply [*apply]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/spherical/side_by_cross_track.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::side::side_by_cross_track::apply]
+
+[indexterm2 apply..strategy::side::side_by_cross_track]
+
+ template<
+ typename P1 ,
+ typename P2 ,
+ typename P >
+ static int apply(
+ P1 const & p1,
+ P2 const & p2,
+ P const & p);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy__side__side_by_triangle strategy::side::side_by_triangle]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename CalculationType >
+ struct side_by_triangle
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__side__side_by_triangle.apply [*apply]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/cartesian/side_by_triangle.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:apply strategy::side::side_by_triangle::apply]
+
+[indexterm2 apply..strategy::side::side_by_triangle]
+
+ template<
+ typename P1 ,
+ typename P2 ,
+ typename P >
+ static int apply(
+ P1 const & p1,
+ P2 const & p2,
+ P const & p);
- struct linestring_tag
-[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:make make]
-
-[indexterm1 make]
-Make a geometry.
+[section:strategy__simplify__douglas_peucker strategy::simplify::douglas_peucker]
-
- template<
- typename Geometry ,
- typename T >
- Geometry ``[link boost_geometry.reference.make.overload1 make]``(
- T const & c1,
- T const & c2);
- `` [''''»''' [link boost_geometry.reference.make.overload1 more...]]``
- template<
- typename Geometry ,
- typename T >
- Geometry ``[link boost_geometry.reference.make.overload2 make]``(
- T const & c1,
- T const & c2,
- T const & c3);
- `` [''''»''' [link boost_geometry.reference.make.overload2 more...]]``
+Implements the [link boost_geometry.reference.strategy__simplify `strategy::simplify`] algorithm.
- template<
- typename Geometry ,
- typename T >
- Geometry ``[link boost_geometry.reference.make.overload3 make]``(
- T const & c1,
- T const & c2,
- T const & c3,
- T const & c4);
- `` [''''»''' [link boost_geometry.reference.make.overload3 more...]]``
- template<
- typename Geometry ,
- typename Range >
- Geometry ``[link boost_geometry.reference.make.overload4 make]``(
- Range const & range);
- `` [''''»''' [link boost_geometry.reference.make.overload4 more...]]``
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/make.hpp]
+[heading Synopsis]
+ template<
+ typename Point ,
+ typename PointDistanceStrategy >
+ class douglas_peucker
-[*Convenience header: ][^boost/geometry.hpp]
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
-[section:overload1 make (1 of 4 overloads)]
+ [[link boost_geometry.reference.strategy__simplify__douglas_peucker.distance_strategy_type [*distance_strategy_type]]]
+ []
+
+ ]
+]
-Make a geometry.
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
- template<
- typename Geometry ,
- typename T >
- Geometry make(
- T const & c1,
- T const & c2);
+ [
+ [[link boost_geometry.reference.strategy__simplify__douglas_peucker.apply [*apply]]]
+ []
+ ]
+
+]
-the Generic Geometry Library uses concepts for all its geometries. Therefore it does not rely on constructors. The "make" functions are object generators creating geometries. There are overloads with two, three, four or six values, which are implemented depending on the geometry specified.
-[heading Remarks]
-
-It does not work with array-point types, like int[2]
+[heading Description]
+The [link boost_geometry.reference.strategy__simplify__douglas_peucker `strategy::simplify::douglas_peucker`] [link boost_geometry.reference.strategy `strategy`] simplifies a [link boost_geometry.reference.linestring `linestring`], ring or vector of points using the well-known Douglas-Peucker algorithm. For the algorithm, see for example:
[variablelist
-[[G][the geometry type ]]
+[[Point][the [link boost_geometry.reference.point `point`] type ]]
-[[T][the coordinate type ]]
+[[PointDistanceStrategy][point-segment [link boost_geometry.reference.strategy__distance `strategy::distance`] [link boost_geometry.reference.strategy `strategy`] to be used ]]
]
-[heading Return Value]
+[heading Remarks]
-the geometry
+This [link boost_geometry.reference.strategy `strategy`] uses itself a point-segment-distance [link boost_geometry.reference.strategy `strategy`] which can be specified
+Barend and Maarten, 1995/1996
+Barend, revised for Generic Geometry Library, 2008
-[endsect]
+[heading Requirements]
-[section:overload2 make (2 of 4 overloads)]
+[*Header: ][^boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
-Make a geometry.
+[section:apply strategy::simplify::douglas_peucker::apply]
+[indexterm2 apply..strategy::simplify::douglas_peucker]
template<
- typename Geometry ,
- typename T >
- Geometry make(
- T const & c1,
- T const & c2,
- T const & c3);
+ typename Range ,
+ typename OutputIterator >
+ static OutputIterator apply(
+ Range const & range,
+ OutputIterator out,
+ double max_distance);
-[heading Return Value]
-
-a 3D point
+[endsect]
+[section:distance_strategy_type strategy::simplify::douglas_peucker::distance_strategy_type]
-[endsect]
+[indexterm2 distance_strategy_type..strategy::simplify::douglas_peucker]
+ typedef PointDistanceStrategy distance_strategy_type;
-[section:overload3 make (3 of 4 overloads)]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp]
- template<
- typename Geometry ,
- typename T >
- Geometry make(
- T const & c1,
- T const & c2,
- T const & c3,
- T const & c4);
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
[endsect]
+[section:strategy__transform__copy_direct strategy::transform::copy_direct]
-[section:overload4 make (4 of 4 overloads)]
+Transformation [link boost_geometry.reference.strategy `strategy`] to copy one [link boost_geometry.reference.point `point`] to another using assignment operator.
+
+[heading Synopsis]
template<
- typename Geometry ,
- typename Range >
- Geometry make(
- Range const & range);
+ typename P >
+ struct copy_direct
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__transform__copy_direct.apply [*apply]]]
+ []
+ ]
+
+]
-[endsect]
+[heading Description]
-[endsect]
-[section:make_buffer make_buffer]
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
-[indexterm1 make_buffer]
-Calculate and return buffer (= new geometry) around specified distance of geometry.
+]
- template<
- typename Output ,
- typename Input ,
- typename T >
- Output make_buffer(
- Input const & geometry,
- T const & distance,
- T const & chord_length = -1);
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/strategy_transform.hpp]
-[heading Parameters]
-
+[*Convenience header: ][^boost/geometry.hpp]
-[variablelist
-
-[[geometry][input geometry ]]
-[[distance][the distance used in buffer ]]
+[section:apply strategy::transform::copy_direct::apply]
-[[chord_length][length of the chord's in the generated arcs around points or bends ]]
+[indexterm2 apply..strategy::transform::copy_direct]
-]
+ bool apply(
+ P const & p1,
+ P & p2) const;
-[heading Return Value]
-
-the buffered geometry
+[endsect]
-[heading Remarks]
-
-See also: buffer
+[endsect]
-[heading Requirements]
+[section:strategy__transform__copy_per_coordinate strategy::transform::copy_per_coordinate]
-[*Header: ][^boost/geometry/algorithms/buffer.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+Transformation [link boost_geometry.reference.strategy `strategy`] to do copy a [link boost_geometry.reference.point `point`], copying per coordinate.
-[endsect]
-[section:make_centroid make_centroid]
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 >
+ struct copy_per_coordinate
-[indexterm1 make_centroid]
-Calculate and return centroid.
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
-
- template<
- typename Point ,
- typename Geometry >
- Point ``[link boost_geometry.reference.make_centroid.overload1 make_centroid]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.make_centroid.overload1 more...]]``
+ [
+ [[link boost_geometry.reference.strategy__transform__copy_per_coordinate.apply [*apply]]]
+ []
+ ]
+
+]
- template<
- typename Point ,
- typename Geometry ,
- typename Strategy >
- Point ``[link boost_geometry.reference.make_centroid.overload2 make_centroid]``(
- Geometry const & geometry,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.make_centroid.overload2 more...]]``
-[heading Requirements]
+[heading Description]
-[*Header: ][^boost/geometry/algorithms/centroid.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[variablelist
+
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
-[section:overload1 make_centroid (1 of 2 overloads)]
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
+]
-Calculate and return centroid.
- template<
- typename Point ,
- typename Geometry >
- Point make_centroid(
- Geometry const & geometry);
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/strategy_transform.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Parameters]
-
-[variablelist
-
-[[geometry][the geometry to calculate centroid from ]]
+[section:apply strategy::transform::copy_per_coordinate::apply]
-]
+[indexterm2 apply..strategy::transform::copy_per_coordinate]
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
-[heading Return Value]
-
-the centroid
+[endsect]
+
[endsect]
+[section:strategy__transform__degree_radian_vv strategy::transform::degree_radian_vv]
-[section:overload2 make_centroid (2 of 2 overloads)]
+Transformation [link boost_geometry.reference.strategy `strategy`] to go from [link boost_geometry.reference.degree `degree`] to [link boost_geometry.reference.radian `radian`] and back.
-Calculate and return centroid, using a specified strategy.
+[heading Synopsis]
template<
- typename Point ,
- typename Geometry ,
- typename Strategy >
- Point make_centroid(
- Geometry const & geometry,
- Strategy const & strategy);
+ typename P1 ,
+ typename P2 ,
+ template< typename > class ``[link boost_geometry.reference.F F]``>
+ struct degree_radian_vv
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__transform__degree_radian_vv.apply [*apply]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
-[heading Parameters]
-
[variablelist
-[[geometry][the geometry to calculate centroid from ]]
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
-[[strategy][Calculation strategy for centroid ]]
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
-]
+[[F][additional functor to divide or multiply with d2r ]]
+]
-[heading Return Value]
-
-the centroid
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/strategy_transform.hpp]
-[endsect]
+[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:apply strategy::transform::degree_radian_vv::apply]
+[indexterm2 apply..strategy::transform::degree_radian_vv]
-[section:make_envelope make_envelope]
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
-[indexterm1 make_envelope]
-Calculate and return envelope of a geometry.
- template<
- typename Box ,
- typename Geometry >
- Box make_envelope(
- Geometry const & geometry);
+[endsect]
-[heading Parameters]
-
+[endsect]
-[variablelist
-
-[[geometry][the geometry ]]
+[section:strategy__transform__degree_radian_vv_3 strategy::transform::degree_radian_vv_3]
-]
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/envelope.hpp]
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 ,
+ template< typename > class ``[link boost_geometry.reference.F F]``>
+ struct degree_radian_vv_3
-[*Convenience header: ][^boost/geometry.hpp]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__transform__degree_radian_vv_3.apply [*apply]]]
+ []
+ ]
+
+]
-[endsect]
+[heading Description]
+[heading Requirements]
-[section:make_inverse make_inverse]
+[*Header: ][^boost/geometry/strategies/strategy_transform.hpp]
-[indexterm1 make_inverse]
-Create a box with inverse infinite coordinates.
+[*Convenience header: ][^boost/geometry.hpp]
- template<
- typename Geometry >
- Geometry make_inverse();
+[section:apply strategy::transform::degree_radian_vv_3::apply]
+[indexterm2 apply..strategy::transform::degree_radian_vv_3]
-The make\_inverse function initialize a 2D or 3D box with large coordinates, the min corner is very large, the max corner is very small
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
-[variablelist
-
-[[Geometry][the geometry type ]]
-]
+[endsect]
-[heading Return Value]
-
-the box
+[endsect]
-[heading Requirements]
+[section:strategy__transform__from_cartesian_3_to_spherical_2 strategy::transform::from_cartesian_3_to_spherical_2]
-[*Header: ][^boost/geometry/algorithms/make.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+Transformation [link boost_geometry.reference.strategy `strategy`] for 3D cartesian (x,y,z) to 2D spherical (phi,theta).
-[endsect]
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 >
+ struct from_cartesian_3_to_spherical_2
-[section:make_zero make_zero]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
-[indexterm1 make_zero]
-Create a geometry with "zero" coordinates.
+ [
+ [[link boost_geometry.reference.strategy__transform__from_cartesian_3_to_spherical_2.apply [*apply]]]
+ []
+ ]
+
+]
- template<
- typename Geometry >
- Geometry make_zero();
+[heading Description]
+
+on Unit sphere
-The make\_zero function initializes a 2D or 3D point or box with coordinates of zero
[variablelist
-[[Geometry][the geometry type ]]
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
+
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
]
-[heading Return Value]
+[heading Remarks]
-the geometry
+If x,y,z [link boost_geometry.reference.point `point`] is not lying on unit sphere, transformation will return false
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/make.hpp]
+[*Header: ][^boost/geometry/strategies/strategy_transform.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:apply strategy::transform::from_cartesian_3_to_spherical_2::apply]
+[indexterm2 apply..strategy::transform::from_cartesian_3_to_spherical_2]
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
-[section:max_corner max_corner]
-[indexterm1 max_corner]
-Index of maximum corner of the box.
+[endsect]
- const int max_corner = 1;
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/core/access.hpp]
+[section:strategy__transform__from_cartesian_3_to_spherical_3 strategy::transform::from_cartesian_3_to_spherical_3]
-[*Convenience header: ][^boost/geometry.hpp]
+Transformation [link boost_geometry.reference.strategy `strategy`] for 3D cartesian (x,y,z) to 3D spherical (phi,theta,r).
-[endsect]
-[section:min_corner min_corner]
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 >
+ struct from_cartesian_3_to_spherical_3
-[indexterm1 min_corner]
-Index of minimum corner of the box.
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__transform__from_cartesian_3_to_spherical_3.apply [*apply]]]
+ []
+ ]
+
+]
- const int min_corner = 0;
+[heading Description]
-[heading Requirements]
-[*Header: ][^boost/geometry/core/access.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[variablelist
+
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
-[endsect]
+]
-[section:multiply_point multiply_point]
+[heading Requirements]
-[indexterm1 multiply_point]
-Multiplies a point by another.
+[*Header: ][^boost/geometry/strategies/strategy_transform.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
- template<
- typename Point1 ,
- typename Point2 >
- void multiply_point(
- Point1 & p1,
- Point2 const & p2);
+[section:apply strategy::transform::from_cartesian_3_to_spherical_3::apply]
-The coordinates of the second point will be multiplied by those of the first point. The second point is not modified.
-[heading Parameters]
-
+[indexterm2 apply..strategy::transform::from_cartesian_3_to_spherical_3]
-[variablelist
-
-[[p1][first point ]]
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
-[[p2][second point ]]
-]
+[endsect]
-[heading Remarks]
-
-This is *not* a dot, cross or wedge product. It is a mere field-by-field multiplication.
+[endsect]
-[heading Requirements]
+[section:strategy__transform__from_spherical_2_to_cartesian_3 strategy::transform::from_spherical_2_to_cartesian_3]
-[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+Transformation [link boost_geometry.reference.strategy `strategy`] for 2D spherical (phi,theta) to 3D cartesian (x,y,z).
-[endsect]
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 >
+ struct from_spherical_2_to_cartesian_3
-[section:multiply_value multiply_value]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
-[indexterm1 multiply_value]
-Multiplies each coordinate of a point by a value.
+ [
+ [[link boost_geometry.reference.strategy__transform__from_spherical_2_to_cartesian_3.apply [*apply]]]
+ []
+ ]
+
+]
- template<
- typename Point >
- void multiply_value(
- Point & p,
- typename detail::param< Point >::type value);
+[heading Description]
+on Unit sphere
-[heading Parameters]
-
[variablelist
-[[p][point ]]
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
-[[value][value to multiply by ]]
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
]
@@ -5636,237 +15131,291 @@
[heading Requirements]
-[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+[*Header: ][^boost/geometry/strategies/strategy_transform.hpp]
[*Convenience header: ][^boost/geometry.hpp]
+[section:apply strategy::transform::from_spherical_2_to_cartesian_3::apply]
+
+[indexterm2 apply..strategy::transform::from_spherical_2_to_cartesian_3]
+
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
+
+
+
[endsect]
-[section:num_geometries num_geometries]
+[endsect]
-[indexterm1 num_geometries]
-Function to get the number of geometries of a composite geometry. For a single geometry it is always 0 (also for a polygon with holes).
+[section:strategy__transform__from_spherical_3_to_cartesian_3 strategy::transform::from_spherical_3_to_cartesian_3]
- template<
- typename Geometry >
- std::size_t num_geometries(
- Geometry const & geometry);
+Transformation [link boost_geometry.reference.strategy `strategy`] for 3D spherical (phi,theta,r) to 3D cartesian (x,y,z).
-[variablelist
-
-[[Geometry][geometry type ]]
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 >
+ struct from_spherical_3_to_cartesian_3
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__transform__from_spherical_3_to_cartesian_3.apply [*apply]]]
+ []
+ ]
+
]
-[heading Parameters]
-
+[heading Description]
+
+
[variablelist
-[[geometry][the polygon or other geometry ]]
-
-]
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
-[heading Return Value]
-
-the number of interior rings of the geometry
+]
[heading Requirements]
-[*Header: ][^boost/geometry/core/num_geometries.hpp]
+[*Header: ][^boost/geometry/strategies/strategy_transform.hpp]
[*Convenience header: ][^boost/geometry.hpp]
+[section:apply strategy::transform::from_spherical_3_to_cartesian_3::apply]
+
+[indexterm2 apply..strategy::transform::from_spherical_3_to_cartesian_3]
+
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
+
+
+
[endsect]
-[section:num_interior_rings num_interior_rings]
+[endsect]
-[indexterm1 num_interior_rings]
-Function to get the number of interior rings of a polygon.
+[section:strategy__transform__inverse_transformer strategy::transform::inverse_transformer]
- template<
- typename Geometry >
- std::size_t num_interior_rings(
- Geometry const & geometry);
+Transformation [link boost_geometry.reference.strategy `strategy`] to do an inverse ransformation in Cartesian system.
-[heading Remarks]
-
-Defined by OGC as "numInteriorRing". To be consistent with "numPoints" letter "s" is appended
-Can be used for any geometry, returning 0 for geometries not having interior rings
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 >
+ struct inverse_transformer : public strategy::transform::ublas_transformer< P1, P2, dimension< P1 >::type::value, dimension< P2 >::type::value >
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
-[variablelist
+ [[link boost_geometry.reference.strategy__transform__inverse_transformer.T [*T]]]
+ []
-[[Geometry][geometry type ]]
+ ]
]
-[heading Parameters]
-
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
-[variablelist
+ [
+ [[link boost_geometry.reference.strategy__transform__inverse_transformer.inverse_transformer [*inverse_transformer]]]
+ []
+ ]
-[[geometry][the polygon or other geometry ]]
-
]
-[heading Return Value]
-
-the number of interior rings of the geometry
-
+[heading Description]
-[heading Requirements]
-[*Header: ][^boost/geometry/core/interior_rings.hpp]
+[variablelist
+
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
-[*Convenience header: ][^boost/geometry.hpp]
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
+]
-[endsect]
+[heading Requirements]
-[section:num_points num_points]
+[*Header: ][^boost/geometry/strategies/transform/inverse_transformer.hpp]
-[indexterm1 num_points]
-get number of points
+[*Convenience header: ][^boost/geometry.hpp]
- template<
- typename Geometry >
- std::size_t num_points(
- Geometry const & geometry);
+[section:T strategy::transform::inverse_transformer::T]
+[indexterm2 T..strategy::transform::inverse_transformer]
+ typedef select_coordinate_type< P1, P2 >::type T;
-[variablelist
-
-[[Geometry][geometry type ]]
-]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/transform/inverse_transformer.hpp]
-[heading Parameters]
-
+[*Convenience header: ][^boost/geometry.hpp]
-[variablelist
-
-[[geometry][the geometry to get number of points from ]]
-]
+[endsect]
-[heading Return Value]
-
-number of points
+[section:inverse_transformer strategy::transform::inverse_transformer::inverse_transformer]
-[heading Remarks]
-
-For linestrings/rings also boost::size or .size() could be used, however, for polygons this is less obvious. So this function is provided. Besides that it is described by OGC (numPoints)
+[indexterm2 inverse_transformer..strategy::transform::inverse_transformer]
+ template<
+ typename MatrixType >
+ inverse_transformer(
+ const MatrixType & input);
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/num_points.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:strategy__transform__map_transformer strategy::transform::map_transformer]
-[section:order_selector order_selector]
+Transformation [link boost_geometry.reference.strategy `strategy`] to do map from one to another Cartesian system.
-[indexterm1 order_selector]
- enum order_selector
-[indexterm2 clockwise..order_selector]
-[indexterm2 counterclockwise..order_selector]
-[indexterm2 order_undetermined..order_selector]
-[heading Values]
-[variablelist
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 ,
+ bool ``[link boost_geometry.reference.Mirror Mirror]``,
+ bool ``[link boost_geometry.reference.SameScale SameScale]`` = true,
+ std::size_t ``[link boost_geometry.reference.Dimension1 Dimension1]`` = dimension<P1>::type::value,
+ std::size_t ``[link boost_geometry.reference.Dimension2 Dimension2]`` = dimension<P2>::type::value>
+ struct map_transformer : public strategy::transform::ublas_transformer< P1, P2, Dimension1, Dimension2 >
+
+[heading Public Types]
+[table
+ [[Name][Description]]
[
- [clockwise]
+
+ [[link boost_geometry.reference.strategy__transform__map_transformer.M [*M]]]
[]
+
]
[
- [counterclockwise]
+
+ [[link boost_geometry.reference.strategy__transform__map_transformer.T [*T]]]
[]
+
]
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
[
- [order_undetermined]
+ [[link boost_geometry.reference.strategy__transform__map_transformer.map_transformer [*map_transformer]]]
[]
]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
+
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
+
+[[Mirror][if true map is mirrored upside-down (in most cases pixels are from top to bottom, while map is from bottom to top) ]]
]
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/point_order.hpp]
+[*Header: ][^boost/geometry/strategies/transform/map_transformer.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:M strategy::transform::map_transformer::M]
+[indexterm2 M..strategy::transform::map_transformer]
+ typedef boost::numeric::ublas::matrix< T > M;
-[section:overlaps overlaps]
-[indexterm1 overlaps]
-Determines overlap between two geometries.
+[heading Requirements]
- template<
- typename Geometry1 ,
- typename Geometry2 >
- bool overlaps(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
+[*Header: ][^boost/geometry/strategies/transform/map_transformer.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Return Value]
-
-true if there is overlap
+[endsect]
+
+
+
+[section:T strategy::transform::map_transformer::T]
+
+[indexterm2 T..strategy::transform::map_transformer]
+
+ typedef select_coordinate_type< P1, P2 >::type T;
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/overlaps.hpp]
+[*Header: ][^boost/geometry/strategies/transform/map_transformer.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -5874,226 +15423,234 @@
[endsect]
-[section:parse parse]
+[section:map_transformer strategy::transform::map_transformer::map_transformer]
+
+[indexterm2 map_transformer..strategy::transform::map_transformer]
-[indexterm1 parse]
-
template<
- typename Geometry >
- void ``[link boost_geometry.reference.parse.overload1 parse]``(
- Geometry & geometry,
- std::string const & c1,
- std::string const & c2);
- `` [''''»''' [link boost_geometry.reference.parse.overload1 more...]]``
+ typename B ,
+ typename D >
+ explicit ``[link boost_geometry.reference.strategy__transform__map_transformer.map_transformer.overload1 map_transformer]``(
+ B const & box,
+ D const & width,
+ D const & height);
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__map_transformer.map_transformer.overload1 more...]]``
template<
- typename Geometry ,
- typename S >
- void ``[link boost_geometry.reference.parse.overload2 parse]``(
- Geometry & geometry,
- std::string const & c1,
- std::string const & c2,
- S const & strategy);
- `` [''''»''' [link boost_geometry.reference.parse.overload2 more...]]``
+ typename W ,
+ typename D >
+ explicit ``[link boost_geometry.reference.strategy__transform__map_transformer.map_transformer.overload2 map_transformer]``(
+ W const & wx1,
+ W const & wy1,
+ W const & wx2,
+ W const & wy2,
+ D const & width,
+ D const & height);
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__map_transformer.map_transformer.overload2 more...]]``
+
+
+[section:overload1 strategy::transform::map_transformer::map_transformer (1 of 2 overloads)]
+
+
template<
- typename Geometry >
- Geometry ``[link boost_geometry.reference.parse.overload3 parse]``(
- std::string const & c1,
- std::string const & c2);
- `` [''''»''' [link boost_geometry.reference.parse.overload3 more...]]``
+ typename B ,
+ typename D >
+ map_transformer(
+ B const & box,
+ D const & width,
+ D const & height);
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/parse.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
-[section:overload1 parse (1 of 3 overloads)]
+[section:overload2 strategy::transform::map_transformer::map_transformer (2 of 2 overloads)]
-parse two strings to a spherical/geographic point, using W/E/N/S
template<
- typename Geometry >
- void parse(
- Geometry & geometry,
- std::string const & c1,
- std::string const & c2);
+ typename W ,
+ typename D >
+ map_transformer(
+ W const & wx1,
+ W const & wy1,
+ W const & wx2,
+ W const & wy2,
+ D const & width,
+ D const & height);
+
+[endsect]
+
[endsect]
+[endsect]
-[section:overload2 parse (2 of 3 overloads)]
+[section:strategy__transform__rotate_transformer strategy::transform::rotate_transformer]
-parse two strings to a spherical/geographic point, using a specified strategy
+Strategy of rotate transformation in Cartesian system.
+
+
+[heading Synopsis]
template<
- typename Geometry ,
- typename S >
- void parse(
- Geometry & geometry,
- std::string const & c1,
- std::string const & c2,
- S const & strategy);
+ typename P1 ,
+ typename P2 ,
+ typename DegreeOrRadian >
+ struct rotate_transformer
+[heading Public Types]
+[table
+ [[Name][Description]]
-user can use N/E/S/O or N/O/Z/W or other formats
+ [
+ [[link boost_geometry.reference.strategy__transform__rotate_transformer.angle_type [*angle_type]]]
+ []
+
+ ]
-[endsect]
+]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
-[section:overload3 parse (3 of 3 overloads)]
+ [
+ [[link boost_geometry.reference.strategy__transform__rotate_transformer.rotate_transformer [*rotate_transformer]]]
+ []
+ ]
+
+]
+[heading Description]
- template<
- typename Geometry >
- Geometry parse(
- std::string const & c1,
- std::string const & c2);
+Rotate rotates a [link boost_geometry.reference.boost__geometry `boost::geometry`] of specified angle about a fixed [link boost_geometry.reference.point `point`] (e.g. origin).
+[variablelist
+
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
-[endsect]
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
+[[DegreeOrRadian][degree/or/radian, type of rotation angle specification ]]
-[endsect]
+]
-[section:perimeter perimeter]
-[indexterm1 perimeter]
+[heading Remarks]
- template<
- typename Geometry >
- length_result< Geometry >::type ``[link boost_geometry.reference.perimeter.overload1 perimeter]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.perimeter.overload1 more...]]``
+A single angle is needed to specify a rotation in 2D. Not yet in 3D, the 3D version requires special things to allow for rotation around X, Y, Z or arbitrary axis.
- template<
- typename Geometry ,
- typename Strategy >
- length_result< Geometry >::type ``[link boost_geometry.reference.perimeter.overload2 perimeter]``(
- Geometry const & geometry,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.perimeter.overload2 more...]]``
-[heading Geometries:]
-
+[heading Requirements]
-* polygon
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
-* box
+[*Convenience header: ][^boost/geometry.hpp]
-* linear_ring
-* multi_polygon
+[section:angle_type strategy::transform::rotate_transformer::angle_type]
+[indexterm2 angle_type..strategy::transform::rotate_transformer]
+ typedef select_most_precise< typename select_coordinate_type< P1, P2 >::type, double >::type angle_type;
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/perimeter.hpp]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 perimeter (1 of 2 overloads)]
-
-
-Calculate perimeter of a geometry.
-
+[endsect]
- template<
- typename Geometry >
- length_result< Geometry >::type perimeter(
- Geometry const & geometry);
-The function perimeter returns the perimeter of a geometry, using the default distance-calculation-strategy
-[heading Parameters]
-
+[section:rotate_transformer strategy::transform::rotate_transformer::rotate_transformer]
-[variablelist
-
-[[geometry][the geometry, be it a geometry::ring, vector, iterator pair, or any other boost compatible range ]]
+[indexterm2 rotate_transformer..strategy::transform::rotate_transformer]
-]
+ rotate_transformer(
+ angle_type const & angle);
-[heading Return Value]
-
-the perimeter
+[endsect]
[endsect]
+[section:strategy__transform__scale_transformer strategy::transform::scale_transformer]
-[section:overload2 perimeter (2 of 2 overloads)]
+Strategy of scale transformation in Cartesian system.
-Calculate perimeter of a geometry.
+[heading Synopsis]
template<
- typename Geometry ,
- typename Strategy >
- length_result< Geometry >::type perimeter(
- Geometry const & geometry,
- Strategy const & strategy);
+ typename P1 ,
+ typename P2 = P1,
+ std::size_t ``[link boost_geometry.reference.Dimension1 Dimension1]`` = geometry::dimension<P1>::type::value,
+ std::size_t ``[link boost_geometry.reference.Dimension2 Dimension2]`` = geometry::dimension<P2>::type::value>
+ struct scale_transformer
+[heading Description]
+
+Scale scales a [link boost_geometry.reference.boost__geometry `boost::geometry`] up or down in all its dimensions.
-The function perimeter returns the perimeter of a geometry, using specified strategy
-[heading Parameters]
-
[variablelist
-[[geometry][the geometry, be it a geometry::ring, vector, iterator pair, or any other boost compatible range ]]
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
-[[strategy][strategy to be used for distance calculations. ]]
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
-]
+[[Dimension1][number of dimensions to [link boost_geometry.reference.strategy__transform `strategy::transform`] from first [link boost_geometry.reference.point `point`], optional ]]
+[[Dimension1][number of dimensions to [link boost_geometry.reference.strategy__transform `strategy::transform`] to second [link boost_geometry.reference.point `point`], optional ]]
+
+]
-[heading Return Value]
-
-the perimeter
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
-[endsect]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:point point]
+[section:strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_ strategy::transform::scale_transformer< P1, P2, 2, 2 >]
-Basic point class, having coordinates defined in a neutral way.
+
+[heading Synopsis]
template<
- typename T,
- std::size_t ``[link boost_geometry.reference.D D]``,
- typename ``[link boost_geometry.reference.C C]``>
- class point
+ typename P1 ,
+ typename P2 >
+ struct scale_transformer< P1, P2, 2, 2 > : public strategy::transform::ublas_transformer< P1, P2, 2, 2 >
[heading Public Types]
[table
@@ -6101,117 +15658,84 @@
[
- [[link boost_geometry.reference.point.coordinate_system [*coordinate_system]]]
- []
-
- ]
-
- [
-
- [[link boost_geometry.reference.point.coordinate_type [*coordinate_type]]]
+ [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.coordinate_type [*coordinate_type]]]
[]
]
]
+
[heading Public Member Functions]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.point.get [*get]]]
- [Compile time access to coordinate values. ]
+ [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.apply [*apply]]]
+ []
]
[
- [[link boost_geometry.reference.point.point [*point]]]
- [Default constructor, no initialization at all.
-
- Constructs with one, or optionally two or three values. ]
+ [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.matrix [*matrix]]]
+ []
]
[
- [[link boost_geometry.reference.point.set [*set]]]
+ [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.scale_transformer [*scale_transformer]]]
[]
]
]
-[heading Public Data Members]
+[heading Protected Data Members]
[table
[[Name][Description]]
- [
- [[link boost_geometry.reference.point.coordinate_count [*coordinate_count]]]
- []
- ]
-
-]
-
-
-
-[variablelist
-
-[[T][numeric type, for example double, float, int ]]
-
-[[D][coordinate dimension as number of coordinates, for example 2 ]]
-
-[[C][coordinate system, for example [link boost_geometry.reference.cs__cartesian `cs::cartesian`] ]]
-
-]
-
-
-
-[heading Requirements]
-
-[*Header: ][^boost/geometry/geometries/point.hpp]
-
-[*Convenience header: ][^boost/geometry.hpp]
-
-
-[section:coordinate_count point::coordinate_count]
-
-[indexterm2 coordinate_count..point]
-
- static const std::size_t coordinate_count = D;
+ [
+ [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.m_matrix [*m_matrix]]]
+ []
+ ]
+]
-[endsect]
+[heading Description]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
-[section:coordinate_system point::coordinate_system]
+[*Convenience header: ][^boost/geometry.hpp]
-[indexterm2 coordinate_system..point]
- typedef C coordinate_system;
+[section:apply strategy::transform::scale_transformer< P1, P2, 2, 2 >::apply]
+['Inherited from strategy::transform::ublas_transformer.]
-[heading Requirements]
+[indexterm2 apply..strategy::transform::scale_transformer< P1, P2, 2, 2 >]
-[*Header: ][^boost/geometry/geometries/point.hpp]
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:coordinate_type point::coordinate_type]
+[section:coordinate_type strategy::transform::scale_transformer< P1, P2, 2, 2 >::coordinate_type]
-[indexterm2 coordinate_type..point]
+[indexterm2 coordinate_type..strategy::transform::scale_transformer< P1, P2, 2, 2 >]
- typedef T coordinate_type;
+ typedef select_coordinate_type< P1, P2 >::type coordinate_type;
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/point.hpp]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -6220,99 +15744,93 @@
-[section:get point::get]
-
-[indexterm2 get..point]
-Compile time access to coordinate values.
-
-
- template<
- std::size_t ``[link boost_geometry.reference.K K]``>
- T const & get() const;
-
+[section:m_matrix strategy::transform::scale_transformer< P1, P2, 2, 2 >::m_matrix]
-[endsect]
+['Inherited from strategy::transform::ublas_transformer.]
+[indexterm2 m_matrix..strategy::transform::scale_transformer< P1, P2, 2, 2 >]
-[section:point point::point]
+ matrix_type m_matrix;
-[indexterm2 point..point]
-Default constructor, no initialization at all.
- ``[link boost_geometry.reference.point.point.overload1 point]``();
- `` [''''»''' [link boost_geometry.reference.point.point.overload1 more...]]``
+[endsect]
-Constructs with one, or optionally two or three values.
+[section:matrix strategy::transform::scale_transformer< P1, P2, 2, 2 >::matrix]
- ``[link boost_geometry.reference.point.point.overload2 point]``(
- T const & v0,
- T const & v1 = 0,
- T const & v2 = 0);
- `` [''''»''' [link boost_geometry.reference.point.point.overload2 more...]]``
+['Inherited from strategy::transform::ublas_transformer.]
-[section:overload1 point::point (1 of 2 overloads)]
+[indexterm2 matrix..strategy::transform::scale_transformer< P1, P2, 2, 2 >]
+ matrix_type const & matrix() const;
-Default constructor, no initialization at all.
- point();
+[endsect]
+[section:scale_transformer strategy::transform::scale_transformer< P1, P2, 2, 2 >::scale_transformer]
-[endsect]
+[indexterm2 scale_transformer..strategy::transform::scale_transformer< P1, P2, 2, 2 >]
+ ``[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.scale_transformer.overload1 scale_transformer]``(
+ coordinate_type const & scale_x,
+ coordinate_type const & scale_y,
+ coordinate_type const & dummy = 0);
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.scale_transformer.overload1 more...]]``
+ ``[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.scale_transformer.overload2 scale_transformer]``(
+ coordinate_type const & scale);
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.scale_transformer.overload2 more...]]``
-[section:overload2 point::point (2 of 2 overloads)]
+[section:overload1 strategy::transform::scale_transformer< P1, P2, 2, 2 >::scale_transformer (1 of 2 overloads)]
-Constructs with one, or optionally two or three values.
- point(
- T const & v0,
- T const & v1 = 0,
- T const & v2 = 0);
+ scale_transformer(
+ coordinate_type const & scale_x,
+ coordinate_type const & scale_y,
+ coordinate_type const & dummy = 0);
[endsect]
-[endsect]
+[section:overload2 strategy::transform::scale_transformer< P1, P2, 2, 2 >::scale_transformer (2 of 2 overloads)]
-[section:set point::set]
-[indexterm2 set..point]
- template<
- std::size_t ``[link boost_geometry.reference.K K]``>
- void set(
- T value);
+ scale_transformer(
+ coordinate_type const & scale);
[endsect]
+[endsect]
+
[endsect]
+[section:strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_ strategy::transform::scale_transformer< P1, P2, 3, 3 >]
-[section:point_2d point_2d]
-[indexterm1 point_2d]
- typedef point_xy< double, cs::cartesian > point_2d;
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 >
+ struct scale_transformer< P1, P2, 3, 3 > : public strategy::transform::ublas_transformer< P1, P2, 3, 3 >
[heading Public Types]
[table
@@ -6320,284 +15838,223 @@
[
- [[link boost_geometry.reference.point_xy.coordinate_system [*coordinate_system]]]
- []
-
- ]
-
- [
-
- [[link boost_geometry.reference.point_xy.coordinate_type [*coordinate_type]]]
+ [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.coordinate_type [*coordinate_type]]]
[]
]
]
+
[heading Public Member Functions]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.point_xy.get [*get]]]
- [Compile time access to coordinate values. ]
- ]
-
- [
- [[link boost_geometry.reference.point_xy.point_xy [*point_xy]]]
- [Default constructor, does not initialize anything.
-
- Constructor with x/y values. ]
- ]
-
- [
- [[link boost_geometry.reference.point_xy.set [*set]]]
+ [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.apply [*apply]]]
[]
]
[
- [[link boost_geometry.reference.point_xy.x [*x]]]
- [Get x-value.
-
- Set x-value. ]
+ [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.matrix [*matrix]]]
+ []
]
[
- [[link boost_geometry.reference.point_xy.y [*y]]]
- [Get y-value.
-
- Set y-value. ]
+ [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.scale_transformer [*scale_transformer]]]
+ []
]
]
-[heading Public Data Members]
+[heading Protected Data Members]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.point_xy.coordinate_count [*coordinate_count]]]
+ [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.m_matrix [*m_matrix]]]
[]
]
]
-[heading Typedef Description]
-
+[heading Description]
-[variablelist
-
-[[T][numeric type, arguments can be, for example, double, float, int ]]
+[heading Requirements]
-]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
+[section:apply strategy::transform::scale_transformer< P1, P2, 3, 3 >::apply]
-[heading Requirements]
-[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+['Inherited from strategy::transform::ublas_transformer.]
-[*Convenience header: ][^boost/geometry.hpp]
+[indexterm2 apply..strategy::transform::scale_transformer< P1, P2, 3, 3 >]
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
-[endsect]
+[endsect]
-[section:point_3d point_3d]
-[indexterm1 point_3d]
- typedef point< double, 3, cs::cartesian > point_3d;
+[section:coordinate_type strategy::transform::scale_transformer< P1, P2, 3, 3 >::coordinate_type]
+[indexterm2 coordinate_type..strategy::transform::scale_transformer< P1, P2, 3, 3 >]
+ typedef select_coordinate_type< P1, P2 >::type coordinate_type;
-[heading Public Types]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.point.coordinate_system [*coordinate_system]]]
- []
-
- ]
+[heading Requirements]
- [
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
- [[link boost_geometry.reference.point.coordinate_type [*coordinate_type]]]
- []
-
- ]
+[*Convenience header: ][^boost/geometry.hpp]
-]
-[heading Public Member Functions]
-[table
- [[Name][Description]]
+[endsect]
- [
- [[link boost_geometry.reference.point.get [*get]]]
- [Compile time access to coordinate values. ]
- ]
-
- [
- [[link boost_geometry.reference.point.point [*point]]]
- [Default constructor, no initialization at all.
- Constructs with one, or optionally two or three values. ]
- ]
-
- [
- [[link boost_geometry.reference.point.set [*set]]]
- []
- ]
-
-]
-[heading Public Data Members]
-[table
- [[Name][Description]]
+[section:m_matrix strategy::transform::scale_transformer< P1, P2, 3, 3 >::m_matrix]
- [
- [[link boost_geometry.reference.point.coordinate_count [*coordinate_count]]]
- []
- ]
-]
+['Inherited from strategy::transform::ublas_transformer.]
-[heading Typedef Description]
-
+[indexterm2 m_matrix..strategy::transform::scale_transformer< P1, P2, 3, 3 >]
+ matrix_type m_matrix;
-[variablelist
-
-[[T][numeric type, for example double, float, int ]]
-[[D][coordinate dimension as number of coordinates, for example 2 ]]
-[[C][coordinate system, for example [link boost_geometry.reference.cs__cartesian `cs::cartesian`] ]]
+[endsect]
-]
+[section:matrix strategy::transform::scale_transformer< P1, P2, 3, 3 >::matrix]
-[heading Requirements]
+['Inherited from strategy::transform::ublas_transformer.]
-[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+[indexterm2 matrix..strategy::transform::scale_transformer< P1, P2, 3, 3 >]
-[*Convenience header: ][^boost/geometry.hpp]
+ matrix_type const & matrix() const;
-[endsect]
+[endsect]
-[section:point_order point_order]
+[section:scale_transformer strategy::transform::scale_transformer< P1, P2, 3, 3 >::scale_transformer]
-Meta-function which defines point type of any geometry.
+[indexterm2 scale_transformer..strategy::transform::scale_transformer< P1, P2, 3, 3 >]
+ ``[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.scale_transformer.overload1 scale_transformer]``(
+ coordinate_type const & scale_x,
+ coordinate_type const & scale_y,
+ coordinate_type const & scale_z);
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.scale_transformer.overload1 more...]]``
- template<
- typename Geometry >
- struct point_order
+ ``[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.scale_transformer.overload2 scale_transformer]``(
+ coordinate_type const & scale);
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.scale_transformer.overload2 more...]]``
-[heading Public Types]
-[table
- [[Name][Description]]
- [
+[section:overload1 strategy::transform::scale_transformer< P1, P2, 3, 3 >::scale_transformer (1 of 2 overloads)]
- [[link boost_geometry.reference.point_order.ncg [*ncg]]]
- []
-
- ]
-]
-[heading Public Data Members]
-[table
- [[Name][Description]]
+ scale_transformer(
+ coordinate_type const & scale_x,
+ coordinate_type const & scale_y,
+ coordinate_type const & scale_z);
- [
- [[link boost_geometry.reference.point_order.value [*value]]]
- []
- ]
-]
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/core/point_order.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:overload2 strategy::transform::scale_transformer< P1, P2, 3, 3 >::scale_transformer (2 of 2 overloads)]
-[section:ncg point_order::ncg]
-[indexterm2 ncg..point_order]
- typedef boost::remove_const< Geometry >::type ncg;
+ scale_transformer(
+ coordinate_type const & scale);
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/core/point_order.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
[endsect]
+[section:strategy__transform__translate_transformer strategy::transform::translate_transformer]
-[section:value point_order::value]
+Strategy of translate transformation in Cartesian system.
-[indexterm2 value..point_order]
- static const order_selector value = core_dispatch::point_order
- <
- typename tag<Geometry>::type,
- ncg
- >::value;
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 ,
+ std::size_t ``[link boost_geometry.reference.Dimension1 Dimension1]`` = geometry::dimension<P1>::type::value,
+ std::size_t ``[link boost_geometry.reference.Dimension2 Dimension2]`` = geometry::dimension<P2>::type::value>
+ struct translate_transformer
-[endsect]
+[heading Description]
+Translate moves a [link boost_geometry.reference.boost__geometry `boost::geometry`] a fixed [link boost_geometry.reference.strategy__distance `strategy::distance`] in 2 or 3 dimensions.
-[endsect]
+[variablelist
+
+[[P1][first [link boost_geometry.reference.point `point`] type ]]
-[section:point_tag point_tag]
+[[P2][second [link boost_geometry.reference.point `point`] type ]]
+
+[[Dimension1][number of dimensions to [link boost_geometry.reference.strategy__transform `strategy::transform`] from first [link boost_geometry.reference.point `point`], optional ]]
+[[Dimension1][number of dimensions to [link boost_geometry.reference.strategy__transform `strategy::transform`] to second [link boost_geometry.reference.point `point`], optional ]]
+
+]
-OGC Point identifying tag.
- struct point_tag
[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:point_type point_type]
+[section:strategy__transform__translate_transformer_lt__P1,_P2,_2,_2__gt_ strategy::transform::translate_transformer< P1, P2, 2, 2 >]
+
-Meta-function which defines point type of any geometry.
+[heading Synopsis]
template<
- typename Geometry >
- struct point_type
+ typename P1 ,
+ typename P2 >
+ struct translate_transformer< P1, P2, 2, 2 > : public strategy::transform::ublas_transformer< P1, P2, 2, 2 >
[heading Public Types]
[table
@@ -6605,38 +16062,84 @@
[
- [[link boost_geometry.reference.point_type.ncg [*ncg]]]
+ [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_2,_2__gt_.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_2,_2__gt_.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_2,_2__gt_.matrix [*matrix]]]
[]
+ ]
+ [
+ [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_2,_2__gt_.translate_transformer [*translate_transformer]]]
+ []
]
+
+]
- [
+[heading Protected Data Members]
+[table
+ [[Name][Description]]
- [[link boost_geometry.reference.point_type.type [*type]]]
+ [
+ [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_2,_2__gt_.m_matrix [*m_matrix]]]
[]
-
]
]
+
+[heading Description]
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/point_type.hpp]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:ncg point_type::ncg]
+[section:apply strategy::transform::translate_transformer< P1, P2, 2, 2 >::apply]
-[indexterm2 ncg..point_type]
- typedef boost::remove_const< Geometry >::type ncg;
+['Inherited from strategy::transform::ublas_transformer.]
+
+[indexterm2 apply..strategy::transform::translate_transformer< P1, P2, 2, 2 >]
+
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
+
+
+
+[endsect]
+
+
+
+[section:coordinate_type strategy::transform::translate_transformer< P1, P2, 2, 2 >::coordinate_type]
+
+[indexterm2 coordinate_type..strategy::transform::translate_transformer< P1, P2, 2, 2 >]
+
+ typedef select_coordinate_type< P1, P2 >::type coordinate_type;
[heading Requirements]
-[*Header: ][^boost/geometry/core/point_type.hpp]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -6645,45 +16148,45 @@
-[section:type point_type::type]
+[section:m_matrix strategy::transform::translate_transformer< P1, P2, 2, 2 >::m_matrix]
-[indexterm2 type..point_type]
- typedef core_dispatch::point_type< typename tag< Geometry >::type, ncg >::type type;
+['Inherited from strategy::transform::ublas_transformer.]
+[indexterm2 m_matrix..strategy::transform::translate_transformer< P1, P2, 2, 2 >]
+ matrix_type m_matrix;
-[heading Public Types]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.tag.type [*type]]]
- []
-
- ]
+[endsect]
-]
-[heading Typedef Description]
-
-All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
-[variablelist
-
-[[Geometry][geometry ]]
+[section:matrix strategy::transform::translate_transformer< P1, P2, 2, 2 >::matrix]
-]
+['Inherited from strategy::transform::ublas_transformer.]
+[indexterm2 matrix..strategy::transform::translate_transformer< P1, P2, 2, 2 >]
+ matrix_type const & matrix() const;
-[heading Requirements]
-[*Header: ][^boost/geometry/core/point_type.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
+
+
+
+[section:translate_transformer strategy::transform::translate_transformer< P1, P2, 2, 2 >::translate_transformer]
+
+[indexterm2 translate_transformer..strategy::transform::translate_transformer< P1, P2, 2, 2 >]
+
+ translate_transformer(
+ coordinate_type const & translate_x,
+ coordinate_type const & translate_y,
+ coordinate_type const & dummy = 0);
+
[endsect]
@@ -6692,16 +16195,17 @@
[endsect]
-[section:point_xy point_xy]
+[section:strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_ strategy::transform::translate_transformer< P1, P2, 3, 3 >]
-2D point in Cartesian coordinate system
+
+[heading Synopsis]
template<
- typename T ,
- typename C = cs::cartesian>
- class point_xy : public point< T, 2, C >
+ typename P1 ,
+ typename P2 >
+ struct translate_transformer< P1, P2, 3, 3 > : public strategy::transform::ublas_transformer< P1, P2, 3, 3 >
[heading Public Types]
[table
@@ -6709,93 +16213,66 @@
[
- [[link boost_geometry.reference.point_xy.coordinate_system [*coordinate_system]]]
- []
-
- ]
-
- [
-
- [[link boost_geometry.reference.point_xy.coordinate_type [*coordinate_type]]]
+ [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_.coordinate_type [*coordinate_type]]]
[]
]
]
+
[heading Public Member Functions]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.point_xy.get [*get]]]
- [Compile time access to coordinate values. ]
- ]
-
- [
- [[link boost_geometry.reference.point_xy.point_xy [*point_xy]]]
- [Default constructor, does not initialize anything.
-
- Constructor with x/y values. ]
- ]
-
- [
- [[link boost_geometry.reference.point_xy.set [*set]]]
+ [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_.apply [*apply]]]
[]
]
[
- [[link boost_geometry.reference.point_xy.x [*x]]]
- [Get x-value.
-
- Set x-value. ]
+ [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_.matrix [*matrix]]]
+ []
]
[
- [[link boost_geometry.reference.point_xy.y [*y]]]
- [Get y-value.
-
- Set y-value. ]
+ [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_.translate_transformer [*translate_transformer]]]
+ []
]
]
-[heading Public Data Members]
+[heading Protected Data Members]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.point_xy.coordinate_count [*coordinate_count]]]
+ [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_.m_matrix [*m_matrix]]]
[]
]
]
-
-[variablelist
-
-[[T][numeric type, arguments can be, for example, double, float, int ]]
-
-]
-
-
+[heading Description]
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/point_xy.hpp]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:coordinate_count point_xy::coordinate_count]
+[section:apply strategy::transform::translate_transformer< P1, P2, 3, 3 >::apply]
-['Inherited from point.]
+['Inherited from strategy::transform::ublas_transformer.]
-[indexterm2 coordinate_count..point_xy]
+[indexterm2 apply..strategy::transform::translate_transformer< P1, P2, 3, 3 >]
- static const std::size_t coordinate_count;
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
@@ -6803,20 +16280,17 @@
-[section:coordinate_system point_xy::coordinate_system]
-
-
-['Inherited from point.]
+[section:coordinate_type strategy::transform::translate_transformer< P1, P2, 3, 3 >::coordinate_type]
-[indexterm2 coordinate_system..point_xy]
+[indexterm2 coordinate_type..strategy::transform::translate_transformer< P1, P2, 3, 3 >]
- typedef C coordinate_system;
+ typedef select_coordinate_type< P1, P2 >::type coordinate_type;
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/point_xy.hpp]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -6825,198 +16299,251 @@
-[section:coordinate_type point_xy::coordinate_type]
+[section:m_matrix strategy::transform::translate_transformer< P1, P2, 3, 3 >::m_matrix]
-['Inherited from point.]
+['Inherited from strategy::transform::ublas_transformer.]
-[indexterm2 coordinate_type..point_xy]
+[indexterm2 m_matrix..strategy::transform::translate_transformer< P1, P2, 3, 3 >]
- typedef T coordinate_type;
+ matrix_type m_matrix;
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/geometries/point_xy.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:matrix strategy::transform::translate_transformer< P1, P2, 3, 3 >::matrix]
-[endsect]
+['Inherited from strategy::transform::ublas_transformer.]
+[indexterm2 matrix..strategy::transform::translate_transformer< P1, P2, 3, 3 >]
-[section:get point_xy::get]
+ matrix_type const & matrix() const;
-['Inherited from point.]
-[indexterm2 get..point_xy]
-Compile time access to coordinate values.
+[endsect]
- T const & get() const;
+[section:translate_transformer strategy::transform::translate_transformer< P1, P2, 3, 3 >::translate_transformer]
+[indexterm2 translate_transformer..strategy::transform::translate_transformer< P1, P2, 3, 3 >]
-[endsect]
+ translate_transformer(
+ coordinate_type const & translate_x,
+ coordinate_type const & translate_y,
+ coordinate_type const & translate_z);
-[section:point_xy point_xy::point_xy]
-[indexterm2 point_xy..point_xy]
-Default constructor, does not initialize anything.
+[endsect]
- ``[link boost_geometry.reference.point_xy.point_xy.overload1 point_xy]``();
- `` [''''»''' [link boost_geometry.reference.point_xy.point_xy.overload1 more...]]``
+[endsect]
-Constructor with x/y values.
+[section:strategy__transform__ublas_transformer strategy::transform::ublas_transformer]
- ``[link boost_geometry.reference.point_xy.point_xy.overload2 point_xy]``(
- T const & x,
- T const & y);
- `` [''''»''' [link boost_geometry.reference.point_xy.point_xy.overload2 more...]]``
+Affine transformation [link boost_geometry.reference.strategy `strategy`] in Cartesian system.
-[section:overload1 point_xy::point_xy (1 of 2 overloads)]
-Default constructor, does not initialize anything.
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 ,
+ std::size_t ``[link boost_geometry.reference.Dimension1 Dimension1]``,
+ std::size_t ``[link boost_geometry.reference.Dimension2 Dimension2]``>
+ class ublas_transformer
+[heading Description]
- point_xy();
+The [link boost_geometry.reference.strategy `strategy`] serves as a generic definition of affine transformation matrix and procedure of application it to given [link boost_geometry.reference.point `point`].
+[variablelist
+
+[[P1][first [link boost_geometry.reference.point `point`] type (source) ]]
-[endsect]
+[[P2][second [link boost_geometry.reference.point `point`] type (target) ]]
+[[Dimension1][number of dimensions to [link boost_geometry.reference.strategy__transform `strategy::transform`] from first [link boost_geometry.reference.point `point`], optional ]]
+[[Dimension1][number of dimensions to [link boost_geometry.reference.strategy__transform `strategy::transform`] to second [link boost_geometry.reference.point `point`], optional ]]
-[section:overload2 point_xy::point_xy (2 of 2 overloads)]
+]
-Constructor with x/y values.
+[heading Requirements]
- point_xy(
- T const & x,
- T const & y);
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_ strategy::transform::ublas_transformer< P1, P2, 2, 2 >]
-[endsect]
-[section:set point_xy::set]
-['Inherited from point.]
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 >
+ class ublas_transformer< P1, P2, 2, 2 >
-[indexterm2 set..point_xy]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
- void set(
- T value);
+ [
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_.matrix [*matrix]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_.ublas_transformer [*ublas_transformer]]]
+ []
+ ]
+
+]
+[heading Protected Data Members]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_.m_matrix [*m_matrix]]]
+ []
+ ]
-[endsect]
+]
-[section:x point_xy::x]
+[heading Description]
-[indexterm2 x..point_xy]
-Get x-value.
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
- T const & ``[link boost_geometry.reference.point_xy.x.overload1 x]``() const;
- `` [''''»''' [link boost_geometry.reference.point_xy.x.overload1 more...]]``
+[*Convenience header: ][^boost/geometry.hpp]
-Set x-value.
+[section:apply strategy::transform::ublas_transformer< P1, P2, 2, 2 >::apply]
+[indexterm2 apply..strategy::transform::ublas_transformer< P1, P2, 2, 2 >]
- void ``[link boost_geometry.reference.point_xy.x.overload2 x]``(
- T const & v);
- `` [''''»''' [link boost_geometry.reference.point_xy.x.overload2 more...]]``
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
-[section:overload1 point_xy::x (1 of 2 overloads)]
+[endsect]
-Get x-value.
- T const & x() const;
+[section:m_matrix strategy::transform::ublas_transformer< P1, P2, 2, 2 >::m_matrix]
+[indexterm2 m_matrix..strategy::transform::ublas_transformer< P1, P2, 2, 2 >]
+ matrix_type m_matrix;
-[endsect]
+[endsect]
-[section:overload2 point_xy::x (2 of 2 overloads)]
-Set x-value.
+[section:matrix strategy::transform::ublas_transformer< P1, P2, 2, 2 >::matrix]
+[indexterm2 matrix..strategy::transform::ublas_transformer< P1, P2, 2, 2 >]
- void x(
- T const & v);
+ matrix_type const & matrix() const;
[endsect]
-[endsect]
+[section:ublas_transformer strategy::transform::ublas_transformer< P1, P2, 2, 2 >::ublas_transformer]
-[section:y point_xy::y]
+[indexterm2 ublas_transformer..strategy::transform::ublas_transformer< P1, P2, 2, 2 >]
-[indexterm2 y..point_xy]
-Get y-value.
+ ``[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_.ublas_transformer.overload1 ublas_transformer]``(
+ ct const & m_0_0,
+ ct const & m_0_1,
+ ct const & m_0_2,
+ ct const & m_1_0,
+ ct const & m_1_1,
+ ct const & m_1_2,
+ ct const & m_2_0,
+ ct const & m_2_1,
+ ct const & m_2_2);
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_.ublas_transformer.overload1 more...]]``
+ ``[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_.ublas_transformer.overload2 ublas_transformer]``(
+ matrix_type const & matrix);
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_.ublas_transformer.overload2 more...]]``
- T const & ``[link boost_geometry.reference.point_xy.y.overload1 y]``() const;
- `` [''''»''' [link boost_geometry.reference.point_xy.y.overload1 more...]]``
+ ``[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_.ublas_transformer.overload3 ublas_transformer]``();
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_2,_2__gt_.ublas_transformer.overload3 more...]]``
-Set y-value.
+[section:overload1 strategy::transform::ublas_transformer< P1, P2, 2, 2 >::ublas_transformer (1 of 3 overloads)]
- void ``[link boost_geometry.reference.point_xy.y.overload2 y]``(
- T const & v);
- `` [''''»''' [link boost_geometry.reference.point_xy.y.overload2 more...]]``
+ ublas_transformer(
+ ct const & m_0_0,
+ ct const & m_0_1,
+ ct const & m_0_2,
+ ct const & m_1_0,
+ ct const & m_1_1,
+ ct const & m_1_2,
+ ct const & m_2_0,
+ ct const & m_2_1,
+ ct const & m_2_2);
-[section:overload1 point_xy::y (1 of 2 overloads)]
-Get y-value.
+[endsect]
- T const & y() const;
+[section:overload2 strategy::transform::ublas_transformer< P1, P2, 2, 2 >::ublas_transformer (2 of 3 overloads)]
-[endsect]
+ ublas_transformer(
+ matrix_type const & matrix);
-[section:overload2 point_xy::y (2 of 2 overloads)]
+[endsect]
-Set y-value.
- void y(
- T const & v);
+[section:overload3 strategy::transform::ublas_transformer< P1, P2, 2, 2 >::ublas_transformer (3 of 3 overloads)]
+
+
+
+ ublas_transformer();
@@ -7028,20 +16555,17 @@
[endsect]
-[section:polygon polygon]
+[section:strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_ strategy::transform::ublas_transformer< P1, P2, 3, 2 >]
+
-The polygon contains an outer ring and zero or more inner rings.
+[heading Synopsis]
template<
- typename Point ,
- template< typename, typename > class ``[link boost_geometry.reference.PointList PointList]`` = std::vector,
- template< typename, typename > class ``[link boost_geometry.reference.RingList RingList]`` = std::vector,
- bool ``[link boost_geometry.reference.ClockWise ClockWise]`` = true,
- template< typename > class ``[link boost_geometry.reference.PointAlloc PointAlloc]`` = std::allocator,
- template< typename > class ``[link boost_geometry.reference.RingAlloc RingAlloc]`` = std::allocator>
- class polygon
+ typename P1 ,
+ typename P2 >
+ struct ublas_transformer< P1, P2, 3, 2 > : public strategy::transform::ublas_transformer< P1, P2, 2, 2 >
[heading Public Types]
[table
@@ -7049,121 +16573,133 @@
[
- [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
- []
-
- ]
-
- [
-
- [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.coordinate_type [*coordinate_type]]]
[]
]
[
- [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.ct [*ct]]]
[]
]
]
+
[heading Public Member Functions]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.polygon.clear [*clear]]]
- [Utility method, clears outer and inner rings. ]
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.apply [*apply]]]
+ []
]
[
- [[link boost_geometry.reference.polygon.inners [*inners]]]
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.matrix [*matrix]]]
[]
]
[
- [[link boost_geometry.reference.polygon.outer [*outer]]]
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.ublas_transformer [*ublas_transformer]]]
[]
]
]
+[heading Protected Data Members]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.m_matrix [*m_matrix]]]
+ []
+ ]
-[variablelist
-
-[[P][point type ]]
+]
-[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
-[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+[heading Description]
-[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
+[heading Requirements]
-[[PointAlloc][container-allocator-type ]]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
-[[RingAlloc][container-allocator-type ]]
+[*Convenience header: ][^boost/geometry.hpp]
-]
+[section:apply strategy::transform::ublas_transformer< P1, P2, 3, 2 >::apply]
-[heading Remarks]
-
-The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+['Inherited from strategy::transform::ublas_transformer.]
+[indexterm2 apply..strategy::transform::ublas_transformer< P1, P2, 3, 2 >]
-[heading Requirements]
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
-[*Header: ][^boost/geometry/geometries/polygon.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
-[section:clear polygon::clear]
-[indexterm2 clear..polygon]
-Utility method, clears outer and inner rings.
+[section:coordinate_type strategy::transform::ublas_transformer< P1, P2, 3, 2 >::coordinate_type]
- void clear();
+[indexterm2 coordinate_type..strategy::transform::ublas_transformer< P1, P2, 3, 2 >]
+
+ typedef select_coordinate_type< P1, P2 >::type coordinate_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:inner_container_type polygon::inner_container_type]
+[section:ct strategy::transform::ublas_transformer< P1, P2, 3, 2 >::ct]
-[indexterm2 inner_container_type..polygon]
+[indexterm2 ct..strategy::transform::ublas_transformer< P1, P2, 3, 2 >]
- typedef RingList< ring_type, RingAlloc< ring_type > > inner_container_type;
+ typedef coordinate_type ct;
-[heading Typedef Description]
-
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
-[variablelist
+ [[link boost_geometry.reference.coordinate_type.ncg [*ncg]]]
+ []
-[[P][point type ]]
+ ]
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
+ [
-[[A][optional container-allocator-type ]]
+ [[link boost_geometry.reference.coordinate_type.type [*type]]]
+ []
+
+ ]
]
-
-
+[heading Typedef Description]
+
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/polygon.hpp]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -7171,22 +16707,15 @@
[endsect]
-[section:inners polygon::inners]
-
-[indexterm2 inners..polygon]
-
- inner_container_type const & ``[link boost_geometry.reference.polygon.inners.overload1 inners]``() const;
- `` [''''»''' [link boost_geometry.reference.polygon.inners.overload1 more...]]``
-
- inner_container_type & ``[link boost_geometry.reference.polygon.inners.overload2 inners]``();
- `` [''''»''' [link boost_geometry.reference.polygon.inners.overload2 more...]]``
+[section:m_matrix strategy::transform::ublas_transformer< P1, P2, 3, 2 >::m_matrix]
-[section:overload1 polygon::inners (1 of 2 overloads)]
+['Inherited from strategy::transform::ublas_transformer.]
+[indexterm2 m_matrix..strategy::transform::ublas_transformer< P1, P2, 3, 2 >]
- inner_container_type const & inners() const;
+ matrix_type m_matrix;
@@ -7194,35 +16723,54 @@
-[section:overload2 polygon::inners (2 of 2 overloads)]
-
+[section:matrix strategy::transform::ublas_transformer< P1, P2, 3, 2 >::matrix]
- inner_container_type & inners();
+['Inherited from strategy::transform::ublas_transformer.]
+[indexterm2 matrix..strategy::transform::ublas_transformer< P1, P2, 3, 2 >]
+ matrix_type const & matrix() const;
-[endsect]
[endsect]
-[section:outer polygon::outer]
-[indexterm2 outer..polygon]
+[section:ublas_transformer strategy::transform::ublas_transformer< P1, P2, 3, 2 >::ublas_transformer]
- ring_type const & ``[link boost_geometry.reference.polygon.outer.overload1 outer]``() const;
- `` [''''»''' [link boost_geometry.reference.polygon.outer.overload1 more...]]``
+[indexterm2 ublas_transformer..strategy::transform::ublas_transformer< P1, P2, 3, 2 >]
- ring_type & ``[link boost_geometry.reference.polygon.outer.overload2 outer]``();
- `` [''''»''' [link boost_geometry.reference.polygon.outer.overload2 more...]]``
+ ``[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.ublas_transformer.overload1 ublas_transformer]``(
+ ct const & m_0_0,
+ ct const & m_0_1,
+ ct const & m_0_2,
+ ct const & m_1_0,
+ ct const & m_1_1,
+ ct const & m_1_2,
+ ct const & m_2_0,
+ ct const & m_2_1,
+ ct const & m_2_2);
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.ublas_transformer.overload1 more...]]``
+ ``[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.ublas_transformer.overload2 ublas_transformer]``();
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.ublas_transformer.overload2 more...]]``
-[section:overload1 polygon::outer (1 of 2 overloads)]
+[section:overload1 strategy::transform::ublas_transformer< P1, P2, 3, 2 >::ublas_transformer (1 of 2 overloads)]
- ring_type const & outer() const;
+
+ ublas_transformer(
+ ct const & m_0_0,
+ ct const & m_0_1,
+ ct const & m_0_2,
+ ct const & m_1_0,
+ ct const & m_1_1,
+ ct const & m_1_2,
+ ct const & m_2_0,
+ ct const & m_2_1,
+ ct const & m_2_2);
@@ -7230,11 +16778,11 @@
-[section:overload2 polygon::outer (2 of 2 overloads)]
+[section:overload2 strategy::transform::ublas_transformer< P1, P2, 3, 2 >::ublas_transformer (2 of 2 overloads)]
- ring_type & outer();
+ ublas_transformer();
@@ -7244,165 +16792,191 @@
[endsect]
-[section:point_type polygon::point_type]
+[endsect]
-[indexterm2 point_type..polygon]
+[section:strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_ strategy::transform::ublas_transformer< P1, P2, 3, 3 >]
- typedef Point point_type;
-[heading Requirements]
-[*Header: ][^boost/geometry/geometries/polygon.hpp]
+[heading Synopsis]
+ template<
+ typename P1 ,
+ typename P2 >
+ class ublas_transformer< P1, P2, 3, 3 >
-[*Convenience header: ][^boost/geometry.hpp]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_.matrix [*matrix]]]
+ []
+ ]
+
+]
-[endsect]
+[heading Protected Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_.ublas_transformer [*ublas_transformer]]]
+ []
+ ]
+
+]
-[section:ring_type polygon::ring_type]
+[heading Protected Data Members]
+[table
+ [[Name][Description]]
-[indexterm2 ring_type..polygon]
+ [
+ [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_.m_matrix [*m_matrix]]]
+ []
+ ]
- typedef linear_ring< Point, PointList, ClockWise, PointAlloc > ring_type;
+]
-[heading Typedef Description]
-
+[heading Description]
+[heading Requirements]
-[variablelist
-
-[[P][point type ]]
+[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
+[*Convenience header: ][^boost/geometry.hpp]
-[[A][optional container-allocator-type ]]
-]
+[section:apply strategy::transform::ublas_transformer< P1, P2, 3, 3 >::apply]
+[indexterm2 apply..strategy::transform::ublas_transformer< P1, P2, 3, 3 >]
+ bool apply(
+ P1 const & p1,
+ P2 & p2) const;
-[heading Requirements]
-[*Header: ][^boost/geometry/geometries/polygon.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:m_matrix strategy::transform::ublas_transformer< P1, P2, 3, 3 >::m_matrix]
+[indexterm2 m_matrix..strategy::transform::ublas_transformer< P1, P2, 3, 3 >]
+ matrix_type m_matrix;
-[endsect]
-[section:polygon_2d polygon_2d]
+[endsect]
-[indexterm1 polygon_2d]
- typedef polygon< point_2d > polygon_2d;
+[section:matrix strategy::transform::ublas_transformer< P1, P2, 3, 3 >::matrix]
+[indexterm2 matrix..strategy::transform::ublas_transformer< P1, P2, 3, 3 >]
-[heading Public Types]
-[table
- [[Name][Description]]
+ matrix_type const & matrix() const;
- [
- [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
- []
-
- ]
- [
+[endsect]
- [[link boost_geometry.reference.polygon.point_type [*point_type]]]
- []
-
- ]
- [
+[section:ublas_transformer strategy::transform::ublas_transformer< P1, P2, 3, 3 >::ublas_transformer]
- [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
- []
-
- ]
+[indexterm2 ublas_transformer..strategy::transform::ublas_transformer< P1, P2, 3, 3 >]
-]
+ ``[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_.ublas_transformer.overload1 ublas_transformer]``(
+ ct const & m_0_0,
+ ct const & m_0_1,
+ ct const & m_0_2,
+ ct const & m_0_3,
+ ct const & m_1_0,
+ ct const & m_1_1,
+ ct const & m_1_2,
+ ct const & m_1_3,
+ ct const & m_2_0,
+ ct const & m_2_1,
+ ct const & m_2_2,
+ ct const & m_2_3,
+ ct const & m_3_0,
+ ct const & m_3_1,
+ ct const & m_3_2,
+ ct const & m_3_3);
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_.ublas_transformer.overload1 more...]]``
-[heading Public Member Functions]
-[table
- [[Name][Description]]
+ ``[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_.ublas_transformer.overload2 ublas_transformer]``();
+ `` [''''»''' [link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_.ublas_transformer.overload2 more...]]``
- [
- [[link boost_geometry.reference.polygon.clear [*clear]]]
- [Utility method, clears outer and inner rings. ]
- ]
-
- [
- [[link boost_geometry.reference.polygon.inners [*inners]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.polygon.outer [*outer]]]
- []
- ]
-
-]
-[heading Typedef Description]
-
+[section:overload1 strategy::transform::ublas_transformer< P1, P2, 3, 3 >::ublas_transformer (1 of 2 overloads)]
-[variablelist
-
-[[P][point type ]]
-[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+ ublas_transformer(
+ ct const & m_0_0,
+ ct const & m_0_1,
+ ct const & m_0_2,
+ ct const & m_0_3,
+ ct const & m_1_0,
+ ct const & m_1_1,
+ ct const & m_1_2,
+ ct const & m_1_3,
+ ct const & m_2_0,
+ ct const & m_2_1,
+ ct const & m_2_2,
+ ct const & m_2_3,
+ ct const & m_3_0,
+ ct const & m_3_1,
+ ct const & m_3_2,
+ ct const & m_3_3);
-[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
-[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
-[[PointAlloc][container-allocator-type ]]
+[endsect]
-[[RingAlloc][container-allocator-type ]]
-]
+[section:overload2 strategy::transform::ublas_transformer< P1, P2, 3, 3 >::ublas_transformer (2 of 2 overloads)]
-[heading Remarks]
-
-The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+ ublas_transformer();
-[heading Requirements]
-[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
+
+[endsect]
[endsect]
+[section:strategy__within__crossings_multiply strategy::within::crossings_multiply]
-[section:polygon_3d polygon_3d]
+Within detection using cross counting,.
-[indexterm1 polygon_3d]
- typedef polygon< point_3d > polygon_3d;
+[heading Synopsis]
+ template<
+ typename Point ,
+ typename PointOfSegment = Point,
+ typename CalculationType = void>
+ class crossings_multiply
[heading Public Types]
[table
@@ -7410,79 +16984,89 @@
[
- [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
+ [[link boost_geometry.reference.strategy__within__crossings_multiply.point_type [*point_type]]]
[]
]
[
- [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+ [[link boost_geometry.reference.strategy__within__crossings_multiply.segment_point_type [*segment_point_type]]]
[]
]
[
- [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ [[link boost_geometry.reference.strategy__within__crossings_multiply.state_type [*state_type]]]
[]
]
]
+
[heading Public Member Functions]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.polygon.clear [*clear]]]
- [Utility method, clears outer and inner rings. ]
- ]
-
- [
- [[link boost_geometry.reference.polygon.inners [*inners]]]
+ [[link boost_geometry.reference.strategy__within__crossings_multiply.apply [*apply]]]
[]
]
[
- [[link boost_geometry.reference.polygon.outer [*outer]]]
+ [[link boost_geometry.reference.strategy__within__crossings_multiply.result [*result]]]
[]
]
]
-[heading Typedef Description]
-
+[heading Description]
-[variablelist
-
-[[P][point type ]]
-[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
-[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+[heading Remarks]
+
+Does NOT work correctly for [link boost_geometry.reference.point `point`] ON border
-[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
-[[PointAlloc][container-allocator-type ]]
-[[RingAlloc][container-allocator-type ]]
+[heading Requirements]
-]
+[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Remarks]
-
-The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+[section:apply strategy::within::crossings_multiply::apply]
+
+[indexterm2 apply..strategy::within::crossings_multiply]
+
+ static bool apply(
+ Point const & point,
+ PointOfSegment const & seg1,
+ PointOfSegment const & seg2,
+ flags & state);
+
+
+
+[endsect]
+
+
+
+[section:point_type strategy::within::crossings_multiply::point_type]
+
+[indexterm2 point_type..strategy::within::crossings_multiply]
+
+ typedef Point point_type;
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -7490,49 +17074,64 @@
[endsect]
-[section:polygon_tag polygon_tag]
+[section:result strategy::within::crossings_multiply::result]
-OGC Polygon identifying tag.
+[indexterm2 result..strategy::within::crossings_multiply]
+ static bool result(
+ flags const & state);
- struct polygon_tag
-[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
-[endsect]
-[section:radian radian]
+[section:segment_point_type strategy::within::crossings_multiply::segment_point_type]
+[indexterm2 segment_point_type..strategy::within::crossings_multiply]
+
+ typedef PointOfSegment segment_point_type;
-Unit of plane angle: Radians.
- class radian
[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
+[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:replace_point_type replace_point_type]
+[section:state_type strategy::within::crossings_multiply::state_type]
+
+[indexterm2 state_type..strategy::within::crossings_multiply]
+
+ typedef flags state_type;
+
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.strategy__within__crossings_multiply__flags.flags [*flags]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
- template<
- typename Geometry ,
- typename NewPointType >
- struct replace_point_type
[heading Requirements]
-[*Header: ][^boost/geometry/core/replace_point_type.hpp]
+[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -7540,223 +17139,235 @@
[endsect]
-[section:reverse reverse]
-
-[indexterm1 reverse]
- template<
- typename Geometry >
- void reverse(
- Geometry & geometry);
+[endsect]
+[section:strategy__within__crossings_multiply__flags strategy::within::crossings_multiply::flags]
-[variablelist
-
-[[Geometry][geometry type ]]
-]
+[heading Synopsis]
+ class flags
-[heading Parameters]
-
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
-[variablelist
+ [
+ [[link boost_geometry.reference.strategy__within__crossings_multiply__flags.flags [*flags]]]
+ []
+ ]
-[[geometry][the geometry to make reverse ]]
-
]
+[heading Description]
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/reverse.hpp]
+[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
-
+[section:flags strategy::within::crossings_multiply::flags::flags]
-[section:reverse_dispatch reverse_dispatch]
+[indexterm2 flags..strategy::within::crossings_multiply::flags]
+ flags();
- template<
- typename Geometry1 ,
- typename Geometry2 >
- struct reverse_dispatch
-[heading Requirements]
-[*Header: ][^boost/geometry/core/reverse_dispatch.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:strategy__within__franklin strategy::within::franklin]
-[section:ring_2d ring_2d]
-[indexterm1 ring_2d]
+Within detection using cross counting.
- typedef linear_ring< point_2d > ring_2d;
-[heading Typedef Description]
-
+[heading Synopsis]
+ template<
+ typename Point ,
+ typename PointOfSegment = Point,
+ typename CalculationType = void>
+ class franklin
-[variablelist
-
-[[P][point type ]]
+[heading Public Types]
+[table
+ [[Name][Description]]
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
+ [
-[[A][optional container-allocator-type ]]
+ [[link boost_geometry.reference.strategy__within__franklin.point_type [*point_type]]]
+ []
+
+ ]
-]
+ [
+ [[link boost_geometry.reference.strategy__within__franklin.segment_point_type [*segment_point_type]]]
+ []
+
+ ]
+ [
+ [[link boost_geometry.reference.strategy__within__franklin.state_type [*state_type]]]
+ []
+
+ ]
-[heading Requirements]
+]
-[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__within__franklin.apply [*apply]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__within__franklin.result [*result]]]
+ []
+ ]
+
+]
-[endsect]
+[heading Description]
-[section:ring_3d ring_3d]
+adapted from Randolph Franklin algorithm
-[indexterm1 ring_3d]
+Barend and Maarten, 1995
- typedef linear_ring< point_3d > ring_3d;
+Revised for templatized library, Barend Gehrels, 2007
-[heading Typedef Description]
-
+[heading Return Value]
+
+true if [link boost_geometry.reference.point `point`] is in ring, works for closed rings in both directions
-[variablelist
-
-[[P][point type ]]
+[heading Remarks]
+
+Does NOT work correctly for [link boost_geometry.reference.point `point`] ON border
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
-[[A][optional container-allocator-type ]]
-]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Requirements]
+[section:apply strategy::within::franklin::apply]
-[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+[indexterm2 apply..strategy::within::franklin]
+
+ static bool apply(
+ Point const & point,
+ PointOfSegment const & seg1,
+ PointOfSegment const & seg2,
+ crossings & state);
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:ring_tag ring_tag]
+[section:point_type strategy::within::franklin::point_type]
+
+[indexterm2 point_type..strategy::within::franklin]
+
+ typedef Point point_type;
-Convenience (linear) ring identifying tag.
- struct ring_tag
[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:ring_type ring_type]
-Meta-function which defines ring type of (multi)polygon geometry.
+[section:result strategy::within::franklin::result]
+[indexterm2 result..strategy::within::franklin]
- template<
- typename Geometry >
- struct ring_type
+ static bool result(
+ crossings const & state);
-[heading Public Types]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.ring_type.type [*type]]]
- []
-
- ]
+[endsect]
-]
-a polygon contains one exterior ring and zero or more interior rings (holes). This meta function retrieves the type of the rings
-[heading Remarks]
-
-Exterior ring and interior rings must have the same ring-type.
+
+[section:segment_point_type strategy::within::franklin::segment_point_type]
+
+[indexterm2 segment_point_type..strategy::within::franklin]
+
+ typedef PointOfSegment segment_point_type;
[heading Requirements]
-[*Header: ][^boost/geometry/core/ring_type.hpp]
+[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:type ring_type::type]
+[endsect]
-[indexterm2 type..ring_type]
- typedef core_dispatch::ring_type< typename tag< Geometry >::type, Geometry >::type type;
+[section:state_type strategy::within::franklin::state_type]
+[indexterm2 state_type..strategy::within::franklin]
-[heading Public Types]
+ typedef crossings state_type;
+
+
+
+[heading Public Member Functions]
[table
[[Name][Description]]
[
-
- [[link boost_geometry.reference.tag.type [*type]]]
+ [[link boost_geometry.reference.strategy__within__franklin__crossings.crossings [*crossings]]]
[]
-
]
-
+
]
[heading Typedef Description]
-All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
-
-[variablelist
-
-[[Geometry][geometry ]]
-
-]
-
-
+subclass to keep state
[heading Requirements]
-[*Header: ][^boost/geometry/core/ring_type.hpp]
+[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -7767,128 +17378,154 @@
[endsect]
-[section:section section]
-
-
-Structure containing section information.
-
+[section:strategy__within__franklin__crossings strategy::within::franklin::crossings]
- template<
- typename Box ,
- std::size_t ``[link boost_geometry.reference.DimensionCount DimensionCount]``>
- struct section
-[heading Public Types]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.section.box_type [*box_type]]]
- []
-
- ]
-]
+[heading Synopsis]
+ class crossings
[heading Public Member Functions]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.section.section [*section]]]
+ [[link boost_geometry.reference.strategy__within__franklin__crossings.crossings [*crossings]]]
[]
]
]
-[heading Public Data Members]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.section.begin_index [*begin_index]]]
- []
- ]
+[heading Description]
- [
- [[link boost_geometry.reference.section.bounding_box [*bounding_box]]]
- []
- ]
+subclass to keep state
- [
- [[link boost_geometry.reference.section.count [*count]]]
- []
- ]
+[heading Requirements]
- [
- [[link boost_geometry.reference.section.directions [*directions]]]
- []
- ]
+[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:crossings strategy::within::franklin::crossings::crossings]
+
+[indexterm2 crossings..strategy::within::franklin::crossings]
+
+ crossings();
+
+
+
+[endsect]
- [
- [[link boost_geometry.reference.section.duplicate [*duplicate]]]
- []
- ]
- [
- [[link boost_geometry.reference.section.end_index [*end_index]]]
- []
- ]
+
+[endsect]
+
+[section:strategy__within__winding strategy::within::winding]
+
+
+Within detection using [link boost_geometry.reference.strategy__within__winding `strategy::within::winding`] rule.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Point ,
+ typename PointOfSegment = Point,
+ typename CalculationType = void>
+ class winding
+
+[heading Public Types]
+[table
+ [[Name][Description]]
[
- [[link boost_geometry.reference.section.id [*id]]]
+
+ [[link boost_geometry.reference.strategy__within__winding.point_type [*point_type]]]
[]
+
]
[
- [[link boost_geometry.reference.section.multi_index [*multi_index]]]
+
+ [[link boost_geometry.reference.strategy__within__winding.segment_point_type [*segment_point_type]]]
[]
+
]
[
- [[link boost_geometry.reference.section.non_duplicate_index [*non_duplicate_index]]]
+
+ [[link boost_geometry.reference.strategy__within__winding.state_type [*state_type]]]
[]
+
]
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
[
- [[link boost_geometry.reference.section.range_count [*range_count]]]
+ [[link boost_geometry.reference.strategy__within__winding.apply [*apply]]]
[]
]
-
+
[
- [[link boost_geometry.reference.section.ring_index [*ring_index]]]
+ [[link boost_geometry.reference.strategy__within__winding.result [*result]]]
[]
]
-
+
]
-Section information consists of a bounding box, direction information (if it is increasing or decreasing, per dimension), index information (begin-end, ring, multi) and the number of segments in this section
+
+[heading Description]
[variablelist
-[[Box][box-type ]]
+[[Point][[link boost_geometry.reference.point `point`] type of [link boost_geometry.reference.point `point`] to examine ]]
-[[DimensionCount][number of dimensions for this section ]]
+[[PointOfSegment][[link boost_geometry.reference.point `point`] type of segments, defaults to Point ]]
]
+Barend Gehrels
+
+
+[heading Remarks]
+
+The implementation is inspired by terralib http://www.terralib.org (LGPL)
+
+but totally revised afterwards, especially for cases on segments
+
+Only dependant on "side", -> agnostic, suitable for spherical/latlong
+
+
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+[*Header: ][^boost/geometry/strategies/agnostic/point_in_poly_winding.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:begin_index section::begin_index]
+[section:apply strategy::within::winding::apply]
-[indexterm2 begin_index..section]
+[indexterm2 apply..strategy::within::winding]
- int begin_index;
+ static bool apply(
+ Point const & point,
+ PointOfSegment const & s1,
+ PointOfSegment const & s2,
+ counter & state);
@@ -7896,102 +17533,131 @@
-[section:bounding_box section::bounding_box]
+[section:point_type strategy::within::winding::point_type]
-[indexterm2 bounding_box..section]
+[indexterm2 point_type..strategy::within::winding]
- Box bounding_box;
+ typedef Point point_type;
-[endsect]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/agnostic/point_in_poly_winding.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:box_type section::box_type]
-[indexterm2 box_type..section]
+[endsect]
- typedef Box box_type;
+[section:result strategy::within::winding::result]
-[heading Requirements]
+[indexterm2 result..strategy::within::winding]
-[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+ static bool result(
+ counter const & state);
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:count section::count]
+[section:segment_point_type strategy::within::winding::segment_point_type]
-[indexterm2 count..section]
+[indexterm2 segment_point_type..strategy::within::winding]
- std::size_t count;
+ typedef PointOfSegment segment_point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/agnostic/point_in_poly_winding.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:directions section::directions]
+[section:state_type strategy::within::winding::state_type]
-[indexterm2 directions..section]
+[indexterm2 state_type..strategy::within::winding]
- int directions;
+ typedef counter state_type;
-[endsect]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__within__winding__counter.counter [*counter]]]
+ []
+ ]
+
+]
+[heading Typedef Description]
+
+subclass to keep state
-[section:duplicate section::duplicate]
-[indexterm2 duplicate..section]
+[heading Requirements]
- bool duplicate;
+[*Header: ][^boost/geometry/strategies/agnostic/point_in_poly_winding.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:end_index section::end_index]
+[endsect]
-[indexterm2 end_index..section]
+[section:strategy__within__winding__counter strategy::within::winding::counter]
- int end_index;
-[endsect]
+[heading Synopsis]
+ class counter
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
-[section:id section::id]
+ [
+ [[link boost_geometry.reference.strategy__within__winding__counter.counter [*counter]]]
+ []
+ ]
+
+]
-[indexterm2 id..section]
- int id;
+[heading Description]
+subclass to keep state
+[heading Requirements]
-[endsect]
+[*Header: ][^boost/geometry/strategies/agnostic/point_in_poly_winding.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:multi_index section::multi_index]
+[section:counter strategy::within::winding::counter::counter]
-[indexterm2 multi_index..section]
+[indexterm2 counter..strategy::within::winding::counter]
- int multi_index;
+ counter();
@@ -7999,48 +17665,74 @@
-[section:non_duplicate_index section::non_duplicate_index]
+[endsect]
-[indexterm2 non_duplicate_index..section]
+[section:strategy_area strategy_area]
- int non_duplicate_index;
+Traits class binding an area [link boost_geometry.reference.strategy `strategy`] to a coordinate system.
-[endsect]
+[heading Synopsis]
+ template<
+ typename ``[link boost_geometry.reference.Tag Tag]``,
+ typename ``[link boost_geometry.reference.PointOfSegment PointOfSegment]``>
+ struct strategy_area
-[section:range_count section::range_count]
+[heading Public Types]
+[table
+ [[Name][Description]]
-[indexterm2 range_count..section]
+ [
- std::size_t range_count;
+ [[link boost_geometry.reference.strategy_area.type [*type]]]
+ []
+
+ ]
+]
-[endsect]
+[heading Description]
-[section:ring_index section::ring_index]
+[variablelist
+
+[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system ]]
-[indexterm2 ring_index..section]
+[[PointOfSegment][point-type ]]
- int ring_index;
+]
-[endsect]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/area.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:section section::section]
-[indexterm2 section..section]
+[section:type strategy_area::type]
+
+[indexterm2 type..strategy_area]
+
+ typedef strategy::not_implemented type;
+
+
+[heading Typedef Description]
+
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
- section();
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/area.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
@@ -8049,40 +17741,52 @@
[endsect]
+[section:strategy_centroid strategy_centroid]
-[section:sectionalize sectionalize]
-[indexterm1 sectionalize]
-Split a geometry into monotonic sections.
+Traits class binding a centroid calculation [link boost_geometry.reference.strategy `strategy`] to a coordinate system.
- template<
- typename Geometry ,
- typename Sections >
- void sectionalize(
- Geometry const & geometry,
- Sections & sections);
+[heading Synopsis]
+ template<
+ typename CsTag ,
+ typename GeometryTag ,
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Point ,
+ typename Geometry >
+ struct strategy_centroid
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
-[variablelist
+ [[link boost_geometry.reference.strategy_centroid.type [*type]]]
+ []
-[[Geometry][type of geometry to check ]]
-
-[[Sections][type of sections to create ]]
+ ]
]
-[heading Parameters]
-
+[heading Description]
+
+
[variablelist
-[[geometry][geometry to create sections from ]]
+[[CsTag][[link boost_geometry.reference.tag `tag`] of coordinate system, for specialization ]]
+
+[[GeometryTag][[link boost_geometry.reference.tag `tag`] of [link boost_geometry.reference.boost__geometry `boost::geometry`], for specialization ]]
+
+[[Dimension][[link boost_geometry.reference.dimension `dimension`] of [link boost_geometry.reference.boost__geometry `boost::geometry`], for specialization ]]
+
+[[Point][point-type ]]
-[[sections][structure with sections ]]
+[[Geometry][]]
]
@@ -8090,7 +17794,26 @@
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+[*Header: ][^boost/geometry/strategies/centroid.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:type strategy_centroid::type]
+
+[indexterm2 type..strategy_centroid]
+
+ typedef strategy::not_implemented type;
+
+
+[heading Typedef Description]
+
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/centroid.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -8098,16 +17821,25 @@
[endsect]
-[section:sections sections]
+[endsect]
+
+[section:strategy_compare strategy_compare]
+
+
+Traits class binding a comparing [link boost_geometry.reference.strategy `strategy`] to a coordinate system.
-Structure containing a collection of sections.
+
+[heading Synopsis]
template<
- typename Box ,
- std::size_t ``[link boost_geometry.reference.DimensionCount DimensionCount]``>
- struct sections
+ typename Tag ,
+ int ``[link boost_geometry.reference.Direction Direction]``,
+ typename Point ,
+ typename CoordinateSystem ,
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``>
+ struct strategy_compare
[heading Public Types]
[table
@@ -8115,65 +17847,135 @@
[
- [[link boost_geometry.reference.sections.box_type [*box_type]]]
+ [[link boost_geometry.reference.strategy_compare.type [*type]]]
[]
]
]
-[heading Public Data Members]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.sections.value [*value]]]
- []
- ]
+[heading Description]
+
+
+
+[variablelist
+
+[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system of point-type ]]
+
+[[Direction][direction to compare on: 1 for less (-> ascending order) and -1 for greater (-> descending order) ]]
+
+[[Point][point-type ]]
+
+[[CoordinateSystem][coordinate sytem of [link boost_geometry.reference.point `point`] ]]
+
+[[Dimension:][the [link boost_geometry.reference.dimension `dimension`] to compare on ]]
]
-[heading Remarks]
-
-Derived from a vector, proves to be faster than of deque
-vector might be templated in the future
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/compare.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:type strategy_compare::type]
+
+[indexterm2 type..strategy_compare]
+
+ typedef strategy::not_implemented type;
+
+
+[heading Typedef Description]
+
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/compare.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:strategy_convex_hull strategy_convex_hull]
+
+
+Traits class binding a convex hull calculation [link boost_geometry.reference.strategy `strategy`] to a coordinate system.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Tag ,
+ typename Geometry ,
+ typename Point >
+ struct strategy_convex_hull
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy_convex_hull.type [*type]]]
+ []
+
+ ]
+]
-[heading Requirements]
+[heading Description]
-[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[variablelist
+
+[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system ]]
-[section:box_type sections::box_type]
+[[Geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type (hull operates internally per hull over [link boost_geometry.reference.boost__geometry `boost::geometry`]) ]]
-[indexterm2 box_type..sections]
+[[Point][point-type of output points ]]
- typedef Box box_type;
+]
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+[*Header: ][^boost/geometry/strategies/convex_hull.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:type strategy_convex_hull::type]
+[indexterm2 type..strategy_convex_hull]
+ typedef strategy::not_implemented type;
-[section:value sections::value]
-[indexterm2 value..sections]
+[heading Typedef Description]
+
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
- static const std::size_t value = DimensionCount;
+[heading Requirements]
+
+[*Header: ][^boost/geometry/strategies/convex_hull.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
@@ -8182,58 +17984,49 @@
[endsect]
-[section:segment segment]
+[section:strategy_distance strategy_distance]
-Class segment: small class containing two (templatized) point references.
+Traits class binding a distance [link boost_geometry.reference.strategy `strategy`] to a (possibly two) coordinate system(s).
- template<
- typename ConstOrNonConstPoint >
- class segment
-[heading Public Member Functions]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.segment.segment [*segment]]]
- []
- ]
-
-]
-[heading Public Data Members]
+[heading Synopsis]
+ template<
+ typename T1,
+ typename ``[link boost_geometry.reference.T2 T2]``,
+ typename ``[link boost_geometry.reference.P1 P1]``,
+ typename ``[link boost_geometry.reference.P2 P2]``>
+ struct strategy_distance
+
+[heading Public Types]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.segment.first [*first]]]
- []
- ]
- [
- [[link boost_geometry.reference.segment.second [*second]]]
+ [[link boost_geometry.reference.strategy_distance.type [*type]]]
[]
+
]
]
-From Wikipedia: In geometry, a line segment is a part of a line that is bounded by two distinct end points, and contains every point on the line between its end points.
-[heading Remarks]
-
-The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
-
-Like std::pair, points are public available.
-
-type is const or non const, so geometry::segment<P> or geometry::segment<const P>
-We cannot derive from std::pair<P&, P&> because of reference assignments.
+[heading Description]
[variablelist
-[[ConstOrNonConstPoint][point type of the segment, maybe a point or a const point ]]
+[[T1][[link boost_geometry.reference.tag `tag`] of coordinate system of first [link boost_geometry.reference.point `point`] type ]]
+
+[[T2][[link boost_geometry.reference.tag `tag`] of coordinate system of second [link boost_geometry.reference.point `point`] type ]]
+
+[[P1][first point-type ]]
+
+[[P2][second point-type ]]
]
@@ -8241,113 +18034,106 @@
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/segment.hpp]
+[*Header: ][^boost/geometry/strategies/distance.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:first segment::first]
+[section:type strategy_distance::type]
-[indexterm2 first..segment]
+[indexterm2 type..strategy_distance]
- point_type & first;
+ typedef strategy::not_implemented type;
+[heading Typedef Description]
+
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
-[endsect]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/distance.hpp]
-[section:second segment::second]
+[*Convenience header: ][^boost/geometry.hpp]
-[indexterm2 second..segment]
- point_type & second;
+[endsect]
[endsect]
+[section:strategy_distance_segment strategy_distance_segment]
-[section:segment segment::segment]
-
-[indexterm2 segment..segment]
-
- segment(
- point_type & p1,
- point_type & p2);
+Traits class binding a distance-to-segment [link boost_geometry.reference.strategy `strategy`] to a (possibly two) coordinate system(s).
-[endsect]
+[heading Synopsis]
+ template<
+ typename CsTag1 ,
+ typename CsTag2 ,
+ typename Point ,
+ typename Segment >
+ struct strategy_distance_segment
+[heading Public Types]
+[table
+ [[Name][Description]]
-[endsect]
+ [
+ [[link boost_geometry.reference.strategy_distance_segment.type [*type]]]
+ []
+
+ ]
-[section:segment_2d segment_2d]
+]
-[indexterm1 segment_2d]
- typedef segment< point_2d > segment_2d;
+[heading Description]
-[heading Public Member Functions]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.segment.segment [*segment]]]
- []
- ]
+[variablelist
-]
+[[CsTag1][[link boost_geometry.reference.tag `tag`] of coordinate system of [link boost_geometry.reference.point `point`] type ]]
-[heading Public Data Members]
-[table
- [[Name][Description]]
+[[CsTag2][[link boost_geometry.reference.tag `tag`] of coordinate system of [link boost_geometry.reference.segment `segment`] type, usually same as CsTag1 ]]
- [
- [[link boost_geometry.reference.segment.first [*first]]]
- []
- ]
+[[Point][point-type ]]
- [
- [[link boost_geometry.reference.segment.second [*second]]]
- []
- ]
+[[Segment][segment-type ]]
]
-[heading Typedef Description]
-
-From Wikipedia: In geometry, a line segment is a part of a line that is bounded by two distinct end points, and contains every point on the line between its end points.
-[heading Remarks]
-
-The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
-Like std::pair, points are public available.
-type is const or non const, so geometry::segment<P> or geometry::segment<const P>
+[heading Requirements]
-We cannot derive from std::pair<P&, P&> because of reference assignments.
+[*Header: ][^boost/geometry/strategies/distance.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+[section:type strategy_distance_segment::type]
-[variablelist
-
-[[ConstOrNonConstPoint][point type of the segment, maybe a point or a const point ]]
+[indexterm2 type..strategy_distance_segment]
-]
+ typedef strategy::not_implemented type;
+[heading Typedef Description]
+
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+[*Header: ][^boost/geometry/strategies/distance.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -8355,177 +18141,171 @@
[endsect]
-[section:segment_identifier segment_identifier]
+[endsect]
+[section:strategy_intersection strategy_intersection]
- struct segment_identifier
-[heading Public Member Functions]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.segment_identifier.operator_lt_ [*operator<]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.segment_identifier.operator_eq__eq_ [*operator==]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.segment_identifier.segment_identifier [*segment_identifier]]]
- []
- ]
-
-]
-[heading Public Data Members]
+
+
+[heading Synopsis]
+ template<
+ typename Tag ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename IntersectionPoint ,
+ typename CalculationType = void>
+ struct strategy_intersection
+
+[heading Public Types]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.segment_identifier.multi_index [*multi_index]]]
- []
- ]
- [
- [[link boost_geometry.reference.segment_identifier.ring_index [*ring_index]]]
+ [[link boost_geometry.reference.strategy_intersection.segment_intersection_strategy_type [*segment_intersection_strategy_type]]]
[]
+
]
[
- [[link boost_geometry.reference.segment_identifier.segment_index [*segment_index]]]
- []
- ]
- [
- [[link boost_geometry.reference.segment_identifier.source_index [*source_index]]]
+ [[link boost_geometry.reference.strategy_intersection.side_strategy_type [*side_strategy_type]]]
[]
+
]
]
-[heading Requirements]
-
-[*Header: ][^boost/geometry/algorithms/overlay/segment_identifier.hpp]
-
-[*Convenience header: ][^boost/geometry.hpp]
-
-
-[section:multi_index segment_identifier::multi_index]
-
-[indexterm2 multi_index..segment_identifier]
-
- int multi_index;
-
-
-
-[endsect]
-
-
-
-[section:operator_lt_ segment_identifier::operator<]
-
-[indexterm2 operator<..segment_identifier]
-
- bool operator<(
- segment_identifier const & other) const;
-
-
-[endsect]
+[heading Description]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/intersection.hpp]
-[section:operator_eq__eq_ segment_identifier::operator==]
+[*Convenience header: ][^boost/geometry.hpp]
-[indexterm2 operator==..segment_identifier]
- bool operator==(
- segment_identifier const & other) const;
+[section:segment_intersection_strategy_type strategy_intersection::segment_intersection_strategy_type]
+[indexterm2 segment_intersection_strategy_type..strategy_intersection]
+ typedef strategy::intersection::relate_cartesian_segments< policies::relate::segments_tupled< policies::relate::segments_intersection_points< segment1_type, segment2_type, ip_type, CalculationType >, policies::relate::segments_direction< segment1_type, segment2_type, CalculationType >, CalculationType >, CalculationType > segment_intersection_strategy_type;
-[endsect]
+[heading Public Types]
+[table
+ [[Name][Description]]
-[section:ring_index segment_identifier::ring_index]
+ [
-[indexterm2 ring_index..segment_identifier]
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
- int ring_index;
+ [
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.return_type [*return_type]]]
+ []
+
+ ]
+ [
-[endsect]
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.segment_type1 [*segment_type1]]]
+ []
+
+ ]
+ [
-[section:segment_identifier segment_identifier::segment_identifier]
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.segment_type2 [*segment_type2]]]
+ []
+
+ ]
-[indexterm2 segment_identifier..segment_identifier]
+]
- ``[link boost_geometry.reference.segment_identifier.segment_identifier.overload1 segment_identifier]``();
- `` [''''»''' [link boost_geometry.reference.segment_identifier.segment_identifier.overload1 more...]]``
- ``[link boost_geometry.reference.segment_identifier.segment_identifier.overload2 segment_identifier]``(
- int src,
- int mul,
- int rin,
- int seg);
- `` [''''»''' [link boost_geometry.reference.segment_identifier.segment_identifier.overload2 more...]]``
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.BOOST_CONCEPT_ASSERT [*BOOST_CONCEPT_ASSERT]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.strategy__intersection__relate_cartesian_segments.apply [*apply]]]
+ [Relate segments a and b.
-[section:overload1 segment_identifier::segment_identifier (1 of 2 overloads)]
+ ]
+ ]
+
+]
+[heading Typedef Description]
+
- segment_identifier();
+[heading Requirements]
-[endsect]
+[*Header: ][^boost/geometry/strategies/intersection.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:overload2 segment_identifier::segment_identifier (2 of 2 overloads)]
+[endsect]
- segment_identifier(
- int src,
- int mul,
- int rin,
- int seg);
+[section:side_strategy_type strategy_intersection::side_strategy_type]
+[indexterm2 side_strategy_type..strategy_intersection]
+ typedef strategy_side< Tag, CalculationType >::type side_strategy_type;
-[endsect]
-[endsect]
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
-[section:segment_index segment_identifier::segment_index]
+ [[link boost_geometry.reference.strategy_side.type [*type]]]
+ []
+
+ ]
-[indexterm2 segment_index..segment_identifier]
+]
- int segment_index;
+[heading Typedef Description]
+
+[variablelist
+
+[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system of point-type ]]
-[endsect]
+]
-[section:source_index segment_identifier::source_index]
-[indexterm2 source_index..segment_identifier]
+[heading Requirements]
- int source_index;
+[*Header: ][^boost/geometry/strategies/intersection.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
@@ -8534,585 +18314,538 @@
[endsect]
-[section:segment_tag segment_tag]
-
+[section:strategy_parse strategy_parse]
-Convenience segment (2-points) identifying tag.
+Tagraits class binding a parsing [link boost_geometry.reference.strategy `strategy`] to a coordinate system.
- struct segment_tag
-[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[heading Synopsis]
+ template<
+ typename Tag ,
+ typename CoordinateSystem >
+ struct strategy_parse
-[endsect]
+[heading Public Types]
+[table
+ [[Name][Description]]
-[section:set set]
+ [
-[indexterm1 set]
-set coordinate value of a Point ( / Sphere)
+ [[link boost_geometry.reference.strategy_parse.type [*type]]]
+ []
+
+ ]
-
- template<
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- void ``[link boost_geometry.reference.set.overload1 set]``(
- Geometry & geometry,
- typename coordinate_type< Geometry >::type const & value);
- `` [''''»''' [link boost_geometry.reference.set.overload1 more...]]``
+]
- template<
- std::size_t ``[link boost_geometry.reference.Index Index]``,
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- void ``[link boost_geometry.reference.set.overload2 set]``(
- Geometry & geometry,
- typename coordinate_type< Geometry >::type const & value);
- `` [''''»''' [link boost_geometry.reference.set.overload2 more...]]``
-[heading Requirements]
+[heading Description]
-[*Header: ][^boost/geometry/core/access.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[variablelist
+
+[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system of point-type ]]
-[section:overload1 set (1 of 2 overloads)]
+[[CoordinateSystem][coordinate system ]]
+]
-set coordinate value of a Point ( / Sphere)
- template<
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- void set(
- Geometry & geometry,
- typename coordinate_type< Geometry >::type const & value);
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/parse.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[variablelist
-
-[[Dimension][dimension ]]
+[section:type strategy_parse::type]
-[[Geometry][geometry ]]
+[indexterm2 type..strategy_parse]
-]
+ typedef strategy::not_implemented type;
-[heading Parameters]
+[heading Typedef Description]
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
-[variablelist
-
-[[geometry][geometry to assign coordinate to ]]
-[[value][coordinate value to assign ]]
+[heading Requirements]
-]
+[*Header: ][^boost/geometry/strategies/parse.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
+
[endsect]
+[section:strategy_side strategy_side]
-[section:overload2 set (2 of 2 overloads)]
+Traits class binding a side determination [link boost_geometry.reference.strategy `strategy`] to a coordinate system.
-set coordinate value of a Box / Segment
+[heading Synopsis]
template<
- std::size_t ``[link boost_geometry.reference.Index Index]``,
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- void set(
- Geometry & geometry,
- typename coordinate_type< Geometry >::type const & value);
-
+ typename ``[link boost_geometry.reference.Tag Tag]``,
+ typename ``[link boost_geometry.reference.CalculationType CalculationType]`` = void>
+ struct strategy_side
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
-[variablelist
+ [[link boost_geometry.reference.strategy_side.type [*type]]]
+ []
-[[Index][for Point: do not specifyfor Box: min\_corner or max\_cornerfor Segment: 0 / 1
-]]
+ ]
-[[Dimension][dimension ]]
+]
-[[Geometry][geometry ]]
-]
+[heading Description]
-[heading Parameters]
-
[variablelist
-[[geometry][geometry to assign coordinate to ]]
-
-[[value][coordinate value to assign ]]
+[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system of point-type ]]
]
+[heading Requirements]
-[endsect]
+[*Header: ][^boost/geometry/strategies/side.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:type strategy_side::type]
-[section:set_from_radian set_from_radian]
+[indexterm2 type..strategy_side]
-[indexterm1 set_from_radian]
-set coordinate value (in radian) to a point
+ typedef strategy::not_implemented type;
- template<
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- void set_from_radian(
- Geometry & geometry,
- const typename coordinate_type< Geometry >::type & radians);
+[heading Typedef Description]
+
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
-Coordinate value will be set correctly, if coordinate system of point is in Degree, Radian value will be converted to Degree
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/side.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[variablelist
-
-[[Dimension][dimension ]]
-[[Geometry][geometry ]]
+[endsect]
-]
-[heading Parameters]
-
+[endsect]
-[variablelist
-
-[[geometry][geometry to assign coordinate to ]]
+[section:strategy_tag strategy_tag]
-[[radians][coordinate value to assign ]]
-]
-[heading Remarks]
-
-Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems
+
+[heading Synopsis]
+ template<
+ typename T >
+ struct strategy_tag
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.strategy_tag.type [*type]]]
+ []
+
+ ]
+
+]
+[heading Description]
[heading Requirements]
-[*Header: ][^boost/geometry/core/radian_access.hpp]
+[*Header: ][^boost/geometry/strategies/tags.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:type strategy_tag::type]
+[indexterm2 type..strategy_tag]
-[section:simplify simplify]
+ typedef strategy_tag_unknown type;
-[indexterm1 simplify]
-
- template<
- typename Geometry ,
- typename Strategy >
- void ``[link boost_geometry.reference.simplify.overload1 simplify]``(
- Geometry const & geometry,
- Geometry & out,
- double max_distance,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.simplify.overload1 more...]]``
- template<
- typename Geometry >
- void ``[link boost_geometry.reference.simplify.overload2 simplify]``(
- Geometry const & geometry,
- Geometry & out,
- double max_distance);
- `` [''''»''' [link boost_geometry.reference.simplify.overload2 more...]]``
+[heading Typedef Description]
+
+[heading Requirements]
-[heading Source description:]
-
+[*Header: ][^boost/geometry/strategies/tags.hpp]
-* Wikipedia: given a 'curve' composed of line segments to find a curve not too dissimilar but that has fewer points
+[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
-[heading Performance]
-
+[endsect]
-* Performance is measured on simplification of a collection of rings, such that 10% of the points is kept.
+[section:strategy_tag_lt__strategy__distance__projected_point_lt__Point,_PointOfSegment,_PPStrategy__gt___gt_ strategy_tag< strategy::distance::projected_point< Point, PointOfSegment, PPStrategy > >]
-* 2776 counties of US are simplified in 0.7 seconds (http://trac.osgeo.org/ggl/wiki/Performance#Simplify1)
-[heading Geometries]
-
+[heading Synopsis]
+ template<
+ typename Point ,
+ typename PointOfSegment ,
+ typename PPStrategy >
+ struct strategy_tag< strategy::distance::projected_point< Point, PointOfSegment, PPStrategy > >
-* linestring:
- This US Road originally contained 34 points, the simplified version contains 7 points
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.strategy_tag_lt__strategy__distance__projected_point_lt__Point,_PointOfSegment,_PPStrategy__gt___gt_.type [*type]]]
+ []
+
+ ]
+]
-* polygon:
- This country (Belgium) originally contained 55 points, the simplified version contains 24 points
+[heading Description]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/cartesian/distance_projected_point.hpp]
-[heading Remarks]
-
-simplifying a valid simple polygon (which never intersects itself) might result in an invalid polygon, where the simplified rings intersect themselves or one of the other outer or inner rings. Efficient simplification of a ring/polygon is still an "Open Problem" (http://maven.smith.edu/~orourke/TOPP/P24.html#Problem.24)
+[*Convenience header: ][^boost/geometry.hpp]
-* multi_linestring
+[section:type strategy_tag< strategy::distance::projected_point< Point, PointOfSegment, PPStrategy > >::type]
-* multi_polygon
+[indexterm2 type..strategy_tag< strategy::distance::projected_point< Point, PointOfSegment, PPStrategy > >]
+ typedef strategy_tag_distance_point_segment type;
+[heading Typedef Description]
+
+
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/simplify.hpp]
+[*Header: ][^boost/geometry/strategies/cartesian/distance_projected_point.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 simplify (1 of 2 overloads)]
+[endsect]
-Simplify a geometry using a specified strategy.
+[endsect]
- template<
- typename Geometry ,
- typename Strategy >
- void simplify(
- Geometry const & geometry,
- Geometry & out,
- double max_distance,
- Strategy const & strategy);
+[section:strategy_tag_lt__strategy__distance__pythagoras_lt__Point1,_Point2__gt___gt_ strategy_tag< strategy::distance::pythagoras< Point1, Point2 > >]
-[heading Parameters]
-
-[variablelist
-
-[[geometry][input geometry, to be simplified ]]
-[[out][output geometry, simplified version of the input geometry ]]
+[heading Synopsis]
+ template<
+ typename Point1 ,
+ typename Point2 >
+ struct strategy_tag< strategy::distance::pythagoras< Point1, Point2 > >
+
+[heading Public Types]
+[table
+ [[Name][Description]]
-[[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 ]]
+ [[link boost_geometry.reference.strategy_tag_lt__strategy__distance__pythagoras_lt__Point1,_Point2__gt___gt_.type [*type]]]
+ []
+
+ ]
]
+[heading Description]
+[heading Requirements]
-[endsect]
+[*Header: ][^boost/geometry/strategies/cartesian/distance_pythagoras.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:overload2 simplify (2 of 2 overloads)]
+[section:type strategy_tag< strategy::distance::pythagoras< Point1, Point2 > >::type]
+[indexterm2 type..strategy_tag< strategy::distance::pythagoras< Point1, Point2 > >]
-Simplify a geometry.
+ typedef strategy_tag_distance_point_point type;
- template<
- typename Geometry >
- void simplify(
- Geometry const & geometry,
- Geometry & out,
- double max_distance);
+[heading Typedef Description]
+
+
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/cartesian/distance_pythagoras.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Remarks]
-
-This version of simplify simplifies a geometry using the default strategy (Douglas Peucker),
+[endsect]
-[heading Parameters]
-
-[variablelist
-
-[[geometry][input geometry, to be simplified ]]
-[[out][output geometry, simplified version of the input geometry ]]
+[endsect]
-[[max_distance][distance (in units of input coordinates) of a vertex to other segments to be removed ]]
+[section:strategy_tag_distance_point_point strategy_tag_distance_point_point]
-]
-[heading Example:]
-
-The simplify algorithm can be used as following:
+[heading Synopsis]
+ struct strategy_tag_distance_point_point
+[heading Description]
+[heading Requirements]
+[*Header: ][^boost/geometry/strategies/tags.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:strategy_tag_distance_point_segment strategy_tag_distance_point_segment]
-[endsect]
-[section:simplify_inserter simplify_inserter]
-[indexterm1 simplify_inserter]
-Simplify a geometry, using an output iterator and a specified strategy.
-
- template<
- typename Geometry ,
- typename OutputIterator ,
- typename Strategy >
- void ``[link boost_geometry.reference.simplify_inserter.overload1 simplify_inserter]``(
- Geometry const & geometry,
- OutputIterator out,
- double max_distance,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.simplify_inserter.overload1 more...]]``
- template<
- typename Geometry ,
- typename OutputIterator >
- void ``[link boost_geometry.reference.simplify_inserter.overload2 simplify_inserter]``(
- Geometry const & geometry,
- OutputIterator out,
- double max_distance);
- `` [''''»''' [link boost_geometry.reference.simplify_inserter.overload2 more...]]``
+[heading Synopsis]
+ struct strategy_tag_distance_point_segment
+
+[heading Description]
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/simplify.hpp]
+[*Header: ][^boost/geometry/strategies/tags.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 simplify_inserter (1 of 2 overloads)]
-
+[endsect]
-Simplify a geometry, using an output iterator and a specified strategy.
+[section:strategy_tag_unknown strategy_tag_unknown]
- template<
- typename Geometry ,
- typename OutputIterator ,
- typename Strategy >
- void simplify_inserter(
- Geometry const & geometry,
- OutputIterator out,
- double max_distance,
- Strategy const & strategy);
-[heading Parameters]
-
+[heading Synopsis]
+ struct strategy_tag_unknown
-[variablelist
-
-[[geometry][input geometry, to be simplified ]]
+[heading Description]
-[[out][output iterator, outputs all simplified points ]]
+[heading Requirements]
-[[max_distance][distance (in units of input coordinates) of a vertex to other segments to be removed ]]
+[*Header: ][^boost/geometry/strategies/tags.hpp]
-[[strategy][simplify strategy to be used for simplification, might include point-distance strategy ]]
+[*Convenience header: ][^boost/geometry.hpp]
-]
+[endsect]
-[heading Example:]
-
-simplify\_inserter with strategy is used as following:
+[section:strategy_transform strategy_transform]
+Traits class binding a transformation [link boost_geometry.reference.strategy `strategy`] to a coordinate system.
+[heading Synopsis]
+ template<
+ typename CoordinateSystemTag1 ,
+ typename CoordinateSystemTag2 ,
+ typename CoordinateSystem1 ,
+ typename CoordinateSystem2 ,
+ std::size_t ``[link boost_geometry.reference.Dimension1 Dimension1]``,
+ std::size_t ``[link boost_geometry.reference.Dimension2 Dimension2]``,
+ typename Point1 ,
+ typename Point2 >
+ struct strategy_transform
+[heading Public Types]
+[table
+ [[Name][Description]]
-[endsect]
+ [
+ [[link boost_geometry.reference.strategy_transform.type [*type]]]
+ []
+
+ ]
+]
-[section:overload2 simplify_inserter (2 of 2 overloads)]
+[heading Description]
-Simplify a geometry, using an output iterator.
+Can be specialized
+* per coordinate system family (tag)
+* per coordinate system (or groups of them)
- template<
- typename Geometry ,
- typename OutputIterator >
- void simplify_inserter(
- Geometry const & geometry,
- OutputIterator out,
- double max_distance);
+* per dimension
+* per point type CoordinateSystemTag1,2 coordinate system tags CoordinateSystem1,2 coordinate system D1, 2 dimension Point1, 2 point type
-[heading Parameters]
-
-[variablelist
-
-[[geometry][input geometry, to be simplified ]]
-[[out][output iterator, outputs all simplified points ]]
+[heading Requirements]
-[[max_distance][distance (in units of input coordinates) of a vertex to other segments to be removed ]]
+[*Header: ][^boost/geometry/strategies/transform.hpp]
-]
+[*Convenience header: ][^boost/geometry.hpp]
+[section:type strategy_transform::type]
+[indexterm2 type..strategy_transform]
-[endsect]
+ typedef strategy::not_implemented type;
-[endsect]
+[heading Typedef Description]
+
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
-[section:spherical_tag spherical_tag]
+[heading Requirements]
-Tag indicating Spherical coordinate system family (spherical,celestial,...).
+[*Header: ][^boost/geometry/strategies/transform.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
- struct spherical_tag
-[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:strategy__intersection__liang_barsky strategy::intersection::liang_barsky]
+[section:strategy_within strategy_within]
-Strategy: line clipping algorithm after Liang Barsky.
+Traits class binding a within determination [link boost_geometry.reference.strategy `strategy`] to a coordinate system.
+
+
+[heading Synopsis]
template<
- typename Box ,
- typename Point >
- class liang_barsky
-[heading Public Member Functions]
+ typename TagPoint ,
+ typename TagSegment ,
+ typename Point ,
+ typename PointOfSegment >
+ struct strategy_within
+
+[heading Public Types]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.strategy__intersection__liang_barsky.apply [*apply]]]
+
+ [[link boost_geometry.reference.strategy_within.type [*type]]]
[]
- ]
- [
- [[link boost_geometry.reference.strategy__intersection__liang_barsky.clip_segment [*clip_segment]]]
- []
]
-
-]
-
-The Liang-Barsky line clipping algorithm clips a line with a clipping box. It is slightly adapted in the sense that it returns which points are clipped
-
-[variablelist
-
-[[B][input box type of clipping box ]]
-
-[[P][input/output point-type of segments to be clipped ]]
]
-[heading Remarks]
-
-The algorithm is currently only implemented for 2D Cartesian points
+[heading Description]
-Though it is implemented in namespace strategy, and theoretically another strategy could be used, it is not (yet) updated to the general strategy concepts, and not (yet) splitted into a file in folder strategies
-Barend Gehrels, and the following recourses
-* A tutorial: http://www.skytopia.com/project/articles/compsci/clipping.html
+[variablelist
+
+[[TagPoint][[link boost_geometry.reference.tag `tag`] of coordinate system of point-type ]]
-* a German applet (link broken): http://ls7-www.cs.uni-dortmund.de/students/projectgroups/acit/lineclip.shtml
+[[TagSegment][[link boost_geometry.reference.tag `tag`] of coordinate system of segment-type ]]
+[[Point][point-type of input points ]]
+[[PointOfSegment][point-type of input segment-points ]]
+
+]
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/overlay/clip_linestring.hpp]
+[*Header: ][^boost/geometry/strategies/point_in_poly.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:apply strategy::intersection::liang_barsky::apply]
-
-[indexterm2 apply..strategy::intersection::liang_barsky]
-
- template<
- typename Linestring ,
- typename OutputIterator >
- void apply(
- Linestring & line_out,
- OutputIterator out) const;
-
+[section:type strategy_within::type]
+[indexterm2 type..strategy_within]
-[endsect]
+ typedef strategy::not_implemented type;
+[heading Typedef Description]
+
+Strategies are defined for [link boost_geometry.reference.point `point`] types or for [link boost_geometry.reference.point `point`] type combinations. If there is no implementation for that specific [link boost_geometry.reference.point `point`] type, or [link boost_geometry.reference.point `point`] type combination, the calculation cannot be done. To indicate this, this [link boost_geometry.reference.strategy__not_implemented `strategy::not_implemented`] class is used as a typedef stub.
-[section:clip_segment strategy::intersection::liang_barsky::clip_segment]
-[indexterm2 clip_segment..strategy::intersection::liang_barsky]
+[heading Requirements]
- bool clip_segment(
- Box const & b,
- segment_type & s,
- bool & sp1_clipped,
- bool & sp2_clipped) const;
+[*Header: ][^boost/geometry/strategies/point_in_poly.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
@@ -9125,7 +18858,7 @@
[section:subtract_point subtract_point]
[indexterm1 subtract_point]
-Subtracts a point to another.
+Subtracts a [link boost_geometry.reference.point `point`] to another.
template<
@@ -9136,15 +18869,15 @@
Point2 const & p2);
-The coordinates of the second point will be subtracted to those of the first point. The second point is not modified.
+The coordinates of the second [link boost_geometry.reference.point `point`] will be subtracted to those of the first [link boost_geometry.reference.point `point`]. The second [link boost_geometry.reference.point `point`] is not modified.
[heading Parameters]
[variablelist
-[[p1][first point ]]
+[[p1][first [link boost_geometry.reference.point `point`] ]]
-[[p2][second point ]]
+[[p2][second [link boost_geometry.reference.point `point`] ]]
]
@@ -9164,7 +18897,7 @@
[section:subtract_value subtract_value]
[indexterm1 subtract_value]
-Subtracts a value to each coordinate of a point.
+Subtracts a value to each coordinate of a [link boost_geometry.reference.point `point`].
template<
@@ -9180,7 +18913,7 @@
[variablelist
-[[p][point ]]
+[[p][[link boost_geometry.reference.point `point`] ]]
[[value][value to subtract ]]
@@ -9217,7 +18950,7 @@
[variablelist
-[[Geometry][geometry type ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
]
@@ -9227,7 +18960,7 @@
[variablelist
-[[geometry][the geometry to make symmetric difference ]]
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make symmetric difference ]]
]
@@ -9246,9 +18979,12 @@
[section:tag tag]
-Meta-function to get the tag of any geometry type.
+Meta-function to get the [link boost_geometry.reference.tag `tag`] of any [link boost_geometry.reference.boost__geometry `boost::geometry`] type.
+
+
+[heading Synopsis]
template<
typename Geometry >
struct tag
@@ -9266,11 +19002,14 @@
]
-All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+
+[heading Description]
+
+All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type ([link boost_geometry.reference.point `point`], [link boost_geometry.reference.linestring `linestring`], [link boost_geometry.reference.polygon `polygon`], etc) by implementing a [link boost_geometry.reference.tag `tag`] [link boost_geometry.reference.traits `traits`] class. This meta-function uses that [link boost_geometry.reference.traits `traits`] class to retrieve the [link boost_geometry.reference.tag `tag`]. If the input type is not a [link boost_geometry.reference.boost__geometry `boost::geometry`] at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
[variablelist
-[[Geometry][geometry ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -9306,7 +19045,7 @@
[heading Typedef Description]
-All geometries should implement a `traits::tag<G>::type` metafunction to indicate their own geometry type.
+All geometries should implement a `traits::tag<G>::type` metafunction to indicate their own [link boost_geometry.reference.boost__geometry `boost::geometry`] type.
[heading Geometries:]
@@ -9328,7 +19067,7 @@
[variablelist
-[[Geometry][geometry ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -9351,13 +19090,19 @@
[section:topological_dimension topological_dimension]
-Meta-function returning the topological dimension of a geometry.
+Meta-function returning the topological [link boost_geometry.reference.dimension `dimension`] of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+[heading Synopsis]
template<
typename Geometry >
struct topological_dimension
-The topological dimension defines a point as 0-dimensional, a linestring as 1-dimensional, and a ring or polygon as 2-dimensional.
+
+[heading Description]
+
+The topological [link boost_geometry.reference.dimension `dimension`] defines a [link boost_geometry.reference.point `point`] as 0-dimensional, a [link boost_geometry.reference.linestring `linestring`] as 1-dimensional, and a ring or [link boost_geometry.reference.polygon `polygon`] as 2-dimensional.
[heading Requirements]
@@ -9372,14 +19117,20 @@
[section:traits__access traits::access]
-Traits class which gives access (get,set) to points.
+Traits class which gives [link boost_geometry.reference.traits__access `traits::access`] (get,set) to points.
+
+
+[heading Synopsis]
template<
typename Geometry ,
std::size_t ``[link boost_geometry.reference.Dimension Dimension]``>
struct access
+[heading Description]
+
+
[heading Geometries:]
@@ -9403,7 +19154,7 @@
[[Geometry][geometry-type ]]
-[[Dimension][dimension to access ]]
+[[Dimension][[link boost_geometry.reference.traits__dimension `traits::dimension`] to [link boost_geometry.reference.traits__access `traits::access`] ]]
]
@@ -9421,14 +19172,20 @@
[section:traits__append_point traits::append_point]
-Traits class, optional, might be implemented to append a point.
+Traits class, optional, might be implemented to append a [link boost_geometry.reference.point `point`].
+
+
+[heading Synopsis]
template<
typename Geometry ,
typename Point >
struct append_point
-If a geometry type should not use the std "push\_back" then it can specialize the "use\_std" traits class to false, it should then implement (a.o.) [link boost_geometry.reference.traits__append_point `traits::append_point`]
+
+[heading Description]
+
+If a [link boost_geometry.reference.boost__geometry `boost::geometry`] type should not use the std "push\_back" then it can specialize the "use\_std" [link boost_geometry.reference.traits `traits`] class to false, it should then implement (a.o.) [link boost_geometry.reference.traits__append_point `traits::append_point`]
[heading Geometries:]
@@ -9462,13 +19219,19 @@
[section:traits__clear traits::clear]
-Traits class, optional, might be implemented to clear a geometry.
+Traits class, optional, might be implemented to [link boost_geometry.reference.traits__clear `traits::clear`] a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+[heading Synopsis]
template<
typename Geometry >
struct clear
-If a geometry type should not use the std ".clear()" then it can specialize the "use\_std" traits class to false, it should then implement (a.o.) clear
+
+[heading Description]
+
+If a [link boost_geometry.reference.boost__geometry `boost::geometry`] type should not use the std ".clear()" then it can specialize the "use\_std" [link boost_geometry.reference.traits `traits`] class to false, it should then implement (a.o.) [link boost_geometry.reference.traits__clear `traits::clear`]
[heading Geometries:]
@@ -9502,13 +19265,19 @@
[section:traits__coordinate_system traits::coordinate_system]
-Traits class defining the coordinate system of a point, important for strategy selection.
+Traits class defining the coordinate system of a [link boost_geometry.reference.point `point`], important for [link boost_geometry.reference.strategy `strategy`] selection.
+
+
+[heading Synopsis]
template<
typename P >
struct coordinate_system
+[heading Description]
+
+
[heading Geometries:]
@@ -9538,13 +19307,19 @@
[section:traits__coordinate_type traits::coordinate_type]
-Traits class which indicate the coordinate type (double,float,...) of a point.
+Traits class which indicate the coordinate type (double,float,...) of a [link boost_geometry.reference.point `point`].
+
+
+[heading Synopsis]
template<
typename P >
struct coordinate_type
+[heading Description]
+
+
[heading Geometries:]
@@ -9574,13 +19349,19 @@
[section:traits__cs_tag traits::cs_tag]
-Traits class defining coordinate system tag, bound to coordinate system.
+Traits class defining coordinate system [link boost_geometry.reference.traits__tag `traits::tag`], bound to coordinate system.
+
+
+[heading Synopsis]
template<
typename CoordinateSystem >
struct cs_tag
+[heading Description]
+
+
[variablelist
@@ -9602,13 +19383,19 @@
[section:traits__dimension traits::dimension]
-Traits class indicating the number of dimensions of a point.
+Traits class indicating the number of dimensions of a [link boost_geometry.reference.point `point`].
+
+
+[heading Synopsis]
template<
typename P >
struct dimension
+[heading Description]
+
+
[heading Geometries:]
@@ -9638,19 +19425,25 @@
[section:traits__exterior_ring traits::exterior_ring]
-Traits class defining access to [link boost_geometry.reference.traits__exterior_ring `traits::exterior_ring`] of a polygon.
+Traits class defining [link boost_geometry.reference.traits__access `traits::access`] to [link boost_geometry.reference.traits__exterior_ring `traits::exterior_ring`] of a [link boost_geometry.reference.polygon `polygon`].
+
+
+[heading Synopsis]
template<
typename Polygon >
struct exterior_ring
-Should define const and non const access
+
+[heading Description]
+
+Should define const and non const [link boost_geometry.reference.traits__access `traits::access`]
[variablelist
-[[Polygon][the polygon type ]]
+[[Polygon][the [link boost_geometry.reference.polygon `polygon`] type ]]
]
@@ -9686,23 +19479,29 @@
[section:traits__indexed_access traits::indexed_access]
-Traits class defining "get" and "set" to get and set point coordinate values.
+Traits class defining "get" and "set" to get and set [link boost_geometry.reference.point `point`] coordinate values.
+
+
+[heading Synopsis]
template<
typename Geometry ,
std::size_t ``[link boost_geometry.reference.Index Index]``,
std::size_t ``[link boost_geometry.reference.Dimension Dimension]``>
struct indexed_access
+[heading Description]
+
+
[variablelist
-[[Geometry][geometry (box, segment) ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ([link boost_geometry.reference.box `box`], [link boost_geometry.reference.segment `segment`]) ]]
-[[Index][index (min\_corner/max\_corner for box, 0/1 for segment) ]]
+[[Index][index (min\_corner/max\_corner for [link boost_geometry.reference.box `box`], 0/1 for [link boost_geometry.reference.segment `segment`]) ]]
-[[Dimension][dimension ]]
+[[Dimension][[link boost_geometry.reference.traits__dimension `traits::dimension`] ]]
]
@@ -9740,13 +19539,19 @@
[section:traits__interior_rings traits::interior_rings]
-Traits class defining access to [link boost_geometry.reference.traits__interior_rings `traits::interior_rings`] of a polygon.
+Traits class defining [link boost_geometry.reference.traits__access `traits::access`] to [link boost_geometry.reference.traits__interior_rings `traits::interior_rings`] of a [link boost_geometry.reference.polygon `polygon`].
+
+
+[heading Synopsis]
template<
typename Geometry >
struct interior_rings
-defines access (const and non const) to interior ring
+
+[heading Description]
+
+defines [link boost_geometry.reference.traits__access `traits::access`] (const and non const) to interior ring
[heading Geometries:]
@@ -9770,7 +19575,7 @@
[variablelist
-[[Geometry][geometry ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -9788,12 +19593,18 @@
[section:traits__interior_type traits::interior_type]
-Traits class indicating interior container type of a polygon.
+Traits class indicating interior container type of a [link boost_geometry.reference.polygon `polygon`].
+
+
+[heading Synopsis]
template<
typename Geometry >
struct interior_type
+
+[heading Description]
+
defines inner container type, so the container containing the interior rings
@@ -9816,7 +19627,7 @@
[variablelist
-[[Geometry][geometry ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -9834,12 +19645,16 @@
[section:traits__point_order traits::point_order]
-Traits class indicating the order of contained points within a ring or (multi)polygon, clockwise, counter clockwise or not known.
+Traits class indicating the order of contained points within a ring or (multi)[link boost_geometry.reference.polygon `polygon`], clockwise, counter clockwise or not known.
+
+
+[heading Synopsis]
template<
typename G >
struct point_order
+
[heading Public Data Members]
[table
[[Name][Description]]
@@ -9852,6 +19667,9 @@
]
+[heading Description]
+
+
[heading Geometries:]
@@ -9875,7 +19693,7 @@
[variablelist
-[[G][geometry ]]
+[[G][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -9908,10 +19726,16 @@
Traits class indicating the type of contained points.
+
+
+[heading Synopsis]
template<
typename G >
struct point_type
+[heading Description]
+
+
[heading Geometries:]
@@ -9931,7 +19755,7 @@
[variablelist
-[[G][geometry ]]
+[[G][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -9952,10 +19776,16 @@
Traits class to indicate ring-type of a polygon's exterior ring/interior rings.
+
+
+[heading Synopsis]
template<
typename Geometry >
struct ring_type
+[heading Description]
+
+
[heading Geometries:]
@@ -9975,7 +19805,7 @@
[variablelist
-[[Geometry][geometry ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -9993,9 +19823,12 @@
[section:traits__tag traits::tag]
-Traits class to attach a tag to a geometry.
+Traits class to attach a [link boost_geometry.reference.traits__tag `traits::tag`] to a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+[heading Synopsis]
template<
typename ``[link boost_geometry.reference.Geometry Geometry]``>
struct tag
@@ -10013,7 +19846,10 @@
]
-All geometries should implement a `traits::tag<G>::type` metafunction to indicate their own geometry type.
+
+[heading Description]
+
+All geometries should implement a `traits::tag<G>::type` metafunction to indicate their own [link boost_geometry.reference.boost__geometry `boost::geometry`] type.
[heading Geometries:]
@@ -10035,7 +19871,7 @@
[variablelist
-[[Geometry][geometry ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -10077,9 +19913,13 @@
Traits class, optional, indicating that the std-library should be used.
+
+
+[heading Synopsis]
template<
typename Geometry >
struct use_std
+
[heading Public Data Members]
[table
[[Name][Description]]
@@ -10091,7 +19931,10 @@
]
-The default geometry (linestring, ring, multi*) follow std:: for its modifying operations (push\_back, clear, size, resize, reserve, etc) If they NOT follow the std:: library they should specialize this traits class
+
+[heading Description]
+
+The default [link boost_geometry.reference.boost__geometry `boost::geometry`] ([link boost_geometry.reference.linestring `linestring`], ring, multi*) follow std:: for its modifying operations (push\_back, [link boost_geometry.reference.traits__clear `traits::clear`], size, resize, reserve, etc) If they NOT follow the std:: library they should specialize this [link boost_geometry.reference.traits `traits`] class
[heading Geometries:]
@@ -10209,7 +20052,7 @@
[section:overload1 transform (1 of 2 overloads)]
-Transforms from one geometry to another geometry using a strategy.
+Transforms from one [link boost_geometry.reference.boost__geometry `boost::geometry`] to another [link boost_geometry.reference.boost__geometry `boost::geometry`] using a [link boost_geometry.reference.strategy `strategy`].
template<
@@ -10226,11 +20069,11 @@
[variablelist
-[[Geometry1][first geometry type ]]
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Geometry2][second geometry type ]]
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Strategy][strategy ]]
+[[Strategy][[link boost_geometry.reference.strategy `strategy`] ]]
]
@@ -10240,11 +20083,11 @@
[variablelist
-[[geometry1][first geometry ]]
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[geometry2][second geometry ]]
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[strategy][the strategy to be used for transformation ]]
+[[strategy][the [link boost_geometry.reference.strategy `strategy`] to be used for transformation ]]
]
@@ -10258,7 +20101,7 @@
[section:overload2 transform (2 of 2 overloads)]
-Transforms from one geometry to another geometry using a strategy.
+Transforms from one [link boost_geometry.reference.boost__geometry `boost::geometry`] to another [link boost_geometry.reference.boost__geometry `boost::geometry`] using a [link boost_geometry.reference.strategy `strategy`].
template<
@@ -10273,9 +20116,9 @@
[variablelist
-[[Geometry1][first geometry type ]]
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Geometry2][second geometry type ]]
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
]
@@ -10285,9 +20128,9 @@
[variablelist
-[[geometry1][first geometry ]]
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[geometry2][second geometry ]]
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -10394,15 +20237,15 @@
[variablelist
-[[GeometryOut][output geometry type, must be specified ]]
+[[GeometryOut][output [link boost_geometry.reference.boost__geometry `boost::geometry`] type, must be specified ]]
-[[Geometry1][first geometry type ]]
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Geometry2][second geometry type ]]
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
[[OutputIterator][output iterator ]]
-[[Strategy][compound strategy for intersection ]]
+[[Strategy][compound [link boost_geometry.reference.strategy `strategy`] for intersection ]]
]
@@ -10412,13 +20255,13 @@
[variablelist
-[[geometry1][first geometry ]]
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[geometry2][second geometry ]]
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
[[out][the output iterator, outputting polygons ]]
-[[strategy][the strategy ]]
+[[strategy][the [link boost_geometry.reference.strategy `strategy`] ]]
]
@@ -10455,11 +20298,11 @@
[variablelist
-[[GeometryOut][output geometry type, must be specified ]]
+[[GeometryOut][output [link boost_geometry.reference.boost__geometry `boost::geometry`] type, must be specified ]]
-[[Geometry1][first geometry type ]]
+[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Geometry2][second geometry type ]]
+[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
[[OutputIterator][output iterator ]]
@@ -10471,9 +20314,9 @@
[variablelist
-[[geometry1][first geometry ]]
+[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[geometry2][second geometry ]]
+[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
[[out][the output iterator, outputting polygons ]]
@@ -10507,7 +20350,7 @@
[variablelist
-[[Geometry][geometry type ]]
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
]
@@ -10517,7 +20360,7 @@
[variablelist
-[[geometry][the geometry to make unique ]]
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make unique ]]
]
@@ -10613,7 +20456,7 @@
[section:overload1 within (1 of 2 overloads)]
-Within, examine if a geometry is within another geometry.
+Within, examine if a [link boost_geometry.reference.boost__geometry `boost::geometry`] is within another [link boost_geometry.reference.boost__geometry `boost::geometry`].
template<
@@ -10630,9 +20473,9 @@
[variablelist
-[[geometry1][geometry which might be within the second geometry ]]
+[[geometry1][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might be within the second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[geometry2][geometry which might contain the first geometry ]]
+[[geometry2][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might contain the first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
]
@@ -10644,7 +20487,7 @@
[heading Remarks]
-The default strategy is used for within detection
+The default [link boost_geometry.reference.strategy `strategy`] is used for within detection
@@ -10656,7 +20499,7 @@
[section:overload2 within (2 of 2 overloads)]
-Within, examine if a geometry is within another geometry, using a specified strategy.
+Within, examine if a [link boost_geometry.reference.boost__geometry `boost::geometry`] is within another [link boost_geometry.reference.boost__geometry `boost::geometry`], using a specified [link boost_geometry.reference.strategy `strategy`].
template<
@@ -10675,11 +20518,11 @@
[variablelist
-[[geometry1][geometry which might be within the second geometry ]]
+[[geometry1][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might be within the second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[geometry2][geometry which might contain the first geometry ]]
+[[geometry2][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might contain the first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[strategy][strategy to be used ]]
+[[strategy][[link boost_geometry.reference.strategy `strategy`] to be used ]]
]
Modified: sandbox/geometry/libs/geometry/doc/quickbook/reference.xsl
==============================================================================
--- sandbox/geometry/libs/geometry/doc/quickbook/reference.xsl (original)
+++ sandbox/geometry/libs/geometry/doc/quickbook/reference.xsl 2010-03-13 23:30:40 EST (Sat, 13 Mar 2010)
@@ -503,6 +503,7 @@
<xsl:template name="header-requirements">
<xsl:param name="file"/>
<xsl:value-of select="$newline"/>
+
<xsl:text>[heading Requirements]</xsl:text>
<xsl:value-of select="$newline"/>
<xsl:value-of select="$newline"/>
@@ -549,6 +550,7 @@
</xsl:text>
+[heading Synopsis]
<xsl:apply-templates select="templateparamlist" mode="class-detail"/>
<xsl:text> </xsl:text>
<xsl:value-of select="@kind"/>
@@ -567,18 +569,21 @@
</xsl:for-each>
<xsl:text></xsl:text>
+
<xsl:call-template name="class-tables">
<xsl:with-param name="class-name" select="$class-name"/>
<xsl:with-param name="class-id" select="$class-id"/>
</xsl:call-template>
-<!-- [heading Class Description] -->
+[heading Description]
<xsl:apply-templates select="detaileddescription" mode="markup"/>
+
<xsl:call-template name="header-requirements">
<xsl:with-param name="file" select="$class-file"/>
</xsl:call-template>
+
<xsl:call-template name="class-members">
<xsl:with-param name="class-name" select="$class-name"/>
<xsl:with-param name="class-id" select="$class-id"/>
@@ -593,10 +598,7 @@
<xsl:template name="class-tables">
<xsl:param name="class-name"/>
<xsl:param name="class-id"/>
-<xsl:if test="
- count(
- sectiondef[@kind='public-type'] |
- innerclass[@prot='public']) > 0">
+<xsl:if test="count(sectiondef[@kind='public-type'] | innerclass[@prot='public']) > 0">
[heading Public Types]
[table
@@ -640,6 +642,7 @@
</xsl:if>
<xsl:if test="count(sectiondef[@kind='public-func' or @kind='public-static-func']) > 0">
+
[heading Public Member Functions]
[table
[[Name][Description]]
@@ -688,6 +691,7 @@
</xsl:if>
<xsl:if test="count(sectiondef[@kind='protected-func' or @kind='protected-static-func']) > 0">
+
[heading Protected Member Functions]
[table
[[Name][Description]]
@@ -736,6 +740,7 @@
</xsl:if>
<xsl:if test="count(sectiondef[@kind='public-attrib' or @kind='public-static-attrib']) > 0">
+
[heading Public Data Members]
[table
[[Name][Description]]
@@ -994,6 +999,7 @@
<xsl:text>
</xsl:text><xsl:apply-templates select="detaileddescription" mode="markup"/>
+
<xsl:if test="@kind='typedef' or @kind='friend'">
<xsl:call-template name="header-requirements">
<xsl:with-param name="file" select="$class-file"/>
@@ -1230,6 +1236,7 @@
<xsl:apply-templates select="detaileddescription" mode="markup"/>
</xsl:for-each>
+
<xsl:call-template name="header-requirements">
<xsl:with-param name="file" select="location/@file"/>
</xsl:call-template>
@@ -1277,6 +1284,7 @@
<!-- [heading NS Member Description] -->
<xsl:apply-templates select="detaileddescription" mode="markup"/>
+
<xsl:if test="$overload-count = 1">
<xsl:call-template name="header-requirements">
<xsl:with-param name="file" select="location/@file"/>
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk