Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
boost::geometry Namespace Reference

Namespaces

 adapt
 
 concept
 
 core_detail
 
 core_dispatch
 
 cs
 
 detail
 
 detail_dispatch
 
 dispatch
 
 fusion_adapt_detail
 
 index
 
 info
 
 math
 
 model
 
 nyi
 
 policies
 
 range
 
 resolve_strategy
 
 resolve_variant
 
 strategy
 
 traits
 
 util
 

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...
 

Enumeration Type Documentation

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] }

Enumerator
open 

Rings are open: first point and last point are different, algorithms close them explicitly on the fly.

closed 

Rings are closed: first point and last point must be the same.

closure_undertermined 

(Not yet implemented): algorithms first figure out if ring must be closed on the fly

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] }

Enumerator
clockwise 

Points are ordered clockwise.

counterclockwise 

Points are ordered counter clockwise.

order_undetermined 

Points might be stored in any order, algorithms will determine it on the fly (not yet supported)

Function Documentation

template<typename Point1 , typename Point2 >
void boost::geometry::add_point ( Point1 &  p1,
Point2 const &  p2 
)
inline
template<typename Point >
void boost::geometry::add_value ( Point &  p,
typename detail::param< Point >::type  value 
)
inline

Adds the same value to each coordinate of a point.

Template Parameters
Point
Parameters
ppoint
valuevalue to add

References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().

template<typename Geometry , typename RangeOrPoint >
void boost::geometry::append ( Geometry &  geometry,
RangeOrPoint const &  range_or_point,
int  ring_index = -1,
int  multi_index = 0 
)
inline

Appends one or more points to a linestring, ring, polygon, multi-geometry.

Template Parameters
Geometry
RangeOrPointEither a range or a point, fullfilling Boost.Range concept or Boost.Geometry Point Concept
Parameters
geometry
range_or_pointThe point or range to add
ring_indexThe index of the ring in case of a polygon: exterior ring (-1, the default) or interior ring index
multi_indexThe 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().

template<typename Geometry >
default_area_result<Geometry>::type boost::geometry::area ( Geometry const &  geometry)
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.

Template Parameters
Geometry
Parameters
geometry
Returns
{area}

{[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().

template<typename Geometry , typename Strategy >
Strategy::return_type boost::geometry::area ( Geometry const &  geometry,
Strategy const &  strategy 
)
inline

{area}

{area} .

Template Parameters
Geometry
Strategy{Area}
Parameters
geometry
strategy{area}
Returns
{area}

{distinguish,with strategy}

{ [include reference/algorithms/area.qbk]

[heading Example] [area_with_strategy] [area_with_strategy_output]

[heading Available Strategies]

  • [link geometry.reference.strategies.strategy_area_surveyor Surveyor (cartesian)]
  • [link geometry.reference.strategies.strategy_area_huiller Huiller (spherical)] }

References boost::geometry::resolve_variant::area< Geometry >::apply().

template<typename Geometry , int Dimensions>
void boost::geometry::assert_dimension ( )
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().

template<typename G1 , typename G2 >
void boost::geometry::assert_dimension_equal ( )
inline

assert_dimension_equal, enables compile-time checking if coordinate dimensions of two geometries are equal

References boost::BOOST_STATIC_ASSERT().

template<typename Geometry , int Dimensions>
void boost::geometry::assert_dimension_greater_equal ( )
inline
template<typename Geometry , int Dimensions>
void boost::geometry::assert_dimension_less_equal ( )
inline

assert_dimension, enables compile-time checking if coordinate dimensions are as expected

References boost::BOOST_STATIC_ASSERT().

template<typename Geometry1 , typename Geometry2 >
void boost::geometry::assign ( Geometry1 &  geometry1,
Geometry2 const &  geometry2 
)
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.

Template Parameters
Geometry1
Geometry2
Parameters
geometry1(target)
geometry2(source)

{ [heading Example] [assign] [assign_output]

[heading See also]

  • [link geometry.reference.algorithms.convert convert] }

References boost::geometry::resolve_variant::assign< Geometry1, Geometry2 >::apply().

Referenced by assign_values().

template<typename Geometry >
void boost::geometry::assign_inverse ( Geometry &  geometry)
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.

Template Parameters
Geometry
Parameters
geometry

{ [heading Example] [assign_inverse] [assign_inverse_output]

[heading See also]

  • [link geometry.reference.algorithms.make.make_inverse make_inverse] }

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().

template<typename Point1 , typename Point2 >
void boost::geometry::assign_point ( Point1 &  p1,
Point2 const &  p2 
)
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.

Template Parameters
Point1
Point2
Parameters
p1first point
p2second point

References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().

template<typename Geometry , typename Range >
void boost::geometry::assign_points ( Geometry &  geometry,
Range const &  range 
)
inline

Assign a range of points to a linestring, ring or polygon.

Note
The point-type of the range might be different from the point-type of the geometry
Template Parameters
Geometry
Range
Parameters
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]

  • [link geometry.reference.algorithms.append append] }

