|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r84840 - in trunk/boost/geometry/index: . detail detail/algorithms detail/rtree/linear detail/rtree/quadratic detail/rtree/rstar detail/rtree/utilities
From: adam.wulkiewicz_at_[hidden]
Date: 2013-06-19 19:00:12
Author: awulkiew
Date: 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013)
New Revision: 84840
URL: http://svn.boost.org/trac/boost/changeset/84840
Log:
[geometry][index]: implemented version of linear find_greatest_normalized_separation optimized for Points. Removed index::detail::traits, the official ones used instead.
Deleted:
trunk/boost/geometry/index/detail/indexable.hpp
Text files modified:
trunk/boost/geometry/index/detail/algorithms/comparable_distance_centroid.hpp | 8 +-
trunk/boost/geometry/index/detail/algorithms/comparable_distance_far.hpp | 8 +-
trunk/boost/geometry/index/detail/algorithms/comparable_distance_near.hpp | 8 +-
trunk/boost/geometry/index/detail/algorithms/content.hpp | 6 -
trunk/boost/geometry/index/detail/algorithms/diff_abs.hpp | 17 ++++
trunk/boost/geometry/index/detail/algorithms/is_valid.hpp | 12 +--
trunk/boost/geometry/index/detail/algorithms/margin.hpp | 2
trunk/boost/geometry/index/detail/algorithms/minmaxdist.hpp | 8 +-
trunk/boost/geometry/index/detail/algorithms/path_intersection.hpp | 12 +-
trunk/boost/geometry/index/detail/algorithms/segment_intersection.hpp | 20 ++---
trunk/boost/geometry/index/detail/algorithms/sum_for_indexable.hpp | 2
/dev/null | 139 ---------------------------------------
trunk/boost/geometry/index/detail/rtree/linear/redistribute_elements.hpp | 140 ++++++++++++++++++++++++++++++---------
trunk/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp | 4
trunk/boost/geometry/index/detail/rtree/rstar/redistribute_elements.hpp | 56 ++++++++++++---
trunk/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp | 24 +++---
trunk/boost/geometry/index/detail/rtree/utilities/print.hpp | 6
trunk/boost/geometry/index/detail/rtree/utilities/statistics.hpp | 1
trunk/boost/geometry/index/rtree.hpp | 10 ++
19 files changed, 228 insertions(+), 255 deletions(-)
Modified: trunk/boost/geometry/index/detail/algorithms/comparable_distance_centroid.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/comparable_distance_centroid.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/comparable_distance_centroid.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -42,8 +42,8 @@
inline static result_type apply(Point const& pt, BoxIndexable const& i)
{
- typedef typename index::detail::traits::coordinate_type<Point>::type point_coord_t;
- typedef typename index::detail::traits::coordinate_type<BoxIndexable>::type indexable_coord_t;
+ typedef typename coordinate_type<Point>::type point_coord_t;
+ typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);
@@ -65,9 +65,9 @@
return detail::sum_for_indexable<
Point,
Indexable,
- typename index::detail::traits::tag<Indexable>::type,
+ typename tag<Indexable>::type,
detail::comparable_distance_centroid_tag,
- index::detail::traits::dimension<Indexable>::value
+ dimension<Indexable>::value
>::apply(pt, i);
}
Modified: trunk/boost/geometry/index/detail/algorithms/comparable_distance_far.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/comparable_distance_far.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/comparable_distance_far.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -30,8 +30,8 @@
inline static result_type apply(Point const& pt, BoxIndexable const& i)
{
- typedef typename index::detail::traits::coordinate_type<Point>::type point_coord_t;
- typedef typename index::detail::traits::coordinate_type<BoxIndexable>::type indexable_coord_t;
+ typedef typename coordinate_type<Point>::type point_coord_t;
+ typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);
@@ -55,9 +55,9 @@
return detail::sum_for_indexable<
Point,
Indexable,
- typename index::detail::traits::tag<Indexable>::type,
+ typename tag<Indexable>::type,
detail::comparable_distance_far_tag,
- index::detail::traits::dimension<Indexable>::value
+ dimension<Indexable>::value
>::apply(pt, i);
}
Modified: trunk/boost/geometry/index/detail/algorithms/comparable_distance_near.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/comparable_distance_near.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/comparable_distance_near.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -41,8 +41,8 @@
inline static result_type apply(Point const& pt, BoxIndexable const& i)
{
- typedef typename index::detail::traits::coordinate_type<Point>::type point_coord_t;
- typedef typename index::detail::traits::coordinate_type<BoxIndexable>::type indexable_coord_t;
+ typedef typename coordinate_type<Point>::type point_coord_t;
+ typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);
@@ -66,9 +66,9 @@
return detail::sum_for_indexable<
Point,
Indexable,
- typename index::detail::traits::tag<Indexable>::type,
+ typename tag<Indexable>::type,
detail::comparable_distance_near_tag,
- index::detail::traits::dimension<Indexable>::value
+ dimension<Indexable>::value
>::apply(pt, i);
}
Modified: trunk/boost/geometry/index/detail/algorithms/content.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/content.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/content.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -11,8 +11,6 @@
#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_CONTENT_HPP
#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_CONTENT_HPP
-#include <boost/geometry/index/detail/indexable.hpp>
-
namespace boost { namespace geometry { namespace index { namespace detail {
template <typename Indexable>
@@ -35,7 +33,7 @@
static inline typename detail::default_content_result<Box>::type apply(Box const& b)
{
return content_box<Box, CurrentDimension - 1>::apply(b) *
- ( detail::get<max_corner, CurrentDimension - 1>(b) - detail::get<min_corner, CurrentDimension - 1>(b) );
+ ( get<max_corner, CurrentDimension - 1>(b) - get<min_corner, CurrentDimension - 1>(b) );
}
};
@@ -44,7 +42,7 @@
{
static inline typename detail::default_content_result<Box>::type apply(Box const& b)
{
- return detail::get<max_corner, 0>(b) - detail::get<min_corner, 0>(b);
+ return get<max_corner, 0>(b) - get<min_corner, 0>(b);
}
};
Modified: trunk/boost/geometry/index/detail/algorithms/diff_abs.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/diff_abs.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/diff_abs.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -14,11 +14,26 @@
namespace boost { namespace geometry { namespace index { namespace detail {
template <typename T>
-inline T diff_abs(T const& v1, T const& v2)
+inline T diff_abs_dispatch(T const& v1, T const& v2, boost::mpl::bool_<true> const& /*is_integral*/)
{
return v1 < v2 ? v2 - v1 : v1 - v2;
}
+template <typename T>
+inline T diff_abs_dispatch(T const& v1, T const& v2, boost::mpl::bool_<false> const& /*is_integral*/)
+{
+ return ::fabs(v1 - v2);
+}
+
+template <typename T>
+inline T diff_abs(T const& v1, T const& v2)
+{
+ typedef boost::mpl::bool_<
+ boost::is_integral<T>::value
+ > is_integral;
+ return diff_abs_dispatch(v1, v2, is_integral());
+}
+
}}}} // namespace boost::geometry::index::detail
#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_DIFF_ABS_HPP
Modified: trunk/boost/geometry/index/detail/algorithms/is_valid.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/is_valid.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/is_valid.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -11,8 +11,6 @@
#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_IS_VALID_HPP
#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_IS_VALID_HPP
-#include <boost/geometry/index/detail/indexable.hpp>
-
namespace boost { namespace geometry { namespace index { namespace detail {
namespace dispatch {
@@ -21,14 +19,14 @@
struct is_valid_box
{
BOOST_MPL_ASSERT_MSG(
- (0 < Dimension && Dimension <= detail::traits::dimension<Box>::value),
+ (0 < Dimension && Dimension <= dimension<Box>::value),
INVALID_DIMENSION_PARAMETER,
(is_valid_box));
static inline bool apply(Box const& b)
{
return is_valid_box<Box, Dimension - 1>::apply(b) &&
- ( detail::get<min_corner, Dimension - 1>(b) <= detail::get<max_corner, Dimension - 1>(b) );
+ ( get<min_corner, Dimension - 1>(b) <= get<max_corner, Dimension - 1>(b) );
}
};
@@ -37,7 +35,7 @@
{
static inline bool apply(Box const& b)
{
- return detail::get<min_corner, 0>(b) <= detail::get<max_corner, 0>(b);
+ return get<min_corner, 0>(b) <= get<max_corner, 0>(b);
}
};
@@ -64,7 +62,7 @@
{
static inline bool apply(Indexable const& b)
{
- return dispatch::is_valid_box<Indexable, detail::traits::dimension<Indexable>::value>::apply(b);
+ return dispatch::is_valid_box<Indexable, dimension<Indexable>::value>::apply(b);
}
};
@@ -73,7 +71,7 @@
template <typename Indexable>
inline bool is_valid(Indexable const& b)
{
- return dispatch::is_valid<Indexable, typename detail::traits::tag<Indexable>::type>::apply(b);
+ return dispatch::is_valid<Indexable, typename tag<Indexable>::type>::apply(b);
}
}}}} // namespace boost::geometry::index::detail
Modified: trunk/boost/geometry/index/detail/algorithms/margin.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/margin.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/margin.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -11,8 +11,6 @@
#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_MARGIN_HPP
#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_MARGIN_HPP
-#include <boost/geometry/index/detail/indexable.hpp>
-
// WARNING! comparable_margin() will work only if the same Geometries are compared
// so it shouldn't be used in the case of Variants!
Modified: trunk/boost/geometry/index/detail/algorithms/minmaxdist.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/minmaxdist.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/minmaxdist.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -32,8 +32,8 @@
inline static result_type apply(Point const& pt, BoxIndexable const& i, result_type const& maxd)
{
- typedef typename index::traits::coordinate_type<Point>::type point_coord_t;
- typedef typename index::traits::coordinate_type<BoxIndexable>::type indexable_coord_t;
+ typedef typename coordinate_type<Point>::type point_coord_t;
+ typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);
@@ -95,7 +95,7 @@
Indexable,
box_tag,
minmaxdist_tag,
- index::traits::dimension<Indexable>::value
+ dimension<Indexable>::value
>::apply(pt, i, maxd);
}
};
@@ -110,7 +110,7 @@
return detail::minmaxdist_impl<
Point,
Indexable,
- typename index::traits::tag<Indexable>::type
+ typename tag<Indexable>::type
>::apply(pt, i);
}
Modified: trunk/boost/geometry/index/detail/algorithms/path_intersection.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/path_intersection.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/path_intersection.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -26,11 +26,11 @@
template <typename Indexable, typename Segment>
struct path_intersection<Indexable, Segment, box_tag, segment_tag>
{
- typedef typename default_distance_result<typename ::boost::geometry::traits::point_type<Segment>::type>::type comparable_distance_type;
+ typedef typename default_distance_result<typename point_type<Segment>::type>::type comparable_distance_type;
static inline bool apply(Indexable const& b, Segment const& segment, comparable_distance_type & comparable_distance)
{
- typedef typename ::boost::geometry::traits::point_type<Segment>::type point_type;
+ typedef typename point_type<Segment>::type point_type;
point_type p1, p2;
geometry::detail::assign_point_from_index<0>(segment, p1);
geometry::detail::assign_point_from_index<1>(segment, p2);
@@ -90,8 +90,8 @@
{
typedef typename dispatch::path_intersection<
Indexable, SegmentOrLinestring,
- typename detail::traits::tag<Indexable>::type,
- typename detail::traits::tag<SegmentOrLinestring>::type
+ typename tag<Indexable>::type,
+ typename tag<SegmentOrLinestring>::type
>::comparable_distance_type type;
};
@@ -104,8 +104,8 @@
return dispatch::path_intersection<
Indexable, SegmentOrLinestring,
- typename detail::traits::tag<Indexable>::type,
- typename detail::traits::tag<SegmentOrLinestring>::type
+ typename tag<Indexable>::type,
+ typename tag<SegmentOrLinestring>::type
>::apply(b, path, comparable_distance);
}
Modified: trunk/boost/geometry/index/detail/algorithms/segment_intersection.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/segment_intersection.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/segment_intersection.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -11,8 +11,6 @@
#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SEGMENT_INTERSECTION_HPP
#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SEGMENT_INTERSECTION_HPP
-#include <boost/geometry/index/detail/indexable.hpp>
-
namespace boost { namespace geometry { namespace index { namespace detail {
//template <typename Indexable, typename Point>
@@ -20,8 +18,8 @@
//{
// typedef typename select_most_precise<
// typename select_most_precise<
-// typename traits::coordinate_type<Indexable>::type,
-// typename traits::coordinate_type<Point>::type
+// typename coordinate_type<Indexable>::type,
+// typename coordinate_type<Point>::type
// >::type,
// float // TODO - use bigger type, calculated from the size of coordinate types
// >::type type;
@@ -36,9 +34,9 @@
template <typename Box, typename Point, size_t I>
struct box_segment_intersection_dim
{
- BOOST_STATIC_ASSERT(I < traits::dimension<Box>::value);
- BOOST_STATIC_ASSERT(I < traits::dimension<Point>::value);
- BOOST_STATIC_ASSERT(traits::dimension<Point>::value == traits::dimension<Box>::value);
+ BOOST_STATIC_ASSERT(I < dimension<Box>::value);
+ BOOST_STATIC_ASSERT(I < dimension<Point>::value);
+ BOOST_STATIC_ASSERT(dimension<Point>::value == dimension<Box>::value);
// WARNING! - RelativeDistance must be IEEE float for this to work
@@ -47,8 +45,8 @@
RelativeDistance & t_near, RelativeDistance & t_far)
{
RelativeDistance ray_d = geometry::get<I>(p1) - geometry::get<I>(p0);
- RelativeDistance tn = ( detail::get<min_corner, I>(b) - geometry::get<I>(p0) ) / ray_d;
- RelativeDistance tf = ( detail::get<max_corner, I>(b) - geometry::get<I>(p0) ) / ray_d;
+ RelativeDistance tn = ( geometry::get<min_corner, I>(b) - geometry::get<I>(p0) ) / ray_d;
+ RelativeDistance tf = ( geometry::get<max_corner, I>(b) - geometry::get<I>(p0) ) / ray_d;
if ( tf < tn )
::std::swap(tn, tf);
@@ -105,7 +103,7 @@
template <typename Indexable, typename Point>
struct segment_intersection<Indexable, Point, box_tag>
{
- typedef dispatch::box_segment_intersection<Indexable, Point, detail::traits::dimension<Indexable>::value> impl;
+ typedef dispatch::box_segment_intersection<Indexable, Point, dimension<Indexable>::value> impl;
template <typename RelativeDistance>
static inline bool apply(Indexable const& b, Point const& p0, Point const& p1, RelativeDistance & relative_distance)
@@ -134,7 +132,7 @@
return dispatch::segment_intersection<
Indexable, Point,
- typename detail::traits::tag<Indexable>::type
+ typename tag<Indexable>::type
>::apply(b, p0, p1, relative_distance);
}
Modified: trunk/boost/geometry/index/detail/algorithms/sum_for_indexable.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/algorithms/sum_for_indexable.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/algorithms/sum_for_indexable.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -11,8 +11,6 @@
#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SUM_FOR_INDEXABLE_HPP
#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SUM_FOR_INDEXABLE_HPP
-#include <boost/geometry/index/detail/indexable.hpp>
-
namespace boost { namespace geometry { namespace index { namespace detail {
template <
Deleted: trunk/boost/geometry/index/detail/indexable.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/indexable.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84839)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,139 +0,0 @@
-// Boost.Geometry Index
-//
-// Indexable's traits and related functions
-//
-// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
-//
-// Use, modification and distribution is subject to the Boost Software License,
-// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_GEOMETRY_INDEX_DETAIL_INDEXABLE_HPP
-#define BOOST_GEOMETRY_INDEX_DETAIL_INDEXABLE_HPP
-
-namespace boost { namespace geometry { namespace index { namespace detail {
-
-namespace dispatch {
-
-template <typename Indexable, typename IndexableTag>
-struct point_type
-{
- typedef void type;
-};
-
-template <typename Indexable>
-struct point_type<Indexable, geometry::box_tag>
-{
- typedef typename geometry::traits::point_type<Indexable>::type type;
-};
-
-template <typename Indexable>
-struct point_type<Indexable, geometry::point_tag>
-{
- typedef Indexable type;
-};
-
-} // namespace dispatch
-
-namespace traits {
-
-template <typename Indexable>
-struct point_type
-{
- typedef typename dispatch::point_type<
- Indexable,
- typename geometry::traits::tag<Indexable>::type
- >::type type;
-};
-
-template <typename Indexable>
-struct coordinate_system
-{
- typedef typename geometry::traits::coordinate_system<
- typename point_type<Indexable>::type
- >::type type;
-};
-
-template <typename Indexable>
-struct coordinate_type
-{
- typedef typename geometry::traits::coordinate_type<
- typename point_type<Indexable>::type
- >::type type;
-};
-
-template <typename Indexable>
-struct dimension
-{
- static const size_t value =
- geometry::traits::dimension<
- typename point_type<Indexable>::type
- >::value;
-};
-
-template <typename Indexable>
-struct tag
-{
- typedef typename geometry::traits::tag<
- Indexable
- >::type type;
-};
-
-} // namespace traits
-
-namespace dispatch {
-
-template <size_t Corner, size_t DimensionIndex, typename Indexable, typename IndexableTag>
-struct indexable_indexed_access {};
-
-template <size_t Corner, size_t DimensionIndex, typename Indexable>
-struct indexable_indexed_access<Corner, DimensionIndex, Indexable, box_tag>
-{
- typedef typename traits::point_type<Indexable>::type point_type;
- typedef typename traits::coordinate_type<point_type>::type coordinate_type;
-
- static inline coordinate_type get(Indexable const& i)
- {
- return geometry::get<Corner, DimensionIndex>(i);
- }
-};
-
-template <size_t Corner, size_t DimensionIndex, typename Indexable>
-struct indexable_indexed_access<Corner, DimensionIndex, Indexable, point_tag>
-{
- typedef typename traits::coordinate_type<Indexable>::type coordinate_type;
-
- static inline coordinate_type get(Indexable const& i)
- {
- return geometry::get<DimensionIndex>(i);
- }
-};
-
-} // namespace dispatch
-
-template <size_t Corner, size_t DimensionIndex, typename Indexable>
-typename traits::coordinate_type<Indexable>::type get(Indexable const& i)
-{
- return dispatch::indexable_indexed_access<
- Corner,
- DimensionIndex,
- Indexable,
- typename geometry::traits::tag<Indexable>::type
- >::get(i);
-}
-
-template <typename Indexable>
-struct default_box_type
-{
- typedef geometry::model::box<
- geometry::model::point<
- typename traits::coordinate_type<Indexable>::type,
- traits::dimension<Indexable>::value,
- typename traits::coordinate_system<Indexable>::type
- >
- > type;
-};
-
-}}}} // namespace boost::geometry::index::detail
-
-#endif // BOOST_GEOMETRY_INDEX_DETAIL_INDEXABLE_HPP
Modified: trunk/boost/geometry/index/detail/rtree/linear/redistribute_elements.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/rtree/linear/redistribute_elements.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/rtree/linear/redistribute_elements.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -26,21 +26,49 @@
namespace linear {
+template <typename R, typename T>
+inline R difference_dispatch(T const& from, T const& to, ::boost::mpl::bool_<false> const& /*is_unsigned*/)
+{
+ return to - from;
+}
+
+template <typename R, typename T>
+inline R difference_dispatch(T const& from, T const& to, ::boost::mpl::bool_<true> const& /*is_unsigned*/)
+{
+ return from <= to ? R(to - from) : -R(from - to);
+}
+
+template <typename R, typename T>
+inline R difference(T const& from, T const& to)
+{
+ BOOST_MPL_ASSERT_MSG(!boost::is_unsigned<R>::value, RESULT_CANT_BE_UNSIGNED, (R));
+
+ typedef ::boost::mpl::bool_<
+ boost::is_unsigned<T>::value
+ > is_unsigned;
+
+ return difference_dispatch<R>(from, to, is_unsigned());
+}
+
// TODO: awulkiew - there are loops inside find_greatest_normalized_separation::apply()
// iteration is done for each DimensionIndex.
// Separations and seeds for all DimensionIndex(es) could be calculated at once, stored, then the greatest would be choosen.
-// TODO: Implement separate version for Points
-
// The following struct/method was adapted for the preliminary version of the R-tree. Then it was called:
// void find_normalized_separations(std::vector<Box> const& boxes, T& separation, unsigned int& first, unsigned int& second) const
-template <typename Elements, typename Parameters, typename Translator, size_t DimensionIndex>
+template <typename Elements, typename Parameters, typename Translator, typename Tag, size_t DimensionIndex>
struct find_greatest_normalized_separation
{
+ BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THIS_TAG, (Tag));
+};
+
+template <typename Elements, typename Parameters, typename Translator, size_t DimensionIndex>
+struct find_greatest_normalized_separation<Elements, Parameters, Translator, box_tag, DimensionIndex>
+{
typedef typename Elements::value_type element_type;
typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
- typedef typename index::detail::traits::coordinate_type<indexable_type>::type coordinate_type;
+ typedef typename coordinate_type<indexable_type>::type coordinate_type;
typedef typename boost::mpl::if_c<
boost::is_integral<coordinate_type>::value,
@@ -48,10 +76,6 @@
coordinate_type
>::type separation_type;
- typedef ::boost::mpl::bool_<
- boost::is_unsigned<coordinate_type>::value
- > is_coordinate_type_unsigned;
-
static inline void apply(Elements const& elements,
Parameters const& parameters,
Translator const& translator,
@@ -64,15 +88,15 @@
BOOST_GEOMETRY_INDEX_ASSERT(2 <= elements_count, "unexpected number of elements");
// find the lowest low, highest high
- coordinate_type lowest_low = index::detail::get<min_corner, DimensionIndex>(rtree::element_indexable(elements[0], translator));
- coordinate_type highest_high = index::detail::get<max_corner, DimensionIndex>(rtree::element_indexable(elements[0], translator));
+ coordinate_type lowest_low = geometry::get<min_corner, DimensionIndex>(rtree::element_indexable(elements[0], translator));
+ coordinate_type highest_high = geometry::get<max_corner, DimensionIndex>(rtree::element_indexable(elements[0], translator));
// and the lowest high
coordinate_type lowest_high = highest_high;
size_t lowest_high_index = 0;
for ( size_t i = 1 ; i < elements_count ; ++i )
{
- coordinate_type min_coord = index::detail::get<min_corner, DimensionIndex>(rtree::element_indexable(elements[i], translator));
- coordinate_type max_coord = index::detail::get<max_corner, DimensionIndex>(rtree::element_indexable(elements[i], translator));
+ coordinate_type min_coord = geometry::get<min_corner, DimensionIndex>(rtree::element_indexable(elements[i], translator));
+ coordinate_type max_coord = geometry::get<max_corner, DimensionIndex>(rtree::element_indexable(elements[i], translator));
if ( max_coord < lowest_high )
{
@@ -89,10 +113,10 @@
// find the highest low
size_t highest_low_index = lowest_high_index == 0 ? 1 : 0;
- coordinate_type highest_low = index::detail::get<min_corner, DimensionIndex>(rtree::element_indexable(elements[highest_low_index], translator));
+ coordinate_type highest_low = geometry::get<min_corner, DimensionIndex>(rtree::element_indexable(elements[highest_low_index], translator));
for ( size_t i = highest_low_index ; i < elements_count ; ++i )
{
- coordinate_type min_coord = index::detail::get<min_corner, DimensionIndex>(rtree::element_indexable(elements[i], translator));
+ coordinate_type min_coord = geometry::get<min_corner, DimensionIndex>(rtree::element_indexable(elements[i], translator));
if ( highest_low < min_coord &&
i != lowest_high_index )
{
@@ -103,7 +127,8 @@
coordinate_type const width = highest_high - lowest_low;
- separation = difference(highest_low, lowest_high, is_coordinate_type_unsigned());
+ // highest_low - lowest_high
+ separation = difference<separation_type>(lowest_high, highest_low);
// BOOST_ASSERT(0 <= width);
if ( std::numeric_limits<coordinate_type>::epsilon() < width )
separation /= width;
@@ -113,21 +138,60 @@
BOOST_GEOMETRY_INDEX_DETAIL_USE_PARAM(parameters)
}
+};
- static inline separation_type difference(coordinate_type const& highest_low,
- coordinate_type const& lowest_high,
- ::boost::mpl::bool_<false> const& /*is_unsigned*/)
- {
- return (highest_low - lowest_high);
- }
+// Version for points doesn't calculate normalized separation since it would always be equal to 1
+// It returns two seeds most distant to each other, separation is equal to distance
+template <typename Elements, typename Parameters, typename Translator, size_t DimensionIndex>
+struct find_greatest_normalized_separation<Elements, Parameters, Translator, point_tag, DimensionIndex>
+{
+ typedef typename Elements::value_type element_type;
+ typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+ typedef typename coordinate_type<indexable_type>::type coordinate_type;
+
+ typedef coordinate_type separation_type;
- static inline separation_type difference(coordinate_type const& highest_low,
- coordinate_type const& lowest_high,
- ::boost::mpl::bool_<true> const& /*is_unsigned*/)
+ static inline void apply(Elements const& elements,
+ Parameters const& parameters,
+ Translator const& translator,
+ separation_type & separation,
+ size_t & seed1,
+ size_t & seed2)
{
- return lowest_high <= highest_low ?
- separation_type(highest_low - lowest_high) :
- -separation_type(lowest_high - highest_low);
+ const size_t elements_count = parameters.get_max_elements() + 1;
+ BOOST_GEOMETRY_INDEX_ASSERT(elements.size() == elements_count, "unexpected number of elements");
+ BOOST_GEOMETRY_INDEX_ASSERT(2 <= elements_count, "unexpected number of elements");
+
+ // find the lowest low, highest high
+ coordinate_type lowest = geometry::get<DimensionIndex>(rtree::element_indexable(elements[0], translator));
+ coordinate_type highest = geometry::get<DimensionIndex>(rtree::element_indexable(elements[0], translator));
+ size_t lowest_index = 0;
+ size_t highest_index = 0;
+ for ( size_t i = 1 ; i < elements_count ; ++i )
+ {
+ coordinate_type coord = geometry::get<DimensionIndex>(rtree::element_indexable(elements[i], translator));
+
+ if ( coord < lowest )
+ {
+ lowest = coord;
+ lowest_index = i;
+ }
+
+ if ( highest < coord )
+ {
+ highest = coord;
+ highest_index = i;
+ }
+ }
+
+ separation = highest - lowest;
+ seed1 = lowest_index;
+ seed2 = highest_index;
+
+ if ( lowest_index == highest_index )
+ seed2 = (lowest_index + 1) % elements_count; // % is just in case since if this is true lowest_index is 0
+
+ BOOST_GEOMETRY_INDEX_DETAIL_USE_PARAM(parameters)
}
};
@@ -138,9 +202,13 @@
typedef typename Elements::value_type element_type;
typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
- typedef typename index::detail::traits::coordinate_type<indexable_type>::type coordinate_type;
+ typedef typename coordinate_type<indexable_type>::type coordinate_type;
+
+ typedef find_greatest_normalized_separation<
+ Elements, Parameters, Translator,
+ typename tag<indexable_type>::type, Dimension - 1
+ > find_norm_sep;
- typedef find_greatest_normalized_separation<Elements, Parameters, Translator, Dimension - 1> find_norm_sep;
typedef typename find_norm_sep::separation_type separation_type;
static inline void apply(Elements const& elements,
@@ -171,9 +239,13 @@
{
typedef typename Elements::value_type element_type;
typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
- typedef typename index::detail::traits::coordinate_type<indexable_type>::type coordinate_type;
+ typedef typename coordinate_type<indexable_type>::type coordinate_type;
+
+ typedef find_greatest_normalized_separation<
+ Elements, Parameters, Translator,
+ typename tag<indexable_type>::type, 0
+ > find_norm_sep;
- typedef find_greatest_normalized_separation<Elements, Parameters, Translator, 0> find_norm_sep;
typedef typename find_norm_sep::separation_type separation_type;
static inline void apply(Elements const& elements,
@@ -194,9 +266,9 @@
{
typedef typename Elements::value_type element_type;
typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
- typedef typename index::detail::traits::coordinate_type<indexable_type>::type coordinate_type;
+ typedef typename coordinate_type<indexable_type>::type coordinate_type;
- static const size_t dimension = index::detail::traits::dimension<indexable_type>::value;
+ static const size_t dimension = dimension<indexable_type>::value;
typedef pick_seeds_impl<Elements, Parameters, Translator, dimension> impl;
typedef typename impl::separation_type separation_type;
@@ -237,7 +309,7 @@
typedef typename rtree::elements_type<Node>::type elements_type;
typedef typename elements_type::value_type element_type;
typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
- typedef typename index::detail::traits::coordinate_type<indexable_type>::type coordinate_type;
+ typedef typename coordinate_type<indexable_type>::type coordinate_type;
typedef typename index::detail::default_content_result<Box>::type content_type;
elements_type & elements1 = rtree::elements(n);
Modified: trunk/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -31,7 +31,7 @@
{
typedef typename Elements::value_type element_type;
typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
- typedef typename index::detail::traits::coordinate_type<indexable_type>::type coordinate_type;
+ typedef typename coordinate_type<indexable_type>::type coordinate_type;
typedef Box box_type;
typedef typename index::detail::default_content_result<box_type>::type content_type;
@@ -100,7 +100,7 @@
typedef typename rtree::elements_type<Node>::type elements_type;
typedef typename elements_type::value_type element_type;
typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
- typedef typename index::detail::traits::coordinate_type<indexable_type>::type coordinate_type;
+ typedef typename coordinate_type<indexable_type>::type coordinate_type;
elements_type & elements1 = rtree::elements(n);
elements_type & elements2 = rtree::elements(second_node);
Modified: trunk/boost/geometry/index/detail/rtree/rstar/redistribute_elements.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/rtree/rstar/redistribute_elements.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/rtree/rstar/redistribute_elements.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -25,9 +25,33 @@
namespace rstar {
-template <typename Element, typename Translator, size_t Corner, size_t AxisIndex>
+template <typename Element, typename Translator, typename Tag, size_t Corner, size_t AxisIndex>
class element_axis_corner_less
{
+ BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THIS_TAG, (Tag));
+};
+
+template <typename Element, typename Translator, size_t Corner, size_t AxisIndex>
+class element_axis_corner_less<Element, Translator, box_tag, Corner, AxisIndex>
+{
+public:
+ element_axis_corner_less(Translator const& tr)
+ : m_tr(tr)
+ {}
+
+ bool operator()(Element const& e1, Element const& e2) const
+ {
+ return geometry::get<Corner, AxisIndex>(rtree::element_indexable(e1, m_tr))
+ < geometry::get<Corner, AxisIndex>(rtree::element_indexable(e2, m_tr));
+ }
+
+private:
+ Translator const& m_tr;
+};
+
+template <typename Element, typename Translator, size_t Corner, size_t AxisIndex>
+class element_axis_corner_less<Element, Translator, point_tag, Corner, AxisIndex>
+{
public:
element_axis_corner_less(Translator const& tr)
: m_tr(tr)
@@ -35,8 +59,8 @@
bool operator()(Element const& e1, Element const& e2) const
{
- return index::detail::get<Corner, AxisIndex>(rtree::element_indexable(e1, m_tr))
- < index::detail::get<Corner, AxisIndex>(rtree::element_indexable(e2, m_tr));
+ return geometry::get<AxisIndex>(rtree::element_indexable(e1, m_tr))
+ < geometry::get<AxisIndex>(rtree::element_indexable(e2, m_tr));
}
private:
@@ -59,6 +83,8 @@
Translator const& translator)
{
typedef typename Elements::value_type element_type;
+ typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+ typedef typename tag<indexable_type>::type indexable_tag;
BOOST_GEOMETRY_INDEX_ASSERT(elements.size() == parameters.get_max_elements() + 1, "wrong number of elements");
@@ -66,7 +92,7 @@
Elements elements_copy(elements); // MAY THROW, STRONG (alloc, copy)
// sort elements
- element_axis_corner_less<element_type, Translator, Corner, AxisIndex> elements_less(translator);
+ element_axis_corner_less<element_type, Translator, indexable_tag, Corner, AxisIndex> elements_less(translator);
std::sort(elements_copy.begin(), elements_copy.end(), elements_less); // MAY THROW, BASIC (copy)
// init outputs
@@ -106,7 +132,7 @@
template <typename Parameters, typename Box, size_t AxisIndex, typename ElementIndexableTag>
struct choose_split_axis_and_index_for_axis
{
- //BOOST_STATIC_ASSERT(0);
+ BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THIS_TAG, (ElementIndexableTag));
};
template <typename Parameters, typename Box, size_t AxisIndex>
@@ -227,7 +253,7 @@
Parameters,
Box,
Dimension - 1,
- typename index::detail::traits::tag<element_indexable_type>::type
+ typename tag<element_indexable_type>::type
>::apply(elements, corner, index, sum_of_margins, overlap_val, content_val, parameters, translator); // MAY THROW, STRONG
if ( sum_of_margins < smallest_sum_of_margins )
@@ -267,7 +293,7 @@
Parameters,
Box,
0,
- typename index::detail::traits::tag<element_indexable_type>::type
+ typename tag<element_indexable_type>::type
>::apply(elements, choosen_corner, choosen_index, smallest_sum_of_margins, smallest_overlap, smallest_content, parameters, translator); // MAY THROW
}
};
@@ -289,7 +315,10 @@
BOOST_GEOMETRY_INDEX_ASSERT(axis == Dimension - 1, "unexpected axis value");
typedef typename Elements::value_type element_type;
- element_axis_corner_less<element_type, Translator, Corner, Dimension - 1> less(tr);
+ typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+ typedef typename tag<indexable_type>::type indexable_tag;
+
+ element_axis_corner_less<element_type, Translator, indexable_tag, Corner, Dimension - 1> less(tr);
std::partial_sort(elements.begin(), elements.begin() + index, elements.end(), less); // MAY THROW, BASIC (copy)
}
}
@@ -307,7 +336,10 @@
BOOST_GEOMETRY_INDEX_ASSERT(axis == 0, "unexpected axis value");
typedef typename Elements::value_type element_type;
- element_axis_corner_less<element_type, Translator, Corner, 0> less(tr);
+ typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+ typedef typename tag<indexable_type>::type indexable_tag;
+
+ element_axis_corner_less<element_type, Translator, indexable_tag, Corner, 0> less(tr);
std::partial_sort(elements.begin(), elements.begin() + index, elements.end(), less); // MAY THROW, BASIC (copy)
}
};
@@ -323,7 +355,7 @@
typedef typename Options::parameters_type parameters_type;
- static const size_t dimension = index::detail::traits::dimension<Box>::value;
+ static const size_t dimension = dimension<Box>::value;
typedef typename index::detail::default_margin_result<Box>::type margin_type;
typedef typename index::detail::default_content_result<Box>::type content_type;
@@ -353,7 +385,7 @@
rstar::choose_split_axis_and_index<
typename Options::parameters_type,
Box,
- index::detail::traits::dimension<Box>::value
+ dimension
>::apply(elements1,
split_axis, split_corner, split_index,
smallest_sum_of_margins, smallest_overlap, smallest_content,
@@ -361,7 +393,7 @@
// TODO: awulkiew - get rid of following static_casts?
- BOOST_GEOMETRY_INDEX_ASSERT(split_axis < index::detail::traits::dimension<Box>::value, "unexpected value");
+ BOOST_GEOMETRY_INDEX_ASSERT(split_axis < dimension, "unexpected value");
BOOST_GEOMETRY_INDEX_ASSERT(split_corner == static_cast<size_t>(min_corner) || split_corner == static_cast<size_t>(max_corner), "unexpected value");
BOOST_GEOMETRY_INDEX_ASSERT(parameters.get_min_elements() <= split_index && split_index <= parameters.get_max_elements() - parameters.get_min_elements() + 1, "unexpected value");
Modified: trunk/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -11,8 +11,6 @@
#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_GL_DRAW_HPP
#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_GL_DRAW_HPP
-#include <boost/geometry/index/detail/indexable.hpp>
-
namespace boost { namespace geometry { namespace index { namespace detail {
namespace utilities {
@@ -26,7 +24,7 @@
template <typename Point>
struct gl_draw_point<Point, 2>
{
- static inline void apply(Point const& p, typename index::detail::traits::coordinate_type<Point>::type z)
+ static inline void apply(Point const& p, typename coordinate_type<Point>::type z)
{
glBegin(GL_POINT);
glVertex3f(geometry::get<0>(p), geometry::get<1>(p), z);
@@ -41,7 +39,7 @@
template <typename Box>
struct gl_draw_box<Box, 2>
{
- static inline void apply(Box const& b, typename index::detail::traits::coordinate_type<Box>::type z)
+ static inline void apply(Box const& b, typename coordinate_type<Box>::type z)
{
glBegin(GL_LINE_LOOP);
glVertex3f(geometry::get<min_corner, 0>(b), geometry::get<min_corner, 1>(b), z);
@@ -60,9 +58,9 @@
template <typename Indexable>
struct gl_draw_indexable<Indexable, box_tag>
{
- static const size_t dimension = index::detail::traits::dimension<Indexable>::value;
+ static const size_t dimension = dimension<Indexable>::value;
- static inline void apply(Indexable const& i, typename index::detail::traits::coordinate_type<Indexable>::type z)
+ static inline void apply(Indexable const& i, typename coordinate_type<Indexable>::type z)
{
gl_draw_box<Indexable, dimension>::apply(i, z);
}
@@ -71,9 +69,9 @@
template <typename Indexable>
struct gl_draw_indexable<Indexable, point_tag>
{
- static const size_t dimension = index::detail::traits::dimension<Indexable>::value;
+ static const size_t dimension = dimension<Indexable>::value;
- static inline void apply(Indexable const& i, typename index::detail::traits::coordinate_type<Indexable>::type z)
+ static inline void apply(Indexable const& i, typename coordinate_type<Indexable>::type z)
{
gl_draw_point<Indexable, dimension>::apply(i, z);
}
@@ -82,11 +80,11 @@
} // namespace dispatch
template <typename Indexable> inline
-void gl_draw_indexable(Indexable const& i, typename index::detail::traits::coordinate_type<Indexable>::type z)
+void gl_draw_indexable(Indexable const& i, typename coordinate_type<Indexable>::type z)
{
dispatch::gl_draw_indexable<
Indexable,
- typename index::detail::traits::tag<Indexable>::type
+ typename tag<Indexable>::type
>::apply(i, z);
}
@@ -105,7 +103,7 @@
inline gl_draw(Translator const& t,
size_t level_first = 0,
size_t level_last = (std::numeric_limits<size_t>::max)(),
- typename index::detail::traits::coordinate_type<Box>::type z_coord_level_multiplier = 1
+ typename coordinate_type<Box>::type z_coord_level_multiplier = 1
)
: tr(t)
, level_f(level_first)
@@ -182,7 +180,7 @@
Translator const& tr;
size_t level_f;
size_t level_l;
- typename index::detail::traits::coordinate_type<Box>::type z_mul;
+ typename coordinate_type<Box>::type z_mul;
size_t level;
};
@@ -193,7 +191,7 @@
void gl_draw(Rtree const& tree,
size_t level_first = 0,
size_t level_last = (std::numeric_limits<size_t>::max)(),
- typename index::detail::traits::coordinate_type<
+ typename coordinate_type<
typename Rtree::bounds_type
>::type z_coord_level_multiplier = 1
)
Modified: trunk/boost/geometry/index/detail/rtree/utilities/print.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/rtree/utilities/print.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/rtree/utilities/print.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -71,7 +71,7 @@
template <typename Indexable>
struct print_indexable<Indexable, box_tag>
{
- static const size_t dimension = index::detail::traits::dimension<Indexable>::value;
+ static const size_t dimension = dimension<Indexable>::value;
static inline void apply(std::ostream &os, Indexable const& i)
{
@@ -86,7 +86,7 @@
template <typename Indexable>
struct print_indexable<Indexable, point_tag>
{
- static const size_t dimension = index::detail::traits::dimension<Indexable>::value;
+ static const size_t dimension = dimension<Indexable>::value;
static inline void apply(std::ostream &os, Indexable const& i)
{
@@ -103,7 +103,7 @@
{
dispatch::print_indexable<
Indexable,
- typename geometry::traits::tag<Indexable>::type
+ typename tag<Indexable>::type
>::apply(os, i);
}
Modified: trunk/boost/geometry/index/detail/rtree/utilities/statistics.hpp
==============================================================================
--- trunk/boost/geometry/index/detail/rtree/utilities/statistics.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/detail/rtree/utilities/statistics.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -12,7 +12,6 @@
#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_STATISTICS_HPP
#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_STATISTICS_HPP
-#include <boost/geometry/index/detail/indexable.hpp>
#include <algorithm>
#include <tuple>
Modified: trunk/boost/geometry/index/rtree.hpp
==============================================================================
--- trunk/boost/geometry/index/rtree.hpp Wed Jun 19 14:04:20 2013 (r84839)
+++ trunk/boost/geometry/index/rtree.hpp 2013-06-19 19:00:12 EDT (Wed, 19 Jun 2013) (r84840)
@@ -29,7 +29,6 @@
#include <boost/geometry/index/indexable.hpp>
#include <boost/geometry/index/equal_to.hpp>
-#include <boost/geometry/index/detail/indexable.hpp>
#include <boost/geometry/index/detail/translator.hpp>
#include <boost/geometry/index/predicates.hpp>
@@ -143,7 +142,14 @@
>::type indexable_type;
/*! \brief The Box type used by the R-tree. */
- typedef typename index::detail::default_box_type<indexable_type>::type bounds_type;
+ typedef geometry::model::box<
+ geometry::model::point<
+ typename coordinate_type<indexable_type>::type,
+ dimension<indexable_type>::value,
+ typename coordinate_system<indexable_type>::type
+ >
+ >
+ bounds_type;
private:
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk