|   boost::geometry::util::calculation_type::geometric::binary< Box1, Box2, CalculationType, double, double > |  | 
|    boost::geometry::strategy::distance::pythagoras_box_box< CalculationType >::calculation_type< Box1, Box2 > |  | 
|   boost::geometry::util::calculation_type::geometric::binary< P1, P2, CalculationType, double, double > |  | 
|    boost::geometry::strategy::distance::pythagoras< CalculationType >::calculation_type< P1, P2 > |  | 
|   boost::geometry::util::calculation_type::geometric::binary< Point, Box, CalculationType, double, double > |  | 
|    boost::geometry::strategy::distance::pythagoras_point_box< CalculationType >::calculation_type< Point, Box > |  | 
|   boost::geometry::util::calculation_type::geometric::binary< Point1, Point2, CalculationType, double, double > |  | 
|    boost::geometry::strategy::distance::comparable::pythagoras< CalculationType >::calculation_type< Point1, Point2 > |  | 
|   boost::geometry::add_const_if_c< IsConst, Type > | Meta-function to define a const or non const type | 
|   boost::geometry::areal_tag | For areal types (polygon, multi_polygon, box, ring) | 
|    boost::geometry::box_tag | Convenience 2D or 3D box (mbr / aabb) identifying tag | 
|    boost::geometry::polygonal_tag |  | 
|     boost::geometry::multi_polygon_tag | OGC Multi polygon identifying tag | 
|     boost::geometry::polygon_tag | OGC Polygon identifying tag | 
|     boost::geometry::ring_tag | Convenience (linear) ring identifying tag | 
|   boost::geometry::cartesian_tag | Tag indicating Cartesian coordinate system family (cartesian,epsg) | 
|   boost::geometry::closeable_view< Range, Close > | View on a range, either closing it or leaving it as it is | 
|   boost::geometry::closure< Geometry > | Metafunction defining [*value] as the closure (clockwise, counterclockwise) of the specified geometry type | 
|   boost::geometry::closure_as_bool< Closure > |  | 
|   boost::geometry::closure_as_bool< closed > |  | 
|   boost::geometry::closure_as_bool< open > |  | 
|   boost::geometry::collected_vector< T, Geometry, CSTag > |  | 
|   boost::geometry::collected_vector< T, Geometry, spherical_equatorial_tag > |  | 
|    boost::geometry::collected_vector< T, Geometry, geographic_tag > |  | 
|    boost::geometry::collected_vector< T, Geometry, spherical_polar_tag > |  | 
|   boost::geometry::concepts::AreaStrategy< Strategy > | Checks strategy for area | 
|   boost::geometry::concepts::Box< Geometry > | Box concept | 
|   boost::geometry::concepts::CentroidStrategy< Strategy > | Checks strategy for centroid | 
|   boost::geometry::concepts::ConstBox< Geometry > | Box concept (const version) | 
|   boost::geometry::concepts::ConstLinestring< Geometry > | Linestring concept (const version) | 
|   boost::geometry::concepts::ConstMultiLinestring< Geometry > | Concept for multi-linestring (const version) | 
|   boost::geometry::concepts::ConstMultiPoint< Geometry > | Concept for multi-point (const version) | 
|   boost::geometry::concepts::ConstMultiPolygon< Geometry > | Concept for multi-polygon (const version) | 
|   boost::geometry::concepts::ConstPoint< Geometry > | Point concept (const version) | 
|   boost::geometry::concepts::ConstPolygon< PolygonType > | Checks polygon concept (const version) | 
|   boost::geometry::concepts::ConstRing< Geometry > | (linear) ring concept (const version) | 
|   boost::geometry::concepts::ConstSegment< Geometry > | Segment concept (const version) | 
|   boost::geometry::concepts::ConvexHullStrategy< Strategy > | Checks strategy for convex_hull | 
|   boost::geometry::concepts::Linestring< Geometry > | Linestring concept | 
|   boost::geometry::concepts::MultiLinestring< Geometry > | Multi-linestring concept | 
|   boost::geometry::concepts::MultiPoint< Geometry > | MultiPoint concept | 
|   boost::geometry::concepts::MultiPolygon< Geometry > | Multi-polygon concept | 
|   boost::geometry::concepts::Point< Geometry > | Point concept | 
|   boost::geometry::concepts::PointDistanceStrategy< Strategy, Point1, Point2 > | Checks strategy for point-point or point-box or box-box distance | 
|   boost::geometry::concepts::PointSegmentDistanceStrategy< Strategy, Point, PointOfSegment > | Checks strategy for point-segment distance | 
|   boost::geometry::concepts::Polygon< PolygonType > | Checks polygon concept | 
|   boost::geometry::concepts::Ring< Geometry > | Ring concept | 
|   boost::geometry::concepts::Segment< Geometry > | Segment concept | 
|   boost::geometry::concepts::SegmentIntersectStrategy< Strategy > | Checks strategy for segment intersection | 
|   boost::geometry::concepts::SimplifyStrategy< Strategy, Point > | Checks strategy for simplify | 
|   boost::geometry::concepts::WithinStrategyBoxBox< Strategy > |  | 
|   boost::geometry::concepts::WithinStrategyPointBox< Strategy > |  | 
|   boost::geometry::concepts::WithinStrategyPolygonal< Strategy > | Checks strategy for within (point-in-polygon) | 
|   boost::geometry::coordinate_system< Geometry > | Metafunction defining [*type] as the coordinate system (cartesian, spherical, etc) of the point type making up the specified geometry type | 
|   boost::geometry::coordinate_type< Geometry > | Metafunction defining [*type] as the coordinate type (int, float, double, etc) of the point type making up the specified geometry type | 
|   boost::geometry::core_dispatch::point_order< detail::buffer::buffered_ring_collection_tag, geometry::detail::buffer::buffered_ring_collection< geometry::detail::buffer::buffered_ring< Ring > > > |  | 
|   boost::geometry::core_dispatch::buffered_ring_collection< Ring >> |  | 
|   boost::geometry::cs::cartesian | Cartesian coordinate system | 
|   boost::geometry::cs::geographic< DegreeOrRadian > | Geographic coordinate system, in degree or in radian | 
|   boost::geometry::cs::polar< DegreeOrRadian > | Polar coordinate system | 
|   boost::geometry::cs::spherical< DegreeOrRadian > | Spherical (polar) coordinate system, in degree or in radian | 
|   boost::geometry::cs::spherical_equatorial< DegreeOrRadian > | Spherical equatorial coordinate system, in degree or in radian | 
|   boost::geometry::cs_tag< Geometry > | Meta-function returning coordinate system tag (cs family) of any geometry | 
|   boost::geometry::default_area_result< Geometry > | Meta-function defining return type of area function, using the default strategy | 
|   boost::geometry::default_strategy |  | 
|   boost::geometry::degree | Unit of plane angle: Degrees | 
|   boost::geometry::detail::coordinate_cast< rational< T > > |  | 
|   boost::geometry::detail::de9im::push_back< Seq, T, IsSeq > |  | 
|   boost::geometry::detail::de9im::push_back< Seq, T, false > |  | 
|   boost::geometry::detail::envelope::intersects_antimeridian |  | 
|   boost::geometry::detail::helper_geometries::cs_tag_to_coordinate_system< Units, CS_Tag > |  | 
|   boost::geometry::detail::helper_geometries::cs_tag_to_coordinate_system< Units, geographic_tag > |  | 
|   boost::geometry::detail::helper_geometries::cs_tag_to_coordinate_system< Units, spherical_equatorial_tag > |  | 
|   boost::geometry::detail::helper_geometries::cs_tag_to_coordinate_system< Units, spherical_tag > |  | 
|   boost::geometry::detail::helper_geometries::default_units< Geometry, CS_Tag > |  | 
|   boost::geometry::detail::helper_geometries::default_units< Geometry, cartesian_tag > |  | 
|   boost::geometry::detail::helper_geometries::helper_point< Point, NewCoordinateType, NewUnits, CS_Tag > |  | 
|   boost::geometry::detail::is_valid::complement_graph< TurnPoint > |  | 
|   boost::geometry::detail::is_valid::complement_graph_vertex< TurnPoint > |  | 
|   boost::geometry::detail::is_valid::debug_validity_phase< Geometry, Tag > |  | 
|   boost::geometry::detail::overlay::get_ring< detail::buffer::buffered_ring_collection_tag > |  | 
|   boost::geometry::detail::partition::include_all_policy |  | 
|   boost::geometry::detail::partition::partition_one_range< Dimension, Box, OverlapsPolicy, ExpandPolicy, VisitBoxPolicy > |  | 
|   boost::geometry::detail::partition::partition_two_ranges< Dimension, Box, OverlapsPolicy1, OverlapsPolicy2, ExpandPolicy1, ExpandPolicy2, VisitBoxPolicy > |  | 
|   boost::geometry::detail::partition::visit_no_policy |  | 
|   boost::geometry::detail::turns::filter_continue_turns< Turns, Enable > |  | 
|   boost::geometry::detail::turns::filter_continue_turns< Turns, true > |  | 
|   boost::geometry::detail::turns::less_seg_fraction_other_op< IdLess, N, U, I, B, C, O, OpId > |  | 
|   boost::geometry::detail::turns::remove_duplicate_turns< Turns, Enable > |  | 
|   boost::geometry::detail::turns::remove_duplicate_turns< Turns, true > |  | 
|   boost::geometry::detail::turns::turn_printer |  | 
|   boost::geometry::detail_dispatch::helper_geometry< Box, NewCoordinateType, NewUnits, box_tag > |  | 
|   boost::geometry::detail_dispatch::helper_geometry< Point, NewCoordinateType, NewUnits, point_tag > |  | 
|   boost::geometry::dispatch::within< Point, MultiGeometry, point_tag, detail::buffer::buffered_ring_collection_tag > |  | 
|   boost::geometry::fp_coordinate_type< Geometry > |  | 
|   boost::geometry::fraction_type< SegmentRatio > |  | 
|   boost::geometry::geometry_not_recognized_tag | "default" tag | 
|   boost::geometry::helper_geometry< Geometry, NewCoordinateType, NewUnits > |  | 
|   boost::geometry::identity_view< Range > | View on a range, not modifying anything | 
|   boost::geometry::info::BOX |  | 
|   boost::geometry::info::DIMENSION< D > |  | 
|   boost::geometry::info::GEOMETRY_COLLECTION |  | 
|   boost::geometry::info::LINESTRING |  | 
|   boost::geometry::info::MULTI_LINESTRING |  | 
|   boost::geometry::info::MULTI_POINT |  | 
|   boost::geometry::info::MULTI_POLYGON |  | 
|   boost::geometry::info::POINT |  | 
|   boost::geometry::info::POLYGON |  | 
|   boost::geometry::info::RING |  | 
|   boost::geometry::info::SEGMENT |  | 
|   boost::geometry::info::UNRECOGNIZED_GEOMETRY_TYPE |  | 
|   boost::geometry::interior_return_type< Geometry > |  | 
|   boost::geometry::interior_type< Geometry > | Metafunction defining [*type] as the interior_type (container type of inner rings) of the specified geometry type | 
|   boost::geometry::intersection_strategies< Tag, Geometry1, Geometry2, IntersectionPoint, RobustPolicy, CalculationType > | "compound strategy", containing a segment-intersection-strategy and a side-strategy | 
|   boost::geometry::linear_tag | For linear types (linestring, multi-linestring, segment) | 
|    boost::geometry::linestring_tag | OGC Linestring identifying tag | 
|    boost::geometry::multi_linestring_tag | OGC Multi linestring identifying tag | 
|    boost::geometry::segment_tag | Convenience segment (2-points) identifying tag | 
|   boost::geometry::model::box< Point > | Class box: defines a box made of two describing points | 
|   boost::geometry::model::detail::array_assign< DimensionCount, Index > |  | 
|   boost::geometry::model::detail::array_assign< 1, 1 > |  | 
|   boost::geometry::model::detail::array_assign< 1, 2 > |  | 
|   boost::geometry::model::detail::array_assign< 2, 2 > |  | 
|   boost::geometry::model::point< CoordinateType, DimensionCount, CoordinateSystem > | Basic point class, having coordinates defined in a neutral way | 
|   boost::geometry::model::pointing_segment< ConstOrNonConstPoint > |  | 
|   boost::geometry::model::polygon< Point, ClockWise, Closed, PointList, RingList, PointAlloc, RingAlloc > | The polygon contains an outer ring and zero or more inner rings | 
|   boost::geometry::model::referring_segment< ConstOrNonConstPoint > | Class segment: small class containing two (templatized) point references | 
|   boost::geometry::multi_tag | For multiple-geometries (multi_point, multi_linestring, multi_polygon) | 
|    boost::geometry::geometry_collection_tag | OGC Geometry Collection identifying tag | 
|    boost::geometry::multi_linestring_tag | OGC Multi linestring identifying tag | 
|    boost::geometry::multi_point_tag | OGC Multi point identifying tag | 
|    boost::geometry::multi_polygon_tag | OGC Multi polygon identifying tag | 
|   boost::geometry::nyi::not_implemented_error< Term1, Term2, Term3 > |  | 
|   boost::geometry::nyi::not_implemented_tag |  | 
|    boost::geometry::not_implemented< Term1, Term2, Term3 > |  | 
|    boost::geometry::not_implemented< Geometry > |  | 
|     boost::geometry::detail_dispatch::helper_geometry< Geometry, NewCoordinateType, NewUnits, Tag > |  | 
|   boost::geometry::nyi::tag_to_term< Tag > |  | 
|   boost::geometry::nyi::tag_to_term< boost::mpl::int_< D > > |  | 
|   boost::geometry::nyi::tag_to_term< box_tag > |  | 
|   boost::geometry::nyi::tag_to_term< geometry_collection_tag > |  | 
|   boost::geometry::nyi::tag_to_term< geometry_not_recognized_tag > |  | 
|   boost::geometry::nyi::tag_to_term< linestring_tag > |  | 
|   boost::geometry::nyi::tag_to_term< multi_linestring_tag > |  | 
|   boost::geometry::nyi::tag_to_term< multi_point_tag > |  | 
|   boost::geometry::nyi::tag_to_term< multi_polygon_tag > |  | 
|   boost::geometry::nyi::tag_to_term< point_tag > |  | 
|   boost::geometry::nyi::tag_to_term< polygon_tag > |  | 
|   boost::geometry::nyi::tag_to_term< ring_tag > |  | 
|   boost::geometry::nyi::tag_to_term< segment_tag > |  | 
|   boost::geometry::order_as_direction< Order > |  | 
|   boost::geometry::order_as_direction< clockwise > |  | 
|   boost::geometry::order_as_direction< counterclockwise > |  | 
|   boost::geometry::parameter_type_of< Method, Index > | Meta-function selecting a parameter type of a (member) function, by index | 
|   boost::geometry::partition< Box, ExpandPolicy1, OverlapsPolicy1, ExpandPolicy2, OverlapsPolicy2, IncludePolicy1, IncludePolicy2, VisitBoxPolicy > |  | 
|   boost::geometry::point_order< Geometry > | Metafunction defining [*value] as the point order (clockwise, counterclockwise) of the specified geometry type | 
|   boost::geometry::point_type< Geometry > | Metafunction defining [*type] as the point_type of the specified geometry type | 
|   boost::geometry::pointlike_tag | For point-like types (point, multi_point) | 
|    boost::geometry::multi_point_tag | OGC Multi point identifying tag | 
|    boost::geometry::point_tag | OGC Point identifying tag | 
|   boost::geometry::policies::relate::direction_type |  | 
|   boost::geometry::policies::relate::segments_direction |  | 
|   boost::geometry::policies::relate::segments_intersection_points< ReturnType > | Policy calculating the intersection points themselves | 
|   boost::geometry::policies::relate::segments_intersection_ratios< FractionType > | Policy returning segment ratios | 
|   boost::geometry::policies::relate::segments_tupled< Policy1, Policy2 > |  | 
|   boost::geometry::promote_floating_point< T, PromoteIntegerTo > | Meta-function converting, if necessary, to "a floating point" type | 
|   boost::geometry::promote_integral< T, PromoteUnsignedToUnsigned, UseCheckedInteger, IsIntegral > | Meta-function to define an integral type with size than is (roughly) twice the bit size of T | 
|   boost::geometry::promote_integral< T, PromoteUnsignedToUnsigned, UseCheckedInteger, false > |  | 
|   boost::geometry::radian | Unit of plane angle: Radians | 
|   boost::geometry::radius_type< Geometry > | Metafunction to get the type of radius of a circle / sphere / ellipse / etc | 
|   boost::geometry::range::detail::copy_or_move_impl< It, OutIt, UseMove > |  | 
|   boost::geometry::range::detail::copy_or_move_impl< It, OutIt, false > |  | 
|   boost::geometry::range::detail::pos< RandomAccessRange > |  | 
|   boost::geometry::resolve_strategy::centroid< Geometry > |  | 
|   boost::geometry::resolve_strategy::comparable_distance |  | 
|   boost::geometry::resolve_strategy::convex_hull |  | 
|   boost::geometry::resolve_strategy::convex_hull_insert |  | 
|   boost::geometry::resolve_strategy::covered_by |  | 
|   boost::geometry::resolve_strategy::default_length_result< Geometry > |  | 
|    boost::geometry::resolve_variant::default_length_result< Geometry > |  | 
|     boost::geometry::default_length_result< Geometry > | Meta-function defining return type of length function | 
|   boost::geometry::resolve_strategy::distance |  | 
|   boost::geometry::resolve_strategy::perimeter |  | 
|   boost::geometry::resolve_strategy::simplify |  | 
|   boost::geometry::resolve_strategy::simplify_insert |  | 
|   boost::geometry::resolve_strategy::transform |  | 
|   boost::geometry::resolve_strategy::within |  | 
|   boost::geometry::resolve_variant::append< Geometry > |  | 
|   boost::geometry::resolve_variant::append< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::area< Geometry > |  | 
|   boost::geometry::resolve_variant::area< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::assign< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::assign< Geometry1, variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::assign< variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::assign< variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, variant< BOOST_VARIANT_ENUM_PARAMS(T2)> > |  | 
|   boost::geometry::resolve_variant::buffer< Geometry > |  | 
|   boost::geometry::resolve_variant::buffer< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::centroid< Geometry > |  | 
|   boost::geometry::resolve_variant::centroid< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::clear< Geometry > |  | 
|   boost::geometry::resolve_variant::clear< variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::comparable_distance< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::comparable_distance< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::comparable_distance< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T2)> > |  | 
|   boost::geometry::resolve_variant::comparable_distance< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::comparable_distance_result< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy > |  | 
|   boost::geometry::resolve_variant::comparable_distance_result< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy > |  | 
|   boost::geometry::resolve_variant::convert< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::convert< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::convex_hull< Geometry > |  | 
|   boost::geometry::resolve_variant::convex_hull< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::convex_hull_insert< Geometry > |  | 
|   boost::geometry::resolve_variant::convex_hull_insert< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::correct< Geometry > |  | 
|   boost::geometry::resolve_variant::correct< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::covered_by< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::covered_by< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::variant< BOOST_VARIANT_ENUM_PARAMS(T2)>> |  | 
|   boost::geometry::resolve_variant::covered_by< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::crosses< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::crosses< Geometry1, variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::crosses< variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::crosses< variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, variant< BOOST_VARIANT_ENUM_PARAMS(T2)> > |  | 
|   boost::geometry::resolve_variant::default_length_result< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::disjoint< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::disjoint< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::variant< BOOST_VARIANT_ENUM_PARAMS(T2)>> |  | 
|   boost::geometry::resolve_variant::disjoint< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::distance< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::distance< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T2)> > |  | 
|   boost::geometry::resolve_variant::distance< Geometry1, variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::distance< variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::distance_result< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy > |  | 
|   boost::geometry::resolve_variant::distance_result< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy > |  | 
|   boost::geometry::resolve_variant::envelope< Geometry > |  | 
|   boost::geometry::resolve_variant::envelope< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::equals< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::equals< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::variant< BOOST_VARIANT_ENUM_PARAMS(T2)>> |  | 
|   boost::geometry::resolve_variant::equals< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::expand< Geometry > |  | 
|   boost::geometry::resolve_variant::expand< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::intersection< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::intersection< Geometry1, variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::intersection< variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::intersection< variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, variant< BOOST_VARIANT_ENUM_PARAMS(T2)> > |  | 
|   boost::geometry::resolve_variant::is_empty< Geometry > |  | 
|   boost::geometry::resolve_variant::is_empty< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::is_simple< Geometry > |  | 
|   boost::geometry::resolve_variant::is_simple< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::is_valid< Geometry > |  | 
|   boost::geometry::resolve_variant::is_valid< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::length< Geometry > |  | 
|   boost::geometry::resolve_variant::length< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::num_geometries< Geometry > |  | 
|   boost::geometry::resolve_variant::num_geometries< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::num_interior_rings< Geometry > |  | 
|   boost::geometry::resolve_variant::num_interior_rings< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::num_points< Geometry > |  | 
|   boost::geometry::resolve_variant::num_points< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::num_segments< Geometry > |  | 
|   boost::geometry::resolve_variant::num_segments< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::perimeter< Geometry > |  | 
|   boost::geometry::resolve_variant::perimeter< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::relate< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::relate< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::variant< BOOST_VARIANT_ENUM_PARAMS(T2)>> |  | 
|   boost::geometry::resolve_variant::relate< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::relation< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::relation< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::relation< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T2)> > |  | 
|   boost::geometry::resolve_variant::relation< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::remove_spikes< Geometry > |  | 
|   boost::geometry::resolve_variant::remove_spikes< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::reverse< Geometry > |  | 
|   boost::geometry::resolve_variant::reverse< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::self_touches< Geometry > |  | 
|   boost::geometry::resolve_variant::self_touches< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::simplify< Geometry > |  | 
|   boost::geometry::resolve_variant::simplify< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::touches< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::touches< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::touches< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T2)> > |  | 
|   boost::geometry::resolve_variant::touches< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::resolve_variant::transform< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::transform< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::within< Geometry1, Geometry2 > |  | 
|   boost::geometry::resolve_variant::within< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 > |  | 
|   boost::geometry::resolve_variant::variant< BOOST_VARIANT_ENUM_PARAMS(T2)>> |  | 
|   boost::geometry::resolve_variant::within< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   boost::geometry::reversible_view< Range, Direction > | View on a range, reversing direction if necessary | 
|   boost::geometry::ring_identifier |  | 
|   boost::geometry::ring_return_type< Geometry > |  | 
|   boost::geometry::ring_type< Geometry > | Metafunction defining [*type] as the ring_type of the specified geometry type | 
|   boost::geometry::section< Box, DimensionCount > | Structure containing section information | 
|   boost::geometry::segment_identifier |  | 
|   boost::geometry::segment_intersection_points< Point, SegmentRatio > | Return-type for segment-intersection | 
|   boost::geometry::select_calculation_type< Geometry1, Geometry2, CalculationType > | Meta-function selecting the "calculation" type | 
|   boost::geometry::select_calculation_type_alt< CalculationType, Geometry1, Geometry2, Geometry3 > |  | 
|   boost::geometry::select_coordinate_type< T1, T2, T3 > | Meta-function selecting the most precise coordinate type of two geometries | 
|   boost::geometry::select_coordinate_type< T1, T2, void > |  | 
|   boost::geometry::select_coordinate_type< T1, void, void > |  | 
|   boost::geometry::select_most_precise< T1, T2, T3 > | Meta-function to select, of two types, the most accurate type for calculations | 
|   boost::geometry::select_most_precise< boost::rational< T >, double > |  | 
|   boost::geometry::select_most_precise< boost::rational< T1 >, boost::rational< T2 > > |  | 
|   boost::geometry::select_most_precise< T1, T2, void > |  | 
|   boost::geometry::select_most_precise< T1, void, void > |  | 
|   boost::geometry::side_info | Class side_info: small class wrapping for sides (-1,0,1) | 
|   boost::geometry::single_tag | For single-geometries (point, linestring, polygon, box, ring, segment) | 
|    boost::geometry::box_tag | Convenience 2D or 3D box (mbr / aabb) identifying tag | 
|    boost::geometry::linestring_tag | OGC Linestring identifying tag | 
|    boost::geometry::point_tag | OGC Point identifying tag | 
|    boost::geometry::polygon_tag | OGC Polygon identifying tag | 
|    boost::geometry::ring_tag | Convenience (linear) ring identifying tag | 
|    boost::geometry::segment_tag | Convenience segment (2-points) identifying tag | 
|   boost::geometry::single_tag_of< Tag > | Meta-function to get for a tag of a multi-geometry the tag of the corresponding single-geometry | 
|   boost::geometry::single_tag_of< detail::buffer::buffered_ring_collection_tag > |  | 
|   boost::geometry::spherical_tag | Tag used for casting spherical/geographic coordinate systems | 
|    boost::geometry::geographic_tag | Tag indicating Geographic coordinate system family (geographic) | 
|    boost::geometry::spherical_equatorial_tag | Tag indicating Spherical equatorial coordinate system family | 
|    boost::geometry::spherical_polar_tag | Tag indicating Spherical polar coordinate system family | 
|   boost::geometry::srs::sphere< RadiusType > | Defines sphere radius value for use in spherical CS calculations | 
|   boost::geometry::srs::spheroid< RadiusType > | Defines spheroid radius values for use in geographical CS calculations | 
|   boost::geometry::srs_spheroid_tag | For reference spheroid defining parameters of geographical coordinate system | 
|    boost::geometry::srs_sphere_tag | For reference sphere defining parameters of spherical coordinate system | 
|   boost::geometry::strategy::area::huiller< PointOfSegment, CalculationType > | Area calculation by spherical excess / Huiller's formula | 
|   boost::geometry::strategy::area::huiller< PointOfSegment, CalculationType >::excess_sum |  | 
|   boost::geometry::strategy::area::services::default_strategy< Tag, PointOfSegment > | Traits class binding a default area strategy to a coordinate system | 
|   boost::geometry::strategy::area::surveyor< PointOfSegment, CalculationType > | Area calculation for cartesian points | 
|   boost::geometry::strategy::buffer::distance_asymmetric< NumericType > | Let the buffer for linestrings be asymmetric | 
|   boost::geometry::strategy::buffer::distance_symmetric< NumericType > | Let the buffer algorithm create buffers with same distances | 
|   boost::geometry::strategy::buffer::end_flat | Let the buffer create flat ends | 
|   boost::geometry::strategy::buffer::end_round | Let the buffer create rounded ends | 
|   boost::geometry::strategy::buffer::join_miter | Let the buffer create sharp corners | 
|   boost::geometry::strategy::buffer::join_round | Let the buffer create rounded corners | 
|   boost::geometry::strategy::buffer::join_round_by_divide |  | 
|   boost::geometry::strategy::buffer::point_circle | Create a circular buffer around a point | 
|   boost::geometry::strategy::buffer::point_square | Create a squared form buffer around a point | 
|   boost::geometry::strategy::buffer::side_straight | Let the buffer use straight sides along segments (the default) | 
|   boost::geometry::strategy::centroid::average< PointCentroid, Point > | Centroid calculation taking average of points | 
|   boost::geometry::strategy::centroid::bashein_detmer< Point, PointOfSegment, CalculationType > | Centroid calculation using algorithm Bashein / Detmer | 
|   boost::geometry::strategy::centroid::detail::weighted_length_sums< Type, DimensionCount > |  | 
|   boost::geometry::strategy::centroid::not_applicable_strategy |  | 
|   boost::geometry::strategy::centroid::services::default_strategy< CsTag, GeometryTag, Dimension, Point, Geometry > | Traits class binding a centroid calculation strategy to a coordinate system | 
|   boost::geometry::strategy::centroid::weighted_length< Point, PointOfSegment > |  | 
|   boost::geometry::strategy::centroid::weighted_length< Point, PointOfSegment >::set_sum_div_length |  | 
|   boost::geometry::strategy::compare::circular_comparator< CoordinateType, Units, Compare > | Compare (in one direction) strategy for spherical coordinates | 
|   boost::geometry::strategy::compare::default_strategy | Default strategy, indicates the default strategy for comparisons | 
|   boost::geometry::strategy::convex_hull::graham_andrew< InputGeometry, OutputPoint > | Graham scan strategy to calculate convex hull | 
|   boost::geometry::strategy::covered_by::services::default_strategy< TagContained, TagContaining, CastedTagContained, CastedTagContaining, CsTagContained, CsTagContaining, GeometryContained, GeometryContaining > | Traits class binding a covered_by determination strategy to a coordinate system | 
|   boost::geometry::strategy::distance::comparable::cross_track< CalculationType, Strategy > |  | 
|   boost::geometry::strategy::distance::comparable::haversine< RadiusType, CalculationType > |  | 
|   boost::geometry::strategy::distance::comparable::pythagoras< CalculationType > | Strategy to calculate comparable distance between two points | 
|   boost::geometry::strategy::distance::comparable::pythagoras_box_box< CalculationType > | Strategy to calculate comparable distance between two boxes | 
|   boost::geometry::strategy::distance::comparable::pythagoras_box_box< CalculationType >::calculation_type< Box1, Box2 > |  | 
|   boost::geometry::strategy::distance::comparable::pythagoras_point_box< CalculationType > | Strategy to calculate comparable distance between a point and a box | 
|   boost::geometry::strategy::distance::comparable::pythagoras_point_box< CalculationType >::calculation_type< Point, Box > |  | 
|   boost::geometry::strategy::distance::cross_track< CalculationType, Strategy > | Strategy functor for distance point to segment calculation | 
|   boost::geometry::strategy::distance::cross_track_point_box< CalculationType, Strategy > | Strategy functor for distance point to box calculation | 
|   boost::geometry::strategy::distance::haversine< RadiusType, CalculationType > | Distance calculation for spherical coordinates on a perfect sphere using haversine | 
|   boost::geometry::strategy::distance::projected_point< CalculationType, Strategy > | Strategy for distance point to segment | 
|   boost::geometry::strategy::distance::pythagoras< CalculationType > | Strategy to calculate the distance between two points | 
|   boost::geometry::strategy::distance::pythagoras_box_box< CalculationType > | Strategy to calculate the distance between two boxes | 
|   boost::geometry::strategy::distance::pythagoras_point_box< CalculationType > | Strategy to calculate the distance between a point and a box | 
|   boost::geometry::strategy::distance::services::comparable_type< Strategy > |  | 
|   boost::geometry::strategy::distance::services::default_strategy< GeometryTag1, GeometryTag2, Point1, Point2, CsTag1, CsTag2, UnderlyingStrategy > | Traits class binding a default strategy for distance to one (or possibly two) coordinate system(s) | 
|   boost::geometry::strategy::distance::services::get_comparable< Strategy > |  | 
|   boost::geometry::strategy::distance::services::result_from_distance< Strategy, P1, P2 > |  | 
|   boost::geometry::strategy::distance::services::return_type< Strategy, P1, P2 > |  | 
|   boost::geometry::strategy::distance::services::tag< Strategy > |  | 
|   boost::geometry::strategy::intersection::liang_barsky< Box, Point > | Strategy: line clipping algorithm after Liang Barsky | 
|   boost::geometry::strategy::intersection::relate_spherical_segments< Policy, CalculationType > |  | 
|   boost::geometry::strategy::intersection::relate_spherical_segments< Policy, CalculationType >::segment_intersection_info< CoordinateType, SegmentRatio, Vector3d > |  | 
|   boost::geometry::strategy::intersection::services::default_strategy< CSTag, Policy, CalculationType > | Traits class binding a segments intersection strategy to a coordinate system | 
|   boost::geometry::strategy::not_implemented | Indicate compiler/library user that strategy is not implemented | 
|   boost::geometry::strategy::relate::relate< Geometry1, Geometry2, StaticMask > |  | 
|   boost::geometry::strategy::side::detail::multiplicable_integral< T > |  | 
|   boost::geometry::strategy::side::services::default_strategy< Tag, CalculationType > | Traits class binding a side determination strategy to a coordinate system | 
|   boost::geometry::strategy::side::side_by_cross_track< CalculationType > | Check at which side of a Great Circle segment a point lies left of segment (> 0), right of segment (< 0), on segment (0) | 
|   boost::geometry::strategy::side::side_by_triangle< CalculationType > | Check at which side of a segment a point lies: left of segment (> 0), right of segment (< 0), on segment (0) | 
|   boost::geometry::strategy::side::side_by_triangle< CalculationType >::compute_side_value< CoordinateType, PromotedType, AreAllIntegralCoordinates > |  | 
|   boost::geometry::strategy::side::side_by_triangle< CalculationType >::compute_side_value< CoordinateType, PromotedType, false > |  | 
|   boost::geometry::strategy::side::side_of_intersection |  | 
|   boost::geometry::strategy::side::spherical_side_formula< CalculationType > | Check at which side of a Great Circle segment a point lies left of segment (> 0), right of segment (< 0), on segment (0) | 
|   boost::geometry::strategy::simplify::douglas_peucker< Point, PointDistanceStrategy > | Implements the simplify algorithm | 
|   boost::geometry::strategy::transform::copy_direct< P > | Transformation strategy to copy one point to another using assignment operator | 
|   boost::geometry::strategy::transform::copy_per_coordinate< P1, P2 > | Transformation strategy to do copy a point, copying per coordinate | 
|   boost::geometry::strategy::transform::degree_radian_vv< P1, P2, F > | Transformation strategy to go from degree to radian and back | 
|   boost::geometry::strategy::transform::degree_radian_vv_3< P1, P2, F > |  | 
|   boost::geometry::strategy::transform::from_cartesian_3_to_spherical_equatorial_2< P1, P2 > |  | 
|   boost::geometry::strategy::transform::from_cartesian_3_to_spherical_equatorial_3< P1, P2 > |  | 
|   boost::geometry::strategy::transform::from_cartesian_3_to_spherical_polar_2< P1, P2 > | Transformation strategy for 3D cartesian (x,y,z) to 2D spherical (phi,theta) | 
|   boost::geometry::strategy::transform::from_cartesian_3_to_spherical_polar_3< P1, P2 > | Transformation strategy for 3D cartesian (x,y,z) to 3D spherical (phi,theta,r) | 
|   boost::geometry::strategy::transform::from_spherical_equatorial_2_to_cartesian_3< P1, P2 > |  | 
|   boost::geometry::strategy::transform::from_spherical_equatorial_3_to_cartesian_3< P1, P2 > |  | 
|   boost::geometry::strategy::transform::from_spherical_polar_2_to_cartesian_3< P1, P2 > | Transformation strategy for 2D spherical (phi,theta) to 3D cartesian (x,y,z) | 
|   boost::geometry::strategy::transform::from_spherical_polar_3_to_cartesian_3< P1, P2 > | Transformation strategy for 3D spherical (phi,theta,r) to 3D cartesian (x,y,z) | 
|   boost::geometry::strategy::transform::scale_transformer< CalculationType, Dimension1, Dimension2 > | Strategy of scale transformation in Cartesian system | 
|   boost::geometry::strategy::transform::services::default_strategy< CoordinateSystemTag1, CoordinateSystemTag2, CoordinateSystem1, CoordinateSystem2, Dimension1, Dimension2, Point1, Point2 > | Traits class binding a transformation strategy to a coordinate system | 
|   boost::geometry::strategy::transform::translate_transformer< CalculationType, Dimension1, Dimension2 > | Strategy of translate transformation in Cartesian system | 
|   boost::geometry::strategy::transform::ublas_transformer< CalculationType, Dimension1, Dimension2 > | Affine transformation strategy in Cartesian system | 
|    boost::geometry::strategy::transform::inverse_transformer< CalculationType, Dimension1, Dimension2 > | Transformation strategy to do an inverse transformation in a Cartesian coordinate system | 
|    boost::geometry::strategy::transform::map_transformer< CalculationType, Dimension1, Dimension2, Mirror, SameScale > | Transformation strategy to map from one to another Cartesian coordinate system | 
|   boost::geometry::strategy::transform::ublas_transformer< CalculationType, 2, 2 > |  | 
|    boost::geometry::strategy::transform::scale_transformer< CalculationType, 2, 2 > |  | 
|    boost::geometry::strategy::transform::translate_transformer< CalculationType, 2, 2 > |  | 
|    boost::geometry::strategy::transform::ublas_transformer< CalculationType, 3, 2 > |  | 
|   boost::geometry::strategy::transform::ublas_transformer< CalculationType, 3, 3 > |  | 
|    boost::geometry::strategy::transform::scale_transformer< CalculationType, 3, 3 > |  | 
|    boost::geometry::strategy::transform::translate_transformer< CalculationType, 3, 3 > |  | 
|   boost::geometry::strategy::within::box_covered_by_coord |  | 
|    boost::geometry::strategy::within::box_covered_by_range< Geometry, Dimension, CSTag > |  | 
|   boost::geometry::strategy::within::box_covered_by_longitude_diff |  | 
|   boost::geometry::strategy::within::box_in_box< Box1, Box2, SubStrategy > |  | 
|   boost::geometry::strategy::within::box_longitude_range< Geometry, CoordCheck, InteriorCheck > |  | 
|   boost::geometry::strategy::within::box_within_coord |  | 
|    boost::geometry::strategy::within::box_within_range< Geometry, Dimension, CSTag > |  | 
|   boost::geometry::strategy::within::box_within_longitude_diff |  | 
|   boost::geometry::strategy::within::covered_by_coord |  | 
|    boost::geometry::strategy::within::covered_by_range< Geometry, Dimension, CSTag > |  | 
|   boost::geometry::strategy::within::covered_by_longitude_diff |  | 
|   boost::geometry::strategy::within::crossings_multiply< Point, PointOfSegment, CalculationType > | Within detection using cross counting, | 
|   boost::geometry::strategy::within::decide_covered_by |  | 
|   boost::geometry::strategy::within::decide_within |  | 
|   boost::geometry::strategy::within::franklin< Point, PointOfSegment, CalculationType > | Within detection using cross counting | 
|   boost::geometry::strategy::within::longitude_range< Geometry, CoordCheck, DiffCheck > |  | 
|   boost::geometry::strategy::within::oriented_winding< Reverse, Point, PointOfSegment, CalculationType > | Within detection using winding rule, but checking if enclosing ring is counter clockwise and, if so, reverses the result | 
|   boost::geometry::strategy::within::point_in_box< Point, Box, SubStrategy > |  | 
|   boost::geometry::strategy::within::point_in_box_by_side< Point, Box, Decide > |  | 
|   boost::geometry::strategy::within::point_in_point< Point1, Point2 > |  | 
|   boost::geometry::strategy::within::relate_box_box_loop< SubStrategy, Box1, Box2, Dimension, DimensionCount > |  | 
|   boost::geometry::strategy::within::relate_box_box_loop< SubStrategy, Box1, Box2, DimensionCount, DimensionCount > |  | 
|   boost::geometry::strategy::within::relate_point_box_loop< SubStrategy, Point, Box, Dimension, DimensionCount > |  | 
|   boost::geometry::strategy::within::relate_point_box_loop< SubStrategy, Point, Box, DimensionCount, DimensionCount > |  | 
|   boost::geometry::strategy::within::services::default_strategy< TagContained, TagContaining, CastedTagContained, CastedTagContaining, CsTagContained, CsTagContaining, GeometryContained, GeometryContaining > | Traits class binding a within determination strategy to a coordinate system | 
|   boost::geometry::strategy::within::winding< Point, PointOfSegment, CalculationType > | Within detection using winding rule | 
|   boost::geometry::strategy::within::winding_calculate_count< Point, CalculationType, CSTag > |  | 
|   boost::geometry::strategy::within::winding_calculate_count< Point, CalculationType, cartesian_tag > |  | 
|   boost::geometry::strategy::within::winding_check_touch< Point, CalculationType, CSTag > |  | 
|   boost::geometry::strategy::within::winding_check_touch< Point, CalculationType, cartesian_tag > |  | 
|   boost::geometry::strategy::within::winding_side_equal< CSTag > |  | 
|   boost::geometry::strategy::within::winding_side_equal< cartesian_tag > |  | 
|   boost::geometry::strategy::within::winding_small_angle< Point, CalculationType > |  | 
|   boost::geometry::strategy::within::within_coord |  | 
|    boost::geometry::strategy::within::within_range< Geometry, Dimension, CSTag > |  | 
|   boost::geometry::strategy::within::within_longitude_diff |  | 
|   boost::geometry::strategy_compare< Tag, Direction, Point, CoordinateSystem, Dimension > | Traits class binding a comparing strategy to a coordinate system | 
|   boost::geometry::strategy_convex_hull< Geometry1, Point, CsTag > | Traits class binding a convex hull calculation strategy to a coordinate system | 
|   boost::geometry::strategy_tag_distance_box_box |  | 
|   boost::geometry::strategy_tag_distance_point_box |  | 
|   boost::geometry::strategy_tag_distance_point_point |  | 
|   boost::geometry::strategy_tag_distance_point_segment |  | 
|   boost::geometry::svg_manipulator< Geometry > | Generic geometry template manipulator class, takes corresponding output class from traits class | 
|   boost::geometry::tag< Geometry > | Metafunction defining [*type] as the tag of the specified geometry type | 
|   boost::geometry::tag_cast< Tag, BaseTag, BaseTag2, BaseTag3, BaseTag4, BaseTag5, BaseTag6, BaseTag7 > | Metafunction defining a type being either the specified tag, or one of the specified basetags if the type inherits from them | 
|   boost::geometry::traits::access< Geometry, Dimension, Enable > | Traits class which gives access (get,set) to points | 
|   boost::geometry::traits::clear< Range > | Traits class to clear a geometry | 
|   boost::geometry::traits::closure< G > | Traits class indicating if points within a ring or (multi)polygon are closed (last point == first point), open or not known | 
|   boost::geometry::traits::closure< geometry::detail::buffer::buffered_ring< Ring > > |  | 
|   boost::geometry::traits::coordinate_system< Point, Enable > | Traits class defining the coordinate system of a point, important for strategy selection | 
|   boost::geometry::traits::coordinate_type< Point, Enable > | Traits class which indicate the coordinate type (double,float,...) of a point | 
|   boost::geometry::traits::cs_tag< CoordinateSystem > | Traits class defining coordinate system tag, bound to coordinate system | 
|   boost::geometry::traits::dimension< Point, Enable > | Traits class indicating the number of dimensions of a point | 
|   boost::geometry::traits::exterior_ring< Polygon > | Traits class defining access to exterior_ring of a polygon | 
|   boost::geometry::traits::indexed_access< Geometry, Index, Dimension > | Traits class defining "get" and "set" to get and set point coordinate values | 
|   boost::geometry::traits::interior_const_type< Geometry > | Traits class indicating interior container type of a polygon | 
|   boost::geometry::traits::interior_mutable_type< Geometry > |  | 
|   boost::geometry::traits::interior_rings< Geometry > | Traits class defining access to interior_rings of a polygon | 
|   boost::geometry::traits::point_order< Ring > | Traits class indicating the order of contained points within a ring or (multi)polygon, clockwise, counter clockwise or not known | 
|   boost::geometry::traits::point_order< geometry::detail::buffer::buffered_ring< Ring > > |  | 
|   boost::geometry::traits::point_type< Geometry > | Traits class indicating the type of contained points | 
|   boost::geometry::traits::point_type< geometry::detail::buffer::buffered_ring_collection< Ring > > |  | 
|   boost::geometry::traits::point_type< geometry::strategy::simplify::detail::douglas_peucker_point< P > > |  | 
|   boost::geometry::traits::push_back< Range > | Traits class to append a point to a range (ring, linestring, multi*) | 
|   boost::geometry::traits::radius_access< Geometry, Dimension > | Traits class to get/set radius of a circle/sphere/(ellipse) | 
|   boost::geometry::traits::radius_type< Geometry > | Traits class indicating the type (double,float,...) of the radius of a circle or a sphere | 
|   boost::geometry::traits::resize< Range > | Traits class to append a point to a range (ring, linestring, multi*) | 
|   boost::geometry::traits::ring_const_type< Geometry > | Traits class to indicate ring-type of a polygon's exterior ring/interior rings | 
|   boost::geometry::traits::ring_mutable_type< Geometry > |  | 
|   boost::geometry::traits::rvalue_type< Range > | Metafunction to define the argument passed to the three traits classes clear, push_back and resize | 
|   boost::geometry::traits::tag< Geometry, Enable > | Traits class to attach a tag to a geometry | 
|   boost::geometry::traits::tag< geometry::detail::buffer::buffered_ring< Ring > > |  | 
|   boost::geometry::traits::tag< geometry::detail::buffer::buffered_ring_collection< Ring > > |  | 
|   boost::geometry::util::bare_type< T > |  | 
|   boost::geometry::util::calculation_type::geometric::binary< Geometry1, Geometry2, CalculationType, DefaultFloatingPointCalculationType, DefaultIntegralCalculationType > |  | 
|   boost::geometry::util::calculation_type::geometric::ternary< Geometry1, Geometry2, Geometry3, CalculationType, DefaultFloatingPointCalculationType, DefaultIntegralCalculationType > | Calculation type (ternary, for three geometry types) | 
|   boost::geometry::util::calculation_type::geometric::unary< Geometry, CalculationType, DefaultFloatingPointCalculationType, DefaultIntegralCalculationType > |  | 
|   boost::geometry::util::combine_if< Sequence1, Sequence2, Pred > | Meta-function to generate all the combination of pairs of types from a given sequence Sequence except those that does not satisfy the predicate Pred | 
|   boost::geometry::util::combine_if< Sequence1, Sequence2, Pred >::combine |  | 
|   boost::geometry::util::combine_if< Sequence1, Sequence2, Pred >::combine::apply< Result, T > |  | 
|   boost::geometry::util::detail::calculation_type< Type, CalculationType, DefaultFloatingPointCalculationType, DefaultIntegralCalculationType > |  | 
|   boost::geometry::util::detail::default_integral |  | 
|   boost::geometry::volumetric_tag | For volume types (also box (?), polyhedron) | 
|   boost::geometry::wkt_manipulator< Geometry > | Generic geometry template manipulator class, takes corresponding output class from traits class | 
|   iterator_adaptor |  | 
|    boost::geometry::point_iterator< Geometry > |  | 
|   iterator_facade |  | 
|    boost::geometry::closing_iterator< Range > | Iterator which iterates through a range, but adds first element at end of the range | 
|    boost::geometry::concatenate_iterator< Iterator1, Iterator2, Value, Reference > |  | 
|    boost::geometry::ever_circling_range_iterator< Range > |  | 
|    boost::geometry::flatten_iterator< OuterIterator, InnerIterator, Value, AccessInnerBegin, AccessInnerEnd, Reference > |  | 
|   and_ |  | 
|    boost::geometry::fusion_adapt_detail::is_fusion_sequence< Sequence > |  | 
|   bool_ |  | 
|    boost::geometry::fusion_adapt_detail::all_same< Sequence > |  | 
|    boost::geometry::fusion_adapt_detail::is_coordinate_size< Sequence > |  | 
|   fold |  | 
|    boost::geometry::detail::unique_types< Variant > |  | 
|   if_ |  | 
|    boost::geometry::detail::variant_or_single< Types > |  | 
|    boost::geometry::detail::variant_or_single< detail::unique_types< Variant >::type > |  | 
|     boost::geometry::compress_variant< Variant > | Meta-function that takes a boost::variant type and tries to minimize it by doing the following: | 
|   noncopyable |  | 
|    boost::geometry::svg_mapper< Point, SameScale, SvgCoordinateType > | Helper class to create SVG maps | 
|   boost::numeric::bounds< rational< T > > |  | 
|   boost::numeric::converter< double, rational< T >, Traits, OverflowHandler, Float2IntRounder, RawConverter, UserRangeChecker > |  | 
|   boost::numeric::converter< int, rational< T >, Traits, OverflowHandler, Float2IntRounder, RawConverter, UserRangeChecker > |  | 
|   static_visitor |  | 
|    boost::geometry::resolve_variant::append< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< RangeOrPoint > |  | 
|    boost::geometry::resolve_variant::area< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::assign< Geometry1, variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::assign< variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor |  | 
|    boost::geometry::resolve_variant::assign< variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, variant< BOOST_VARIANT_ENUM_PARAMS(T2)> >::visitor |  | 
|    boost::geometry::resolve_variant::buffer< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Distance, GeometryOut > |  | 
|    boost::geometry::resolve_variant::centroid< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Point, Strategy > |  | 
|    boost::geometry::resolve_variant::clear< variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::comparable_distance< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::comparable_distance< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T2)> >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::comparable_distance< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::convert< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor |  | 
|    boost::geometry::resolve_variant::convex_hull< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< OutputGeometry, Strategy > |  | 
|    boost::geometry::resolve_variant::convex_hull_insert< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< OutputIterator, Strategy > |  | 
|    boost::geometry::resolve_variant::correct< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::covered_by< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::variant< BOOST_VARIANT_ENUM_PARAMS(T2)>>::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::covered_by< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::crosses< Geometry1, variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::crosses< variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor |  | 
|    boost::geometry::resolve_variant::crosses< variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, variant< BOOST_VARIANT_ENUM_PARAMS(T2)> >::visitor |  | 
|    boost::geometry::resolve_variant::disjoint< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor |  | 
|    boost::geometry::resolve_variant::variant< BOOST_VARIANT_ENUM_PARAMS(T2)>>::visitor |  | 
|    boost::geometry::resolve_variant::disjoint< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::distance< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T2)> >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::distance< Geometry1, variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::distance< variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::envelope< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Box > |  | 
|    boost::geometry::resolve_variant::equals< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor |  | 
|    boost::geometry::resolve_variant::variant< BOOST_VARIANT_ENUM_PARAMS(T2)>>::visitor |  | 
|    boost::geometry::resolve_variant::equals< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::expand< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Box > |  | 
|    boost::geometry::resolve_variant::intersection< Geometry1, variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< GeometryOut > |  | 
|    boost::geometry::resolve_variant::intersection< variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor< GeometryOut > |  | 
|    boost::geometry::resolve_variant::intersection< variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, variant< BOOST_VARIANT_ENUM_PARAMS(T2)> >::visitor< GeometryOut > |  | 
|    boost::geometry::resolve_variant::is_empty< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::is_simple< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::is_valid< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< VisitPolicy > |  | 
|    boost::geometry::resolve_variant::length< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::num_geometries< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::num_interior_rings< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::num_points< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::num_segments< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::perimeter< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::relate< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor< Mask > |  | 
|    boost::geometry::resolve_variant::variant< BOOST_VARIANT_ENUM_PARAMS(T2)>>::visitor< Mask > |  | 
|    boost::geometry::resolve_variant::relate< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Mask > |  | 
|    boost::geometry::resolve_variant::relation< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor< Matrix > |  | 
|    boost::geometry::resolve_variant::relation< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T2)> >::visitor< Matrix > |  | 
|    boost::geometry::resolve_variant::relation< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Matrix > |  | 
|    boost::geometry::resolve_variant::remove_spikes< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::reverse< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::self_touches< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::simplify< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Distance, Strategy > |  | 
|    boost::geometry::resolve_variant::touches< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor |  | 
|    boost::geometry::resolve_variant::touches< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T1)>, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T2)> >::visitor |  | 
|    boost::geometry::resolve_variant::touches< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor |  | 
|    boost::geometry::resolve_variant::transform< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::within< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2 >::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::variant< BOOST_VARIANT_ENUM_PARAMS(T2)>>::visitor< Strategy > |  | 
|    boost::geometry::resolve_variant::within< Geometry1, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::visitor< Strategy > |  | 
|   true_type |  | 
|    boost::geometry::is_radian< CoordinateSystem > | Meta-function to verify if a coordinate system is radian | 
|   boost::geometry::strategy::within::box_longitude_range< Geometry, box_covered_by_coord, box_covered_by_longitude_diff > |  | 
|    boost::geometry::strategy::within::box_covered_by_range< Geometry, 0, spherical_tag > |  | 
|   boost::geometry::strategy::within::box_longitude_range< Geometry, box_within_coord, box_within_longitude_diff > |  | 
|    boost::geometry::strategy::within::box_within_range< Geometry, 0, spherical_tag > |  | 
|   Container |  | 
|    boost::geometry::model::linestring< Point, Container, Allocator > | A linestring (named so by OGC) is a collection (default a vector) of points | 
|    boost::geometry::model::multi_linestring< LineString, Container, Allocator > | Multi_line, a collection of linestring | 
|    boost::geometry::model::multi_point< Point, Container, Allocator > | Multi_point, a collection of points | 
|    boost::geometry::model::multi_polygon< Polygon, Container, Allocator > | Multi_polygon, a collection of polygons | 
|    boost::geometry::model::ring< Point, ClockWise, Closed, Container, Allocator > | A ring (aka linear ring) is a closed line which should not be selfintersecting | 
|   dimension |  | 
|    boost::geometry::dimension< Geometry > | Metafunction defining [*value] as the number of coordinates (the number of axes of any geometry) of the point type making up the specified geometry type | 
|   geometry_id |  | 
|    boost::geometry::geometry_id< Geometry > | Meta-function returning the id of a geometry type | 
|   is_areal |  | 
|    boost::geometry::is_areal< Geometry > | Meta-function defining "true" for areal types (box, (multi)polygon, ring), | 
|   top_dim |  | 
|    boost::geometry::topological_dimension< Geometry > | Meta-function returning the topological dimension of a geometry | 
|   copy_segment_point_multi |  | 
|    boost::geometry::dispatch::copy_segment_point< detail::buffer::buffered_ring_collection_tag, MultiRing, Reverse, SegmentIdentifier, PointOut > |  | 
|   copy_segments_multi |  | 
|    boost::geometry::dispatch::copy_segments< detail::buffer::buffered_ring_collection_tag, Reverse > |  | 
|   envelope_multi_range |  | 
|    boost::geometry::dispatch::envelope< Geometry, detail::buffer::buffered_ring_collection_tag > |  | 
|   multi_is_empty |  | 
|    boost::geometry::dispatch::is_empty< Geometry, detail::buffer::buffered_ring_collection_tag > |  | 
|   iterator_base |  | 
|    boost::geometry::ever_circling_iterator< Iterator > | Iterator which ever circles through a range | 
|   points_view |  | 
|    boost::geometry::box_view< Box, Clockwise > | Makes a box behave like a ring or a range | 
|    boost::geometry::segment_view< Segment > | Makes a segment behave like a linestring or a range | 
|   rad_rotate_transformer |  | 
|    boost::geometry::strategy::transform::rotate_transformer< DegreeOrRadian, CalculationType, Dimension1, Dimension2 > | Strategy for rotate transformation in Cartesian coordinate system | 
|   mask |  | 
|    boost::geometry::de9im::mask | DE-9IM model intersection mask | 
|   matrix |  | 
|    boost::geometry::de9im::matrix | DE-9IM model intersection matrix | 
|   static_mask |  | 
|    boost::geometry::de9im::static_mask< II, IB, IE, BI, BB, BE, EI, EB, EE > | DE-9IM model intersection mask (static version) | 
|   reverse_dispatch |  | 
|    boost::geometry::reverse_dispatch< Geometry1, Geometry2 > |  | 
|   type |  | 
|    boost::geometry::segment_iterator< Geometry > |  | 
|   compare_geometries |  | 
|    boost::geometry::equal_to< Point, Dimension, Strategy > | Equal To functor, to compare if points are equal | 
|    boost::geometry::greater< Point, Dimension, Strategy > | Greater functor | 
|    boost::geometry::less< Point, Dimension, Strategy > | Less functor, to sort points in ascending order | 
|   boost::geometry::strategy::distance::haversine< calculation_type > |  | 
|   boost::geometry::strategy::within::longitude_range< Geometry, covered_by_coord, covered_by_longitude_diff > |  | 
|    boost::geometry::strategy::within::covered_by_range< Geometry, 0, spherical_tag > |  | 
|   boost::geometry::strategy::within::longitude_range< Geometry, within_coord, within_longitude_diff > |  | 
|    boost::geometry::strategy::within::within_range< Geometry, 0, spherical_tag > |  | 
|   make_variant_over |  | 
|    boost::geometry::transform_variant< Sequence, Op, In > | 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 | 
|    boost::geometry::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 | 
|   boost::geometry::nyi::not_implemented_error< boost::mpl::identity< nyi::tag_to_term< Geometry >::type >::type, boost::mpl::identity< nyi::tag_to_term< void >::type >::type, boost::mpl::identity< nyi::tag_to_term< void >::type >::type > |  | 
|    boost::geometry::not_implemented< Geometry > |  | 
|   boost::geometry::nyi::not_implemented_error< boost::mpl::identity< nyi::tag_to_term< Term1 >::type >::type, boost::mpl::identity< nyi::tag_to_term< Term2 >::type >::type, boost::mpl::identity< nyi::tag_to_term< Term3 >::type >::type > |  | 
|    boost::geometry::not_implemented< Term1, Term2, Term3 > |  | 
|   boost::geometry::model::point< CoordinateType, 2, CoordinateSystem > |  | 
|    boost::geometry::model::d2::point_xy< CoordinateType, CoordinateSystem > | 2D point in Cartesian coordinate system | 
|   boost::geometry::model::point< T, 2, cs_type > |  | 
|   boost::geometry::model::point< T, 3, cs::cartesian > |  | 
|   boost::geometry::model::point< Type, DimensionCount, cs::cartesian > |  | 
|   boost::geometry::point_type< boost::mpl::front< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>::types >::type > |  | 
|    boost::geometry::point_type< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> > |  | 
|   PointList |  | 
|    boost::geometry::model::ring< Point, ClockWise, Closed, PointList, PointAlloc > |  | 
|   boost::geometry::promote_floating_point< select_calculation_type< Point, PointOfSegment, CalculationType >::type > |  | 
|    boost::geometry::strategy::distance::comparable::cross_track< CalculationType, Strategy >::return_type< Point, PointOfSegment > |  | 
|    boost::geometry::strategy::distance::cross_track< CalculationType, Strategy >::return_type< Point, PointOfSegment > |  | 
|   boost::geometry::promote_floating_point< select_calculation_type< Point1, Point2, CalculationType >::type > |  | 
|    boost::geometry::strategy::distance::comparable::haversine< RadiusType, CalculationType >::calculation_type< Point1, Point2 > |  | 
|   boost::geometry::promote_floating_point< strategy::distance::services::return_type< Strategy, Point, PointOfSegment >::type > |  | 
|    boost::geometry::strategy::distance::projected_point< CalculationType, Strategy >::calculation_type< Point, PointOfSegment > |  | 
|   boost::geometry::strategy::distance::services::return_type< comparable_type, Point1, Point2 > |  | 
|    boost::geometry::strategy::distance::haversine< RadiusType, CalculationType >::calculation_type< Point1, Point2 > |  | 
|   boost::geometry::strategy::distance::services::return_type< detail::distance::default_strategy< Geometry1, Geometry2 >::type, point_type< Geometry1 >::type, point_type< Geometry2 >::type > |  | 
|    boost::geometry::resolve_strategy::distance_result< Geometry1, Geometry2, detail::distance::default_strategy< Geometry1, Geometry2 >::type > |  | 
|     boost::geometry::resolve_strategy::distance_result< Geometry1, Geometry2, default_strategy > |  | 
|      boost::geometry::resolve_variant::distance_result< Geometry1, Geometry2, default_strategy > |  | 
|       boost::geometry::distance_result< Geometry1, Geometry2, default_strategy > |  | 
|   boost::geometry::strategy::distance::services::return_type< Strategy, Point, point_type< Box >::type > |  | 
|    boost::geometry::strategy::distance::cross_track_point_box< CalculationType, Strategy >::return_type< Point, Box > |  | 
|   boost::geometry::strategy::distance::services::return_type< Strategy, point_type< Geometry1 >::type, point_type< Geometry2 >::type > |  | 
|    boost::geometry::resolve_strategy::distance_result< Geometry1, Geometry2, Strategy > |  | 
|     boost::geometry::resolve_variant::distance_result< Geometry1, Geometry2, Strategy > |  | 
|      boost::geometry::distance_result< Geometry1, Geometry2, Strategy > | Meta-function defining return type of distance function | 
|       boost::geometry::distance_result< Geometry1, Geometry2, void > |  | 
|        boost::geometry::default_distance_result< Geometry1, Geometry2 > | Meta-function defining return type of distance function | 
|   boost::geometry::strategy::distance::services::return_type< Strategy, point_type< Geometry2 >::type, point_type< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::type > |  | 
|    boost::geometry::resolve_strategy::distance_result< Geometry2, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy > |  | 
|     boost::geometry::resolve_variant::distance_result< Geometry2, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy > |  | 
|      boost::geometry::resolve_variant::distance_result< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2, Strategy > |  | 
|   boost::geometry::strategy::distance::services::return_type< strategy::distance::services::comparable_type< detail::distance::default_strategy< Geometry1, Geometry2 >::type >::type, point_type< Geometry1 >::type, point_type< Geometry2 >::type > |  | 
|    boost::geometry::resolve_strategy::comparable_distance_result< Geometry1, Geometry2, detail::distance::default_strategy< Geometry1, Geometry2 >::type > |  | 
|     boost::geometry::resolve_strategy::comparable_distance_result< Geometry1, Geometry2, default_strategy > |  | 
|      boost::geometry::resolve_variant::comparable_distance_result< Geometry1, Geometry2, default_strategy > |  | 
|       boost::geometry::comparable_distance_result< Geometry1, Geometry2, default_strategy > |  | 
|        boost::geometry::comparable_distance_result< Geometry1, Geometry2, void > |  | 
|         boost::geometry::default_comparable_distance_result< Geometry1, Geometry2 > | Meta-function defining return type of comparable_distance function | 
|   boost::geometry::strategy::distance::services::return_type< strategy::distance::services::comparable_type< Strategy >::type, point_type< Geometry1 >::type, point_type< Geometry2 >::type > |  | 
|    boost::geometry::resolve_strategy::comparable_distance_result< Geometry1, Geometry2, Strategy > |  | 
|     boost::geometry::resolve_variant::comparable_distance_result< Geometry1, Geometry2, Strategy > |  | 
|      boost::geometry::comparable_distance_result< Geometry1, Geometry2, Strategy > | Meta-function defining return type of comparable_distance function | 
|   boost::geometry::strategy::distance::services::return_type< strategy::distance::services::comparable_type< Strategy >::type, point_type< Geometry2 >::type, point_type< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)> >::type > |  | 
|    boost::geometry::resolve_strategy::comparable_distance_result< Geometry2, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy > |  | 
|     boost::geometry::resolve_variant::comparable_distance_result< Geometry2, boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy > |  | 
|      boost::geometry::resolve_variant::comparable_distance_result< boost::variant< BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2, Strategy > |  | 
|   boost::geometry::select_calculation_type< Point, PointOfSegment, CalculationType > |  | 
|   std::exception | STL class | 
|    boost::geometry::exception | Base exception class for Boost.Geometry algorithms | 
|     boost::geometry::centroid_exception | Centroid Exception | 
|     boost::geometry::inconsistent_turns_exception |  | 
|     boost::geometry::invalid_input_exception | Invalid Input Exception | 
|      boost::geometry::empty_input_exception | Empty Input Exception | 
|     boost::geometry::overlay_invalid_input_exception | Overlay Invalid Input Exception | 
|     boost::geometry::read_wkt_exception | Exception showing things wrong with WKT parsing | 
|     boost::geometry::turn_info_exception |  | 
|   iterator |  | 
|    boost::geometry::range::back_insert_iterator< Container > |  | 
|   pair |  | 
|    boost::geometry::model::segment< Point > | Class segment: small class containing two points | 
|   reverse_iterator |  | 
|    boost::geometry::point_reverse_iterator< Geometry > |  | 
|   std::vector< T > | STL class | 
|    boost::geometry::sections< Box, DimensionCount > | Structure containing a collection of sections |