|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r60518 - sandbox/geometry/libs/geometry/doc/quickbook
From: mateusz_at_[hidden]
Date: 2010-03-12 09:15:21
Author: mloskot
Date: 2010-03-12 09:15:19 EST (Fri, 12 Mar 2010)
New Revision: 60518
URL: http://svn.boost.org/trac/boost/changeset/60518
Log:
Geometry: regenerated reference.qbk with Reference node content
Text files modified:
sandbox/geometry/libs/geometry/doc/quickbook/reference.qbk | 6487 +++++++++++++++++++++++++++------------
1 files changed, 4419 insertions(+), 2068 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-12 09:15:19 EST (Fri, 12 Mar 2010)
@@ -113,7 +113,7 @@
[variablelist
-[[geometry][a [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry][a geometry ]]
[[range_or_point][the point or range to add ]]
@@ -189,7 +189,7 @@
[section:overload1 area (1 of 2 overloads)]
-Calculate area of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Calculate area of a geometry.
template<
@@ -198,13 +198,13 @@
Geometry const & geometry);
-The function area returns the area of a polygon, ring, box using the default area-calculation [link boost_geometry.reference.strategy `strategy`]. Strategies are provided for cartesian and spherical coordinate systems The geometries should correct, polygons should be closed and according to the specified orientation (clockwise/counter clockwise)
+The function area returns the area of a polygon, ring, box using the default area-calculation strategy. Strategies are provided for cartesian and spherical coordinate systems The geometries should correct, polygons should be closed and according to the specified orientation (clockwise/counter clockwise)
[heading Parameters]
[variablelist
-[[geometry][a [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry][a geometry ]]
]
@@ -223,7 +223,7 @@
[section:overload2 area (2 of 2 overloads)]
-Calculate area of a [link boost_geometry.reference.boost__geometry `boost::geometry`] using a specified [link boost_geometry.reference.strategy `strategy`].
+Calculate area of a geometry using a specified strategy.
template<
@@ -234,15 +234,15 @@
Strategy const & strategy);
-This version of area calculation takes a [link boost_geometry.reference.strategy `strategy`]
+This version of area calculation takes a strategy
[heading Parameters]
[variablelist
-[[geometry][a [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry][a geometry ]]
-[[strategy][the [link boost_geometry.reference.strategy `strategy`] to calculate area. Especially for spherical areas there are some approaches. ]]
+[[strategy][the strategy to calculate area. Especially for spherical areas there are some approaches. ]]
]
@@ -480,7 +480,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`]
+The point-type of the range might be different from the point-type of the geometry
@@ -538,7 +538,7 @@
Geometry & geometry);
-The assign\_inverse function initialize a 2D or 3D box with large coordinates, the min corner is very large, the max corner is very small. This is a convenient `starting` point to collect the minimum bounding box of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+The assign\_inverse function initialize a 2D or 3D box with large coordinates, the min corner is very large, the max corner is very small. This is a convenient starting point to collect the minimum bounding box of a geometry.
[heading Requirements]
@@ -639,7 +639,7 @@
[variablelist
-[[Geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry][the geometry type ]]
]
@@ -655,10 +655,302 @@
[endsect]
+[section:box box]
+
+
+Class box: defines a box made of two describing points.
+
+
+ template<
+ typename Point >
+ class box
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.box.box [*box]]]
+ [
+
+ Constructor taking the minimum corner point and the maximum corner point. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.box.max_corner [*max_corner]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.box.min_corner [*min_corner]]]
+ []
+ ]
+
+]
+
+Box is always described by a `min_corner()` and a `max_corner()` point. If another rectangle is used, use [link boost_geometry.reference.linear_ring `linear_ring`] or polygon.
+[heading Remarks]
+
+Boxes are for selections and for calculating the envelope of geometries. Not all algorithms are implemented for box. Boxes are also used in Spatial Indexes.
+
+
+
+[variablelist
+
+[[Point][point type. The box takes a point type as template parameter. The point type can be any point type. It can be 2D but can also be 3D or more dimensional. The box can also take a latlong point type as template parameter. ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/box.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+[section:box box::box]
+
+[indexterm2 box..box]
+
+ ``[link boost_geometry.reference.box.box.overload1 box]``();
+ `` [''''»''' [link boost_geometry.reference.box.box.overload1 more...]]``
+
+
+Constructor taking the minimum corner point and the maximum corner point.
+
+
+ ``[link boost_geometry.reference.box.box.overload2 box]``(
+ Point const & min_corner,
+ Point const & max_corner);
+ `` [''''»''' [link boost_geometry.reference.box.box.overload2 more...]]``
+
+
+[section:overload1 box::box (1 of 2 overloads)]
+
+
+
+ box();
+
+
+
+[endsect]
+
+
+
+[section:overload2 box::box (2 of 2 overloads)]
+
+
+Constructor taking the minimum corner point and the maximum corner point.
+
+
+ box(
+ Point const & min_corner,
+ Point const & max_corner);
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:max_corner box::max_corner]
+
+[indexterm2 max_corner..box]
+
+ Point const & ``[link boost_geometry.reference.box.max_corner.overload1 max_corner]``() const;
+ `` [''''»''' [link boost_geometry.reference.box.max_corner.overload1 more...]]``
+
+ Point & ``[link boost_geometry.reference.box.max_corner.overload2 max_corner]``();
+ `` [''''»''' [link boost_geometry.reference.box.max_corner.overload2 more...]]``
+
+
+[section:overload1 box::max_corner (1 of 2 overloads)]
+
+
+
+ Point const & max_corner() const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 box::max_corner (2 of 2 overloads)]
+
+
+
+ Point & max_corner();
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:min_corner box::min_corner]
+
+[indexterm2 min_corner..box]
+
+ Point const & ``[link boost_geometry.reference.box.min_corner.overload1 min_corner]``() const;
+ `` [''''»''' [link boost_geometry.reference.box.min_corner.overload1 more...]]``
+
+ Point & ``[link boost_geometry.reference.box.min_corner.overload2 min_corner]``();
+ `` [''''»''' [link boost_geometry.reference.box.min_corner.overload2 more...]]``
+
+
+[section:overload1 box::min_corner (1 of 2 overloads)]
+
+
+
+ Point const & min_corner() const;
+
+
+
+[endsect]
+
+
+
+[section:overload2 box::min_corner (2 of 2 overloads)]
+
+
+
+ Point & min_corner();
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:box_2d box_2d]
+
+[indexterm1 box_2d]
+
+ typedef box< point_2d > box_2d;
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.box.box [*box]]]
+ [
+
+ Constructor taking the minimum corner point and the maximum corner point. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.box.max_corner [*max_corner]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.box.min_corner [*min_corner]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+Box is always described by a `min_corner()` and a `max_corner()` point. If another rectangle is used, use [link boost_geometry.reference.linear_ring `linear_ring`] or polygon.
+[heading Remarks]
+
+Boxes are for selections and for calculating the envelope of geometries. Not all algorithms are implemented for box. Boxes are also used in Spatial Indexes.
+
+
+
+[variablelist
+
+[[Point][point type. The box takes a point type as template parameter. The point type can be any point type. It can be 2D but can also be 3D or more dimensional. The box can also take a latlong point type as template parameter. ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:box_3d box_3d]
+
+[indexterm1 box_3d]
+
+ typedef box< point_3d > box_3d;
+
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.box.box [*box]]]
+ [
+
+ Constructor taking the minimum corner point and the maximum corner point. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.box.max_corner [*max_corner]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.box.min_corner [*min_corner]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+Box is always described by a `min_corner()` and a `max_corner()` point. If another rectangle is used, use [link boost_geometry.reference.linear_ring `linear_ring`] or polygon.
+[heading Remarks]
+
+Boxes are for selections and for calculating the envelope of geometries. Not all algorithms are implemented for box. Boxes are also used in Spatial Indexes.
+
+
+
+[variablelist
+
+[[Point][point type. The box takes a point type as template parameter. The point type can be any point type. It can be 2D but can also be 3D or more dimensional. The box can also take a latlong point type as template parameter. ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
[section:box_tag box_tag]
-Convenience 2D or 3D box (mbr) identifying [link boost_geometry.reference.tag `tag`].
+Convenience 2D or 3D box (mbr) identifying tag.
struct box_tag
@@ -675,7 +967,7 @@
[section:buffer buffer]
[indexterm1 buffer]
-Calculate buffer (= new [link boost_geometry.reference.boost__geometry `boost::geometry`]) around specified distance of [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Calculate buffer (= new geometry) around specified distance of geometry.
template<
@@ -695,13 +987,13 @@
[variablelist
-[[geometry_in][input [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry_in][input geometry ]]
[[distance][the distance used in buffer ]]
[[chord_length][length of the chord's in the generated arcs around points or bends ]]
-[[geometry_out][buffered [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry_out][buffered geometry ]]
]
@@ -841,7 +1133,7 @@
[section:overload1 centroid (1 of 2 overloads)]
-Calculate centroid using a specified [link boost_geometry.reference.strategy `strategy`].
+Calculate centroid using a specified strategy.
template<
@@ -860,11 +1152,11 @@
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate centroid from ]]
+[[geometry][the geometry to calculate centroid from ]]
[[c][reference to point which will contain the centroid ]]
-[[strategy][Calculation [link boost_geometry.reference.strategy `strategy`] for centroid ]]
+[[strategy][Calculation strategy for centroid ]]
]
@@ -895,7 +1187,7 @@
[variablelist
-[[geometry][a [link boost_geometry.reference.boost__geometry `boost::geometry`] (e.g. closed ring or polygon) ]]
+[[geometry][a geometry (e.g. closed ring or polygon) ]]
[[c][reference to point which will contain the centroid ]]
@@ -976,7 +1268,7 @@
Geometry & geometry);
-Generic function to clear a [link boost_geometry.reference.boost__geometry `boost::geometry`]
+Generic function to clear a geometry
[heading Remarks]
@@ -999,7 +1291,7 @@
[section:combine combine]
[indexterm1 combine]
-Combines a box with another [link boost_geometry.reference.boost__geometry `boost::geometry`] (box, point).
+Combines a box with another geometry (box, point).
template<
@@ -1016,7 +1308,7 @@
[[Box][type of the box ]]
-[[Geometry][of second [link boost_geometry.reference.boost__geometry `boost::geometry`], to be combined with the box ]]
+[[Geometry][of second geometry, to be combined with the box ]]
]
@@ -1026,9 +1318,9 @@
[variablelist
-[[box][box to combine another [link boost_geometry.reference.boost__geometry `boost::geometry`] with, might be changed ]]
+[[box][box to combine another geometry with, might be changed ]]
-[[geometry][other [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry][other geometry ]]
]
@@ -1044,473 +1336,440 @@
[endsect]
+[section:concept__Box concept::Box]
-[section:convert convert]
-[indexterm1 convert]
-Converts one [link boost_geometry.reference.boost__geometry `boost::geometry`] to another [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[link boost_geometry.reference.concept__Box `concept::Box`] concept.
template<
- typename Geometry1 ,
- typename Geometry2 >
- void convert(
- Geometry1 const & geometry1,
- Geometry2 & geometry2);
+ typename Geometry >
+ class Box
+[heading Formal definition:]
+
+The box concept is defined as following:
+* there must be a specialization of traits::tag defining box_tag as type
-The convert algorithm converts one [link boost_geometry.reference.boost__geometry `boost::geometry`], e.g. a BOX, to another [link boost_geometry.reference.boost__geometry `boost::geometry`], e.g. a RING. This only if it is possible and applicable.
+* there must be a specialization of traits::point_type to define the underlying point type (even if it does not consist of points, it should define this type, to indicate the points it can work with)
+* there must be a specialization of traits::indexed_access, per index (min_corner, max_corner) and per dimension, with two functions:get to get a coordinate valueset to set a coordinate value (this one is not checked for ConstBox)
-[variablelist
-
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-]
-[heading Parameters]
-
+[heading Requirements]
-[variablelist
-
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] (source) ]]
+[*Header: ][^boost/geometry/geometries/concepts/box_concept.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] (target) ]]
-]
+[endsect]
+
+[section:concept__ConstBox concept::ConstBox]
+
+
+[link boost_geometry.reference.concept__Box `concept::Box`] concept (const version).
+ template<
+ typename Geometry >
+ class ConstBox
+The [link boost_geometry.reference.concept__ConstBox `concept::ConstBox`] concept apply the same as the [link boost_geometry.reference.concept__Box `concept::Box`] concept, but does not apply write access.
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/convert.hpp]
+[*Header: ][^boost/geometry/geometries/concepts/box_concept.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:concept__ConstLinestring concept::ConstLinestring]
+
+
+[link boost_geometry.reference.concept__Linestring `concept::Linestring`] concept (const version).
-[section:convex_hull convex_hull]
-[indexterm1 convex_hull]
-
template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename Strategy >
- void ``[link boost_geometry.reference.convex_hull.overload1 convex_hull]``(
- Geometry1 const & geometry,
- Geometry2 & out,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.convex_hull.overload1 more...]]``
-
- template<
- typename Geometry1 ,
- typename Geometry2 >
- void ``[link boost_geometry.reference.convex_hull.overload2 convex_hull]``(
- Geometry1 const & geometry,
- Geometry2 & out);
- `` [''''»''' [link boost_geometry.reference.convex_hull.overload2 more...]]``
+ typename Geometry >
+ class ConstLinestring
+The [link boost_geometry.reference.concept__ConstLinestring `concept::ConstLinestring`] concept check the same as the [link boost_geometry.reference.concept__Linestring `concept::Linestring`] concept, but does not check write access.
+[heading Requirements]
-[heading Source descriptions:]
-
+[*Header: ][^boost/geometry/geometries/concepts/linestring_concept.hpp]
-* OGC description: Returns a geometric object that represents the convex hull of this geometric object. Convex hulls, being dependent on straight lines, can be accurately represented in linear interpolations for any geometry restricted to linear interpolations.
+[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
+[section:concept__ConstPoint concept::ConstPoint]
-[heading Performance]
-
-2776 counties of US are "hulled" in 0.9 seconds (http://trac.osgeo.org/ggl/wiki/Performance#Convexhull1)
+point concept (const version)
-[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.
+ template<
+ typename Geometry >
+ class ConstPoint
+The [link boost_geometry.reference.concept__ConstPoint `concept::ConstPoint`] concept apply the same as the [link boost_geometry.reference.concept__Point `concept::Point`] concept, but does not apply write access.
+[heading Requirements]
-[heading Geometries supported:]
-
-In the images below the convex hull is painted in red.
+[*Header: ][^boost/geometry/geometries/concepts/point_concept.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-* point: will not compile
+[endsect]
+[section:concept__ConstPolygon concept::ConstPolygon]
-* linestring:
+[link boost_geometry.reference.concept__Polygon `concept::Polygon`] concept (const version).
+ template<
+ typename Geometry >
+ class ConstPolygon
+The [link boost_geometry.reference.concept__ConstPolygon `concept::ConstPolygon`] concept check the same as the [link boost_geometry.reference.concept__Polygon `concept::Polygon`] concept, but does not check write access.
+[heading Requirements]
-* polygon: will deliver a polygon without holes
+[*Header: ][^boost/geometry/geometries/concepts/polygon_concept.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
+[section:concept__ConstRing concept::ConstRing]
-* multi_point:
+(linear) ring concept (const version)
+ template<
+ typename Geometry >
+ class ConstRing
+The ConstLinearRing concept check the same as the Geometry concept, but does not check write access.
+[heading Requirements]
-* multi_linestring:
+[*Header: ][^boost/geometry/geometries/concepts/ring_concept.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
-* multi_polygon:
+[section:concept__ConstSegment concept::ConstSegment]
+[link boost_geometry.reference.concept__Segment `concept::Segment`] concept (const version).
-[heading Output geometries supported:]
-
+ template<
+ typename Geometry >
+ class ConstSegment
+The [link boost_geometry.reference.concept__ConstSegment `concept::ConstSegment`] concept verifies the same as the [link boost_geometry.reference.concept__Segment `concept::Segment`] concept, but does not verify write access.
+[heading Requirements]
+[*Header: ][^boost/geometry/geometries/concepts/segment_concept.hpp]
-* polygon
+[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
+[section:concept__Linestring concept::Linestring]
-* ring
+[link boost_geometry.reference.concept__Linestring `concept::Linestring`] concept.
+ template<
+ typename Geometry >
+ class Linestring
-* inserter version (with output iterator) can output to any array supporting points of same type as the input geometry type
+[heading Formal definition:]
+
+The linestring concept is defined as following:
+* there must be a specialization of traits::tag defining linestring_tag as type
+* it must behave like a Boost.Range
+* either it can behave like the std library, having push_back and clear
-[heading Requirements]
+* or it can implement a mechanism for clearing and adding points:there can be a specialization of traits::use_std class indicating that it does not use the standard library (for modifications)there should then be a specialization of traits::clear to make a linestring emptythere should then be a specialization of traits::append_point to add a point to a linestring
-[*Header: ][^boost/geometry/algorithms/convex_hull.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 convex_hull (1 of 2 overloads)]
+[heading Remarks]
+
+to fulfil the concepts, no traits class has to be specialized to define the point type. The point type is taken using boost::range\_value<X>::type
- template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename Strategy >
- void convex_hull(
- Geometry1 const & geometry,
- Geometry2 & out,
- Strategy const & strategy);
+[heading Example:]
+
+A custom linestring, defining the necessary specializations to fulfil to the concept.
-[endsect]
+Suppose that the following linestring is defined:
-[section:overload2 convex_hull (2 of 2 overloads)]
-Calculate the convex hull of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+It can then be adapted to the concept as following:
- template<
- typename Geometry1 ,
- typename Geometry2 >
- void convex_hull(
- Geometry1 const & geometry,
- Geometry2 & out);
-[variablelist
-
-[[Geometry1][the input [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[heading Remarks]
+
-[[Geometry2:][the output [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+* There is also the registration macro BOOST_GEOMETRY_REGISTER_LINESTRING
-]
+* For registration of std::vector<P> (and deque, and list) it is enough to include the header-file geometries/adapted/std_as_linestring.hpp. That registers a vector as a linestring (so it cannot be registered as a linear ring then, in the same source code).
-[heading Parameters]
-
-[variablelist
-
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate convex hull from ]]
-[[out][a [link boost_geometry.reference.boost__geometry `boost::geometry`] receiving points of the convex hull ]]
-]
+[heading Requirements]
+[*Header: ][^boost/geometry/geometries/concepts/linestring_concept.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:concept__Point concept::Point]
-[endsect]
-[section:convex_hull_inserter convex_hull_inserter]
+[link boost_geometry.reference.concept__Point `concept::Point`] concept.
-[indexterm1 convex_hull_inserter]
-
- template<
- typename Geometry ,
- typename OutputIterator ,
- typename Strategy >
- OutputIterator ``[link boost_geometry.reference.convex_hull_inserter.overload1 convex_hull_inserter]``(
- Geometry const & geometry,
- OutputIterator out,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.convex_hull_inserter.overload1 more...]]``
template<
- typename Geometry ,
- typename OutputIterator >
- OutputIterator ``[link boost_geometry.reference.convex_hull_inserter.overload2 convex_hull_inserter]``(
- Geometry const & geometry,
- OutputIterator out);
- `` [''''»''' [link boost_geometry.reference.convex_hull_inserter.overload2 more...]]``
+ typename Geometry >
+ class Point
-[heading Requirements]
+[heading Formal definition:]
+
+The point concept is defined as following:
+* there must be a specialization of traits::tag defining point_tag as type
-[*Header: ][^boost/geometry/algorithms/convex_hull.hpp]
+* there must be a specialization of traits::coordinate_type defining the type of its coordinates
-[*Convenience header: ][^boost/geometry.hpp]
+* there must be a specialization of traits::coordinate_system defining its coordinate system (cartesian, spherical, etc)
+* there must be a specialization of traits::dimension defining its number of dimensions (2, 3, ...) (derive it conveniently from boost::mpl::int_<X> for X-D)
-[section:overload1 convex_hull_inserter (1 of 2 overloads)]
+* there must be a specialization of traits::access, per dimension, with two functions:get to get a coordinate valueset to set a coordinate value (this one is not checked for ConstPoint)
- template<
- typename Geometry ,
- typename OutputIterator ,
- typename Strategy >
- OutputIterator convex_hull_inserter(
- Geometry const & geometry,
- OutputIterator out,
- Strategy const & strategy);
+[heading Example:]
+
-[endsect]
+A legacy point, defining the necessary specializations to fulfil to the concept.
+Suppose that the following point is defined:
-[section:overload2 convex_hull_inserter (2 of 2 overloads)]
-Calculate the convex hull of a [link boost_geometry.reference.boost__geometry `boost::geometry`], output-iterator version.
- template<
- typename Geometry ,
- typename OutputIterator >
- OutputIterator convex_hull_inserter(
- Geometry const & geometry,
- OutputIterator out);
+It can then be adapted to the concept as following:
-[variablelist
-
-[[Geometry][the input [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[OutputIterator:][an output-iterator ]]
+Note that it is done like above to show the system. Users will normally use the registration macro.
-]
+[heading Example:]
+
-[heading Parameters]
-
-[variablelist
-
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate convex hull from ]]
+A read-only legacy point, using a macro to fulfil to the [link boost_geometry.reference.concept__ConstPoint `concept::ConstPoint`] concept. It cannot be modified by the library but can be used in all algorithms where points are not modified.
-[[out][an output iterator outputing points of the convex hull ]]
+The point looks like the following:
-]
+
-[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
+It uses the macro as following:
-[endsect]
-[endsect]
-[section:coordinate_system coordinate_system]
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/concepts/point_concept.hpp]
-Meta-function which defines coordinate system for any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[*Convenience header: ][^boost/geometry.hpp]
- template<
- typename G >
- struct coordinate_system
+[endsect]
-[heading Public Types]
-[table
- [[Name][Description]]
+[section:concept__Polygon concept::Polygon]
- [
- [[link boost_geometry.reference.coordinate_system.ncg [*ncg]]]
- []
-
- ]
+[link boost_geometry.reference.concept__Polygon `concept::Polygon`] concept.
- [
- [[link boost_geometry.reference.coordinate_system.type [*type]]]
- []
+ template<
+ typename Geometry >
+ class Polygon
+
+[heading Formal definition:]
- ]
+The polygon concept is defined as following:
+* there must be a specialization of traits::tag defining polygon_tag as type
-]
+* there must be a specialization of traits::ring_type defining the type of its exterior ring and interior rings as type
-[heading Requirements]
+* there must be a specialization of traits::interior_type defining the type of the collection of its interior rings as type
-[*Header: ][^boost/geometry/core/coordinate_system.hpp]
+* there must be a specialization of traits::exterior_ring with two functions named "get", returning the exterior ring, a const version and a mutable version
-[*Convenience header: ][^boost/geometry.hpp]
+* there must be a specialization of traits::interior_rings with two functions named "get", returning the interior rings, a const version and a mutable version
-[section:ncg coordinate_system::ncg]
-[indexterm2 ncg..coordinate_system]
- typedef boost::remove_const< G >::type ncg;
+[heading Remarks]
+
+to fulfil the concepts, no traits class has to be specialized to define the point type. The point type is automatically defined as typename range\_value<typename `ring_type<P>::type`>type
[heading Requirements]
-[*Header: ][^boost/geometry/core/coordinate_system.hpp]
+[*Header: ][^boost/geometry/geometries/concepts/polygon_concept.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:concept__Ring concept::Ring]
-[section:type coordinate_system::type]
-
-[indexterm2 type..coordinate_system]
+ring concept
- typedef core_dispatch::coordinate_system< typename tag< G >::type, ncg >::type type;
+ template<
+ typename Geometry >
+ class Ring
+[heading Formal definition:]
+
+The ring concept is defined as following:
+* there must be a specialization of traits::tag defining ring_tag as type
-[heading Public Types]
-[table
- [[Name][Description]]
+* it must behave like a Boost.Range
- [
+* there can optionally be a specialization of traits::point_order defining the order or orientation of its points, clockwise or counterclockwise.
- [[link boost_geometry.reference.tag.type [*type]]]
- []
-
- ]
+* either it can behave like the std library, having pushback
-]
+* or it can implement a mechanism for clearing and adding points. This is the same as the for the concept Linestring, and described there.
-[heading Typedef Description]
-
-All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type (point, linestring, 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 Remarks]
+
+to fulfil the concepts, no traits class has to be specialized to define the point type. The point type is taken using boost::range\_value<X>::type
[heading Requirements]
-[*Header: ][^boost/geometry/core/coordinate_system.hpp]
+[*Header: ][^boost/geometry/geometries/concepts/ring_concept.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:concept__Segment concept::Segment]
-[endsect]
+segment concept
-[section:coordinate_type coordinate_type]
+ template<
+ typename Geometry >
+ class Segment
-Meta-function which defines coordinate type (int, float, double, etc) of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[heading Formal definition:]
+
+The segment concept is defined as following:
+* there must be a specialization of traits::tag defining segment_tag as type
+* there must be a specialization of traits::point_type to define the underlying point type (even if it does not consist of points, it should define this type, to indicate the points it can work with)
- template<
- typename ``[link boost_geometry.reference.G G]``>
- struct coordinate_type
+* there must be a specialization of traits::indexed_access, per index and per dimension, with two functions:get to get a coordinate valueset to set a coordinate value (this one is not checked for ConstSegment)
-[heading Public Types]
-[table
- [[Name][Description]]
- [
- [[link boost_geometry.reference.coordinate_type.ncg [*ncg]]]
- []
-
- ]
- [
- [[link boost_geometry.reference.coordinate_type.type [*type]]]
- []
-
- ]
+[heading Remarks]
+
+The segment concept is similar to the box concept, defining another tag. However, the box concept assumes the index as min\_corner, max\_corner, while for the segment concept there is no assumption.
+
-]
[heading Requirements]
-[*Header: ][^boost/geometry/core/coordinate_type.hpp]
+[*Header: ][^boost/geometry/geometries/concepts/segment_concept.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:ncg coordinate_type::ncg]
+[endsect]
-[indexterm2 ncg..coordinate_type]
- typedef boost::remove_const< G >::type ncg;
+[section:concept__check concept::check]
+
+[indexterm1 concept::check]
+Checks, in compile-time, the concept of any geometry.
+ template<
+ typename Geometry >
+ void check();
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/coordinate_type.hpp]
+[*Header: ][^boost/geometry/geometries/concepts/check.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -1519,43 +1778,72 @@
-[section:type coordinate_type::type]
+[section:concept__check_concepts_and_equal_dimensions concept::check_concepts_and_equal_dimensions]
-[indexterm2 type..coordinate_type]
+[indexterm1 concept::check_concepts_and_equal_dimensions]
+Checks, in compile-time, the concept of two geometries, and if they have equal dimensions.
- typedef core_dispatch::coordinate_type< typename tag< G >::type, ncg >::type type;
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ void check_concepts_and_equal_dimensions();
-[heading Public Types]
-[table
- [[Name][Description]]
+[heading Requirements]
- [
+[*Header: ][^boost/geometry/geometries/concepts/check.hpp]
- [[link boost_geometry.reference.tag.type [*type]]]
- []
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:convert convert]
+
+[indexterm1 convert]
+Converts one geometry to another geometry.
+
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ void convert(
+ Geometry1 const & geometry1,
+ Geometry2 & geometry2);
+
+
+The convert algorithm converts one geometry, e.g. a BOX, to another geometry, e.g. a RING. This only if it is possible and applicable.
+
+
+
+[variablelist
- ]
+[[Geometry1][first geometry type ]]
+
+[[Geometry2][second geometry type ]]
]
-[heading Typedef Description]
+
+[heading Parameters]
-All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type (point, linestring, 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`] ]]
+[[geometry1][first geometry (source) ]]
-]
+[[geometry2][second geometry (target) ]]
+]
[heading Requirements]
-[*Header: ][^boost/geometry/core/coordinate_type.hpp]
+[*Header: ][^boost/geometry/algorithms/convert.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -1563,305 +1851,280 @@
[endsect]
+[section:convex_hull convex_hull]
-[endsect]
-
-[section:copy_segment_point copy_segment_point]
-
-[indexterm1 copy_segment_point]
-Helper function, copies a point from a segment.
-
-
+[indexterm1 convex_hull]
+
template<
- typename Geometry ,
- typename SegmentIdentifier ,
- typename PointOut >
- bool ``[link boost_geometry.reference.copy_segment_point.overload1 copy_segment_point]``(
- Geometry const & geometry,
- SegmentIdentifier const & seg_id,
- bool second,
- PointOut & point_out);
- `` [''''»''' [link boost_geometry.reference.copy_segment_point.overload1 more...]]``
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Strategy >
+ void ``[link boost_geometry.reference.convex_hull.overload1 convex_hull]``(
+ Geometry1 const & geometry,
+ Geometry2 & out,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.convex_hull.overload1 more...]]``
template<
typename Geometry1 ,
- typename Geometry2 ,
- typename SegmentIdentifier ,
- typename PointOut >
- bool ``[link boost_geometry.reference.copy_segment_point.overload2 copy_segment_point]``(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- SegmentIdentifier const & seg_id,
- bool second,
- PointOut & point_out);
- `` [''''»''' [link boost_geometry.reference.copy_segment_point.overload2 more...]]``
+ typename Geometry2 >
+ void ``[link boost_geometry.reference.convex_hull.overload2 convex_hull]``(
+ Geometry1 const & geometry,
+ Geometry2 & out);
+ `` [''''»''' [link boost_geometry.reference.convex_hull.overload2 more...]]``
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/overlay/copy_segment_point.hpp]
+[heading Source descriptions:]
+
-[*Convenience header: ][^boost/geometry.hpp]
+* OGC description: Returns a geometric object that represents the convex hull of this geometric object. Convex hulls, being dependent on straight lines, can be accurately represented in linear interpolations for any geometry restricted to linear interpolations.
-[section:overload1 copy_segment_point (1 of 2 overloads)]
-Helper function, copies a point from a segment.
+[heading Performance]
+
+2776 counties of US are "hulled" in 0.9 seconds (http://trac.osgeo.org/ggl/wiki/Performance#Convexhull1)
- template<
- typename Geometry ,
- typename SegmentIdentifier ,
- typename PointOut >
- bool copy_segment_point(
- Geometry const & geometry,
- SegmentIdentifier const & seg_id,
- bool second,
- PointOut & point_out);
+[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.
-[endsect]
+[heading Geometries supported:]
+
+In the images below the convex hull is painted in red.
+* point: will not compile
-[section:overload2 copy_segment_point (2 of 2 overloads)]
-Helper function, to avoid the same construct several times, copies a point, based on a source-index and two geometries.
+* linestring:
- template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename SegmentIdentifier ,
- typename PointOut >
- bool copy_segment_point(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- SegmentIdentifier const & seg_id,
- bool second,
- PointOut & point_out);
-[endsect]
+* polygon: will deliver a polygon without holes
-[endsect]
-[section:copy_segment_points copy_segment_points]
-[indexterm1 copy_segment_points]
-Helper function, to avoid the same construct several times, copies a point, based on a source-index and two geometries.
+* multi_point:
- template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename SegmentIdentifier ,
- typename PointOut >
- bool copy_segment_points(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- SegmentIdentifier const & seg_id,
- PointOut & point1,
- PointOut & point2);
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/overlay/copy_segment_point.hpp]
+* multi_linestring:
-[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+* multi_polygon:
-[section:copy_segments copy_segments]
-[indexterm1 copy_segments]
-Traverses through intersection points / geometries.
+[heading Output geometries supported:]
+
- template<
- typename Geometry ,
- typename SegmentIdentifier ,
- typename RangeOut >
- void copy_segments(
- Geometry const & geometry,
- SegmentIdentifier const & seg_id,
- int to_index,
- RangeOut & range_out);
-[heading Requirements]
+* polygon
-[*Header: ][^boost/geometry/algorithms/overlay/copy_segments.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+* ring
-[section:correct correct]
-[indexterm1 correct]
+* inserter version (with output iterator) can output to any array supporting points of same type as the input geometry type
- template<
- typename Geometry >
- void correct(
- Geometry & geometry);
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/correct.hpp]
+[*Header: ][^boost/geometry/algorithms/convex_hull.hpp]
[*Convenience header: ][^boost/geometry.hpp]
+[section:overload1 convex_hull (1 of 2 overloads)]
+
+
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Strategy >
+ void convex_hull(
+ Geometry1 const & geometry,
+ Geometry2 & out,
+ Strategy const & strategy);
+
+
+
[endsect]
-[section:cross_product cross_product]
+[section:overload2 convex_hull (2 of 2 overloads)]
-[indexterm1 cross_product]
-Computes the cross product of two vector.
+Calculate the convex hull of a geometry.
- template<
- typename P1 ,
- typename P2 >
- P1 cross_product(
- P1 const & p1,
- P2 const & p2);
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ void convex_hull(
+ Geometry1 const & geometry,
+ Geometry2 & out);
-Both vectors shall be of the same type. This type also determines type of result vector.
-[heading Parameters]
-
[variablelist
-[[p1][first vector ]]
+[[Geometry1][the input geometry type ]]
-[[p2][second vector ]]
+[[Geometry2:][the output geometry type ]]
]
-[heading Return Value]
-
-the cross product vector
+[heading Parameters]
+
+[variablelist
+
+[[geometry][the geometry to calculate convex hull from ]]
+[[out][a geometry receiving points of the convex hull ]]
-[heading Requirements]
+]
-[*Header: ][^boost/geometry/arithmetic/cross_product.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:cs__cartesian cs::cartesian]
-
-
-Cartesian coordinate system.
+[endsect]
+[section:convex_hull_inserter convex_hull_inserter]
- struct cartesian
-Defines the Cartesian or rectangular coordinate system where points are defined in 2 or 3 (or more) dimensions and usually (but not always) known as x,y,z
+[indexterm1 convex_hull_inserter]
+
+ template<
+ typename Geometry ,
+ typename OutputIterator ,
+ typename Strategy >
+ OutputIterator ``[link boost_geometry.reference.convex_hull_inserter.overload1 convex_hull_inserter]``(
+ Geometry const & geometry,
+ OutputIterator out,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.convex_hull_inserter.overload1 more...]]``
+ template<
+ typename Geometry ,
+ typename OutputIterator >
+ OutputIterator ``[link boost_geometry.reference.convex_hull_inserter.overload2 convex_hull_inserter]``(
+ Geometry const & geometry,
+ OutputIterator out);
+ `` [''''»''' [link boost_geometry.reference.convex_hull_inserter.overload2 more...]]``
[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
+[*Header: ][^boost/geometry/algorithms/convex_hull.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[section:overload1 convex_hull_inserter (1 of 2 overloads)]
-[section:cs__geographic cs::geographic]
-Geographic coordinate system, in [link boost_geometry.reference.degree `degree`] or in [link boost_geometry.reference.radian `radian`].
+ template<
+ typename Geometry ,
+ typename OutputIterator ,
+ typename Strategy >
+ OutputIterator convex_hull_inserter(
+ Geometry const & geometry,
+ OutputIterator out,
+ Strategy const & strategy);
- template<
- typename DegreeOrRadian >
- struct geographic
-[heading Public Types]
-[table
- [[Name][Description]]
+[endsect]
- [
- [[link boost_geometry.reference.cs__geographic.units [*units]]]
- []
-
- ]
-]
+[section:overload2 convex_hull_inserter (2 of 2 overloads)]
-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
+Calculate the convex hull of a geometry, output-iterator version.
+ template<
+ typename Geometry ,
+ typename OutputIterator >
+ OutputIterator convex_hull_inserter(
+ Geometry const & geometry,
+ OutputIterator out);
-[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[variablelist
+
+[[Geometry][the input geometry type ]]
-[section:units cs::geographic::units]
+[[OutputIterator:][an output-iterator ]]
-[indexterm2 units..cs::geographic]
+]
- typedef DegreeOrRadian units;
+[heading Parameters]
+
+[variablelist
+
+[[geometry][the geometry to calculate convex hull from ]]
-[heading Requirements]
+[[out][an output iterator outputing points of the convex hull ]]
-[*Header: ][^boost/geometry/core/cs.hpp]
+]
-[*Convenience header: ][^boost/geometry.hpp]
+[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
-[endsect]
[endsect]
-[section:cs__polar cs::polar]
+
+[endsect]
+
+[section:coordinate_system coordinate_system]
-Polar coordinate system.
+Meta-function which defines coordinate system for any geometry.
template<
- typename DegreeOrRadian >
- struct polar
+ typename G >
+ struct coordinate_system
[heading Public Types]
[table
@@ -1869,35 +2132,38 @@
[
- [[link boost_geometry.reference.cs__polar.units [*units]]]
+ [[link boost_geometry.reference.coordinate_system.ncg [*ncg]]]
[]
]
-]
+ [
-Defines the [link boost_geometry.reference.cs__polar `cs::polar`] coordinate system "in which each point
- on a plane is determined by an angle and a distance"
+ [[link boost_geometry.reference.coordinate_system.type [*type]]]
+ []
+
+ ]
+]
[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
+[*Header: ][^boost/geometry/core/coordinate_system.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:units cs::polar::units]
+[section:ncg coordinate_system::ncg]
-[indexterm2 units..cs::polar]
+[indexterm2 ncg..coordinate_system]
- typedef DegreeOrRadian units;
+ typedef boost::remove_const< G >::type ncg;
[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
+[*Header: ][^boost/geometry/core/coordinate_system.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -1906,17 +2172,13 @@
-[endsect]
-
-[section:cs__spherical cs::spherical]
+[section:type coordinate_system::type]
+[indexterm2 type..coordinate_system]
-Spherical coordinate system, in [link boost_geometry.reference.degree `degree`] or in [link boost_geometry.reference.radian `radian`].
+ typedef core_dispatch::coordinate_system< typename tag< G >::type, ncg >::type type;
- template<
- typename DegreeOrRadian >
- struct spherical
[heading Public Types]
[table
@@ -1924,46 +2186,29 @@
[
- [[link boost_geometry.reference.cs__spherical.units [*units]]]
+ [[link boost_geometry.reference.tag.type [*type]]]
[]
]
]
-Defines the [link boost_geometry.reference.cs__spherical `cs::spherical`] coordinate system where points are defined in two angles and an optional radius usually known as r, theta, phi
-[heading Coordinates:]
-
-
-* coordinate 0: 0 <= phi < 2pi is the angle between the positive x-axis and the line from the origin to the P projected onto the xy-plane.
-
-* coordinate 1: 0 <= theta <= pi is the angle between the positive z-axis and the line formed between the origin and P.
-
-* coordinate 2 (if specified): r >= 0 is the distance from the origin to a given point P.
-
-
-
-
-
-
-[heading Requirements]
-
-[*Header: ][^boost/geometry/core/cs.hpp]
-
-[*Convenience header: ][^boost/geometry.hpp]
-
+[heading Typedef Description]
+
+All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
-[section:units cs::spherical::units]
+[variablelist
+
+[[Geometry][geometry ]]
-[indexterm2 units..cs::spherical]
+]
- typedef DegreeOrRadian units;
[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
+[*Header: ][^boost/geometry/core/coordinate_system.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -1974,15 +2219,15 @@
[endsect]
-[section:cs_tag cs_tag]
+[section:coordinate_type coordinate_type]
-Meta-function returning coordinate system [link boost_geometry.reference.tag `tag`] ([link boost_geometry.reference.cs `cs`] family) of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Meta-function which defines coordinate type (int, float, double, etc) of any geometry.
template<
- typename G >
- struct cs_tag
+ typename ``[link boost_geometry.reference.G G]``>
+ struct coordinate_type
[heading Public Types]
[table
@@ -1990,63 +2235,38 @@
[
- [[link boost_geometry.reference.cs_tag.type [*type]]]
+ [[link boost_geometry.reference.coordinate_type.ncg [*ncg]]]
[]
]
-]
-
-[heading Requirements]
-
-[*Header: ][^boost/geometry/core/cs.hpp]
-
-[*Convenience header: ][^boost/geometry.hpp]
-
-
-[section:type cs_tag::type]
-
-[indexterm2 type..cs_tag]
-
- typedef traits::cs_tag< typename geometry::coordinate_system< G >::type >::type type;
-
-
-[heading Typedef Description]
-
-
+ [
-[variablelist
+ [[link boost_geometry.reference.coordinate_type.type [*type]]]
+ []
-[[CoordinateSystem][coordinate system ]]
+ ]
]
-
-
-
[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
+[*Header: ][^boost/geometry/core/coordinate_type.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
-
-
-
-[endsect]
+[section:ncg coordinate_type::ncg]
-[section:degree degree]
+[indexterm2 ncg..coordinate_type]
+ typedef boost::remove_const< G >::type ncg;
-Unit of plane angle: Degrees.
- class degree
[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
+[*Header: ][^boost/geometry/core/coordinate_type.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -2054,43 +2274,44 @@
[endsect]
-[section:difference difference]
-[indexterm1 difference]
+[section:type coordinate_type::type]
- template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename Collection >
- void difference(
- Geometry1 const & geometry1,
- Geometry2 geometry2,
- Collection & output_collection);
+[indexterm2 type..coordinate_type]
+ typedef core_dispatch::coordinate_type< typename tag< G >::type, ncg >::type type;
-[variablelist
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.tag.type [*type]]]
+ []
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+ ]
]
-
-[heading Parameters]
+[heading Typedef Description]
+All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make difference ]]
+[[Geometry][geometry ]]
]
+
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/difference.hpp]
+[*Header: ][^boost/geometry/core/coordinate_type.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -2098,71 +2319,116 @@
[endsect]
-[section:dimension dimension]
+[endsect]
+
+[section:copy_segment_point copy_segment_point]
-Meta-function which defines coordinate dimensions, i.e. the number of axes of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[indexterm1 copy_segment_point]
+Helper function, copies a point from a segment.
+
+ template<
+ typename Geometry ,
+ typename SegmentIdentifier ,
+ typename PointOut >
+ bool ``[link boost_geometry.reference.copy_segment_point.overload1 copy_segment_point]``(
+ Geometry const & geometry,
+ SegmentIdentifier const & seg_id,
+ bool second,
+ PointOut & point_out);
+ `` [''''»''' [link boost_geometry.reference.copy_segment_point.overload1 more...]]``
template<
- typename G >
- struct dimension
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename SegmentIdentifier ,
+ typename PointOut >
+ bool ``[link boost_geometry.reference.copy_segment_point.overload2 copy_segment_point]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ SegmentIdentifier const & seg_id,
+ bool second,
+ PointOut & point_out);
+ `` [''''»''' [link boost_geometry.reference.copy_segment_point.overload2 more...]]``
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/coordinate_dimension.hpp]
+[*Header: ][^boost/geometry/algorithms/overlay/copy_segment_point.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
-
+[section:overload1 copy_segment_point (1 of 2 overloads)]
-[section:disjoint disjoint]
-[indexterm1 disjoint]
-Calculate if two geometries are disjoint.
+Helper function, copies a point from a segment.
template<
- typename Geometry1 ,
- typename Geometry2 >
- bool disjoint(
- const Geometry1 & geometry1,
- const Geometry2 & geometry2);
-
-
-
-
-[variablelist
-
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+ typename Geometry ,
+ typename SegmentIdentifier ,
+ typename PointOut >
+ bool copy_segment_point(
+ Geometry const & geometry,
+ SegmentIdentifier const & seg_id,
+ bool second,
+ PointOut & point_out);
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-]
+[endsect]
-[heading Parameters]
-
-[variablelist
-
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[section:overload2 copy_segment_point (2 of 2 overloads)]
-]
+Helper function, to avoid the same construct several times, copies a point, based on a source-index and two geometries.
-[heading Return Value]
-
-true if disjoint, else false
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename SegmentIdentifier ,
+ typename PointOut >
+ bool copy_segment_point(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ SegmentIdentifier const & seg_id,
+ bool second,
+ PointOut & point_out);
+[endsect]
+
+
+[endsect]
+
+
+[section:copy_segment_points copy_segment_points]
+
+[indexterm1 copy_segment_points]
+Helper function, to avoid the same construct several times, copies a point, based on a source-index and two geometries.
+
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename SegmentIdentifier ,
+ typename PointOut >
+ bool copy_segment_points(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ SegmentIdentifier const & seg_id,
+ PointOut & point1,
+ PointOut & point2);
+
+
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/disjoint.hpp]
+[*Header: ][^boost/geometry/algorithms/overlay/copy_segment_point.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -2171,47 +2437,47 @@
-[section:dissolve dissolve]
+[section:copy_segments copy_segments]
-[indexterm1 dissolve]
-Removes self intersections from a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[indexterm1 copy_segments]
+Traverses through intersection points / geometries.
template<
typename Geometry ,
- typename OutputIterator >
- OutputIterator dissolve(
+ typename SegmentIdentifier ,
+ typename RangeOut >
+ void copy_segments(
Geometry const & geometry,
- OutputIterator output);
-
+ SegmentIdentifier const & seg_id,
+ int to_index,
+ RangeOut & range_out);
+[heading Requirements]
-[variablelist
-
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[*Header: ][^boost/geometry/algorithms/overlay/copy_segments.hpp]
-[[OutputIterator][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
+[*Convenience header: ][^boost/geometry.hpp]
-]
+[endsect]
-[heading Parameters]
-
-[variablelist
-
-[[geometry][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[output][container which will contain intersection points ]]
+[section:correct correct]
-]
+[indexterm1 correct]
+ template<
+ typename Geometry >
+ void correct(
+ Geometry & geometry);
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/dissolve.hpp]
+[*Header: ][^boost/geometry/algorithms/correct.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -2219,260 +2485,241 @@
[endsect]
-[section:distance distance]
-[indexterm1 distance]
-
- template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename Strategy >
- Strategy::return_type ``[link boost_geometry.reference.distance.overload1 distance]``(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.distance.overload1 more...]]``
+[section:cross_product cross_product]
+
+[indexterm1 cross_product]
+Computes the cross product of two vector.
+
template<
- typename Geometry1 ,
- typename Geometry2 >
- distance_result< Geometry1, Geometry2 >::type ``[link boost_geometry.reference.distance.overload2 distance]``(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
- `` [''''»''' [link boost_geometry.reference.distance.overload2 more...]]``
+ typename P1 ,
+ typename P2 >
+ P1 cross_product(
+ P1 const & p1,
+ P2 const & p2);
-The distance algorithm returns the distance between two geometries.
-[heading Coordinate systems and strategies:]
-
-With help of strategies the distance function returns the appropriate distance. If the input is in cartesian coordinates, the Euclidian distance (Pythagoras) is calculated. If the input is in spherical coordinates (either degree or radian), the distance over the sphere is returned. If the input is in geographic coordinates, distance is calculated over the globe and returned in meters.
+Both vectors shall be of the same type. This type also determines type of result vector.
-[heading Distance result:]
-
-Depending on calculation type the distance result is either a structure, convertable to a double, or a double value. In case of Pythagoras it makes sense to not draw the square root in the strategy itself. Taking a square root is relative expensive and is not necessary when comparing distances.
+[heading Parameters]
+
-[heading Geometries:]
+[variablelist
-Currently implemented, for both cartesian and spherical/geographic:
-* POINT - POINT
+[[p1][first vector ]]
-* POINT - SEGMENT and v.v.
+[[p2][second vector ]]
+
+]
-* POINT - LINESTRING and v.v.
+[heading Return Value]
+
+the cross product vector
-Not yet implemented:
-* POINT - RING etc, note that it will return a zero if the point is anywhere within the ring
+[heading Requirements]
+
+[*Header: ][^boost/geometry/arithmetic/cross_product.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
-[heading Example:]
-
-Example showing distance calculation of two points, in xy and in latlong coordinates
+[section:cs__cartesian cs::cartesian]
+Cartesian coordinate system.
+ struct cartesian
+Defines the Cartesian or rectangular coordinate system where points are defined in 2 or 3 (or more) dimensions and usually (but not always) known as x,y,z
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/distance.hpp]
+[*Header: ][^boost/geometry/core/cs.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 distance (1 of 2 overloads)]
+[endsect]
+[section:cs__geographic cs::geographic]
-Calculate distance between two geometries with a specified [link boost_geometry.reference.strategy `strategy`].
+Geographic coordinate system, in degree or in radian.
- template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename Strategy >
- Strategy::return_type distance(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- Strategy const & strategy);
+ template<
+ typename DegreeOrRadian >
+ struct geographic
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
-[variablelist
+ [[link boost_geometry.reference.cs__geographic.units [*units]]]
+ []
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-
-[[S][point-point-distance [link boost_geometry.reference.strategy `strategy`] type ]]
+ ]
]
+Defines the geographic coordinate system where points are defined in two angles and usually known as lat,long or lo,la or phi,lambda
-[heading Parameters]
-
-
-[variablelist
-
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[heading Remarks]
+
+might be moved to extensions/gis/geographic
-[[strategy][[link boost_geometry.reference.strategy `strategy`] to calculate distance between two points ]]
-]
+[heading Requirements]
-[heading Return Value]
-
-the distance (either a double or a distance\_result, (convertable to double))
+[*Header: ][^boost/geometry/core/cs.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[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`].
+[section:units cs::geographic::units]
-[heading Example:]
-
-Example showing distance calculation of two lat long points, using the accurate Vincenty approximation
+[indexterm2 units..cs::geographic]
+ typedef DegreeOrRadian units;
+[heading Requirements]
+[*Header: ][^boost/geometry/core/cs.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:overload2 distance (2 of 2 overloads)]
+[endsect]
+
+[section:cs__polar cs::polar]
-Calculate distance between two geometries.
+Polar coordinate system.
template<
- typename Geometry1 ,
- typename Geometry2 >
- distance_result< Geometry1, Geometry2 >::type distance(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
+ typename DegreeOrRadian >
+ struct polar
+[heading Public Types]
+[table
+ [[Name][Description]]
-The default [link boost_geometry.reference.strategy `strategy`] is used, belonging to the corresponding coordinate system of the geometries
+ [
-[variablelist
+ [[link boost_geometry.reference.cs__polar.units [*units]]]
+ []
-[[G1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-
-[[G2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+ ]
]
+Defines the polar coordinate system "in which each point
+ on a plane is determined by an angle and a distance"
-[heading Parameters]
-
-[variablelist
-
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[heading Requirements]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[*Header: ][^boost/geometry/core/cs.hpp]
-]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Return Value]
-
-the distance (either a double or a distance result, convertable to double)
+[section:units cs::polar::units]
+[indexterm2 units..cs::polar]
+ typedef DegreeOrRadian units;
-[endsect]
+[heading Requirements]
-[endsect]
+[*Header: ][^boost/geometry/core/cs.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:divide_point divide_point]
-[indexterm1 divide_point]
-Divides a point by another.
+[endsect]
- template<
- typename Point1 ,
- typename Point2 >
- void divide_point(
- Point1 & p1,
- Point2 const & p2);
+[endsect]
-The coordinates of the second point will be divided by those of the first point. The second point is not modified.
-[heading Parameters]
-
+[section:cs__spherical cs::spherical]
-[variablelist
-
-[[p1][first point ]]
-[[p2][second point ]]
+Spherical coordinate system, in degree or in radian.
-]
+ template<
+ typename DegreeOrRadian >
+ struct spherical
+[heading Public Types]
+[table
+ [[Name][Description]]
-[heading Requirements]
+ [
-[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+ [[link boost_geometry.reference.cs__spherical.units [*units]]]
+ []
+
+ ]
-[*Convenience header: ][^boost/geometry.hpp]
+]
+Defines the spherical coordinate system where points are defined in two angles and an optional radius usually known as r, theta, phi
+[heading Coordinates:]
+
-[endsect]
+* coordinate 0: 0 <= phi < 2pi is the angle between the positive x-axis and the line from the origin to the P projected onto the xy-plane.
+* coordinate 1: 0 <= theta <= pi is the angle between the positive z-axis and the line formed between the origin and P.
+* coordinate 2 (if specified): r >= 0 is the distance from the origin to a given point P.
-[section:divide_value divide_value]
-[indexterm1 divide_value]
-Divides each coordinate of a point by a value.
- template<
- typename Point >
- void divide_value(
- Point & p,
- typename detail::param< Point >::type value);
+[heading Requirements]
-[heading Parameters]
-
+[*Header: ][^boost/geometry/core/cs.hpp]
-[variablelist
-
-[[p][point ]]
+[*Convenience header: ][^boost/geometry.hpp]
-[[value][value to divide by ]]
-]
+[section:units cs::spherical::units]
+
+[indexterm2 units..cs::spherical]
+
+ typedef DegreeOrRadian units;
[heading Requirements]
-[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+[*Header: ][^boost/geometry/core/cs.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -2481,91 +2728,81 @@
-[section:dot_product dot_product]
+[endsect]
-[indexterm1 dot_product]
-Computes the dot product (or scalar product) of 2 vectors (points).
+[section:cs_tag cs_tag]
- template<
- typename P1 ,
- typename P2 >
- select_coordinate_type< P1, P2 >::type dot_product(
- P1 const & p1,
- P2 const & p2);
+Meta-function returning coordinate system tag (cs family) of any geometry.
+ template<
+ typename G >
+ struct cs_tag
+
+[heading Public Types]
+[table
+ [[Name][Description]]
-[heading Parameters]
-
+ [
-[variablelist
+ [[link boost_geometry.reference.cs_tag.type [*type]]]
+ []
-[[p1][first point ]]
-
-[[p2][second point ]]
+ ]
]
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/cs.hpp]
-[heading Return Value]
-
-the dot product
+[*Convenience header: ][^boost/geometry.hpp]
+[section:type cs_tag::type]
-[heading Requirements]
+[indexterm2 type..cs_tag]
-[*Header: ][^boost/geometry/arithmetic/dot_product.hpp]
+ typedef traits::cs_tag< typename geometry::coordinate_system< G >::type >::type type;
-[*Convenience header: ][^boost/geometry.hpp]
+[heading Typedef Description]
+
-[endsect]
+[variablelist
+
+[[CoordinateSystem][coordinate system ]]
+]
-[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);
+[heading Requirements]
+[*Header: ][^boost/geometry/core/cs.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[variablelist
-
-[[TurnPoints][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
+[endsect]
-]
-[heading Parameters]
-
+[endsect]
-[variablelist
-
-[[turn_points][container containing intersectionpoints ]]
+[section:degree degree]
-]
+Unit of plane angle: Degrees.
+ class degree
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/overlay/enrich_intersection_points.hpp]
+[*Header: ][^boost/geometry/core/cs.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -2573,47 +2810,62 @@
[endsect]
+[section:difference difference]
-[section:envelope envelope]
+[indexterm1 difference]
-[indexterm1 envelope]
-Calculate envelope of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+ template<
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Collection >
+ void difference(
+ Geometry1 const & geometry1,
+ Geometry2 geometry2,
+ Collection & output_collection);
- template<
- typename Geometry ,
- typename Box >
- void envelope(
- Geometry const & geometry,
- Box & mbr);
+[variablelist
+
+[[Geometry][geometry type ]]
+
+]
+
[heading Parameters]
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-
-[[mbr][the box receiving the envelope ]]
+[[geometry][the geometry to make difference ]]
]
-[heading Example:]
-
-Example showing envelope calculation, using point\_ll latlong points
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/difference.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+[section:dimension dimension]
+Meta-function which defines coordinate dimensions, i.e. the number of axes of any geometry.
+ template<
+ typename G >
+ struct dimension
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/envelope.hpp]
+[*Header: ][^boost/geometry/core/coordinate_dimension.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -2621,28 +2873,27 @@
[endsect]
+[section:disjoint disjoint]
-[section:equals equals]
-
-[indexterm1 equals]
-Detect if two geometries are spatially equal.
+[indexterm1 disjoint]
+Calculate if two geometries are disjoint.
template<
typename Geometry1 ,
typename Geometry2 >
- bool equals(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
+ bool disjoint(
+ const Geometry1 & geometry1,
+ const Geometry2 & geometry2);
[variablelist
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry1][first geometry type ]]
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry2][second geometry type ]]
]
@@ -2652,22 +2903,22 @@
[variablelist
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry1][first geometry ]]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry2][second geometry ]]
]
[heading Return Value]
-true if geometries are spatially equal, else false
+true if disjoint, else false
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/equals.hpp]
+[*Header: ][^boost/geometry/algorithms/disjoint.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -2675,116 +2926,147 @@
[endsect]
-[section:exception exception]
+[section:dissolve dissolve]
-Base [link boost_geometry.reference.exception `exception`] class for GGL.
+[indexterm1 dissolve]
+Removes self intersections from a geometry.
- struct exception
-[heading Requirements]
+ template<
+ typename Geometry ,
+ typename OutputIterator >
+ OutputIterator dissolve(
+ Geometry const & geometry,
+ OutputIterator output);
-[*Header: ][^boost/geometry/core/exception.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[variablelist
+
+[[Geometry][geometry type ]]
-[section:exterior_ring exterior_ring]
+[[OutputIterator][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
-[indexterm1 exterior_ring]
-Function to get the exterior\_ring ring of a polygon.
+]
+
+[heading Parameters]
- template<
- typename Polygon >
- ring_type< Polygon >::type & ``[link boost_geometry.reference.exterior_ring.overload1 exterior_ring]``(
- Polygon & polygon);
- `` [''''»''' [link boost_geometry.reference.exterior_ring.overload1 more...]]``
- template<
- typename Polygon >
- const ring_type< Polygon >::type & ``[link boost_geometry.reference.exterior_ring.overload2 exterior_ring]``(
- Polygon const & polygon);
- `` [''''»''' [link boost_geometry.reference.exterior_ring.overload2 more...]]``
+[variablelist
+
+[[geometry][first geometry ]]
+
+[[output][container which will contain intersection points ]]
+
+]
+
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/exterior_ring.hpp]
+[*Header: ][^boost/geometry/algorithms/dissolve.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 exterior_ring (1 of 2 overloads)]
-
+[endsect]
-Function to get the exterior\_ring ring of a polygon.
+[section:distance distance]
- template<
- typename Polygon >
- ring_type< Polygon >::type & exterior_ring(
- Polygon & polygon);
+[indexterm1 distance]
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Strategy >
+ Strategy::return_type ``[link boost_geometry.reference.distance.overload1 distance]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.distance.overload1 more...]]``
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ distance_result< Geometry1, Geometry2 >::type ``[link boost_geometry.reference.distance.overload2 distance]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
+ `` [''''»''' [link boost_geometry.reference.distance.overload2 more...]]``
+The distance algorithm returns the distance between two geometries.
+[heading Coordinate systems and strategies:]
+
+With help of strategies the distance function returns the appropriate distance. If the input is in cartesian coordinates, the Euclidian distance (Pythagoras) is calculated. If the input is in spherical coordinates (either degree or radian), the distance over the sphere is returned. If the input is in geographic coordinates, distance is calculated over the globe and returned in meters.
-[heading Remarks]
-
-OGC compliance: instead of ExteriorRing
+[heading Distance result:]
+
+Depending on calculation type the distance result is either a structure, convertable to a double, or a double value. In case of Pythagoras it makes sense to not draw the square root in the strategy itself. Taking a square root is relative expensive and is not necessary when comparing distances.
-[variablelist
+[heading Geometries:]
-[[P][polygon type ]]
+Currently implemented, for both cartesian and spherical/geographic:
+* POINT - POINT
-]
+* POINT - SEGMENT and v.v.
+* POINT - LINESTRING and v.v.
-[heading Parameters]
-
-[variablelist
-
-[[polygon][the polygon to get the exterior ring from ]]
-]
+Not yet implemented:
+* POINT - RING etc, note that it will return a zero if the point is anywhere within the ring
-[heading Return Value]
-
-a reference to the exterior ring
+[heading Example:]
+
+Example showing distance calculation of two points, in xy and in latlong coordinates
-[endsect]
-[section:overload2 exterior_ring (2 of 2 overloads)]
-Function to get the exterior ring of a polygon (const version).
+[heading Requirements]
+[*Header: ][^boost/geometry/algorithms/distance.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
- template<
- typename Polygon >
- const ring_type< Polygon >::type & exterior_ring(
- Polygon const & polygon);
+[section:overload1 distance (1 of 2 overloads)]
-[heading Remarks]
-
-OGC compliance: instead of ExteriorRing
+Calculate distance between two geometries with a specified strategy.
+
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Strategy >
+ Strategy::return_type distance(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ Strategy const & strategy);
+
[variablelist
-[[Polygon][polygon type ]]
+[[Geometry1][first geometry type ]]
+
+[[Geometry2][second geometry type ]]
+
+[[S][point-point-distance strategy type ]]
]
@@ -2794,160 +3076,140 @@
[variablelist
-[[polygon][the polygon to get the exterior ring from ]]
+[[geometry1][first geometry ]]
+
+[[geometry2][second geometry ]]
+
+[[strategy][strategy to calculate distance between two points ]]
]
[heading Return Value]
-a const reference to the exterior ring
+the distance (either a double or a distance\_result, (convertable to double))
+[heading Remarks]
+
+The strategy can be a point-point strategy. In case of distance point-line/point-polygon it may also be a point-segment strategy.
-[endsect]
+[heading Example:]
+
+Example showing distance calculation of two lat long points, using the accurate Vincenty approximation
-[endsect]
-[section:for_each_point for_each_point]
-[indexterm1 for_each_point]
-Calls functor for [link boost_geometry.reference.boost__geometry `boost::geometry`].
-
- template<
- typename Geometry ,
- typename Functor >
- Functor ``[link boost_geometry.reference.for_each_point.overload1 for_each_point]``(
- Geometry const & geometry,
- Functor f);
- `` [''''»''' [link boost_geometry.reference.for_each_point.overload1 more...]]``
- template<
- typename Geometry ,
- typename Functor >
- Functor ``[link boost_geometry.reference.for_each_point.overload2 for_each_point]``(
- Geometry & geometry,
- Functor f);
- `` [''''»''' [link boost_geometry.reference.for_each_point.overload2 more...]]``
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/for_each.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 for_each_point (1 of 2 overloads)]
+[section:overload2 distance (2 of 2 overloads)]
-Calls functor for [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Calculate distance between two geometries.
template<
- typename Geometry ,
- typename Functor >
- Functor for_each_point(
- Geometry const & geometry,
- Functor f);
+ typename Geometry1 ,
+ typename Geometry2 >
+ distance_result< Geometry1, Geometry2 >::type distance(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
+The default strategy is used, belonging to the corresponding coordinate system of the geometries
+
+[variablelist
+
+[[G1][first geometry type ]]
+
+[[G2][second geometry type ]]
+
+]
+
[heading Parameters]
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]]
+[[geometry1][first geometry ]]
-[[f][functor to use]]
+[[geometry2][second geometry ]]
]
-Calls the functor the specified const [link boost_geometry.reference.boost__geometry `boost::geometry`]
+
+[heading Return Value]
+
+the distance (either a double or a distance result, convertable to double)
+
+
[endsect]
+[endsect]
-[section:overload2 for_each_point (2 of 2 overloads)]
+[section:divide_point divide_point]
-Calls functor for [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[indexterm1 divide_point]
+Divides a point by another.
template<
- typename Geometry ,
- typename Functor >
- Functor for_each_point(
- Geometry & geometry,
- Functor f);
-
+ typename Point1 ,
+ typename Point2 >
+ void divide_point(
+ Point1 & p1,
+ Point2 const & p2);
+The coordinates of the second point will be divided by those of the first point. The second point is not modified.
[heading Parameters]
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]]
+[[p1][first point ]]
-[[f][functor to use]]
+[[p2][second point ]]
]
-Calls the functor for the specified [link boost_geometry.reference.boost__geometry `boost::geometry`]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:for_each_segment for_each_segment]
-
-[indexterm1 for_each_segment]
-Calls functor for segments on linestrings, rings, polygons, ...
-
-
- template<
- typename Geometry ,
- typename Functor >
- Functor ``[link boost_geometry.reference.for_each_segment.overload1 for_each_segment]``(
- Geometry const & geometry,
- Functor f);
- `` [''''»''' [link boost_geometry.reference.for_each_segment.overload1 more...]]``
- template<
- typename Geometry ,
- typename Functor >
- Functor ``[link boost_geometry.reference.for_each_segment.overload2 for_each_segment]``(
- Geometry & geometry,
- Functor f);
- `` [''''»''' [link boost_geometry.reference.for_each_segment.overload2 more...]]``
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/for_each.hpp]
+[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 for_each_segment (1 of 2 overloads)]
+[endsect]
-Calls functor for segments on linestrings, rings, polygons, ...
+
+[section:divide_value divide_value]
+
+[indexterm1 divide_value]
+Divides each coordinate of a point by a value.
template<
- typename Geometry ,
- typename Functor >
- Functor for_each_segment(
- Geometry const & geometry,
- Functor f);
+ typename Point >
+ void divide_value(
+ Point & p,
+ typename detail::param< Point >::type value);
@@ -2956,31 +3218,37 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]]
+[[p][point ]]
-[[f][functor to use]]
+[[value][value to divide by ]]
]
-Calls the functor all const segments of the specified const [link boost_geometry.reference.boost__geometry `boost::geometry`]
-[endsect]
+[heading Requirements]
+[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:overload2 for_each_segment (2 of 2 overloads)]
+[endsect]
-Calls functor for segments on linestrings, rings, polygons, ...
+
+
+[section:dot_product dot_product]
+
+[indexterm1 dot_product]
+Computes the dot product (or scalar product) of 2 vectors (points).
template<
- typename Geometry ,
- typename Functor >
- Functor for_each_segment(
- Geometry & geometry,
- Functor f);
+ typename P1 ,
+ typename P2 >
+ select_coordinate_type< P1, P2 >::type dot_product(
+ P1 const & p1,
+ P2 const & p2);
@@ -2989,125 +3257,148 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to loop through ]]
+[[p1][first point ]]
-[[f][functor to use]]
+[[p2][second point ]]
]
-Calls the functor all segments of the specified [link boost_geometry.reference.boost__geometry `boost::geometry`]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:geographic_tag geographic_tag]
+[heading Return Value]
+
+the dot product
-Tag indicating Geographic coordinate system family (geographic).
- struct geographic_tag
[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[*Header: ][^boost/geometry/arithmetic/dot_product.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:geometry_id geometry_id]
-Meta-function the id for a [link boost_geometry.reference.boost__geometry `boost::geometry`] type.
+[section:enrich_intersection_points enrich_intersection_points]
+[indexterm1 enrich_intersection_points]
+All intersection points are enriched with successor information.
- template<
- typename Geometry >
- struct geometry_id
-[heading Remarks]
-
-Used for e.g. reverse meta-function
+ 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);
-[heading Requirements]
-[*Header: ][^boost/geometry/core/geometry_id.hpp]
+[variablelist
+
+[[TurnPoints][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
-[*Convenience header: ][^boost/geometry.hpp]
+]
-[endsect]
+[heading Parameters]
+
-[section:geometry_not_recognized_tag geometry_not_recognized_tag]
+[variablelist
+
+[[turn_points][container containing intersectionpoints ]]
+]
-"default" [link boost_geometry.reference.tag `tag`]
- struct geometry_not_recognized_tag
[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[*Header: ][^boost/geometry/algorithms/overlay/enrich_intersection_points.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:get get]
-[indexterm1 get]
-get coordinate value of a Point ( / Sphere)
-
- template<
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- coordinate_type< Geometry >::type ``[link boost_geometry.reference.get.overload1 get]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.get.overload1 more...]]``
+[section:envelope envelope]
+
+[indexterm1 envelope]
+Calculate envelope of a geometry.
+
template<
- std::size_t ``[link boost_geometry.reference.Index Index]``,
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- coordinate_type< Geometry >::type ``[link boost_geometry.reference.get.overload2 get]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.get.overload2 more...]]``
+ typename Geometry ,
+ typename Box >
+ void envelope(
+ Geometry const & geometry,
+ Box & mbr);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the geometry ]]
+
+[[mbr][the box receiving the envelope ]]
+
+]
+
+
+[heading Example:]
+
+Example showing envelope calculation, using point\_ll latlong points
+
+
+
+
+
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/access.hpp]
+[*Header: ][^boost/geometry/algorithms/envelope.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 get (1 of 2 overloads)]
+[endsect]
-get coordinate value of a Point ( / Sphere)
+
+[section:equals equals]
+
+[indexterm1 equals]
+Detect if two geometries are spatially equal.
template<
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- coordinate_type< Geometry >::type get(
- Geometry const & geometry);
+ typename Geometry1 ,
+ typename Geometry2 >
+ bool equals(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
[variablelist
-[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
+[[Geometry1][first geometry type ]]
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry2][second geometry type ]]
]
@@ -3117,46 +3408,92 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to query coordinate value from ]]
+[[geometry1][first geometry ]]
+
+[[geometry2][second geometry ]]
]
[heading Return Value]
-coordinate value
+true if geometries are spatially equal, else false
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/equals.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
[endsect]
+[section:exception exception]
-[section:overload2 get (2 of 2 overloads)]
+Base exception class for GGL.
-get coordinate value of a Box / Segment
+ struct exception
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/exception.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:exterior_ring exterior_ring]
+
+[indexterm1 exterior_ring]
+Function to get the exterior\_ring ring of a polygon.
+
+
+ template<
+ typename Polygon >
+ ring_type< Polygon >::type & ``[link boost_geometry.reference.exterior_ring.overload1 exterior_ring]``(
+ Polygon & polygon);
+ `` [''''»''' [link boost_geometry.reference.exterior_ring.overload1 more...]]``
template<
- std::size_t ``[link boost_geometry.reference.Index Index]``,
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- coordinate_type< Geometry >::type get(
- Geometry const & geometry);
+ typename Polygon >
+ const ring_type< Polygon >::type & ``[link boost_geometry.reference.exterior_ring.overload2 exterior_ring]``(
+ Polygon const & polygon);
+ `` [''''»''' [link boost_geometry.reference.exterior_ring.overload2 more...]]``
+
+[heading Requirements]
+[*Header: ][^boost/geometry/core/exterior_ring.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[variablelist
-
-[[Index][for Point: do not specifyfor Box: min\_corner or max\_cornerfor Segment: 0 / 1
-]]
+[section:overload1 exterior_ring (1 of 2 overloads)]
+
+
+Function to get the exterior\_ring ring of a polygon.
+
+
+ template<
+ typename Polygon >
+ ring_type< Polygon >::type & exterior_ring(
+ Polygon & polygon);
+
+
+
+[heading Remarks]
+
+OGC compliance: instead of ExteriorRing
+
-[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[variablelist
+
+[[P][polygon type ]]
]
@@ -3166,14 +3503,14 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to query coordinate value from ]]
+[[polygon][the polygon to get the exterior ring from ]]
]
[heading Return Value]
-coordinate value
+a reference to the exterior ring
@@ -3181,34 +3518,29 @@
[endsect]
-[endsect]
+[section:overload2 exterior_ring (2 of 2 overloads)]
-[section:get_as_radian get_as_radian]
-[indexterm1 get_as_radian]
-get coordinate value of a point, result is in Radian
+Function to get the exterior ring of a polygon (const version).
template<
- std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
- typename Geometry >
- coordinate_type< Geometry >::type get_as_radian(
- const Geometry & geometry);
+ typename Polygon >
+ const ring_type< Polygon >::type & exterior_ring(
+ Polygon const & polygon);
-Result is in Radian, even if source coordinate system is in Degrees
-[heading Return Value]
+
+[heading Remarks]
-coordinate value
+OGC compliance: instead of ExteriorRing
[variablelist
-[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
-
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Polygon][polygon type ]]
]
@@ -3218,53 +3550,65 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to get coordinate value from ]]
+[[polygon][the polygon to get the exterior ring from ]]
]
-[heading Remarks]
+[heading Return Value]
-Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems
-
-
-
-[heading Requirements]
+a const reference to the exterior ring
-[*Header: ][^boost/geometry/core/radian_access.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[endsect]
-[section:get_section get_section]
-
-[indexterm1 get_section]
-Get iterators for a specified [link boost_geometry.reference.section `section`].
+[section:for_each_point for_each_point]
+[indexterm1 for_each_point]
+Calls functor for geometry.
+
template<
typename Geometry ,
- typename Section >
- void get_section(
+ typename Functor >
+ Functor ``[link boost_geometry.reference.for_each_point.overload1 for_each_point]``(
Geometry const & geometry,
- Section const & section,
- typename boost::range_const_iterator< typename geometry::range_type< Geometry >::type >::type & begin,
- typename boost::range_const_iterator< typename geometry::range_type< Geometry >::type >::type & end);
+ Functor f);
+ `` [''''»''' [link boost_geometry.reference.for_each_point.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor ``[link boost_geometry.reference.for_each_point.overload2 for_each_point]``(
+ Geometry & geometry,
+ Functor f);
+ `` [''''»''' [link boost_geometry.reference.for_each_point.overload2 more...]]``
+
+[heading Requirements]
+[*Header: ][^boost/geometry/algorithms/for_each.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[variablelist
-
-[[Geometry][type ]]
+[section:overload1 for_each_point (1 of 2 overloads)]
-[[Section][type of [link boost_geometry.reference.section `section`] to get from ]]
-]
+Calls functor for geometry.
+
+
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor for_each_point(
+ Geometry const & geometry,
+ Functor f);
+
[heading Parameters]
@@ -3272,211 +3616,254 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might be located in the neighborhood ]]
+[[geometry][geometry to loop through ]]
-[[section][structure with [link boost_geometry.reference.section `section`] ]]
+[[f][functor to use]]
-[[begin][begin-iterator (const iterator over points of [link boost_geometry.reference.section `section`]) ]]
+]
-[[end][end-iterator (const iterator over points of [link boost_geometry.reference.section `section`]) ]]
+Calls the functor the specified const geometry
-]
+[endsect]
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/get_section.hpp]
+[section:overload2 for_each_point (2 of 2 overloads)]
-[*Convenience header: ][^boost/geometry.hpp]
+
+Calls functor for geometry.
+
+
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor for_each_point(
+ Geometry & geometry,
+ Functor f);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][geometry to loop through ]]
+
+[[f][functor to use]]
+
+]
+
+Calls the functor for the specified geometry
[endsect]
-[section:get_turns get_turns]
+[endsect]
-[indexterm1 get_turns]
-Calculate intersection points of two geometries.
+[section:for_each_segment for_each_segment]
+
+[indexterm1 for_each_segment]
+Calls functor for segments on linestrings, rings, polygons, ...
template<
- typename AssignPolicy ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename Turns ,
- typename InterruptPolicy >
- void ``[link boost_geometry.reference.get_turns.overload1 get_turns]``(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- Turns & turns,
- InterruptPolicy & interrupt_policy);
- `` [''''»''' [link boost_geometry.reference.get_turns.overload1 more...]]``
+ typename Geometry ,
+ typename Functor >
+ Functor ``[link boost_geometry.reference.for_each_segment.overload1 for_each_segment]``(
+ Geometry const & geometry,
+ Functor f);
+ `` [''''»''' [link boost_geometry.reference.for_each_segment.overload1 more...]]``
template<
- typename AssignPolicy ,
typename Geometry ,
- typename Turns ,
- typename InterruptPolicy >
- void ``[link boost_geometry.reference.get_turns.overload2 get_turns]``(
- Geometry const & geometry,
- Turns & turns,
- InterruptPolicy & interrupt_policy);
- `` [''''»''' [link boost_geometry.reference.get_turns.overload2 more...]]``
+ typename Functor >
+ Functor ``[link boost_geometry.reference.for_each_segment.overload2 for_each_segment]``(
+ Geometry & geometry,
+ Functor f);
+ `` [''''»''' [link boost_geometry.reference.for_each_segment.overload2 more...]]``
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/overlay/get_turns.hpp]
+[*Header: ][^boost/geometry/algorithms/for_each.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 get_turns (1 of 2 overloads)]
+[section:overload1 for_each_segment (1 of 2 overloads)]
-Calculate intersection points of two geometries.
+Calls functor for segments on linestrings, rings, polygons, ...
template<
- typename AssignPolicy ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename Turns ,
- typename InterruptPolicy >
- void get_turns(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- Turns & turns,
- InterruptPolicy & interrupt_policy);
+ typename Geometry ,
+ typename Functor >
+ Functor for_each_segment(
+ Geometry const & geometry,
+ Functor f);
+[heading Parameters]
+
[variablelist
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[geometry][geometry to loop through ]]
-[[Turns][type of turn-container (e.g. vector of "intersection/turn point"'s) ]]
+[[f][functor to use]]
]
+Calls the functor all const segments of the specified const geometry
+
+
+[endsect]
+
+
+
+[section:overload2 for_each_segment (2 of 2 overloads)]
+
+
+Calls functor for segments on linestrings, rings, polygons, ...
+
+
+ template<
+ typename Geometry ,
+ typename Functor >
+ Functor for_each_segment(
+ Geometry & geometry,
+ Functor f);
+
+
[heading Parameters]
[variablelist
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry][geometry to loop through ]]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-
-[[turns][container which will contain intersection points ]]
+[[f][functor to use]]
]
+Calls the functor all segments of the specified geometry
+
+[endsect]
[endsect]
+[section:geographic_tag geographic_tag]
-[section:overload2 get_turns (2 of 2 overloads)]
+Tag indicating Geographic coordinate system family (geographic).
-Calculate self intersections of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+ struct geographic_tag
+[heading Requirements]
+[*Header: ][^boost/geometry/core/tags.hpp]
- template<
- typename AssignPolicy ,
- typename Geometry ,
- typename Turns ,
- typename InterruptPolicy >
- void get_turns(
- Geometry const & geometry,
- Turns & turns,
- InterruptPolicy & interrupt_policy);
+[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
+[section:geometry_id geometry_id]
-[variablelist
-
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-[[Turns][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
+Meta-function the id for a geometry type.
-]
+ template<
+ typename Geometry >
+ struct geometry_id
-[heading Parameters]
-
+[heading Remarks]
+
+Used for e.g. reverse meta-function
-[variablelist
-
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[turns][container which will contain intersection points ]]
-]
+[heading Requirements]
+[*Header: ][^boost/geometry/core/geometry_id.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:geometry_not_recognized_tag geometry_not_recognized_tag]
+
+
+"default" tag
+
+
+ struct geometry_not_recognized_tag
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
[endsect]
-[section:interior_rings interior_rings]
+[section:get get]
-[indexterm1 interior_rings]
-Function to get the interior rings of a polygon (non const version).
+[indexterm1 get]
+get coordinate value of a Point ( / Sphere)
template<
- typename Polygon >
- interior_type< Polygon >::type & ``[link boost_geometry.reference.interior_rings.overload1 interior_rings]``(
- Polygon & polygon);
- `` [''''»''' [link boost_geometry.reference.interior_rings.overload1 more...]]``
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ coordinate_type< Geometry >::type ``[link boost_geometry.reference.get.overload1 get]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.get.overload1 more...]]``
template<
- typename Polygon >
- const interior_type< Polygon >::type & ``[link boost_geometry.reference.interior_rings.overload2 interior_rings]``(
- Polygon const & polygon);
- `` [''''»''' [link boost_geometry.reference.interior_rings.overload2 more...]]``
+ std::size_t ``[link boost_geometry.reference.Index Index]``,
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ coordinate_type< Geometry >::type ``[link boost_geometry.reference.get.overload2 get]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.get.overload2 more...]]``
[heading Requirements]
-[*Header: ][^boost/geometry/core/interior_rings.hpp]
+[*Header: ][^boost/geometry/core/access.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 interior_rings (1 of 2 overloads)]
+[section:overload1 get (1 of 2 overloads)]
-Function to get the interior rings of a polygon (non const version).
+get coordinate value of a Point ( / Sphere)
template<
- typename Polygon >
- interior_type< Polygon >::type & interior_rings(
- Polygon & polygon);
-
-
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ coordinate_type< Geometry >::type get(
+ Geometry const & geometry);
-[heading Remarks]
-
-OGC compliance: instead of InteriorRingN
[variablelist
-[[P][polygon type ]]
+[[Dimension][dimension ]]
+
+[[Geometry][geometry ]]
]
@@ -3486,14 +3873,14 @@
[variablelist
-[[polygon][the polygon to get the interior rings from ]]
+[[geometry][geometry to query coordinate value from ]]
]
[heading Return Value]
-a reference to the interior rings
+coordinate value
@@ -3502,28 +3889,30 @@
-[section:overload2 interior_rings (2 of 2 overloads)]
+[section:overload2 get (2 of 2 overloads)]
-Function to get the interior rings of a polygon (const version).
+get coordinate value of a Box / Segment
template<
- typename Polygon >
- const interior_type< Polygon >::type & interior_rings(
- Polygon const & polygon);
-
-
+ std::size_t ``[link boost_geometry.reference.Index Index]``,
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
+ typename Geometry >
+ coordinate_type< Geometry >::type get(
+ Geometry const & geometry);
-[heading Remarks]
-
-OGC compliance: instead of InteriorRingN
[variablelist
-[[P][polygon type ]]
+[[Index][for Point: do not specifyfor Box: min\_corner or max\_cornerfor Segment: 0 / 1
+]]
+
+[[Dimension][dimension ]]
+
+[[Geometry][geometry ]]
]
@@ -3533,14 +3922,14 @@
[variablelist
-[[polygon][the polygon to get the interior rings from ]]
+[[geometry][geometry to query coordinate value from ]]
]
[heading Return Value]
-a const reference to the interior rings
+coordinate value
@@ -3550,75 +3939,55 @@
[endsect]
-[section:interior_type interior_type]
+[section:get_as_radian get_as_radian]
-Meta-function defining container type of inner rings of (multi)polygon geometriy.
+[indexterm1 get_as_radian]
+get coordinate value of a point, result is in Radian
template<
+ std::size_t ``[link boost_geometry.reference.Dimension Dimension]``,
typename Geometry >
- struct interior_type
-
-[heading Public Types]
-[table
- [[Name][Description]]
+ coordinate_type< Geometry >::type get_as_radian(
+ const Geometry & geometry);
- [
- [[link boost_geometry.reference.interior_type.type [*type]]]
- []
-
- ]
+Result is in Radian, even if source coordinate system is in Degrees
+[heading Return Value]
+
+coordinate value
-]
-the interior rings should be organized as a container (std::vector, std::deque, boost::array) with `boost` range support. This meta function defines the type of that container.
-[heading Requirements]
-
-[*Header: ][^boost/geometry/core/interior_rings.hpp]
-
-[*Convenience header: ][^boost/geometry.hpp]
-
-
-[section:type interior_type::type]
-
-[indexterm2 type..interior_type]
-
- typedef core_dispatch::interior_type< typename tag< Geometry >::type, Geometry >::type type;
-
-
-
-[heading Public Types]
-[table
- [[Name][Description]]
-
- [
-
- [[link boost_geometry.reference.tag.type [*type]]]
- []
+[variablelist
- ]
+[[Dimension][dimension ]]
+
+[[Geometry][geometry ]]
]
-[heading Typedef Description]
+
+[heading Parameters]
-All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type (point, linestring, 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`] ]]
+[[geometry][geometry to get coordinate value from ]]
]
+[heading Remarks]
+
+Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems
+
[heading Requirements]
-[*Header: ][^boost/geometry/core/interior_rings.hpp]
+[*Header: ][^boost/geometry/core/radian_access.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -3627,34 +3996,29 @@
-[endsect]
-
-
-[section:intersection intersection]
+[section:get_section get_section]
-[indexterm1 intersection]
-Intersects two geometries.
+[indexterm1 get_section]
+Get iterators for a specified section.
template<
- typename Geometry1 ,
- typename Geometry2 ,
- typename Collection >
- void intersection(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- Collection & output_collection);
+ typename Geometry ,
+ typename Section >
+ void get_section(
+ Geometry const & geometry,
+ Section const & section,
+ typename boost::range_const_iterator< typename geometry::range_type< Geometry >::type >::type & begin,
+ typename boost::range_const_iterator< typename geometry::range_type< Geometry >::type >::type & end);
+
-The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are added to the specified collection.
[variablelist
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry][type ]]
-[[Collection][collection of rings, polygons (e.g. a vector<polygon> or a multi\_polygon) ]]
+[[Section][type of section to get from ]]
]
@@ -3664,24 +4028,21 @@
[variablelist
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry][geometry which might be located in the neighborhood ]]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-
-[[output_collection][the collection ]]
+[[section][structure with section ]]
-]
+[[begin][begin-iterator (const iterator over points of section) ]]
+[[end][end-iterator (const iterator over points of section) ]]
-[heading Return Value]
-
-true if successful
+]
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/intersection.hpp]
+[*Header: ][^boost/geometry/algorithms/get_section.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -3689,75 +4050,71 @@
[endsect]
-[section:intersection_inserter intersection_inserter]
+[section:get_turns get_turns]
-[indexterm1 intersection_inserter]
-Intersects two geometries.
+[indexterm1 get_turns]
+Calculate intersection points of two geometries.
template<
- typename GeometryOut ,
+ typename AssignPolicy ,
typename Geometry1 ,
typename Geometry2 ,
- typename OutputIterator ,
- typename Strategy >
- OutputIterator ``[link boost_geometry.reference.intersection_inserter.overload1 intersection_inserter]``(
+ typename Turns ,
+ typename InterruptPolicy >
+ void ``[link boost_geometry.reference.get_turns.overload1 get_turns]``(
Geometry1 const & geometry1,
Geometry2 const & geometry2,
- OutputIterator out,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.intersection_inserter.overload1 more...]]``
+ Turns & turns,
+ InterruptPolicy & interrupt_policy);
+ `` [''''»''' [link boost_geometry.reference.get_turns.overload1 more...]]``
template<
- typename GeometryOut ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename OutputIterator >
- OutputIterator ``[link boost_geometry.reference.intersection_inserter.overload2 intersection_inserter]``(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- OutputIterator out);
- `` [''''»''' [link boost_geometry.reference.intersection_inserter.overload2 more...]]``
+ typename AssignPolicy ,
+ typename Geometry ,
+ typename Turns ,
+ typename InterruptPolicy >
+ void ``[link boost_geometry.reference.get_turns.overload2 get_turns]``(
+ Geometry const & geometry,
+ Turns & turns,
+ InterruptPolicy & interrupt_policy);
+ `` [''''»''' [link boost_geometry.reference.get_turns.overload2 more...]]``
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/intersection.hpp]
+[*Header: ][^boost/geometry/algorithms/overlay/get_turns.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 intersection_inserter (1 of 2 overloads)]
+[section:overload1 get_turns (1 of 2 overloads)]
-Intersects two geometries.
+Calculate intersection points of two geometries.
template<
- typename GeometryOut ,
+ typename AssignPolicy ,
typename Geometry1 ,
typename Geometry2 ,
- typename OutputIterator ,
- typename Strategy >
- OutputIterator intersection_inserter(
+ typename Turns ,
+ typename InterruptPolicy >
+ void get_turns(
Geometry1 const & geometry1,
Geometry2 const & geometry2,
- OutputIterator out,
- Strategy const & strategy);
+ Turns & turns,
+ InterruptPolicy & interrupt_policy);
+
-The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are sent to the specified output operator.
[variablelist
-[[GeometryOut][output [link boost_geometry.reference.boost__geometry `boost::geometry`] type, must be specified ]]
-
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry1][first geometry type ]]
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-
-[[OutputIterator][output iterator ]]
+[[Geometry2][second geometry type ]]
-[[Strategy][compound [link boost_geometry.reference.strategy `strategy`] for intersection ]]
+[[Turns][type of turn-container (e.g. vector of "intersection/turn point"'s) ]]
]
@@ -3767,56 +4124,45 @@
[variablelist
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry1][first geometry ]]
-[[out][the output iterator, outputting linestrings or polygons ]]
+[[geometry2][second geometry ]]
-[[strategy][the [link boost_geometry.reference.strategy `strategy`] ]]
+[[turns][container which will contain intersection points ]]
]
-[heading Return Value]
-
-the output iterator
-
-
[endsect]
-[section:overload2 intersection_inserter (2 of 2 overloads)]
+[section:overload2 get_turns (2 of 2 overloads)]
-Intersects two geometries.
+Calculate self intersections of a geometry.
template<
- typename GeometryOut ,
- typename Geometry1 ,
- typename Geometry2 ,
- typename OutputIterator >
- OutputIterator intersection_inserter(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2,
- OutputIterator out);
+ typename AssignPolicy ,
+ typename Geometry ,
+ typename Turns ,
+ typename InterruptPolicy >
+ void get_turns(
+ Geometry const & geometry,
+ Turns & turns,
+ InterruptPolicy & interrupt_policy);
+
-The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are sent to the specified output operator.
[variablelist
-[[GeometryOut][output [link boost_geometry.reference.boost__geometry `boost::geometry`] type, must be specified ]]
-
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry][geometry type ]]
-[[OutputIterator][output iterator ]]
+[[Turns][type of intersection container (e.g. vector of "intersection/turn point"'s) ]]
]
@@ -3826,20 +4172,13 @@
[variablelist
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry][geometry ]]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-
-[[out][the output iterator, outputting linestrings or polygons ]]
+[[turns][container which will contain intersection points ]]
]
-[heading Return Value]
-
-the output iterator
-
-
[endsect]
@@ -3847,92 +4186,100 @@
[endsect]
-[section:intersects intersects]
+[section:interior_rings interior_rings]
-[indexterm1 intersects]
-
+[indexterm1 interior_rings]
+Function to get the interior rings of a polygon (non const version).
+
+
template<
- typename Geometry >
- bool ``[link boost_geometry.reference.intersects.overload1 intersects]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.intersects.overload1 more...]]``
+ typename Polygon >
+ interior_type< Polygon >::type & ``[link boost_geometry.reference.interior_rings.overload1 interior_rings]``(
+ Polygon & polygon);
+ `` [''''»''' [link boost_geometry.reference.interior_rings.overload1 more...]]``
template<
- typename Geometry1 ,
- typename Geometry2 >
- bool ``[link boost_geometry.reference.intersects.overload2 intersects]``(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
- `` [''''»''' [link boost_geometry.reference.intersects.overload2 more...]]``
+ typename Polygon >
+ const interior_type< Polygon >::type & ``[link boost_geometry.reference.interior_rings.overload2 interior_rings]``(
+ Polygon const & polygon);
+ `` [''''»''' [link boost_geometry.reference.interior_rings.overload2 more...]]``
+[heading Requirements]
-[heading Source descriptions:]
-
+[*Header: ][^boost/geometry/core/interior_rings.hpp]
-* OGC description: Returns 1 (TRUE) if this geometric object spatially intersects anotherGeometry.
+[*Convenience header: ][^boost/geometry.hpp]
-* OGC: a.Intersects(b) <=> ! a.Disjoint(b)
+
+[section:overload1 interior_rings (1 of 2 overloads)]
+Function to get the interior rings of a polygon (non const version).
-[heading Remarks]
-
-There are two overloaded versions:
-* with one geometry, detecting self-intersections
+ template<
+ typename Polygon >
+ interior_type< Polygon >::type & interior_rings(
+ Polygon & polygon);
+
-* with two geometries, deferring to disjoint, returning !disjoint
+[heading Remarks]
+
+OGC compliance: instead of InteriorRingN
-[heading Geometries:]
+[variablelist
+[[P][polygon type ]]
-* ring
+]
-* polygon
-* for two geometries: same is disjoint
+[heading Parameters]
+
+[variablelist
+
+[[polygon][the polygon to get the interior rings from ]]
+]
-[heading Remarks]
+[heading Return Value]
-if one geometry is completely within another geometry, it "intersects"
+a reference to the interior rings
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/intersects.hpp]
+[endsect]
-[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 intersects (1 of 2 overloads)]
+[section:overload2 interior_rings (2 of 2 overloads)]
-Determine if there is at least one intersection (crossing or self-tangency).
+Function to get the interior rings of a polygon (const version).
template<
- typename Geometry >
- bool intersects(
- Geometry const & geometry);
+ typename Polygon >
+ const interior_type< Polygon >::type & interior_rings(
+ Polygon const & polygon);
[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)
+OGC compliance: instead of InteriorRingN
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[P][polygon type ]]
]
@@ -3942,14 +4289,14 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[polygon][the polygon to get the interior rings from ]]
]
[heading Return Value]
-true if there are intersections, else false
+a const reference to the interior rings
@@ -3957,335 +4304,408 @@
[endsect]
+[endsect]
-[section:overload2 intersects (2 of 2 overloads)]
+[section:interior_type interior_type]
-Determine if there is at least one intersection.
+Meta-function defining container type of inner rings of (multi)polygon geometriy.
template<
- typename Geometry1 ,
- typename Geometry2 >
- bool intersects(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
-
+ typename Geometry >
+ struct interior_type
+[heading Public Types]
+[table
+ [[Name][Description]]
+ [
-[variablelist
+ [[link boost_geometry.reference.interior_type.type [*type]]]
+ []
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+ ]
]
+the interior rings should be organized as a container (std::vector, std::deque, boost::array) with boost range support. This meta function defines the type of that container.
-[heading Parameters]
-
-
-[variablelist
-
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[heading Requirements]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[*Header: ][^boost/geometry/core/interior_rings.hpp]
-]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Return Value]
-
-true if there are intersection(s), else false
+[section:type interior_type::type]
+[indexterm2 type..interior_type]
+ typedef core_dispatch::interior_type< typename tag< Geometry >::type, Geometry >::type type;
-[endsect]
+[heading Public Types]
+[table
+ [[Name][Description]]
-[endsect]
+ [
-[section:is_linear is_linear]
+ [[link boost_geometry.reference.tag.type [*type]]]
+ []
+
+ ]
+]
-Meta-function defining "true" for linear types (linestring,ring), "false" for non-linear typse.
+[heading Typedef Description]
+
+All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+[variablelist
+
+[[Geometry][geometry ]]
- template<
- typename Geometry >
- struct is_linear
+]
-[heading Remarks]
-
-Used for [link boost_geometry.reference.tag `tag`] dispatching and meta-function finetuning
[heading Requirements]
-[*Header: ][^boost/geometry/core/is_linear.hpp]
+[*Header: ][^boost/geometry/core/interior_rings.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:is_multi is_multi]
-Meta-function defining "true" for multi geometries (multi\_point, etc).
+[endsect]
+
+
+[section:intersection intersection]
+
+[indexterm1 intersection]
+Intersects two geometries.
template<
- typename Geometry >
- struct is_multi
-[heading Requirements]
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename Collection >
+ void intersection(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ Collection & output_collection);
-[*Header: ][^boost/geometry/core/is_multi.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are added to the specified collection.
+[variablelist
+
+[[Geometry1][first geometry type ]]
-[endsect]
+[[Geometry2][second geometry type ]]
-[section:is_radian is_radian]
+[[Collection][collection of rings, polygons (e.g. a vector<polygon> or a multi\_polygon) ]]
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry1][first geometry ]]
+
+[[geometry2][second geometry ]]
+
+[[output_collection][the collection ]]
+
+]
+
+
+[heading Return Value]
+
+true if successful
-Meta-function to verify if a coordinate system is [link boost_geometry.reference.radian `radian`].
- template<
- typename CoordinateSystem >
- struct is_radian
[heading Requirements]
-[*Header: ][^boost/geometry/core/cs.hpp]
+[*Header: ][^boost/geometry/algorithms/intersection.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:length length]
-[indexterm1 length]
-
- template<
- typename Geometry >
- length_result< Geometry >::type ``[link boost_geometry.reference.length.overload1 length]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.length.overload1 more...]]``
+[section:intersection_inserter intersection_inserter]
+[indexterm1 intersection_inserter]
+Intersects two geometries.
+
+
template<
- typename Geometry ,
+ typename GeometryOut ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename OutputIterator ,
typename Strategy >
- length_result< Geometry >::type ``[link boost_geometry.reference.length.overload2 length]``(
- Geometry const & geometry,
+ OutputIterator ``[link boost_geometry.reference.intersection_inserter.overload1 intersection_inserter]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ OutputIterator out,
Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.length.overload2 more...]]``
+ `` [''''»''' [link boost_geometry.reference.intersection_inserter.overload1 more...]]``
-The length algorithm is implemented for the linestring and the multi\_linestring geometry and results in the length of the linestring. If the points of a linestring have coordinates expressed in kilometers, the length of the line is expressed in kilometers as well.
-[heading Example:]
-
-Example showing length calculation
+ template<
+ typename GeometryOut ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename OutputIterator >
+ OutputIterator ``[link boost_geometry.reference.intersection_inserter.overload2 intersection_inserter]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ OutputIterator out);
+ `` [''''»''' [link boost_geometry.reference.intersection_inserter.overload2 more...]]``
+[heading Requirements]
+[*Header: ][^boost/geometry/algorithms/intersection.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
+[section:overload1 intersection_inserter (1 of 2 overloads)]
-[heading Requirements]
+Intersects two geometries.
-[*Header: ][^boost/geometry/algorithms/length.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+ template<
+ typename GeometryOut ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename OutputIterator ,
+ typename Strategy >
+ OutputIterator intersection_inserter(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ OutputIterator out,
+ Strategy const & strategy);
-[section:overload1 length (1 of 2 overloads)]
+The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are sent to the specified output operator.
+[variablelist
+
+[[GeometryOut][output geometry type, must be specified ]]
-Calculate length of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[[Geometry1][first geometry type ]]
+[[Geometry2][second geometry type ]]
- template<
- typename Geometry >
- length_result< Geometry >::type length(
- Geometry const & geometry);
+[[OutputIterator][output iterator ]]
+
+[[Strategy][compound strategy for intersection ]]
+
+]
-The function length returns the length of a [link boost_geometry.reference.boost__geometry `boost::geometry`], using the default distance-calculation-strategy
[heading Parameters]
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`], being a geometry::linestring, vector, iterator pair, or any other `boost` compatible range ]]
+[[geometry1][first geometry ]]
+
+[[geometry2][second geometry ]]
+
+[[out][the output iterator, outputting linestrings or polygons ]]
+
+[[strategy][the strategy ]]
]
[heading Return Value]
-the length Example showing length calculation on a vector
+the output iterator
+[endsect]
+[section:overload2 intersection_inserter (2 of 2 overloads)]
-[endsect]
+Intersects two geometries.
-[section:overload2 length (2 of 2 overloads)]
+ template<
+ typename GeometryOut ,
+ typename Geometry1 ,
+ typename Geometry2 ,
+ typename OutputIterator >
+ OutputIterator intersection_inserter(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2,
+ OutputIterator out);
+
+
+The two input geometries are intersected and the resulting linestring(s), ring(s) or polygon(s) are sent to the specified output operator.
+[variablelist
+
+[[GeometryOut][output geometry type, must be specified ]]
-Calculate length of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[[Geometry1][first geometry type ]]
+[[Geometry2][second geometry type ]]
- template<
- typename Geometry ,
- typename Strategy >
- length_result< Geometry >::type length(
- Geometry const & geometry,
- Strategy const & strategy);
+[[OutputIterator][output iterator ]]
+
+]
-The function length returns the length of a [link boost_geometry.reference.boost__geometry `boost::geometry`], using specified [link boost_geometry.reference.strategy `strategy`]
[heading Parameters]
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`], being a geometry::linestring, vector, iterator pair, or any other `boost` compatible range ]]
+[[geometry1][first geometry ]]
-[[strategy][[link boost_geometry.reference.strategy `strategy`] to be used for distance calculations. ]]
+[[geometry2][second geometry ]]
+
+[[out][the output iterator, outputting linestrings or polygons ]]
]
[heading Return Value]
-the length
-
-
-[heading Example:]
-
-Example showing length calculation using iterators and the Vincenty [link boost_geometry.reference.strategy `strategy`]
-
-
+the output iterator
+[endsect]
[endsect]
+[section:intersects intersects]
-[endsect]
+[indexterm1 intersects]
+
+ template<
+ typename Geometry >
+ bool ``[link boost_geometry.reference.intersects.overload1 intersects]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.intersects.overload1 more...]]``
-[section:linestring_tag linestring_tag]
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ bool ``[link boost_geometry.reference.intersects.overload2 intersects]``(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
+ `` [''''»''' [link boost_geometry.reference.intersects.overload2 more...]]``
-OGC Linestring identifying [link boost_geometry.reference.tag `tag`].
+[heading Source descriptions:]
+
+* OGC description: Returns 1 (TRUE) if this geometric object spatially intersects anotherGeometry.
- struct linestring_tag
-[heading Requirements]
+* OGC: a.Intersects(b) <=> ! a.Disjoint(b)
-[*Header: ][^boost/geometry/core/tags.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
-[endsect]
+[heading Remarks]
+
+There are two overloaded versions:
+* with one geometry, detecting self-intersections
-[section:make make]
+* with two geometries, deferring to disjoint, returning !disjoint
-[indexterm1 make]
-Make a [link boost_geometry.reference.boost__geometry `boost::geometry`].
-
- template<
- typename Geometry ,
- typename T >
- Geometry ``[link boost_geometry.reference.make.overload1 make]``(
- T const & c1,
- T const & c2);
- `` [''''»''' [link boost_geometry.reference.make.overload1 more...]]``
- template<
- typename Geometry ,
- typename T >
- Geometry ``[link boost_geometry.reference.make.overload2 make]``(
- T const & c1,
- T const & c2,
- T const & c3);
- `` [''''»''' [link boost_geometry.reference.make.overload2 more...]]``
- template<
- typename Geometry ,
- typename T >
- Geometry ``[link boost_geometry.reference.make.overload3 make]``(
- T const & c1,
- T const & c2,
- T const & c3,
- T const & c4);
- `` [''''»''' [link boost_geometry.reference.make.overload3 more...]]``
+[heading Geometries:]
+
+
+* ring
+
+* polygon
+
+* for two geometries: same is disjoint
+
+
+
+
+[heading Remarks]
+
+if one geometry is completely within another geometry, it "intersects"
+
- template<
- typename Geometry ,
- typename Range >
- Geometry ``[link boost_geometry.reference.make.overload4 make]``(
- Range const & range);
- `` [''''»''' [link boost_geometry.reference.make.overload4 more...]]``
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/make.hpp]
+[*Header: ][^boost/geometry/algorithms/intersects.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 make (1 of 4 overloads)]
+[section:overload1 intersects (1 of 2 overloads)]
-Make a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Determine if there is at least one intersection (crossing or self-tangency).
template<
- typename Geometry ,
- typename T >
- Geometry make(
- T const & c1,
- T const & c2);
+ typename Geometry >
+ bool intersects(
+ Geometry const & geometry);
+
-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]
+This function can be called for one geometry (self-intersection) and also for two geometries (intersection)
[variablelist
-[[G][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry][geometry type ]]
-[[T][the coordinate type ]]
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][geometry ]]
]
[heading Return Value]
-the [link boost_geometry.reference.boost__geometry `boost::geometry`]
+true if there are intersections, else false
@@ -4294,178 +4714,182 @@
-[section:overload2 make (2 of 4 overloads)]
+[section:overload2 intersects (2 of 2 overloads)]
-Make a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Determine if there is at least one intersection.
template<
- typename Geometry ,
- typename T >
- Geometry make(
- T const & c1,
- T const & c2,
- T const & c3);
+ typename Geometry1 ,
+ typename Geometry2 >
+ bool intersects(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
-[heading Return Value]
-
-a 3D point
+[variablelist
+
+[[Geometry1][first geometry type ]]
+[[Geometry2][second geometry type ]]
+]
-[endsect]
+[heading Parameters]
+
+[variablelist
+
+[[geometry1][first geometry ]]
-[section:overload3 make (3 of 4 overloads)]
+[[geometry2][second geometry ]]
+]
- template<
- typename Geometry ,
- typename T >
- Geometry make(
- T const & c1,
- T const & c2,
- T const & c3,
- T const & c4);
+[heading Return Value]
+
+true if there are intersection(s), else false
-[endsect]
+[endsect]
-[section:overload4 make (4 of 4 overloads)]
+[endsect]
+[section:is_linear is_linear]
- template<
- typename Geometry ,
- typename Range >
- Geometry make(
- Range const & range);
+Meta-function defining "true" for linear types (linestring,ring), "false" for non-linear typse.
+ template<
+ typename Geometry >
+ struct is_linear
-[endsect]
+[heading Remarks]
+
+Used for tag dispatching and meta-function finetuning
-[endsect]
+[heading Requirements]
-[section:make_buffer make_buffer]
+[*Header: ][^boost/geometry/core/is_linear.hpp]
-[indexterm1 make_buffer]
-Calculate and return buffer (= new [link boost_geometry.reference.boost__geometry `boost::geometry`]) around specified distance of [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[*Convenience header: ][^boost/geometry.hpp]
- template<
- typename Output ,
- typename Input ,
- typename T >
- Output make_buffer(
- Input const & geometry,
- T const & distance,
- T const & chord_length = -1);
+[endsect]
+[section:is_multi is_multi]
-[heading Parameters]
-
+Meta-function defining "true" for multi geometries (multi\_point, etc).
-[variablelist
-
-[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-[[distance][the distance used in buffer ]]
+ template<
+ typename Geometry >
+ struct is_multi
+[heading Requirements]
-[[chord_length][length of the chord's in the generated arcs around points or bends ]]
+[*Header: ][^boost/geometry/core/is_multi.hpp]
-]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Return Value]
-
-the buffered [link boost_geometry.reference.boost__geometry `boost::geometry`]
+[endsect]
+[section:is_radian is_radian]
-[heading Remarks]
-
-See also: buffer
+Meta-function to verify if a coordinate system is radian.
+ template<
+ typename CoordinateSystem >
+ struct is_radian
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/buffer.hpp]
+[*Header: ][^boost/geometry/core/cs.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:length length]
-[section:make_centroid make_centroid]
-
-[indexterm1 make_centroid]
-Calculate and return centroid.
-
-
+[indexterm1 length]
+
template<
- typename Point ,
typename Geometry >
- Point ``[link boost_geometry.reference.make_centroid.overload1 make_centroid]``(
+ length_result< Geometry >::type ``[link boost_geometry.reference.length.overload1 length]``(
Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.make_centroid.overload1 more...]]``
+ `` [''''»''' [link boost_geometry.reference.length.overload1 more...]]``
template<
- typename Point ,
typename Geometry ,
typename Strategy >
- Point ``[link boost_geometry.reference.make_centroid.overload2 make_centroid]``(
+ length_result< Geometry >::type ``[link boost_geometry.reference.length.overload2 length]``(
Geometry const & geometry,
Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.make_centroid.overload2 more...]]``
+ `` [''''»''' [link boost_geometry.reference.length.overload2 more...]]``
+
+The length algorithm is implemented for the linestring and the multi\_linestring geometry and results in the length of the linestring. If the points of a linestring have coordinates expressed in kilometers, the length of the line is expressed in kilometers as well.
+[heading Example:]
+
+Example showing length calculation
+
+
+
+
+
+
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/centroid.hpp]
+[*Header: ][^boost/geometry/algorithms/length.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 make_centroid (1 of 2 overloads)]
+[section:overload1 length (1 of 2 overloads)]
-Calculate and return centroid.
+Calculate length of a geometry.
template<
- typename Point ,
typename Geometry >
- Point make_centroid(
+ length_result< Geometry >::type length(
Geometry const & geometry);
-
+The function length returns the length of a geometry, using the default distance-calculation-strategy
[heading Parameters]
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate centroid from ]]
+[[geometry][the geometry, being a [link boost_geometry.reference.linestring `linestring`], vector, iterator pair, or any other boost compatible range ]]
]
[heading Return Value]
-the centroid
+the length Example showing length calculation on a vector
+
+
+
+
@@ -4474,67 +4898,75 @@
-[section:overload2 make_centroid (2 of 2 overloads)]
+[section:overload2 length (2 of 2 overloads)]
-Calculate and return centroid, using a specified [link boost_geometry.reference.strategy `strategy`].
+Calculate length of a geometry.
template<
- typename Point ,
typename Geometry ,
typename Strategy >
- Point make_centroid(
+ length_result< Geometry >::type length(
Geometry const & geometry,
Strategy const & strategy);
-
+The function length returns the length of a geometry, using specified strategy
[heading Parameters]
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to calculate centroid from ]]
+[[geometry][the geometry, being a [link boost_geometry.reference.linestring `linestring`], vector, iterator pair, or any other boost compatible range ]]
-[[strategy][Calculation [link boost_geometry.reference.strategy `strategy`] for centroid ]]
+[[strategy][strategy to be used for distance calculations. ]]
]
[heading Return Value]
-the centroid
+the length
+
+
+[heading Example:]
+
+Example showing length calculation using iterators and the Vincenty strategy
+
+
-[endsect]
[endsect]
-[section:make_envelope make_envelope]
+[endsect]
-[indexterm1 make_envelope]
-Calculate and return envelope of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[section:linear_ring linear_ring]
- template<
- typename Box ,
- typename Geometry >
- Box make_envelope(
- Geometry const & geometry);
+A [link boost_geometry.reference.linear_ring `linear_ring`] (linear [link boost_geometry.reference.linear_ring `linear_ring`]) is a closed line which should not be selfintersecting.
+ template<
+ typename ``[link boost_geometry.reference.P P]``,
+ template< typename, typename > class ``[link boost_geometry.reference.V V]`` = std::vector,
+ bool ``[link boost_geometry.reference.ClockWise ClockWise]`` = true,
+ template< typename > class ``[link boost_geometry.reference.A A]`` = std::allocator>
+ class linear_ring
-[heading Parameters]
-
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[P][point type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type ]]
]
@@ -4542,44 +4974,1669 @@
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/envelope.hpp]
+[*Header: ][^boost/geometry/geometries/linear_ring.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:linestring linestring]
-[section:make_inverse make_inverse]
-
-[indexterm1 make_inverse]
-Create a box with inverse infinite coordinates.
+A linestring (named so by OGC) is a collection (default a vector) of points.
template<
- typename Geometry >
- Geometry make_inverse();
+ typename P ,
+ template< typename, typename > class ``[link boost_geometry.reference.V V]`` = std::vector,
+ template< typename > class ``[link boost_geometry.reference.A A]`` = std::allocator>
+ class linestring
+
+
+[variablelist
+
+[[P][point type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type (see http://accu.org/index.php/journals/427#ftn.d0e249 ) ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/linestring.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:linestring_2d linestring_2d]
+
+[indexterm1 linestring_2d]
+
+ typedef linestring< point_2d > linestring_2d;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][point type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type (see http://accu.org/index.php/journals/427#ftn.d0e249 ) ]]
+
+]
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:linestring_3d linestring_3d]
+
+[indexterm1 linestring_3d]
+
+ typedef linestring< point_3d > linestring_3d;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][point type ]]
+
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
+
+[[A][optional container-allocator-type (see http://accu.org/index.php/journals/427#ftn.d0e249 ) ]]
+
+]
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:linestring_tag linestring_tag]
+
+
+OGC Linestring identifying tag.
+
+
+ struct linestring_tag
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:make make]
+
+[indexterm1 make]
+Make a geometry.
+
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry ``[link boost_geometry.reference.make.overload1 make]``(
+ T const & c1,
+ T const & c2);
+ `` [''''»''' [link boost_geometry.reference.make.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry ``[link boost_geometry.reference.make.overload2 make]``(
+ T const & c1,
+ T const & c2,
+ T const & c3);
+ `` [''''»''' [link boost_geometry.reference.make.overload2 more...]]``
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry ``[link boost_geometry.reference.make.overload3 make]``(
+ T const & c1,
+ T const & c2,
+ T const & c3,
+ T const & c4);
+ `` [''''»''' [link boost_geometry.reference.make.overload3 more...]]``
+
+ template<
+ typename Geometry ,
+ typename Range >
+ Geometry ``[link boost_geometry.reference.make.overload4 make]``(
+ Range const & range);
+ `` [''''»''' [link boost_geometry.reference.make.overload4 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/make.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 make (1 of 4 overloads)]
+
+
+Make a geometry.
+
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry make(
+ T const & c1,
+ T const & c2);
+
+
+the Generic Geometry Library uses concepts for all its geometries. Therefore it does not rely on constructors. The "make" functions are object generators creating geometries. There are overloads with two, three, four or six values, which are implemented depending on the geometry specified.
+[heading Remarks]
+
+It does not work with array-point types, like int[2]
-The make\_inverse function initialize a 2D or 3D box with large coordinates, the min corner is very large, the max corner is very small
[variablelist
-[[Geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[G][the geometry type ]]
+
+[[T][the coordinate type ]]
]
[heading Return Value]
-the box
+the geometry
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 make (2 of 4 overloads)]
+
+
+Make a geometry.
+
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry make(
+ T const & c1,
+ T const & c2,
+ T const & c3);
+
+
+
+[heading Return Value]
+
+a 3D point
+
+
+
+
+[endsect]
+
+
+
+[section:overload3 make (3 of 4 overloads)]
+
+
+
+ template<
+ typename Geometry ,
+ typename T >
+ Geometry make(
+ T const & c1,
+ T const & c2,
+ T const & c3,
+ T const & c4);
+
+
+
+[endsect]
+
+
+
+[section:overload4 make (4 of 4 overloads)]
+
+
+
+ template<
+ typename Geometry ,
+ typename Range >
+ Geometry make(
+ Range const & range);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:make_buffer make_buffer]
+
+[indexterm1 make_buffer]
+Calculate and return buffer (= new geometry) around specified distance of geometry.
+
+
+ template<
+ typename Output ,
+ typename Input ,
+ typename T >
+ Output make_buffer(
+ Input const & geometry,
+ T const & distance,
+ T const & chord_length = -1);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][input geometry ]]
+
+[[distance][the distance used in buffer ]]
+
+[[chord_length][length of the chord's in the generated arcs around points or bends ]]
+
+]
+
+
+[heading Return Value]
+
+the buffered geometry
+
+
+[heading Remarks]
+
+See also: buffer
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/buffer.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:make_centroid make_centroid]
+
+[indexterm1 make_centroid]
+Calculate and return centroid.
+
+
+ template<
+ typename Point ,
+ typename Geometry >
+ Point ``[link boost_geometry.reference.make_centroid.overload1 make_centroid]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.make_centroid.overload1 more...]]``
+
+ template<
+ typename Point ,
+ typename Geometry ,
+ typename Strategy >
+ Point ``[link boost_geometry.reference.make_centroid.overload2 make_centroid]``(
+ Geometry const & geometry,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.make_centroid.overload2 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/centroid.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 make_centroid (1 of 2 overloads)]
+
+
+Calculate and return centroid.
+
+
+ template<
+ typename Point ,
+ typename Geometry >
+ Point make_centroid(
+ Geometry const & geometry);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the geometry to calculate centroid from ]]
+
+]
+
+
+[heading Return Value]
+
+the centroid
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 make_centroid (2 of 2 overloads)]
+
+
+Calculate and return centroid, using a specified strategy.
+
+
+ template<
+ typename Point ,
+ typename Geometry ,
+ typename Strategy >
+ Point make_centroid(
+ Geometry const & geometry,
+ Strategy const & strategy);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the geometry to calculate centroid from ]]
+
+[[strategy][Calculation strategy for centroid ]]
+
+]
+
+
+[heading Return Value]
+
+the centroid
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:make_envelope make_envelope]
+
+[indexterm1 make_envelope]
+Calculate and return envelope of a geometry.
+
+
+ template<
+ typename Box ,
+ typename Geometry >
+ Box make_envelope(
+ Geometry const & geometry);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the geometry ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/envelope.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:make_inverse make_inverse]
+
+[indexterm1 make_inverse]
+Create a box with inverse infinite coordinates.
+
+
+ template<
+ typename Geometry >
+ Geometry make_inverse();
+
+
+The make\_inverse function initialize a 2D or 3D box with large coordinates, the min corner is very large, the max corner is very small
+
+[variablelist
+
+[[Geometry][the geometry type ]]
+
+]
+
+
+[heading Return Value]
+
+the box
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/make.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:make_zero make_zero]
+
+[indexterm1 make_zero]
+Create a geometry with "zero" coordinates.
+
+
+ template<
+ typename Geometry >
+ Geometry make_zero();
+
+
+The make\_zero function initializes a 2D or 3D point or box with coordinates of zero
+
+[variablelist
+
+[[Geometry][the geometry type ]]
+
+]
+
+
+[heading Return Value]
+
+the geometry
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/make.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:max_corner max_corner]
+
+[indexterm1 max_corner]
+Index of maximum corner of the 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 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 point by another.
+
+
+ template<
+ typename Point1 ,
+ typename Point2 >
+ void multiply_point(
+ Point1 & p1,
+ Point2 const & p2);
+
+
+The coordinates of the second point will be multiplied by those of the first point. The second point is not modified.
+[heading Parameters]
+
+
+[variablelist
+
+[[p1][first point ]]
+
+[[p2][second point ]]
+
+]
+
+
+[heading Remarks]
+
+This is *not* a dot, cross or wedge product. It is a mere field-by-field multiplication.
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:multiply_value multiply_value]
+
+[indexterm1 multiply_value]
+Multiplies each coordinate of a point by a value.
+
+
+ template<
+ typename Point >
+ void multiply_value(
+ Point & p,
+ typename detail::param< Point >::type value);
+
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[p][point ]]
+
+[[value][value to multiply by ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:num_geometries num_geometries]
+
+[indexterm1 num_geometries]
+Function to get the number of geometries of a composite geometry. For a single geometry it is always 0 (also for a polygon with holes).
+
+
+ template<
+ typename Geometry >
+ std::size_t num_geometries(
+ Geometry const & geometry);
+
+
+
+
+[variablelist
+
+[[Geometry][geometry type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the polygon or other geometry ]]
+
+]
+
+
+[heading Return Value]
+
+the number of interior rings of the geometry
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/num_geometries.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:num_interior_rings num_interior_rings]
+
+[indexterm1 num_interior_rings]
+Function to get the number of interior rings of a polygon.
+
+
+ template<
+ typename Geometry >
+ std::size_t num_interior_rings(
+ Geometry const & geometry);
+
+
+
+[heading Remarks]
+
+Defined by OGC as "numInteriorRing". To be consistent with "numPoints" letter "s" is appended
+
+Can be used for any geometry, returning 0 for geometries not having interior rings
+
+
+
+[variablelist
+
+[[Geometry][geometry type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the polygon or other geometry ]]
+
+]
+
+
+[heading Return Value]
+
+the number of interior rings of the geometry
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/interior_rings.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:num_points num_points]
+
+[indexterm1 num_points]
+get number of points
+
+
+ template<
+ typename Geometry >
+ std::size_t num_points(
+ Geometry const & geometry);
+
+
+
+
+[variablelist
+
+[[Geometry][geometry type ]]
+
+]
+
+
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the geometry to get number of points from ]]
+
+]
+
+
+[heading Return Value]
+
+number of points
+
+
+[heading Remarks]
+
+For linestrings/rings also boost::size or .size() could be used, however, for polygons this is less obvious. So this function is provided. Besides that it is described by OGC (numPoints)
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/num_points.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:order_selector order_selector]
+
+[indexterm1 order_selector]
+
+ enum order_selector
+
+[indexterm2 clockwise..order_selector]
+[indexterm2 counterclockwise..order_selector]
+[indexterm2 order_undetermined..order_selector]
+
+[heading Values]
+[variablelist
+
+ [
+ [clockwise]
+ []
+ ]
+
+ [
+ [counterclockwise]
+ []
+ ]
+
+ [
+ [order_undetermined]
+ []
+ ]
+
+]
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_order.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:overlaps overlaps]
+
+[indexterm1 overlaps]
+Determines overlap between two geometries.
+
+
+ template<
+ typename Geometry1 ,
+ typename Geometry2 >
+ bool overlaps(
+ Geometry1 const & geometry1,
+ Geometry2 const & geometry2);
+
+
+
+[heading Return Value]
+
+true if there is overlap
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/overlaps.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:parse parse]
+
+[indexterm1 parse]
+
+ template<
+ typename Geometry >
+ void ``[link boost_geometry.reference.parse.overload1 parse]``(
+ Geometry & geometry,
+ std::string const & c1,
+ std::string const & c2);
+ `` [''''»''' [link boost_geometry.reference.parse.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename S >
+ void ``[link boost_geometry.reference.parse.overload2 parse]``(
+ Geometry & geometry,
+ std::string const & c1,
+ std::string const & c2,
+ S const & strategy);
+ `` [''''»''' [link boost_geometry.reference.parse.overload2 more...]]``
+
+ template<
+ typename Geometry >
+ Geometry ``[link boost_geometry.reference.parse.overload3 parse]``(
+ std::string const & c1,
+ std::string const & c2);
+ `` [''''»''' [link boost_geometry.reference.parse.overload3 more...]]``
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/parse.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 parse (1 of 3 overloads)]
+
+
+parse two strings to a spherical/geographic point, using W/E/N/S
+
+
+ template<
+ typename Geometry >
+ void parse(
+ Geometry & geometry,
+ std::string const & c1,
+ std::string const & c2);
+
+
+
+[endsect]
+
+
+
+[section:overload2 parse (2 of 3 overloads)]
+
+
+parse two strings to a spherical/geographic point, using a specified strategy
+
+
+ template<
+ typename Geometry ,
+ typename S >
+ void parse(
+ Geometry & geometry,
+ std::string const & c1,
+ std::string const & c2,
+ S const & strategy);
+
+
+user can use N/E/S/O or N/O/Z/W or other formats
+
+
+[endsect]
+
+
+
+[section:overload3 parse (3 of 3 overloads)]
+
+
+
+ template<
+ typename Geometry >
+ Geometry parse(
+ std::string const & c1,
+ std::string const & c2);
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:perimeter perimeter]
+
+[indexterm1 perimeter]
+
+ template<
+ typename Geometry >
+ length_result< Geometry >::type ``[link boost_geometry.reference.perimeter.overload1 perimeter]``(
+ Geometry const & geometry);
+ `` [''''»''' [link boost_geometry.reference.perimeter.overload1 more...]]``
+
+ template<
+ typename Geometry ,
+ typename Strategy >
+ length_result< Geometry >::type ``[link boost_geometry.reference.perimeter.overload2 perimeter]``(
+ Geometry const & geometry,
+ Strategy const & strategy);
+ `` [''''»''' [link boost_geometry.reference.perimeter.overload2 more...]]``
+
+
+[heading Geometries:]
+
+
+* polygon
+
+* box
+
+* linear_ring
+
+* multi_polygon
+
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/algorithms/perimeter.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:overload1 perimeter (1 of 2 overloads)]
+
+
+Calculate perimeter of a geometry.
+
+
+ template<
+ typename Geometry >
+ length_result< Geometry >::type perimeter(
+ Geometry const & geometry);
+
+
+The function perimeter returns the perimeter of a geometry, using the default distance-calculation-strategy
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the geometry, be it a geometry::ring, vector, iterator pair, or any other boost compatible range ]]
+
+]
+
+
+[heading Return Value]
+
+the perimeter
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 perimeter (2 of 2 overloads)]
+
+
+Calculate perimeter of a geometry.
+
+
+ template<
+ typename Geometry ,
+ typename Strategy >
+ length_result< Geometry >::type perimeter(
+ Geometry const & geometry,
+ Strategy const & strategy);
+
+
+The function perimeter returns the perimeter of a geometry, using specified strategy
+[heading Parameters]
+
+
+[variablelist
+
+[[geometry][the geometry, be it a geometry::ring, vector, iterator pair, or any other boost compatible range ]]
+
+[[strategy][strategy to be used for distance calculations. ]]
+
+]
+
+
+[heading Return Value]
+
+the perimeter
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+[section:point point]
+
+
+Basic point class, having coordinates defined in a neutral way.
+
+
+ template<
+ typename T,
+ std::size_t ``[link boost_geometry.reference.D D]``,
+ typename ``[link boost_geometry.reference.C C]``>
+ class point
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point.coordinate_system [*coordinate_system]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+]
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point.get [*get]]]
+ [Compile time access to coordinate values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point.point [*point]]]
+ [Default constructor, no initialization at all.
+
+ Constructs with one, or optionally two or three values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point.set [*set]]]
+ []
+ ]
+
+]
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point.coordinate_count [*coordinate_count]]]
+ []
+ ]
+
+]
+
+
+
+[variablelist
+
+[[T][numeric type, for example double, float, int ]]
+
+[[D][coordinate dimension as number of coordinates, for example 2 ]]
+
+[[C][coordinate system, for example [link boost_geometry.reference.cs__cartesian `cs::cartesian`] ]]
+
+]
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:coordinate_count point::coordinate_count]
+
+[indexterm2 coordinate_count..point]
+
+ static const std::size_t coordinate_count = D;
+
+
+
+[endsect]
+
+
+
+[section:coordinate_system point::coordinate_system]
+
+[indexterm2 coordinate_system..point]
+
+ typedef C coordinate_system;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:coordinate_type point::coordinate_type]
+
+[indexterm2 coordinate_type..point]
+
+ typedef T coordinate_type;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/point.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:get point::get]
+
+[indexterm2 get..point]
+Compile time access to coordinate values.
+
+
+ template<
+ std::size_t ``[link boost_geometry.reference.K K]``>
+ T const & get() const;
+
+
+
+[endsect]
+
+
+[section:point point::point]
+
+[indexterm2 point..point]
+Default constructor, no initialization at all.
+
+
+ ``[link boost_geometry.reference.point.point.overload1 point]``();
+ `` [''''»''' [link boost_geometry.reference.point.point.overload1 more...]]``
+
+
+Constructs with one, or optionally two or three values.
+
+
+ ``[link boost_geometry.reference.point.point.overload2 point]``(
+ T const & v0,
+ T const & v1 = 0,
+ T const & v2 = 0);
+ `` [''''»''' [link boost_geometry.reference.point.point.overload2 more...]]``
+
+
+[section:overload1 point::point (1 of 2 overloads)]
+
+
+Default constructor, no initialization at all.
+
+
+ point();
+
+
+
+[endsect]
+
+
+
+[section:overload2 point::point (2 of 2 overloads)]
+
+
+Constructs with one, or optionally two or three values.
+
+
+ point(
+ T const & v0,
+ T const & v1 = 0,
+ T const & v2 = 0);
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[section:set point::set]
+
+[indexterm2 set..point]
+
+ template<
+ std::size_t ``[link boost_geometry.reference.K K]``>
+ void set(
+ T value);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+
+[section:point_2d point_2d]
+
+[indexterm1 point_2d]
+
+ typedef point_xy< double, cs::cartesian > point_2d;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point_xy.coordinate_system [*coordinate_system]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point_xy.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+]
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point_xy.get [*get]]]
+ [Compile time access to coordinate values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.point_xy [*point_xy]]]
+ [Default constructor, does not initialize anything.
+
+ Constructor with x/y values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.set [*set]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.x [*x]]]
+ [Get x-value.
+
+ Set x-value. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.y [*y]]]
+ [Get y-value.
+
+ Set y-value. ]
+ ]
+
+]
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point_xy.coordinate_count [*coordinate_count]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[T][numeric type, arguments can be, for example, double, float, int ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:point_3d point_3d]
+
+[indexterm1 point_3d]
+
+ typedef point< double, 3, cs::cartesian > point_3d;
+
+
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point.coordinate_system [*coordinate_system]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+
+]
+
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point.get [*get]]]
+ [Compile time access to coordinate values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point.point [*point]]]
+ [Default constructor, no initialization at all.
+
+ Constructs with one, or optionally two or three values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point.set [*set]]]
+ []
+ ]
+
+]
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point.coordinate_count [*coordinate_count]]]
+ []
+ ]
+
+]
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[T][numeric type, for example double, float, int ]]
+
+[[D][coordinate dimension as number of coordinates, for example 2 ]]
+
+[[C][coordinate system, for example [link boost_geometry.reference.cs__cartesian `cs::cartesian`] ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+[section:point_order point_order]
+
+
+Meta-function which defines point type of any geometry.
+
+
+ template<
+ typename Geometry >
+ struct point_order
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point_order.ncg [*ncg]]]
+ []
+
+ ]
+
+]
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.point_order.value [*value]]]
+ []
+ ]
+
+]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_order.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:ncg point_order::ncg]
+
+[indexterm2 ncg..point_order]
+
+ typedef boost::remove_const< Geometry >::type ncg;
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_order.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
+
+[section:value point_order::value]
+
+[indexterm2 value..point_order]
+
+ static const order_selector value = core_dispatch::point_order
+ <
+ typename tag<Geometry>::type,
+ ncg
+ >::value;
+
+
+
+[endsect]
+
+
+
+[endsect]
+
+[section:point_tag point_tag]
+
+
+OGC Point identifying tag.
+
+
+ struct point_tag
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/tags.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+[section:point_type point_type]
+
+
+Meta-function which defines point type of any geometry.
+
+
+ template<
+ typename Geometry >
+ struct point_type
+
+[heading Public Types]
+[table
+ [[Name][Description]]
+
+ [
+
+ [[link boost_geometry.reference.point_type.ncg [*ncg]]]
+ []
+
+ ]
+
+ [
+
+ [[link boost_geometry.reference.point_type.type [*type]]]
+ []
+
+ ]
+
+]
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/core/point_type.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[section:ncg point_type::ncg]
+
+[indexterm2 ncg..point_type]
+
+ typedef boost::remove_const< Geometry >::type ncg;
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/make.hpp]
+[*Header: ][^boost/geometry/core/point_type.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -4588,35 +6645,43 @@
-[section:make_zero make_zero]
+[section:type point_type::type]
-[indexterm1 make_zero]
-Create a [link boost_geometry.reference.boost__geometry `boost::geometry`] with "zero" coordinates.
+[indexterm2 type..point_type]
+ typedef core_dispatch::point_type< typename tag< Geometry >::type, ncg >::type type;
- template<
- typename Geometry >
- Geometry make_zero();
-The make\_zero function initializes a 2D or 3D point or box with coordinates of zero
+[heading Public Types]
+[table
+ [[Name][Description]]
-[variablelist
+ [
+
+ [[link boost_geometry.reference.tag.type [*type]]]
+ []
-[[Geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+ ]
]
+[heading Typedef Description]
+
+All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
+
+[variablelist
+
+[[Geometry][geometry ]]
+
+]
-[heading Return Value]
-
-the [link boost_geometry.reference.boost__geometry `boost::geometry`]
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/make.hpp]
+[*Header: ][^boost/geometry/core/point_type.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -4625,120 +6690,155 @@
-[section:max_corner max_corner]
+[endsect]
-[indexterm1 max_corner]
-Index of maximum corner of the box.
+[section:point_xy point_xy]
- const int max_corner = 1;
+2D point in Cartesian coordinate system
-[heading Requirements]
+ template<
+ typename T ,
+ typename C = cs::cartesian>
+ class point_xy : public point< T, 2, C >
-[*Header: ][^boost/geometry/core/access.hpp]
+[heading Public Types]
+[table
+ [[Name][Description]]
-[*Convenience header: ][^boost/geometry.hpp]
+ [
+ [[link boost_geometry.reference.point_xy.coordinate_system [*coordinate_system]]]
+ []
+
+ ]
-[endsect]
+ [
+ [[link boost_geometry.reference.point_xy.coordinate_type [*coordinate_type]]]
+ []
+
+ ]
+]
-[section:min_corner min_corner]
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
-[indexterm1 min_corner]
-Index of minimum corner of the box.
+ [
+ [[link boost_geometry.reference.point_xy.get [*get]]]
+ [Compile time access to coordinate values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.point_xy [*point_xy]]]
+ [Default constructor, does not initialize anything.
+ Constructor with x/y values. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.set [*set]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.x [*x]]]
+ [Get x-value.
- const int min_corner = 0;
+ Set x-value. ]
+ ]
+
+ [
+ [[link boost_geometry.reference.point_xy.y [*y]]]
+ [Get y-value.
+ Set y-value. ]
+ ]
+
+]
-[heading Requirements]
+[heading Public Data Members]
+[table
+ [[Name][Description]]
-[*Header: ][^boost/geometry/core/access.hpp]
+ [
+ [[link boost_geometry.reference.point_xy.coordinate_count [*coordinate_count]]]
+ []
+ ]
-[*Convenience header: ][^boost/geometry.hpp]
+]
-[endsect]
+[variablelist
+
+[[T][numeric type, arguments can be, for example, double, float, int ]]
+]
-[section:multiply_point multiply_point]
-[indexterm1 multiply_point]
-Multiplies a point by another.
+[heading Requirements]
- template<
- typename Point1 ,
- typename Point2 >
- void multiply_point(
- Point1 & p1,
- Point2 const & p2);
+[*Header: ][^boost/geometry/geometries/point_xy.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-The coordinates of the second point will be multiplied by those of the first point. The second point is not modified.
-[heading Parameters]
-
-[variablelist
-
-[[p1][first point ]]
+[section:coordinate_count point_xy::coordinate_count]
-[[p2][second point ]]
-]
+['Inherited from point.]
+[indexterm2 coordinate_count..point_xy]
-[heading Remarks]
-
-This is *not* a dot, cross or wedge product. It is a mere field-by-field multiplication.
+ static const std::size_t coordinate_count;
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[section:coordinate_system point_xy::coordinate_system]
-[endsect]
+['Inherited from point.]
+[indexterm2 coordinate_system..point_xy]
-[section:multiply_value multiply_value]
+ typedef C coordinate_system;
-[indexterm1 multiply_value]
-Multiplies each coordinate of a point by a value.
- template<
- typename Point >
- void multiply_value(
- Point & p,
- typename detail::param< Point >::type value);
+[heading Requirements]
+[*Header: ][^boost/geometry/geometries/point_xy.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[heading Parameters]
-
-[variablelist
-
-[[p][point ]]
+[endsect]
-[[value][value to multiply by ]]
-]
+
+[section:coordinate_type point_xy::coordinate_type]
+
+
+['Inherited from point.]
+
+[indexterm2 coordinate_type..point_xy]
+
+ typedef T coordinate_type;
[heading Requirements]
-[*Header: ][^boost/geometry/arithmetic/arithmetic.hpp]
+[*Header: ][^boost/geometry/geometries/point_xy.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -4747,398 +6847,346 @@
-[section:num_geometries num_geometries]
-
-[indexterm1 num_geometries]
-Function to get the number of geometries of a composite [link boost_geometry.reference.boost__geometry `boost::geometry`]. For a single [link boost_geometry.reference.boost__geometry `boost::geometry`] it is always 0 (also for a polygon with holes).
+[section:get point_xy::get]
- template<
- typename Geometry >
- std::size_t num_geometries(
- Geometry const & geometry);
+['Inherited from point.]
+[indexterm2 get..point_xy]
+Compile time access to coordinate values.
+ T const & get() const;
-[variablelist
-
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-]
+[endsect]
-[heading Parameters]
-
-[variablelist
-
-[[geometry][the polygon or other [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[section:point_xy point_xy::point_xy]
-]
+[indexterm2 point_xy..point_xy]
+Default constructor, does not initialize anything.
-[heading Return Value]
-
-the number of interior rings of the [link boost_geometry.reference.boost__geometry `boost::geometry`]
+ ``[link boost_geometry.reference.point_xy.point_xy.overload1 point_xy]``();
+ `` [''''»''' [link boost_geometry.reference.point_xy.point_xy.overload1 more...]]``
+Constructor with x/y values.
-[heading Requirements]
-[*Header: ][^boost/geometry/core/num_geometries.hpp]
+ ``[link boost_geometry.reference.point_xy.point_xy.overload2 point_xy]``(
+ T const & x,
+ T const & y);
+ `` [''''»''' [link boost_geometry.reference.point_xy.point_xy.overload2 more...]]``
-[*Convenience header: ][^boost/geometry.hpp]
+[section:overload1 point_xy::point_xy (1 of 2 overloads)]
-[endsect]
+Default constructor, does not initialize anything.
-[section:num_interior_rings num_interior_rings]
+ point_xy();
-[indexterm1 num_interior_rings]
-Function to get the number of interior rings of a polygon.
- template<
- typename Geometry >
- std::size_t num_interior_rings(
- Geometry const & geometry);
+[endsect]
-[heading Remarks]
-
-Defined by OGC as "numInteriorRing". To be consistent with "numPoints" letter "s" is appended
+[section:overload2 point_xy::point_xy (2 of 2 overloads)]
-Can be used for any [link boost_geometry.reference.boost__geometry `boost::geometry`], returning 0 for geometries not having interior rings
+Constructor with x/y values.
-[variablelist
-
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+ point_xy(
+ T const & x,
+ T const & y);
-]
-[heading Parameters]
-
+[endsect]
-[variablelist
-
-[[geometry][the polygon or other [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
-]
+[endsect]
-[heading Return Value]
-
-the number of interior rings of the [link boost_geometry.reference.boost__geometry `boost::geometry`]
+[section:set point_xy::set]
+['Inherited from point.]
-[heading Requirements]
+[indexterm2 set..point_xy]
-[*Header: ][^boost/geometry/core/interior_rings.hpp]
+ void set(
+ T value);
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[section:x point_xy::x]
-[section:num_points num_points]
+[indexterm2 x..point_xy]
+Get x-value.
-[indexterm1 num_points]
-get number of points
+ T const & ``[link boost_geometry.reference.point_xy.x.overload1 x]``() const;
+ `` [''''»''' [link boost_geometry.reference.point_xy.x.overload1 more...]]``
- template<
- typename Geometry >
- std::size_t num_points(
- Geometry const & geometry);
+Set x-value.
+ void ``[link boost_geometry.reference.point_xy.x.overload2 x]``(
+ T const & v);
+ `` [''''»''' [link boost_geometry.reference.point_xy.x.overload2 more...]]``
-[variablelist
-
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
-]
+[section:overload1 point_xy::x (1 of 2 overloads)]
-[heading Parameters]
-
+Get x-value.
-[variablelist
-
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to get number of points from ]]
-]
+ T const & x() const;
-[heading Return Value]
-
-number of points
+[endsect]
-[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)
+[section:overload2 point_xy::x (2 of 2 overloads)]
-[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/num_points.hpp]
+Set x-value.
+
+
+ void x(
+ T const & v);
-[*Convenience header: ][^boost/geometry.hpp]
[endsect]
+[endsect]
-[section:order_selector order_selector]
+[section:y point_xy::y]
-[indexterm1 order_selector]
+[indexterm2 y..point_xy]
+Get y-value.
- enum order_selector
-[indexterm2 clockwise..order_selector]
-[indexterm2 counterclockwise..order_selector]
-[indexterm2 order_undetermined..order_selector]
+ T const & ``[link boost_geometry.reference.point_xy.y.overload1 y]``() const;
+ `` [''''»''' [link boost_geometry.reference.point_xy.y.overload1 more...]]``
-[heading Values]
-[variablelist
- [
- [clockwise]
- []
- ]
+Set y-value.
- [
- [counterclockwise]
- []
- ]
- [
- [order_undetermined]
- []
- ]
+ void ``[link boost_geometry.reference.point_xy.y.overload2 y]``(
+ T const & v);
+ `` [''''»''' [link boost_geometry.reference.point_xy.y.overload2 more...]]``
-]
+[section:overload1 point_xy::y (1 of 2 overloads)]
-[heading Requirements]
-[*Header: ][^boost/geometry/core/point_order.hpp]
+Get y-value.
-[*Convenience header: ][^boost/geometry.hpp]
+ T const & y() const;
-[endsect]
+[endsect]
-[section:overlaps overlaps]
-[indexterm1 overlaps]
-Determines overlap between two geometries.
+[section:overload2 point_xy::y (2 of 2 overloads)]
- template<
- typename Geometry1 ,
- typename Geometry2 >
- bool overlaps(
- Geometry1 const & geometry1,
- Geometry2 const & geometry2);
+Set y-value.
-[heading Return Value]
-
-true if there is overlap
+ void y(
+ T const & v);
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/algorithms/overlaps.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
[endsect]
+[section:polygon polygon]
-[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...]]``
+The polygon contains an outer ring and zero or more inner rings.
- 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...]]``
+ 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 Requirements]
+[heading Public Types]
+[table
+ [[Name][Description]]
-[*Header: ][^boost/geometry/algorithms/parse.hpp]
+ [
-[*Convenience header: ][^boost/geometry.hpp]
+ [[link boost_geometry.reference.polygon.inner_container_type [*inner_container_type]]]
+ []
+
+ ]
+ [
-[section:overload1 parse (1 of 3 overloads)]
+ [[link boost_geometry.reference.polygon.point_type [*point_type]]]
+ []
+
+ ]
+ [
-parse two strings to a spherical/geographic point, using W/E/N/S
+ [[link boost_geometry.reference.polygon.ring_type [*ring_type]]]
+ []
+
+ ]
+]
- template<
- typename Geometry >
- void parse(
- Geometry & geometry,
- std::string const & c1,
- std::string const & c2);
+[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]
+[variablelist
+
+[[P][point type ]]
+[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
-[section:overload2 parse (2 of 3 overloads)]
+[[ClockWise][optional parameter, true for clockwise direction, false for CounterClockWise direction ]]
+[[PointAlloc][container-allocator-type ]]
-parse two strings to a spherical/geographic point, using a specified [link boost_geometry.reference.strategy `strategy`]
+[[RingAlloc][container-allocator-type ]]
+]
- template<
- typename Geometry ,
- typename S >
- void parse(
- Geometry & geometry,
- std::string const & c1,
- std::string const & c2,
- S const & strategy);
+[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.
-user can use N/E/S/O or N/O/Z/W or other formats
-[endsect]
+[heading Requirements]
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
+[*Convenience header: ][^boost/geometry.hpp]
-[section:overload3 parse (3 of 3 overloads)]
+[section:clear polygon::clear]
+[indexterm2 clear..polygon]
+Utility method, clears outer and inner rings.
- template<
- typename Geometry >
- Geometry parse(
- std::string const & c1,
- std::string const & c2);
+
+ void clear();
[endsect]
-[endsect]
-[section:perimeter perimeter]
+[section:inner_container_type polygon::inner_container_type]
-[indexterm1 perimeter]
-
- template<
- typename Geometry >
- length_result< Geometry >::type ``[link boost_geometry.reference.perimeter.overload1 perimeter]``(
- Geometry const & geometry);
- `` [''''»''' [link boost_geometry.reference.perimeter.overload1 more...]]``
+[indexterm2 inner_container_type..polygon]
- template<
- typename Geometry ,
- typename Strategy >
- length_result< Geometry >::type ``[link boost_geometry.reference.perimeter.overload2 perimeter]``(
- Geometry const & geometry,
- Strategy const & strategy);
- `` [''''»''' [link boost_geometry.reference.perimeter.overload2 more...]]``
+ typedef RingList< ring_type, RingAlloc< ring_type > > inner_container_type;
-[heading Geometries:]
-
+[heading Typedef Description]
+
-* polygon
-* box
+[variablelist
+
+[[P][point type ]]
-* linear_ring
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
-* multi_polygon
+[[A][optional container-allocator-type ]]
+]
[heading Requirements]
-[*Header: ][^boost/geometry/algorithms/perimeter.hpp]
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
[*Convenience header: ][^boost/geometry.hpp]
-[section:overload1 perimeter (1 of 2 overloads)]
-
+[endsect]
-Calculate perimeter of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[section:inners polygon::inners]
- template<
- typename Geometry >
- length_result< Geometry >::type perimeter(
- Geometry const & geometry);
+[indexterm2 inners..polygon]
+ inner_container_type const & ``[link boost_geometry.reference.polygon.inners.overload1 inners]``() const;
+ `` [''''»''' [link boost_geometry.reference.polygon.inners.overload1 more...]]``
-The function perimeter returns the perimeter of a [link boost_geometry.reference.boost__geometry `boost::geometry`], using the default distance-calculation-strategy
-[heading Parameters]
-
+ inner_container_type & ``[link boost_geometry.reference.polygon.inners.overload2 inners]``();
+ `` [''''»''' [link boost_geometry.reference.polygon.inners.overload2 more...]]``
-[variablelist
-
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`], be it a geometry::ring, vector, iterator pair, or any other `boost` compatible range ]]
-]
+[section:overload1 polygon::inners (1 of 2 overloads)]
-[heading Return Value]
-
-the perimeter
+ inner_container_type const & inners() const;
@@ -5146,97 +7194,67 @@
-[section:overload2 perimeter (2 of 2 overloads)]
-
+[section:overload2 polygon::inners (2 of 2 overloads)]
-Calculate perimeter of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
- template<
- typename Geometry ,
- typename Strategy >
- length_result< Geometry >::type perimeter(
- Geometry const & geometry,
- Strategy const & strategy);
+ inner_container_type & inners();
-The function perimeter returns the perimeter of a [link boost_geometry.reference.boost__geometry `boost::geometry`], using specified [link boost_geometry.reference.strategy `strategy`]
-[heading Parameters]
-
-[variablelist
-
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`], be it a geometry::ring, vector, iterator pair, or any other `boost` compatible range ]]
+[endsect]
-[[strategy][[link boost_geometry.reference.strategy `strategy`] to be used for distance calculations. ]]
-]
+[endsect]
+[section:outer polygon::outer]
-[heading Return Value]
-
-the perimeter
+[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...]]``
-[endsect]
+[section:overload1 polygon::outer (1 of 2 overloads)]
-[endsect]
-[section:point_order point_order]
+ ring_type const & outer() const;
-Meta-function which defines point type of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[endsect]
- template<
- typename Geometry >
- struct point_order
-[heading Public Types]
-[table
- [[Name][Description]]
- [
+[section:overload2 polygon::outer (2 of 2 overloads)]
- [[link boost_geometry.reference.point_order.ncg [*ncg]]]
- []
-
- ]
-]
-[heading Public Data Members]
-[table
- [[Name][Description]]
+ ring_type & outer();
- [
- [[link boost_geometry.reference.point_order.value [*value]]]
- []
- ]
-]
-[heading Requirements]
+[endsect]
-[*Header: ][^boost/geometry/core/point_order.hpp]
-[*Convenience header: ][^boost/geometry.hpp]
+[endsect]
-[section:ncg point_order::ncg]
+[section:point_type polygon::point_type]
-[indexterm2 ncg..point_order]
+[indexterm2 point_type..polygon]
- typedef boost::remove_const< Geometry >::type ncg;
+ typedef Point point_type;
[heading Requirements]
-[*Header: ][^boost/geometry/core/point_order.hpp]
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -5245,49 +7263,51 @@
-[section:value point_order::value]
+[section:ring_type polygon::ring_type]
-[indexterm2 value..point_order]
+[indexterm2 ring_type..polygon]
- static const order_selector value = core_dispatch::point_order
- <
- typename tag<Geometry>::type,
- ncg
- >::value;
+ typedef linear_ring< Point, PointList, ClockWise, PointAlloc > ring_type;
+[heading Typedef Description]
+
-[endsect]
+[variablelist
+
+[[P][point type ]]
+[[V][optional container type, for example std::vector, std::list, std::deque ]]
-[endsect]
+[[A][optional container-allocator-type ]]
-[section:point_tag point_tag]
+]
-OGC Point identifying [link boost_geometry.reference.tag `tag`].
- struct point_tag
[heading Requirements]
-[*Header: ][^boost/geometry/core/tags.hpp]
+[*Header: ][^boost/geometry/geometries/polygon.hpp]
[*Convenience header: ][^boost/geometry.hpp]
[endsect]
-[section:point_type point_type]
-Meta-function which defines point type of any [link boost_geometry.reference.boost__geometry `boost::geometry`].
+[endsect]
+
+
+[section:polygon_2d polygon_2d]
+
+[indexterm1 polygon_2d]
+
+ typedef polygon< point_2d > polygon_2d;
- template<
- typename Geometry >
- struct point_type
[heading Public Types]
[table
@@ -5295,38 +7315,79 @@
[
- [[link boost_geometry.reference.point_type.ncg [*ncg]]]
+ [[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]
+
- [
- [[link boost_geometry.reference.point_type.type [*type]]]
- []
+[variablelist
- ]
+[[P][point type ]]
-]
+[[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/core/point_type.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:ncg point_type::ncg]
+]
-[indexterm2 ncg..point_type]
- typedef boost::remove_const< Geometry >::type ncg;
+[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/core/point_type.hpp]
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -5335,11 +7396,11 @@
-[section:type point_type::type]
+[section:polygon_3d polygon_3d]
-[indexterm2 type..point_type]
+[indexterm1 polygon_3d]
- typedef core_dispatch::point_type< typename tag< Geometry >::type, ncg >::type type;
+ typedef polygon< point_3d > polygon_3d;
@@ -5349,29 +7410,79 @@
[
- [[link boost_geometry.reference.tag.type [*type]]]
+ [[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]
-All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type (point, linestring, 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`] ]]
+[[P][point type ]]
+
+[[PointList][optional container type for points, for example std::vector, std::list, std::deque ]]
+
+[[RingList][optional container type for inner rings, for example std::vector, std::list, std::deque ]]
+
+[[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/core/point_type.hpp]
+[*Header: ][^boost/geometry/geometries/cartesian3d.hpp]
[*Convenience header: ][^boost/geometry.hpp]
@@ -5379,13 +7490,10 @@
[endsect]
-
-[endsect]
-
[section:polygon_tag polygon_tag]
-OGC Polygon identifying [link boost_geometry.reference.tag `tag`].
+OGC Polygon identifying tag.
struct polygon_tag
@@ -5446,7 +7554,7 @@
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry][geometry type ]]
]
@@ -5456,7 +7564,7 @@
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make reverse ]]
+[[geometry][the geometry to make reverse ]]
]
@@ -5489,10 +7597,80 @@
[endsect]
+
+[section:ring_2d ring_2d]
+
+[indexterm1 ring_2d]
+
+ typedef linear_ring< point_2d > ring_2d;
+
+
+[heading Typedef Description]
+
+
+
+[variablelist
+
+[[P][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][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`].
+Convenience (linear) ring identifying tag.
struct ring_tag
@@ -5508,7 +7686,7 @@
[section:ring_type ring_type]
-Meta-function which defines ring type of (multi)polygon [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Meta-function which defines ring type of (multi)polygon geometry.
template<
@@ -5565,11 +7743,11 @@
[heading Typedef Description]
-All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type (point, linestring, 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.
+All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry][geometry ]]
]
@@ -5592,7 +7770,7 @@
[section:section section]
-Structure containing [link boost_geometry.reference.section `section`] information.
+Structure containing section information.
template<
@@ -5685,7 +7863,7 @@
]
-Section information consists of a bounding 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`]
+Section information consists of a bounding box, direction information (if it is increasing or decreasing, per dimension), index information (begin-end, ring, multi) and the number of segments in this section
@@ -5693,7 +7871,7 @@
[[Box][box-type ]]
-[[DimensionCount][number of dimensions for this [link boost_geometry.reference.section `section`] ]]
+[[DimensionCount][number of dimensions for this section ]]
]
@@ -5875,7 +8053,7 @@
[section:sectionalize sectionalize]
[indexterm1 sectionalize]
-Split a [link boost_geometry.reference.boost__geometry `boost::geometry`] into monotonic [link boost_geometry.reference.sections `sections`].
+Split a geometry into monotonic sections.
template<
@@ -5890,9 +8068,9 @@
[variablelist
-[[Geometry][type of [link boost_geometry.reference.boost__geometry `boost::geometry`] to check ]]
+[[Geometry][type of geometry to check ]]
-[[Sections][type of [link boost_geometry.reference.sections `sections`] to create ]]
+[[Sections][type of sections to create ]]
]
@@ -5902,9 +8080,9 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to create [link boost_geometry.reference.sections `sections`] from ]]
+[[geometry][geometry to create sections from ]]
-[[sections][structure with [link boost_geometry.reference.sections `sections`] ]]
+[[sections][structure with sections ]]
]
@@ -5923,7 +8101,7 @@
[section:sections sections]
-Structure containing a collection of [link boost_geometry.reference.sections `sections`].
+Structure containing a collection of sections.
template<
@@ -6004,6 +8182,179 @@
[endsect]
+[section:segment segment]
+
+
+Class segment: small class containing two (templatized) point references.
+
+
+ template<
+ typename ConstOrNonConstPoint >
+ class segment
+[heading Public Member Functions]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment.segment [*segment]]]
+ []
+ ]
+
+]
+
+[heading Public Data Members]
+[table
+ [[Name][Description]]
+
+ [
+ [[link boost_geometry.reference.segment.first [*first]]]
+ []
+ ]
+
+ [
+ [[link boost_geometry.reference.segment.second [*second]]]
+ []
+ ]
+
+]
+
+From Wikipedia: In geometry, a line segment is a part of a line that is bounded by two distinct end points, and contains every point on the line between its end points.
+[heading Remarks]
+
+The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
+
+Like std::pair, points are public available.
+
+type is const or non const, so geometry::segment<P> or geometry::segment<const P>
+
+We cannot derive from std::pair<P&, P&> because of reference assignments.
+
+
+
+[variablelist
+
+[[ConstOrNonConstPoint][point type of the segment, maybe a point or a const 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 geometry, a line segment is a part of a line that is bounded by two distinct end points, and contains every point on the line between its end points.
+[heading Remarks]
+
+The structure is like std::pair, and can often be used interchangeable. Difference is that it refers to points, does not have points.
+
+Like std::pair, points are public available.
+
+type is const or non const, so geometry::segment<P> or geometry::segment<const P>
+
+We cannot derive from std::pair<P&, P&> because of reference assignments.
+
+
+
+[variablelist
+
+[[ConstOrNonConstPoint][point type of the segment, maybe a point or a const point ]]
+
+]
+
+
+
+
+[heading Requirements]
+
+[*Header: ][^boost/geometry/geometries/cartesian2d.hpp]
+
+[*Convenience header: ][^boost/geometry.hpp]
+
+
+[endsect]
+
+
[section:segment_identifier segment_identifier]
@@ -6186,7 +8537,7 @@
[section:segment_tag segment_tag]
-Convenience segment (2-points) identifying [link boost_geometry.reference.tag `tag`].
+Convenience segment (2-points) identifying tag.
struct segment_tag
@@ -6247,9 +8598,9 @@
[variablelist
-[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
+[[Dimension][dimension ]]
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry][geometry ]]
]
@@ -6259,7 +8610,7 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to assign coordinate to ]]
+[[geometry][geometry to assign coordinate to ]]
[[value][coordinate value to assign ]]
@@ -6294,9 +8645,9 @@
[[Index][for Point: do not specifyfor Box: min\_corner or max\_cornerfor Segment: 0 / 1
]]
-[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
+[[Dimension][dimension ]]
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry][geometry ]]
]
@@ -6306,7 +8657,7 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to assign coordinate to ]]
+[[geometry][geometry to assign coordinate to ]]
[[value][coordinate value to assign ]]
@@ -6324,7 +8675,7 @@
[section:set_from_radian set_from_radian]
[indexterm1 set_from_radian]
-set coordinate value (in [link boost_geometry.reference.radian `radian`]) to a point
+set coordinate value (in radian) to a point
template<
@@ -6341,9 +8692,9 @@
[variablelist
-[[Dimension][[link boost_geometry.reference.dimension `dimension`] ]]
+[[Dimension][dimension ]]
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry][geometry ]]
]
@@ -6353,7 +8704,7 @@
[variablelist
-[[geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] to assign coordinate to ]]
+[[geometry][geometry to assign coordinate to ]]
[[radians][coordinate value to assign ]]
@@ -6454,7 +8805,7 @@
[section:overload1 simplify (1 of 2 overloads)]
-Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`] using a specified [link boost_geometry.reference.strategy `strategy`].
+Simplify a geometry using a specified strategy.
template<
@@ -6473,13 +8824,13 @@
[variablelist
-[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]]
+[[geometry][input geometry, to be simplified ]]
-[[out][output [link boost_geometry.reference.boost__geometry `boost::geometry`], simplified version of the input [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[out][output geometry, simplified version of the input geometry ]]
[[max_distance][distance (in units of input coordinates) of a vertex to other segments to be removed ]]
-[[strategy][simplify [link boost_geometry.reference.strategy `strategy`] to be used for simplification, might include point-distance [link boost_geometry.reference.strategy `strategy`] ]]
+[[strategy][simplify strategy to be used for simplification, might include point-distance strategy ]]
]
@@ -6493,7 +8844,7 @@
[section:overload2 simplify (2 of 2 overloads)]
-Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Simplify a geometry.
template<
@@ -6507,7 +8858,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),
+This version of simplify simplifies a geometry using the default strategy (Douglas Peucker),
[heading Parameters]
@@ -6515,9 +8866,9 @@
[variablelist
-[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]]
+[[geometry][input geometry, to be simplified ]]
-[[out][output [link boost_geometry.reference.boost__geometry `boost::geometry`], simplified version of the input [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[out][output geometry, simplified version of the input geometry ]]
[[max_distance][distance (in units of input coordinates) of a vertex to other segments to be removed ]]
@@ -6543,7 +8894,7 @@
[section:simplify_inserter simplify_inserter]
[indexterm1 simplify_inserter]
-Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`], using an output iterator and a specified [link boost_geometry.reference.strategy `strategy`].
+Simplify a geometry, using an output iterator and a specified strategy.
template<
@@ -6576,7 +8927,7 @@
[section:overload1 simplify_inserter (1 of 2 overloads)]
-Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`], using an output iterator and a specified [link boost_geometry.reference.strategy `strategy`].
+Simplify a geometry, using an output iterator and a specified strategy.
template<
@@ -6596,20 +8947,20 @@
[variablelist
-[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]]
+[[geometry][input geometry, to be simplified ]]
[[out][output iterator, outputs all simplified points ]]
[[max_distance][distance (in units of input coordinates) of a vertex to other segments to be removed ]]
-[[strategy][simplify [link boost_geometry.reference.strategy `strategy`] to be used for simplification, might include point-distance [link boost_geometry.reference.strategy `strategy`] ]]
+[[strategy][simplify strategy to be used for simplification, might include point-distance strategy ]]
]
[heading Example:]
-simplify\_inserter with [link boost_geometry.reference.strategy `strategy`] is used as following:
+simplify\_inserter with strategy is used as following:
@@ -6625,7 +8976,7 @@
[section:overload2 simplify_inserter (2 of 2 overloads)]
-Simplify a [link boost_geometry.reference.boost__geometry `boost::geometry`], using an output iterator.
+Simplify a geometry, using an output iterator.
template<
@@ -6643,7 +8994,7 @@
[variablelist
-[[geometry][input [link boost_geometry.reference.boost__geometry `boost::geometry`], to be simplified ]]
+[[geometry][input geometry, to be simplified ]]
[[out][output iterator, outputs all simplified points ]]
@@ -6716,7 +9067,7 @@
The algorithm is currently only implemented for 2D Cartesian points
-Though it is implemented in namespace [link boost_geometry.reference.strategy `strategy`], and theoretically another [link boost_geometry.reference.strategy `strategy`] could be used, it is not (yet) updated to the general [link boost_geometry.reference.strategy `strategy`] concepts, and not (yet) splitted into a file in folder strategies
+Though it is implemented in namespace strategy, and theoretically another strategy could be used, it is not (yet) updated to the general strategy concepts, and not (yet) splitted into a file in folder strategies
Barend Gehrels, and the following recourses
@@ -6866,7 +9217,7 @@
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry][geometry type ]]
]
@@ -6876,7 +9227,7 @@
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make symmetric difference ]]
+[[geometry][the geometry to make symmetric difference ]]
]
@@ -6895,7 +9246,7 @@
[section:tag tag]
-Meta-function to get the [link boost_geometry.reference.tag `tag`] of any [link boost_geometry.reference.boost__geometry `boost::geometry`] type.
+Meta-function to get the tag of any geometry type.
template<
@@ -6915,11 +9266,11 @@
]
-All geometries tell their [link boost_geometry.reference.boost__geometry `boost::geometry`] type (point, linestring, 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.
+All geometries tell their geometry type (point, linestring, polygon, etc) by implementing a tag traits class. This meta-function uses that traits class to retrieve the tag. If the input type is not a geometry at all, a [link boost_geometry.reference.geometry_not_recognized_tag `geometry_not_recognized_tag`] will be returned.
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry][geometry ]]
]
@@ -6955,7 +9306,7 @@
[heading Typedef Description]
-All geometries should implement a `traits::tag<G>::type` metafunction to indicate their own [link boost_geometry.reference.boost__geometry `boost::geometry`] type.
+All geometries should implement a `traits::tag<G>::type` metafunction to indicate their own geometry type.
[heading Geometries:]
@@ -6977,7 +9328,7 @@
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry][geometry ]]
]
@@ -7000,13 +9351,13 @@
[section:topological_dimension topological_dimension]
-Meta-function returning the topological [link boost_geometry.reference.dimension `dimension`] of a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Meta-function returning the topological dimension of a geometry.
template<
typename Geometry >
struct topological_dimension
-The topological [link boost_geometry.reference.dimension `dimension`] defines a point as 0-dimensional, a linestring as 1-dimensional, and a ring or polygon as 2-dimensional.
+The topological dimension defines a point as 0-dimensional, a linestring as 1-dimensional, and a ring or polygon as 2-dimensional.
[heading Requirements]
@@ -7021,7 +9372,7 @@
[section:traits__access traits::access]
-Traits class which gives [link boost_geometry.reference.traits__access `traits::access`] (get,set) to points.
+Traits class which gives access (get,set) to points.
template<
@@ -7052,7 +9403,7 @@
[[Geometry][geometry-type ]]
-[[Dimension][[link boost_geometry.reference.traits__dimension `traits::dimension`] to [link boost_geometry.reference.traits__access `traits::access`] ]]
+[[Dimension][dimension to access ]]
]
@@ -7077,7 +9428,7 @@
typename Geometry ,
typename Point >
struct append_point
-If a [link boost_geometry.reference.boost__geometry `boost::geometry`] type should not use the std "push\_back" then it can specialize the "use\_std" [link boost_geometry.reference.traits `traits`] class to false, it should then implement (a.o.) [link boost_geometry.reference.traits__append_point `traits::append_point`]
+If a geometry type should not use the std "push\_back" then it can specialize the "use\_std" traits class to false, it should then implement (a.o.) [link boost_geometry.reference.traits__append_point `traits::append_point`]
[heading Geometries:]
@@ -7111,13 +9462,13 @@
[section:traits__clear traits::clear]
-Traits class, optional, might be implemented to [link boost_geometry.reference.traits__clear `traits::clear`] a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Traits class, optional, might be implemented to clear a geometry.
template<
typename Geometry >
struct clear
-If a [link boost_geometry.reference.boost__geometry `boost::geometry`] type should not use the std ".clear()" then it can specialize the "use\_std" [link boost_geometry.reference.traits `traits`] class to false, it should then implement (a.o.) [link boost_geometry.reference.traits__clear `traits::clear`]
+If a geometry type should not use the std ".clear()" then it can specialize the "use\_std" traits class to false, it should then implement (a.o.) clear
[heading Geometries:]
@@ -7151,7 +9502,7 @@
[section:traits__coordinate_system traits::coordinate_system]
-Traits class defining the coordinate system of a point, important for [link boost_geometry.reference.strategy `strategy`] selection.
+Traits class defining the coordinate system of a point, important for strategy selection.
template<
@@ -7223,7 +9574,7 @@
[section:traits__cs_tag traits::cs_tag]
-Traits class defining coordinate system [link boost_geometry.reference.traits__tag `traits::tag`], bound to coordinate system.
+Traits class defining coordinate system tag, bound to coordinate system.
template<
@@ -7287,13 +9638,13 @@
[section:traits__exterior_ring traits::exterior_ring]
-Traits class defining [link boost_geometry.reference.traits__access `traits::access`] to [link boost_geometry.reference.traits__exterior_ring `traits::exterior_ring`] of a polygon.
+Traits class defining access to [link boost_geometry.reference.traits__exterior_ring `traits::exterior_ring`] of a polygon.
template<
typename Polygon >
struct exterior_ring
-Should define const and non const [link boost_geometry.reference.traits__access `traits::access`]
+Should define const and non const access
@@ -7347,11 +9698,11 @@
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] (box, segment) ]]
+[[Geometry][geometry (box, segment) ]]
[[Index][index (min\_corner/max\_corner for box, 0/1 for segment) ]]
-[[Dimension][[link boost_geometry.reference.traits__dimension `traits::dimension`] ]]
+[[Dimension][dimension ]]
]
@@ -7389,13 +9740,13 @@
[section:traits__interior_rings traits::interior_rings]
-Traits class defining [link boost_geometry.reference.traits__access `traits::access`] to [link boost_geometry.reference.traits__interior_rings `traits::interior_rings`] of a polygon.
+Traits class defining access to [link boost_geometry.reference.traits__interior_rings `traits::interior_rings`] of a polygon.
template<
typename Geometry >
struct interior_rings
-defines [link boost_geometry.reference.traits__access `traits::access`] (const and non const) to interior ring
+defines access (const and non const) to interior ring
[heading Geometries:]
@@ -7419,7 +9770,7 @@
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry][geometry ]]
]
@@ -7465,7 +9816,7 @@
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry][geometry ]]
]
@@ -7524,7 +9875,7 @@
[variablelist
-[[G][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[G][geometry ]]
]
@@ -7580,7 +9931,7 @@
[variablelist
-[[G][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[G][geometry ]]
]
@@ -7624,7 +9975,7 @@
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry][geometry ]]
]
@@ -7642,7 +9993,7 @@
[section:traits__tag traits::tag]
-Traits class to attach a [link boost_geometry.reference.traits__tag `traits::tag`] to a [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Traits class to attach a tag to a geometry.
template<
@@ -7662,7 +10013,7 @@
]
-All geometries should implement a `traits::tag<G>::type` metafunction to indicate their own [link boost_geometry.reference.boost__geometry `boost::geometry`] type.
+All geometries should implement a `traits::tag<G>::type` metafunction to indicate their own geometry type.
[heading Geometries:]
@@ -7684,7 +10035,7 @@
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[Geometry][geometry ]]
]
@@ -7740,7 +10091,7 @@
]
-The default [link boost_geometry.reference.boost__geometry `boost::geometry`] (linestring, ring, multi*) follow std:: for its modifying operations (push\_back, [link boost_geometry.reference.traits__clear `traits::clear`], size, resize, reserve, etc) If they NOT follow the std:: library they should specialize this [link boost_geometry.reference.traits `traits`] class
+The default geometry (linestring, ring, multi*) follow std:: for its modifying operations (push\_back, clear, size, resize, reserve, etc) If they NOT follow the std:: library they should specialize this traits class
[heading Geometries:]
@@ -7858,7 +10209,7 @@
[section:overload1 transform (1 of 2 overloads)]
-Transforms from one [link boost_geometry.reference.boost__geometry `boost::geometry`] to another [link boost_geometry.reference.boost__geometry `boost::geometry`] using a [link boost_geometry.reference.strategy `strategy`].
+Transforms from one geometry to another geometry using a strategy.
template<
@@ -7875,11 +10226,11 @@
[variablelist
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry1][first geometry type ]]
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry2][second geometry type ]]
-[[Strategy][[link boost_geometry.reference.strategy `strategy`] ]]
+[[Strategy][strategy ]]
]
@@ -7889,11 +10240,11 @@
[variablelist
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry1][first geometry ]]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry2][second geometry ]]
-[[strategy][the [link boost_geometry.reference.strategy `strategy`] to be used for transformation ]]
+[[strategy][the strategy to be used for transformation ]]
]
@@ -7907,7 +10258,7 @@
[section:overload2 transform (2 of 2 overloads)]
-Transforms from one [link boost_geometry.reference.boost__geometry `boost::geometry`] to another [link boost_geometry.reference.boost__geometry `boost::geometry`] using a [link boost_geometry.reference.strategy `strategy`].
+Transforms from one geometry to another geometry using a strategy.
template<
@@ -7922,9 +10273,9 @@
[variablelist
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry1][first geometry type ]]
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry2][second geometry type ]]
]
@@ -7934,9 +10285,9 @@
[variablelist
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry1][first geometry ]]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry2][second geometry ]]
]
@@ -8043,15 +10394,15 @@
[variablelist
-[[GeometryOut][output [link boost_geometry.reference.boost__geometry `boost::geometry`] type, must be specified ]]
+[[GeometryOut][output geometry type, must be specified ]]
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry1][first geometry type ]]
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry2][second geometry type ]]
[[OutputIterator][output iterator ]]
-[[Strategy][compound [link boost_geometry.reference.strategy `strategy`] for intersection ]]
+[[Strategy][compound strategy for intersection ]]
]
@@ -8061,13 +10412,13 @@
[variablelist
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry1][first geometry ]]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry2][second geometry ]]
[[out][the output iterator, outputting polygons ]]
-[[strategy][the [link boost_geometry.reference.strategy `strategy`] ]]
+[[strategy][the strategy ]]
]
@@ -8104,11 +10455,11 @@
[variablelist
-[[GeometryOut][output [link boost_geometry.reference.boost__geometry `boost::geometry`] type, must be specified ]]
+[[GeometryOut][output geometry type, must be specified ]]
-[[Geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry1][first geometry type ]]
-[[Geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry2][second geometry type ]]
[[OutputIterator][output iterator ]]
@@ -8120,9 +10471,9 @@
[variablelist
-[[geometry1][first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry1][first geometry ]]
-[[geometry2][second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry2][second geometry ]]
[[out][the output iterator, outputting polygons ]]
@@ -8156,7 +10507,7 @@
[variablelist
-[[Geometry][[link boost_geometry.reference.boost__geometry `boost::geometry`] type ]]
+[[Geometry][geometry type ]]
]
@@ -8166,7 +10517,7 @@
[variablelist
-[[geometry][the [link boost_geometry.reference.boost__geometry `boost::geometry`] to make unique ]]
+[[geometry][the geometry to make unique ]]
]
@@ -8262,7 +10613,7 @@
[section:overload1 within (1 of 2 overloads)]
-Within, examine if a [link boost_geometry.reference.boost__geometry `boost::geometry`] is within another [link boost_geometry.reference.boost__geometry `boost::geometry`].
+Within, examine if a geometry is within another geometry.
template<
@@ -8279,9 +10630,9 @@
[variablelist
-[[geometry1][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might be within the second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry1][geometry which might be within the second geometry ]]
-[[geometry2][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might contain the first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry2][geometry which might contain the first geometry ]]
]
@@ -8293,7 +10644,7 @@
[heading Remarks]
-The default [link boost_geometry.reference.strategy `strategy`] is used for within detection
+The default strategy is used for within detection
@@ -8305,7 +10656,7 @@
[section:overload2 within (2 of 2 overloads)]
-Within, examine if a [link boost_geometry.reference.boost__geometry `boost::geometry`] is within another [link boost_geometry.reference.boost__geometry `boost::geometry`], using a specified [link boost_geometry.reference.strategy `strategy`].
+Within, examine if a geometry is within another geometry, using a specified strategy.
template<
@@ -8324,11 +10675,11 @@
[variablelist
-[[geometry1][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might be within the second [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry1][geometry which might be within the second geometry ]]
-[[geometry2][[link boost_geometry.reference.boost__geometry `boost::geometry`] which might contain the first [link boost_geometry.reference.boost__geometry `boost::geometry`] ]]
+[[geometry2][geometry which might contain the first geometry ]]
-[[strategy][[link boost_geometry.reference.strategy `strategy`] to be used ]]
+[[strategy][strategy to be used ]]
]
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