mirror of
https://github.com/boostorg/geometry.git
synced 2026-02-11 11:52:11 +00:00
551 lines
18 KiB
C++
551 lines
18 KiB
C++
// Boost.Geometry Index
|
|
// Additional tests
|
|
|
|
// Copyright (c) 2011-2012 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 TESTS_RTREE_FUNCTION_HPP
|
|
#define TESTS_RTREE_FUNCTION_HPP
|
|
|
|
#include <boost/geometry/geometry.hpp>
|
|
|
|
#include <boost/geometry/extensions/index/rtree/rtree.hpp>
|
|
#include <boost/geometry/extensions/index/translator/index.hpp>
|
|
#include <boost/geometry/extensions/index/inserter.hpp>
|
|
|
|
#include <boost/geometry/extensions/index/rtree/visitors/print.hpp>
|
|
|
|
#include <boost/range/algorithm.hpp>
|
|
#include <boost/foreach.hpp>
|
|
|
|
#include <map>
|
|
|
|
namespace helpers
|
|
{
|
|
|
|
template <typename Indexable, size_t DI, typename Tag>
|
|
struct value_randomizer_impl_set {};
|
|
|
|
template <typename Box, size_t DI>
|
|
struct value_randomizer_impl_set<Box, DI, boost::geometry::box_tag>
|
|
{
|
|
inline static void apply(
|
|
Box & b,
|
|
typename boost::geometry::index::traits::coordinate_type<Box>::type m,
|
|
typename boost::geometry::index::traits::coordinate_type<Box>::type w)
|
|
{
|
|
namespace bg = boost::geometry;
|
|
typedef typename bg::index::traits::coordinate_type<Box>::type coord_t;
|
|
|
|
coord_t c1 = ::rand() / coord_t(RAND_MAX / m);
|
|
coord_t c2 = ::rand() / coord_t(RAND_MAX / w);
|
|
|
|
bg::set<bg::min_corner, DI>(b, c1 - c2);
|
|
bg::set<bg::max_corner, DI>(b, c1 + c2);
|
|
}
|
|
};
|
|
|
|
template <typename Point, size_t DI>
|
|
struct value_randomizer_impl_set<Point, DI, boost::geometry::point_tag>
|
|
{
|
|
inline static void apply(
|
|
Point & p,
|
|
typename boost::geometry::index::traits::coordinate_type<Point>::type m,
|
|
typename boost::geometry::index::traits::coordinate_type<Point>::type)
|
|
{
|
|
namespace bg = boost::geometry;
|
|
typedef typename bg::index::traits::coordinate_type<Point>::type coord_t;
|
|
|
|
coord_t c = ::rand() / coord_t(RAND_MAX / m);
|
|
|
|
bg::set<DI>(p, c);
|
|
}
|
|
};
|
|
|
|
template <typename Indexable, size_t D>
|
|
struct value_randomizer_impl
|
|
{
|
|
inline static void apply(
|
|
Indexable & i,
|
|
typename boost::geometry::index::traits::coordinate_type<Indexable>::type m,
|
|
typename boost::geometry::index::traits::coordinate_type<Indexable>::type w)
|
|
{
|
|
value_randomizer_impl<Indexable, D - 1>::apply(i, m, w);
|
|
value_randomizer_impl_set<
|
|
Indexable,
|
|
D - 1,
|
|
typename boost::geometry::index::traits::tag<Indexable>::type
|
|
>::apply(i, m, w);
|
|
}
|
|
};
|
|
|
|
template <typename Indexable>
|
|
struct value_randomizer_impl<Indexable, 1>
|
|
{
|
|
inline static void apply(
|
|
Indexable & i,
|
|
typename boost::geometry::index::traits::coordinate_type<Indexable>::type m,
|
|
typename boost::geometry::index::traits::coordinate_type<Indexable>::type w)
|
|
{
|
|
value_randomizer_impl_set<
|
|
Indexable,
|
|
0,
|
|
typename boost::geometry::index::traits::tag<Indexable>::type
|
|
>::apply(i, m, w);
|
|
}
|
|
};
|
|
|
|
template <typename Indexable>
|
|
struct value_randomizer
|
|
{
|
|
typedef Indexable value_type;
|
|
|
|
typedef typename boost::geometry::index::traits::coordinate_type<Indexable>::type coord_t;
|
|
|
|
inline value_randomizer(coord_t mm, coord_t ww)
|
|
: m(mm), w(ww)
|
|
{}
|
|
|
|
inline Indexable operator()() const
|
|
{
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
Indexable i;
|
|
value_randomizer_impl<Indexable, bgi::traits::dimension<Indexable>::value>::apply(i, m, w);
|
|
return i;
|
|
}
|
|
|
|
coord_t m, w;
|
|
};
|
|
|
|
template <typename Rtree, typename Cont, typename Randomizer>
|
|
void random_insert(Rtree & t, Cont & c, size_t n, Randomizer r)
|
|
{
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
bgi::insert_iterator<Rtree> ii = bgi::inserter(t);
|
|
|
|
for ( size_t i = 0 ; i < n ; ++i )
|
|
{
|
|
typename Randomizer::value_type v = r();
|
|
//bgi::insert(t, v);
|
|
*ii++ = v;
|
|
c.push_back(v);
|
|
}
|
|
}
|
|
|
|
template <typename Cont, typename Translator>
|
|
bool results_compare(Cont const& c1, Cont const& c2, Translator const& tr)
|
|
{
|
|
if ( c1.size() != c2.size() )
|
|
return false;
|
|
|
|
for ( typename Cont::const_iterator it = c1.begin() ; it != c1.end() ; ++it )
|
|
{
|
|
bool found = false;
|
|
for ( typename Cont::const_iterator it2 = c2.begin() ; it2 != c2.end() ; ++it2 )
|
|
if ( tr.equals(*it, *it2) )
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
|
|
if ( !found )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename Point, typename Cont, typename Translator>
|
|
bool nearest_results_compare(Point const& p, Cont const& c1, Cont const& c2, Translator const& tr)
|
|
{
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = boost::geometry::index;
|
|
|
|
typedef typename bgi::translator::indexable_type<Translator>::type indexable_type;
|
|
typedef bg::default_distance_result<Point, indexable_type>::type distance_type;
|
|
|
|
if ( c1.size() != c2.size() )
|
|
return false;
|
|
|
|
if ( c1.size() == 0 && c2.size() == 0 )
|
|
return true;
|
|
|
|
distance_type biggest_distance1 = 0;
|
|
|
|
for ( typename Cont::const_iterator it = c1.begin() ; it != c1.end() ; ++it )
|
|
{
|
|
distance_type curr_distance = bgi::comparable_distance_near(p, tr(*it));
|
|
|
|
if ( biggest_distance1 < curr_distance )
|
|
biggest_distance1 = curr_distance;
|
|
}
|
|
|
|
distance_type biggest_distance2 = 0;
|
|
for ( typename Cont::const_iterator it = c2.begin() ; it != c2.end() ; ++it )
|
|
{
|
|
distance_type curr_distance = bgi::comparable_distance_near(p, tr(*it));
|
|
|
|
if ( biggest_distance2 < curr_distance )
|
|
biggest_distance2 = curr_distance;
|
|
}
|
|
|
|
return biggest_distance1 == biggest_distance2;
|
|
}
|
|
|
|
template <typename Point, typename Translator>
|
|
struct val_mindist_cmp
|
|
{
|
|
val_mindist_cmp(Point const& p, Translator const& t)
|
|
: pt(p), tr(t)
|
|
{}
|
|
|
|
template <typename Value>
|
|
bool operator()(Value const& v1, Value const& v2)
|
|
{
|
|
return boost::geometry::index::comparable_distance_near(pt, tr(v1))
|
|
< boost::geometry::index::comparable_distance_near(pt, tr(v2));
|
|
}
|
|
|
|
Point const& pt;
|
|
Translator const& tr;
|
|
};
|
|
|
|
template <typename Box, typename Iter, typename Translator>
|
|
Box values_box(Iter first, Iter last, Translator const& tr)
|
|
{
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
Box b;
|
|
bg::assign_inverse(b);
|
|
|
|
for ( ; first != last ; ++first )
|
|
{
|
|
bg::expand(b, tr(*first));
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
} // namespace helpers
|
|
|
|
template <typename Predicate, typename Rtree, typename Cont, typename Randomizer>
|
|
void random_query_check(Rtree const& t, Cont const& c, size_t n, Randomizer r)
|
|
{
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
for ( size_t i = 0 ; i < n ; ++i )
|
|
{
|
|
Predicate pred = Predicate(r());
|
|
|
|
std::vector<typename Rtree::value_type> res1, res2;
|
|
|
|
bgi::query(t, pred, std::back_inserter(res1));
|
|
|
|
for ( typename Cont::const_iterator it = c.begin() ; it != c.end() ; ++it )
|
|
{
|
|
if ( bgi::predicates_check<bgi::detail::rtree::value_tag>(pred, *it, t.translator()(*it)) )
|
|
res2.push_back(*it);
|
|
}
|
|
|
|
std::stringstream ss;
|
|
ss << "\nPredicate: " << typeid(Predicate).name() << "\n"
|
|
<< "res1: " << res1.size()
|
|
<< ", res2: " << res2.size()<< '\n';
|
|
|
|
BOOST_CHECK_MESSAGE( helpers::results_compare(res1, res2, t.translator()), ss.str());
|
|
}
|
|
}
|
|
|
|
template <typename Predicate, typename Rtree, typename Cont, typename PointRandomizer, typename PredicateRandomizer>
|
|
void random_nearest_check(
|
|
Rtree const& t,
|
|
Cont const& c,
|
|
size_t n,
|
|
PointRandomizer const& pr,
|
|
size_t k,
|
|
PredicateRandomizer const& r)
|
|
{
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
for ( size_t i = 0 ; i < n ; ++i )
|
|
{
|
|
typename PointRandomizer::value_type pt = pr();
|
|
Predicate pred = Predicate(r());
|
|
|
|
std::vector<typename Rtree::value_type> res1, res2;
|
|
|
|
bgi::nearest(t, pt, k, pred, std::back_inserter(res1));
|
|
|
|
for ( typename Cont::const_iterator it = c.begin() ; it != c.end() ; ++it )
|
|
{
|
|
if ( bgi::predicates_check<bgi::detail::rtree::value_tag>(pred, *it, t.translator()(*it)) )
|
|
res2.push_back(*it);
|
|
}
|
|
std::sort(
|
|
res2.begin(),
|
|
res2.end(),
|
|
helpers::val_mindist_cmp<
|
|
typename PointRandomizer::value_type,
|
|
typename Rtree::translator_type
|
|
>(pt, t.translator())
|
|
);
|
|
if ( k < res2.size() )
|
|
res2.resize(k);
|
|
|
|
std::stringstream ss;
|
|
ss << "\nPredicate: " << typeid(Predicate).name() << "\n"
|
|
<< "res1: " << res1.size()
|
|
<< ", res2: " << res2.size() << '\n';
|
|
|
|
BOOST_CHECK_MESSAGE(helpers::nearest_results_compare(pt, res1, res2, t.translator()), ss.str());
|
|
}
|
|
}
|
|
|
|
template <typename P, typename B, typename Tag>
|
|
struct tests_rtree_function_queries {};
|
|
|
|
template <typename P, typename B>
|
|
struct tests_rtree_function_queries<P, B, boost::geometry::point_tag>
|
|
{
|
|
template <typename Rtree, typename Cont>
|
|
inline static void apply(Rtree const& t, Cont const& v)
|
|
{
|
|
namespace bgi = boost::geometry::index;
|
|
|
|
random_query_check<B>(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::covered_by<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::disjoint<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::intersects<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::within<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::not_covered_by<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::not_disjoint<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::not_intersects<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::not_within<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
|
|
random_nearest_check<bgi::detail::empty>(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, bgi::empty);
|
|
random_nearest_check<B>(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
random_nearest_check<bgi::detail::intersects<B> >(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
random_nearest_check<bgi::detail::within<B> >(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
random_nearest_check<bgi::detail::covered_by<B> >(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
random_nearest_check<bgi::detail::disjoint<B> >(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
}
|
|
};
|
|
|
|
template <typename P, typename B>
|
|
struct tests_rtree_function_queries<P, B, boost::geometry::box_tag>
|
|
{
|
|
template <typename Rtree, typename Cont>
|
|
inline static void apply(Rtree const& t, Cont const& v)
|
|
{
|
|
namespace bgi = boost::geometry::index;
|
|
|
|
random_query_check<B>(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::covered_by<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::disjoint<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::intersects<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::overlaps<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::within<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::not_covered_by<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::not_disjoint<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::not_intersects<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::not_overlaps<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
random_query_check<bgi::detail::not_within<B> >(t, v, 5, helpers::value_randomizer<B>(10, 5));
|
|
|
|
random_nearest_check<bgi::detail::empty>(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, bgi::empty);
|
|
random_nearest_check<B>(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
random_nearest_check<bgi::detail::intersects<B> >(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
random_nearest_check<bgi::detail::overlaps<B> >(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
random_nearest_check<bgi::detail::within<B> >(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
random_nearest_check<bgi::detail::covered_by<B> >(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
random_nearest_check<bgi::detail::disjoint<B> >(t, v, 5, helpers::value_randomizer<P>(10, 0), 3, helpers::value_randomizer<B>(10, 5));
|
|
}
|
|
};
|
|
|
|
template <typename Value, typename Options, typename Translator>
|
|
void tests_rtree_function(Translator const& tr = Translator())
|
|
{
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
bgi::rtree<Value, Options, Translator> t(tr);
|
|
std::vector<Value> v;
|
|
|
|
typedef typename bgi::rtree<Value, Options, Translator>::indexable_type I;
|
|
typedef typename bgi::rtree<Value, Options, Translator>::box_type B;
|
|
typedef typename bgi::traits::point_type<B>::type P ;
|
|
|
|
helpers::random_insert(t, v, 10, helpers::value_randomizer<Value>(10, 1));
|
|
|
|
bgi::rtree<Value, Options, Translator> t_copy(t);
|
|
|
|
BOOST_CHECK(bgi::size(t) == 10);
|
|
BOOST_CHECK(bgi::size(t) == bgi::size(t_copy));
|
|
BOOST_CHECK(bg::equals(bgi::box(t), bgi::box(t_copy)));
|
|
|
|
B bt = bgi::box(t);
|
|
B bv = helpers::values_box<B>(v.begin(), v.end(), tr);
|
|
BOOST_CHECK(bg::equals(bt, bv));
|
|
|
|
tests_rtree_function_queries<P, B, bgi::traits::tag<I>::type>::apply(t, v);
|
|
|
|
bgi::clear(t);
|
|
BOOST_CHECK(bgi::empty(t));
|
|
bt = bgi::box(t);
|
|
B be;
|
|
bg::assign_inverse(be);
|
|
BOOST_CHECK(bg::equals(be, bt));
|
|
|
|
for ( size_t i = 3 ; i < 10 ; ++i )
|
|
bgi::remove(t_copy, v[i]);
|
|
v.erase(v.begin() + 3, v.end());
|
|
|
|
tests_rtree_function_queries<P, B, bgi::traits::tag<I>::type>::apply(t_copy, v);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(tests_rtree_function_box3f)
|
|
{
|
|
#ifdef TEST_PRINT_INFO
|
|
std::cout << "tests/rtree_function_box3f\n";
|
|
#endif
|
|
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
typedef bg::model::point<float, 3, bg::cs::cartesian> P;
|
|
typedef bg::model::box<P> B;
|
|
typedef B V;
|
|
|
|
tests_rtree_function< V, bgi::linear<4, 2>, bgi::translator::def<V> >();
|
|
tests_rtree_function< V, bgi::quadratic<4, 2>, bgi::translator::def<V> >();
|
|
tests_rtree_function< V, bgi::rstar<4, 2>, bgi::translator::def<V> >();
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(tests_rtree_function_box2f)
|
|
{
|
|
#ifdef TEST_PRINT_INFO
|
|
std::cout << "tests/rtree_function_box2f\n";
|
|
#endif
|
|
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
typedef bg::model::point<float, 2, bg::cs::cartesian> P;
|
|
typedef bg::model::box<P> B;
|
|
typedef B V;
|
|
|
|
tests_rtree_function< V, bgi::linear<4, 2>, bgi::translator::def<V> >();
|
|
tests_rtree_function< V, bgi::quadratic<4, 2>, bgi::translator::def<V> >();
|
|
tests_rtree_function< V, bgi::rstar<4, 2>, bgi::translator::def<V> >();
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(tests_rtree_function_point2f)
|
|
{
|
|
#ifdef TEST_PRINT_INFO
|
|
std::cout << "tests/rtree_function_point2f\n";
|
|
#endif
|
|
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
typedef bg::model::point<float, 2, bg::cs::cartesian> P;
|
|
typedef P V;
|
|
|
|
tests_rtree_function< V, bgi::linear<4, 2>, bgi::translator::def<V> >();
|
|
tests_rtree_function< V, bgi::quadratic<4, 2>, bgi::translator::def<V> >();
|
|
tests_rtree_function< V, bgi::rstar<4, 2>, bgi::translator::def<V> >();
|
|
}
|
|
|
|
namespace helpers {
|
|
|
|
template <typename Indexable>
|
|
struct value_randomizer< std::pair<Indexable, int> >
|
|
{
|
|
typedef std::pair<Indexable, int> value_type;
|
|
|
|
typedef typename boost::geometry::index::traits::coordinate_type<Indexable>::type coord_t;
|
|
|
|
inline value_randomizer(coord_t mm, coord_t ww)
|
|
: r(mm, ww)
|
|
{}
|
|
|
|
inline value_type operator()() const
|
|
{
|
|
return std::make_pair(r(), ::rand());
|
|
}
|
|
|
|
value_randomizer<Indexable> r;
|
|
};
|
|
|
|
} // namespace helpers
|
|
|
|
BOOST_AUTO_TEST_CASE(tests_rtree_function_pair_box2f_int)
|
|
{
|
|
#ifdef TEST_PRINT_INFO
|
|
std::cout << "tests/rtree_function_pair_box2f_int\n";
|
|
#endif
|
|
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
typedef bg::model::point<float, 2, bg::cs::cartesian> P;
|
|
typedef bg::model::box<P> B;
|
|
typedef std::pair<B, int> V;
|
|
|
|
tests_rtree_function< V, bgi::linear<4, 2>, bgi::translator::def<V> >();
|
|
tests_rtree_function< V, bgi::quadratic<4, 2>, bgi::translator::def<V> >();
|
|
tests_rtree_function< V, bgi::rstar<4, 2>, bgi::translator::def<V> >();
|
|
}
|
|
|
|
namespace helpers {
|
|
|
|
template <typename Indexable>
|
|
struct value_randomizer< boost::shared_ptr< std::pair<Indexable, int> > >
|
|
{
|
|
typedef boost::shared_ptr< std::pair<Indexable, int> > value_type;
|
|
|
|
typedef typename boost::geometry::index::traits::coordinate_type<Indexable>::type coord_t;
|
|
|
|
inline value_randomizer(coord_t mm, coord_t ww)
|
|
: r(mm, ww)
|
|
{}
|
|
|
|
inline value_type operator()() const
|
|
{
|
|
return value_type(new std::pair<Indexable, int>(r(), ::rand()));
|
|
}
|
|
|
|
value_randomizer<Indexable> r;
|
|
};
|
|
|
|
} // namespace helpers
|
|
|
|
BOOST_AUTO_TEST_CASE(tests_rtree_function_shared_ptr_pair_box2f_int)
|
|
{
|
|
#ifdef TEST_PRINT_INFO
|
|
std::cout << "tests/rtree_function_shared_ptr_pair_box2f_int\n";
|
|
#endif
|
|
|
|
namespace bg = boost::geometry;
|
|
namespace bgi = bg::index;
|
|
|
|
typedef bg::model::point<float, 2, bg::cs::cartesian> P;
|
|
typedef bg::model::box<P> B;
|
|
typedef boost::shared_ptr< std::pair<B, int> > V;
|
|
|
|
tests_rtree_function< V, bgi::linear<4, 2>, bgi::translator::def<V> >();
|
|
tests_rtree_function< V, bgi::quadratic<4, 2>, bgi::translator::def<V> >();
|
|
tests_rtree_function< V, bgi::rstar<4, 2>, bgi::translator::def<V> >();
|
|
}
|
|
|
|
#endif // TESTS_RTREE_FUNCTION_HPP
|