|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r60716 - sandbox/geometry/libs/geometry/doc/quickbook
From: mateusz_at_[hidden]
Date: 2010-03-19 17:25:08
Author: mloskot
Date: 2010-03-19 17:25:07 EDT (Fri, 19 Mar 2010)
New Revision: 60716
URL: http://svn.boost.org/trac/boost/changeset/60716
Log:
Geometry: update to quickbook Reference with new sections and source input
Text files modified:
sandbox/geometry/libs/geometry/doc/quickbook/reference.qbk | 6240 ++++++++++++++++++++++++++++++++++-----
1 files changed, 5447 insertions(+), 793 deletions(-)
Modified: sandbox/geometry/libs/geometry/doc/quickbook/reference.qbk
==============================================================================
--- sandbox/geometry/libs/geometry/doc/quickbook/reference.qbk (original)
+++ sandbox/geometry/libs/geometry/doc/quickbook/reference.qbk 2010-03-19 17:25:07 EDT (Fri, 19 Mar 2010)
@@ -13,6 +13,84 @@
[include geometry_concepts.qbk]
+[section:add_const_if_c add_const_if_c]
+
+
+Meta-function to define a const or non const type.
+
+
+
+
+[heading Synopsis]
+ template<
+ bool ``[link boost_geometry.reference.IsConst IsConst]``,
+ typename Type >
+ struct add_const_if_c
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.add_const_if_c.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Description]
+
+If the boolean template parameter is true, the type parameter will be defined as const, otherwise it will be defined as it was. This meta-function is used to have one implementation for both const and non const references
+
+[heading Remarks]
+
+This [link boost_geometry.reference.traits `traits`] class is completely independant from GGL and might be a separate addition to Boost
+
+Used in a.o. for\_each, interior\_rings, exterior\_ring
+
+
+[heading Example]
+
+
+
+ void foo(typename add_const_if_c<IsConst, Point>::type& point)
+
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/add_const_if_c.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:type add_const_if_c::type]
+
+[indexterm2 type..add_const_if_c]
+
+ typedef boost::mpl::if_c< IsConst, const Type, Type >::type type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/add_const_if_c.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
[section:add_point add_point]
@@ -209,6 +287,7 @@
]
+
[heading Return Value]
the area
@@ -247,6 +326,7 @@
]
+
[heading Return Value]
the area
@@ -303,6 +383,7 @@
[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)
@@ -426,6 +507,74 @@
[endsect]
+[section:as_range as_range]
+
+[indexterm1 as_range]
+Function getting either the range (ring, [link boost_geometry.reference.linestring `linestring`]) itself or the outer ring ([link boost_geometry.reference.polygon `polygon`]).
+
+
+ template<
+ typename Range ,
+ typename Geometry >
+ Range & ``[link boost_geometry.reference.as_range.overload1 as_range]``(
+ Geometry & input);
+ `` [''''»''' [link boost_geometry.reference.as_range.overload1 more...]]``
+
+ template<
+ typename Range ,
+ typename Geometry >
+ Range const & ``[link boost_geometry.reference.as_range.overload2 as_range]``(
+ Geometry const & input);
+ `` [''''»''' [link boost_geometry.reference.as_range.overload2 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/as_range.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 as_range (1 of 2 overloads)]
+
+
+Function getting either the range (ring, [link boost_geometry.reference.linestring `linestring`]) itself or the outer ring ([link boost_geometry.reference.polygon `polygon`]).
+
+
+ template<
+ typename Range ,
+ typename Geometry >
+ Range & as_range(
+ Geometry & input);
+
+
+Utility to handle polygon's outer ring as a range
+
+
+[endsect]
+
+
+
+[section:overload2 as_range (2 of 2 overloads)]
+
+
+Function getting either the range (ring, [link boost_geometry.reference.linestring `linestring`]) itself or the outer ring ([link boost_geometry.reference.polygon `polygon`]), const version.
+
+
+ template<
+ typename Range ,
+ typename Geometry >
+ Range const & as_range(
+ Geometry const & input);
+
+
+Utility to handle polygon's outer ring as a range
+
+
+[endsect]
+
+
+[endsect]
+
[section:assert_dimension assert_dimension]
@@ -590,7 +739,7 @@
[section:overload2 assign (2 of 4 overloads)]
-assign three values to a 3D [link boost_geometry.reference.point `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<
@@ -611,7 +760,7 @@
[section:overload3 assign (3 of 4 overloads)]
-assign center + radius to a sphere [for extension]
+assign center + radius to a sphere \[for extension\]
template<
@@ -645,6 +794,7 @@
+
[heading Remarks]
The point-type of the range might be different from the point-type of the [link boost_geometry.reference.boost__geometry `boost::geometry`]
@@ -676,6 +826,7 @@
+
[heading Remarks]
The order is crucial. Most logical is LOWER, UPPER and sub-order LEFT, RIGHT so this is how it is implemented.
@@ -862,6 +1013,7 @@
[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 [link boost_geometry.reference.box `box`]. Boxes are also used in Spatial Indexes.
@@ -1038,6 +1190,7 @@
[heading Typedef 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 [link boost_geometry.reference.box `box`]. Boxes are also used in Spatial Indexes.
@@ -1098,6 +1251,7 @@
[heading Typedef 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 [link boost_geometry.reference.box `box`]. Boxes are also used in Spatial Indexes.
@@ -1180,6 +1334,7 @@
]
+
[heading Remarks]
Currently only implemented for [link boost_geometry.reference.box `box`], the trivial case, but still useful
@@ -1245,7 +1400,7 @@
[
[[link boost_geometry.reference.cartesian_distance.squared_value [*squared_value]]]
- [The "squared_value" method returns the internal squared value. ]
+ [The "squared\_value" method returns the internal squared value. ]
]
[
@@ -1270,6 +1425,7 @@
[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
@@ -1460,6 +1616,7 @@
+
[heading Remarks]
Polygon should be closed, and can be orientated either way
@@ -1653,6 +1810,116 @@
[endsect]
+[section:circular_iterator circular_iterator]
+
+
+Iterator which goes circular through a range, `starting` at a [link boost_geometry.reference.point `point`], ending at that [link boost_geometry.reference.point `point`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Iterator >
+ struct circular_iterator
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.circular_iterator.circular_iterator [*circular_iterator]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.circular_iterator.moveto [*moveto]]]
+ [Navigate to a certain position, should be in \[start .. end\], it at end it will circle again. ]
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[Iterator][iterator on which this class is based on ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/iterators/circular_iterator.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+[section:circular_iterator circular_iterator::circular_iterator]
+
+[indexterm2 circular_iterator..circular_iterator]
+
+ explicit ``[link boost_geometry.reference.circular_iterator.circular_iterator.overload1 circular_iterator]``(
+ Iterator begin,
+ Iterator end,
+ Iterator start);
+ `` [''''»''' [link boost_geometry.reference.circular_iterator.circular_iterator.overload1 more...]]``
+
+ explicit ``[link boost_geometry.reference.circular_iterator.circular_iterator.overload2 circular_iterator]``(
+ Iterator end);
+ `` [''''»''' [link boost_geometry.reference.circular_iterator.circular_iterator.overload2 more...]]``
+
+
+[section:overload1 circular_iterator::circular_iterator (1 of 2 overloads)]
+
+
+
+ circular_iterator(
+ Iterator begin,
+ Iterator end,
+ Iterator start);
+
+
+
+[endsect]
+
+
+
+[section:overload2 circular_iterator::circular_iterator (2 of 2 overloads)]
+
+
+
+ circular_iterator(
+ Iterator end);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:moveto circular_iterator::moveto]
+
+[indexterm2 moveto..circular_iterator]
+Navigate to a certain position, should be in \[start .. end\], it at end it will circle again.
+
+
+ void moveto(
+ Iterator it);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
[section:clear clear]
@@ -1669,6 +1936,7 @@
Generic function to clear a [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
[heading Remarks]
points and boxes cannot be cleared, instead they can be set to zero by "assign\_zero"
@@ -2075,6 +2343,7 @@
+
[heading Remarks]
to fulfil the concepts, no [link boost_geometry.reference.traits `traits`] class has to be specialized to define the [link boost_geometry.reference.point `point`] type. The [link boost_geometry.reference.point `point`] type is taken using boost::range\_value<X>::type
@@ -2099,6 +2368,7 @@
+
[heading Remarks]
@@ -2282,6 +2552,7 @@
+
[heading Remarks]
to fulfil the concepts, no [link boost_geometry.reference.traits `traits`] class has to be specialized to define the [link boost_geometry.reference.point `point`] type. The [link boost_geometry.reference.point `point`] type is automatically defined as typename range\_value<typename `ring_type<P>::type`>type
@@ -2329,6 +2600,7 @@
+
[heading Remarks]
to fulfil the concepts, no [link boost_geometry.reference.traits `traits`] class has to be specialized to define the [link boost_geometry.reference.point `point`] type. The [link boost_geometry.reference.point `point`] type is taken using boost::range\_value<X>::type
@@ -2370,6 +2642,7 @@
+
[heading Remarks]
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.
@@ -2590,6 +2863,7 @@
2776 counties of US are "hulled" in 0.9 seconds (http://trac.osgeo.org/ggl/wiki/Performance#Convexhull1)
+
[heading Remarks]
The convex hull is always a ring, holes are not possible. Therefore it is can also be used in combination with an output iterator.
@@ -2806,6 +3080,7 @@
]
+
[heading Remarks]
This overloaded version outputs to an output iterator. In this case, nothing is known about its point-type or about its clockwise order. Therefore, the input point-type and order are copied
@@ -3036,6 +3311,51 @@
[endsect]
+
+[section:copy_coordinates copy_coordinates]
+
+[indexterm1 copy_coordinates]
+Copies coordinates from source to destination [link boost_geometry.reference.point `point`].
+
+
+ template<
+ typename Src ,
+ typename Dst >
+ void copy_coordinates(
+ Src const & source,
+ Dst & dest);
+
+
+The function copy\_coordinates copies coordinates from one [link boost_geometry.reference.point `point`] to another [link boost_geometry.reference.point `point`]. Source [link boost_geometry.reference.point `point`] and destination [link boost_geometry.reference.point `point`] might be of different types.
+[heading Parameters]
+
+
+[variablelist
+
+[[source][Source [link boost_geometry.reference.point `point`] ]]
+
+[[dest][Destination [link boost_geometry.reference.point `point`] ]]
+
+]
+
+
+
+[heading Remarks]
+
+If destination type differs from source type, they must have the same coordinate count
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/copy.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
[section:copy_segment_point copy_segment_point]
[indexterm1 copy_segment_point]
@@ -3229,6 +3549,7 @@
]
+
[heading Return Value]
the cross product vector
@@ -3301,6 +3622,7 @@
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]
might be moved to extensions/gis/geographic
@@ -4639,6 +4961,7 @@
]
+
[heading Return Value]
true if disjoint, else false
@@ -4814,11 +5137,13 @@
]
+
[heading Return Value]
the distance (either a double or a [link boost_geometry.reference.distance_result `distance_result`], (convertable to double))
+
[heading Remarks]
The [link boost_geometry.reference.strategy `strategy`] can be a point-point [link boost_geometry.reference.strategy `strategy`]. In case of distance point-line/point-polygon it may also be a point-segment [link boost_geometry.reference.strategy `strategy`].
@@ -4876,6 +5201,7 @@
]
+
[heading Return Value]
the distance (either a double or a distance result, convertable to double)
@@ -5219,6 +5545,7 @@
]
+
[heading Return Value]
the dot product
@@ -5236,19 +5563,59 @@
-[section:enrich_intersection_points enrich_intersection_points]
+[section:dsv dsv]
-[indexterm1 enrich_intersection_points]
-All intersection points are enriched with successor information.
+[indexterm1 dsv]
+Main DSV-streaming function.
template<
- typename TurnPoints ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename Strategy >
- void enrich_intersection_points(
- TurnPoints & turn_points,
+ typename Geometry >
+ detail::dsv::dsv_manipulator< Geometry > dsv(
+ Geometry const & geometry,
+ std::string const & coordinate_separator = ", ",
+ std::string const & point_open = "(",
+ std::string const & point_close = ")",
+ std::string const & point_separator = ", ",
+ std::string const & list_open = "(",
+ std::string const & list_close = ")",
+ std::string const & list_separator = ", ");
+
+
+DSV stands for Delimiter Separated Values. Geometries can be streamed as DSV. There are defaults for all separators.
+
+[heading Remarks]
+
+Useful for examples and testing purposes
+
+With this function GeoJSON objects can be created, using the right delimiters
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/write_dsv.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:enrich_intersection_points enrich_intersection_points]
+
+[indexterm1 enrich_intersection_points]
+All intersection points are enriched with successor information.
+
+
+ template<
+ typename TurnPoints ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Strategy >
+ void enrich_intersection_points(
+ TurnPoints & turn_points,
Geometry1 const & geometry1,
Geometry2 const & geometry2,
Strategy const & strategy);
@@ -5370,6 +5737,7 @@
]
+
[heading Return Value]
true if geometries are spatially equal, else false
@@ -5386,6 +5754,128 @@
[endsect]
+[section:ever_circling_iterator ever_circling_iterator]
+
+
+Iterator which ever circles through a range.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Iterator >
+ struct ever_circling_iterator
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.ever_circling_iterator.ever_circling_iterator [*ever_circling_iterator]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.ever_circling_iterator.moveto [*moveto]]]
+ [Navigate to a certain position, should be in \[start .. end\], it at end it will circle again. ]
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[Iterator][iterator on which this class is based on]]
+
+]
+
+If the iterator arrives at range.end() it restarts from the beginning. So it has to be stopped in another way. Don't call for(....; it++) because it will turn in an endless loop
+
+[heading Remarks]
+
+Name inspired on David Bowie's "Chant Of The Ever Circling Skeletal Family"
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/iterators/ever_circling_iterator.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+[section:ever_circling_iterator ever_circling_iterator::ever_circling_iterator]
+
+[indexterm2 ever_circling_iterator..ever_circling_iterator]
+
+ explicit ``[link boost_geometry.reference.ever_circling_iterator.ever_circling_iterator.overload1 ever_circling_iterator]``(
+ Iterator begin,
+ Iterator end,
+ bool skip_first = false);
+ `` [''''»''' [link boost_geometry.reference.ever_circling_iterator.ever_circling_iterator.overload1 more...]]``
+
+ explicit ``[link boost_geometry.reference.ever_circling_iterator.ever_circling_iterator.overload2 ever_circling_iterator]``(
+ Iterator begin,
+ Iterator end,
+ Iterator start,
+ bool skip_first = false);
+ `` [''''»''' [link boost_geometry.reference.ever_circling_iterator.ever_circling_iterator.overload2 more...]]``
+
+
+[section:overload1 ever_circling_iterator::ever_circling_iterator (1 of 2 overloads)]
+
+
+
+ ever_circling_iterator(
+ Iterator begin,
+ Iterator end,
+ bool skip_first = false);
+
+
+
+[endsect]
+
+
+
+[section:overload2 ever_circling_iterator::ever_circling_iterator (2 of 2 overloads)]
+
+
+
+ ever_circling_iterator(
+ Iterator begin,
+ Iterator end,
+ Iterator start,
+ bool skip_first = false);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:moveto ever_circling_iterator::moveto]
+
+[indexterm2 moveto..ever_circling_iterator]
+Navigate to a certain position, should be in \[start .. end\], it at end it will circle again.
+
+
+ void moveto(
+ Iterator it);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
[section:exception exception]
@@ -5446,6 +5936,7 @@
+
[heading Remarks]
OGC compliance: instead of ExteriorRing
@@ -5469,6 +5960,7 @@
]
+
[heading Return Value]
a reference to the exterior ring
@@ -5493,6 +5985,7 @@
+
[heading Remarks]
OGC compliance: instead of ExteriorRing
@@ -5516,6 +6009,7 @@
]
+
[heading Return Value]
a const reference to the exterior ring
@@ -5528,6 +6022,29 @@
[endsect]
+
+[section:for_each_coordinate for_each_coordinate]
+
+[indexterm1 for_each_coordinate]
+
+ template<
+ typename Point ,
+ typename Op >
+ void for_each_coordinate(
+ Point & point,
+ Op operation);
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/for_each_coordinate.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
[section:for_each_point for_each_point]
[indexterm1 for_each_point]
@@ -5624,6 +6141,29 @@
[endsect]
+
+[section:for_each_range for_each_range]
+
+[indexterm1 for_each_range]
+
+ template<
+ typename Geometry ,
+ typename Actor >
+ void for_each_range(
+ Geometry const & geometry,
+ Actor & actor);
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/for_each_range.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
[section:for_each_segment for_each_segment]
[indexterm1 for_each_segment]
@@ -5780,6 +6320,7 @@
[heading Description]
+
[heading Remarks]
Used for e.g. reverse meta-function
@@ -5879,6 +6420,7 @@
]
+
[heading Return Value]
coordinate value
@@ -5928,6 +6470,7 @@
]
+
[heading Return Value]
coordinate value
@@ -5955,6 +6498,7 @@
Result is in Radian, even if source coordinate system is in Degrees
+
[heading Return Value]
coordinate value
@@ -5980,6 +6524,7 @@
]
+
[heading Remarks]
Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems
@@ -6225,6 +6770,7 @@
+
[heading Remarks]
OGC compliance: instead of InteriorRingN
@@ -6248,6 +6794,7 @@
]
+
[heading Return Value]
a reference to the interior rings
@@ -6272,6 +6819,7 @@
+
[heading Remarks]
OGC compliance: instead of InteriorRingN
@@ -6295,6 +6843,7 @@
]
+
[heading Return Value]
a const reference to the interior rings
@@ -6436,6 +6985,7 @@
]
+
[heading Return Value]
true if successful
@@ -6541,6 +7091,7 @@
]
+
[heading Return Value]
the output iterator
@@ -6598,6 +7149,7 @@
]
+
[heading Return Value]
the output iterator
@@ -6639,6 +7191,7 @@
+
[heading Remarks]
There are two overloaded versions:
@@ -6661,6 +7214,7 @@
+
[heading Remarks]
if one geometry is completely within another geometry, it "intersects"
@@ -6687,6 +7241,7 @@
+
[heading Remarks]
This function can be called for one [link boost_geometry.reference.boost__geometry `boost::geometry`] (self-intersection) and also for two geometries (intersection)
@@ -6710,6 +7265,7 @@
]
+
[heading Return Value]
true if there are intersections, else false
@@ -6758,6 +7314,7 @@
]
+
[heading Return Value]
true if there are intersection(s), else false
@@ -6786,6 +7343,7 @@
[heading Description]
+
[heading Remarks]
Used for [link boost_geometry.reference.tag `tag`] dispatching and meta-function finetuning
@@ -6908,6 +7466,7 @@
]
+
[heading Return Value]
the length Example showing length calculation on a vector
@@ -6950,6 +7509,7 @@
]
+
[heading Return Value]
the length
@@ -7001,6 +7561,7 @@
[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.
@@ -7028,22 +7589,51 @@
[
- [[link boost_geometry.reference.coordinate_type.ncg [*ncg]]]
+ [[link boost_geometry.reference.select_most_precise.type [*type]]]
[]
]
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.both_same [*both_same]]]
+ []
+ ]
+
[
+ [[link boost_geometry.reference.select_most_precise.one_not_fundamental [*one_not_fundamental]]]
+ []
+ ]
- [[link boost_geometry.reference.coordinate_type.type [*type]]]
+ [
+ [[link boost_geometry.reference.select_most_precise.second_larger [*second_larger]]]
[]
-
]
]
[heading Typedef Description]
+[link boost_geometry.reference.select_most_precise `select_most_precise`] classes, compares two types on compile time. For example, if an addition must be done with a double and an integer, the result must be a double. If both types are integer, the result can be an integer.
+
+[heading Remarks]
+
+It is different from the "promote" class, already in `boost`. That class promotes e.g. a (one) float to a double. This class selects a type from two types. It takes the most accurate, but does not promote afterwards.
+
+This [link boost_geometry.reference.traits `traits`] class is completely independant from GGL and might be a separate addition to Boost
+
+If the input is a non-fundamental type, it might be a calculation type such as a GMP-value or another high precision value. Therefore, if one is non-fundamental, that one is chosen.
+
+If both types are non-fundamental, the result is indeterminate and currently the first one is chosen.
+
+
+
[heading Requirements]
@@ -7296,9 +7886,10 @@
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]
+It does not work with array-point types, like int\[2\]
@@ -7311,6 +7902,7 @@
]
+
[heading Return Value]
the [link boost_geometry.reference.boost__geometry `boost::geometry`]
@@ -7338,6 +7930,7 @@
+
[heading Return Value]
a 3D [link boost_geometry.reference.point `point`]
@@ -7417,11 +8010,13 @@
]
+
[heading Return Value]
the buffered [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
[heading Remarks]
See also: buffer
@@ -7491,6 +8086,7 @@
]
+
[heading Return Value]
the centroid
@@ -7530,6 +8126,7 @@
]
+
[heading Return Value]
the centroid
@@ -7577,6 +8174,7 @@
]
+
[heading Return Value]
the distance result
@@ -7650,6 +8248,7 @@
]
+
[heading Return Value]
the [link boost_geometry.reference.box `box`]
@@ -7667,6 +8266,27 @@
+[section:make_segment_iterator make_segment_iterator]
+
+[indexterm1 make_segment_iterator]
+
+ template<
+ typename C >
+ segment_iterator< typename C::iterator, typename C::value_type > make_segment_iterator(
+ C & c);
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
[section:make_zero make_zero]
[indexterm1 make_zero]
@@ -7687,6 +8307,7 @@
]
+
[heading Return Value]
the [link boost_geometry.reference.boost__geometry `boost::geometry`]
@@ -7704,18 +8325,16 @@
-[section:max_corner max_corner]
-
-[indexterm1 max_corner]
-Index of maximum corner of the [link boost_geometry.reference.box `box`].
+[section:math__d2r math::d2r]
+[indexterm1 math::d2r]
- const int max_corner = 1;
+ double const d2r =pi / 180.0;
[heading Requirements]
-[*Header: ][^boost/geometry/core/access.hpp]
+[*Header: ][^boost/geometry/util/math.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -7724,36 +8343,233 @@
-[section:min_corner min_corner]
+[section:math__equals math::equals]
-[indexterm1 min_corner]
-Index of minimum corner of the [link boost_geometry.reference.box `box`].
+[indexterm1 math::equals]
+returns true if both arguments are equal.
- const int min_corner = 0;
+ template<
+ typename T1 ,
+ typename T2 >
+ bool equals(
+ T1 const & a,
+ T2 const & b);
-[heading Requirements]
-[*Header: ][^boost/geometry/core/access.hpp]
+[heading Parameters]
+
-[*Convenience header: ][^boost/geometry.hpp]
+[variablelist
+
+[[a][first argument ]]
+[[b][second argument ]]
-[endsect]
+]
-[section:multiply_point multiply_point]
+[heading Return Value]
+
+true if a == b
-[indexterm1 multiply_point]
-Multiplies a [link boost_geometry.reference.point `point`] by another.
- template<
- typename Point1 ,
- typename Point2 >
- void multiply_point(
+[heading Remarks]
+
+If both a and b are of an integral type, comparison is done by ==. If one of the types is floating [link boost_geometry.reference.point `point`], comparison is done by abs and comparing with epsilon. If one of the types is non-fundamental, it might be a high-precision number and comparison is done using the == operator of that class.
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/math.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:math__hav math::hav]
+
+[indexterm1 math::hav]
+Calculates the haversine of an angle.
+
+
+ template<
+ typename T >
+ T hav(
+ T const & theta);
+
+
+
+
+[heading Remarks]
+
+See http://en.wikipedia.org/wiki/Haversine\_formula haversin(alpha) = sin2(alpha/2)
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/math.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:math__pi math::pi]
+
+[indexterm1 math::pi]
+
+ double const pi = boost::math::constants::pi<double>();
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/math.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:math__r2d math::r2d]
+
+[indexterm1 math::r2d]
+
+ double const r2d = 1.0 / d2r;
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/math.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:math__sqr math::sqr]
+
+[indexterm1 math::sqr]
+Short utility to return the square.
+
+
+ template<
+ typename T >
+ T sqr(
+ T const & value);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[value][Value to calculate the square from ]]
+
+]
+
+
+
+[heading Return Value]
+
+The squared value
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/math.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:math__two_pi math::two_pi]
+
+[indexterm1 math::two_pi]
+
+ double const two_pi = 2.0 * pi;
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/math.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:max_corner max_corner]
+
+[indexterm1 max_corner]
+Index of maximum corner of the [link boost_geometry.reference.box `box`].
+
+
+ const int max_corner = 1;
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/access.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:min_corner min_corner]
+
+[indexterm1 min_corner]
+Index of minimum corner of the [link boost_geometry.reference.box `box`].
+
+
+ const int min_corner = 0;
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/access.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:multiply_point multiply_point]
+
+[indexterm1 multiply_point]
+Multiplies a [link boost_geometry.reference.point `point`] by another.
+
+
+ template<
+ typename Point1 ,
+ typename Point2 >
+ void multiply_point(
Point1 & p1,
Point2 const & p2);
@@ -7771,6 +8587,7 @@
]
+
[heading Remarks]
This is *not* a dot, cross or wedge product. It is a mere field-by-field multiplication.
@@ -7857,6 +8674,7 @@
]
+
[heading Return Value]
the number of interior rings of the [link boost_geometry.reference.boost__geometry `boost::geometry`]
@@ -7887,6 +8705,7 @@
+
[heading Remarks]
Defined by OGC as "numInteriorRing". To be consistent with "numPoints" letter "s" is appended
@@ -7912,6 +8731,7 @@
]
+
[heading Return Value]
the number of interior rings of the [link boost_geometry.reference.boost__geometry `boost::geometry`]
@@ -7960,11 +8780,13 @@
]
+
[heading Return Value]
number of points
+
[heading Remarks]
For linestrings/rings also boost::size or .size() could be used, however, for polygons this is less obvious. So this function is provided. Besides that it is described by OGC (numPoints)
@@ -7981,117 +8803,278 @@
[endsect]
+[section:one_section_segment_iterator one_section_segment_iterator]
-[section:order_selector order_selector]
-[indexterm1 order_selector]
- enum order_selector
-[indexterm2 clockwise..order_selector]
-[indexterm2 counterclockwise..order_selector]
-[indexterm2 order_undetermined..order_selector]
-[heading Values]
-[variablelist
+[heading Synopsis]
+ template<
+ typename G ,
+ typename SEC ,
+ typename B ,
+ size_t ``[link boost_geometry.reference.D D]``>
+ struct one_section_segment_iterator
- [
- [clockwise]
- []
- ]
+[heading Public Types]
+[table
+ [[Name][Description]]
[
- [counterclockwise]
+
+ [[link boost_geometry.reference.one_section_segment_iterator.normal_iterator [*normal_iterator]]]
[]
+
]
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
[
- [order_undetermined]
+ [[link boost_geometry.reference.one_section_segment_iterator.one_section_segment_iterator [*one_section_segment_iterator]]]
[]
]
-
+
]
+[heading Description]
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/point_order.hpp]
+[*Header: ][^boost/geometry/iterators/section_iterators.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:normal_iterator one_section_segment_iterator::normal_iterator]
+[indexterm2 normal_iterator..one_section_segment_iterator]
+ typedef boost::range_const_iterator< G >::type normal_iterator;
-[section:overlaps overlaps]
-[indexterm1 overlaps]
-Determines overlap between two geometries.
+[heading Requirements]
- template<
- typename Geometry1 ,
- typename Geometry2 >
- bool overlaps(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
+[*Header: ][^boost/geometry/iterators/section_iterators.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Return Value]
-
-true if there is overlap
+[endsect]
+[section:one_section_segment_iterator one_section_segment_iterator::one_section_segment_iterator]
-[heading Requirements]
+[indexterm2 one_section_segment_iterator..one_section_segment_iterator]
-[*Header: ][^boost/geometry/algorithms/overlaps.hpp]
+ ``[link boost_geometry.reference.one_section_segment_iterator.one_section_segment_iterator.overload1 one_section_segment_iterator]``(
+ const G & ring,
+ const SEC & section,
+ const B & box);
+ `` [''''»''' [link boost_geometry.reference.one_section_segment_iterator.one_section_segment_iterator.overload1 more...]]``
-[*Convenience header: ][^boost/geometry.hpp]
+ ``[link boost_geometry.reference.one_section_segment_iterator.one_section_segment_iterator.overload2 one_section_segment_iterator]``(
+ normal_iterator end);
+ `` [''''»''' [link boost_geometry.reference.one_section_segment_iterator.one_section_segment_iterator.overload2 more...]]``
-[endsect]
+[section:overload1 one_section_segment_iterator::one_section_segment_iterator (1 of 2 overloads)]
-[section:parse parse]
-[indexterm1 parse]
-
- template<
- typename Geometry >
- void ``[link boost_geometry.reference.parse.overload1 parse]``(
- Geometry & geometry,
- std::string const & c1,
- std::string const & c2);
- `` [''''»''' [link boost_geometry.reference.parse.overload1 more...]]``
+ one_section_segment_iterator(
+ const G & ring,
+ const SEC & section,
+ const B & box);
- template<
- typename Geometry ,
- typename S >
- void ``[link boost_geometry.reference.parse.overload2 parse]``(
- Geometry & geometry,
- std::string const & c1,
- std::string const & c2,
- S const & strategy);
- `` [''''»''' [link boost_geometry.reference.parse.overload2 more...]]``
- template<
- typename Geometry >
- Geometry ``[link boost_geometry.reference.parse.overload3 parse]``(
- std::string const & c1,
- std::string const & c2);
- `` [''''»''' [link boost_geometry.reference.parse.overload3 more...]]``
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/algorithms/parse.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:overload2 one_section_segment_iterator::one_section_segment_iterator (2 of 2 overloads)]
-[section:overload1 parse (1 of 3 overloads)]
+
+
+ one_section_segment_iterator(
+ normal_iterator end);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:operator_not__eq_ operator!=]
+
+[indexterm1 operator!=]
+
+ template<
+ typename Base ,
+ typename Point >
+ bool operator!=(
+ segment_iterator< Base, Point > const & lhs,
+ segment_iterator< Base, Point > const & rhs);
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:operator_eq__eq_ operator==]
+
+[indexterm1 operator==]
+
+ template<
+ typename Base ,
+ typename Point >
+ bool operator==(
+ segment_iterator< Base, Point > const & lhs,
+ segment_iterator< Base, Point > const & rhs);
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:order_selector order_selector]
+
+[indexterm1 order_selector]
+
+ enum order_selector
+
+[indexterm2 clockwise..order_selector]
+[indexterm2 counterclockwise..order_selector]
+[indexterm2 order_undetermined..order_selector]
+
+[heading Values]
+[variablelist
+
+ [
+ [clockwise]
+ []
+ ]
+
+ [
+ [counterclockwise]
+ []
+ ]
+
+ [
+ [order_undetermined]
+ []
+ ]
+
+]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_order.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:overlaps overlaps]
+
+[indexterm1 overlaps]
+Determines overlap between two geometries.
+
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ bool overlaps(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
+
+
+
+
+[heading Return Value]
+
+true if there is overlap
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/overlaps.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:parse parse]
+
+[indexterm1 parse]
+
+ template<
+ typename Geometry >
+ void ``[link boost_geometry.reference.parse.overload1 parse]``(
+ Geometry & geometry,
+ std::string const & c1,
+ std::string const & c2);
+ `` [''''»''' [link boost_geometry.reference.parse.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename S >
+ void ``[link boost_geometry.reference.parse.overload2 parse]``(
+ Geometry & geometry,
+ std::string const & c1,
+ std::string const & c2,
+ S const & strategy);
+ `` [''''»''' [link boost_geometry.reference.parse.overload2 more...]]``
+
+ template<
+ typename Geometry >
+ Geometry ``[link boost_geometry.reference.parse.overload3 parse]``(
+ std::string const & c1,
+ std::string const & c2);
+ `` [''''»''' [link boost_geometry.reference.parse.overload3 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/parse.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 parse (1 of 3 overloads)]
parse two strings to a spherical/geographic [link boost_geometry.reference.point `point`], using W/E/N/S
@@ -8214,6 +9197,7 @@
]
+
[heading Return Value]
the perimeter
@@ -8252,6 +9236,7 @@
]
+
[heading Return Value]
the perimeter
@@ -9248,184 +10233,168 @@
[endsect]
-[section:polygon polygon]
-
+[section:policies__relate__direction_type policies::relate::direction_type]
-The [link boost_geometry.reference.polygon `polygon`] contains an outer ring and zero or more inner rings.
[heading Synopsis]
- template<
- typename Point ,
- template< typename, typename > class ``[link boost_geometry.reference.PointList PointList]`` = std::vector,
- template< typename, typename > class ``[link boost_geometry.reference.RingList RingList]`` = std::vector,
- bool ``[link boost_geometry.reference.ClockWise ClockWise]`` = true,
- template< typename > class ``[link boost_geometry.reference.PointAlloc PointAlloc]`` = std::allocator,
- template< typename > class ``[link boost_geometry.reference.RingAlloc RingAlloc]`` = std::allocator>
- class polygon
+ struct direction_type
-[heading Public Types]
+[heading Public Member Functions]
[table
[[Name][Description]]
[
-
- [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
+ [[link boost_geometry.reference.policies__relate__direction_type.direction_type [*direction_type]]]
[]
-
]
+
+]
- [
- [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.arrival [*arrival]]]
[]
-
]
[
-
- [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ [[link boost_geometry.reference.policies__relate__direction_type.dir_a [*dir_a]]]
[]
-
]
-]
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.dir_b [*dir_b]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.how [*how]]]
+ []
+ ]
-[heading Public Member Functions]
-[table
- [[Name][Description]]
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.how_a [*how_a]]]
+ []
+ ]
[
- [[link boost_geometry.reference.polygon.clear [*clear]]]
- [Utility method, clears outer and inner rings. ]
+ [[link boost_geometry.reference.policies__relate__direction_type.how_b [*how_b]]]
+ []
]
-
+
[
- [[link boost_geometry.reference.polygon.inners [*inners]]]
+ [[link boost_geometry.reference.policies__relate__direction_type.opposite [*opposite]]]
[]
]
-
+
[
- [[link boost_geometry.reference.polygon.outer [*outer]]]
+ [[link boost_geometry.reference.policies__relate__direction_type.sides [*sides]]]
[]
]
-
+
]
[heading Description]
+[heading Requirements]
+[*Header: ][^boost/geometry/policies/relate/direction.hpp]
-[variablelist
-
-[[P][[link boost_geometry.reference.point `point`] type ]]
+[*Convenience header: ][^boost/geometry.hpp]
-[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
-[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+[section:arrival policies::relate::direction_type::arrival]
-[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
+[indexterm2 arrival..policies::relate::direction_type]
-[[PointAlloc][container-allocator-type ]]
+ int arrival;
-[[RingAlloc][container-allocator-type ]]
-]
+[endsect]
-[heading Remarks]
-
-The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+[section:dir_a policies::relate::direction_type::dir_a]
-[heading Requirements]
+[indexterm2 dir_a..policies::relate::direction_type]
-[*Header: ][^boost/geometry/geometries/polygon.hpp]
+ int dir_a;
-[*Convenience header: ][^boost/geometry.hpp]
-[section:clear polygon::clear]
+[endsect]
-[indexterm2 clear..polygon]
-Utility method, clears outer and inner rings.
- void clear();
+[section:dir_b policies::relate::direction_type::dir_b]
+[indexterm2 dir_b..policies::relate::direction_type]
+ int dir_b;
-[endsect]
+[endsect]
-[section:inner_container_type polygon::inner_container_type]
-[indexterm2 inner_container_type..polygon]
+[section:direction_type policies::relate::direction_type::direction_type]
- typedef RingList< ring_type, RingAlloc< ring_type > > inner_container_type;
+[indexterm2 direction_type..policies::relate::direction_type]
+ ``[link boost_geometry.reference.policies__relate__direction_type.direction_type.overload1 direction_type]``(
+ side_info const & s,
+ char h,
+ int ha,
+ int hb,
+ int da = 0,
+ int db = 0,
+ bool op = false);
+ `` [''''»''' [link boost_geometry.reference.policies__relate__direction_type.direction_type.overload1 more...]]``
-[heading Typedef Description]
-
+ ``[link boost_geometry.reference.policies__relate__direction_type.direction_type.overload2 direction_type]``(
+ char h,
+ bool op,
+ int ha = 0,
+ int hb = 0);
+ `` [''''»''' [link boost_geometry.reference.policies__relate__direction_type.direction_type.overload2 more...]]``
-[variablelist
-
-[[P][[link boost_geometry.reference.point `point`] type ]]
+[section:overload1 policies::relate::direction_type::direction_type (1 of 2 overloads)]
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
-[[A][optional container-allocator-type ]]
-]
+ direction_type(
+ side_info const & s,
+ char h,
+ int ha,
+ int hb,
+ int da = 0,
+ int db = 0,
+ bool op = false);
+[endsect]
-[heading Requirements]
-[*Header: ][^boost/geometry/geometries/polygon.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:overload2 policies::relate::direction_type::direction_type (2 of 2 overloads)]
-[endsect]
-
-[section:inners polygon::inners]
-
-[indexterm2 inners..polygon]
-
- inner_container_type const & ``[link boost_geometry.reference.polygon.inners.overload1 inners]``() const;
- `` [''''»''' [link boost_geometry.reference.polygon.inners.overload1 more...]]``
-
- inner_container_type & ``[link boost_geometry.reference.polygon.inners.overload2 inners]``();
- `` [''''»''' [link boost_geometry.reference.polygon.inners.overload2 more...]]``
-
-
-[section:overload1 polygon::inners (1 of 2 overloads)]
-
-
-
- inner_container_type const & inners() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 polygon::inners (2 of 2 overloads)]
-
-
-
- inner_container_type & inners();
+ direction_type(
+ char h,
+ bool op,
+ int ha = 0,
+ int hb = 0);
@@ -9434,22 +10403,12 @@
[endsect]
-[section:outer polygon::outer]
-
-[indexterm2 outer..polygon]
-
- ring_type const & ``[link boost_geometry.reference.polygon.outer.overload1 outer]``() const;
- `` [''''»''' [link boost_geometry.reference.polygon.outer.overload1 more...]]``
-
- ring_type & ``[link boost_geometry.reference.polygon.outer.overload2 outer]``();
- `` [''''»''' [link boost_geometry.reference.polygon.outer.overload2 more...]]``
-
-
-[section:overload1 polygon::outer (1 of 2 overloads)]
+[section:how policies::relate::direction_type::how]
+[indexterm2 how..policies::relate::direction_type]
- ring_type const & outer() const;
+ char how;
@@ -9457,68 +10416,48 @@
-[section:overload2 polygon::outer (2 of 2 overloads)]
-
-
-
- ring_type & outer();
+[section:how_a policies::relate::direction_type::how_a]
+[indexterm2 how_a..policies::relate::direction_type]
+ int how_a;
-[endsect]
[endsect]
-[section:point_type polygon::point_type]
-
-[indexterm2 point_type..polygon]
-
- typedef Point point_type;
-
+[section:how_b policies::relate::direction_type::how_b]
-[heading Requirements]
+[indexterm2 how_b..policies::relate::direction_type]
-[*Header: ][^boost/geometry/geometries/polygon.hpp]
+ int how_b;
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:ring_type polygon::ring_type]
-
-[indexterm2 ring_type..polygon]
-
- typedef linear_ring< Point, PointList, ClockWise, PointAlloc > ring_type;
-
-
-[heading Typedef Description]
-
+[section:opposite policies::relate::direction_type::opposite]
+[indexterm2 opposite..policies::relate::direction_type]
-[variablelist
-
-[[P][[link boost_geometry.reference.point `point`] type ]]
+ bool opposite;
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
-[[A][optional container-allocator-type ]]
-]
+[endsect]
+[section:sides policies::relate::direction_type::sides]
-[heading Requirements]
+[indexterm2 sides..policies::relate::direction_type]
-[*Header: ][^boost/geometry/geometries/polygon.hpp]
+ side_info sides;
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
@@ -9527,14 +10466,17 @@
[endsect]
+[section:policies__relate__segments_de9im policies::relate::segments_de9im]
-[section:polygon_2d polygon_2d]
-[indexterm1 polygon_2d]
- typedef polygon< point_2d > polygon_2d;
+[heading Synopsis]
+ template<
+ typename S1 ,
+ typename S2 >
+ struct segments_de9im
[heading Public Types]
[table
@@ -9542,21 +10484,28 @@
[
- [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
+ [[link boost_geometry.reference.policies__relate__segments_de9im.coordinate_type [*coordinate_type]]]
[]
]
[
- [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+ [[link boost_geometry.reference.policies__relate__segments_de9im.return_type [*return_type]]]
[]
]
[
- [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ [[link boost_geometry.reference.policies__relate__segments_de9im.segment_type1 [*segment_type1]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_de9im.segment_type2 [*segment_type2]]]
[]
]
@@ -9569,239 +10518,3334 @@
[[Name][Description]]
[
- [[link boost_geometry.reference.polygon.clear [*clear]]]
- [Utility method, clears outer and inner rings. ]
+ [[link boost_geometry.reference.policies__relate__segments_de9im.collinear_a_in_b [*collinear_a_in_b]]]
+ []
]
[
- [[link boost_geometry.reference.polygon.inners [*inners]]]
+ [[link boost_geometry.reference.policies__relate__segments_de9im.collinear_b_in_a [*collinear_b_in_a]]]
[]
]
[
- [[link boost_geometry.reference.polygon.outer [*outer]]]
+ [[link boost_geometry.reference.policies__relate__segments_de9im.collinear_disjoint [*collinear_disjoint]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_de9im.collinear_interior_boundary_intersect [*collinear_interior_boundary_intersect]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_de9im.collinear_overlaps [*collinear_overlaps]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_de9im.collinear_touch [*collinear_touch]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_de9im.degenerate [*degenerate]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_de9im.parallel [*parallel]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_de9im.rays_intersect [*rays_intersect]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_de9im.segment_equal [*segment_equal]]]
[]
]
]
-[heading Typedef Description]
-
-
-[variablelist
-
-[[P][[link boost_geometry.reference.point `point`] type ]]
+[heading Description]
-[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+[heading Requirements]
-[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+[*Header: ][^boost/geometry/policies/relate/de9im.hpp]
-[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
+[*Convenience header: ][^boost/geometry.hpp]
-[[PointAlloc][container-allocator-type ]]
-[[RingAlloc][container-allocator-type ]]
+[section:collinear_a_in_b policies::relate::segments_de9im::collinear_a_in_b]
-]
+[indexterm2 collinear_a_in_b..policies::relate::segments_de9im]
+ static return_type collinear_a_in_b(
+ S1 const & s,
+ bool opposite);
-[heading Remarks]
-
-The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+[endsect]
-[heading Requirements]
-[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+[section:collinear_b_in_a policies::relate::segments_de9im::collinear_b_in_a]
-[*Convenience header: ][^boost/geometry.hpp]
+[indexterm2 collinear_b_in_a..policies::relate::segments_de9im]
+ static return_type collinear_b_in_a(
+ const S2 & s,
+ bool opposite);
-[endsect]
+[endsect]
-[section:polygon_3d polygon_3d]
-[indexterm1 polygon_3d]
- typedef polygon< point_3d > polygon_3d;
+[section:collinear_disjoint policies::relate::segments_de9im::collinear_disjoint]
+[indexterm2 collinear_disjoint..policies::relate::segments_de9im]
+ static return_type collinear_disjoint();
-[heading Public Types]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
- []
-
- ]
+[endsect]
- [
- [[link boost_geometry.reference.polygon.point_type [*point_type]]]
- []
-
- ]
- [
+[section:collinear_interior_boundary_intersect policies::relate::segments_de9im::collinear_interior_boundary_intersect]
- [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
- []
-
- ]
+[indexterm2 collinear_interior_boundary_intersect..policies::relate::segments_de9im]
-]
+ template<
+ typename S >
+ static return_type collinear_interior_boundary_intersect(
+ S const & s,
+ bool a_within_b,
+ bool opposite);
-[heading Public Member Functions]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.polygon.clear [*clear]]]
- [Utility method, clears outer and inner rings. ]
- ]
-
- [
- [[link boost_geometry.reference.polygon.inners [*inners]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.polygon.outer [*outer]]]
- []
- ]
-
-]
+[endsect]
-[heading Typedef Description]
-
-[variablelist
-
-[[P][[link boost_geometry.reference.point `point`] type ]]
+[section:collinear_overlaps policies::relate::segments_de9im::collinear_overlaps]
-[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+[indexterm2 collinear_overlaps..policies::relate::segments_de9im]
-[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+ static return_type collinear_overlaps(
+ coordinate_type const & x1,
+ coordinate_type const & y1,
+ coordinate_type const & x2,
+ coordinate_type const & y2,
+ bool opposite);
-[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
-[[PointAlloc][container-allocator-type ]]
-[[RingAlloc][container-allocator-type ]]
+[endsect]
-]
-[heading Remarks]
-
-The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+[section:collinear_touch policies::relate::segments_de9im::collinear_touch]
+[indexterm2 collinear_touch..policies::relate::segments_de9im]
+ static return_type collinear_touch(
+ coordinate_type const & x,
+ coordinate_type const & y,
+ bool opposite,
+ char );
-[heading Requirements]
-[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:coordinate_type policies::relate::segments_de9im::coordinate_type]
+[indexterm2 coordinate_type..policies::relate::segments_de9im]
-[section:polygon_tag polygon_tag]
+ typedef select_coordinate_type< S1, S2 >::type coordinate_type;
-OGC Polygon identifying [link boost_geometry.reference.tag `tag`].
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
+ []
+
+ ]
-[heading Synopsis]
- struct polygon_tag
+]
-[heading Description]
+[heading Typedef Description]
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[*Header: ][^boost/geometry/policies/relate/de9im.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:radian radian]
-
-Unit of plane angle: Radians.
+[section:degenerate policies::relate::segments_de9im::degenerate]
+[indexterm2 degenerate..policies::relate::segments_de9im]
+ static return_type degenerate(
+ S1 const & segment,
+ bool a_degenerate);
-[heading Synopsis]
- class radian
-[heading Description]
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/core/cs.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:parallel policies::relate::segments_de9im::parallel]
-[endsect]
+[indexterm2 parallel..policies::relate::segments_de9im]
-[section:replace_point_type replace_point_type]
+ static return_type parallel();
+[endsect]
-[heading Synopsis]
- template<
- typename Geometry ,
- typename NewPointType >
- struct replace_point_type
-[heading Description]
+[section:rays_intersect policies::relate::segments_de9im::rays_intersect]
-[heading Requirements]
+[indexterm2 rays_intersect..policies::relate::segments_de9im]
-[*Header: ][^boost/geometry/core/replace_point_type.hpp]
+ static return_type rays_intersect(
+ bool on_segment,
+ double ra,
+ double rb,
+ coordinate_type const & dx1,
+ coordinate_type const & dy1,
+ coordinate_type const & dx2,
+ coordinate_type const & dy2,
+ coordinate_type const & wx,
+ coordinate_type const & wy,
+ S1 const & s1,
+ S2 const & s2);
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:reverse reverse]
-[indexterm1 reverse]
+[section:return_type policies::relate::segments_de9im::return_type]
- template<
- typename Geometry >
- void reverse(
- Geometry & geometry);
+[indexterm2 return_type..policies::relate::segments_de9im]
+ typedef de9im_segment return_type;
-[variablelist
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.as_char [*as_char]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.contains [*contains]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.crosses [*crosses]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.de9im_segment [*de9im_segment]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.disjoint [*disjoint]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.equals [*equals]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.intersects [*intersects]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.overlaps [*overlaps]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.touches [*touches]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.de9im_segment.within [*within]]]
+ []
+ ]
+
+]
+
+
+[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 Typedef Description]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/de9im.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_equal policies::relate::segments_de9im::segment_equal]
+
+[indexterm2 segment_equal..policies::relate::segments_de9im]
+
+ static return_type segment_equal(
+ S1 const & s,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:segment_type1 policies::relate::segments_de9im::segment_type1]
+
+[indexterm2 segment_type1..policies::relate::segments_de9im]
+
+ typedef S1 segment_type1;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/de9im.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_type2 policies::relate::segments_de9im::segment_type2]
+
+[indexterm2 segment_type2..policies::relate::segments_de9im]
+
+ typedef S2 segment_type2;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/de9im.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:policies__relate__segments_direction policies::relate::segments_direction]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename S1 ,
+ typename S2 ,
+ typename CalculationType = void>
+ struct segments_direction
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_direction.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_direction.return_type [*return_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_direction.rtype [*rtype]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_direction.segment_type1 [*segment_type1]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_direction.segment_type2 [*segment_type2]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.collinear_a_in_b [*collinear_a_in_b]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.collinear_b_in_a [*collinear_b_in_a]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.collinear_disjoint [*collinear_disjoint]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.collinear_interior_boundary_intersect [*collinear_interior_boundary_intersect]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.collinear_overlaps [*collinear_overlaps]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.collinear_touch [*collinear_touch]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.degenerate [*degenerate]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.disjoint [*disjoint]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.error [*error]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.parallel [*parallel]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.segment_equal [*segment_equal]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_direction.segments_intersect [*segments_intersect]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/direction.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:collinear_a_in_b policies::relate::segments_direction::collinear_a_in_b]
+
+[indexterm2 collinear_a_in_b..policies::relate::segments_direction]
+
+ static return_type collinear_a_in_b(
+ S1 const & ,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:collinear_b_in_a policies::relate::segments_direction::collinear_b_in_a]
+
+[indexterm2 collinear_b_in_a..policies::relate::segments_direction]
+
+ static return_type collinear_b_in_a(
+ S2 const & ,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:collinear_disjoint policies::relate::segments_direction::collinear_disjoint]
+
+[indexterm2 collinear_disjoint..policies::relate::segments_direction]
+
+ static return_type collinear_disjoint();
+
+
+
+[endsect]
+
+
+
+[section:collinear_interior_boundary_intersect policies::relate::segments_direction::collinear_interior_boundary_intersect]
+
+[indexterm2 collinear_interior_boundary_intersect..policies::relate::segments_direction]
+
+ template<
+ typename S >
+ static return_type collinear_interior_boundary_intersect(
+ S const & ,
+ bool ,
+ int arrival_a,
+ int arrival_b,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:collinear_overlaps policies::relate::segments_direction::collinear_overlaps]
+
+[indexterm2 collinear_overlaps..policies::relate::segments_direction]
+
+ static return_type collinear_overlaps(
+ coordinate_type const & ,
+ coordinate_type const & ,
+ coordinate_type const & ,
+ coordinate_type const & ,
+ int arrival_a,
+ int arrival_b,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:collinear_touch policies::relate::segments_direction::collinear_touch]
+
+[indexterm2 collinear_touch..policies::relate::segments_direction]
+
+ static return_type collinear_touch(
+ coordinate_type const & ,
+ coordinate_type const & ,
+ int arrival_a,
+ int arrival_b);
+
+
+
+[endsect]
+
+
+
+[section:coordinate_type policies::relate::segments_direction::coordinate_type]
+
+[indexterm2 coordinate_type..policies::relate::segments_direction]
+
+ typedef select_calculation_type< S1, S2, CalculationType >::type coordinate_type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_calculation_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+Based on two input [link boost_geometry.reference.boost__geometry `boost::geometry`] types, and an input calculation type, (which defaults to void in the calling function), this meta-function selects the most appropriate:
+* if calculation type is specified, that one is used,
+
+* if it is void, the most precise of the two points is used
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/direction.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:degenerate policies::relate::segments_direction::degenerate]
+
+[indexterm2 degenerate..policies::relate::segments_direction]
+
+ static return_type degenerate(
+ S1 const & ,
+ bool );
+
+
+
+[endsect]
+
+
+
+[section:disjoint policies::relate::segments_direction::disjoint]
+
+[indexterm2 disjoint..policies::relate::segments_direction]
+
+ static return_type disjoint();
+
+
+
+[endsect]
+
+
+
+[section:error policies::relate::segments_direction::error]
+
+[indexterm2 error..policies::relate::segments_direction]
+
+ static return_type error(
+ std::string const & msg);
+
+
+
+[endsect]
+
+
+
+[section:parallel policies::relate::segments_direction::parallel]
+
+[indexterm2 parallel..policies::relate::segments_direction]
+
+ static return_type parallel();
+
+
+
+[endsect]
+
+
+
+[section:return_type policies::relate::segments_direction::return_type]
+
+[indexterm2 return_type..policies::relate::segments_direction]
+
+ typedef direction_type return_type;
+
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.direction_type [*direction_type]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.arrival [*arrival]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.dir_a [*dir_a]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.dir_b [*dir_b]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.how [*how]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.how_a [*how_a]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.how_b [*how_b]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.opposite [*opposite]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__direction_type.sides [*sides]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/direction.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:rtype policies::relate::segments_direction::rtype]
+
+[indexterm2 rtype..policies::relate::segments_direction]
+
+ typedef select_most_precise< coordinate_type, double >::type rtype;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_most_precise.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.both_same [*both_same]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.one_not_fundamental [*one_not_fundamental]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.second_larger [*second_larger]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+[link boost_geometry.reference.select_most_precise `select_most_precise`] classes, compares two types on compile time. For example, if an addition must be done with a double and an integer, the result must be a double. If both types are integer, the result can be an integer.
+
+[heading Remarks]
+
+It is different from the "promote" class, already in `boost`. That class promotes e.g. a (one) float to a double. This class selects a type from two types. It takes the most accurate, but does not promote afterwards.
+
+This [link boost_geometry.reference.traits `traits`] class is completely independant from GGL and might be a separate addition to Boost
+
+If the input is a non-fundamental type, it might be a calculation type such as a GMP-value or another high precision value. Therefore, if one is non-fundamental, that one is chosen.
+
+If both types are non-fundamental, the result is indeterminate and currently the first one is chosen.
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/direction.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_equal policies::relate::segments_direction::segment_equal]
+
+[indexterm2 segment_equal..policies::relate::segments_direction]
+
+ static return_type segment_equal(
+ S1 const & ,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:segment_type1 policies::relate::segments_direction::segment_type1]
+
+[indexterm2 segment_type1..policies::relate::segments_direction]
+
+ typedef S1 segment_type1;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/direction.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_type2 policies::relate::segments_direction::segment_type2]
+
+[indexterm2 segment_type2..policies::relate::segments_direction]
+
+ typedef S2 segment_type2;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/direction.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segments_intersect policies::relate::segments_direction::segments_intersect]
+
+[indexterm2 segments_intersect..policies::relate::segments_direction]
+
+ static return_type segments_intersect(
+ side_info const & sides,
+ coordinate_type const & dx1,
+ coordinate_type const & dy1,
+ coordinate_type const & dx2,
+ coordinate_type const & dy2,
+ S1 const & s1,
+ S2 const & s2);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:policies__relate__segments_intersection_points policies::relate::segments_intersection_points]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename S1 ,
+ typename S2 ,
+ typename ReturnType ,
+ typename CalculationType = void>
+ struct segments_intersection_points
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.promoted_type [*promoted_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.return_type [*return_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.segment_type1 [*segment_type1]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.segment_type2 [*segment_type2]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.collinear_a_in_b [*collinear_a_in_b]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.collinear_b_in_a [*collinear_b_in_a]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.collinear_disjoint [*collinear_disjoint]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.collinear_inside [*collinear_inside]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.collinear_interior_boundary_intersect [*collinear_interior_boundary_intersect]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.collinear_overlaps [*collinear_overlaps]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.collinear_touch [*collinear_touch]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.cross [*cross]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.degenerate [*degenerate]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.disjoint [*disjoint]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.error [*error]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.parallel [*parallel]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.rico [*rico]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.segment_equal [*segment_equal]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_intersection_points.segments_intersect [*segments_intersect]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/intersection_points_slope.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:collinear_a_in_b policies::relate::segments_intersection_points::collinear_a_in_b]
+
+[indexterm2 collinear_a_in_b..policies::relate::segments_intersection_points]
+
+ static return_type collinear_a_in_b(
+ S1 const & s,
+ bool );
+
+
+
+[endsect]
+
+
+
+[section:collinear_b_in_a policies::relate::segments_intersection_points::collinear_b_in_a]
+
+[indexterm2 collinear_b_in_a..policies::relate::segments_intersection_points]
+
+ static return_type collinear_b_in_a(
+ S2 const & s,
+ bool );
+
+
+
+[endsect]
+
+
+
+[section:collinear_disjoint policies::relate::segments_intersection_points::collinear_disjoint]
+
+[indexterm2 collinear_disjoint..policies::relate::segments_intersection_points]
+
+ static return_type collinear_disjoint();
+
+
+
+[endsect]
+
+
+
+[section:collinear_inside policies::relate::segments_intersection_points::collinear_inside]
+
+[indexterm2 collinear_inside..policies::relate::segments_intersection_points]
+
+ template<
+ typename S >
+ static return_type collinear_inside(
+ S const & s);
+
+
+
+[endsect]
+
+
+
+[section:collinear_interior_boundary_intersect policies::relate::segments_intersection_points::collinear_interior_boundary_intersect]
+
+[indexterm2 collinear_interior_boundary_intersect..policies::relate::segments_intersection_points]
+
+ template<
+ typename S >
+ static return_type collinear_interior_boundary_intersect(
+ S const & s,
+ bool ,
+ bool );
+
+
+
+[endsect]
+
+
+
+[section:collinear_overlaps policies::relate::segments_intersection_points::collinear_overlaps]
+
+[indexterm2 collinear_overlaps..policies::relate::segments_intersection_points]
+
+ static return_type collinear_overlaps(
+ coordinate_type const & x1,
+ coordinate_type const & y1,
+ coordinate_type const & x2,
+ coordinate_type const & y2,
+ bool );
+
+
+
+[endsect]
+
+
+
+[section:collinear_touch policies::relate::segments_intersection_points::collinear_touch]
+
+[indexterm2 collinear_touch..policies::relate::segments_intersection_points]
+
+ static return_type collinear_touch(
+ coordinate_type const & x,
+ coordinate_type const & y,
+ bool ,
+ char );
+
+
+
+[endsect]
+
+
+
+[section:coordinate_type policies::relate::segments_intersection_points::coordinate_type]
+
+[indexterm2 coordinate_type..policies::relate::segments_intersection_points]
+
+ typedef select_calculation_type< S1, S2, CalculationType >::type coordinate_type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_calculation_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+Based on two input [link boost_geometry.reference.boost__geometry `boost::geometry`] types, and an input calculation type, (which defaults to void in the calling function), this meta-function selects the most appropriate:
+* if calculation type is specified, that one is used,
+
+* if it is void, the most precise of the two points is used
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/intersection_points_slope.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:cross policies::relate::segments_intersection_points::cross]
+
+[indexterm2 cross..policies::relate::segments_intersection_points]
+
+ static return_type cross(
+ S1 const & s1,
+ S2 const & s2);
+
+
+
+[endsect]
+
+
+
+[section:degenerate policies::relate::segments_intersection_points::degenerate]
+
+[indexterm2 degenerate..policies::relate::segments_intersection_points]
+
+ static return_type degenerate(
+ S1 const & s,
+ bool );
+
+
+
+[endsect]
+
+
+
+[section:disjoint policies::relate::segments_intersection_points::disjoint]
+
+[indexterm2 disjoint..policies::relate::segments_intersection_points]
+
+ static return_type disjoint();
+
+
+
+[endsect]
+
+
+
+[section:error policies::relate::segments_intersection_points::error]
+
+[indexterm2 error..policies::relate::segments_intersection_points]
+
+ static return_type error(
+ std::string const & msg);
+
+
+
+[endsect]
+
+
+
+[section:parallel policies::relate::segments_intersection_points::parallel]
+
+[indexterm2 parallel..policies::relate::segments_intersection_points]
+
+ static return_type parallel();
+
+
+
+[endsect]
+
+
+
+[section:promoted_type policies::relate::segments_intersection_points::promoted_type]
+
+[indexterm2 promoted_type..policies::relate::segments_intersection_points]
+
+ typedef select_most_precise< coordinate_type, double >::type promoted_type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_most_precise.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.both_same [*both_same]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.one_not_fundamental [*one_not_fundamental]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.second_larger [*second_larger]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+[link boost_geometry.reference.select_most_precise `select_most_precise`] classes, compares two types on compile time. For example, if an addition must be done with a double and an integer, the result must be a double. If both types are integer, the result can be an integer.
+
+[heading Remarks]
+
+It is different from the "promote" class, already in `boost`. That class promotes e.g. a (one) float to a double. This class selects a type from two types. It takes the most accurate, but does not promote afterwards.
+
+This [link boost_geometry.reference.traits `traits`] class is completely independant from GGL and might be a separate addition to Boost
+
+If the input is a non-fundamental type, it might be a calculation type such as a GMP-value or another high precision value. Therefore, if one is non-fundamental, that one is chosen.
+
+If both types are non-fundamental, the result is indeterminate and currently the first one is chosen.
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/intersection_points_slope.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:return_type policies::relate::segments_intersection_points::return_type]
+
+[indexterm2 return_type..policies::relate::segments_intersection_points]
+
+ typedef ReturnType return_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/intersection_points_slope.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:rico policies::relate::segments_intersection_points::rico]
+
+[indexterm2 rico..policies::relate::segments_intersection_points]
+
+ template<
+ int ``[link boost_geometry.reference.Dimension Dimension]``>
+ static return_type rico(
+ coordinate_type const & dm1,
+ coordinate_type const & dn1,
+ coordinate_type const & dm2,
+ coordinate_type const & dn2,
+ S1 const & s1,
+ S2 const & s2);
+
+
+
+[endsect]
+
+
+
+[section:segment_equal policies::relate::segments_intersection_points::segment_equal]
+
+[indexterm2 segment_equal..policies::relate::segments_intersection_points]
+
+ static return_type segment_equal(
+ S1 const & s,
+ bool );
+
+
+
+[endsect]
+
+
+
+[section:segment_type1 policies::relate::segments_intersection_points::segment_type1]
+
+[indexterm2 segment_type1..policies::relate::segments_intersection_points]
+
+ typedef S1 segment_type1;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/intersection_points_slope.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_type2 policies::relate::segments_intersection_points::segment_type2]
+
+[indexterm2 segment_type2..policies::relate::segments_intersection_points]
+
+ typedef S2 segment_type2;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/intersection_points_slope.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segments_intersect policies::relate::segments_intersection_points::segments_intersect]
+
+[indexterm2 segments_intersect..policies::relate::segments_intersection_points]
+
+ static return_type segments_intersect(
+ side_info const & sides,
+ coordinate_type const & dx1,
+ coordinate_type const & dy1,
+ coordinate_type const & dx2,
+ coordinate_type const & dy2,
+ S1 const & s1,
+ S2 const & s2);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:policies__relate__segments_tupled policies::relate::segments_tupled]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Policy1 ,
+ typename Policy2 ,
+ typename CalculationType = void>
+ struct segments_tupled
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_tupled.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_tupled.return_type [*return_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_tupled.rtype [*rtype]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_tupled.segment_type1 [*segment_type1]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.policies__relate__segments_tupled.segment_type2 [*segment_type2]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.collinear_a_in_b [*collinear_a_in_b]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.collinear_b_in_a [*collinear_b_in_a]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.collinear_disjoint [*collinear_disjoint]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.collinear_interior_boundary_intersect [*collinear_interior_boundary_intersect]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.collinear_overlaps [*collinear_overlaps]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.collinear_touch [*collinear_touch]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.degenerate [*degenerate]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.disjoint [*disjoint]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.error [*error]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.parallel [*parallel]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.segment_equal [*segment_equal]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.policies__relate__segments_tupled.segments_intersect [*segments_intersect]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/tupled.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:collinear_a_in_b policies::relate::segments_tupled::collinear_a_in_b]
+
+[indexterm2 collinear_a_in_b..policies::relate::segments_tupled]
+
+ static return_type collinear_a_in_b(
+ segment_type1 const & segment,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:collinear_b_in_a policies::relate::segments_tupled::collinear_b_in_a]
+
+[indexterm2 collinear_b_in_a..policies::relate::segments_tupled]
+
+ static return_type collinear_b_in_a(
+ segment_type2 const & segment,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:collinear_disjoint policies::relate::segments_tupled::collinear_disjoint]
+
+[indexterm2 collinear_disjoint..policies::relate::segments_tupled]
+
+ static return_type collinear_disjoint();
+
+
+
+[endsect]
+
+
+
+[section:collinear_interior_boundary_intersect policies::relate::segments_tupled::collinear_interior_boundary_intersect]
+
+[indexterm2 collinear_interior_boundary_intersect..policies::relate::segments_tupled]
+
+ template<
+ typename S >
+ static return_type collinear_interior_boundary_intersect(
+ S const & segment,
+ bool a_within_b,
+ int arrival_a,
+ int arrival_b,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:collinear_overlaps policies::relate::segments_tupled::collinear_overlaps]
+
+[indexterm2 collinear_overlaps..policies::relate::segments_tupled]
+
+ static return_type collinear_overlaps(
+ coordinate_type const & x1,
+ coordinate_type const & y1,
+ coordinate_type const & x2,
+ coordinate_type const & y2,
+ int arrival_a,
+ int arrival_b,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:collinear_touch policies::relate::segments_tupled::collinear_touch]
+
+[indexterm2 collinear_touch..policies::relate::segments_tupled]
+
+ static return_type collinear_touch(
+ coordinate_type const & x,
+ coordinate_type const & y,
+ int arrival_a,
+ int arrival_b);
+
+
+
+[endsect]
+
+
+
+[section:coordinate_type policies::relate::segments_tupled::coordinate_type]
+
+[indexterm2 coordinate_type..policies::relate::segments_tupled]
+
+ typedef select_calculation_type< segment_type1, segment_type2, CalculationType >::type coordinate_type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_calculation_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+Based on two input [link boost_geometry.reference.boost__geometry `boost::geometry`] types, and an input calculation type, (which defaults to void in the calling function), this meta-function selects the most appropriate:
+* if calculation type is specified, that one is used,
+
+* if it is void, the most precise of the two points is used
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/tupled.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:degenerate policies::relate::segments_tupled::degenerate]
+
+[indexterm2 degenerate..policies::relate::segments_tupled]
+
+ static return_type degenerate(
+ segment_type1 const & segment,
+ bool a_degenerate);
+
+
+
+[endsect]
+
+
+
+[section:disjoint policies::relate::segments_tupled::disjoint]
+
+[indexterm2 disjoint..policies::relate::segments_tupled]
+
+ static return_type disjoint();
+
+
+
+[endsect]
+
+
+
+[section:error policies::relate::segments_tupled::error]
+
+[indexterm2 error..policies::relate::segments_tupled]
+
+ static return_type error(
+ std::string const & msg);
+
+
+
+[endsect]
+
+
+
+[section:parallel policies::relate::segments_tupled::parallel]
+
+[indexterm2 parallel..policies::relate::segments_tupled]
+
+ static return_type parallel();
+
+
+
+[endsect]
+
+
+
+[section:return_type policies::relate::segments_tupled::return_type]
+
+[indexterm2 return_type..policies::relate::segments_tupled]
+
+ typedef boost::tuple< typename Policy1::return_type, typename Policy2::return_type > return_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/tupled.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:rtype policies::relate::segments_tupled::rtype]
+
+[indexterm2 rtype..policies::relate::segments_tupled]
+
+ typedef select_most_precise< coordinate_type, double >::type rtype;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_most_precise.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.both_same [*both_same]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.one_not_fundamental [*one_not_fundamental]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.second_larger [*second_larger]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+[link boost_geometry.reference.select_most_precise `select_most_precise`] classes, compares two types on compile time. For example, if an addition must be done with a double and an integer, the result must be a double. If both types are integer, the result can be an integer.
+
+[heading Remarks]
+
+It is different from the "promote" class, already in `boost`. That class promotes e.g. a (one) float to a double. This class selects a type from two types. It takes the most accurate, but does not promote afterwards.
+
+This [link boost_geometry.reference.traits `traits`] class is completely independant from GGL and might be a separate addition to Boost
+
+If the input is a non-fundamental type, it might be a calculation type such as a GMP-value or another high precision value. Therefore, if one is non-fundamental, that one is chosen.
+
+If both types are non-fundamental, the result is indeterminate and currently the first one is chosen.
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/tupled.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_equal policies::relate::segments_tupled::segment_equal]
+
+[indexterm2 segment_equal..policies::relate::segments_tupled]
+
+ static return_type segment_equal(
+ segment_type1 const & s,
+ bool opposite);
+
+
+
+[endsect]
+
+
+
+[section:segment_type1 policies::relate::segments_tupled::segment_type1]
+
+[indexterm2 segment_type1..policies::relate::segments_tupled]
+
+ typedef Policy1::segment_type1 segment_type1;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/tupled.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segment_type2 policies::relate::segments_tupled::segment_type2]
+
+[indexterm2 segment_type2..policies::relate::segments_tupled]
+
+ typedef Policy1::segment_type2 segment_type2;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/policies/relate/tupled.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:segments_intersect policies::relate::segments_tupled::segments_intersect]
+
+[indexterm2 segments_intersect..policies::relate::segments_tupled]
+
+ static return_type segments_intersect(
+ side_info const & sides,
+ coordinate_type const & dx1,
+ coordinate_type const & dy1,
+ coordinate_type const & dx2,
+ coordinate_type const & dy2,
+ segment_type1 const & s1,
+ segment_type2 const & s2);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:polygon polygon]
+
+
+The [link boost_geometry.reference.polygon `polygon`] contains an outer ring and zero or more inner rings.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Point ,
+ template< typename, typename > class ``[link boost_geometry.reference.PointList PointList]`` = std::vector,
+ template< typename, typename > class ``[link boost_geometry.reference.RingList RingList]`` = std::vector,
+ bool ``[link boost_geometry.reference.ClockWise ClockWise]`` = true,
+ template< typename > class ``[link boost_geometry.reference.PointAlloc PointAlloc]`` = std::allocator,
+ template< typename > class ``[link boost_geometry.reference.RingAlloc RingAlloc]`` = std::allocator>
+ class polygon
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.polygon.clear [*clear]]]
+ [Utility method, clears outer and inner rings. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.inners [*inners]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.outer [*outer]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+
+[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+
+[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
+
+[[PointAlloc][container-allocator-type ]]
+
+[[RingAlloc][container-allocator-type ]]
+
+]
+
+
+
+[heading Remarks]
+
+The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:clear polygon::clear]
+
+[indexterm2 clear..polygon]
+Utility method, clears outer and inner rings.
+
+
+ void clear();
+
+
+
+[endsect]
+
+
+
+[section:inner_container_type polygon::inner_container_type]
+
+[indexterm2 inner_container_type..polygon]
+
+ typedef RingList< ring_type, RingAlloc< ring_type > > inner_container_type;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:inners polygon::inners]
+
+[indexterm2 inners..polygon]
+
+ inner_container_type const & ``[link boost_geometry.reference.polygon.inners.overload1 inners]``() const;
+ `` [''''»''' [link boost_geometry.reference.polygon.inners.overload1 more...]]``
+
+ inner_container_type & ``[link boost_geometry.reference.polygon.inners.overload2 inners]``();
+ `` [''''»''' [link boost_geometry.reference.polygon.inners.overload2 more...]]``
+
+
+[section:overload1 polygon::inners (1 of 2 overloads)]
+
+
+
+ inner_container_type const & inners() const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 polygon::inners (2 of 2 overloads)]
+
+
+
+ inner_container_type & inners();
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:outer polygon::outer]
+
+[indexterm2 outer..polygon]
+
+ ring_type const & ``[link boost_geometry.reference.polygon.outer.overload1 outer]``() const;
+ `` [''''»''' [link boost_geometry.reference.polygon.outer.overload1 more...]]``
+
+ ring_type & ``[link boost_geometry.reference.polygon.outer.overload2 outer]``();
+ `` [''''»''' [link boost_geometry.reference.polygon.outer.overload2 more...]]``
+
+
+[section:overload1 polygon::outer (1 of 2 overloads)]
+
+
+
+ ring_type const & outer() const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 polygon::outer (2 of 2 overloads)]
+
+
+
+ ring_type & outer();
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:point_type polygon::point_type]
+
+[indexterm2 point_type..polygon]
+
+ typedef Point point_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:ring_type polygon::ring_type]
+
+[indexterm2 ring_type..polygon]
+
+ typedef linear_ring< Point, PointList, ClockWise, PointAlloc > ring_type;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:polygon_2d polygon_2d]
+
+[indexterm1 polygon_2d]
+
+ typedef polygon< point_2d > polygon_2d;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.polygon.clear [*clear]]]
+ [Utility method, clears outer and inner rings. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.inners [*inners]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.outer [*outer]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+
+[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+
+[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
+
+[[PointAlloc][container-allocator-type ]]
+
+[[RingAlloc][container-allocator-type ]]
+
+]
+
+
+
+[heading Remarks]
+
+The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:polygon_3d polygon_3d]
+
+[indexterm1 polygon_3d]
+
+ typedef polygon< point_3d > polygon_3d;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.polygon.clear [*clear]]]
+ [Utility method, clears outer and inner rings. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.inners [*inners]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.polygon.outer [*outer]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+
+[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+
+[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
+
+[[PointAlloc][container-allocator-type ]]
+
+[[RingAlloc][container-allocator-type ]]
+
+]
+
+
+
+[heading Remarks]
+
+The container collecting the points in the rings can be different from the container collecting the inner rings. They all default to vector.
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:polygon_tag polygon_tag]
+
+
+OGC Polygon identifying [link boost_geometry.reference.tag `tag`].
+
+
+
+
+[heading Synopsis]
+ struct polygon_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:radian radian]
+
+
+Unit of plane angle: Radians.
+
+
+
+
+[heading Synopsis]
+ class radian
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/cs.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:range_iterator_const_if_c range_iterator_const_if_c]
+
+
+Meta-function to define a const or non const `boost` range iterator.
+
+
+
+
+[heading Synopsis]
+ template<
+ bool ``[link boost_geometry.reference.IsConst IsConst]``,
+ typename Range >
+ struct range_iterator_const_if_c
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.range_iterator_const_if_c.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Description]
+
+Is used to have one implementation for both const and non const range iterators
+
+[heading Remarks]
+
+This [link boost_geometry.reference.traits `traits`] class is completely independant from GGL and might be a separate addition to Boost
+
+Used in for\_each
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/range_iterator_const_if_c.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:type range_iterator_const_if_c::type]
+
+[indexterm2 type..range_iterator_const_if_c]
+
+ typedef boost::mpl::if_c< IsConst, typename boost::range_const_iterator< Range >::type, typename boost::range_iterator< Range >::type >::type type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/range_iterator_const_if_c.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:range_type range_type]
+
+
+Meta-function defining a type which is a boost-range.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ struct range_type
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.range_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Description]
+
+
+* For linestrings and rings, it defines the type itself.
+
+* For polygons it defines the ring type.
+
+* For multi-points, it defines the type itself
+
+* For multi-polygons and multi-linestrings, it defines the single-version (so in the end the linestring and ring-type-of-multi-polygon)
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/iterators/range_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:type range_type::type]
+
+[indexterm2 type..range_type]
+
+ typedef dispatch::range_type< typename tag< Geometry >::type, Geometry >::type type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.tag.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type ([link boost_geometry.reference.point `point`], [link boost_geometry.reference.linestring `linestring`], [link boost_geometry.reference.polygon `polygon`], etc) by implementing a [link boost_geometry.reference.tag `tag`] [link boost_geometry.reference.traits `traits`] class. This meta-function uses that [link boost_geometry.reference.traits `traits`] class to retrieve the [link boost_geometry.reference.tag `tag`]. If the input type is not a [link boost_geometry.reference.boost__geometry `boost::geometry`] at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/iterators/range_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:replace_point_type replace_point_type]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry ,
+ typename NewPointType >
+ struct replace_point_type
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/replace_point_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:reverse reverse]
+
+[indexterm1 reverse]
+
+ template<
+ typename Geometry >
+ void reverse(
+ Geometry & geometry);
+
+
+
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make reverse ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/reverse.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:reverse_dispatch reverse_dispatch]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ struct reverse_dispatch
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/reverse_dispatch.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:ring_2d ring_2d]
+
+[indexterm1 ring_2d]
+
+ typedef linear_ring< point_2d > ring_2d;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:ring_3d ring_3d]
+
+[indexterm1 ring_3d]
+
+ typedef linear_ring< point_3d > ring_3d;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][[link boost_geometry.reference.point `point`] type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:ring_tag ring_tag]
+
+
+Convenience (linear) ring identifying [link boost_geometry.reference.tag `tag`].
+
+
+
+
+[heading Synopsis]
+ struct ring_tag
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:ring_type ring_type]
+
+
+Meta-function which defines ring type of (multi)[link boost_geometry.reference.polygon `polygon`] [link boost_geometry.reference.boost__geometry `boost::geometry`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Geometry >
+ struct ring_type
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.ring_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Description]
+
+a [link boost_geometry.reference.polygon `polygon`] contains one exterior ring and zero or more interior rings (holes). This meta function retrieves the type of the rings
+
+[heading Remarks]
+
+Exterior ring and interior rings must have the same ring-type.
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/ring_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:type ring_type::type]
+
+[indexterm2 type..ring_type]
+
+ typedef core_dispatch::ring_type< typename tag< Geometry >::type, Geometry >::type type;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.tag.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type ([link boost_geometry.reference.point `point`], [link boost_geometry.reference.linestring `linestring`], [link boost_geometry.reference.polygon `polygon`], etc) by implementing a [link boost_geometry.reference.tag `tag`] [link boost_geometry.reference.traits `traits`] class. This meta-function uses that [link boost_geometry.reference.traits `traits`] class to retrieve the [link boost_geometry.reference.tag `tag`]. If the input type is not a [link boost_geometry.reference.boost__geometry `boost::geometry`] at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+
+[variablelist
+
+[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/ring_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:section section]
+
+
+Structure containing [link boost_geometry.reference.section `section`] information.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Box ,
+ std::size_t ``[link boost_geometry.reference.DimensionCount DimensionCount]``>
+ struct section
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.section.box_type [*box_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.section.section [*section]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.section.begin_index [*begin_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.bounding_box [*bounding_box]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.count [*count]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.directions [*directions]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.duplicate [*duplicate]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.end_index [*end_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.id [*id]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.multi_index [*multi_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.non_duplicate_index [*non_duplicate_index]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.range_count [*range_count]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.section.ring_index [*ring_index]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+Section information consists of a bounding [link boost_geometry.reference.box `box`], direction information (if it is increasing or decreasing, per [link boost_geometry.reference.dimension `dimension`]), index information (begin-end, ring, multi) and the number of segments in this [link boost_geometry.reference.section `section`]
+
+
+
+[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Box][box-type ]]
+
+[[DimensionCount][number of dimensions for this [link boost_geometry.reference.section `section`] ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:begin_index section::begin_index]
+
+[indexterm2 begin_index..section]
+
+ int begin_index;
+
+
+
+[endsect]
+
+
+
+[section:bounding_box section::bounding_box]
+
+[indexterm2 bounding_box..section]
+
+ Box bounding_box;
+
+
+
+[endsect]
+
+
+
+[section:box_type section::box_type]
+
+[indexterm2 box_type..section]
+
+ typedef Box box_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:count section::count]
+
+[indexterm2 count..section]
+
+ std::size_t count;
+
+
+
+[endsect]
+
+
+
+[section:directions section::directions]
+
+[indexterm2 directions..section]
+
+ int directions;
+
+
+
+[endsect]
+
+
+
+[section:duplicate section::duplicate]
+
+[indexterm2 duplicate..section]
+
+ bool duplicate;
+
+
+
+[endsect]
+
+
+
+[section:end_index section::end_index]
+
+[indexterm2 end_index..section]
+
+ int end_index;
+
+
+
+[endsect]
+
+
+
+[section:id section::id]
+
+[indexterm2 id..section]
+
+ int id;
+
+
+
+[endsect]
+
+
+
+[section:multi_index section::multi_index]
+
+[indexterm2 multi_index..section]
+
+ int multi_index;
+
+
+
+[endsect]
+
+
+
+[section:non_duplicate_index section::non_duplicate_index]
+
+[indexterm2 non_duplicate_index..section]
+
+ int non_duplicate_index;
+
+
+
+[endsect]
+
+
+
+[section:range_count section::range_count]
+
+[indexterm2 range_count..section]
+
+ std::size_t range_count;
+
+
+
+[endsect]
+
+
+
+[section:ring_index section::ring_index]
+
+[indexterm2 ring_index..section]
+
+ int ring_index;
+
+
+
+[endsect]
+
+
+
+[section:section section::section]
+
+[indexterm2 section..section]
+
+ section();
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:section_iterator section_iterator]
+
+
+
+
+
+[heading Synopsis]
+ template<
+ typename G ,
+ typename S ,
+ typename B ,
+ size_t ``[link boost_geometry.reference.D D]``>
+ struct section_iterator
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.section_iterator.section_iterator [*section_iterator]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/iterators/section_iterators.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:section_iterator section_iterator::section_iterator]
+
+[indexterm2 section_iterator..section_iterator]
+
+ section_iterator(
+ const G & ring,
+ const S & sections,
+ const B & box);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:sectionalize sectionalize]
+
+[indexterm1 sectionalize]
+Split a [link boost_geometry.reference.boost__geometry `boost::geometry`] into monotonic [link boost_geometry.reference.sections `sections`].
+
+
+ template<
+ typename Geometry ,
+ typename Sections >
+ void sectionalize(
+ Geometry const & geometry,
+ Sections & sections);
+
+
+
+
+[variablelist
+
+[[Geometry][type of [link boost_geometry.reference.boost__geometry `boost::geometry`] to check ]]
+
+[[Sections][type of [link boost_geometry.reference.sections `sections`] to create ]]
]
@@ -9811,7 +13855,9 @@
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make reverse ]]
+[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to create [link boost_geometry.reference.sections `sections`] from ]]
+
+[[sections][structure with [link boost_geometry.reference.sections `sections`] ]]
]
@@ -9819,31 +13865,284 @@
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/reverse.hpp]
+[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:sections sections]
+
+
+Structure containing a collection of [link boost_geometry.reference.sections `sections`].
+
+
+
+
+[heading Synopsis]
+ template<
+ typename Box ,
+ std::size_t ``[link boost_geometry.reference.DimensionCount DimensionCount]``>
+ struct sections
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.sections.box_type [*box_type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.sections.value [*value]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+
+
+[heading Remarks]
+
+Derived from a vector, proves to be faster than of deque
+
+vector might be templated in the future
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:box_type sections::box_type]
+
+[indexterm2 box_type..sections]
+
+ typedef Box box_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:value sections::value]
+
+[indexterm2 value..sections]
+
+ static const std::size_t value = DimensionCount;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:segment segment]
+
+
+Class [link boost_geometry.reference.segment `segment`]: small class containing two (templatized) [link boost_geometry.reference.point `point`] references.
+
+
+
+
+[heading Synopsis]
+ template<
+ typename ``[link boost_geometry.reference.ConstOrNonConstPoint ConstOrNonConstPoint]``>
+ class segment
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment.segment [*segment]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment.first [*first]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment.second [*second]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+From Wikipedia: In [link boost_geometry.reference.boost__geometry `boost::geometry`], a line [link boost_geometry.reference.segment `segment`] is a part of a line that is bounded by two distinct end points, and contains every [link boost_geometry.reference.point `point`] on the line between its end points.
+
+[heading Remarks]
+
+The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
+
+Like std::pair, points are public available.
+
+type is const or non const, so geometry::segment<P> or geometry::segment<const P>
+
+We cannot derive from std::pair<P&, P&> because of reference assignments.
+
+
+
+[variablelist
+
+[[ConstOrNonConstPoint][[link boost_geometry.reference.point `point`] type of the [link boost_geometry.reference.segment `segment`], maybe a [link boost_geometry.reference.point `point`] or a const [link boost_geometry.reference.point `point`] ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/segment.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:first segment::first]
+
+[indexterm2 first..segment]
+
+ point_type & first;
+
+
+
+[endsect]
+
+
+
+[section:second segment::second]
+
+[indexterm2 second..segment]
+
+ point_type & second;
+
+
+
+[endsect]
+
+
+
+[section:segment segment::segment]
+
+[indexterm2 segment..segment]
+
+ segment(
+ point_type & p1,
+ point_type & p2);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:segment_2d segment_2d]
+
+[indexterm1 segment_2d]
+
+ typedef segment< point_2d > segment_2d;
+
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment.segment [*segment]]]
+ []
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment.first [*first]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment.second [*second]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+From Wikipedia: In [link boost_geometry.reference.boost__geometry `boost::geometry`], a line [link boost_geometry.reference.segment `segment`] is a part of a line that is bounded by two distinct end points, and contains every [link boost_geometry.reference.point `point`] on the line between its end points.
-[*Convenience header: ][^boost/geometry.hpp]
+[heading Remarks]
+
+The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
+Like std::pair, points are public available.
-[endsect]
+type is const or non const, so geometry::segment<P> or geometry::segment<const P>
+We cannot derive from std::pair<P&, P&> because of reference assignments.
-[section:reverse_dispatch reverse_dispatch]
+[variablelist
+
+[[ConstOrNonConstPoint][[link boost_geometry.reference.point `point`] type of the [link boost_geometry.reference.segment `segment`], maybe a [link boost_geometry.reference.point `point`] or a const [link boost_geometry.reference.point `point`] ]]
+]
-[heading Synopsis]
- template<
- typename Geometry1 ,
- typename Geometry2 >
- struct reverse_dispatch
-[heading Description]
[heading Requirements]
-[*Header: ][^boost/geometry/core/reverse_dispatch.hpp]
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -9851,179 +14150,185 @@
[endsect]
-[section:ring_2d ring_2d]
-
-[indexterm1 ring_2d]
-
- typedef linear_ring< point_2d > ring_2d;
+[section:segment_identifier segment_identifier]
-[heading Typedef Description]
-
-[variablelist
-
-[[P][[link boost_geometry.reference.point `point`] type ]]
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
+[heading Synopsis]
+ struct segment_identifier
-[[A][optional container-allocator-type ]]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.segment_identifier.operator_lt_ [*operator<]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_identifier.operator_eq__eq_ [*operator==]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_identifier.segment_identifier [*segment_identifier]]]
+ []
+ ]
+
]
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.segment_identifier.multi_index [*multi_index]]]
+ []
+ ]
-[heading Requirements]
-
-[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+ [
+ [[link boost_geometry.reference.segment_identifier.ring_index [*ring_index]]]
+ []
+ ]
-[*Convenience header: ][^boost/geometry.hpp]
+ [
+ [[link boost_geometry.reference.segment_identifier.segment_index [*segment_index]]]
+ []
+ ]
+ [
+ [[link boost_geometry.reference.segment_identifier.source_index [*source_index]]]
+ []
+ ]
-[endsect]
+]
+[heading Description]
-[section:ring_3d ring_3d]
+[heading Requirements]
-[indexterm1 ring_3d]
+[*Header: ][^boost/geometry/algorithms/overlay/segment_identifier.hpp]
- typedef linear_ring< point_3d > ring_3d;
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Typedef Description]
-
+[section:multi_index segment_identifier::multi_index]
+[indexterm2 multi_index..segment_identifier]
-[variablelist
-
-[[P][[link boost_geometry.reference.point `point`] type ]]
+ int multi_index;
-[[V][optional container type, for example std::vector, std::list, std::deque ]]
-[[A][optional container-allocator-type ]]
-]
+[endsect]
+[section:operator_lt_ segment_identifier::operator<]
-[heading Requirements]
+[indexterm2 operator<..segment_identifier]
-[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+ bool operator<(
+ segment_identifier const & other) const;
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:ring_tag ring_tag]
+[section:operator_eq__eq_ segment_identifier::operator==]
+
+[indexterm2 operator==..segment_identifier]
-Convenience (linear) ring identifying [link boost_geometry.reference.tag `tag`].
+ bool operator==(
+ segment_identifier const & other) const;
+[endsect]
-[heading Synopsis]
- struct ring_tag
-[heading Description]
-[heading Requirements]
+[section:ring_index segment_identifier::ring_index]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[indexterm2 ring_index..segment_identifier]
-[*Convenience header: ][^boost/geometry.hpp]
+ int ring_index;
-[endsect]
-[section:ring_type ring_type]
+[endsect]
-Meta-function which defines ring type of (multi)[link boost_geometry.reference.polygon `polygon`] [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[section:segment_identifier segment_identifier::segment_identifier]
+[indexterm2 segment_identifier..segment_identifier]
+ ``[link boost_geometry.reference.segment_identifier.segment_identifier.overload1 segment_identifier]``();
+ `` [''''»''' [link boost_geometry.reference.segment_identifier.segment_identifier.overload1 more...]]``
+ ``[link boost_geometry.reference.segment_identifier.segment_identifier.overload2 segment_identifier]``(
+ int src,
+ int mul,
+ int rin,
+ int seg);
+ `` [''''»''' [link boost_geometry.reference.segment_identifier.segment_identifier.overload2 more...]]``
-[heading Synopsis]
- template<
- typename Geometry >
- struct ring_type
-[heading Public Types]
-[table
- [[Name][Description]]
+[section:overload1 segment_identifier::segment_identifier (1 of 2 overloads)]
- [
- [[link boost_geometry.reference.ring_type.type [*type]]]
- []
-
- ]
-]
+ segment_identifier();
-[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.
+[endsect]
-[heading Requirements]
+[section:overload2 segment_identifier::segment_identifier (2 of 2 overloads)]
-[*Header: ][^boost/geometry/core/ring_type.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+ segment_identifier(
+ int src,
+ int mul,
+ int rin,
+ int seg);
-[section:type ring_type::type]
-[indexterm2 type..ring_type]
- typedef core_dispatch::ring_type< typename tag< Geometry >::type, Geometry >::type type;
+[endsect]
+[endsect]
-[heading Public Types]
-[table
- [[Name][Description]]
- [
+[section:segment_index segment_identifier::segment_index]
- [[link boost_geometry.reference.tag.type [*type]]]
- []
-
- ]
+[indexterm2 segment_index..segment_identifier]
-]
+ int segment_index;
-[heading Typedef Description]
-
-All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type ([link boost_geometry.reference.point `point`], [link boost_geometry.reference.linestring `linestring`], [link boost_geometry.reference.polygon `polygon`], etc) by implementing a [link boost_geometry.reference.tag `tag`] [link boost_geometry.reference.traits `traits`] class. This meta-function uses that [link boost_geometry.reference.traits `traits`] class to retrieve the [link boost_geometry.reference.tag `tag`]. If the input type is not a [link boost_geometry.reference.boost__geometry `boost::geometry`] at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
-[variablelist
-
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-]
+[endsect]
+[section:source_index segment_identifier::source_index]
-[heading Requirements]
+[indexterm2 source_index..segment_identifier]
-[*Header: ][^boost/geometry/core/ring_type.hpp]
+ int source_index;
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
@@ -10032,19 +14337,16 @@
[endsect]
-[section:section section]
-
+[section:segment_intersection_points segment_intersection_points]
-Structure containing [link boost_geometry.reference.section `section`] information.
[heading Synopsis]
template<
- typename Box ,
- std::size_t ``[link boost_geometry.reference.DimensionCount DimensionCount]``>
- struct section
+ typename Point >
+ struct segment_intersection_points
[heading Public Types]
[table
@@ -10052,7 +14354,7 @@
[
- [[link boost_geometry.reference.section.box_type [*box_type]]]
+ [[link boost_geometry.reference.segment_intersection_points.point_type [*point_type]]]
[]
]
@@ -10065,7 +14367,7 @@
[[Name][Description]]
[
- [[link boost_geometry.reference.section.section [*section]]]
+ [[link boost_geometry.reference.segment_intersection_points.segment_intersection_points [*segment_intersection_points]]]
[]
]
@@ -10077,57 +14379,12 @@
[[Name][Description]]
[
- [[link boost_geometry.reference.section.begin_index [*begin_index]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.section.bounding_box [*bounding_box]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.section.count [*count]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.section.directions [*directions]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.section.duplicate [*duplicate]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.section.end_index [*end_index]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.section.id [*id]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.section.multi_index [*multi_index]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.section.non_duplicate_index [*non_duplicate_index]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.section.range_count [*range_count]]]
+ [[link boost_geometry.reference.segment_intersection_points.count [*count]]]
[]
]
[
- [[link boost_geometry.reference.section.ring_index [*ring_index]]]
+ [[link boost_geometry.reference.segment_intersection_points.intersections [*intersections]]]
[]
]
@@ -10136,32 +14393,18 @@
[heading Description]
-Section information consists of a bounding [link boost_geometry.reference.box `box`], direction information (if it is increasing or decreasing, per [link boost_geometry.reference.dimension `dimension`]), index information (begin-end, ring, multi) and the number of segments in this [link boost_geometry.reference.section `section`]
-
-
-
-[variablelist
-
-[[Box][box-type ]]
-
-[[DimensionCount][number of dimensions for this [link boost_geometry.reference.section `section`] ]]
-
-]
-
-
-
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+[*Header: ][^boost/geometry/strategies/intersection_result.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:begin_index section::begin_index]
+[section:count segment_intersection_points::count]
-[indexterm2 begin_index..section]
+[indexterm2 count..segment_intersection_points]
- int begin_index;
+ std::size_t count;
@@ -10169,11 +14412,11 @@
-[section:bounding_box section::bounding_box]
+[section:intersections segment_intersection_points::intersections]
-[indexterm2 bounding_box..section]
+[indexterm2 intersections..segment_intersection_points]
- Box bounding_box;
+ Point intersections;
@@ -10181,17 +14424,17 @@
-[section:box_type section::box_type]
+[section:point_type segment_intersection_points::point_type]
-[indexterm2 box_type..section]
+[indexterm2 point_type..segment_intersection_points]
- typedef Box box_type;
+ typedef Point point_type;
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+[*Header: ][^boost/geometry/strategies/intersection_result.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -10200,11 +14443,11 @@
-[section:count section::count]
+[section:segment_intersection_points segment_intersection_points::segment_intersection_points]
-[indexterm2 count..section]
+[indexterm2 segment_intersection_points..segment_intersection_points]
- std::size_t count;
+ segment_intersection_points();
@@ -10212,71 +14455,129 @@
-[section:directions section::directions]
-
-[indexterm2 directions..section]
-
- int directions;
-
-
-
[endsect]
+[section:segment_iterator segment_iterator]
-[section:duplicate section::duplicate]
-
-[indexterm2 duplicate..section]
- bool duplicate;
+[heading Synopsis]
+ template<
+ typename Base ,
+ typename Point >
+ struct segment_iterator
-[endsect]
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
+ [[link boost_geometry.reference.segment_iterator.base_type [*base_type]]]
+ []
+
+ ]
-[section:end_index section::end_index]
+ [
-[indexterm2 end_index..section]
+ [[link boost_geometry.reference.segment_iterator.difference_type [*difference_type]]]
+ []
+
+ ]
- int end_index;
+ [
+ [[link boost_geometry.reference.segment_iterator.iterator_category [*iterator_category]]]
+ []
+
+ ]
+ [
-[endsect]
+ [[link boost_geometry.reference.segment_iterator.point_type [*point_type]]]
+ []
+
+ ]
+ [
+ [[link boost_geometry.reference.segment_iterator.pointer [*pointer]]]
+ []
+
+ ]
-[section:id section::id]
+ [
-[indexterm2 id..section]
+ [[link boost_geometry.reference.segment_iterator.reference [*reference]]]
+ []
+
+ ]
- int id;
+ [
+ [[link boost_geometry.reference.segment_iterator.segment_type [*segment_type]]]
+ []
+
+ ]
+ [
-[endsect]
+ [[link boost_geometry.reference.segment_iterator.value_type [*value_type]]]
+ []
+
+ ]
+]
-[section:multi_index section::multi_index]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
-[indexterm2 multi_index..section]
+ [
+ [[link boost_geometry.reference.segment_iterator.base [*base]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_iterator.operator* [*operator*]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_iterator.operator_plus__plus_ [*operator++]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_iterator.operator-_gt_ [*operator->]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment_iterator.segment_iterator [*segment_iterator]]]
+ []
+ ]
+
+]
- int multi_index;
+[heading Description]
+[heading Requirements]
-[endsect]
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:non_duplicate_index section::non_duplicate_index]
+[section:base segment_iterator::base]
-[indexterm2 non_duplicate_index..section]
+[indexterm2 base..segment_iterator]
- int non_duplicate_index;
+ Base const & base() const;
@@ -10284,162 +14585,136 @@
-[section:range_count section::range_count]
+[section:base_type segment_iterator::base_type]
-[indexterm2 range_count..section]
+[indexterm2 base_type..segment_iterator]
- std::size_t range_count;
+ typedef Base base_type;
-[endsect]
+[heading Requirements]
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:ring_index section::ring_index]
-[indexterm2 ring_index..section]
+[endsect]
- int ring_index;
+[section:difference_type segment_iterator::difference_type]
-[endsect]
+[indexterm2 difference_type..segment_iterator]
+ typedef std::iterator_traits< Base >::difference_type difference_type;
-[section:section section::section]
-[indexterm2 section..section]
+[heading Requirements]
- section();
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[endsect]
+[section:iterator_category segment_iterator::iterator_category]
+[indexterm2 iterator_category..segment_iterator]
-[section:sectionalize sectionalize]
+ typedef std::input_iterator_tag iterator_category;
-[indexterm1 sectionalize]
-Split a [link boost_geometry.reference.boost__geometry `boost::geometry`] into monotonic [link boost_geometry.reference.sections `sections`].
- template<
- typename Geometry ,
- typename Sections >
- void sectionalize(
- Geometry const & geometry,
- Sections & sections);
+[heading Requirements]
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[variablelist
-
-[[Geometry][type of [link boost_geometry.reference.boost__geometry `boost::geometry`] to check ]]
+[endsect]
-[[Sections][type of [link boost_geometry.reference.sections `sections`] to create ]]
-]
+[section:operator* segment_iterator::operator*]
-[heading Parameters]
-
+[indexterm2 operator*..segment_iterator]
-[variablelist
-
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to create [link boost_geometry.reference.sections `sections`] from ]]
+ reference operator*();
-[[sections][structure with [link boost_geometry.reference.sections `sections`] ]]
-]
+[endsect]
-[heading Requirements]
+[section:operator_plus__plus_ segment_iterator::operator++]
-[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+[indexterm2 operator++..segment_iterator]
-[*Convenience header: ][^boost/geometry.hpp]
+ segment_iterator & ``[link boost_geometry.reference.segment_iterator.operator_plus__plus_.overload1 operator++]``();
+ `` [''''»''' [link boost_geometry.reference.segment_iterator.operator_plus__plus_.overload1 more...]]``
+ segment_iterator ``[link boost_geometry.reference.segment_iterator.operator_plus__plus_.overload2 operator++]``(
+ int );
+ `` [''''»''' [link boost_geometry.reference.segment_iterator.operator_plus__plus_.overload2 more...]]``
-[endsect]
+[section:overload1 segment_iterator::operator++ (1 of 2 overloads)]
-[section:sections sections]
-Structure containing a collection of [link boost_geometry.reference.sections `sections`].
+ segment_iterator & operator++();
+[endsect]
-[heading Synopsis]
- template<
- typename Box ,
- std::size_t ``[link boost_geometry.reference.DimensionCount DimensionCount]``>
- struct sections
-[heading Public Types]
-[table
- [[Name][Description]]
- [
+[section:overload2 segment_iterator::operator++ (2 of 2 overloads)]
- [[link boost_geometry.reference.sections.box_type [*box_type]]]
- []
-
- ]
-]
+ segment_iterator operator++(
+ int );
-[heading Public Data Members]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.sections.value [*value]]]
- []
- ]
-]
+[endsect]
-[heading Description]
+[endsect]
-[heading Remarks]
-
-Derived from a vector, proves to be faster than of deque
+[section:operator-_gt_ segment_iterator::operator->]
-vector might be templated in the future
+[indexterm2 operator->..segment_iterator]
+ pointer operator->();
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
-[section:box_type sections::box_type]
+[section:point_type segment_iterator::point_type]
-[indexterm2 box_type..sections]
+[indexterm2 point_type..segment_iterator]
- typedef Box box_type;
+ typedef Point point_type;
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/sectionalize.hpp]
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -10448,32 +14723,32 @@
-[section:value sections::value]
+[section:pointer segment_iterator::pointer]
-[indexterm2 value..sections]
+[indexterm2 pointer..segment_iterator]
- static const std::size_t value = DimensionCount;
+ typedef segment_type * pointer;
-[endsect]
+[heading Requirements]
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:segment segment]
-Class [link boost_geometry.reference.segment `segment`]: small class containing two (templatized) [link boost_geometry.reference.point `point`] references.
+[section:reference segment_iterator::reference]
+[indexterm2 reference..segment_iterator]
+ typedef segment_type & reference;
-[heading Synopsis]
- template<
- typename ConstOrNonConstPoint >
- class segment
[heading Public Member Functions]
[table
@@ -10503,10 +14778,10 @@
]
-
-[heading Description]
-
+[heading Typedef Description]
+
From Wikipedia: In [link boost_geometry.reference.boost__geometry `boost::geometry`], a line [link boost_geometry.reference.segment `segment`] is a part of a line that is bounded by two distinct end points, and contains every [link boost_geometry.reference.point `point`] on the line between its end points.
+
[heading Remarks]
The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
@@ -10527,30 +14802,37 @@
+
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/segment.hpp]
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:first segment::first]
+[endsect]
-[indexterm2 first..segment]
- point_type & first;
+[section:segment_iterator segment_iterator::segment_iterator]
+[indexterm2 segment_iterator..segment_iterator]
+ explicit ``[link boost_geometry.reference.segment_iterator.segment_iterator.overload1 segment_iterator]``(
+ Base const & end);
+ `` [''''»''' [link boost_geometry.reference.segment_iterator.segment_iterator.overload1 more...]]``
-[endsect]
+ ``[link boost_geometry.reference.segment_iterator.segment_iterator.overload2 segment_iterator]``(
+ Base const & it,
+ Base const & end);
+ `` [''''»''' [link boost_geometry.reference.segment_iterator.segment_iterator.overload2 more...]]``
+[section:overload1 segment_iterator::segment_iterator (1 of 2 overloads)]
-[section:second segment::second]
-[indexterm2 second..segment]
- point_type & second;
+ segment_iterator(
+ Base const & end);
@@ -10558,28 +14840,27 @@
-[section:segment segment::segment]
+[section:overload2 segment_iterator::segment_iterator (2 of 2 overloads)]
+
-[indexterm2 segment..segment]
- segment(
- point_type & p1,
- point_type & p2);
+ segment_iterator(
+ Base const & it,
+ Base const & end);
[endsect]
-
[endsect]
-[section:segment_2d segment_2d]
+[section:segment_type segment_iterator::segment_type]
-[indexterm1 segment_2d]
+[indexterm2 segment_type..segment_iterator]
- typedef segment< point_2d > segment_2d;
+ typedef geometry::segment< Point > segment_type;
@@ -10614,6 +14895,7 @@
[heading Typedef Description]
From Wikipedia: In [link boost_geometry.reference.boost__geometry `boost::geometry`], a line [link boost_geometry.reference.segment `segment`] is a part of a line that is bounded by two distinct end points, and contains every [link boost_geometry.reference.point `point`] on the line between its end points.
+
[heading Remarks]
The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
@@ -10637,7 +14919,7 @@
[heading Requirements]
-[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -10645,31 +14927,21 @@
[endsect]
-[section:segment_identifier segment_identifier]
+[section:value_type segment_iterator::value_type]
+[indexterm2 value_type..segment_iterator]
+ typedef segment_type value_type;
-[heading Synopsis]
- struct segment_identifier
[heading Public Member Functions]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.segment_identifier.operator_lt_ [*operator<]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.segment_identifier.operator_eq__eq_ [*operator==]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.segment_identifier.segment_identifier [*segment_identifier]]]
+ [[link boost_geometry.reference.segment.segment [*segment]]]
[]
]
@@ -10681,149 +14953,151 @@
[[Name][Description]]
[
- [[link boost_geometry.reference.segment_identifier.multi_index [*multi_index]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.segment_identifier.ring_index [*ring_index]]]
- []
- ]
-
- [
- [[link boost_geometry.reference.segment_identifier.segment_index [*segment_index]]]
+ [[link boost_geometry.reference.segment.first [*first]]]
[]
]
[
- [[link boost_geometry.reference.segment_identifier.source_index [*source_index]]]
+ [[link boost_geometry.reference.segment.second [*second]]]
[]
]
]
+[heading Typedef Description]
+
+From Wikipedia: In [link boost_geometry.reference.boost__geometry `boost::geometry`], a line [link boost_geometry.reference.segment `segment`] is a part of a line that is bounded by two distinct end points, and contains every [link boost_geometry.reference.point `point`] on the line between its end points.
-[heading Description]
-
-[heading Requirements]
-
-[*Header: ][^boost/geometry/algorithms/overlay/segment_identifier.hpp]
-
-[*Convenience header: ][^boost/geometry.hpp]
+[heading Remarks]
+
+The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
+Like std::pair, points are public available.
-[section:multi_index segment_identifier::multi_index]
+type is const or non const, so geometry::segment<P> or geometry::segment<const P>
-[indexterm2 multi_index..segment_identifier]
+We cannot derive from std::pair<P&, P&> because of reference assignments.
- int multi_index;
+[variablelist
+
+[[ConstOrNonConstPoint][[link boost_geometry.reference.point `point`] type of the [link boost_geometry.reference.segment `segment`], maybe a [link boost_geometry.reference.point `point`] or a const [link boost_geometry.reference.point `point`] ]]
-[endsect]
+]
-[section:operator_lt_ segment_identifier::operator<]
-[indexterm2 operator<..segment_identifier]
+[heading Requirements]
- bool operator<(
- segment_identifier const & other) const;
+[*Header: ][^boost/geometry/iterators/segment_iterator.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:operator_eq__eq_ segment_identifier::operator==]
+[endsect]
-[indexterm2 operator==..segment_identifier]
+[section:segment_tag segment_tag]
- bool operator==(
- segment_identifier const & other) const;
+Convenience [link boost_geometry.reference.segment `segment`] (2-points) identifying [link boost_geometry.reference.tag `tag`].
-[endsect]
+[heading Synopsis]
+ struct segment_tag
-[section:ring_index segment_identifier::ring_index]
+[heading Description]
-[indexterm2 ring_index..segment_identifier]
+[heading Requirements]
- int ring_index;
+[*Header: ][^boost/geometry/core/tags.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:select_calculation_type select_calculation_type]
-[section:segment_identifier segment_identifier::segment_identifier]
-
-[indexterm2 segment_identifier..segment_identifier]
-
- ``[link boost_geometry.reference.segment_identifier.segment_identifier.overload1 segment_identifier]``();
- `` [''''»''' [link boost_geometry.reference.segment_identifier.segment_identifier.overload1 more...]]``
-
- ``[link boost_geometry.reference.segment_identifier.segment_identifier.overload2 segment_identifier]``(
- int src,
- int mul,
- int rin,
- int seg);
- `` [''''»''' [link boost_geometry.reference.segment_identifier.segment_identifier.overload2 more...]]``
+Meta-function selecting the "calculation" type.
-[section:overload1 segment_identifier::segment_identifier (1 of 2 overloads)]
- segment_identifier();
+[heading Synopsis]
+ template<
+ typename ``[link boost_geometry.reference.Geometry1 Geometry1]``,
+ typename ``[link boost_geometry.reference.Geometry2 Geometry2]``,
+ typename ``[link boost_geometry.reference.CalculationType CalculationType]``>
+ struct select_calculation_type
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
-[endsect]
+ [[link boost_geometry.reference.select_calculation_type.type [*type]]]
+ []
+
+ ]
+]
-[section:overload2 segment_identifier::segment_identifier (2 of 2 overloads)]
+[heading Description]
+Based on two input [link boost_geometry.reference.boost__geometry `boost::geometry`] types, and an input calculation type, (which defaults to void in the calling function), this meta-function selects the most appropriate:
+* if calculation type is specified, that one is used,
+* if it is void, the most precise of the two points is used
- segment_identifier(
- int src,
- int mul,
- int rin,
- int seg);
+[heading Requirements]
-[endsect]
+[*Header: ][^boost/geometry/util/select_calculation_type.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:type select_calculation_type::type]
-[section:segment_index segment_identifier::segment_index]
+[indexterm2 type..select_calculation_type]
-[indexterm2 segment_index..segment_identifier]
+ typedef boost::mpl::if_c< boost::is_void< CalculationType >::type::value, typename select_coordinate_type< Geometry1, Geometry2 >::type, CalculationType >::type type;
- int segment_index;
+[heading Public Types]
+[table
+ [[Name][Description]]
-[endsect]
+ [
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
+ []
+
+ ]
+]
-[section:source_index segment_identifier::source_index]
+[heading Typedef Description]
+
-[indexterm2 source_index..segment_identifier]
+[heading Requirements]
- int source_index;
+[*Header: ][^boost/geometry/util/select_calculation_type.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
@@ -10832,16 +15106,19 @@
[endsect]
-[section:segment_intersection_points segment_intersection_points]
+[section:select_coordinate_type select_coordinate_type]
+
+Meta-function selecting the most precise coordinate type of two geometries.
[heading Synopsis]
template<
- typename Point >
- struct segment_intersection_points
+ typename T1,
+ typename ``[link boost_geometry.reference.T2 T2]``>
+ struct select_coordinate_type
[heading Public Types]
[table
@@ -10849,7 +15126,7 @@
[
- [[link boost_geometry.reference.segment_intersection_points.point_type [*point_type]]]
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
[]
]
@@ -10857,15 +15134,34 @@
]
-[heading Public Member Functions]
+[heading Description]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/util/select_coordinate_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:type select_coordinate_type::type]
+
+[indexterm2 type..select_coordinate_type]
+
+ typedef select_most_precise< typename coordinate_type< T1 >::type, typename coordinate_type< T2 >::type >::type type;
+
+
+
+[heading Public Types]
[table
[[Name][Description]]
[
- [[link boost_geometry.reference.segment_intersection_points.segment_intersection_points [*segment_intersection_points]]]
+
+ [[link boost_geometry.reference.select_most_precise.type [*type]]]
[]
- ]
+ ]
+
]
@@ -10874,75 +15170,146 @@
[[Name][Description]]
[
- [[link boost_geometry.reference.segment_intersection_points.count [*count]]]
+ [[link boost_geometry.reference.select_most_precise.both_same [*both_same]]]
[]
]
[
- [[link boost_geometry.reference.segment_intersection_points.intersections [*intersections]]]
+ [[link boost_geometry.reference.select_most_precise.one_not_fundamental [*one_not_fundamental]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.second_larger [*second_larger]]]
[]
]
]
+[heading Typedef Description]
+
+[link boost_geometry.reference.select_most_precise `select_most_precise`] classes, compares two types on compile time. For example, if an addition must be done with a double and an integer, the result must be a double. If both types are integer, the result can be an integer.
+
+[heading Remarks]
+
+It is different from the "promote" class, already in `boost`. That class promotes e.g. a (one) float to a double. This class selects a type from two types. It takes the most accurate, but does not promote afterwards.
+
+This [link boost_geometry.reference.traits `traits`] class is completely independant from GGL and might be a separate addition to Boost
+
+If the input is a non-fundamental type, it might be a calculation type such as a GMP-value or another high precision value. Therefore, if one is non-fundamental, that one is chosen.
+
+If both types are non-fundamental, the result is indeterminate and currently the first one is chosen.
+
+
-[heading Description]
[heading Requirements]
-[*Header: ][^boost/geometry/strategies/intersection_result.hpp]
+[*Header: ][^boost/geometry/util/select_coordinate_type.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:count segment_intersection_points::count]
+[endsect]
-[indexterm2 count..segment_intersection_points]
- std::size_t count;
+[endsect]
+[section:select_most_precise select_most_precise]
-[endsect]
+Meta-function to select, of two types, the most accurate type for calculations.
-[section:intersections segment_intersection_points::intersections]
-[indexterm2 intersections..segment_intersection_points]
- Point intersections;
+[heading Synopsis]
+ template<
+ typename T1,
+ typename ``[link boost_geometry.reference.T2 T2]``>
+ struct select_most_precise
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
-[endsect]
+ [[link boost_geometry.reference.select_most_precise.type [*type]]]
+ []
+
+ ]
+]
-[section:point_type segment_intersection_points::point_type]
+[heading Public Data Members]
+[table
+ [[Name][Description]]
-[indexterm2 point_type..segment_intersection_points]
+ [
+ [[link boost_geometry.reference.select_most_precise.both_same [*both_same]]]
+ []
+ ]
- typedef Point point_type;
+ [
+ [[link boost_geometry.reference.select_most_precise.one_not_fundamental [*one_not_fundamental]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.second_larger [*second_larger]]]
+ []
+ ]
+
+]
+
+
+[heading Description]
+
+[link boost_geometry.reference.select_most_precise `select_most_precise`] classes, compares two types on compile time. For example, if an addition must be done with a double and an integer, the result must be a double. If both types are integer, the result can be an integer.
+
+[heading Remarks]
+
+It is different from the "promote" class, already in `boost`. That class promotes e.g. a (one) float to a double. This class selects a type from two types. It takes the most accurate, but does not promote afterwards.
+
+This [link boost_geometry.reference.traits `traits`] class is completely independant from GGL and might be a separate addition to Boost
+
+If the input is a non-fundamental type, it might be a calculation type such as a GMP-value or another high precision value. Therefore, if one is non-fundamental, that one is chosen.
+
+If both types are non-fundamental, the result is indeterminate and currently the first one is chosen.
[heading Requirements]
-[*Header: ][^boost/geometry/strategies/intersection_result.hpp]
+[*Header: ][^boost/geometry/util/select_most_precise.hpp]
[*Convenience header: ][^boost/geometry.hpp]
+[section:both_same select_most_precise::both_same]
+
+[indexterm2 both_same..select_most_precise]
+
+ static const bool both_same =
+ boost::is_floating_point<T1>::type::value
+ == boost::is_floating_point<T2>::type::value;
+
+
+
[endsect]
-[section:segment_intersection_points segment_intersection_points::segment_intersection_points]
+[section:one_not_fundamental select_most_precise::one_not_fundamental]
-[indexterm2 segment_intersection_points..segment_intersection_points]
+[indexterm2 one_not_fundamental..select_most_precise]
- segment_intersection_points();
+ static const bool one_not_fundamental = !
+ (boost::is_fundamental<T1>::type::value
+ && boost::is_fundamental<T2>::type::value);
@@ -10950,30 +15317,39 @@
-[endsect]
+[section:second_larger select_most_precise::second_larger]
-[section:segment_tag segment_tag]
+[indexterm2 second_larger..select_most_precise]
+ static const bool second_larger = sizeof(T2) > sizeof(T1);
-Convenience [link boost_geometry.reference.segment `segment`] (2-points) identifying [link boost_geometry.reference.tag `tag`].
+[endsect]
-[heading Synopsis]
- struct segment_tag
-[heading Description]
+[section:type select_most_precise::type]
+
+[indexterm2 type..select_most_precise]
+
+ typedef boost::mpl::if_c< one_not_fundamental, typename detail::select_most_precise::select_non_fundamental< boost::is_fundamental< T1 >::type::value, boost::is_fundamental< T2 >::type::value, T1, T2 >::type, typename boost::mpl::if_c< both_same, typename detail::select_most_precise::select_largest< second_larger, T1, T2 >::type, typename detail::select_most_precise::select_floating_point< boost::is_floating_point< T1 >::type::value, boost::is_floating_point< T2 >::type::value, T1, T2 >::type >::type >::type type;
+
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[*Header: ][^boost/geometry/util/select_most_precise.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+
+
+[endsect]
+
[section:set set]
[indexterm1 set]
@@ -11135,6 +15511,7 @@
]
+
[heading Remarks]
Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems
@@ -11369,6 +15746,7 @@
+
[heading Remarks]
simplifying a valid simple polygon (which never intersects itself) might result in an invalid polygon, where the simplified rings intersect themselves or one of the other outer or inner rings. Efficient simplification of a ring/polygon is still an "Open Problem" (http://maven.smith.edu/~orourke/TOPP/P24.html#Problem.24)
@@ -11441,6 +15819,7 @@
+
[heading Remarks]
This version of simplify simplifies a [link boost_geometry.reference.boost__geometry `boost::geometry`] using the default [link boost_geometry.reference.strategy `strategy`] (Douglas Peucker),
@@ -11737,22 +16116,51 @@
[
- [[link boost_geometry.reference.coordinate_type.ncg [*ncg]]]
+ [[link boost_geometry.reference.select_most_precise.type [*type]]]
[]
]
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.both_same [*both_same]]]
+ []
+ ]
+
[
+ [[link boost_geometry.reference.select_most_precise.one_not_fundamental [*one_not_fundamental]]]
+ []
+ ]
- [[link boost_geometry.reference.coordinate_type.type [*type]]]
+ [
+ [[link boost_geometry.reference.select_most_precise.second_larger [*second_larger]]]
[]
-
]
]
[heading Typedef Description]
+[link boost_geometry.reference.select_most_precise `select_most_precise`] classes, compares two types on compile time. For example, if an addition must be done with a double and an integer, the result must be a double. If both types are integer, the result can be an integer.
+
+[heading Remarks]
+
+It is different from the "promote" class, already in `boost`. That class promotes e.g. a (one) float to a double. This class selects a type from two types. It takes the most accurate, but does not promote afterwards.
+
+This [link boost_geometry.reference.traits `traits`] class is completely independant from GGL and might be a separate addition to Boost
+
+If the input is a non-fundamental type, it might be a calculation type such as a GMP-value or another high precision value. Therefore, if one is non-fundamental, that one is chosen.
+
+If both types are non-fundamental, the result is indeterminate and currently the first one is chosen.
+
+
+
[heading Requirements]
@@ -11968,6 +16376,7 @@
+
[heading Remarks]
The version in Gems didn't account for polygons crossing the 180 meridian.
@@ -13027,6 +17436,7 @@
[heading Description]
+
[heading Remarks]
Completely reworked version inspired on the sources listed below
@@ -13473,6 +17883,7 @@
+
[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)) ]
@@ -13698,6 +18109,22 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/cartesian/distance_projected_point.hpp]
@@ -13786,7 +18213,7 @@
[
[[link boost_geometry.reference.cartesian_distance.squared_value [*squared_value]]]
- [The "squared_value" method returns the internal squared value. ]
+ [The "squared\_value" method returns the internal squared value. ]
]
[
@@ -13810,6 +18237,7 @@
[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
@@ -13962,6 +18390,29 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_calculation_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+Based on two input [link boost_geometry.reference.boost__geometry `boost::geometry`] types, and an input calculation type, (which defaults to void in the calling function), this meta-function selects the most appropriate:
+* if calculation type is specified, that one is used,
+
+* if it is void, the most precise of the two points is used
+
+
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/cartesian/distance_pythagoras.hpp]
@@ -14031,7 +18482,7 @@
[
[[link boost_geometry.reference.cartesian_distance.squared_value [*squared_value]]]
- [The "squared_value" method returns the internal squared value. ]
+ [The "squared\_value" method returns the internal squared value. ]
]
[
@@ -14055,6 +18506,7 @@
[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
@@ -14138,6 +18590,7 @@
]
+
[heading Remarks]
The algorithm is currently only implemented for 2D Cartesian points
@@ -14380,6 +18833,29 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_calculation_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+Based on two input [link boost_geometry.reference.boost__geometry `boost::geometry`] types, and an input calculation type, (which defaults to void in the calling function), this meta-function selects the most appropriate:
+* if calculation type is specified, that one is used,
+
+* if it is void, the most precise of the two points is used
+
+
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/cartesian/cart_intersect.hpp]
@@ -14658,6 +19134,7 @@
]
+
[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
@@ -14995,6 +19472,7 @@
]
+
[heading Remarks]
If x,y,z [link boost_geometry.reference.point `point`] is not lying on unit sphere, transformation will return false
@@ -15284,6 +19762,22 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/transform/inverse_transformer.hpp]
@@ -15413,6 +19907,22 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/transform/map_transformer.hpp]
@@ -15549,6 +20059,7 @@
]
+
[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.
@@ -15570,6 +20081,58 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_most_precise.type [*type]]]
+ []
+
+ ]
+
+]
+
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.both_same [*both_same]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.one_not_fundamental [*one_not_fundamental]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.select_most_precise.second_larger [*second_larger]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+[link boost_geometry.reference.select_most_precise `select_most_precise`] classes, compares two types on compile time. For example, if an addition must be done with a double and an integer, the result must be a double. If both types are integer, the result can be an integer.
+
+[heading Remarks]
+
+It is different from the "promote" class, already in `boost`. That class promotes e.g. a (one) float to a double. This class selects a type from two types. It takes the most accurate, but does not promote afterwards.
+
+This [link boost_geometry.reference.traits `traits`] class is completely independant from GGL and might be a separate addition to Boost
+
+If the input is a non-fundamental type, it might be a calculation type such as a GMP-value or another high precision value. Therefore, if one is non-fundamental, that one is chosen.
+
+If both types are non-fundamental, the result is indeterminate and currently the first one is chosen.
+
+
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
@@ -15733,6 +20296,22 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
@@ -15913,6 +20492,22 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
@@ -16137,6 +20732,22 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
@@ -16288,6 +20899,22 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
@@ -16655,6 +21282,22 @@
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.select_coordinate_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Typedef Description]
+
+
[heading Requirements]
[*Header: ][^boost/geometry/strategies/transform/matrix_transformers.hpp]
@@ -17027,6 +21670,7 @@
+
[heading Remarks]
Does NOT work correctly for [link boost_geometry.reference.point `point`] ON border
@@ -17256,11 +21900,13 @@
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
@@ -17500,6 +22146,7 @@
Barend Gehrels
+
[heading Remarks]
The implementation is inspired by terralib http://www.terralib.org (LGPL)
@@ -20034,6 +24681,7 @@
+
[heading Remarks]
Not every possibility is yet worked out, e.g. polar coordinate system is ignored until now
@@ -20135,6 +24783,7 @@
]
+
[heading Return Value]
true if the transformation could be done
@@ -20266,6 +24915,7 @@
]
+
[heading Return Value]
the output iterator
@@ -20323,6 +24973,7 @@
]
+
[heading Return Value]
the output iterator
@@ -20480,11 +25131,13 @@
]
+
[heading Return Value]
true if geometry1 is completely contained within geometry2, else false
+
[heading Remarks]
The default [link boost_geometry.reference.strategy `strategy`] is used for within detection
@@ -20527,6 +25180,7 @@
]
+
[heading Return Value]
true if geometry1 is completely contained within geometry2, else false
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk