diff --git a/doc/quickbook/quickref.xml b/doc/quickbook/quickref.xml index 03bb997be..3eb0555b9 100644 --- a/doc/quickbook/quickref.xml +++ b/doc/quickbook/quickref.xml @@ -362,8 +362,41 @@ + + + + + + + + Strategy Concepts + + + + + + + + boost::geometry::concept::AreaStrategy + boost::geometry::concept::CentroidStrategy + boost::geometry::concept::ConvexHullStrategy + boost::geometry::concept::PointDistanceStrategy + boost::geometry::concept::PointSegmentDistanceStrategy + + + + + boost::geometry::concept::SegmentIntersectStrategy + boost::geometry::concept::SimplifyStrategy + boost::geometry::concept::WithinStrategy + + + + + + - + @@ -379,6 +412,8 @@ Area + boost::geometry::strategy_area + boost::geometry::strategy_area boost::geometry::area_result boost::geometry::strategy::area::by_triangles diff --git a/doc/quickbook/reference.qbk b/doc/quickbook/reference.qbk index 6c0e835d0..baa704e4d 100644 --- a/doc/quickbook/reference.qbk +++ b/doc/quickbook/reference.qbk @@ -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 @@ Adds a point to another. 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 @@ The coordinates of the second point will be added to those of the first point. T [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 @@ Adds a value to each coordinate of a point. [variablelist -[[p][point ]] +[[p][[link boost_geometry.reference.point `point`] ]] [[value][value to add ]] @@ -94,7 +94,7 @@ Adds a value to each coordinate of a point. [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 @@ Appends one or more points to a linestring, ring, polygon, multi. [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 @@ Example showing area calculation of polygons built [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 @@ Calculate area of a geometry. 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 @@ the area [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 @@ Calculate area of a geometry using a specified strategy. 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. ]] ] @@ -257,6 +257,173 @@ the area [endsect] +[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] @@ -352,7 +519,7 @@ assert\_dimension, enables compile-time checking if coordinate dimensions are as [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 @@ assign two values to a 2D point [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 @@ assign two values to a 2D point [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 @@ assign center + radius to a sphere [for extension] [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 @@ assign a range of points to a linestring, ring or polygon [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 @@ The point-type of the range might be different from the point-type of the geomet [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 @@ The order is crucial. Most logical is LOWER, UPPER and sub-order LEFT, RIGHT so [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 @@ assign to a box inverse infinite 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 @@ The assign\_inverse function initialize a 2D or 3D box with large coordinates, t [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 @@ Assign a point with a point of a box or segment. [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 @@ Assign a point with a point of a box or segment. [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 @@ Assign a box or segment with the value of a point. [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 @@ Assign a box or segment with the value of a point. [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 @@ assign zero values to a box, point 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 @@ The assign\_zero function initializes a 2D or 3D point or box with coordinates o [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 @@ Class box: defines a box made of two describing points. ] -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 @@ Boxes are for selections and for calculating the envelope of geometries. Not all `` [''''»''' [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 @@ Constructor taking the minimum corner point and the maximum corner point. [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 @@ Constructor taking the minimum corner point and the maximum corner point. typedef box< point_2d > box_2d; + [heading Public Member Functions] [table [[Name][Description]] @@ -862,16 +1037,16 @@ Constructor taking the minimum corner point and the maximum corner point. [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 @@ Boxes are for selections and for calculating the envelope of geometries. Not all typedef box< point_3d > box_3d; + [heading Public Member Functions] [table [[Name][Description]] @@ -921,16 +1097,16 @@ Boxes are for selections and for calculating the envelope of geometries. Not all [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 @@ Boxes are for selections and for calculating the envelope of geometries. Not all [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 @@ Convenience 2D or 3D box (mbr) identifying tag. [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 @@ Calculate buffer (= new geometry) around specified distance of geometry. [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,13 +1201,222 @@ BOX + distance -> BOX: it is allowed that "geometry\_out" the same object as "ge [endsect] +[section:cartesian_distance cartesian_distance] + + +Encapsulate the results of distance calculation. + + + + +[heading Synopsis] + template< + typename T = double> + struct cartesian_distance + +[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 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/distance_result.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:cartesian_distance cartesian_distance::cartesian_distance] + +[indexterm2 cartesian_distance..cartesian_distance] +Constructor with a value. + + + cartesian_distance( + T const & v); + + + +[endsect] + + + +[section:operator_cast_type cartesian_distance::operator cast_type] + +[indexterm2 operator cast_type..cartesian_distance] +Automatic conversion to double or higher precision, taking squareroot if necessary. + + + operator cast_type() const; + + + +[endsect] + + + +[section:operator_lt_ cartesian_distance::operator<] + +[indexterm2 operator<..cartesian_distance] + + bool operator<( + cartesian_distance< T > const & other) const; + + + +[endsect] + + + +[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] @@ -1133,7 +1524,7 @@ Example showing centroid calculation [section:overload1 centroid (1 of 2 overloads)] -Calculate centroid using a specified strategy. +Calculate centroid using a specified [link boost_geometry.reference.strategy `strategy`]. template< @@ -1152,11 +1543,11 @@ Calculate centroid using a specified strategy. [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 @@ Calculate centroid. [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 @@ Calculate centroid. + + +[heading Synopsis] class centroid_exception : public exception + [heading Public Member Functions] [table [[Name][Description]] @@ -1222,6 +1617,9 @@ Calculate centroid. ] + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/algorithms/centroid.hpp] @@ -1259,7 +1657,7 @@ Calculate centroid. [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 @@ Clears a linestring, linear ring or polygon (exterior+interiors) or multi*. Geometry & geometry); -Generic function to clear a geometry +Generic function to clear a [link boost_geometry.reference.boost__geometry `boost::geometry`] [heading Remarks] @@ -1288,10 +1686,53 @@ points and boxes cannot be cleared, instead they can be set to zero by "assign\_ +[section:close_to_zero close_to_zero] + +[indexterm1 close_to_zero] +Utility function to check if a distance is very small. + + + template< + 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 + +[[R][the distance result type, either arithmetic or cartesian distance ]] + +] + + +[heading Parameters] + + +[variablelist + +[[value][the distance result to check ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/distance_result.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + [section:combine combine] [indexterm1 combine] -Combines a box with another geometry (box, point). +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< @@ -1306,9 +1747,9 @@ Combines a box with another geometry (box, point). [variablelist -[[Box][type of the box ]] +[[Box][type of the [link boost_geometry.reference.box `box`] ]] -[[Geometry][of second geometry, to be combined with the box ]] +[[Geometry][of second [link boost_geometry.reference.boost__geometry `boost::geometry`], to be combined with the [link boost_geometry.reference.box `box`] ]] ] @@ -1318,9 +1759,9 @@ Combines a box with another geometry (box, point). [variablelist -[[box][box to combine another geometry with, might be changed ]] +[[box][[link boost_geometry.reference.box `box`] to combine another [link boost_geometry.reference.boost__geometry `boost::geometry`] with, might be changed ]] -[[geometry][other geometry ]] +[[geometry][other [link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -1336,19 +1777,49 @@ Combines a box with another geometry (box, point). [endsect] +[section:concept__AreaStrategy concept::AreaStrategy] + + +Checks [link boost_geometry.reference.strategy `strategy`] for area. + + + + +[heading Synopsis] + template< + typename Strategy > + class AreaStrategy + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/concepts/area_concept.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + [section:concept__Box concept::Box] -[link boost_geometry.reference.concept__Box `concept::Box`] concept. +[link boost_geometry.reference.concept__Box `concept::Box`] [link boost_geometry.reference.concept `concept`]. + + +[heading Synopsis] template< typename Geometry > class Box +[heading Description] + + [heading Formal definition:] -The box concept is defined as following: +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) @@ -1367,18 +1838,48 @@ The box concept is defined as following: [*Convenience header: ][^boost/geometry.hpp] +[endsect] + +[section:concept__CentroidStrategy concept::CentroidStrategy] + + +Checks [link boost_geometry.reference.strategy `strategy`] for centroid. + + + + +[heading Synopsis] + template< + typename Strategy > + class CentroidStrategy + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/concepts/centroid_concept.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + [endsect] [section:concept__ConstBox concept::ConstBox] -[link boost_geometry.reference.concept__Box `concept::Box`] concept (const version). +[link boost_geometry.reference.concept__Box `concept::Box`] [link boost_geometry.reference.concept `concept`] (const version). + + +[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. + +[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] @@ -1392,13 +1893,19 @@ The [link boost_geometry.reference.concept__ConstBox `concept::ConstBox`] concep [section:concept__ConstLinestring concept::ConstLinestring] -[link boost_geometry.reference.concept__Linestring `concept::Linestring`] concept (const version). +[link boost_geometry.reference.concept__Linestring `concept::Linestring`] [link boost_geometry.reference.concept `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. + +[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] @@ -1412,13 +1919,19 @@ The [link boost_geometry.reference.concept__ConstLinestring `concept::ConstLines [section:concept__ConstPoint concept::ConstPoint] -point concept (const version) +[link boost_geometry.reference.point `point`] [link boost_geometry.reference.concept `concept`] (const version). + + +[heading Synopsis] 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 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] @@ -1432,13 +1945,19 @@ The [link boost_geometry.reference.concept__ConstPoint `concept::ConstPoint`] co [section:concept__ConstPolygon concept::ConstPolygon] -[link boost_geometry.reference.concept__Polygon `concept::Polygon`] concept (const version). +[link boost_geometry.reference.concept__Polygon `concept::Polygon`] [link boost_geometry.reference.concept `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. + +[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] @@ -1452,13 +1971,19 @@ The [link boost_geometry.reference.concept__ConstPolygon `concept::ConstPolygon` [section:concept__ConstRing concept::ConstRing] -(linear) ring concept (const version) +(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 @@ The ConstLinearRing concept check the same as the Geometry concept, but does not [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] @@ -1487,21 +2018,51 @@ The [link boost_geometry.reference.concept__ConstSegment `concept::ConstSegment` [*Convenience header: ][^boost/geometry.hpp] +[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 @@ The linestring concept is defined as following: [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::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::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 @@ It can then be adapted to the concept as following: [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 @@ The point concept is defined as following: -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 @@ Note that it is done like above to show the system. Users will normally use the -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: @@ -1633,21 +2200,75 @@ It uses the macro as following: [*Convenience header: ][^boost/geometry.hpp] +[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 @@ The polygon concept is defined as following: [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::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::type`>type @@ -1679,16 +2300,22 @@ to fulfil the concepts, no traits class has to be specialized to define the poin [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 @@ The ring concept is defined as following: [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::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::type @@ -1720,16 +2347,19 @@ to fulfil the concepts, no traits class has to be specialized to define the poin [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 @@ The segment concept is defined as following: [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. @@ -1753,13 +2383,85 @@ The segment concept is similar to the box concept, defining another tag. However [*Convenience header: ][^boost/geometry.hpp] +[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 @@ Checks, in compile-time, the concept of any geometry. [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 @@ Checks, in compile-time, the concept of two geometries, and if they have equal d [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 @@ Converts one geometry to another geometry. 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 @@ The convert algorithm converts one geometry, e.g. a BOX, to another geometry, e. [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 @@ In the images below the convex hull is painted in red. [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 @@ Calculate the convex hull of a geometry. [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 @@ Calculate the convex hull of a geometry. [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 @@ Calculate the convex hull of a geometry. [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 @@ Calculate the convex hull of a geometry, output-iterator version. [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 @@ Calculate the convex hull of a geometry, output-iterator version. [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 @@ This overloaded version outputs to an output iterator. In this case, nothing is [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 @@ Meta-function which defines coordinate system for any geometry. ] + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/coordinate_system.hpp] @@ -2195,11 +2903,11 @@ Meta-function which defines coordinate system for any geometry. [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 @@ All geometries tell their geometry type (point, linestring, polygon, etc) by imp [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 @@ Meta-function which defines coordinate type (int, float, double, etc) of any geo ] + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/coordinate_type.hpp] @@ -2298,11 +3012,11 @@ Meta-function which defines coordinate type (int, float, double, etc) of any geo [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 @@ All geometries tell their geometry type (point, linestring, polygon, etc) by imp [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 @@ Helper function, copies a point from a segment. [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 @@ Helper function, copies a point from a segment. [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 @@ Helper function, to avoid the same construct several times, copies a point, base [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 @@ the cross product vector 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 @@ Defines the Cartesian or rectangular coordinate system where points are defined [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 @@ Geographic coordinate system, in degree or in radian. ] -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 @@ might be moved to extensions/gis/geographic Polar coordinate system. + + +[heading Synopsis] template< typename DegreeOrRadian > struct polar @@ -2632,7 +3361,10 @@ Polar coordinate system. ] -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 @@ Defines the polar coordinate system "in which each point [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 @@ Spherical coordinate system, in degree or in radian. ] -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 @@ Defines the spherical coordinate system where points are defined in two angles a [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 @@ Meta-function returning coordinate system tag (cs family) of any geometry. ] + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/cs.hpp] @@ -2791,6 +3535,979 @@ Meta-function returning coordinate system tag (cs family) of any geometry. +[endsect] + +[section:de9im de9im] + + +Dimensionally Extended 9 Intersection Matrix. + + + + +[heading Synopsis] + struct de9im + +[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]]] + [] + ] + +] + + +[heading Public Data Members] +[table + [[Name][Description]] + + [ + [[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]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im.ee [*ee]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im.ei [*ei]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im.ib [*ib]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im.ie [*ie]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im.ii [*ii]]] + [] + ] + +] + + +[heading Description] + + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/intersection_result.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:as_char de9im::as_char] + +[indexterm2 as_char..de9im] + + static char as_char( + int v); + + + +[endsect] + + + +[section:bb de9im::bb] + +[indexterm2 bb..de9im] + + int bb; + + + +[endsect] + + + +[section:be de9im::be] + +[indexterm2 be..de9im] + + int be; + + + +[endsect] + + + +[section:bi de9im::bi] + +[indexterm2 bi..de9im] + + int bi; + + + +[endsect] + + + +[section:contains de9im::contains] + +[indexterm2 contains..de9im] + + bool contains() const; + + + +[endsect] + + + +[section:crosses de9im::crosses] + +[indexterm2 crosses..de9im] + + bool crosses() const; + + + +[endsect] + + +[section:de9im de9im::de9im] + +[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...]]`` + + +[section:overload1 de9im::de9im (1 of 2 overloads)] + + + + de9im(); + + + +[endsect] + + + +[section:overload2 de9im::de9im (2 of 2 overloads)] + + + + de9im( + int ii0, + int ib0, + int ie0, + int bi0, + int bb0, + int be0, + int ei0, + int eb0, + int ee0); + + + +[endsect] + + +[endsect] + + +[section:disjoint de9im::disjoint] + +[indexterm2 disjoint..de9im] + + bool disjoint() const; + + + +[endsect] + + + +[section:eb de9im::eb] + +[indexterm2 eb..de9im] + + int eb; + + + +[endsect] + + + +[section:ee de9im::ee] + +[indexterm2 ee..de9im] + + int ee; + + + +[endsect] + + + +[section:ei de9im::ei] + +[indexterm2 ei..de9im] + + int ei; + + + +[endsect] + + + +[section:equals de9im::equals] + +[indexterm2 equals..de9im] + + bool equals() const; + + + +[endsect] + + + +[section:ib de9im::ib] + +[indexterm2 ib..de9im] + + int ib; + + + +[endsect] + + + +[section:ie de9im::ie] + +[indexterm2 ie..de9im] + + int ie; + + + +[endsect] + + + +[section:ii de9im::ii] + +[indexterm2 ii..de9im] + + int ii; + + + +[endsect] + + + +[section:intersects de9im::intersects] + +[indexterm2 intersects..de9im] + + bool intersects() const; + + + +[endsect] + + + +[section:overlaps de9im::overlaps] + +[indexterm2 overlaps..de9im] + + bool overlaps() const; + + + +[endsect] + + + +[section:touches de9im::touches] + +[indexterm2 touches..de9im] + + bool touches() const; + + + +[endsect] + + + +[section:within de9im::within] + +[indexterm2 within..de9im] + + bool within() const; + + + +[endsect] + + + +[endsect] + +[section:de9im_segment de9im_segment] + + + + + +[heading Synopsis] + struct de9im_segment : public de9im + +[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]]] + [] + ] + +] + + +[heading Public Data Members] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.de9im_segment.bb [*bb]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.be [*be]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.bi [*bi]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.collinear [*collinear]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.degenerate [*degenerate]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.eb [*eb]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.ee [*ee]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.ei [*ei]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.ib [*ib]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.ie [*ie]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.ii [*ii]]] + [] + ] + + [ + [[link boost_geometry.reference.de9im_segment.opposite [*opposite]]] + [] + ] + + [ + [[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 Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/intersection_result.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:as_char de9im_segment::as_char] + + +['Inherited from de9im.] + +[indexterm2 as_char..de9im_segment] + + static char as_char( + int v); + + + +[endsect] + + + +[section:bb de9im_segment::bb] + + +['Inherited from de9im.] + +[indexterm2 bb..de9im_segment] + + int bb; + + + +[endsect] + + + +[section:be de9im_segment::be] + + +['Inherited from de9im.] + +[indexterm2 be..de9im_segment] + + int be; + + + +[endsect] + + + +[section:bi de9im_segment::bi] + + +['Inherited from de9im.] + +[indexterm2 bi..de9im_segment] + + int bi; + + + +[endsect] + + + +[section:collinear de9im_segment::collinear] + +[indexterm2 collinear..de9im_segment] + + bool collinear; + + + +[endsect] + + + +[section:contains de9im_segment::contains] + + +['Inherited from de9im.] + +[indexterm2 contains..de9im_segment] + + bool contains() const; + + + +[endsect] + + + +[section:crosses de9im_segment::crosses] + + +['Inherited from de9im.] + +[indexterm2 crosses..de9im_segment] + + bool crosses() const; + + + +[endsect] + + +[section:de9im_segment de9im_segment::de9im_segment] + +[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...]]`` + + +[section:overload1 de9im_segment::de9im_segment (1 of 2 overloads)] + + + + de9im_segment(); + + + +[endsect] + + + +[section:overload2 de9im_segment::de9im_segment (2 of 2 overloads)] + + + + 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); + + + +[endsect] + + +[endsect] + + +[section:degenerate de9im_segment::degenerate] + +[indexterm2 degenerate..de9im_segment] + + bool degenerate; + + + +[endsect] + + + +[section:disjoint de9im_segment::disjoint] + + +['Inherited from de9im.] + +[indexterm2 disjoint..de9im_segment] + + bool disjoint() const; + + + +[endsect] + + + +[section:eb de9im_segment::eb] + + +['Inherited from de9im.] + +[indexterm2 eb..de9im_segment] + + int eb; + + + +[endsect] + + + +[section:ee de9im_segment::ee] + + +['Inherited from de9im.] + +[indexterm2 ee..de9im_segment] + + int ee; + + + +[endsect] + + + +[section:ei de9im_segment::ei] + + +['Inherited from de9im.] + +[indexterm2 ei..de9im_segment] + + int ei; + + + +[endsect] + + + +[section:equals de9im_segment::equals] + + +['Inherited from de9im.] + +[indexterm2 equals..de9im_segment] + + bool equals() const; + + + +[endsect] + + + +[section:ib de9im_segment::ib] + + +['Inherited from de9im.] + +[indexterm2 ib..de9im_segment] + + int ib; + + + +[endsect] + + + +[section:ie de9im_segment::ie] + + +['Inherited from de9im.] + +[indexterm2 ie..de9im_segment] + + int ie; + + + +[endsect] + + + +[section:ii de9im_segment::ii] + + +['Inherited from de9im.] + +[indexterm2 ii..de9im_segment] + + int ii; + + + +[endsect] + + + +[section:intersects de9im_segment::intersects] + + +['Inherited from de9im.] + +[indexterm2 intersects..de9im_segment] + + bool intersects() const; + + + +[endsect] + + + +[section:opposite de9im_segment::opposite] + +[indexterm2 opposite..de9im_segment] + + bool opposite; + + + +[endsect] + + + +[section:overlaps de9im_segment::overlaps] + + +['Inherited from de9im.] + +[indexterm2 overlaps..de9im_segment] + + bool overlaps() const; + + + +[endsect] + + + +[section:parallel de9im_segment::parallel] + +[indexterm2 parallel..de9im_segment] + + bool parallel; + + + +[endsect] + + + +[section:ra de9im_segment::ra] + +[indexterm2 ra..de9im_segment] + + double ra; + + + +[endsect] + + + +[section:rb de9im_segment::rb] + +[indexterm2 rb..de9im_segment] + + double rb; + + + +[endsect] + + + +[section:touches de9im_segment::touches] + + +['Inherited from de9im.] + +[indexterm2 touches..de9im_segment] + + bool touches() const; + + + +[endsect] + + + +[section:within de9im_segment::within] + + +['Inherited from de9im.] + +[indexterm2 within..de9im_segment] + + bool within() const; + + + +[endsect] + + + [endsect] [section:degree degree] @@ -2799,7 +4516,13 @@ Meta-function returning coordinate system tag (cs family) of any geometry. Unit of plane angle: Degrees. + + +[heading Synopsis] class degree + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/cs.hpp] @@ -2828,7 +4551,7 @@ Unit of plane angle: Degrees. [variablelist -[[Geometry][geometry type ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] @@ -2838,7 +4561,7 @@ Unit of plane angle: Degrees. [variablelist -[[geometry][the geometry to make difference ]] +[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make difference ]] ] @@ -2857,12 +4580,18 @@ Unit of plane angle: Degrees. [section:dimension dimension] -Meta-function which defines coordinate dimensions, i.e. the number of axes of any geometry. +Meta-function which defines coordinate dimensions, i.e. the number of axes of any [link boost_geometry.reference.boost__geometry `boost::geometry`]. + + +[heading Synopsis] template< typename G > struct dimension + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/coordinate_dimension.hpp] @@ -2891,9 +4620,9 @@ Calculate if two geometries are disjoint. [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 ]] ] @@ -2903,9 +4632,9 @@ Calculate if two geometries are disjoint. [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`] ]] ] @@ -2930,7 +4659,7 @@ true if disjoint, else false [section:dissolve dissolve] [indexterm1 dissolve] -Removes self intersections from a geometry. +Removes self intersections from a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -2945,7 +4674,7 @@ Removes self intersections from a geometry. [variablelist -[[Geometry][geometry type ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] [[OutputIterator][type of intersection container (e.g. vector of "intersection/turn point"'s) ]] @@ -2957,7 +4686,7 @@ Removes self intersections from a geometry. [variablelist -[[geometry][first geometry ]] +[[geometry][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]] [[output][container which will contain intersection points ]] @@ -3045,7 +4774,7 @@ Example showing distance calculation of two points, in xy and in latlong coordin [section:overload1 distance (1 of 2 overloads)] -Calculate distance between two geometries with a specified strategy. +Calculate distance between two geometries with a specified [link boost_geometry.reference.strategy `strategy`]. template< @@ -3062,11 +4791,11 @@ Calculate distance between two geometries with a specified strategy. [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 ]] -[[S][point-point-distance strategy type ]] +[[S][point-point-distance [link boost_geometry.reference.strategy `strategy`] type ]] ] @@ -3076,23 +4805,23 @@ Calculate distance between two geometries with a specified strategy. [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][strategy to calculate distance between two points ]] +[[strategy][[link boost_geometry.reference.strategy `strategy`] to calculate distance between two points ]] ] [heading Return Value] -the distance (either a double or a distance\_result, (convertable to double)) +the distance (either a double or a [link boost_geometry.reference.distance_result `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. +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`]. [heading Example:] @@ -3124,13 +4853,13 @@ Calculate distance between two geometries. Geometry2 const & geometry2); -The default strategy is used, belonging to the corresponding coordinate system of the geometries +The default [link boost_geometry.reference.strategy `strategy`] is used, belonging to the corresponding coordinate system of the geometries [variablelist -[[G1][first geometry type ]] +[[G1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] -[[G2][second geometry type ]] +[[G2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] @@ -3140,9 +4869,9 @@ The default strategy is used, belonging to the corresponding coordinate system o [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`] ]] ] @@ -3157,13 +4886,239 @@ the distance (either a double or a distance result, convertable to double) [endsect] +[endsect] + +[section:distance_result distance_result] + + +Shortcut to define return type of distance [link boost_geometry.reference.strategy `strategy`]. + + + + +[heading Synopsis] + template< + typename ``[link boost_geometry.reference.Geometry1 Geometry1]``, + typename ``[link boost_geometry.reference.Geometry2 Geometry2]`` = Geometry1> + struct distance_result + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.distance_result.point_type1 [*point_type1]]] + [] + + ] + + [ + + [[link boost_geometry.reference.distance_result.point_type2 [*point_type2]]] + [] + + ] + + [ + + [[link boost_geometry.reference.distance_result.strategy_type [*strategy_type]]] + [] + + ] + + [ + + [[link boost_geometry.reference.distance_result.type [*type]]] + [] + + ] + +] + + +[heading Description] + + + +[variablelist + +[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]] + +[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]] + +] + + + +[heading Requirements] + +[*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; + + + +[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/distance_result.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:point_type2 distance_result::point_type2] + +[indexterm2 point_type2..distance_result] + + typedef point_type< Geometry2 >::type point_type2; + + + +[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/distance_result.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:strategy_type distance_result::strategy_type] + +[indexterm2 strategy_type..distance_result] + + typedef strategy_distance< typename cs_tag< point_type1 >::type, typename cs_tag< point_type2 >::type, point_type1, point_type2 >::type 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/distance_result.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:type distance_result::type] + +[indexterm2 type..distance_result] + + typedef strategy_type::return_type type; + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/distance_result.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + [endsect] [section:divide_point divide_point] [indexterm1 divide_point] -Divides a point by another. +Divides a [link boost_geometry.reference.point `point`] by another. template< @@ -3174,15 +5129,15 @@ Divides a point by another. Point2 const & p2); -The coordinates of the second point will be divided by those of the first point. The second point is not modified. +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 -[[p1][first point ]] +[[p1][first [link boost_geometry.reference.point `point`] ]] -[[p2][second point ]] +[[p2][second [link boost_geometry.reference.point `point`] ]] ] @@ -3202,7 +5157,7 @@ The coordinates of the second point will be divided by those of the first point. [section:divide_value divide_value] [indexterm1 divide_value] -Divides each coordinate of a point by a value. +Divides each coordinate of a [link boost_geometry.reference.point `point`] by a value. template< @@ -3218,7 +5173,7 @@ Divides each coordinate of a point by a value. [variablelist -[[p][point ]] +[[p][[link boost_geometry.reference.point `point`] ]] [[value][value to divide by ]] @@ -3257,9 +5212,9 @@ Computes the dot product (or scalar product) of 2 vectors (points). [variablelist -[[p1][first point ]] +[[p1][first [link boost_geometry.reference.point `point`] ]] -[[p2][second point ]] +[[p2][second [link boost_geometry.reference.point `point`] ]] ] @@ -3333,7 +5288,7 @@ All intersection points are enriched with successor information. [section:envelope envelope] [indexterm1 envelope] -Calculate envelope of a geometry. +Calculate envelope of a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -3350,9 +5305,9 @@ Calculate envelope of a geometry. [variablelist -[[geometry][the geometry ]] +[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] ]] -[[mbr][the box receiving the envelope ]] +[[mbr][the [link boost_geometry.reference.box `box`] receiving the envelope ]] ] @@ -3396,9 +5351,9 @@ Detect if two geometries are spatially equal. [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 ]] ] @@ -3408,9 +5363,9 @@ Detect if two geometries are spatially equal. [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`] ]] ] @@ -3434,10 +5389,16 @@ true if geometries are spatially equal, else false [section:exception exception] -Base exception class for GGL. +Base [link boost_geometry.reference.exception `exception`] class for GGL. + + +[heading Synopsis] struct exception + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/exception.hpp] @@ -3450,7 +5411,7 @@ Base exception class for GGL. [section:exterior_ring exterior_ring] [indexterm1 exterior_ring] -Function to get the exterior\_ring ring of a polygon. +Function to get the exterior\_ring ring of a [link boost_geometry.reference.polygon `polygon`]. template< @@ -3475,7 +5436,7 @@ Function to get the exterior\_ring ring of a polygon. [section:overload1 exterior_ring (1 of 2 overloads)] -Function to get the exterior\_ring ring of a polygon. +Function to get the exterior\_ring ring of a [link boost_geometry.reference.polygon `polygon`]. template< @@ -3493,7 +5454,7 @@ OGC compliance: instead of ExteriorRing [variablelist -[[P][polygon type ]] +[[P][[link boost_geometry.reference.polygon `polygon`] type ]] ] @@ -3503,7 +5464,7 @@ OGC compliance: instead of ExteriorRing [variablelist -[[polygon][the polygon to get the exterior ring from ]] +[[polygon][the [link boost_geometry.reference.polygon `polygon`] to get the exterior ring from ]] ] @@ -3522,7 +5483,7 @@ a reference to the exterior ring [section:overload2 exterior_ring (2 of 2 overloads)] -Function to get the exterior ring of a polygon (const version). +Function to get the exterior ring of a [link boost_geometry.reference.polygon `polygon`] (const version). template< @@ -3540,7 +5501,7 @@ OGC compliance: instead of ExteriorRing [variablelist -[[Polygon][polygon type ]] +[[Polygon][[link boost_geometry.reference.polygon `polygon`] type ]] ] @@ -3550,7 +5511,7 @@ OGC compliance: instead of ExteriorRing [variablelist -[[polygon][the polygon to get the exterior ring from ]] +[[polygon][the [link boost_geometry.reference.polygon `polygon`] to get the exterior ring from ]] ] @@ -3570,7 +5531,7 @@ a const reference to the exterior ring [section:for_each_point for_each_point] [indexterm1 for_each_point] -Calls functor for geometry. +Calls functor for [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -3599,7 +5560,7 @@ Calls functor for geometry. [section:overload1 for_each_point (1 of 2 overloads)] -Calls functor for geometry. +Calls functor for [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -3616,13 +5577,13 @@ Calls functor for geometry. [variablelist -[[geometry][geometry to loop through ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]] [[f][functor to use]] ] -Calls the functor the specified const geometry +Calls the functor the specified const [link boost_geometry.reference.boost__geometry `boost::geometry`] [endsect] @@ -3632,7 +5593,7 @@ Calls the functor the specified const geometry [section:overload2 for_each_point (2 of 2 overloads)] -Calls functor for geometry. +Calls functor for [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -3649,13 +5610,13 @@ Calls functor for geometry. [variablelist -[[geometry][geometry to loop through ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]] [[f][functor to use]] ] -Calls the functor for the specified geometry +Calls the functor for the specified [link boost_geometry.reference.boost__geometry `boost::geometry`] [endsect] @@ -3712,13 +5673,13 @@ Calls functor for segments on linestrings, rings, polygons, ... [variablelist -[[geometry][geometry to loop through ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]] [[f][functor to use]] ] -Calls the functor all const segments of the specified const geometry +Calls the functor all const segments of the specified const [link boost_geometry.reference.boost__geometry `boost::geometry`] [endsect] @@ -3745,13 +5706,13 @@ Calls functor for segments on linestrings, rings, polygons, ... [variablelist -[[geometry][geometry to loop through ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]] [[f][functor to use]] ] -Calls the functor all segments of the specified geometry +Calls the functor all segments of the specified [link boost_geometry.reference.boost__geometry `boost::geometry`] [endsect] @@ -3759,13 +5720,41 @@ Calls the functor all segments of the specified geometry [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/strategies/distance_result.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + [section:geographic_tag geographic_tag] Tag indicating Geographic coordinate system family (geographic). + + +[heading Synopsis] struct geographic_tag + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/tags.hpp] @@ -3778,13 +5767,19 @@ Tag indicating Geographic coordinate system family (geographic). [section:geometry_id geometry_id] -Meta-function the id for a geometry type. +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 @@ -3803,10 +5798,16 @@ Used for e.g. reverse meta-function [section:geometry_not_recognized_tag geometry_not_recognized_tag] -"default" 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] @@ -3861,9 +5862,9 @@ get coordinate value of a Point ( / Sphere) [variablelist -[[Dimension][dimension ]] +[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]] -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -3873,7 +5874,7 @@ get coordinate value of a Point ( / Sphere) [variablelist -[[geometry][geometry to query coordinate value from ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to query coordinate value from ]] ] @@ -3910,9 +5911,9 @@ get coordinate value of a Box / Segment [[Index][for Point: do not specifyfor Box: min\_corner or max\_cornerfor Segment: 0 / 1 ]] -[[Dimension][dimension ]] +[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]] -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -3922,7 +5923,7 @@ get coordinate value of a Box / Segment [variablelist -[[geometry][geometry to query coordinate value from ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to query coordinate value from ]] ] @@ -3943,7 +5944,7 @@ coordinate value [section:get_as_radian get_as_radian] [indexterm1 get_as_radian] -get coordinate value of a point, result is in Radian +get coordinate value of a [link boost_geometry.reference.point `point`], result is in Radian template< @@ -3962,9 +5963,9 @@ coordinate value [variablelist -[[Dimension][dimension ]] +[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]] -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -3974,7 +5975,7 @@ coordinate value [variablelist -[[geometry][geometry to get coordinate value from ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to get coordinate value from ]] ] @@ -3999,7 +6000,7 @@ Only applicable to coordinate systems templatized by units, e.g. spherical or ge [section:get_section get_section] [indexterm1 get_section] -Get iterators for a specified section. +Get iterators for a specified [link boost_geometry.reference.section `section`]. template< @@ -4018,7 +6019,7 @@ Get iterators for a specified section. [[Geometry][type ]] -[[Section][type of section to get from ]] +[[Section][type of [link boost_geometry.reference.section `section`] to get from ]] ] @@ -4028,13 +6029,13 @@ Get iterators for a specified section. [variablelist -[[geometry][geometry which might be located in the neighborhood ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might be located in the neighborhood ]] -[[section][structure with section ]] +[[section][structure with [link boost_geometry.reference.section `section`] ]] -[[begin][begin-iterator (const iterator over points of section) ]] +[[begin][begin-iterator (const iterator over points of [link boost_geometry.reference.section `section`]) ]] -[[end][end-iterator (const iterator over points of section) ]] +[[end][end-iterator (const iterator over points of [link boost_geometry.reference.section `section`]) ]] ] @@ -4110,9 +6111,9 @@ Calculate intersection points of two geometries. [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 ]] [[Turns][type of turn-container (e.g. vector of "intersection/turn point"'s) ]] @@ -4124,9 +6125,9 @@ Calculate intersection points of two geometries. [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`] ]] [[turns][container which will contain intersection points ]] @@ -4142,7 +6143,7 @@ Calculate intersection points of two geometries. [section:overload2 get_turns (2 of 2 overloads)] -Calculate self intersections of a geometry. +Calculate self intersections of a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -4160,7 +6161,7 @@ Calculate self intersections of a geometry. [variablelist -[[Geometry][geometry type ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] [[Turns][type of intersection container (e.g. vector of "intersection/turn point"'s) ]] @@ -4172,7 +6173,7 @@ Calculate self intersections of a geometry. [variablelist -[[geometry][geometry ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] [[turns][container which will contain intersection points ]] @@ -4189,7 +6190,7 @@ Calculate self intersections of a geometry. [section:interior_rings interior_rings] [indexterm1 interior_rings] -Function to get the interior rings of a polygon (non const version). +Function to get the interior rings of a [link boost_geometry.reference.polygon `polygon`] (non const version). template< @@ -4214,7 +6215,7 @@ Function to get the interior rings of a polygon (non const version). [section:overload1 interior_rings (1 of 2 overloads)] -Function to get the interior rings of a polygon (non const version). +Function to get the interior rings of a [link boost_geometry.reference.polygon `polygon`] (non const version). template< @@ -4232,7 +6233,7 @@ OGC compliance: instead of InteriorRingN [variablelist -[[P][polygon type ]] +[[P][[link boost_geometry.reference.polygon `polygon`] type ]] ] @@ -4242,7 +6243,7 @@ OGC compliance: instead of InteriorRingN [variablelist -[[polygon][the polygon to get the interior rings from ]] +[[polygon][the [link boost_geometry.reference.polygon `polygon`] to get the interior rings from ]] ] @@ -4261,7 +6262,7 @@ a reference to the interior rings [section:overload2 interior_rings (2 of 2 overloads)] -Function to get the interior rings of a polygon (const version). +Function to get the interior rings of a [link boost_geometry.reference.polygon `polygon`] (const version). template< @@ -4279,7 +6280,7 @@ OGC compliance: instead of InteriorRingN [variablelist -[[P][polygon type ]] +[[P][[link boost_geometry.reference.polygon `polygon`] type ]] ] @@ -4289,7 +6290,7 @@ OGC compliance: instead of InteriorRingN [variablelist -[[polygon][the polygon to get the interior rings from ]] +[[polygon][the [link boost_geometry.reference.polygon `polygon`] to get the interior rings from ]] ] @@ -4309,9 +6310,12 @@ a const reference to the interior rings [section:interior_type interior_type] -Meta-function defining container type of inner rings of (multi)polygon geometriy. +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 @@ -4329,7 +6333,10 @@ Meta-function defining container type of inner rings of (multi)polygon geometriy ] -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 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] @@ -4361,11 +6368,11 @@ the interior rings should be organized as a container (std::vector, std::deque, [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`] ]] ] @@ -4406,9 +6413,9 @@ The two input geometries are intersected and the resulting linestring(s), ring(s [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 ]] [[Collection][collection of rings, polygons (e.g. a vector or a multi\_polygon) ]] @@ -4420,9 +6427,9 @@ The two input geometries are intersected and the resulting linestring(s), ring(s [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`] ]] [[output_collection][the collection ]] @@ -4505,15 +6512,15 @@ The two input geometries are intersected and the resulting linestring(s), ring(s [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 ]] ] @@ -4523,13 +6530,13 @@ The two input geometries are intersected and the resulting linestring(s), ring(s [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 linestrings or polygons ]] -[[strategy][the strategy ]] +[[strategy][the [link boost_geometry.reference.strategy `strategy`] ]] ] @@ -4566,11 +6573,11 @@ The two input geometries are intersected and the resulting linestring(s), ring(s [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 ]] @@ -4582,9 +6589,9 @@ The two input geometries are intersected and the resulting linestring(s), ring(s [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 linestrings or polygons ]] @@ -4682,13 +6689,13 @@ Determine if there is at least one intersection (crossing or self-tangency). [heading Remarks] -This function can be called for one geometry (self-intersection) and also for two geometries (intersection) +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][geometry type ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] @@ -4698,7 +6705,7 @@ This function can be called for one geometry (self-intersection) and also for tw [variablelist -[[geometry][geometry ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -4732,9 +6739,9 @@ Determine if there is at least one intersection. [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,9 +6751,9 @@ Determine if there is at least one intersection. [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`] ]] ] @@ -4766,16 +6773,22 @@ true if there are intersection(s), else false [section:is_linear is_linear] -Meta-function defining "true" for linear types (linestring,ring), "false" for non-linear typse. +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 tag dispatching and meta-function finetuning +Used for [link boost_geometry.reference.tag `tag`] dispatching and meta-function finetuning @@ -4794,9 +6807,15 @@ Used for tag dispatching and meta-function finetuning 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] @@ -4809,12 +6828,18 @@ Meta-function defining "true" for multi geometries (multi\_point, etc). [section:is_radian is_radian] -Meta-function to verify if a coordinate system 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] @@ -4863,7 +6888,7 @@ Example showing length calculation [section:overload1 length (1 of 2 overloads)] -Calculate length of a geometry. +Calculate length of a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -4872,13 +6897,13 @@ Calculate length of a geometry. Geometry const & geometry); -The function length returns the length of a geometry, using the default distance-calculation-strategy +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 geometry, being a [link boost_geometry.reference.linestring `linestring`], vector, iterator pair, or any other boost compatible range ]] +[[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 ]] ] @@ -4901,7 +6926,7 @@ the length Example showing length calculation on a vector [section:overload2 length (2 of 2 overloads)] -Calculate length of a geometry. +Calculate length of a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -4912,15 +6937,15 @@ Calculate length of a geometry. Strategy const & strategy); -The function length returns the length of a geometry, using specified 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 geometry, being a [link boost_geometry.reference.linestring `linestring`], vector, iterator pair, or any other boost compatible range ]] +[[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][strategy to be used for distance calculations. ]] +[[strategy][[link boost_geometry.reference.strategy `strategy`] to be used for distance calculations. ]] ] @@ -4932,7 +6957,7 @@ the length [heading Example:] -Example showing length calculation using iterators and the Vincenty strategy +Example showing length calculation using iterators and the Vincenty [link boost_geometry.reference.strategy `strategy`] @@ -4944,6 +6969,93 @@ Example showing length calculation using iterators and the Vincenty 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] @@ -4952,6 +7064,9 @@ Example showing length calculation using iterators and the Vincenty strategy 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, @@ -4959,10 +7074,13 @@ A [link boost_geometry.reference.linear_ring `linear_ring`] (linear [link boost_ template< typename > class ``[link boost_geometry.reference.A A]`` = std::allocator> class linear_ring +[heading Description] + + [variablelist -[[P][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[V][optional container type, for example std::vector, std::list, std::deque ]] @@ -4984,19 +7102,25 @@ A [link boost_geometry.reference.linear_ring `linear_ring`] (linear [link boost_ [section:linestring linestring] -A linestring (named so by OGC) is a collection (default a vector) of points. +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][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[V][optional container type, for example std::vector, std::list, std::deque ]] @@ -5030,7 +7154,7 @@ A linestring (named so by OGC) is a collection (default a vector) of points. [variablelist -[[P][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[V][optional container type, for example std::vector, std::list, std::deque ]] @@ -5066,7 +7190,7 @@ A linestring (named so by OGC) is a collection (default a vector) of points. [variablelist -[[P][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[V][optional container type, for example std::vector, std::list, std::deque ]] @@ -5091,10 +7215,16 @@ A linestring (named so by OGC) is a collection (default a vector) of points. [section:linestring_tag linestring_tag] -OGC Linestring identifying 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] @@ -5107,7 +7237,7 @@ OGC Linestring identifying tag. [section:make make] [indexterm1 make] -Make a geometry. +Make a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -5154,7 +7284,7 @@ Make a geometry. [section:overload1 make (1 of 4 overloads)] -Make a geometry. +Make a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -5165,7 +7295,7 @@ Make a geometry. 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 geometry specified. +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] @@ -5174,7 +7304,7 @@ It does not work with array-point types, like int[2] [variablelist -[[G][the geometry type ]] +[[G][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] [[T][the coordinate type ]] @@ -5183,7 +7313,7 @@ It does not work with array-point types, like int[2] [heading Return Value] -the geometry +the [link boost_geometry.reference.boost__geometry `boost::geometry`] @@ -5195,7 +7325,7 @@ the geometry [section:overload2 make (2 of 4 overloads)] -Make a geometry. +Make a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -5210,7 +7340,7 @@ Make a geometry. [heading Return Value] -a 3D point +a 3D [link boost_geometry.reference.point `point`] @@ -5259,7 +7389,7 @@ a 3D point [section:make_buffer make_buffer] [indexterm1 make_buffer] -Calculate and return buffer (= new geometry) around specified distance of geometry. +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< @@ -5278,7 +7408,7 @@ Calculate and return buffer (= new geometry) around specified distance of geomet [variablelist -[[geometry][input geometry ]] +[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`] ]] [[distance][the distance used in buffer ]] @@ -5289,7 +7419,7 @@ Calculate and return buffer (= new geometry) around specified distance of geomet [heading Return Value] -the buffered geometry +the buffered [link boost_geometry.reference.boost__geometry `boost::geometry`] [heading Remarks] @@ -5356,7 +7486,7 @@ Calculate and return centroid. [variablelist -[[geometry][the geometry to calculate centroid from ]] +[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate centroid from ]] ] @@ -5375,7 +7505,7 @@ the centroid [section:overload2 make_centroid (2 of 2 overloads)] -Calculate and return centroid, using a specified strategy. +Calculate and return centroid, using a specified [link boost_geometry.reference.strategy `strategy`]. template< @@ -5393,9 +7523,9 @@ Calculate and return centroid, using a specified strategy. [variablelist -[[geometry][the geometry to calculate centroid from ]] +[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate centroid from ]] -[[strategy][Calculation strategy for centroid ]] +[[strategy][Calculation [link boost_geometry.reference.strategy `strategy`] for centroid ]] ] @@ -5413,10 +7543,61 @@ the centroid [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 geometry. +Calculate and return envelope of a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -5432,7 +7613,7 @@ Calculate and return envelope of a geometry. [variablelist -[[geometry][the geometry ]] +[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -5452,7 +7633,7 @@ Calculate and return envelope of a geometry. [section:make_inverse make_inverse] [indexterm1 make_inverse] -Create a box with inverse infinite coordinates. +Create a [link boost_geometry.reference.box `box`] with inverse infinite coordinates. template< @@ -5460,18 +7641,18 @@ Create a box with inverse infinite coordinates. Geometry make_inverse(); -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 +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 geometry type ]] +[[Geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] [heading Return Value] -the box +the [link boost_geometry.reference.box `box`] @@ -5489,7 +7670,7 @@ the box [section:make_zero make_zero] [indexterm1 make_zero] -Create a geometry with "zero" coordinates. +Create a [link boost_geometry.reference.boost__geometry `boost::geometry`] with "zero" coordinates. template< @@ -5497,18 +7678,18 @@ Create a geometry with "zero" coordinates. Geometry make_zero(); -The make\_zero function initializes a 2D or 3D point or box with coordinates of 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 geometry type ]] +[[Geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] [heading Return Value] -the geometry +the [link boost_geometry.reference.boost__geometry `boost::geometry`] @@ -5526,7 +7707,7 @@ the geometry [section:max_corner max_corner] [indexterm1 max_corner] -Index of maximum corner of the box. +Index of maximum corner of the [link boost_geometry.reference.box `box`]. const int max_corner = 1; @@ -5546,7 +7727,7 @@ Index of maximum corner of the box. [section:min_corner min_corner] [indexterm1 min_corner] -Index of minimum corner of the box. +Index of minimum corner of the [link boost_geometry.reference.box `box`]. const int min_corner = 0; @@ -5566,7 +7747,7 @@ Index of minimum corner of the box. [section:multiply_point multiply_point] [indexterm1 multiply_point] -Multiplies a point by another. +Multiplies a [link boost_geometry.reference.point `point`] by another. template< @@ -5577,15 +7758,15 @@ Multiplies a point by another. Point2 const & p2); -The coordinates of the second point will be multiplied by those of the first point. The second point is not modified. +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 point ]] +[[p1][first [link boost_geometry.reference.point `point`] ]] -[[p2][second point ]] +[[p2][second [link boost_geometry.reference.point `point`] ]] ] @@ -5610,7 +7791,7 @@ This is *not* a dot, cross or wedge product. It is a mere field-by-field multipl [section:multiply_value multiply_value] [indexterm1 multiply_value] -Multiplies each coordinate of a point by a value. +Multiplies each coordinate of a [link boost_geometry.reference.point `point`] by a value. template< @@ -5626,7 +7807,7 @@ Multiplies each coordinate of a point by a value. [variablelist -[[p][point ]] +[[p][[link boost_geometry.reference.point `point`] ]] [[value][value to multiply by ]] @@ -5648,7 +7829,7 @@ Multiplies each coordinate of a point by a value. [section:num_geometries num_geometries] [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). +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< @@ -5661,7 +7842,7 @@ Function to get the number of geometries of a composite geometry. For a single g [variablelist -[[Geometry][geometry type ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] @@ -5671,14 +7852,14 @@ Function to get the number of geometries of a composite geometry. For a single g [variablelist -[[geometry][the polygon or other geometry ]] +[[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 geometry +the number of interior rings of the [link boost_geometry.reference.boost__geometry `boost::geometry`] @@ -5696,7 +7877,7 @@ the number of interior rings of the geometry [section:num_interior_rings num_interior_rings] [indexterm1 num_interior_rings] -Function to get the number of interior rings of a polygon. +Function to get the number of interior rings of a [link boost_geometry.reference.polygon `polygon`]. template< @@ -5710,13 +7891,13 @@ Function to get the number of interior rings of a polygon. 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 +Can be used for any [link boost_geometry.reference.boost__geometry `boost::geometry`], returning 0 for geometries not having interior rings [variablelist -[[Geometry][geometry type ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] @@ -5726,14 +7907,14 @@ Can be used for any geometry, returning 0 for geometries not having interior rin [variablelist -[[geometry][the polygon or other geometry ]] +[[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 geometry +the number of interior rings of the [link boost_geometry.reference.boost__geometry `boost::geometry`] @@ -5764,7 +7945,7 @@ get number of points [variablelist -[[Geometry][geometry type ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] @@ -5774,7 +7955,7 @@ get number of points [variablelist -[[geometry][the geometry to get number of points from ]] +[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to get number of points from ]] ] @@ -5913,7 +8094,7 @@ true if there is overlap [section:overload1 parse (1 of 3 overloads)] -parse two strings to a spherical/geographic point, using W/E/N/S +parse two strings to a spherical/geographic [link boost_geometry.reference.point `point`], using W/E/N/S template< @@ -5932,7 +8113,7 @@ parse two strings to a spherical/geographic point, using W/E/N/S [section:overload2 parse (2 of 3 overloads)] -parse two strings to a spherical/geographic point, using a specified strategy +parse two strings to a spherical/geographic [link boost_geometry.reference.point `point`], using a specified [link boost_geometry.reference.strategy `strategy`] template< @@ -6013,7 +8194,7 @@ user can use N/E/S/O or N/O/Z/W or other formats [section:overload1 perimeter (1 of 2 overloads)] -Calculate perimeter of a geometry. +Calculate perimeter of a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -6022,13 +8203,13 @@ Calculate perimeter of a geometry. Geometry const & geometry); -The function perimeter returns the perimeter of a geometry, using the default distance-calculation-strategy +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 geometry, be it a geometry::ring, vector, iterator pair, or any other boost compatible range ]] +[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`], be it a geometry::ring, vector, iterator pair, or any other `boost` compatible range ]] ] @@ -6047,7 +8228,7 @@ the perimeter [section:overload2 perimeter (2 of 2 overloads)] -Calculate perimeter of a geometry. +Calculate perimeter of a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -6058,15 +8239,15 @@ Calculate perimeter of a geometry. Strategy const & strategy); -The function perimeter returns the perimeter of a geometry, using specified 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 geometry, be it a geometry::ring, vector, iterator pair, or any other boost compatible range ]] +[[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][strategy to be used for distance calculations. ]] +[[strategy][[link boost_geometry.reference.strategy `strategy`] to be used for distance calculations. ]] ] @@ -6086,9 +8267,12 @@ the perimeter [section:point point] -Basic point class, having coordinates defined in a neutral way. +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]``, @@ -6115,6 +8299,7 @@ Basic point class, having coordinates defined in a neutral way. ] + [heading Public Member Functions] [table [[Name][Description]] @@ -6138,6 +8323,7 @@ Basic point class, having coordinates defined in a neutral way. ] + [heading Public Data Members] [table [[Name][Description]] @@ -6150,12 +8336,15 @@ Basic point class, having coordinates defined in a neutral way. ] +[heading Description] + + [variablelist [[T][numeric type, for example double, float, int ]] -[[D][coordinate dimension as number of coordinates, for example 2 ]] +[[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`] ]] @@ -6334,6 +8523,7 @@ Constructs with one, or optionally two or three values. ] + [heading Public Member Functions] [table [[Name][Description]] @@ -6371,6 +8561,7 @@ Constructs with one, or optionally two or three values. ] + [heading Public Data Members] [table [[Name][Description]] @@ -6434,6 +8625,7 @@ Constructs with one, or optionally two or three values. ] + [heading Public Member Functions] [table [[Name][Description]] @@ -6457,6 +8649,7 @@ Constructs with one, or optionally two or three values. ] + [heading Public Data Members] [table [[Name][Description]] @@ -6476,7 +8669,7 @@ Constructs with one, or optionally two or three values. [[T][numeric type, for example double, float, int ]] -[[D][coordinate dimension as number of coordinates, for example 2 ]] +[[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`] ]] @@ -6498,9 +8691,12 @@ Constructs with one, or optionally two or three values. [section:point_order point_order] -Meta-function which defines point type of any geometry. +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 @@ -6518,6 +8714,7 @@ Meta-function which defines point type of any geometry. ] + [heading Public Data Members] [table [[Name][Description]] @@ -6529,6 +8726,9 @@ Meta-function which defines point type of any geometry. ] + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/point_order.hpp] @@ -6576,10 +8776,16 @@ Meta-function which defines point type of any geometry. [section:point_tag point_tag] -OGC Point identifying 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] @@ -6592,11 +8798,14 @@ OGC Point identifying tag. [section:point_type point_type] -Meta-function which defines point type of any geometry. +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 > + typename ``[link boost_geometry.reference.Geometry Geometry]``> struct point_type [heading Public Types] @@ -6619,6 +8828,9 @@ Meta-function which defines point type of any geometry. ] + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/point_type.hpp] @@ -6668,11 +8880,11 @@ Meta-function which defines point type of any geometry. [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`] ]] ] @@ -6695,9 +8907,12 @@ All geometries tell their geometry type (point, linestring, polygon, etc) by imp [section:point_xy point_xy] -2D point in Cartesian coordinate system +2D [link boost_geometry.reference.point `point`] in Cartesian coordinate system + + +[heading Synopsis] template< typename T , typename C = cs::cartesian> @@ -6723,6 +8938,7 @@ All geometries tell their geometry type (point, linestring, polygon, etc) by imp ] + [heading Public Member Functions] [table [[Name][Description]] @@ -6760,6 +8976,7 @@ All geometries tell their geometry type (point, linestring, polygon, etc) by imp ] + [heading Public Data Members] [table [[Name][Description]] @@ -6772,6 +8989,9 @@ All geometries tell their geometry type (point, linestring, polygon, etc) by imp ] +[heading Description] + + [variablelist @@ -6856,7 +9076,7 @@ All geometries tell their geometry type (point, linestring, polygon, etc) by imp Compile time access to coordinate values. - T const & get() const; + Tconst & get() const; @@ -6922,7 +9142,7 @@ Constructor with x/y values. [indexterm2 set..point_xy] void set( - T value); + Tvalue ); @@ -7031,9 +9251,12 @@ Set y-value. [section:polygon polygon] -The polygon contains an outer ring and zero or more inner rings. +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, @@ -7070,6 +9293,7 @@ The polygon contains an outer ring and zero or more inner rings. ] + [heading Public Member Functions] [table [[Name][Description]] @@ -7092,10 +9316,13 @@ The polygon contains an outer ring and zero or more inner rings. ] +[heading Description] + + [variablelist -[[P][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[PointList][optional container type for points, for example std::vector, std::list, std::deque ]] @@ -7150,7 +9377,7 @@ Utility method, clears outer and inner rings. [variablelist -[[P][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[V][optional container type, for example std::vector, std::list, std::deque ]] @@ -7276,7 +9503,7 @@ Utility method, clears outer and inner rings. [variablelist -[[P][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[V][optional container type, for example std::vector, std::list, std::deque ]] @@ -7336,6 +9563,7 @@ Utility method, clears outer and inner rings. ] + [heading Public Member Functions] [table [[Name][Description]] @@ -7363,7 +9591,7 @@ Utility method, clears outer and inner rings. [variablelist -[[P][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[PointList][optional container type for points, for example std::vector, std::list, std::deque ]] @@ -7431,6 +9659,7 @@ The container collecting the points in the rings can be different from the conta ] + [heading Public Member Functions] [table [[Name][Description]] @@ -7458,7 +9687,7 @@ The container collecting the points in the rings can be different from the conta [variablelist -[[P][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[PointList][optional container type for points, for example std::vector, std::list, std::deque ]] @@ -7493,10 +9722,16 @@ The container collecting the points in the rings can be different from the conta [section:polygon_tag polygon_tag] -OGC Polygon identifying 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] @@ -7512,7 +9747,13 @@ OGC Polygon identifying tag. Unit of plane angle: Radians. + + +[heading Synopsis] class radian + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/cs.hpp] @@ -7526,10 +9767,16 @@ Unit of plane angle: Radians. + + +[heading Synopsis] template< typename Geometry , typename NewPointType > struct replace_point_type + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/replace_point_type.hpp] @@ -7554,7 +9801,7 @@ Unit of plane angle: Radians. [variablelist -[[Geometry][geometry type ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] @@ -7564,7 +9811,7 @@ Unit of plane angle: Radians. [variablelist -[[geometry][the geometry to make reverse ]] +[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make reverse ]] ] @@ -7584,10 +9831,16 @@ Unit of plane angle: Radians. + + +[heading Synopsis] template< typename Geometry1 , typename Geometry2 > struct reverse_dispatch + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/reverse_dispatch.hpp] @@ -7611,7 +9864,7 @@ Unit of plane angle: Radians. [variablelist -[[P][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[V][optional container type, for example std::vector, std::list, std::deque ]] @@ -7646,7 +9899,7 @@ Unit of plane angle: Radians. [variablelist -[[P][point type ]] +[[P][[link boost_geometry.reference.point `point`] type ]] [[V][optional container type, for example std::vector, std::list, std::deque ]] @@ -7670,10 +9923,16 @@ Unit of plane angle: Radians. [section:ring_tag ring_tag] -Convenience (linear) ring identifying 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] @@ -7686,9 +9945,12 @@ Convenience (linear) ring identifying tag. [section:ring_type ring_type] -Meta-function which defines ring type of (multi)polygon geometry. +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 @@ -7706,7 +9968,10 @@ Meta-function which defines ring type of (multi)polygon geometry. ] -a polygon contains one exterior ring and zero or more interior rings (holes). This meta function retrieves the type of the rings + +[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. @@ -7743,11 +10008,11 @@ Exterior ring and interior rings must have the same ring-type. [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`] ]] ] @@ -7770,9 +10035,12 @@ All geometries tell their geometry type (point, linestring, polygon, etc) by imp [section:section section] -Structure containing section information. +Structure containing [link boost_geometry.reference.section `section`] information. + + +[heading Synopsis] template< typename Box , std::size_t ``[link boost_geometry.reference.DimensionCount DimensionCount]``> @@ -7791,6 +10059,7 @@ Structure containing section information. ] + [heading Public Member Functions] [table [[Name][Description]] @@ -7802,6 +10071,7 @@ Structure containing section information. ] + [heading Public Data Members] [table [[Name][Description]] @@ -7863,7 +10133,10 @@ Structure containing section information. ] -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] + +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`] @@ -7871,7 +10144,7 @@ Section information consists of a bounding box, direction information (if it is [[Box][box-type ]] -[[DimensionCount][number of dimensions for this section ]] +[[DimensionCount][number of dimensions for this [link boost_geometry.reference.section `section`] ]] ] @@ -8053,7 +10326,7 @@ Section information consists of a bounding box, direction information (if it is [section:sectionalize sectionalize] [indexterm1 sectionalize] -Split a geometry into monotonic sections. +Split a [link boost_geometry.reference.boost__geometry `boost::geometry`] into monotonic [link boost_geometry.reference.sections `sections`]. template< @@ -8068,9 +10341,9 @@ Split a geometry into monotonic sections. [variablelist -[[Geometry][type of geometry to check ]] +[[Geometry][type of [link boost_geometry.reference.boost__geometry `boost::geometry`] to check ]] -[[Sections][type of sections to create ]] +[[Sections][type of [link boost_geometry.reference.sections `sections`] to create ]] ] @@ -8080,9 +10353,9 @@ Split a geometry into monotonic sections. [variablelist -[[geometry][geometry to create sections from ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to create [link boost_geometry.reference.sections `sections`] from ]] -[[sections][structure with sections ]] +[[sections][structure with [link boost_geometry.reference.sections `sections`] ]] ] @@ -8101,9 +10374,12 @@ Split a geometry into monotonic sections. [section:sections sections] -Structure containing a collection of 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]``> @@ -8122,6 +10398,7 @@ Structure containing a collection of sections. ] + [heading Public Data Members] [table [[Name][Description]] @@ -8134,6 +10411,9 @@ Structure containing a collection of sections. ] +[heading Description] + + [heading Remarks] Derived from a vector, proves to be faster than of deque @@ -8185,12 +10465,16 @@ vector might be templated in the future [section:segment segment] -Class segment: small class containing two (templatized) point references. +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]] @@ -8202,6 +10486,7 @@ Class segment: small class containing two (templatized) point references. ] + [heading Public Data Members] [table [[Name][Description]] @@ -8218,7 +10503,10 @@ Class segment: small class containing two (templatized) point references. ] -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 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. @@ -8233,7 +10521,7 @@ We cannot derive from std::pair because of reference assignments. [variablelist -[[ConstOrNonConstPoint][point type of the segment, maybe a point or a const point ]] +[[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`] ]] ] @@ -8294,6 +10582,7 @@ We cannot derive from std::pair because of reference assignments. typedef segment< point_2d > segment_2d; + [heading Public Member Functions] [table [[Name][Description]] @@ -8305,6 +10594,7 @@ We cannot derive from std::pair because of reference assignments. ] + [heading Public Data Members] [table [[Name][Description]] @@ -8323,7 +10613,7 @@ We cannot derive from std::pair because of reference assignments. [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. +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. @@ -8338,7 +10628,7 @@ We cannot derive from std::pair because of reference assignments. [variablelist -[[ConstOrNonConstPoint][point type of the segment, maybe a point or a const point ]] +[[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`] ]] ] @@ -8359,7 +10649,11 @@ We cannot derive from std::pair because of reference assignments. + + +[heading Synopsis] struct segment_identifier + [heading Public Member Functions] [table [[Name][Description]] @@ -8381,6 +10675,7 @@ We cannot derive from std::pair because of reference assignments. ] + [heading Public Data Members] [table [[Name][Description]] @@ -8407,6 +10702,9 @@ We cannot derive from std::pair because of reference assignments. ] + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/algorithms/overlay/segment_identifier.hpp] @@ -8532,15 +10830,141 @@ We cannot derive from std::pair because of reference assignments. +[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 segment (2-points) identifying 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] @@ -8598,9 +11022,9 @@ set coordinate value of a Point ( / Sphere) [variablelist -[[Dimension][dimension ]] +[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]] -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -8610,7 +11034,7 @@ set coordinate value of a Point ( / Sphere) [variablelist -[[geometry][geometry to assign coordinate to ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to assign coordinate to ]] [[value][coordinate value to assign ]] @@ -8645,9 +11069,9 @@ set coordinate value of a Box / Segment [[Index][for Point: do not specifyfor Box: min\_corner or max\_cornerfor Segment: 0 / 1 ]] -[[Dimension][dimension ]] +[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]] -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -8657,7 +11081,7 @@ set coordinate value of a Box / Segment [variablelist -[[geometry][geometry to assign coordinate to ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to assign coordinate to ]] [[value][coordinate value to assign ]] @@ -8675,7 +11099,7 @@ set coordinate value of a Box / Segment [section:set_from_radian set_from_radian] [indexterm1 set_from_radian] -set coordinate value (in radian) to a point +set coordinate value (in [link boost_geometry.reference.radian `radian`]) to a [link boost_geometry.reference.point `point`] template< @@ -8686,15 +11110,15 @@ set coordinate value (in radian) to a point const typename coordinate_type< Geometry >::type & radians); -Coordinate value will be set correctly, if coordinate system of point is in Degree, Radian value will be converted to Degree +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][dimension ]] +[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]] -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -8704,7 +11128,7 @@ Coordinate value will be set correctly, if coordinate system of point is in Degr [variablelist -[[geometry][geometry to assign coordinate to ]] +[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to assign coordinate to ]] [[radians][coordinate value to assign ]] @@ -8727,6 +11151,167 @@ Only applicable to coordinate systems templatized by units, e.g. spherical or ge [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] @@ -8805,7 +11390,7 @@ simplifying a valid simple polygon (which never intersects itself) might result [section:overload1 simplify (1 of 2 overloads)] -Simplify a geometry using a specified strategy. +Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`] using a specified [link boost_geometry.reference.strategy `strategy`]. template< @@ -8824,13 +11409,13 @@ Simplify a geometry using a specified strategy. [variablelist -[[geometry][input geometry, to be simplified ]] +[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]] -[[out][output geometry, simplified version of the input geometry ]] +[[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 strategy to be used for simplification, might include point-distance strategy ]] +[[strategy][simplify [link boost_geometry.reference.strategy `strategy`] to be used for simplification, might include point-distance [link boost_geometry.reference.strategy `strategy`] ]] ] @@ -8844,7 +11429,7 @@ Simplify a geometry using a specified strategy. [section:overload2 simplify (2 of 2 overloads)] -Simplify a geometry. +Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`]. template< @@ -8858,7 +11443,7 @@ Simplify a geometry. [heading Remarks] -This version of simplify simplifies a geometry using the default strategy (Douglas Peucker), +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] @@ -8866,9 +11451,9 @@ This version of simplify simplifies a geometry using the default strategy (Dougl [variablelist -[[geometry][input geometry, to be simplified ]] +[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]] -[[out][output geometry, simplified version of the input geometry ]] +[[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 ]] @@ -8894,7 +11479,7 @@ The simplify algorithm can be used as following: [section:simplify_inserter simplify_inserter] [indexterm1 simplify_inserter] -Simplify a geometry, using an output iterator and a specified strategy. +Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`], using an output iterator and a specified [link boost_geometry.reference.strategy `strategy`]. template< @@ -8927,7 +11512,7 @@ Simplify a geometry, using an output iterator and a specified strategy. [section:overload1 simplify_inserter (1 of 2 overloads)] -Simplify a geometry, using an output iterator and a specified strategy. +Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`], using an output iterator and a specified [link boost_geometry.reference.strategy `strategy`]. template< @@ -8947,20 +11532,20 @@ Simplify a geometry, using an output iterator and a specified strategy. [variablelist -[[geometry][input geometry, to be simplified ]] +[[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 strategy to be used for simplification, might include point-distance strategy ]] +[[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 strategy is used as following: +simplify\_inserter with [link boost_geometry.reference.strategy `strategy`] is used as following: @@ -8976,7 +11561,7 @@ simplify\_inserter with strategy is used as following: [section:overload2 simplify_inserter (2 of 2 overloads)] -Simplify a geometry, using an output iterator. +Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`], using an output iterator. template< @@ -8994,7 +11579,7 @@ Simplify a geometry, using an output iterator. [variablelist -[[geometry][input geometry, to be simplified ]] +[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]] [[out][output iterator, outputs all simplified points ]] @@ -9016,7 +11601,13 @@ Simplify a geometry, using an output iterator. Tag indicating Spherical coordinate system family (spherical,celestial,...). + + +[heading Synopsis] struct spherical_tag + +[heading Description] + [heading Requirements] [*Header: ][^boost/geometry/core/tags.hpp] @@ -9024,6 +11615,2483 @@ Tag indicating Spherical coordinate system family (spherical,celestial,...). [*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::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] @@ -9032,10 +14100,14 @@ Tag indicating Spherical coordinate system family (spherical,celestial,...). Strategy: line clipping algorithm after Liang Barsky. + + +[heading Synopsis] template< typename Box , typename Point > class liang_barsky + [heading Public Member Functions] [table [[Name][Description]] @@ -9052,11 +14124,14 @@ Strategy: line clipping algorithm after Liang Barsky. ] -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 + +[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 box type of clipping box ]] +[[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 ]] @@ -9067,7 +14142,7 @@ The Liang-Barsky line clipping algorithm clips a line with a clipping box. It is The algorithm is currently only implemented for 2D Cartesian points -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 +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 @@ -9119,13 +14194,4671 @@ Barend Gehrels, and the following recourses +[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); + + + +[endsect] + + + +[endsect] + +[section:strategy__simplify__douglas_peucker strategy::simplify::douglas_peucker] + + +Implements the [link boost_geometry.reference.strategy__simplify `strategy::simplify`] algorithm. + + + + +[heading Synopsis] + template< + typename Point , + typename PointDistanceStrategy > + class douglas_peucker + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy__simplify__douglas_peucker.distance_strategy_type [*distance_strategy_type]]] + [] + + ] + +] + + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__simplify__douglas_peucker.apply [*apply]]] + [] + ] + +] + + +[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 + +[[Point][the [link boost_geometry.reference.point `point`] type ]] + +[[PointDistanceStrategy][point-segment [link boost_geometry.reference.strategy__distance `strategy::distance`] [link boost_geometry.reference.strategy `strategy`] to be used ]] + +] + + +[heading Remarks] + +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 + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::simplify::douglas_peucker::apply] + +[indexterm2 apply..strategy::simplify::douglas_peucker] + + template< + typename Range , + typename OutputIterator > + static OutputIterator apply( + Range const & range, + OutputIterator out, + double max_distance); + + + +[endsect] + + + +[section:distance_strategy_type strategy::simplify::douglas_peucker::distance_strategy_type] + +[indexterm2 distance_strategy_type..strategy::simplify::douglas_peucker] + + typedef PointDistanceStrategy distance_strategy_type; + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy__transform__copy_direct strategy::transform::copy_direct] + + +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 P > + struct copy_direct + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__copy_direct.apply [*apply]]] + [] + ] + +] + + +[heading Description] + + + +[variablelist + +[[P][[link boost_geometry.reference.point `point`] type ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/strategy_transform.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::transform::copy_direct::apply] + +[indexterm2 apply..strategy::transform::copy_direct] + + bool apply( + P const & p1, + P & p2) const; + + + +[endsect] + + + +[endsect] + +[section:strategy__transform__copy_per_coordinate strategy::transform::copy_per_coordinate] + + +Transformation [link boost_geometry.reference.strategy `strategy`] to do copy a [link boost_geometry.reference.point `point`], copying per coordinate. + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 > + struct copy_per_coordinate + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__copy_per_coordinate.apply [*apply]]] + [] + ] + +] + + +[heading Description] + + + +[variablelist + +[[P1][first [link boost_geometry.reference.point `point`] type ]] + +[[P2][second [link boost_geometry.reference.point `point`] type ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/strategy_transform.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::transform::copy_per_coordinate::apply] + +[indexterm2 apply..strategy::transform::copy_per_coordinate] + + bool apply( + P1 const & p1, + P2 & p2) const; + + + +[endsect] + + + +[endsect] + +[section:strategy__transform__degree_radian_vv strategy::transform::degree_radian_vv] + + +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. + + + + +[heading Synopsis] + template< + 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] + + + +[variablelist + +[[P1][first [link boost_geometry.reference.point `point`] type ]] + +[[P2][second [link boost_geometry.reference.point `point`] type ]] + +[[F][additional functor to divide or multiply with d2r ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/strategy_transform.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::transform::degree_radian_vv::apply] + +[indexterm2 apply..strategy::transform::degree_radian_vv] + + bool apply( + P1 const & p1, + P2 & p2) const; + + + +[endsect] + + + +[endsect] + +[section:strategy__transform__degree_radian_vv_3 strategy::transform::degree_radian_vv_3] + + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 , + template< typename > class ``[link boost_geometry.reference.F F]``> + struct degree_radian_vv_3 + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__degree_radian_vv_3.apply [*apply]]] + [] + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/strategy_transform.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::transform::degree_radian_vv_3::apply] + +[indexterm2 apply..strategy::transform::degree_radian_vv_3] + + bool apply( + P1 const & p1, + P2 & p2) const; + + + +[endsect] + + + +[endsect] + +[section:strategy__transform__from_cartesian_3_to_spherical_2 strategy::transform::from_cartesian_3_to_spherical_2] + + +Transformation [link boost_geometry.reference.strategy `strategy`] for 3D cartesian (x,y,z) to 2D spherical (phi,theta). + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 > + struct from_cartesian_3_to_spherical_2 + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__from_cartesian_3_to_spherical_2.apply [*apply]]] + [] + ] + +] + + +[heading Description] + +on Unit sphere + + + +[variablelist + +[[P1][first [link boost_geometry.reference.point `point`] type ]] + +[[P2][second [link boost_geometry.reference.point `point`] type ]] + +] + + +[heading Remarks] + +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/strategies/strategy_transform.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[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; + + + +[endsect] + + + +[endsect] + +[section:strategy__transform__from_cartesian_3_to_spherical_3 strategy::transform::from_cartesian_3_to_spherical_3] + + +Transformation [link boost_geometry.reference.strategy `strategy`] for 3D cartesian (x,y,z) to 3D spherical (phi,theta,r). + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 > + struct from_cartesian_3_to_spherical_3 + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__from_cartesian_3_to_spherical_3.apply [*apply]]] + [] + ] + +] + + +[heading Description] + + + +[variablelist + +[[P1][first [link boost_geometry.reference.point `point`] type ]] + +[[P2][second [link boost_geometry.reference.point `point`] type ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/strategy_transform.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::transform::from_cartesian_3_to_spherical_3::apply] + +[indexterm2 apply..strategy::transform::from_cartesian_3_to_spherical_3] + + bool apply( + P1 const & p1, + P2 & p2) const; + + + +[endsect] + + + +[endsect] + +[section:strategy__transform__from_spherical_2_to_cartesian_3 strategy::transform::from_spherical_2_to_cartesian_3] + + +Transformation [link boost_geometry.reference.strategy `strategy`] for 2D spherical (phi,theta) to 3D cartesian (x,y,z). + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 > + struct from_spherical_2_to_cartesian_3 + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__from_spherical_2_to_cartesian_3.apply [*apply]]] + [] + ] + +] + + +[heading Description] + +on Unit sphere + + + +[variablelist + +[[P1][first [link boost_geometry.reference.point `point`] type ]] + +[[P2][second [link boost_geometry.reference.point `point`] type ]] + +] + + + +[heading Requirements] + +[*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] + + + +[endsect] + +[section:strategy__transform__from_spherical_3_to_cartesian_3 strategy::transform::from_spherical_3_to_cartesian_3] + + +Transformation [link boost_geometry.reference.strategy `strategy`] for 3D spherical (phi,theta,r) to 3D cartesian (x,y,z). + + + + +[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 Description] + + + +[variablelist + +[[P1][first [link boost_geometry.reference.point `point`] type ]] + +[[P2][second [link boost_geometry.reference.point `point`] type ]] + +] + + + +[heading Requirements] + +[*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] + + + +[endsect] + +[section:strategy__transform__inverse_transformer strategy::transform::inverse_transformer] + + +Transformation [link boost_geometry.reference.strategy `strategy`] to do an inverse ransformation in Cartesian system. + + + + +[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]] + + [ + + [[link boost_geometry.reference.strategy__transform__inverse_transformer.T [*T]]] + [] + + ] + +] + + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__inverse_transformer.inverse_transformer [*inverse_transformer]]] + [] + ] + +] + + +[heading Description] + + + +[variablelist + +[[P1][first [link boost_geometry.reference.point `point`] type ]] + +[[P2][second [link boost_geometry.reference.point `point`] type ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform/inverse_transformer.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:T strategy::transform::inverse_transformer::T] + +[indexterm2 T..strategy::transform::inverse_transformer] + + typedef select_coordinate_type< P1, P2 >::type T; + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform/inverse_transformer.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:inverse_transformer strategy::transform::inverse_transformer::inverse_transformer] + +[indexterm2 inverse_transformer..strategy::transform::inverse_transformer] + + template< + typename MatrixType > + inverse_transformer( + const MatrixType & input); + + + +[endsect] + + + +[endsect] + +[section:strategy__transform__map_transformer strategy::transform::map_transformer] + + +Transformation [link boost_geometry.reference.strategy `strategy`] to do map from one to another Cartesian system. + + + + +[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::type::value, + std::size_t ``[link boost_geometry.reference.Dimension2 Dimension2]`` = dimension::type::value> + struct map_transformer : public strategy::transform::ublas_transformer< P1, P2, Dimension1, Dimension2 > + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy__transform__map_transformer.M [*M]]] + [] + + ] + + [ + + [[link boost_geometry.reference.strategy__transform__map_transformer.T [*T]]] + [] + + ] + +] + + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[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/strategies/transform/map_transformer.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:M strategy::transform::map_transformer::M] + +[indexterm2 M..strategy::transform::map_transformer] + + typedef boost::numeric::ublas::matrix< T > M; + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform/map_transformer.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[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/strategies/transform/map_transformer.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + +[section:map_transformer strategy::transform::map_transformer::map_transformer] + +[indexterm2 map_transformer..strategy::transform::map_transformer] + + template< + 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 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 B , + typename D > + map_transformer( + B const & box, + D const & width, + D const & height); + + + +[endsect] + + + +[section:overload2 strategy::transform::map_transformer::map_transformer (2 of 2 overloads)] + + + + template< + 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:strategy__transform__rotate_transformer strategy::transform::rotate_transformer] + + +Strategy of rotate transformation in Cartesian system. + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 , + typename DegreeOrRadian > + struct rotate_transformer + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy__transform__rotate_transformer.angle_type [*angle_type]]] + [] + + ] + +] + + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__rotate_transformer.rotate_transformer [*rotate_transformer]]] + [] + ] + +] + + +[heading Description] + +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 ]] + +[[P2][second [link boost_geometry.reference.point `point`] type ]] + +[[DegreeOrRadian][degree/or/radian, type of rotation angle specification ]] + +] + + +[heading Remarks] + +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. + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[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/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:rotate_transformer strategy::transform::rotate_transformer::rotate_transformer] + +[indexterm2 rotate_transformer..strategy::transform::rotate_transformer] + + rotate_transformer( + angle_type const & angle); + + + +[endsect] + + + +[endsect] + +[section:strategy__transform__scale_transformer strategy::transform::scale_transformer] + + +Strategy of scale transformation in Cartesian system. + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 = P1, + std::size_t ``[link boost_geometry.reference.Dimension1 Dimension1]`` = geometry::dimension::type::value, + std::size_t ``[link boost_geometry.reference.Dimension2 Dimension2]`` = geometry::dimension::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. + + +[variablelist + +[[P1][first [link boost_geometry.reference.point `point`] type ]] + +[[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 Requirements] + +[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + +[section:strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_ strategy::transform::scale_transformer< P1, P2, 2, 2 >] + + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 > + struct scale_transformer< P1, P2, 2, 2 > : public strategy::transform::ublas_transformer< P1, P2, 2, 2 > + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[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.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.apply [*apply]]] + [] + ] + + [ + [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.matrix [*matrix]]] + [] + ] + + [ + [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.scale_transformer [*scale_transformer]]] + [] + ] + +] + +[heading Protected Data Members] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_2,_2__gt_.m_matrix [*m_matrix]]] + [] + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::transform::scale_transformer< P1, P2, 2, 2 >::apply] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 apply..strategy::transform::scale_transformer< P1, P2, 2, 2 >] + + bool apply( + P1 const & p1, + P2 & p2) const; + + + +[endsect] + + + +[section:coordinate_type strategy::transform::scale_transformer< P1, P2, 2, 2 >::coordinate_type] + +[indexterm2 coordinate_type..strategy::transform::scale_transformer< P1, P2, 2, 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:m_matrix strategy::transform::scale_transformer< P1, P2, 2, 2 >::m_matrix] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 m_matrix..strategy::transform::scale_transformer< P1, P2, 2, 2 >] + + matrix_type m_matrix; + + + +[endsect] + + + +[section:matrix strategy::transform::scale_transformer< P1, P2, 2, 2 >::matrix] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 matrix..strategy::transform::scale_transformer< P1, P2, 2, 2 >] + + matrix_type const & matrix() const; + + + +[endsect] + + +[section:scale_transformer strategy::transform::scale_transformer< P1, P2, 2, 2 >::scale_transformer] + +[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:overload1 strategy::transform::scale_transformer< P1, P2, 2, 2 >::scale_transformer (1 of 2 overloads)] + + + + scale_transformer( + coordinate_type const & scale_x, + coordinate_type const & scale_y, + coordinate_type const & dummy = 0); + + + +[endsect] + + + +[section:overload2 strategy::transform::scale_transformer< P1, P2, 2, 2 >::scale_transformer (2 of 2 overloads)] + + + + 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 >] + + + + + +[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 + [[Name][Description]] + + [ + + [[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.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.apply [*apply]]] + [] + ] + + [ + [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.matrix [*matrix]]] + [] + ] + + [ + [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.scale_transformer [*scale_transformer]]] + [] + ] + +] + +[heading Protected Data Members] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__scale_transformer_lt__P1,_P2,_3,_3__gt_.m_matrix [*m_matrix]]] + [] + ] + +] + + +[heading Description] + +[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] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 apply..strategy::transform::scale_transformer< P1, P2, 3, 3 >] + + bool apply( + P1 const & p1, + P2 & p2) const; + + + +[endsect] + + + +[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 Requirements] + +[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:m_matrix strategy::transform::scale_transformer< P1, P2, 3, 3 >::m_matrix] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 m_matrix..strategy::transform::scale_transformer< P1, P2, 3, 3 >] + + matrix_type m_matrix; + + + +[endsect] + + + +[section:matrix strategy::transform::scale_transformer< P1, P2, 3, 3 >::matrix] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 matrix..strategy::transform::scale_transformer< P1, P2, 3, 3 >] + + matrix_type const & matrix() const; + + + +[endsect] + + +[section:scale_transformer strategy::transform::scale_transformer< P1, P2, 3, 3 >::scale_transformer] + +[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...]]`` + + ``[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...]]`` + + +[section:overload1 strategy::transform::scale_transformer< P1, P2, 3, 3 >::scale_transformer (1 of 2 overloads)] + + + + scale_transformer( + coordinate_type const & scale_x, + coordinate_type const & scale_y, + coordinate_type const & scale_z); + + + +[endsect] + + + +[section:overload2 strategy::transform::scale_transformer< P1, P2, 3, 3 >::scale_transformer (2 of 2 overloads)] + + + + scale_transformer( + coordinate_type const & scale); + + + +[endsect] + + +[endsect] + + +[endsect] + +[section:strategy__transform__translate_transformer strategy::transform::translate_transformer] + + +Strategy of translate transformation in Cartesian system. + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 , + std::size_t ``[link boost_geometry.reference.Dimension1 Dimension1]`` = geometry::dimension::type::value, + std::size_t ``[link boost_geometry.reference.Dimension2 Dimension2]`` = geometry::dimension::type::value> + struct translate_transformer + +[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. + + +[variablelist + +[[P1][first [link boost_geometry.reference.point `point`] type ]] + +[[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 Requirements] + +[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + +[section:strategy__transform__translate_transformer_lt__P1,_P2,_2,_2__gt_ strategy::transform::translate_transformer< P1, P2, 2, 2 >] + + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 > + struct translate_transformer< P1, P2, 2, 2 > : public strategy::transform::ublas_transformer< P1, P2, 2, 2 > + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[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.strategy__transform__translate_transformer_lt__P1,_P2,_2,_2__gt_.m_matrix [*m_matrix]]] + [] + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::transform::translate_transformer< P1, P2, 2, 2 >::apply] + + +['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/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:m_matrix strategy::transform::translate_transformer< P1, P2, 2, 2 >::m_matrix] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 m_matrix..strategy::transform::translate_transformer< P1, P2, 2, 2 >] + + matrix_type m_matrix; + + + +[endsect] + + + +[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; + + + +[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] + + + +[endsect] + +[section:strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_ strategy::transform::translate_transformer< P1, P2, 3, 3 >] + + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 > + struct translate_transformer< P1, P2, 3, 3 > : public strategy::transform::ublas_transformer< P1, P2, 3, 3 > + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[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.strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_.apply [*apply]]] + [] + ] + + [ + [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_.matrix [*matrix]]] + [] + ] + + [ + [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_.translate_transformer [*translate_transformer]]] + [] + ] + +] + +[heading Protected Data Members] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__translate_transformer_lt__P1,_P2,_3,_3__gt_.m_matrix [*m_matrix]]] + [] + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::transform::translate_transformer< P1, P2, 3, 3 >::apply] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 apply..strategy::transform::translate_transformer< P1, P2, 3, 3 >] + + bool apply( + P1 const & p1, + P2 & p2) const; + + + +[endsect] + + + +[section:coordinate_type strategy::transform::translate_transformer< P1, P2, 3, 3 >::coordinate_type] + +[indexterm2 coordinate_type..strategy::transform::translate_transformer< P1, P2, 3, 3 >] + + 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:m_matrix strategy::transform::translate_transformer< P1, P2, 3, 3 >::m_matrix] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 m_matrix..strategy::transform::translate_transformer< P1, P2, 3, 3 >] + + matrix_type m_matrix; + + + +[endsect] + + + +[section:matrix strategy::transform::translate_transformer< P1, P2, 3, 3 >::matrix] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 matrix..strategy::transform::translate_transformer< P1, P2, 3, 3 >] + + matrix_type const & matrix() const; + + + +[endsect] + + + +[section:translate_transformer strategy::transform::translate_transformer< P1, P2, 3, 3 >::translate_transformer] + +[indexterm2 translate_transformer..strategy::transform::translate_transformer< P1, P2, 3, 3 >] + + translate_transformer( + coordinate_type const & translate_x, + coordinate_type const & translate_y, + coordinate_type const & translate_z); + + + +[endsect] + + + +[endsect] + +[section:strategy__transform__ublas_transformer strategy::transform::ublas_transformer] + + +Affine transformation [link boost_geometry.reference.strategy `strategy`] in Cartesian system. + + + + +[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] + +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) ]] + +[[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 ]] + +] + + + +[heading Requirements] + +[*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 >] + + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 > + class ublas_transformer< P1, P2, 2, 2 > + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[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]]] + [] + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::transform::ublas_transformer< P1, P2, 2, 2 >::apply] + +[indexterm2 apply..strategy::transform::ublas_transformer< P1, P2, 2, 2 >] + + bool apply( + P1 const & p1, + P2 & p2) const; + + + +[endsect] + + + +[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] + + + +[section:matrix strategy::transform::ublas_transformer< P1, P2, 2, 2 >::matrix] + +[indexterm2 matrix..strategy::transform::ublas_transformer< P1, P2, 2, 2 >] + + matrix_type const & matrix() const; + + + +[endsect] + + +[section:ublas_transformer strategy::transform::ublas_transformer< P1, P2, 2, 2 >::ublas_transformer] + +[indexterm2 ublas_transformer..strategy::transform::ublas_transformer< P1, P2, 2, 2 >] + + ``[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...]]`` + + ``[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...]]`` + + +[section:overload1 strategy::transform::ublas_transformer< P1, P2, 2, 2 >::ublas_transformer (1 of 3 overloads)] + + + + 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); + + + +[endsect] + + + +[section:overload2 strategy::transform::ublas_transformer< P1, P2, 2, 2 >::ublas_transformer (2 of 3 overloads)] + + + + ublas_transformer( + matrix_type const & matrix); + + + +[endsect] + + + +[section:overload3 strategy::transform::ublas_transformer< P1, P2, 2, 2 >::ublas_transformer (3 of 3 overloads)] + + + + ublas_transformer(); + + + +[endsect] + + +[endsect] + + +[endsect] + +[section:strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_ strategy::transform::ublas_transformer< P1, P2, 3, 2 >] + + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 > + struct ublas_transformer< P1, P2, 3, 2 > : public strategy::transform::ublas_transformer< P1, P2, 2, 2 > + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.coordinate_type [*coordinate_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.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.apply [*apply]]] + [] + ] + + [ + [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_2__gt_.matrix [*matrix]]] + [] + ] + + [ + [[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]]] + [] + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::transform::ublas_transformer< P1, P2, 3, 2 >::apply] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 apply..strategy::transform::ublas_transformer< P1, P2, 3, 2 >] + + bool apply( + P1 const & p1, + P2 & p2) const; + + + +[endsect] + + + +[section:coordinate_type strategy::transform::ublas_transformer< P1, P2, 3, 2 >::coordinate_type] + +[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:ct strategy::transform::ublas_transformer< P1, P2, 3, 2 >::ct] + +[indexterm2 ct..strategy::transform::ublas_transformer< P1, P2, 3, 2 >] + + typedef coordinate_type ct; + + + +[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/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:m_matrix strategy::transform::ublas_transformer< P1, P2, 3, 2 >::m_matrix] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 m_matrix..strategy::transform::ublas_transformer< P1, P2, 3, 2 >] + + matrix_type m_matrix; + + + +[endsect] + + + +[section:matrix strategy::transform::ublas_transformer< P1, P2, 3, 2 >::matrix] + + +['Inherited from strategy::transform::ublas_transformer.] + +[indexterm2 matrix..strategy::transform::ublas_transformer< P1, P2, 3, 2 >] + + matrix_type const & matrix() const; + + + +[endsect] + + +[section:ublas_transformer strategy::transform::ublas_transformer< P1, P2, 3, 2 >::ublas_transformer] + +[indexterm2 ublas_transformer..strategy::transform::ublas_transformer< P1, P2, 3, 2 >] + + ``[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 strategy::transform::ublas_transformer< P1, P2, 3, 2 >::ublas_transformer (1 of 2 overloads)] + + + + 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); + + + +[endsect] + + + +[section:overload2 strategy::transform::ublas_transformer< P1, P2, 3, 2 >::ublas_transformer (2 of 2 overloads)] + + + + ublas_transformer(); + + + +[endsect] + + +[endsect] + + +[endsect] + +[section:strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_ strategy::transform::ublas_transformer< P1, P2, 3, 3 >] + + + + + +[heading Synopsis] + template< + typename P1 , + typename P2 > + class ublas_transformer< P1, P2, 3, 3 > + +[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]]] + [] + ] + +] + + +[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]]] + [] + ] + +] + +[heading Protected Data Members] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__transform__ublas_transformer_lt__P1,_P2,_3,_3__gt_.m_matrix [*m_matrix]]] + [] + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[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; + + + +[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:matrix strategy::transform::ublas_transformer< P1, P2, 3, 3 >::matrix] + +[indexterm2 matrix..strategy::transform::ublas_transformer< P1, P2, 3, 3 >] + + matrix_type const & matrix() const; + + + +[endsect] + + +[section:ublas_transformer strategy::transform::ublas_transformer< P1, P2, 3, 3 >::ublas_transformer] + +[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...]]`` + + ``[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...]]`` + + +[section:overload1 strategy::transform::ublas_transformer< P1, P2, 3, 3 >::ublas_transformer (1 of 2 overloads)] + + + + 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); + + + +[endsect] + + + +[section:overload2 strategy::transform::ublas_transformer< P1, P2, 3, 3 >::ublas_transformer (2 of 2 overloads)] + + + + ublas_transformer(); + + + +[endsect] + + +[endsect] + + +[endsect] + +[section:strategy__within__crossings_multiply strategy::within::crossings_multiply] + + +Within detection using cross counting,. + + + + +[heading Synopsis] + template< + typename Point , + typename PointOfSegment = Point, + typename CalculationType = void> + class crossings_multiply + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy__within__crossings_multiply.point_type [*point_type]]] + [] + + ] + + [ + + [[link boost_geometry.reference.strategy__within__crossings_multiply.segment_point_type [*segment_point_type]]] + [] + + ] + + [ + + [[link boost_geometry.reference.strategy__within__crossings_multiply.state_type [*state_type]]] + [] + + ] + +] + + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__within__crossings_multiply.apply [*apply]]] + [] + ] + + [ + [[link boost_geometry.reference.strategy__within__crossings_multiply.result [*result]]] + [] + ] + +] + + +[heading Description] + + + +[heading Remarks] + +Does NOT work correctly for [link boost_geometry.reference.point `point`] ON border + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[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/strategies/cartesian/point_in_poly_crossings_multiply.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:result strategy::within::crossings_multiply::result] + +[indexterm2 result..strategy::within::crossings_multiply] + + static bool result( + flags const & state); + + + +[endsect] + + + +[section:segment_point_type strategy::within::crossings_multiply::segment_point_type] + +[indexterm2 segment_point_type..strategy::within::crossings_multiply] + + typedef PointOfSegment segment_point_type; + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[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] + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy__within__crossings_multiply__flags strategy::within::crossings_multiply::flags] + + + + + +[heading Synopsis] + class flags + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__within__crossings_multiply__flags.flags [*flags]]] + [] + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:flags strategy::within::crossings_multiply::flags::flags] + +[indexterm2 flags..strategy::within::crossings_multiply::flags] + + flags(); + + + +[endsect] + + + +[endsect] + +[section:strategy__within__franklin strategy::within::franklin] + + +Within detection using cross counting. + + + + +[heading Synopsis] + template< + typename Point , + typename PointOfSegment = Point, + typename CalculationType = void> + class franklin + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[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 Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__within__franklin.apply [*apply]]] + [] + ] + + [ + [[link boost_geometry.reference.strategy__within__franklin.result [*result]]] + [] + ] + +] + + +[heading Description] + + +adapted from Randolph Franklin algorithm + +Barend and Maarten, 1995 + +Revised for templatized library, Barend Gehrels, 2007 + + +[heading Return Value] + +true if [link boost_geometry.reference.point `point`] is in ring, works for closed rings in both directions + + +[heading Remarks] + +Does NOT work correctly for [link boost_geometry.reference.point `point`] ON border + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::within::franklin::apply] + +[indexterm2 apply..strategy::within::franklin] + + static bool apply( + Point const & point, + PointOfSegment const & seg1, + PointOfSegment const & seg2, + crossings & state); + + + +[endsect] + + + +[section:point_type strategy::within::franklin::point_type] + +[indexterm2 point_type..strategy::within::franklin] + + typedef Point point_type; + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:result strategy::within::franklin::result] + +[indexterm2 result..strategy::within::franklin] + + static bool result( + crossings const & state); + + + +[endsect] + + + +[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/strategies/cartesian/point_in_poly_franklin.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:state_type strategy::within::franklin::state_type] + +[indexterm2 state_type..strategy::within::franklin] + + typedef crossings state_type; + + + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__within__franklin__crossings.crossings [*crossings]]] + [] + ] + +] + +[heading Typedef Description] + +subclass to keep state + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy__within__franklin__crossings strategy::within::franklin::crossings] + + + + + +[heading Synopsis] + class crossings + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__within__franklin__crossings.crossings [*crossings]]] + [] + ] + +] + + +[heading Description] + +subclass to keep state + +[heading Requirements] + +[*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] + + + +[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.strategy__within__winding.point_type [*point_type]]] + [] + + ] + + [ + + [[link boost_geometry.reference.strategy__within__winding.segment_point_type [*segment_point_type]]] + [] + + ] + + [ + + [[link boost_geometry.reference.strategy__within__winding.state_type [*state_type]]] + [] + + ] + +] + + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__within__winding.apply [*apply]]] + [] + ] + + [ + [[link boost_geometry.reference.strategy__within__winding.result [*result]]] + [] + ] + +] + + +[heading Description] + + + +[variablelist + +[[Point][[link boost_geometry.reference.point `point`] type of [link boost_geometry.reference.point `point`] to examine ]] + +[[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/strategies/agnostic/point_in_poly_winding.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:apply strategy::within::winding::apply] + +[indexterm2 apply..strategy::within::winding] + + static bool apply( + Point const & point, + PointOfSegment const & s1, + PointOfSegment const & s2, + counter & state); + + + +[endsect] + + + +[section:point_type strategy::within::winding::point_type] + +[indexterm2 point_type..strategy::within::winding] + + typedef Point point_type; + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/agnostic/point_in_poly_winding.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:result strategy::within::winding::result] + +[indexterm2 result..strategy::within::winding] + + static bool result( + counter const & state); + + + +[endsect] + + + +[section:segment_point_type strategy::within::winding::segment_point_type] + +[indexterm2 segment_point_type..strategy::within::winding] + + typedef PointOfSegment segment_point_type; + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/agnostic/point_in_poly_winding.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:state_type strategy::within::winding::state_type] + +[indexterm2 state_type..strategy::within::winding] + + typedef counter state_type; + + + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__within__winding__counter.counter [*counter]]] + [] + ] + +] + +[heading Typedef Description] + +subclass to keep state + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/agnostic/point_in_poly_winding.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy__within__winding__counter strategy::within::winding::counter] + + + + + +[heading Synopsis] + class counter + +[heading Public Member Functions] +[table + [[Name][Description]] + + [ + [[link boost_geometry.reference.strategy__within__winding__counter.counter [*counter]]] + [] + ] + +] + + +[heading Description] + +subclass to keep state + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/agnostic/point_in_poly_winding.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:counter strategy::within::winding::counter::counter] + +[indexterm2 counter..strategy::within::winding::counter] + + counter(); + + + +[endsect] + + + +[endsect] + +[section:strategy_area strategy_area] + + +Traits class binding an area [link boost_geometry.reference.strategy `strategy`] to a coordinate system. + + + + +[heading Synopsis] + template< + typename ``[link boost_geometry.reference.Tag Tag]``, + typename ``[link boost_geometry.reference.PointOfSegment PointOfSegment]``> + struct strategy_area + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy_area.type [*type]]] + [] + + ] + +] + + +[heading Description] + + + +[variablelist + +[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system ]] + +[[PointOfSegment][point-type ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/area.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[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. + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/area.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_centroid strategy_centroid] + + +Traits class binding a centroid calculation [link boost_geometry.reference.strategy `strategy`] to a coordinate system. + + + + +[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]] + + [ + + [[link boost_geometry.reference.strategy_centroid.type [*type]]] + [] + + ] + +] + + +[heading Description] + + + +[variablelist + +[[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 ]] + +[[Geometry][]] + +] + + + +[heading Requirements] + +[*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] + + +[endsect] + + + +[endsect] + +[section:strategy_compare strategy_compare] + + +Traits class binding a comparing [link boost_geometry.reference.strategy `strategy`] to a coordinate system. + + + + +[heading Synopsis] + template< + 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 + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy_compare.type [*type]]] + [] + + ] + +] + + +[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 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 Description] + + + +[variablelist + +[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system ]] + +[[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`]) ]] + +[[Point][point-type of output points ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/convex_hull.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:type strategy_convex_hull::type] + +[indexterm2 type..strategy_convex_hull] + + 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/convex_hull.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_distance strategy_distance] + + +Traits class binding a distance [link boost_geometry.reference.strategy `strategy`] to a (possibly two) coordinate system(s). + + + + +[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.strategy_distance.type [*type]]] + [] + + ] + +] + + +[heading 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/distance.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:type strategy_distance::type] + +[indexterm2 type..strategy_distance] + + 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/distance.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_distance_segment strategy_distance_segment] + + +Traits class binding a distance-to-segment [link boost_geometry.reference.strategy `strategy`] to a (possibly two) coordinate system(s). + + + + +[heading Synopsis] + template< + typename CsTag1 , + typename CsTag2 , + typename Point , + typename Segment > + struct strategy_distance_segment + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy_distance_segment.type [*type]]] + [] + + ] + +] + + +[heading Description] + + + +[variablelist + +[[CsTag1][[link boost_geometry.reference.tag `tag`] of coordinate system of [link boost_geometry.reference.point `point`] type ]] + +[[CsTag2][[link boost_geometry.reference.tag `tag`] of coordinate system of [link boost_geometry.reference.segment `segment`] type, usually same as CsTag1 ]] + +[[Point][point-type ]] + +[[Segment][segment-type ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/distance.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:type strategy_distance_segment::type] + +[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/strategies/distance.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_intersection strategy_intersection] + + + + + +[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.strategy_intersection.segment_intersection_strategy_type [*segment_intersection_strategy_type]]] + [] + + ] + + [ + + [[link boost_geometry.reference.strategy_intersection.side_strategy_type [*side_strategy_type]]] + [] + + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/intersection.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[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; + + + +[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 Typedef Description] + + + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/intersection.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[section:side_strategy_type strategy_intersection::side_strategy_type] + +[indexterm2 side_strategy_type..strategy_intersection] + + typedef strategy_side< Tag, CalculationType >::type side_strategy_type; + + + +[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/intersection.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_parse strategy_parse] + + +Tagraits class binding a parsing [link boost_geometry.reference.strategy `strategy`] to a coordinate system. + + + + +[heading Synopsis] + template< + typename Tag , + typename CoordinateSystem > + struct strategy_parse + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy_parse.type [*type]]] + [] + + ] + +] + + +[heading Description] + + + +[variablelist + +[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system of point-type ]] + +[[CoordinateSystem][coordinate system ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/parse.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:type strategy_parse::type] + +[indexterm2 type..strategy_parse] + + 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/parse.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_side strategy_side] + + +Traits class binding a side determination [link boost_geometry.reference.strategy `strategy`] to a coordinate system. + + + + +[heading Synopsis] + template< + typename ``[link boost_geometry.reference.Tag Tag]``, + typename ``[link boost_geometry.reference.CalculationType CalculationType]`` = void> + struct strategy_side + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy_side.type [*type]]] + [] + + ] + +] + + +[heading Description] + + + +[variablelist + +[[Tag][[link boost_geometry.reference.tag `tag`] of coordinate system of point-type ]] + +] + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/side.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:type strategy_side::type] + +[indexterm2 type..strategy_side] + + 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/side.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_tag strategy_tag] + + + + + +[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/strategies/tags.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:type strategy_tag::type] + +[indexterm2 type..strategy_tag] + + typedef strategy_tag_unknown type; + + +[heading Typedef Description] + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/tags.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_tag_lt__strategy__distance__projected_point_lt__Point,_PointOfSegment,_PPStrategy__gt___gt_ strategy_tag< strategy::distance::projected_point< Point, PointOfSegment, PPStrategy > >] + + + + + +[heading Synopsis] + template< + typename Point , + typename PointOfSegment , + typename PPStrategy > + struct strategy_tag< strategy::distance::projected_point< Point, PointOfSegment, PPStrategy > > + +[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]]] + [] + + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/cartesian/distance_projected_point.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:type strategy_tag< strategy::distance::projected_point< Point, PointOfSegment, PPStrategy > >::type] + +[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/strategies/cartesian/distance_projected_point.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_tag_lt__strategy__distance__pythagoras_lt__Point1,_Point2__gt___gt_ strategy_tag< strategy::distance::pythagoras< Point1, Point2 > >] + + + + + +[heading Synopsis] + template< + typename Point1 , + typename Point2 > + struct strategy_tag< strategy::distance::pythagoras< Point1, Point2 > > + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy_tag_lt__strategy__distance__pythagoras_lt__Point1,_Point2__gt___gt_.type [*type]]] + [] + + ] + +] + + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/cartesian/distance_pythagoras.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:type strategy_tag< strategy::distance::pythagoras< Point1, Point2 > >::type] + +[indexterm2 type..strategy_tag< strategy::distance::pythagoras< Point1, Point2 > >] + + typedef strategy_tag_distance_point_point type; + + +[heading Typedef Description] + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/cartesian/distance_pythagoras.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_tag_distance_point_point strategy_tag_distance_point_point] + + + + + +[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] + + + + + +[heading Synopsis] + struct strategy_tag_distance_point_segment + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/tags.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + +[section:strategy_tag_unknown strategy_tag_unknown] + + + + + +[heading Synopsis] + struct strategy_tag_unknown + +[heading Description] + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/tags.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + +[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]] + + [ + + [[link boost_geometry.reference.strategy_transform.type [*type]]] + [] + + ] + +] + + +[heading Description] + +Can be specialized +* per coordinate system family (tag) + +* per coordinate system (or groups of them) + +* per dimension + +* per point type CoordinateSystemTag1,2 coordinate system tags CoordinateSystem1,2 coordinate system D1, 2 dimension Point1, 2 point type + + + + +[heading Requirements] + +[*Header: ][^boost/geometry/strategies/transform.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:type strategy_transform::type] + +[indexterm2 type..strategy_transform] + + 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/transform.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + +[endsect] + +[section:strategy_within strategy_within] + + +Traits class binding a within determination [link boost_geometry.reference.strategy `strategy`] to a coordinate system. + + + + +[heading Synopsis] + template< + typename TagPoint , + typename TagSegment , + typename Point , + typename PointOfSegment > + struct strategy_within + +[heading Public Types] +[table + [[Name][Description]] + + [ + + [[link boost_geometry.reference.strategy_within.type [*type]]] + [] + + ] + +] + + +[heading Description] + + + +[variablelist + +[[TagPoint][[link boost_geometry.reference.tag `tag`] of coordinate system of point-type ]] + +[[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/strategies/point_in_poly.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[section:type strategy_within::type] + +[indexterm2 type..strategy_within] + + 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/point_in_poly.hpp] + +[*Convenience header: ][^boost/geometry.hpp] + + +[endsect] + + + [endsect] [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 @@ Subtracts a point to another. 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 @@ The coordinates of the second point will be subtracted to those of the first poi [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 @@ Subtracts a value to each coordinate of a point. [variablelist -[[p][point ]] +[[p][[link boost_geometry.reference.point `point`] ]] [[value][value to subtract ]] @@ -9217,7 +18950,7 @@ Subtracts a value to each coordinate of a point. [variablelist -[[Geometry][geometry type ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] @@ -9227,7 +18960,7 @@ Subtracts a value to each coordinate of a point. [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 @@ Subtracts a value to each coordinate of a point. [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 @@ Meta-function to get the tag of any geometry type. ] -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 @@ All geometries tell their geometry type (point, linestring, polygon, etc) by imp [heading Typedef Description] -All geometries should implement a `traits::tag::type` metafunction to indicate their own geometry type. +All geometries should implement a `traits::tag::type` metafunction to indicate their own [link boost_geometry.reference.boost__geometry `boost::geometry`] type. [heading Geometries:] @@ -9328,7 +19067,7 @@ All geometries should implement a `traits::tag::type` metafunction to indicat [variablelist -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -9351,13 +19090,19 @@ All geometries should implement a `traits::tag::type` metafunction to indicat [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 @@ The topological dimension defines a point as 0-dimensional, a linestring as 1-di [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 @@ Traits class which gives access (get,set) to points. [[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 @@ Traits class which gives access (get,set) to points. [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 @@ If a geometry type should not use the std "push\_back" then it can specialize th [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 @@ If a geometry type should not use the std ".clear()" then it can specialize the [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 @@ Traits class defining the coordinate system of a point, important for strategy s [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 @@ Traits class which indicate the coordinate type (double,float,...) of a point. [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 @@ Traits class defining coordinate system tag, bound to coordinate system. [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 @@ Traits class indicating the number of dimensions of a point. [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 @@ Should define const and non const access [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 @@ Traits class defining "get" and "set" to get and set point coordinate values. [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 @@ defines access (const and non const) to interior ring [variablelist -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -9788,12 +19593,18 @@ defines access (const and non const) to interior ring [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 @@ defines inner container type, so the container containing the interior rings [variablelist -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -9834,12 +19645,16 @@ defines inner container type, so the container containing the interior rings [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 @@ Traits class indicating the order of contained points within a ring or (multi)po ] +[heading Description] + + [heading Geometries:] @@ -9875,7 +19693,7 @@ Traits class indicating the order of contained points within a ring or (multi)po [variablelist -[[G][geometry ]] +[[G][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -9908,10 +19726,16 @@ Traits class indicating the order of contained points within a ring or (multi)po Traits class indicating the type of contained points. + + +[heading Synopsis] template< typename G > struct point_type +[heading Description] + + [heading Geometries:] @@ -9931,7 +19755,7 @@ Traits class indicating the type of contained points. [variablelist -[[G][geometry ]] +[[G][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -9952,10 +19776,16 @@ Traits class indicating the type of contained points. 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 @@ Traits class to indicate ring-type of a polygon's exterior ring/interior rings. [variablelist -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -9993,9 +19823,12 @@ Traits class to indicate ring-type of a polygon's exterior ring/interior rings. [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 @@ Traits class to attach a tag to a geometry. ] -All geometries should implement a `traits::tag::type` metafunction to indicate their own geometry type. + +[heading Description] + +All geometries should implement a `traits::tag::type` metafunction to indicate their own [link boost_geometry.reference.boost__geometry `boost::geometry`] type. [heading Geometries:] @@ -10035,7 +19871,7 @@ All geometries should implement a `traits::tag::type` metafunction to indicat [variablelist -[[Geometry][geometry ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]] ] @@ -10077,9 +19913,13 @@ All geometries should implement a `traits::tag::type` metafunction to indicat 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 @@ Traits class, optional, indicating that the std-library should be used. ] -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 @@ This "transform" is broader then geodetic datum transformations, those are curre [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 @@ Transforms from one geometry to another geometry using a strategy. [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 @@ Transforms from one geometry to another geometry using a strategy. [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 @@ Transforms from one geometry to another geometry using a strategy. [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 @@ Transforms from one geometry to another geometry using a strategy. [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 @@ Transforms from one geometry to another geometry using a strategy. [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 @@ Combines two geometries which each other. [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 @@ Combines two geometries which each other. [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 @@ Combines two geometries which each other. [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 @@ Combines two geometries which each other. [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 @@ the output iterator [variablelist -[[Geometry][geometry type ]] +[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]] ] @@ -10517,7 +20360,7 @@ the output iterator [variablelist -[[geometry][the geometry to make unique ]] +[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make unique ]] ] @@ -10613,7 +20456,7 @@ The within algorithm is used as following: [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 @@ Within, examine if a geometry is within another geometry. [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 @@ true if geometry1 is completely contained within geometry2, else false [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 @@ The default strategy is used for within detection [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 @@ Within, examine if a geometry is within another geometry, using a specified stra [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 ]] ] diff --git a/doc/quickbook/reference.xsl b/doc/quickbook/reference.xsl index 0e5237652..fbb818bb6 100644 --- a/doc/quickbook/reference.xsl +++ b/doc/quickbook/reference.xsl @@ -503,6 +503,7 @@ + [heading Requirements] @@ -549,6 +550,7 @@ +[heading Synopsis] @@ -567,18 +569,21 @@ + - +[heading Description] + + @@ -593,10 +598,7 @@ - + [heading Public Types] [table @@ -640,6 +642,7 @@ + [heading Public Member Functions] [table [[Name][Description]] @@ -688,6 +691,7 @@ + [heading Protected Member Functions] [table [[Name][Description]] @@ -736,6 +740,7 @@ + [heading Public Data Members] [table [[Name][Description]] @@ -994,6 +999,7 @@ + @@ -1230,6 +1236,7 @@ + @@ -1277,6 +1284,7 @@ +