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