References append(), and clear().

template<typename Point >
void boost::geometry::assign_value ( Point &  p,
typename detail::param< Point >::type  value 
)
inline

Assign each coordinate of a point the same value.

Template Parameters
Point
Parameters
ppoint
valuevalue to assign

References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().

template<typename Geometry , typename Type >
void boost::geometry::assign_values ( Geometry &  geometry,
Type const &  c1,
Type const &  c2 
)
inline

Assign two coordinates to a geometry (usually a 2D point)

Template Parameters
Geometry
Typeto specify the coordinates
Parameters
geometry
c1
c2

{distinguish, 2 coordinate values} { [heading Example] [assign_2d_point] [assign_2d_point_output]

[heading See also]

  • [link geometry.reference.algorithms.make.make_2_2_coordinate_values make] }

References assign().

template<typename Geometry , typename Type >
void boost::geometry::assign_values ( Geometry &  geometry,
Type const &  c1,
Type const &  c2,
Type const &  c3 
)
inline

Assign three values to a geometry (usually a 3D point)

Template Parameters
Geometry
Typeto specify the coordinates
Parameters
geometry
c1
c2
c3

{distinguish, 3 coordinate values} { [heading Example] [assign_3d_point] [assign_3d_point_output]

[heading See also]

  • [link geometry.reference.algorithms.make.make_3_3_coordinate_values make] }

References assign().

template<typename Geometry , typename Type >
void boost::geometry::assign_values ( Geometry &  geometry,
Type const &  c1,
Type const &  c2,
Type const &  c3,
Type const &  c4 
)
inline

Assign four values to a geometry (usually a box or segment)

Template Parameters
Geometry
Typeto specify the coordinates
Parameters
geometry
c1First coordinate (usually x1)
c2Second coordinate (usually y1)
c3Third coordinate (usually x2)
c4Fourth coordinate (usually y2)

{distinguish, 4 coordinate values}

References assign().

template<typename Geometry >
void boost::geometry::assign_zero ( Geometry &  geometry)
inline
template<typename Geometry , typename Point , typename Strategy >
void boost::geometry::centroid ( Geometry const &  geometry,
Point &  c,
Strategy const &  strategy 
)
inline

{centroid}

{centroid,geometric center (or: center of mass)}.

Template Parameters
Geometry
Point
Strategy{Centroid}
Parameters
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().

template<typename Geometry , typename Point >
void boost::geometry::centroid ( Geometry const &  geometry,
Point &  c 
)
inline

{centroid}

{centroid,geometric center (or: center of mass)}.

Template Parameters
Geometry
Point
Parameters
geometry
cThe 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.

template<typename Geometry >
void boost::geometry::clear ( Geometry &  geometry)
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.

Template Parameters
Geometry
Parameters
geometrywhich will be cleared
Note
points and boxes cannot be cleared, instead they can be set to zero by "assign_zero"

{[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().

template<typename Geometry , typename OutputGeometry , typename Strategy >
void boost::geometry::convex_hull ( Geometry const &  geometry,
OutputGeometry &  out,
Strategy const &  strategy 
)
inline
template<typename Geometry , typename OutputGeometry >
void boost::geometry::convex_hull ( Geometry const &  geometry,
OutputGeometry &  hull 
)
inline

{convex hull}

{convex_hull,convex hull}.

Template Parameters
Geometrythe input geometry type
OutputGeometrythe output geometry type
Parameters
geometry, input geometry
hull{convex hull}

{[include reference/algorithms/convex_hull.qbk]}

References convex_hull(), and boost::iostreams::zlib::default_strategy.

template<typename Geometry >
void boost::geometry::correct ( Geometry &  geometry)
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.

Template Parameters
Geometry
Parameters
geometrywhich will be corrected if necessary

{[include reference/algorithms/correct.qbk]}

References boost::geometry::resolve_variant::correct< Geometry >::apply().

template<typename Geometry1 , typename Geometry2 >
bool boost::geometry::covered_by ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2 
)
inline

{is inside or on border}

{covered_by, is inside or on border}.

Template Parameters
Geometry1
Geometry2
Parameters
geometry1which might be inside or on the border of the second geometry
geometry2which might cover the first geometry
Returns
true if geometry1 is inside of or on the border of geometry2, else false
Note
The default strategy is used for covered_by detection

{[include reference/algorithms/covered_by.qbk]}

References boost::geometry::resolve_variant::covered_by< Geometry1, Geometry2 >::apply(), and boost::iostreams::zlib::default_strategy.

template<typename Geometry1 , typename Geometry2 , typename Strategy >
bool boost::geometry::covered_by ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2,
Strategy const &  strategy 
)
inline

