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