 |
Boost
v1.57.0
doxygen for www.boost.org
|
|
|
Boost
v1.57.0
doxygen for www.boost.org
|
|
Classes | |
| struct | add_const_if_c |
| Meta-function to define a const or non const type. More... | |
| struct | areal_tag |
| For areal types (polygon, multi_polygon, box, ring) More... | |
| struct | box_tag |
| Convenience 2D or 3D box (mbr / aabb) identifying tag. More... | |
| struct | box_view |
| Makes a box behave like a ring or a range. More... | |
| struct | cartesian_tag |
| Tag indicating Cartesian coordinate system family (cartesian,epsg) More... | |
| class | centroid_exception |
| Centroid Exception. More... | |
| struct | closeable_view |
| View on a range, either closing it or leaving it as it is. More... | |
| struct | closeable_view< Range, closed > |
| struct | closeable_view< Range, open > |
| struct | closing_iterator |
| Iterator which iterates through a range, but adds first element at end of the range. More... | |
| struct | closure |
| {value, closure (clockwise\, counterclockwise), } More... | |
| struct | closure_as_bool |
| struct | closure_as_bool< closed > |
| struct | closure_as_bool< open > |
| struct | comparable_distance_result |
| Meta-function defining return type of comparable_distance function. More... | |
| struct | comparable_distance_result< Geometry1, Geometry2, void > |
| struct | compress_variant |
| Meta-function that takes a boost::variant type and tries to minimize it by doing the following: More... | |
| class | concatenate_iterator |
| struct | coordinate_system |
| {type, coordinate system (cartesian\, spherical\, etc), } More... | |
| struct | coordinate_type |
| {type, coordinate type (int\, float\, double\, etc), } More... | |
| struct | cs_tag |
| Meta-function returning coordinate system tag (cs family) of any geometry. More... | |
| struct | de9im |
| Dimensionally Extended 9 Intersection Matrix. More... | |
| struct | de9im_segment |
| struct | default_area_result |
| Meta-function defining return type of area function, using the default strategy. More... | |
| struct | default_comparable_distance_result |
| Meta-function defining return type of comparable_distance function. More... | |
| struct | default_distance_result |
| Meta-function defining return type of distance function. More... | |
| struct | default_length_result |
| Meta-function defining return type of length function. More... | |
| struct | default_strategy |
| struct | degree |
| Unit of plane angle: Degrees. More... | |
| struct | dimension |
| {value, number of coordinates (the number of axes of any geometry), } More... | |
| struct | distance_result |
| Meta-function defining return type of distance function. More... | |
| struct | distance_result< Geometry1, Geometry2, void > |
| class | empty_input_exception |
| Empty Input Exception. More... | |
| struct | equal_to |
| Equal To functor, to compare if points are equal. More... | |
| struct | ever_circling_iterator |
| Iterator which ever circles through a range. More... | |
| struct | ever_circling_range_iterator |
| class | exception |
| Base exception class for Boost.Geometry algorithms. More... | |
| class | flatten_iterator |
| struct | format_dsv |
| struct | format_wkb |
| struct | format_wkt |
| struct | fp_coordinate_type |
| struct | fraction_type |
| struct | geographic_tag |
| Tag indicating Geographic coordinate system family (geographic) More... | |
| struct | geometry_collection_tag |
| OGC Geometry Collection identifying tag. More... | |
| struct | geometry_id |
| Meta-function returning the id of a geometry type. More... | |
| struct | geometry_not_recognized_tag |
| "default" tag More... | |
| struct | greater |
| Greater functor. More... | |
| struct | identity_view |
| View on a range, not modifying anything. More... | |
| struct | interior_return_type |
| struct | interior_type |
| {type, interior_type (container type of inner rings), } More... | |
| struct | is_areal |
| Meta-function defining "true" for areal types (box, (multi)polygon, ring),. More... | |
| struct | is_radian |
| Meta-function to verify if a coordinate system is radian. More... | |
| struct | is_radian< CoordinateSystem< degree > > |
| struct | less |
| Less functor, to sort points in ascending order. More... | |
| struct | linear_tag |
| For linear types (linestring, multi-linestring, segment) More... | |
| struct | linestring_tag |
| OGC Linestring identifying tag. More... | |
| struct | multi_linestring_tag |
| OGC Multi linestring identifying tag. More... | |
| struct | multi_point_tag |
| OGC Multi point identifying tag. More... | |
| struct | multi_polygon_tag |
| OGC Multi polygon identifying tag. More... | |
| struct | multi_tag |
| For multiple-geometries (multi_point, multi_linestring, multi_polygon) More... | |
| struct | not_implemented |
| struct | order_as_direction |
| struct | order_as_direction< clockwise > |
| struct | order_as_direction< counterclockwise > |
| struct | parameter_type_of |
| Meta-function selecting a parameter type of a (member) function, by index. More... | |
| class | point_iterator |
| struct | point_order |
| {value, point order (clockwise\, counterclockwise), } More... | |
| class | point_reverse_iterator |
| struct | point_tag |
| OGC Point identifying tag. More... | |
| struct | point_type |
| {type, point_type, } More... | |
| struct | point_type< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |
| struct | pointlike_tag |
| For point-like types (point, multi_point) More... | |
| struct | polygon_tag |
| OGC Polygon identifying tag. More... | |
| struct | polygonal_tag |
| struct | promote_floating_point |
| Meta-function converting, if necessary, to "a floating point" type. More... | |
| struct | radian |
| Unit of plane angle: Radians. More... | |
| struct | read_wkt_exception |
| Exception showing things wrong with WKT parsing. More... | |
| struct | rescale_overlay_policy_type |
| struct | rescale_overlay_policy_type< Geometry1, Geometry2, areal_tag, areal_tag > |
| struct | rescale_policy_type |
| struct | reverse_dispatch |
| struct | reversible_view |
| View on a range, reversing direction if necessary. More... | |
| struct | reversible_view< Range, iterate_forward > |
| struct | reversible_view< Range, iterate_reverse > |
| struct | ring_return_type |
| struct | ring_tag |
| Convenience (linear) ring identifying tag. More... | |
| struct | ring_type |
| {type, ring_type, } More... | |
| struct | robust_point_type |
| struct | robust_point_type< Point, detail::no_rescale_policy > |
| struct | robust_point_type< Point, detail::robust_policy< FpPoint, IntPoint, CalculationType > > |
| struct | segment_intersection_info |
| struct | segment_intersection_points |
| return-type for segment-intersection More... | |
| class | segment_iterator |
| class | segment_ratio |
| Small class to keep a ratio (e.g. More... | |
| struct | segment_ratio_type |
| struct | segment_ratio_type< Point, detail::no_rescale_policy > |
| struct | segment_ratio_type< Point, detail::robust_policy< FpPoint, IntPoint, CalculationType > > |
| struct | segment_tag |
| Convenience segment (2-points) identifying tag. More... | |
| struct | segment_view |
| Makes a segment behave like a linestring or a range. More... | |
| struct | select_calculation_type |
| Meta-function selecting the "calculation" type. More... | |
| struct | select_coordinate_type |
| Meta-function selecting the most precise coordinate type of two geometries. More... | |
| struct | select_most_precise |
| Meta-function to select, of two types, the most accurate type for calculations. More... | |
| struct | select_most_precise< boost::rational< T >, double > |
| struct | select_most_precise< boost::rational< T1 >, boost::rational< T2 > > |
| class | side_info |
| Class side_info: small class wrapping for sides (-1,0,1) More... | |
| struct | single_tag |
| For single-geometries (point, linestring, polygon, box, ring, segment) More... | |
| struct | single_tag_of |
| Meta-function to get for a tag of a multi-geometry the tag of the corresponding single-geometry. More... | |
| struct | single_tag_of< multi_linestring_tag > |
| struct | single_tag_of< multi_point_tag > |
| struct | single_tag_of< multi_polygon_tag > |
| struct | spherical_equatorial_tag |
| Tag indicating Spherical equatorial coordinate system family. More... | |
| struct | spherical_polar_tag |
| Tag indicating Spherical polar coordinate system family. More... | |
| struct | spherical_tag |
| Tag used for casting spherical/geographic coordinate systems. More... | |
| struct | strategy_compare |
| Traits class binding a comparing strategy to a coordinate system. More... | |
| struct | strategy_compare< spherical_polar_tag, 1, Point, CoordinateSystem< Units >, 0 > |
| struct | strategy_compare< spherical_polar_tag,-1, Point, CoordinateSystem< Units >, 0 > |
| struct | strategy_compare< Tag, 0, Point, CoordinateSystem, Dimension > |
| struct | strategy_compare< Tag, 1, Point, CoordinateSystem, Dimension > |
| struct | strategy_compare< Tag,-1, Point, CoordinateSystem, Dimension > |
| struct | strategy_convex_hull |
| Traits class binding a convex hull calculation strategy to a coordinate system. More... | |
| struct | strategy_convex_hull< InputGeometry, OutputPoint, cartesian_tag > |
| struct | strategy_intersection |
| "compound strategy", containing a segment-intersection-strategy and a side-strategy More... | |
| struct | strategy_intersection_empty |
| struct | strategy_tag_distance_box_box |
| struct | strategy_tag_distance_point_box |
| struct | strategy_tag_distance_point_point |
| struct | strategy_tag_distance_point_segment |
| class | svg_manipulator |
| Generic geometry template manipulator class, takes corresponding output class from traits class. More... | |
| class | svg_mapper |
| Helper class to create SVG maps. More... | |
| struct | tag |
| {type, tag, } More... | |
| struct | tag_cast |
| Metafunction defining a type being either the specified tag, or one of the specified basetags if the type inherits from them. More... | |
| struct | tag_cast< Tag, void, void, void, void, void, void, void > |
| struct | topological_dimension |
| Meta-function returning the topological dimension of a geometry. More... | |
| struct | transform_variant |
| Meta-function that takes a Sequence type, an MPL lambda expression and an optional Inserter and returns a variant type over the same types as the initial variant type, each transformed using the lambda expression. More... | |
| struct | transform_variant< variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Op, boost::mpl::na > |
| Meta-function that takes a boost::variant type and an MPL lambda expression and returns a variant type over the same types as the initial variant type, each transformed using the lambda expression. More... | |
| struct | volumetric_tag |
| For volume types (also box (?), polyhedron) More... | |
| class | wkt_manipulator |
| Generic geometry template manipulator class, takes corresponding output class from traits class. More... | |
Enumerations | |
| enum | closure_selector { open = 0, closed = 1, closure_undertermined = -1 } |
| Enumerates options for defining if polygons are open or closed. More... | |
| enum | order_selector { clockwise = 1, counterclockwise = 2, order_undetermined = 0 } |
| Enumerates options for the order of points within polygons. More... | |
| enum | iterate_direction { iterate_forward, iterate_reverse } |
| Flag for iterating a reversible_view in forward or reverse direction. More... | |
Functions | |
| template<typename Geometry , typename RangeOrPoint > | |
| void | append (Geometry &geometry, RangeOrPoint const &range_or_point, int ring_index=-1, int multi_index=0) |
| Appends one or more points to a linestring, ring, polygon, multi-geometry. More... | |
| template<typename Geometry > | |
| default_area_result< Geometry > ::type | area (Geometry const &geometry) |
| {area} More... | |
| template<typename Geometry , typename Strategy > | |
| Strategy::return_type | area (Geometry const &geometry, Strategy const &strategy) |
| {area} More... | |
| template<typename Geometry , typename Range > | |
| void | assign_points (Geometry &geometry, Range const &range) |
| Assign a range of points to a linestring, ring or polygon. More... | |
| template<typename Geometry > | |
| void | assign_inverse (Geometry &geometry) |
| assign to a box inverse infinite More... | |
| template<typename Geometry > | |
| void | assign_zero (Geometry &geometry) |
| assign zero values to a box, point More... | |
| template<typename Geometry , typename Type > | |
| void | assign_values (Geometry &geometry, Type const &c1, Type const &c2) |
| Assign two coordinates to a geometry (usually a 2D point) More... | |
| template<typename Geometry , typename Type > | |
| void | assign_values (Geometry &geometry, Type const &c1, Type const &c2, Type const &c3) |
| Assign three values to a geometry (usually a 3D point) More... | |
| template<typename Geometry , typename Type > | |
| void | assign_values (Geometry &geometry, Type const &c1, Type const &c2, Type const &c3, Type const &c4) |
| Assign four values to a geometry (usually a box or segment) More... | |
| template<typename Geometry1 , typename Geometry2 > | |
| void | assign (Geometry1 &geometry1, Geometry2 const &geometry2) |
| Assigns one geometry to another geometry. More... | |
| template<typename Input , typename Output , typename Distance > | |
| void | buffer (Input const &geometry_in, Output &geometry_out, Distance const &distance, Distance const &chord_length=-1) |
| {buffer} More... | |
| template<typename Output , typename Input , typename Distance > | |
| Output | return_buffer (Input const &geometry, Distance const &distance, Distance const &chord_length=-1) |
| {buffer} More... | |
| template<typename GeometryIn , typename MultiPolygon , typename DistanceStrategy , typename SideStrategy , typename JoinStrategy , typename EndStrategy , typename PointStrategy > | |
| void | buffer (GeometryIn const &geometry_in, MultiPolygon &geometry_out, DistanceStrategy const &distance_strategy, SideStrategy const &side_strategy, JoinStrategy const &join_strategy, EndStrategy const &end_strategy, PointStrategy const &point_strategy) |
| {buffer} More... | |
| template<typename Geometry , typename Point , typename Strategy > | |
| void | centroid (Geometry const &geometry, Point &c, Strategy const &strategy) |
| {centroid} More... | |
| template<typename Geometry , typename Point > | |
| void | centroid (Geometry const &geometry, Point &c) |
| {centroid} More... | |
| template<typename Point , typename Geometry > | |
| Point | return_centroid (Geometry const &geometry) |
| {centroid} More... | |
| template<typename Point , typename Geometry , typename Strategy > | |
| Point | return_centroid (Geometry const &geometry, Strategy const &strategy) |
| {centroid} More... | |
| template<typename Geometry > | |
| void | clear (Geometry &geometry) |
| Clears a linestring, ring or polygon (exterior+interiors) or multi*. More... | |
| template<typename Geometry1 , typename Geometry2 > | |
| void | convert (Geometry1 const &geometry1, Geometry2 &geometry2) |
| Converts one geometry to another geometry. More... | |
| template<typename Geometry , typename OutputGeometry , typename Strategy > | |
| void | convex_hull (Geometry const &geometry, OutputGeometry &out, Strategy const &strategy) |
| template<typename Geometry , typename OutputGeometry > | |
| void | convex_hull (Geometry const &geometry, OutputGeometry &hull) |
| {convex hull} More... | |
| template<typename Geometry > | |
| void | correct (Geometry &geometry) |
| Corrects a geometry. More... | |
| template<typename Geometry1 , typename Geometry2 > | |
| bool | covered_by (Geometry1 const &geometry1, Geometry2 const &geometry2) |
| {is inside or on border} More... | |
| template<typename Geometry1 , typename Geometry2 , typename Strategy > | |
| bool | covered_by (Geometry1 const &geometry1, Geometry2 const &geometry2, Strategy const &strategy) |
| {is inside or on border} More... | |
| template<typename Geometry1 , typename Geometry2 > | |
| bool | crosses (Geometry1 const &geometry1, Geometry2 const &geometry2) |
| {crosses} More... | |
| template<typename Geometry1 , typename Geometry2 , typename Collection > | |
| void | difference (Geometry1 const &geometry1, Geometry2 const &geometry2, Collection &output_collection) |
| {difference} More... | |
| template<typename Geometry , typename Box > | |
| void | envelope (Geometry const &geometry, Box &mbr) |
| {envelope} More... | |
| template<typename Box , typename Geometry > | |
| Box | return_envelope (Geometry const &geometry) |
| {envelope} More... | |
| template<typename Geometry1 , typename Geometry2 > | |
| bool | equals (Geometry1 const &geometry1, Geometry2 const &geometry2) |
| {are spatially equal} More... | |
| template<typename Box , typename Geometry > | |
| void | expand (Box &box, Geometry const &geometry) |
| Expands a box using the bounding box (envelope) of another geometry (box, point) More... | |
| template<typename Geometry , typename Functor > | |
| Functor | for_each_point (Geometry &geometry, Functor f) |
| {point} More... | |
| template<typename Geometry , typename Functor > | |
| Functor | for_each_segment (Geometry &geometry, Functor f) |
| {segment} More... | |
| template<typename Geometry > | |
| bool | intersects (Geometry const &geometry) |
| {has at least one intersection (crossing or self-tangency)} More... | |
| template<typename Geometry1 , typename Geometry2 > | |
| bool | intersects (Geometry1 const &geometry1, Geometry2 const &geometry2) |
| {have at least one intersection} More... | |
| template<typename Geometry > | |
| default_length_result < Geometry >::type | length (Geometry const &geometry) |
| {length} More... | |
| template<typename Geometry , typename Strategy > | |
| default_length_result < Geometry >::type | length (Geometry const &geometry, Strategy const &strategy) |
| {length} More... | |
| template<typename Geometry , typename Type > | |
| Geometry | make (Type const &c1, Type const &c2) |
| Construct a geometry. More... | |
| template<typename Geometry , typename Type > | |
| Geometry | make (Type const &c1, Type const &c2, Type const &c3) |
| Construct a geometry. More... | |
| template<typename Geometry , typename Type > | |
| Geometry | make (Type const &c1, Type const &c2, Type const &c3, Type const &c4) |
| template<typename Geometry > | |
| Geometry | make_inverse () |
| Construct a box with inverse infinite coordinates. More... | |
| template<typename Geometry > | |
| Geometry | make_zero () |
| Construct a geometry with its coordinates initialized to zero. More... | |
| template<typename Geometry > | |
| std::size_t | num_geometries (Geometry const &geometry) |
| {number of geometries} More... | |
| template<typename Geometry > | |
| std::size_t | num_interior_rings (Geometry const &geometry) |
| {number of interior rings} More... | |
| template<typename Geometry > | |
| std::size_t | num_points (Geometry const &geometry, bool add_for_open=false) |
| {number of points} More... | |
| template<typename Geometry > | |
| std::size_t | num_segments (Geometry const &geometry) |
| {number of segments} More... | |
| template<typename Geometry1 , typename Geometry2 > | |
| bool | overlaps (Geometry1 const &geometry1, Geometry2 const &geometry2) |
| {overlap} More... | |
| template<typename Geometry > | |
| default_length_result < Geometry >::type | perimeter (Geometry const &geometry) |
| {perimeter} More... | |
| template<typename Geometry , typename Strategy > | |
| default_length_result < Geometry >::type | perimeter (Geometry const &geometry, Strategy const &strategy) |
| {perimeter} More... | |
| template<typename Geometry , typename Point > | |
| void | point_on_surface (Geometry const &geometry, Point &point) |
| Assigns a Point guaranteed to lie on the surface of the Geometry. More... | |
| template<typename Geometry > | |
| geometry::point_type< Geometry > ::type | return_point_on_surface (Geometry const &geometry) |
| Returns point guaranteed to lie on the surface of the Geometry. More... | |
| template<typename Geometry > | |
| void | remove_spikes (Geometry &geometry) |
| template<typename Geometry > | |
| void | reverse (Geometry &geometry) |
| Reverses the points within a geometry. More... | |
| template<typename Geometry , typename Distance , typename Strategy > | |
| void | simplify (Geometry const &geometry, Geometry &out, Distance const &max_distance, Strategy const &strategy) |
| Simplify a geometry using a specified strategy. More... | |
| template<typename Geometry , typename Distance > | |
| void | simplify (Geometry const &geometry, Geometry &out, Distance const &max_distance) |
| Simplify a geometry. More... | |
| template<typename Geometry1 , typename Geometry2 , typename Collection > | |
| void | sym_difference (Geometry1 const &geometry1, Geometry2 const &geometry2, Collection &output_collection) |
| {symmetric difference} More... | |
| template<typename Geometry > | |
| bool | touches (Geometry const &geometry) |
| {has at least one touching point (self-tangency)} More... | |
| template<typename Geometry1 , typename Geometry2 > | |
| bool | touches (Geometry1 const &geometry1, Geometry2 const &geometry2) |
| {have at least one touching point (tangent - non overlapping)} More... | |
| template<typename Geometry1 , typename Geometry2 , typename Strategy > | |
| bool | transform (Geometry1 const &geometry1, Geometry2 &geometry2, Strategy const &strategy) |
| Transforms from one geometry to another geometry . More... | |
| template<typename Geometry1 , typename Geometry2 > | |
| bool | transform (Geometry1 const &geometry1, Geometry2 &geometry2) |
| Transforms from one geometry to another geometry using a strategy. More... | |
| template<typename Geometry1 , typename Geometry2 , typename Collection > | |
| void | union_ (Geometry1 const &geometry1, Geometry2 const &geometry2, Collection &output_collection) |
| Combines two geometries which each other. More... | |
| template<typename Geometry > | |
| void | unique (Geometry &geometry) |
| {minimal set} More... | |
| template<typename Geometry1 , typename Geometry2 > | |
| bool | within (Geometry1 const &geometry1, Geometry2 const &geometry2) |
| {is completely inside} More... | |
| template<typename Geometry1 , typename Geometry2 , typename Strategy > | |
| bool | within (Geometry1 const &geometry1, Geometry2 const &geometry2, Strategy const &strategy) |
| {is completely inside} More... | |
| template<typename Point > | |
| void | add_value (Point &p, typename detail::param< Point >::type value) |
| Adds the same value to each coordinate of a point. More... | |
| template<typename Point1 , typename Point2 > | |
| void | add_point (Point1 &p1, Point2 const &p2) |
| Adds a point to another. More... | |
| template<typename Point > | |
| void | subtract_value (Point &p, typename detail::param< Point >::type value) |
| Subtracts the same value to each coordinate of a point. More... | |
| template<typename Point1 , typename Point2 > | |
| void | subtract_point (Point1 &p1, Point2 const &p2) |
| Subtracts a point to another. More... | |
| template<typename Point > | |
| void | multiply_value (Point &p, typename detail::param< Point >::type value) |
| Multiplies each coordinate of a point by the same value. More... | |
| template<typename Point1 , typename Point2 > | |
| void | multiply_point (Point1 &p1, Point2 const &p2) |
| Multiplies a point by another. More... | |
| template<typename Point > | |
| void | divide_value (Point &p, typename detail::param< Point >::type value) |
| Divides each coordinate of the same point by a value. More... | |
| template<typename Point1 , typename Point2 > | |
| void | divide_point (Point1 &p1, Point2 const &p2) |
| Divides a point by another. More... | |
| template<typename Point > | |
| void | assign_value (Point &p, typename detail::param< Point >::type value) |
| Assign each coordinate of a point the same value. More... | |
| template<typename Point1 , typename Point2 > | |
| void | assign_point (Point1 &p1, Point2 const &p2) |
| Assign a point with another. More... | |
| template<typename Point1 , typename Point2 > | |
| select_coordinate_type< Point1, Point2 >::type | dot_product (Point1 const &p1, Point2 const &p2) |
| Computes the dot product (or scalar product) of 2 vectors (points). More... | |
| template<std::size_t Dimension, typename Geometry > | |
| coordinate_type< Geometry >::type | get (Geometry const &geometry, detail::signature_getset_dimension *dummy=0) |
| Get coordinate value of a geometry (usually a point) More... | |
| template<std::size_t Dimension, typename Geometry > | |
| void | set (Geometry &geometry, typename coordinate_type< Geometry >::type const &value, detail::signature_getset_dimension *dummy=0) |
| Set coordinate value of a geometry (usually a point) More... | |
| template<std::size_t Index, std::size_t Dimension, typename Geometry > | |
| coordinate_type< Geometry >::type | get (Geometry const &geometry, detail::signature_getset_index_dimension *dummy=0) |
| get coordinate value of a Box or Segment More... | |
| template<std::size_t Index, std::size_t Dimension, typename Geometry > | |
| void | set (Geometry &geometry, typename coordinate_type< Geometry >::type const &value, detail::signature_getset_index_dimension *dummy=0) |
| set coordinate value of a Box / Segment More... | |
| template<typename Geometry , int Dimensions> | |
| void | assert_dimension () |
| assert_dimension, enables compile-time checking if coordinate dimensions are as expected More... | |
| template<typename Geometry , int Dimensions> | |
| void | assert_dimension_less_equal () |
| assert_dimension, enables compile-time checking if coordinate dimensions are as expected More... | |
| template<typename Geometry , int Dimensions> | |
| void | assert_dimension_greater_equal () |
| template<typename G1 , typename G2 > | |
| void | assert_dimension_equal () |
| assert_dimension_equal, enables compile-time checking if coordinate dimensions of two geometries are equal More... | |
| template<typename Polygon > | |
| ring_return_type< Polygon >::type | exterior_ring (Polygon &polygon) |
| Function to get the exterior_ring ring of a polygon. More... | |
| template<typename Polygon > | |
| ring_return_type< Polygon const >::type | exterior_ring (Polygon const &polygon) |
| Function to get the exterior ring of a polygon (const version) More... | |
| template<typename Polygon > | |
| interior_return_type< Polygon > ::type | interior_rings (Polygon &polygon) |
| Function to get the interior rings of a polygon (non const version) More... | |
| template<typename Polygon > | |
| interior_return_type< Polygon const >::type | interior_rings (Polygon const &polygon) |
| Function to get the interior rings of a polygon (const version) More... | |
| template<std::size_t Dimension, typename Geometry > | |
| fp_coordinate_type< Geometry > ::type | get_as_radian (Geometry const &geometry) |
| get coordinate value of a point, result is in Radian More... | |
| template<std::size_t Dimension, typename Geometry > | |
| void | set_from_radian (Geometry &geometry, typename fp_coordinate_type< Geometry >::type const &radians) |
| set coordinate value (in radian) to a point More... | |
| template<typename Geometry > | |
| detail::dsv::dsv_manipulator < Geometry > | dsv (Geometry const &geometry, std::string const &coordinate_separator=", ", std::string const &point_open="(", std::string const &point_close=")", std::string const &point_separator=", ", std::string const &list_open="(", std::string const &list_close=")", std::string const &list_separator=", ") |
| Main DSV-streaming function. More... | |
| template<typename Format , typename Geometry > | |
| void | read (Geometry &geometry, std::string const &wkt) |
| template<typename Geometry , typename TransformStrategy > | |
| void | svg_map (std::ostream &stream, std::string const &style, int size, Geometry const &geometry, TransformStrategy const &strategy) |
| template<typename Geometry > | |
| svg_manipulator< Geometry > | svg (Geometry const &geometry, std::string const &style, int size=-1) |
| Manipulator to stream geometries as SVG. More... | |
| template<typename Geometry > | |
| void | read_wkt (std::string const &wkt, Geometry &geometry) |
| Parses OGC Well-Known Text (WKT) into a geometry (any geometry) More... | |
| template<typename Geometry > | |
| wkt_manipulator< Geometry > | wkt (Geometry const &geometry) |
| Main WKT-streaming function. More... | |
| template<typename Iterator > | |
| bool | has_one_element (Iterator first, Iterator beyond) |
| template<typename Geometry > | |
| point_iterator< Geometry > | points_begin (Geometry &geometry) |
| template<typename Geometry > | |
| point_iterator< Geometry > | points_end (Geometry &geometry) |
| template<typename Geometry > | |
| point_reverse_iterator< Geometry > | points_rbegin (Geometry &geometry) |
| template<typename Geometry > | |
| point_reverse_iterator< Geometry > | points_rend (Geometry &geometry) |
| template<typename Geometry > | |
| segment_iterator< Geometry const > | segments_begin (Geometry const &geometry) |
| template<typename Geometry > | |
| segment_iterator< Geometry const > | segments_end (Geometry const &geometry) |
| template<typename Policy , typename Geometry > | |
| Policy | get_rescale_policy (Geometry const &geometry) |
| template<typename Policy , typename Geometry1 , typename Geometry2 > | |
| Policy | get_rescale_policy (Geometry1 const &geometry1, Geometry2 const &geometry2) |
| template<typename Point , typename Op > | |
| void | for_each_coordinate (Point &point, Op operation) |
| template<typename Point , typename Op > | |
| Op | for_each_coordinate (Point const &point, Op operation) |
Variables | |
| int const | min_corner = 0 |
| Index of minimum corner of the box. More... | |
| int const | max_corner = 1 |
| Index of maximum corner of the box. More... | |
Enumerates options for defining if polygons are open or closed.
The enumeration closure_selector describes options for if a polygon is open or closed. In a closed polygon the very first point (per ring) should be equal to the very last point. The specific closing property of a polygon type is defined by the closure metafunction. The closure metafunction defines a value, which is one of the values enumerated in the closure_selector
{ [heading See also] [link geometry.reference.core.closure The closure metafunction] }
Flag for iterating a reversible_view in forward or reverse direction.
| Enumerator | |
|---|---|
| iterate_forward | |
| iterate_reverse | |
Enumerates options for the order of points within polygons.
The enumeration order_selector describes options for the order of points within a polygon. Polygons can be ordered either clockwise or counterclockwise. The specific order of a polygon type is defined by the point_order metafunction. The point_order metafunction defines a value, which is one of the values enumerated in the order_selector
{ [heading See also] [link geometry.reference.core.point_order The point_order metafunction] }
|
inline |
Adds a point to another.
The coordinates of the second point will be added to those of the first point. The second point is not modified.
| Point1 | |
| Point2 |
| p1 | first point |
| p2 | second point |
References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().
Referenced by boost::geometry::strategy::centroid::average< PointCentroid, Point >::apply(), boost::geometry::strategy::centroid::weighted_length< Point, PointOfSegment >::apply(), boost::geometry::strategy::distance::projected_point< CalculationType, Strategy >::apply(), boost::geometry::strategy::distance::detail::projected_point_ax< CalculationType, Strategy >::apply(), and boost::geometry::strategy::centroid::weighted_length< Point, PointOfSegment >::result().
|
inline |
Adds the same value to each coordinate of a point.
| Point |
| p | point |
| value | value to add |
References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().
|
inline |
Appends one or more points to a linestring, ring, polygon, multi-geometry.
| Geometry | |
| RangeOrPoint | Either a range or a point, fullfilling Boost.Range concept or Boost.Geometry Point Concept |
| geometry | |
| range_or_point | The point or range to add |
| ring_index | The index of the ring in case of a polygon: exterior ring (-1, the default) or interior ring index |
| multi_index | The index of the geometry to which the points are appended |
{[include reference/algorithms/append.qbk]} }
References boost::geometry::resolve_variant::append< Geometry >::apply().
Referenced by boost::geometry::dispatch::convex_hull< Box, box_tag >::apply(), boost::geometry::detail::correct::correct_ring< Ring, std::less< default_area_result< Ring >::type > >::apply(), boost::geometry::detail::conversion::range_to_range< LineString1, LineString2 >::apply(), boost::geometry::detail::wkt::container_appender< Geometry >::apply(), assign_points(), and boost::geometry::detail::make::make_points().
|
inline |
{area}
{area}.
The area algorithm calculates the surface area of all geometries having a surface, namely box, polygon, ring, multipolygon. The units are the square of the units used for the points defining the surface. If subject geometry is defined in meters, then area is calculated in square meters.
The area calculation can be done in all three common coordinate systems, Cartesian, Spherical and Geographic as well.
| Geometry |
| geometry |
{[include reference/algorithms/area.qbk]} {[heading Examples]} {[area] [area_output]}
References boost::geometry::resolve_variant::area< Geometry >::apply().
Referenced by boost::geometry::detail::equals::area_check::apply().
|
inline |
{area}
{area} .
| Geometry | |
| Strategy | {Area} |
| geometry | |
| strategy | {area} |
{distinguish,with strategy}
{ [include reference/algorithms/area.qbk]
[heading Example] [area_with_strategy] [area_with_strategy_output]
[heading Available Strategies]
References boost::geometry::resolve_variant::area< Geometry >::apply().
|
inline |
assert_dimension, enables compile-time checking if coordinate dimensions are as expected
References boost::BOOST_STATIC_ASSERT(), boost::fusion::equal_to(), boost::spirit::x3::int_, and boost::program_options::value().
|
inline |
assert_dimension_equal, enables compile-time checking if coordinate dimensions of two geometries are equal
References boost::BOOST_STATIC_ASSERT().
|
inline |
References boost::BOOST_STATIC_ASSERT().
|
inline |
assert_dimension, enables compile-time checking if coordinate dimensions are as expected
References boost::BOOST_STATIC_ASSERT().
|
inline |
Assigns one geometry to another geometry.
The assign algorithm assigns one geometry, e.g. a BOX, to another geometry, e.g. a RING. This only works if it is possible and applicable.
| Geometry1 | |
| Geometry2 |
| geometry1 | (target) |
| geometry2 | (source) |
{ [heading Example] [assign] [assign_output]
[heading See also]
References boost::geometry::resolve_variant::assign< Geometry1, Geometry2 >::apply().
Referenced by assign_values().
|
inline |
assign to a box inverse infinite
The assign_inverse function initialize a 2D or 3D box with large coordinates, the min corner is very large, the max corner is very small. This is a convenient starting point to collect the minimum bounding box of a geometry.
| Geometry |
| geometry |
{ [heading Example] [assign_inverse] [assign_inverse_output]
[heading See also]
Referenced by boost::geometry::detail::envelope::envelope_expand_one::apply(), boost::geometry::detail::envelope::envelope_range::apply(), boost::geometry::detail::envelope::envelope_multi_linestring::apply(), boost::geometry::detail::envelope::envelope_multi_polygon::apply(), boost::geometry::index::rtree< Value, Parameters, IndexableGetter, EqualTo, Allocator >::bounds(), make_inverse(), and boost::geometry::svg_mapper< Point, SameScale >::svg_mapper().
|
inline |
Assign a point with another.
The coordinates of the first point will be assigned those of the second point. The second point is not modified.
| Point1 | |
| Point2 |
| p1 | first point |
| p2 | second point |
References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().
|
inline |
Assign a range of points to a linestring, ring or polygon.
| Geometry | |
| Range |
| geometry | |
| range |
{ [heading Notes] [note Assign automatically clears the geometry before assigning (use append if you don't want that)] [heading Example] [assign_points] [assign_points_output]
[heading See also]
|
inline |
Assign each coordinate of a point the same value.
| Point |
| p | point |
| value | value to assign |
References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().
|
inline |
Assign two coordinates to a geometry (usually a 2D point)
| Geometry | |
| Type | to specify the coordinates |
| geometry | |
| c1 | |
| c2 |
{distinguish, 2 coordinate values} { [heading Example] [assign_2d_point] [assign_2d_point_output]
[heading See also]
References assign().
|
inline |
Assign three values to a geometry (usually a 3D point)
| Geometry | |
| Type | to specify the coordinates |
| geometry | |
| c1 | |
| c2 | |
| c3 |
{distinguish, 3 coordinate values} { [heading Example] [assign_3d_point] [assign_3d_point_output]
[heading See also]
References assign().
|
inline |
Assign four values to a geometry (usually a box or segment)
| Geometry | |
| Type | to specify the coordinates |
| geometry | |
| c1 | First coordinate (usually x1) |
| c2 | Second coordinate (usually y1) |
| c3 | Third coordinate (usually x2) |
| c4 | Fourth coordinate (usually y2) |
{distinguish, 4 coordinate values}
References assign().
|
inline |
assign zero values to a box, point
The assign_zero function initializes a 2D or 3D point or box with coordinates of zero
| Geometry |
| geometry |
Referenced by boost::geometry::strategy::centroid::weighted_length< Point, PointOfSegment >::apply(), boost::geometry::detail::wkt::box_parser< Box >::apply(), make_zero(), boost::geometry::strategy::centroid::weighted_length< Point, PointOfSegment >::result(), and boost::geometry::strategy::centroid::detail::weighted_length_sums< Type, DimensionCount >::weighted_length_sums().
|
inline |
{centroid}
{centroid,geometric center (or: center of mass)}.
| Geometry | |
| Point | |
| Strategy | {Centroid} |
| geometry | |
| c | {centroid} |
| strategy | {centroid} |
{distinguish,with strategy} {[include reference/algorithms/centroid.qbk]} {[include reference/algorithms/centroid_strategies.qbk]} }
References boost::geometry::resolve_variant::centroid< Geometry >::apply().
Referenced by boost::geometry::detail::centroid::centroid_indexed_calculator< Indexed, Point, Dimension, DimensionCount >::apply(), centroid(), boost::geometry::strategy::centroid::bashein_detmer< Point, PointOfSegment, CalculationType >::result(), and return_centroid().
|
inline |
{centroid}
{centroid,geometric center (or: center of mass)}.
| Geometry | |
| Point |
| geometry | |
| c | The calculated centroid will be assigned to this point reference |
{[include reference/algorithms/centroid.qbk]} { [heading Example] [centroid] [centroid_output] }
References centroid(), and boost::iostreams::zlib::default_strategy.
|
inline |
Clears a linestring, ring or polygon (exterior+interiors) or multi*.
Generic function to clear a geometry. All points will be removed from the collection or collections making up the geometry. In most cases this is equivalent to the .clear() method of a std::vector<...>. In the case of a polygon, this clear functionality is automatically called for the exterior ring, and for the interior ring collection. In the case of a point, boxes and segments, nothing will happen.
| Geometry |
| geometry | which will be cleared |
{[include reference/algorithms/clear.qbk]}
References boost::geometry::resolve_variant::clear< Geometry >::apply().
Referenced by boost::geometry::detail::remove_spikes::range_remove_spikes< Ring >::apply(), boost::geometry::detail::conversion::range_to_range< LineString1, LineString2 >::apply(), boost::geometry::detail::transform::transform_polygon::apply(), boost::geometry::detail::wkt::geometry_parser< Ring, detail::wkt::ring_parser, detail::wkt::prefix_polygon >::apply(), assign_points(), and simplify().
|
inline |
References boost::geometry::resolve_variant::convex_hull< Geometry >::apply(), and num_points().
Referenced by convex_hull().
|
inline |
{convex hull}
{convex_hull,convex hull}.
| Geometry | the input geometry type |
| OutputGeometry | the output geometry type |
| geometry | , input geometry |
| hull | {convex hull} |
{[include reference/algorithms/convex_hull.qbk]}
References convex_hull(), and boost::iostreams::zlib::default_strategy.
|
inline |
Corrects a geometry.
Corrects a geometry: all rings which are wrongly oriented with respect to their expected orientation are reversed. To all rings which do not have a closing point and are typed as they should have one, the first point is appended. Also boxes can be corrected.
| Geometry |
| geometry | which will be corrected if necessary |
{[include reference/algorithms/correct.qbk]}
References boost::geometry::resolve_variant::correct< Geometry >::apply().
|
inline |
{is inside or on border}
{covered_by, is inside or on border}.
| Geometry1 | |
| Geometry2 |
| geometry1 | which might be inside or on the border of the second geometry |
| geometry2 | which might cover the first geometry |
{[include reference/algorithms/covered_by.qbk]}
References boost::geometry::resolve_variant::covered_by< Geometry1, Geometry2 >::apply(), and boost::iostreams::zlib::default_strategy.
|
inline |
{is inside or on border}
{covered_by, is inside or on border}, .
| Geometry1 | |
| Geometry2 |
| geometry1 | which might be inside or on the border of the second geometry |
| geometry2 | which might cover the first geometry |
| strategy | strategy to be used |
{distinguish,with strategy} {[include reference/algorithms/covered_by.qbk]}
References boost::geometry::resolve_variant::covered_by< Geometry1, Geometry2 >::apply().
|
inline |
{crosses}
| Geometry1 | |
| Geometry2 |
| geometry1 | |
| geometry2 |
{[include reference/algorithms/crosses.qbk]}
References boost::geometry::resolve_variant::crosses< Geometry1, Geometry2 >::apply().
|
inline |
{difference}
{difference, spatial set theoretic difference}.
| Geometry1 | |
| Geometry2 | |
| Collection |
| geometry1 | |
| geometry2 | |
| output_collection | the output collection |
{[include reference/algorithms/difference.qbk]}
Referenced by boost::sinks::unbounded_ordering_queue< OrderT >::dequeue_ready(), and boost::sinks::bounded_ordering_queue< OrderT, MaxQueueSizeV, OverflowStrategyT >::dequeue_ready().
|
inline |
Divides a point by another.
The coordinates of the first point will be divided by those of the second point. The second point is not modified.
| Point1 | |
| Point2 |
| p1 | first point |
| p2 | second point |
References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().
|
inline |
Divides each coordinate of the same point by a value.
| Point |
| p | point |
| value | value to divide by |
References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().
Referenced by boost::geometry::strategy::centroid::average< PointCentroid, Point >::result(), and boost::geometry::strategy::centroid::weighted_length< Point, PointOfSegment >::result().
|
inline |
Computes the dot product (or scalar product) of 2 vectors (points).
| Point1 | |
| Point2 |
| p1 | first point |
| p2 | second point |
References boost::BOOST_CONCEPT_ASSERT().
Referenced by boost::geometry::strategy::distance::projected_point< CalculationType, Strategy >::apply(), and boost::geometry::strategy::distance::detail::projected_point_ax< CalculationType, Strategy >::apply().
|
inline |
Main DSV-streaming function.
DSV stands for Delimiter Separated Values. Geometries can be streamed as DSV. There are defaults for all separators.
Referenced by boost::geometry::strategy::distance::cross_track< CalculationType, Strategy >::apply().
|
inline |
{envelope}
{envelope,}.
| Geometry | |
| Box |
| geometry | |
| mbr | {envelope} |
{[include reference/algorithms/envelope.qbk]} { [heading Example] [envelope] [envelope_output] }
References boost::geometry::resolve_variant::envelope< Geometry >::apply().
Referenced by buffer().
|
inline |
{are spatially equal}
{equals, is spatially equal}. Spatially equal means that the same point set is included. A box can therefore be spatially equal to a ring or a polygon, or a linestring can be spatially equal to a multi-linestring or a segment. This only works theoretically, not all combinations are implemented yet.
| Geometry1 | |
| Geometry2 |
| geometry1 | |
| geometry2 |
{[include reference/algorithms/equals.qbk]}
References boost::geometry::resolve_variant::equals< Geometry1, Geometry2 >::apply().
Referenced by boost::geometry::index::detail::equals< Geometry, Tag >::apply(), boost::geometry::strategy::buffer::join_miter::apply(), boost::geometry::strategy::buffer::join_round_by_divide::apply(), and boost::geometry::strategy::buffer::join_round::apply().
|
inline |
Expands a box using the bounding box (envelope) of another geometry (box, point)
| Box | type of the box |
| Geometry |
| box | box to be expanded using another geometry, mutable |
| geometry | geometry which envelope (bounding box) will be added to the box |
{[include reference/algorithms/expand.qbk]}
References boost::geometry::resolve_variant::expand< Geometry >::apply().
Referenced by boost::geometry::svg_mapper< Point, SameScale >::add(), boost::geometry::detail::envelope::envelope_expand_one::apply(), and boost::geometry::detail::envelope::envelope_range_additional().
|
inline |
Function to get the exterior_ring ring of a polygon.
| Polygon | polygon type |
| polygon | the polygon to get the exterior ring from |
Referenced by boost::geometry::detail::clear::polygon_clear< Polygon >::apply(), boost::geometry::detail::reverse::polygon_reverse::apply(), boost::geometry::detail::unique::polygon_unique::apply(), boost::geometry::dispatch::points_begin< Polygon, polygon_tag >::apply(), boost::geometry::dispatch::segments_begin< Polygon, polygon_tag >::apply(), boost::geometry::detail::append::point_to_polygon< Polygon, Point >::apply(), boost::geometry::detail::envelope::envelope_multi_polygon::apply(), boost::geometry::detail::append::range_to_polygon< Polygon, Range >::apply(), boost::geometry::detail::svg::svg_poly< Polygon >::apply(), boost::geometry::detail::remove_spikes::polygon_remove_spikes< Polygon >::apply(), boost::geometry::detail::transform::transform_polygon::apply(), boost::geometry::detail::for_each::fe_polygon_per_point::apply(), boost::geometry::detail::simplify::simplify_polygon::apply(), boost::geometry::dispatch::envelope< Polygon, polygon_tag >::apply(), boost::geometry::detail::correct::correct_polygon< Polygon >::apply(), boost::geometry::detail::for_each::fe_polygon_per_segment::apply(), boost::geometry::dispatch::points_end< Polygon, polygon_tag >::apply(), boost::geometry::detail::wkt::wkt_poly< Polygon, detail::wkt::prefix_polygon >::apply(), boost::geometry::dispatch::segments_end< Polygon, polygon_tag >::apply(), boost::geometry::detail::conversion::polygon_to_polygon< Polygon1, Polygon2 >::apply(), boost::geometry::detail::dsv::dsv_poly< Polygon >::apply(), boost::geometry::detail::centroid::centroid_polygon_state::apply(), boost::geometry::detail::centroid::centroid_polygon::apply(), boost::geometry::detail::wkt::polygon_parser< Polygon >::apply(), boost::geometry::dispatch::convert< Box, Polygon, box_tag, polygon_tag, 2, false >::apply(), boost::geometry::dispatch::convert< Ring, Polygon, ring_tag, polygon_tag, DimensionCount, false >::apply(), and boost::geometry::dispatch::convert< Polygon, Ring, polygon_tag, ring_tag, DimensionCount, false >::apply().
|
inline |
Function to get the exterior ring of a polygon (const version)
| Polygon | polygon type |
| polygon | the polygon to get the exterior ring from |
{distinguish,const version}
|
inline |
References boost::BOOST_CONCEPT_ASSERT().
Referenced by add_point(), add_value(), assign_point(), assign_value(), divide_point(), divide_value(), multiply_point(), multiply_value(), subtract_point(), and subtract_value().
|
inline |
References boost::BOOST_CONCEPT_ASSERT().
|
inline |
{point}
{point}
| geometry | |
| f | {point} |
| Geometry | |
| Functor |
{[include reference/algorithms/for_each_point.qbk]} {[heading Example]} {[for_each_point] [for_each_point_output]} {[for_each_point_const] [for_each_point_const_output]}
|
inline |
{segment}
{segment}
| geometry | |
| f | {segment} |
| Geometry | |
| Functor |
{[include reference/algorithms/for_each_segment.qbk]} {[heading Example]} {[for_each_segment_const] [for_each_segment_const_output]}
|
inline |
Get coordinate value of a geometry (usually a point)
| Dimension | |
| Geometry | (usually a Point Concept) |
| geometry | (usually a point) |
{[include reference/core/get_point.qbk]}
References get(), boost::ignore_unused_variable_warning(), and boost::detail::type.
Referenced by boost::geometry::strategy::distance::detail::compute_pythagoras_point_box< I >::apply(), boost::geometry::strategy::distance::detail::compute_pythagoras_box_box< I >::apply(), boost::geometry::core_dispatch::interior_rings< polygon_tag, Polygon >::apply(), boost::geometry::core_dispatch::exterior_ring< polygon_tag, Polygon >::apply(), boost::geometry::core_dispatch::access< point_tag, Point, CoordinateType, Dimension, boost::true_type >::get(), and get_as_radian().
|
inline |
get coordinate value of a Box or Segment
| Index | |
| Dimension | |
| Geometry |
| geometry |
{distinguish,with index} {[include reference/core/get_box.qbk]}
References get(), boost::ignore_unused_variable_warning(), and boost::detail::type.
|
inline |
get coordinate value of a point, result is in Radian
Result is in Radian, even if source coordinate system is in Degrees
| Dimension | dimension |
| Geometry | geometry |
| geometry | geometry to get coordinate value from |
References get().
|
inline |
|
inline |
|
inline |
|
inline |
Function to get the interior rings of a polygon (non const version)
| Polygon | polygon type |
| polygon | the polygon to get the interior rings from |
Referenced by boost::geometry::detail::clear::polygon_clear< Polygon >::apply(), boost::geometry::detail::reverse::polygon_reverse::apply(), boost::geometry::dispatch::num_interior_rings< Polygon, polygon_tag >::apply(), boost::geometry::detail::unique::polygon_unique::apply(), boost::geometry::dispatch::points_begin< Polygon, polygon_tag >::apply(), boost::geometry::dispatch::segments_begin< Polygon, polygon_tag >::apply(), boost::geometry::detail::append::point_to_polygon< Polygon, Point >::apply(), boost::geometry::detail::append::range_to_polygon< Polygon, Range >::apply(), boost::geometry::detail::svg::svg_poly< Polygon >::apply(), boost::geometry::detail::remove_spikes::polygon_remove_spikes< Polygon >::apply(), boost::geometry::detail::transform::transform_polygon::apply(), boost::geometry::detail::for_each::fe_polygon_per_point::apply(), boost::geometry::detail::simplify::simplify_polygon::apply(), boost::geometry::detail::correct::correct_polygon< Polygon >::apply(), boost::geometry::detail::for_each::fe_polygon_per_segment::apply(), boost::geometry::dispatch::points_end< Polygon, polygon_tag >::apply(), boost::geometry::detail::wkt::wkt_poly< Polygon, detail::wkt::prefix_polygon >::apply(), boost::geometry::dispatch::segments_end< Polygon, polygon_tag >::apply(), boost::geometry::detail::conversion::polygon_to_polygon< Polygon1, Polygon2 >::apply(), boost::geometry::detail::dsv::dsv_poly< Polygon >::apply(), boost::geometry::detail::centroid::centroid_polygon_state::apply(), and boost::geometry::detail::wkt::polygon_parser< Polygon >::apply().
|
inline |
Function to get the interior rings of a polygon (const version)
| Polygon | polygon type |
| polygon | the polygon to get the interior rings from |
{distinguish,const version}
|
inline |
{has at least one intersection (crossing or self-tangency)}
| Geometry |
| geometry |
{distinguish,one geometry} {[def one_parameter]} {[include reference/algorithms/intersects.qbk]}
References boost::geometry::detail::disjoint::disjoint_interrupt_policy::has_intersections.
Referenced by boost::polygon::polygon_set_data< T >::resize_poly_down().
|
inline |
{have at least one intersection}
| Geometry1 | |
| Geometry2 |
| geometry1 | |
| geometry2 |
{distinguish,two geometries} {[include reference/algorithms/intersects.qbk]}
References boost::geometry::index::disjoint().
|
inline |
{length}
{length, length (the sum of distances between consecutive points)}.
| Geometry |
| geometry |
{[include reference/algorithms/length.qbk]} {[length] [length_output]}
References boost::geometry::resolve_variant::length< Geometry >::apply().
Referenced by boost::geometry::strategy::buffer::side_straight::apply(), and boost::geometry::detail::equals::length_check::apply().
|
inline |
{length}
{length, length (the sum of distances between consecutive points)} .
| Geometry | |
| Strategy | {distance} |
| geometry | |
| strategy | {distance} |
{distinguish,with strategy} {[include reference/algorithms/length.qbk]} {[length_with_strategy] [length_with_strategy_output]}
References boost::geometry::resolve_variant::length< Geometry >::apply().
|
inline |
Construct a geometry.
| Geometry | |
| Type | to specify the coordinates |
| c1 | |
| c2 |
{distinguish, 2 coordinate values} { [heading Example] [make_2d_point] [make_2d_point_output]
[heading See also]
References boost::assign().
Referenced by boost::phoenix::bind(), BOOST_PHOENIX_DEFINE_EXPRESSION(), BOOST_PHOENIX_DEFINE_EXPRESSION_VARARG(), boost::xpressive::by_ref(), boost::phoenix::as_actor< T, mpl::false_ >::convert(), boost::spirit::lazy(), boost::spirit::lex::less(), boost::spirit::lex::lookahead(), boost::phoenix::expression::terminal< reference_wrapper< T > >::make(), boost::gil::detail::_color_converted_view_type< SrcView, CC, DstP, SrcView::value_type >::make(), boost::phoenix::detail::catch_push_back< TryCatch, Exception, Expr, 1 >::make(), boost::phoenix::detail::catch_all_push_back< TryCatch, Expr, 1 >::make(), boost::gil::detail::__nth_channel_view< View, true >::make(), boost::gil::detail::__nth_channel_view< View, false >::make(), boost::gil::nth_channel_view_type< View >::make(), boost::gil::detail::__kth_channel_view< K, View, true >::make(), boost::gil::detail::__kth_channel_view< K, View, false >::make(), boost::gil::kth_channel_view_type< K, View >::make(), meta_grammar(), boost::proto::detail::deep_copy_impl< Expr, 0 >::operator()(), boost::phoenix::function< F >::operator()(), boost::spirit::make_lazy< F, A0 >::operator()(), boost::spirit::make_lazy< F, A0, A1 >::operator()(), boost::spirit::make_lazy< F, A0, A1, A2 >::operator()(), boost::spirit::terminal< tag::int_generator< T, Radix, force_sign > >::operator()(), boost::phoenix::actor< spirit::lex::value_context >::operator=(), boost::phoenix::actor< spirit::lex::state_context >::operator=(), boost::phoenix::catch_gen< TryCatch, Exception >::operator[](), boost::phoenix::catch_all_gen< boost::phoenix::try_catch_actor >::operator[](), boost::phoenix::try_gen::operator[](), boost::xpressive::range(), and boost::phoenix::throw_().
|
inline |
Construct a geometry.
| Geometry | |
| Type | to specify the coordinates |
| c1 | |
| c2 | |
| c3 |
{distinguish, 3 coordinate values} { [heading Example] [make_3d_point] [make_3d_point_output]
[heading See also]
References boost::assign().
|
inline |
References boost::assign().
|
inline |
Construct a box with inverse infinite coordinates.
The make_inverse function initializes a 2D or 3D box with large coordinates, the min corner is very large, the max corner is very small. This is useful e.g. in combination with the expand function, to determine the bounding box of a series of geometries.
| Geometry |
{ [heading Example] [make_inverse] [make_inverse_output]
[heading See also]
References assign_inverse().
|
inline |
Construct a geometry with its coordinates initialized to zero.
The make_zero function initializes a 2D or 3D point or box with coordinates of zero
| Geometry |
References assign_zero().
|
inline |
Multiplies a point by another.
The coordinates of the first point will be multiplied by those of the second point. The second point is not modified.
| Point1 | |
| Point2 |
| p1 | first point |
| p2 | second point |
References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().
|
inline |
Multiplies each coordinate of a point by the same value.
| Point |
| p | point |
| value | value to multiply by |
References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().
Referenced by boost::geometry::strategy::centroid::weighted_length< Point, PointOfSegment >::apply(), boost::geometry::strategy::distance::projected_point< CalculationType, Strategy >::apply(), and boost::geometry::strategy::distance::detail::projected_point_ax< CalculationType, Strategy >::apply().
|
inline |
{number of geometries}
{num_geometries, number of geometries}.
| Geometry |
| geometry |
{[include reference/algorithms/num_geometries.qbk]}
References boost::geometry::resolve_variant::num_geometries< Geometry >::apply().
|
inline |
{number of interior rings}
{num_interior_rings, number of interior rings}.
| Geometry |
| geometry |
{[include reference/algorithms/num_interior_rings.qbk]}
References boost::geometry::resolve_variant::num_interior_rings< Geometry >::apply().
Referenced by boost::geometry::detail::append::point_to_polygon< Polygon, Point >::apply(), boost::geometry::detail::append::range_to_polygon< Polygon, Range >::apply(), boost::geometry::detail::transform::transform_polygon::apply(), and boost::geometry::detail::conversion::polygon_to_polygon< Polygon1, Polygon2 >::apply().
|
inline |
{number of points}
{num_points, number of points}.
| Geometry |
| geometry | |
| add_for_open | add one for open geometries (i.e. polygon types which are not closed) |
{[include reference/algorithms/num_points.qbk]}
Referenced by boost::geometry::svg_mapper< Point, SameScale >::add(), boost::geometry::detail::centroid::centroid_multi< detail::centroid::centroid_polygon_state >::apply(), and convex_hull().
|
inline |
{number of segments}
{num_segments, number of segments}.
| Geometry |
| geometry |
{[include reference/algorithms/num_segments.qbk]}
|
inline |
{overlap}
| Geometry1 | |
| Geometry2 |
| geometry1 | |
| geometry2 |
{[include reference/algorithms/overlaps.qbk]}
Referenced by boost::geometry::detail::overlaps::box_box::apply().
|
inline |
{perimeter}
The function perimeter returns the perimeter of a geometry, using the default distance-calculation-strategy
| Geometry |
| geometry |
{[include reference/algorithms/perimeter.qbk]}
References boost::geometry::resolve_variant::perimeter< Geometry >::apply(), and boost::iostreams::zlib::default_strategy.
|
inline |
{perimeter}
The function perimeter returns the perimeter of a geometry, using specified strategy
| Geometry | |
| Strategy | {distance} |
| geometry | |
| strategy | strategy to be used for distance calculations. |
{distinguish,with strategy} {[include reference/algorithms/perimeter.qbk]}
References boost::geometry::resolve_variant::perimeter< Geometry >::apply().
|
inline |
Assigns a Point guaranteed to lie on the surface of the Geometry.
| Geometry | geometry type. This also defines the type of the output point |
| geometry | Geometry to take point from |
| point | Point to assign |
Referenced by return_point_on_surface().
|
inline |
Referenced by points_rend().
|
inline |
Referenced by points_rbegin().
|
inline |
References points_end().
|
inline |
References points_begin().
|
inline |
|
inline |
Parses OGC Well-Known Text (WKT) into a geometry (any geometry)
| Geometry |
| wkt | string containing WKT |
| geometry | output geometry |
{[include reference/io/read_wkt.qbk]}
|
inline |
| Geometry | geometry type |
| geometry | the geometry to make remove_spikes |
References boost::geometry::resolve_variant::remove_spikes< Geometry >::apply().
|
inline |
{centroid}
{centroid,geometric center (or: center of mass)}. {centroid}.
| Point | |
| Geometry |
| geometry |
{[include reference/algorithms/centroid.qbk]}
References boost::multiprecision::backends::c, and centroid().
|
inline |
{centroid}
{centroid,geometric center (or: center of mass)}. {centroid}.
| Point | |
| Geometry | |
| Strategy | {centroid} |
| geometry | |
| strategy | {centroid} |
{distinguish,with strategy} {[include reference/algorithms/centroid.qbk]} {[include reference/algorithms/centroid_strategies.qbk]}
References boost::multiprecision::backends::c, and centroid().
|
inline |
{envelope}
{return_envelope,}. {envelope}
| Box | |
| Geometry |
| geometry |
{[include reference/algorithms/envelope.qbk]} { [heading Example] [return_envelope] [return_envelope_output] }
References boost::geometry::resolve_variant::envelope< Geometry >::apply().
Referenced by boost::geometry::svg_mapper< Point, SameScale >::add().
|
inline |
Returns point guaranteed to lie on the surface of the Geometry.
| Geometry | geometry type. This also defines the type of the output point |
| geometry | Geometry to take point from |
References point_on_surface().
|
inline |
Reverses the points within a geometry.
Generic function to reverse a geometry. It resembles the std::reverse functionality, but it takes the geometry type into account. Only for a ring or for a linestring it is the same as the std::reverse.
| Geometry |
| geometry | which will be reversed |
{[include reference/algorithms/reverse.qbk]}
References boost::geometry::resolve_variant::reverse< Geometry >::apply().
|
inline |
|
inline |
|
inline |
Set coordinate value of a geometry (usually a point)
| Dimension | |
| Geometry | (usually a Point Concept) |
| geometry | geometry to assign coordinate to |
| geometry | (usually a point) |
| value | The coordinate value to set |
{[include reference/core/set_point.qbk]}
References boost::ignore_unused_variable_warning(), set(), boost::detail::type, and boost::program_options::value().
Referenced by boost::geometry::strategy::within::winding_side_equal< CSTag >::apply(), boost::geometry::strategy::within::winding_side_between< CSTag >::apply(), boost::geometry::core_dispatch::access< point_tag, Point, CoordinateType, Dimension, boost::true_type >::set(), and set_from_radian().
|
inline |
set coordinate value of a Box / Segment
| Index | |
| Dimension | |
| Geometry |
| geometry | geometry to assign coordinate to |
| geometry | |
| value | The coordinate value to set |
{distinguish,with index} {[include reference/core/set_box.qbk]}
References boost::ignore_unused_variable_warning(), boost::detail::type, and boost::program_options::value().
Referenced by boost::geometry::detail::indexed_access_non_pointer< Box, CoordinateType, Index, Dimension >::set(), boost::geometry::core_dispatch::access< point_tag, Point, CoordinateType, Dimension, boost::false_type >::set(), and set().
|
inline |
set coordinate value (in radian) to a point
Coordinate value will be set correctly, if coordinate system of point is in Degree, Radian value will be converted to Degree
| Dimension | dimension |
| Geometry | geometry |
| geometry | geometry to assign coordinate to |
| radians | coordinate value to assign |
References set().
|
inline |
Simplify a geometry using a specified strategy.
| Geometry | |
| Distance | A numerical distance measure |
| Strategy | A type fulfilling a SimplifyStrategy concept |
| strategy | A strategy to calculate simplification |
| geometry | input geometry, to be simplified |
| out | output geometry, simplified version of the input geometry |
| max_distance | distance (in units of input coordinates) of a vertex to other segments to be removed |
| strategy | simplify strategy to be used for simplification, might include point-distance strategy |
{distinguish,with strategy}
References boost::geometry::resolve_variant::simplify< Geometry >::apply(), and clear().
Referenced by simplify().
|
inline |
Simplify a geometry.
| Geometry | |
| Distance |
| geometry | input geometry, to be simplified |
| out | output geometry, simplified version of the input geometry |
| max_distance | distance (in units of input coordinates) of a vertex to other segments to be removed |
{[include reference/algorithms/simplify.qbk]}
References boost::iostreams::zlib::default_strategy, and simplify().
|
inline |
Subtracts a point to another.
The coordinates of the second point will be subtracted to those of the first point. The second point is not modified.
| Point1 | |
| Point2 |
| p1 | first point |
| p2 | second point |
References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().
Referenced by boost::geometry::strategy::distance::projected_point< CalculationType, Strategy >::apply(), and boost::geometry::strategy::distance::detail::projected_point_ax< CalculationType, Strategy >::apply().
|
inline |
Subtracts the same value to each coordinate of a point.
| Point |
| p | point |
| value | value to subtract |
References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().
|
inline |
Manipulator to stream geometries as SVG.
| Geometry |
| geometry | |
| style | String containing verbatim SVG style information |
| size | Optional size (used for SVG points) in SVG pixels. For linestrings, specify linewidth in the SVG style information |
References boost::size().
Referenced by boost::geometry::dispatch::svg_map< point_tag, Point >::apply(), boost::geometry::dispatch::svg_map< box_tag, Box >::apply(), boost::geometry::dispatch::svg_map_range< Linestring, model::linestring< detail::svg::svg_point_type > >::apply(), and boost::geometry::dispatch::svg_map< polygon_tag, Polygon >::apply().
|
inline |
References boost::detail::type.
Referenced by boost::geometry::svg_mapper< Point, SameScale >::map().
|
inline |
{symmetric difference}
{symmetric difference, spatial set theoretic symmetric difference (XOR)}.
| Geometry1 | |
| Geometry2 | |
| Collection | output collection, either a multi-geometry, or a std::vector<Geometry> / std::deque<Geometry> etc |
| geometry1 | |
| geometry2 | |
| output_collection | the output collection |
{[include reference/algorithms/sym_difference.qbk]}
|
inline |
{has at least one touching point (self-tangency)}
| Geometry |
| geometry |
{distinguish,one geometry} {[def one_parameter]} {[include reference/algorithms/touches.qbk]}
References boost::geometry::resolve_variant::self_touches< Geometry >::apply().
Referenced by boost::geometry::detail::touches::box_box::apply().
|
inline |
{have at least one touching point (tangent - non overlapping)}
| Geometry1 | |
| Geometry2 |
| geometry1 | |
| geometry2 |
{distinguish,two geometries} {[include reference/algorithms/touches.qbk]}
References boost::geometry::resolve_variant::touches< Geometry1, Geometry2 >::apply().
|
inline |
Transforms from one geometry to another geometry .
| Geometry1 | |
| Geometry2 | |
| Strategy | strategy |
| geometry1 | |
| geometry2 | |
| strategy | The strategy to be used for transformation |
{distinguish,with strategy}
{[include reference/algorithms/transform_with_strategy.qbk]}
References boost::geometry::resolve_variant::transform< Geometry1, Geometry2 >::apply().
Referenced by boost::geometry::dispatch::svg_map< point_tag, Point >::apply(), boost::geometry::dispatch::svg_map< box_tag, Box >::apply(), boost::geometry::dispatch::svg_map_range< Linestring, model::linestring< detail::svg::svg_point_type > >::apply(), boost::geometry::dispatch::svg_map< polygon_tag, Polygon >::apply(), boost::geometry::svg_mapper< Point, SameScale >::text(), and transform().
|
inline |
Transforms from one geometry to another geometry using a strategy.
| Geometry1 | |
| Geometry2 |
| geometry1 | |
| geometry2 |
{[include reference/algorithms/transform.qbk]}
References boost::iostreams::zlib::default_strategy, and transform().
|
inline |
Combines two geometries which each other.
{union, spatial set theoretic union}.
| Geometry1 | |
| Geometry2 | |
| Collection | output collection, either a multi-geometry, or a std::vector<Geometry> / std::deque<Geometry> etc |
| geometry1 | |
| geometry2 | |
| output_collection | the output collection |
{[include reference/algorithms/union.qbk]}
|
inline |
{minimal set}
{unique,minimal set (where duplicate consecutive points are removed)}.
| Geometry |
| geometry | which will be made unique |
{[include reference/algorithms/unique.qbk]}
References boost::geometry::dispatch::unique< Geometry, Tag >::apply().
Referenced by boost::intrusive::slist_impl< ValueTraits, SizeType, BoolFlags, HeaderHolder >::empty(), boost::intrusive::bstree_impl< ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder >::empty(), boost::intrusive::sgtree_impl< ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder >::erase(), boost::intrusive::treap_impl< ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder >::erase(), boost::intrusive::bstree_impl< ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder >::erase(), boost::phoenix::impl::unique::execute(), boost::intrusive::sgtree_impl< ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder >::insert_before(), boost::intrusive::treap_impl< ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder >::insert_before(), boost::intrusive::bstree_impl< ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder >::insert_before(), boost::intrusive::treap_impl< ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder >::insert_equal(), boost::intrusive::sgtree_impl< ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder >::insert_equal(), boost::intrusive::bstree_impl< ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder >::insert_equal(), boost::intrusive::sgtree_impl< ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder >::insert_unique_commit(), boost::intrusive::treap_impl< ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder >::insert_unique_commit(), boost::intrusive::bstree_impl< ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder >::insert_unique_commit(), boost::intrusive::hashtable_impl< ValueTraits, Hash, Equal, SizeType, BucketTraits, BoolFlags >::insert_unique_commit(), boost::lambda::ll::unique::operator()(), boost::graph::distributed::cc_detail::parallel_connected_components(), boost::intrusive::sgtree_impl< ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder >::push_back(), boost::intrusive::treap_impl< ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder >::push_back(), boost::intrusive::bstree_impl< ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder >::push_back(), boost::intrusive::sgtree_impl< ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder >::push_front(), boost::intrusive::treap_impl< ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder >::push_front(), boost::intrusive::bstree_impl< ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder >::push_front(), boost::polygon::snap_point_vector_to_45(), and boost::transitive_closure().
|
inline |
{is completely inside}
{within, is completely inside}.
| Geometry1 | |
| Geometry2 |
| geometry1 | which might be within the second geometry |
| geometry2 | which might contain the first geometry |
{[include reference/algorithms/within.qbk]}
{ [heading Example] [within] [within_output] }
References boost::iostreams::zlib::default_strategy.
Referenced by boost::geometry::detail::touches::check_each_ring_for_within< Geometry >::apply(), and boost::icl::contains().
|
inline |
{is completely inside}
{within, is completely inside}, .
| Geometry1 | |
| Geometry2 |
| geometry1 | which might be within the second geometry |
| geometry2 | which might contain the first geometry |
| strategy | strategy to be used |
{distinguish,with strategy} {[include reference/algorithms/within.qbk]} { [heading Available Strategies]
[heading Example] [within_strategy] [within_strategy_output]
}
|
inline |
Main WKT-streaming function.
| Geometry |
| geometry |
{[include reference/io/wkt.qbk]}
Referenced by boost::geometry::strategy::buffer::join_round_by_divide::apply(), boost::geometry::detail::wkt::parsing_assigner< Point, Dimension, DimensionCount >::apply(), boost::geometry::strategy::buffer::join_round::apply(), boost::geometry::detail::wkt::geometry_parser< Ring, detail::wkt::ring_parser, detail::wkt::prefix_polygon >::apply(), boost::geometry::detail::wkt::multi_parser< MultiGeometry, detail::wkt::polygon_parser, detail::wkt::prefix_multipolygon >::apply(), boost::geometry::detail::wkt::multi_point_parser< MultiGeometry, detail::wkt::prefix_multipoint >::apply(), boost::geometry::detail::wkt::initialize(), and operator<<().
| int const boost::geometry::max_corner = 1 |
Index of maximum corner of the box.
Referenced by boost::geometry::strategy::distance::detail::compute_pythagoras_point_box< I >::apply(), boost::geometry::strategy::distance::detail::compute_pythagoras_box_box< I >::apply(), and boost::geometry::dispatch::convert< Point, Box, point_tag, box_tag, DimensionCount, false >::apply().
| int const boost::geometry::min_corner = 0 |
Index of minimum corner of the box.
Referenced by boost::geometry::strategy::distance::detail::compute_pythagoras_point_box< I >::apply(), boost::geometry::strategy::distance::detail::compute_pythagoras_box_box< I >::apply(), and boost::geometry::dispatch::convert< Point, Box, point_tag, box_tag, DimensionCount, false >::apply().
1.8.8