{is inside or on border}

{covered_by, is inside or on border}, .

Template Parameters
Geometry1
Geometry2
Parameters
geometry1which might be inside or on the border of the second geometry
geometry2which might cover the first geometry
strategystrategy to be used
Returns
true if geometry1 is inside of or on the border of geometry2, else false

{distinguish,with strategy} {[include reference/algorithms/covered_by.qbk]}

References boost::geometry::resolve_variant::covered_by< Geometry1, Geometry2 >::apply().

template<typename Geometry1 , typename Geometry2 >
bool boost::geometry::crosses ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2 
)
inline

{crosses}

Template Parameters
Geometry1
Geometry2
Parameters
geometry1
geometry2
Returns
{crosses}

{[include reference/algorithms/crosses.qbk]}

References boost::geometry::resolve_variant::crosses< Geometry1, Geometry2 >::apply().

template<typename Geometry1 , typename Geometry2 , typename Collection >
void boost::geometry::difference ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2,
Collection &  output_collection 
)
inline

{difference}

{difference, spatial set theoretic difference}.

Template Parameters
Geometry1
Geometry2
Collection
Parameters
geometry1
geometry2
output_collectionthe 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().

template<typename Point1 , typename Point2 >
void boost::geometry::divide_point ( Point1 &  p1,
Point2 const &  p2 
)
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.

Template Parameters
Point1
Point2
Parameters
p1first point
p2second point

References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().

template<typename Point >
void boost::geometry::divide_value ( Point &  p,
typename detail::param< Point >::type  value 
)
inline

Divides each coordinate of the same point by a value.

Template Parameters
Point
Parameters
ppoint
valuevalue 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().

template<typename Point1 , typename Point2 >
select_coordinate_type<Point1, Point2>::type boost::geometry::dot_product ( Point1 const &  p1,
Point2 const &  p2 
)
inline

Computes the dot product (or scalar product) of 2 vectors (points).

Template Parameters
Point1
Point2
Parameters
p1first point
p2second point
Returns
the dot product

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().

template<typename Geometry >
detail::dsv::dsv_manipulator<Geometry> boost::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 = ", " 
)
inline

Main DSV-streaming function.

DSV stands for Delimiter Separated Values. Geometries can be streamed as DSV. There are defaults for all separators.

Note
Useful for examples and testing purposes
With this function GeoJSON objects can be created, using the right delimiters

Referenced by boost::geometry::strategy::distance::cross_track< CalculationType, Strategy >::apply().

template<typename Geometry , typename Box >
void boost::geometry::envelope ( Geometry const &  geometry,
Box &  mbr 
)
inline

{envelope}

{envelope,}.

Template Parameters
Geometry
Box
Parameters
geometry
mbr{envelope}

{[include reference/algorithms/envelope.qbk]} { [heading Example] [envelope] [envelope_output] }

References boost::geometry::resolve_variant::envelope< Geometry >::apply().

Referenced by buffer().

template<typename Geometry1 , typename Geometry2 >
bool boost::geometry::equals ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2 
)
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.

Template Parameters
Geometry1
Geometry2
Parameters
geometry1
geometry2
Returns
{are spatially equal}

{[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().

template<typename Box , typename Geometry >
void boost::geometry::expand ( Box &  box,
Geometry const &  geometry 
)
inline

Expands a box using the bounding box (envelope) of another geometry (box, point)

Template Parameters
Boxtype of the box
Geometry
Parameters
boxbox to be expanded using another geometry, mutable
geometrygeometry 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().

template<typename Polygon >
ring_return_type<Polygon>::type boost::geometry::exterior_ring ( Polygon &  polygon)
inline

Function to get the exterior_ring ring of a polygon.

Note
OGC compliance: instead of ExteriorRing
Template Parameters
Polygonpolygon type
Parameters
polygonthe polygon to get the exterior ring from
Returns
a reference to the exterior ring

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().

template<typename Polygon >
ring_return_type<Polygon const>::type boost::geometry::exterior_ring ( Polygon const &  polygon)
inline

Function to get the exterior ring of a polygon (const version)

Note
OGC compliance: instead of ExteriorRing
Template Parameters
Polygonpolygon type
Parameters
polygonthe polygon to get the exterior ring from
Returns
a const reference to the exterior ring

{distinguish,const version}

template<typename Point , typename Op >
void boost::geometry::for_each_coordinate ( Point &  point,
Op  operation 
)
inline
template<typename Point , typename Op >
Op boost::geometry::for_each_coordinate ( Point const &  point,
Op  operation 
)
inline
template<typename Geometry , typename Functor >
Functor boost::geometry::for_each_point ( Geometry &  geometry,
Functor  f 
)
inline

{point}

{point}

Parameters
geometry
f{point}
Template Parameters
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]}

template<typename Geometry , typename Functor >
Functor boost::geometry::for_each_segment ( Geometry &  geometry,
Functor  f 
)
inline

{segment}

{segment}

Parameters
geometry
f{segment}
Template Parameters
Geometry
Functor

{[include reference/algorithms/for_each_segment.qbk]} {[heading Example]} {[for_each_segment_const] [for_each_segment_const_output]}

template<std::size_t Dimension, typename Geometry >
coordinate_type<Geometry>::type boost::geometry::get ( Geometry const &  geometry,
detail::signature_getset_dimension *  dummy = 0 
)
inline
template<std::size_t Index, std::size_t Dimension, typename Geometry >
coordinate_type<Geometry>::type boost::geometry::get ( Geometry const &  geometry,
detail::signature_getset_index_dimension *  dummy = 0 
)
inline

get coordinate value of a Box or Segment

Template Parameters
Index
Dimension
Geometry
Parameters
geometry
Returns
coordinate value

{distinguish,with index} {[include reference/core/get_box.qbk]}

References get(), boost::ignore_unused_variable_warning(), and boost::detail::type.

template<std::size_t Dimension, typename Geometry >
fp_coordinate_type<Geometry>::type boost::geometry::get_as_radian ( Geometry const &  geometry)
inline

get coordinate value of a point, result is in Radian

Result is in Radian, even if source coordinate system is in Degrees

Returns
coordinate value
Template Parameters
Dimensiondimension
Geometrygeometry
Parameters
geometrygeometry to get coordinate value from
Note
Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems

References get().

template<typename Policy , typename Geometry >
Policy boost::geometry::get_rescale_policy ( Geometry const &  geometry)
inline
template<typename Policy , typename Geometry1 , typename Geometry2 >
Policy boost::geometry::get_rescale_policy ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2 
)
inline
template<typename Iterator >
bool boost::geometry::has_one_element ( Iterator  first,
Iterator  beyond 
)
inline
template<typename Polygon >
interior_return_type<Polygon>::type boost::geometry::interior_rings ( Polygon &  polygon)
inline

Function to get the interior rings of a polygon (non const version)

Note
OGC compliance: instead of InteriorRingN
Template Parameters
Polygonpolygon type
Parameters
polygonthe polygon to get the interior rings from
Returns
the interior rings (possibly a reference)

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().

template<typename Polygon >
interior_return_type<Polygon const>::type boost::geometry::interior_rings ( Polygon const &  polygon)
inline

Function to get the interior rings of a polygon (const version)

Note
OGC compliance: instead of InteriorRingN
Template Parameters
Polygonpolygon type
Parameters
polygonthe polygon to get the interior rings from
Returns
the interior rings (possibly a const reference)

{distinguish,const version}

template<typename Geometry >
bool boost::geometry::intersects ( Geometry const &  geometry)
inline

{has at least one intersection (crossing or self-tangency)}

Note
This function can be called for one geometry (self-intersection) and also for two geometries (intersection)
Template Parameters
Geometry
Parameters
geometry
Returns
{is self-intersecting}

{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().

template<typename Geometry1 , typename Geometry2 >
bool boost::geometry::intersects ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2 
)
inline

{have at least one intersection}

Template Parameters
Geometry1
Geometry2
Parameters
geometry1
geometry2
Returns
{intersect each other}

{distinguish,two geometries} {[include reference/algorithms/intersects.qbk]}

References boost::geometry::index::disjoint().

template<typename Geometry >
default_length_result<Geometry>::type boost::geometry::length ( Geometry const &  geometry)
inline

{length}

{length, length (the sum of distances between consecutive points)}.

Template Parameters
Geometry
Parameters
geometry
Returns
{length}

{[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().

template<typename Geometry , typename Strategy >
default_length_result<Geometry>::type boost::geometry::length ( Geometry const &  geometry,
Strategy const &  strategy 
)
inline

{length}

{length, length (the sum of distances between consecutive points)} .

Template Parameters
Geometry
Strategy{distance}
Parameters
geometry
strategy{distance}
Returns
{length}

{distinguish,with strategy} {[include reference/algorithms/length.qbk]} {[length_with_strategy] [length_with_strategy_output]}

References boost::geometry::resolve_variant::length< Geometry >::apply().

template<typename Geometry , typename Type >
Geometry boost::geometry::make ( Type const &  c1,
Type const &  c2 
)
inline

Construct a geometry.

Note
It does not work with array-point types, like int[2]
Template Parameters
Geometry
Typeto specify the coordinates
Parameters
c1
c2
Returns
The constructed geometry, here: a 2D point

{distinguish, 2 coordinate values} { [heading Example] [make_2d_point] [make_2d_point_output]

[heading See also]

  • [link geometry.reference.algorithms.assign.assign_values_3_2_coordinate_values assign] }

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_().

template<typename Geometry , typename Type >
Geometry boost::geometry::make ( Type const &  c1,
Type const &  c2,
Type const &  c3 
)
inline

Construct a geometry.

Template Parameters
Geometry
Typeto specify the coordinates
Parameters
c1
c2
c3
Returns
The constructed geometry, here: a 3D point

{distinguish, 3 coordinate values} { [heading Example] [make_3d_point] [make_3d_point_output]

[heading See also]

  • [link geometry.reference.algorithms.assign.assign_values_4_3_coordinate_values assign] }

References boost::assign().

template<typename Geometry , typename Type >
Geometry boost::geometry::make ( Type const &  c1,
Type const &  c2,
Type const &  c3,
Type const &  c4 
)
inline

References boost::assign().

template<typename Geometry >
Geometry boost::geometry::make_inverse ( )
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.

Template Parameters
Geometry
Returns
The constructed geometry, here: a box

{ [heading Example] [make_inverse] [make_inverse_output]

[heading See also]

  • [link geometry.reference.algorithms.assign.assign_inverse assign_inverse] }

References assign_inverse().

template<typename Geometry >
Geometry boost::geometry::make_zero ( )
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

Template Parameters
Geometry
Returns
The constructed and zero-initialized geometry

References assign_zero().

template<typename Point1 , typename Point2 >
void boost::geometry::multiply_point ( Point1 &  p1,
Point2 const &  p2 
)
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.

Template Parameters
Point1
Point2
Parameters
p1first point
p2second point
Note
This is not a dot, cross or wedge product. It is a mere field-by-field multiplication.

References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().

template<typename Point >
void boost::geometry::multiply_value ( Point &  p,
typename detail::param< Point >::type  value 
)
inline
template<typename Geometry >
std::size_t boost::geometry::num_geometries ( Geometry const &  geometry)
inline

{number of geometries}

{num_geometries, number of geometries}.

Template Parameters
Geometry
Parameters
geometry
Returns
{number of geometries}

{[include reference/algorithms/num_geometries.qbk]}

References boost::geometry::resolve_variant::num_geometries< Geometry >::apply().

template<typename Geometry >
std::size_t boost::geometry::num_interior_rings ( Geometry const &  geometry)
inline

{number of interior rings}

{num_interior_rings, number of interior rings}.

Template Parameters
Geometry
Parameters
geometry
Returns
{number of interior rings}

{[include reference/algorithms/num_interior_rings.qbk]}

Note
Defined by OGC as "numInteriorRing". To be consistent with "numPoints" letter "s" is appended

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().

template<typename Geometry >
std::size_t boost::geometry::num_points ( Geometry const &  geometry,
bool  add_for_open = false 
)
inline

{number of points}

{num_points, number of points}.

Template Parameters
Geometry
Parameters
geometry
add_for_openadd one for open geometries (i.e. polygon types which are not closed)
Returns
{number of points}

{[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().

template<typename Geometry >
std::size_t boost::geometry::num_segments ( Geometry const &  geometry)
inline

{number of segments}

{num_segments, number of segments}.

Template Parameters
Geometry
Parameters
geometry
Returns
{number of segments}

{[include reference/algorithms/num_segments.qbk]}

template<typename Geometry1 , typename Geometry2 >
bool boost::geometry::overlaps ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2 
)
inline

{overlap}

Template Parameters
Geometry1
Geometry2
Parameters
geometry1
geometry2
Returns
{overlap}

{[include reference/algorithms/overlaps.qbk]}

Referenced by boost::geometry::detail::overlaps::box_box::apply().

template<typename Geometry >
default_length_result<Geometry>::type boost::geometry::perimeter ( Geometry const &  geometry)
inline

{perimeter}

The function perimeter returns the perimeter of a geometry, using the default distance-calculation-strategy

Template Parameters
Geometry
Parameters
geometry
Returns
{perimeter}

{[include reference/algorithms/perimeter.qbk]}

References boost::geometry::resolve_variant::perimeter< Geometry >::apply(), and boost::iostreams::zlib::default_strategy.

template<typename Geometry , typename Strategy >
default_length_result<Geometry>::type boost::geometry::perimeter ( Geometry const &  geometry,
Strategy const &  strategy 
)
inline

{perimeter}

The function perimeter returns the perimeter of a geometry, using specified strategy

Template Parameters
Geometry
Strategy{distance}
Parameters
geometry
strategystrategy to be used for distance calculations.
Returns
{perimeter}

{distinguish,with strategy} {[include reference/algorithms/perimeter.qbk]}

References boost::geometry::resolve_variant::perimeter< Geometry >::apply().

template<typename Geometry , typename Point >
void boost::geometry::point_on_surface ( Geometry const &  geometry,
Point &  point 
)
inline

Assigns a Point guaranteed to lie on the surface of the Geometry.

Template Parameters
Geometrygeometry type. This also defines the type of the output point
Parameters
geometryGeometry to take point from
pointPoint to assign

Referenced by return_point_on_surface().

template<typename Geometry >
point_iterator<Geometry> boost::geometry::points_begin ( Geometry &  geometry)
inline

Referenced by points_rend().

template<typename Geometry >
point_iterator<Geometry> boost::geometry::points_end ( Geometry &  geometry)
inline

Referenced by points_rbegin().

template<typename Geometry >
point_reverse_iterator<Geometry> boost::geometry::points_rbegin ( Geometry &  geometry)
inline

References points_end().

template<typename Geometry >
point_reverse_iterator<Geometry> boost::geometry::points_rend ( Geometry &  geometry)
inline

References points_begin().

template<typename Format , typename Geometry >
void boost::geometry::read ( Geometry &  geometry,
std::string const &  wkt 
)
inline
template<typename Geometry >
void boost::geometry::read_wkt ( std::string const &  wkt,
Geometry &  geometry 
)
inline

Parses OGC Well-Known Text (WKT) into a geometry (any geometry)

Template Parameters
Geometry
Parameters
wktstring containing WKT
geometryoutput geometry

{[include reference/io/read_wkt.qbk]}

template<typename Geometry >
void boost::geometry::remove_spikes ( Geometry &  geometry)
inline
Template Parameters
Geometrygeometry type
Parameters
geometrythe geometry to make remove_spikes

References boost::geometry::resolve_variant::remove_spikes< Geometry >::apply().

template<typename Point , typename Geometry >
Point boost::geometry::return_centroid ( Geometry const &  geometry)
inline

{centroid}

{centroid,geometric center (or: center of mass)}. {centroid}.

Template Parameters
Point
Geometry
Parameters
geometry
Returns
{centroid}

{[include reference/algorithms/centroid.qbk]}

References boost::multiprecision::backends::c, and centroid().

template<typename Point , typename Geometry , typename Strategy >
Point boost::geometry::return_centroid ( Geometry const &  geometry,
Strategy const &  strategy 
)
inline

{centroid}

{centroid,geometric center (or: center of mass)}. {centroid}.

Template Parameters
Point
Geometry
Strategy{centroid}
Parameters
geometry
strategy{centroid}
Returns
{centroid}

{distinguish,with strategy} {[include reference/algorithms/centroid.qbk]} {[include reference/algorithms/centroid_strategies.qbk]}

References boost::multiprecision::backends::c, and centroid().

template<typename Box , typename Geometry >
Box boost::geometry::return_envelope ( Geometry const &  geometry)
inline

{envelope}

{return_envelope,}. {envelope}

Template Parameters
Box
Geometry
Parameters
geometry
Returns
{envelope}

{[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().

template<typename Geometry >
geometry::point_type<Geometry>::type boost::geometry::return_point_on_surface ( Geometry const &  geometry)
inline

Returns point guaranteed to lie on the surface of the Geometry.

Template Parameters
Geometrygeometry type. This also defines the type of the output point
Parameters
geometryGeometry to take point from
Returns
The Point guaranteed to lie on the surface of the Geometry

References point_on_surface().

template<typename Geometry >
void boost::geometry::reverse ( Geometry &  geometry)
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.

Template Parameters
Geometry
Parameters
geometrywhich will be reversed

{[include reference/algorithms/reverse.qbk]}

References boost::geometry::resolve_variant::reverse< Geometry >::apply().

template<typename Geometry >
segment_iterator<Geometry const> boost::geometry::segments_begin ( Geometry const &  geometry)
inline
template<typename Geometry >
segment_iterator<Geometry const> boost::geometry::segments_end ( Geometry const &  geometry)
inline
template<std::size_t Dimension, typename Geometry >
void boost::geometry::set ( Geometry &  geometry,
typename coordinate_type< Geometry >::type const &  value,
detail::signature_getset_dimension *  dummy = 0 
)
inline

Set coordinate value of a geometry (usually a point)

Template Parameters
Dimension
Geometry(usually a Point Concept)
Parameters
geometrygeometry to assign coordinate to
geometry(usually a point)
valueThe 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().

template<std::size_t Index, std::size_t Dimension, typename Geometry >
void boost::geometry::set ( Geometry &  geometry,
typename coordinate_type< Geometry >::type const &  value,
detail::signature_getset_index_dimension *  dummy = 0 
)
inline

set coordinate value of a Box / Segment

Template Parameters
Index
Dimension
Geometry
Parameters
geometrygeometry to assign coordinate to
geometry
valueThe 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().

template<std::size_t Dimension, typename Geometry >
void boost::geometry::set_from_radian ( Geometry &  geometry,
typename fp_coordinate_type< Geometry >::type const &  radians 
)
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

Template Parameters
Dimensiondimension
Geometrygeometry
Parameters
geometrygeometry to assign coordinate to
radianscoordinate value to assign
Note
Only applicable to coordinate systems templatized by units, e.g. spherical or geographic coordinate systems

References set().

template<typename Geometry , typename Distance , typename Strategy >
void boost::geometry::simplify ( Geometry const &  geometry,
Geometry &  out,
Distance const &  max_distance,
Strategy const &  strategy 
)
inline

Simplify a geometry using a specified strategy.

Template Parameters
Geometry
DistanceA numerical distance measure
StrategyA type fulfilling a SimplifyStrategy concept
Parameters
strategyA strategy to calculate simplification
geometryinput geometry, to be simplified
outoutput geometry, simplified version of the input geometry
max_distancedistance (in units of input coordinates) of a vertex to other segments to be removed
strategysimplify strategy to be used for simplification, might include point-distance strategy
svg_simplify_country.png
The image below presents the simplified country

{distinguish,with strategy}

References boost::geometry::resolve_variant::simplify< Geometry >::apply(), and clear().

Referenced by simplify().

template<typename Geometry , typename Distance >
void boost::geometry::simplify ( Geometry const &  geometry,
Geometry &  out,
Distance const &  max_distance 
)
inline

Simplify a geometry.

Template Parameters
Geometry
Distance
Note
This version of simplify simplifies a geometry using the default strategy (Douglas Peucker),
Parameters
geometryinput geometry, to be simplified
outoutput geometry, simplified version of the input geometry
max_distancedistance (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().

template<typename Point1 , typename Point2 >
void boost::geometry::subtract_point ( Point1 &  p1,
Point2 const &  p2 
)
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.

Template Parameters
Point1
Point2
Parameters
p1first point
p2second 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().

template<typename Point >
void boost::geometry::subtract_value ( Point &  p,
typename detail::param< Point >::type  value 
)
inline

Subtracts the same value to each coordinate of a point.

Template Parameters
Point
Parameters
ppoint
valuevalue to subtract

References boost::BOOST_CONCEPT_ASSERT(), and for_each_coordinate().

template<typename Geometry >
svg_manipulator<Geometry> boost::geometry::svg ( Geometry const &  geometry,
std::string const &  style,
int  size = -1 
)
inline

Manipulator to stream geometries as SVG.

Template Parameters
Geometry
Parameters
geometry
styleString containing verbatim SVG style information
sizeOptional 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().

template<typename Geometry , typename TransformStrategy >
void boost::geometry::svg_map ( std::ostream &  stream,
std::string const &  style,
int  size,
Geometry const &  geometry,
TransformStrategy const &  strategy 
)
inline
template<typename Geometry1 , typename Geometry2 , typename Collection >
void boost::geometry::sym_difference ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2,
Collection &  output_collection 
)
inline

{symmetric difference}

{symmetric difference, spatial set theoretic symmetric difference (XOR)}.

Template Parameters
Geometry1
Geometry2
Collectionoutput collection, either a multi-geometry, or a std::vector<Geometry> / std::deque<Geometry> etc
Parameters
geometry1
geometry2
output_collectionthe output collection

{[include reference/algorithms/sym_difference.qbk]}

template<typename Geometry >
bool boost::geometry::touches ( Geometry const &  geometry)
inline

{has at least one touching point (self-tangency)}

Note
This function can be called for one geometry (self-tangency) and also for two geometries (touch)
Template Parameters
Geometry
Parameters
geometry
Returns
{is self-touching}

{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().

template<typename Geometry1 , typename Geometry2 >
bool boost::geometry::touches ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2 
)
inline

{have at least one touching point (tangent - non overlapping)}

Template Parameters
Geometry1
Geometry2
Parameters
geometry1
geometry2
Returns
{touch each other}

{distinguish,two geometries} {[include reference/algorithms/touches.qbk]}

References boost::geometry::resolve_variant::touches< Geometry1, Geometry2 >::apply().

template<typename Geometry1 , typename Geometry2 , typename Strategy >
bool boost::geometry::transform ( Geometry1 const &  geometry1,
Geometry2 &  geometry2,
Strategy const &  strategy 
)
inline

Transforms from one geometry to another geometry .

Template Parameters
Geometry1
Geometry2
Strategystrategy
Parameters
geometry1
geometry2
strategyThe strategy to be used for transformation
Returns
True if the transformation could be done

{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().

template<typename Geometry1 , typename Geometry2 >
bool boost::geometry::transform ( Geometry1 const &  geometry1,
Geometry2 &  geometry2 
)
inline

Transforms from one geometry to another geometry using a strategy.

Template Parameters
Geometry1
Geometry2
Parameters
geometry1
geometry2
Returns
True if the transformation could be done

{[include reference/algorithms/transform.qbk]}

References boost::iostreams::zlib::default_strategy, and transform().

template<typename Geometry1 , typename Geometry2 , typename Collection >
void boost::geometry::union_ ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2,
Collection &  output_collection 
)
inline

Combines two geometries which each other.

{union, spatial set theoretic union}.

Template Parameters
Geometry1
Geometry2
Collectionoutput collection, either a multi-geometry, or a std::vector<Geometry> / std::deque<Geometry> etc
Parameters
geometry1
geometry2
output_collectionthe output collection
Note
Called union_ because union is a reserved word.

{[include reference/algorithms/union.qbk]}

template<typename Geometry >
void boost::geometry::unique ( Geometry &  geometry)
inline

{minimal set}

{unique,minimal set (where duplicate consecutive points are removed)}.

Template Parameters
Geometry
Parameters
geometrywhich 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().

template<typename Geometry1 , typename Geometry2 >
bool boost::geometry::within ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2 
)
inline

{is completely inside}

{within, is completely inside}.

Template Parameters
Geometry1
Geometry2
Parameters
geometry1which might be within the second geometry
geometry2which might contain the first geometry
Returns
true if geometry1 is completely contained within geometry2, else false
Note
The default strategy is used for within detection

{[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().

template<typename Geometry1 , typename Geometry2 , typename Strategy >
bool boost::geometry::within ( Geometry1 const &  geometry1,
Geometry2 const &  geometry2,
Strategy const &  strategy 
)
inline

{is completely inside}

{within, is completely inside}, .

Template Parameters
Geometry1
Geometry2
Parameters
geometry1which might be within the second geometry
geometry2which might contain the first geometry
strategystrategy to be used
Returns
true if geometry1 is completely contained within geometry2, else false

{distinguish,with strategy} {[include reference/algorithms/within.qbk]} { [heading Available Strategies]

  • [link geometry.reference.strategies.strategy_within_winding Winding (coordinate system agnostic)]
  • [link geometry.reference.strategies.strategy_within_franklin Franklin (cartesian)]
  • [link geometry.reference.strategies.strategy_within_crossings_multiply Crossings Multiply (cartesian)]

[heading Example] [within_strategy] [within_strategy_output]

}

Variable Documentation