From ea822b7aea2f68d9d071372060ce4f06eddf61e5 Mon Sep 17 00:00:00 2001 From: Adam Wulkiewicz Date: Sat, 27 Aug 2011 00:05:54 +0000 Subject: [PATCH] predicates implemented, query() method added to the rtree + some cleanup. [SVN r74082] --- .../index/algorithms/intersection_content.hpp | 16 +- .../geometry/extensions/index/assert.hpp | 6 +- .../geometry/extensions/index/indexable.hpp | 14 +- .../extensions/index/nonassignable.hpp | 2 +- .../geometry/extensions/index/predicates.hpp | 217 ++++++++++++++++ .../extensions/index/pushable_array.hpp | 232 +++++++++--------- .../extensions/index/rtree/options.hpp | 92 +++---- .../extensions/index/rtree/predicates.hpp | 52 ++++ .../geometry/extensions/index/rtree/rtree.hpp | 24 +- .../index/rtree/visitors/are_boxes_ok.hpp | 40 +-- .../index/rtree/visitors/are_levels_ok.hpp | 32 +-- .../extensions/index/rtree/visitors/find.hpp | 4 +- .../index/rtree/visitors/gl_draw.hpp | 2 +- .../index/rtree/visitors/insert.hpp | 140 +++++------ .../extensions/index/rtree/visitors/print.hpp | 2 +- .../extensions/index/rtree/visitors/query.hpp | 70 ++++++ .../index/rtree/visitors/remove.hpp | 10 +- .../extensions/index/translator/getter.hpp | 4 +- .../extensions/index/translator/helpers.hpp | 16 +- tests/additional_sizes_and_times.cpp | 106 +++++--- tests/main.cpp | 2 +- 21 files changed, 733 insertions(+), 350 deletions(-) create mode 100644 include/boost/geometry/extensions/index/predicates.hpp create mode 100644 include/boost/geometry/extensions/index/rtree/predicates.hpp create mode 100644 include/boost/geometry/extensions/index/rtree/visitors/query.hpp diff --git a/include/boost/geometry/extensions/index/algorithms/intersection_content.hpp b/include/boost/geometry/extensions/index/algorithms/intersection_content.hpp index bb42ec79f..ae8286f2c 100644 --- a/include/boost/geometry/extensions/index/algorithms/intersection_content.hpp +++ b/include/boost/geometry/extensions/index/algorithms/intersection_content.hpp @@ -21,14 +21,14 @@ namespace boost { namespace geometry { namespace index { template inline typename default_content_result::type intersection_content(Box const& box1, Box const& box2) { - typename default_content_result::type result = 0; - if ( geometry::intersects(box1, box2) ) - { - Box box_intersection; - geometry::intersection(box1, box2, box_intersection); - result = index::content(box_intersection); - } - return result; + typename default_content_result::type result = 0; + if ( geometry::intersects(box1, box2) ) + { + Box box_intersection; + geometry::intersection(box1, box2, box_intersection); + result = index::content(box_intersection); + } + return result; } }}} // namespace boost::geometry::index diff --git a/include/boost/geometry/extensions/index/assert.hpp b/include/boost/geometry/extensions/index/assert.hpp index c40a9cf49..d614165ea 100644 --- a/include/boost/geometry/extensions/index/assert.hpp +++ b/include/boost/geometry/extensions/index/assert.hpp @@ -7,8 +7,8 @@ // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) -#ifndef BOOST_GEOMETRY_EXTENSIONS_ASSERT_HPP -#define BOOST_GEOMETRY_EXTENSIONS_ASSERT_HPP +#ifndef BOOST_GEOMETRY_EXTENSIONS_INDEX_ASSERT_HPP +#define BOOST_GEOMETRY_EXTENSIONS_INDEX_ASSERT_HPP #ifdef NDEBUG @@ -24,4 +24,4 @@ #endif -#endif // BOOST_GEOMETRY_EXTENSIONS_ASSERT_HPP +#endif // BOOST_GEOMETRY_EXTENSIONS_INDEX_ASSERT_HPP diff --git a/include/boost/geometry/extensions/index/indexable.hpp b/include/boost/geometry/extensions/index/indexable.hpp index 7553c46c2..5092b5086 100644 --- a/include/boost/geometry/extensions/index/indexable.hpp +++ b/include/boost/geometry/extensions/index/indexable.hpp @@ -162,13 +162,13 @@ typename traits::coordinate_type::type get(Indexable const& i) template struct default_box_type { - typedef geometry::model::box< - geometry::model::point< - typename traits::coordinate_type::type, - traits::dimension::value, - typename traits::coordinate_system::type - > - > type; + typedef geometry::model::box< + geometry::model::point< + typename traits::coordinate_type::type, + traits::dimension::value, + typename traits::coordinate_system::type + > + > type; }; }}} // namespace boost::geometry::index diff --git a/include/boost/geometry/extensions/index/nonassignable.hpp b/include/boost/geometry/extensions/index/nonassignable.hpp index a59a04ae6..a272c9289 100644 --- a/include/boost/geometry/extensions/index/nonassignable.hpp +++ b/include/boost/geometry/extensions/index/nonassignable.hpp @@ -14,7 +14,7 @@ namespace boost { namespace geometry { namespace index { class nonassignable { - nonassignable & operator=(nonassignable const&); + nonassignable & operator=(nonassignable const&); }; }}} // namespace boost::geometry::index diff --git a/include/boost/geometry/extensions/index/predicates.hpp b/include/boost/geometry/extensions/index/predicates.hpp new file mode 100644 index 000000000..edca1fb35 --- /dev/null +++ b/include/boost/geometry/extensions/index/predicates.hpp @@ -0,0 +1,217 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) +// +// Boost.SpatialIndex - Spatial index query predicates +// +// Copyright 2011 Adam Wulkiewicz. +// 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_EXTENSIONS_INDEX_PREDICATES_HPP +#define BOOST_GEOMETRY_EXTENSIONS_INDEX_PREDICATES_HPP + +#include +#include +#include + +// TODO: awulkiew - temporary +#include + +namespace boost { namespace geometry { namespace index { + +// predicates + +namespace detail { + +template +struct covered_by +{ + covered_by(Geometry const& g) : geometry(g) {} + Geometry const& geometry; +}; + +template +struct intersects +{ + intersects(Geometry const& g) : geometry(g) {} + Geometry const& geometry; +}; + +template +struct overlaps +{ + overlaps(Geometry const& g) : geometry(g) {} + Geometry const& geometry; +}; + +template +struct within +{ + within(Geometry const& g) : geometry(g) {} + Geometry const& geometry; +}; + +} // namespace detail + +template +inline detail::covered_by covered_by(Geometry const& g) +{ + return detail::covered_by(g); +} + +template +inline detail::intersects intersects(Geometry const& g) +{ + return detail::intersects(g); +} + +template +inline detail::overlaps overlaps(Geometry const& g) +{ + return detail::overlaps(g); +} + +template +inline detail::within within(Geometry const& g) +{ + return detail::within(g); +} + +// predicates checks + +namespace detail +{ + +template +struct predicate_check +{ + template + static inline bool apply(Geometry const& g, Indexable const& i) + { + return geometry::intersects(i, g); + } +}; + +template +struct predicate_check, Tag> +{ + template + static inline bool apply(covered_by const& p, Indexable const& i) + { + return geometry::covered_by(i, p.geometry); + } +}; + +template +struct predicate_check, Tag> +{ + template + static inline bool apply(intersects const& p, Indexable const& i) + { + return geometry::intersects(i, p.geometry); + } +}; + +template +struct predicate_check, Tag> +{ + template + static inline bool apply(overlaps const& p, Indexable const& i) + { + return geometry::overlaps(i, p.geometry); + } +}; + +template +struct predicate_check, Tag> +{ + template + static inline bool apply(within const& p, Indexable const& i) + { + return geometry::within(i, p.geometry); + } +}; + +template +struct predicates_check_tuple +{ + template + static inline bool apply(TuplePredicates const& p, Indexable const& i) + { + return predicates_check_tuple::apply(p, i) + && predicate_check< + typename boost::tuples::element::type, + Tag + >::apply(boost::get(p), i); + } +}; + +template +struct predicates_check_tuple +{ + template + static inline bool apply(TuplePredicates const& p, Indexable const& i) + { + return predicate_check< + typename boost::tuples::element<0, TuplePredicates>::type, + Tag + >::apply(boost::get<0>(p), i); + } +}; + +template +struct predicates_check +{ + template + static inline bool apply(Predicate const& p, Indexable const& i) + { + return predicate_check::apply(p, i); + } +}; + +template +struct predicates_check, Tag> +{ + template + static inline bool apply(std::pair const& p, Indexable const& i) + { + return predicate_check::apply(p.first, i) + && predicate_check::apply(p.second, i); + } +}; + +template < + typename T0, typename T1, typename T2, typename T3, typename T4, + typename T5, typename T6, typename T7, typename T8, typename T9, + typename Tag +> +struct predicates_check< + boost::tuple, + Tag +> +{ + typedef boost::tuple predicates_type; + + template + static inline bool apply(predicates_type const& p, Indexable const& i) + { + return predicates_check_tuple< + predicates_type, + Tag, + boost::tuples::length::value + >::apply(p, i); + } +}; + +} // namespace detail + +template +inline bool predicates_check(Predicates const& p, Indexable const& i) +{ + return detail::predicates_check + ::apply(p, i); +} + +}}} // namespace boost::geometry::index + +#endif // BOOST_GEOMETRY_EXTENSIONS_INDEX_PREDICATES_HPP diff --git a/include/boost/geometry/extensions/index/pushable_array.hpp b/include/boost/geometry/extensions/index/pushable_array.hpp index 566f86873..b782bd2b5 100644 --- a/include/boost/geometry/extensions/index/pushable_array.hpp +++ b/include/boost/geometry/extensions/index/pushable_array.hpp @@ -19,146 +19,146 @@ namespace boost { namespace geometry { namespace index { template class pushable_array { - typedef typename boost::array array_type; + typedef typename boost::array array_type; public: - typedef typename array_type::value_type value_type; - typedef typename array_type::size_type size_type; - typedef typename array_type::iterator iterator; - typedef typename array_type::const_iterator const_iterator; - typedef typename array_type::reverse_iterator reverse_iterator; - typedef typename array_type::const_reverse_iterator const_reverse_iterator; + typedef typename array_type::value_type value_type; + typedef typename array_type::size_type size_type; + typedef typename array_type::iterator iterator; + typedef typename array_type::const_iterator const_iterator; + typedef typename array_type::reverse_iterator reverse_iterator; + typedef typename array_type::const_reverse_iterator const_reverse_iterator; - inline pushable_array() - : m_size(0) - {} + inline pushable_array() + : m_size(0) + {} - inline explicit pushable_array(size_type s) - : m_size(s) - { - BOOST_GEOMETRY_INDEX_ASSERT(s <= Capacity, "size too big"); - } + inline explicit pushable_array(size_type s) + : m_size(s) + { + BOOST_GEOMETRY_INDEX_ASSERT(s <= Capacity, "size too big"); + } - inline void resize(size_type s) - { - BOOST_GEOMETRY_INDEX_ASSERT(s <= Capacity, "size too big"); - m_size = s; - } + inline void resize(size_type s) + { + BOOST_GEOMETRY_INDEX_ASSERT(s <= Capacity, "size too big"); + m_size = s; + } - inline Element & operator[](size_type i) - { - BOOST_GEOMETRY_INDEX_ASSERT(i < m_size, "index of the element outside the container"); - return m_array[i]; - } + inline Element & operator[](size_type i) + { + BOOST_GEOMETRY_INDEX_ASSERT(i < m_size, "index of the element outside the container"); + return m_array[i]; + } - inline Element const& operator[](size_type i) const - { - BOOST_GEOMETRY_INDEX_ASSERT(i < m_size, "index of the element outside the container"); - return m_array[i]; - } + inline Element const& operator[](size_type i) const + { + BOOST_GEOMETRY_INDEX_ASSERT(i < m_size, "index of the element outside the container"); + return m_array[i]; + } - inline Element const& front() const - { - BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container"); - return m_array.front(); - } + inline Element const& front() const + { + BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container"); + return m_array.front(); + } - inline Element & front() - { - BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container"); - return m_array.front(); - } + inline Element & front() + { + BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container"); + return m_array.front(); + } - inline Element const& back() const - { - BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container"); - return *(begin() + (m_size - 1)); - } + inline Element const& back() const + { + BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container"); + return *(begin() + (m_size - 1)); + } - inline Element & back() - { - BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container"); - return *(begin() + (m_size - 1)); - } + inline Element & back() + { + BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container"); + return *(begin() + (m_size - 1)); + } - inline iterator begin() - { - return m_array.begin(); - } + inline iterator begin() + { + return m_array.begin(); + } - inline iterator end() - { - return m_array.begin() + m_size; - } + inline iterator end() + { + return m_array.begin() + m_size; + } - inline const_iterator begin() const - { - return m_array.begin(); - } + inline const_iterator begin() const + { + return m_array.begin(); + } - inline const_iterator end() const - { - return m_array.begin() + m_size; - } + inline const_iterator end() const + { + return m_array.begin() + m_size; + } - inline reverse_iterator rbegin() - { - return reverse_iterator(end()); - } + inline reverse_iterator rbegin() + { + return reverse_iterator(end()); + } - inline reverse_iterator rend() - { - return reverse_iterator(begin()); - } + inline reverse_iterator rend() + { + return reverse_iterator(begin()); + } - inline const_reverse_iterator rbegin() const - { - return const_reverse_iterator(end()); - } + inline const_reverse_iterator rbegin() const + { + return const_reverse_iterator(end()); + } - inline const_reverse_iterator rend() const - { - return const_reverse_iterator(begin()); - } + inline const_reverse_iterator rend() const + { + return const_reverse_iterator(begin()); + } - inline void clear() - { - m_size = 0; - } + inline void clear() + { + m_size = 0; + } - inline void erase(iterator it) - { - BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container"); - BOOST_GEOMETRY_INDEX_ASSERT(begin() <= it && it < end(), "iterator points on the element outside the container"); - //std::copy(it + 1, end(), it); - *it = back(); - --m_size; - } - - inline void push_back(Element const& v) - { - BOOST_GEOMETRY_INDEX_ASSERT(m_size < Capacity, "can't further increase the size of the container"); - m_array[m_size++] = v; - } + inline void erase(iterator it) + { + BOOST_GEOMETRY_INDEX_ASSERT(0 < m_size, "there are no elements in the container"); + BOOST_GEOMETRY_INDEX_ASSERT(begin() <= it && it < end(), "iterator points on the element outside the container"); + //std::copy(it + 1, end(), it); + *it = back(); + --m_size; + } + + inline void push_back(Element const& v) + { + BOOST_GEOMETRY_INDEX_ASSERT(m_size < Capacity, "can't further increase the size of the container"); + m_array[m_size++] = v; + } - inline bool empty() const - { - return m_size == 0; - } - - inline size_t size() const - { - return m_size; - } + inline bool empty() const + { + return m_size == 0; + } + + inline size_t size() const + { + return m_size; + } - inline size_t capacity() const - { - return Capacity; - } - + inline size_t capacity() const + { + return Capacity; + } + private: - boost::array m_array; - size_type m_size; + boost::array m_array; + size_type m_size; }; }}} // namespace boost::geometry::index diff --git a/include/boost/geometry/extensions/index/rtree/options.hpp b/include/boost/geometry/extensions/index/rtree/options.hpp index 6b15545b0..842bae424 100644 --- a/include/boost/geometry/extensions/index/rtree/options.hpp +++ b/include/boost/geometry/extensions/index/rtree/options.hpp @@ -35,22 +35,22 @@ struct node_default_static_tag {}; // TODO: awulkiew - implement those: //if ( m_min_elems_per_node < 1 ) -// m_min_elems_per_node = 1; +// m_min_elems_per_node = 1; //if ( m_max_elems_per_node < 2 ) -// m_max_elems_per_node = 2; +// m_max_elems_per_node = 2; template struct linear { - static const size_t max_elements = MaxElements; - static const size_t min_elements = MinElements; + static const size_t max_elements = MaxElements; + static const size_t min_elements = MinElements; }; template struct quadratic { - static const size_t max_elements = MaxElements; - static const size_t min_elements = MinElements; + static const size_t max_elements = MaxElements; + static const size_t min_elements = MinElements; }; namespace options { namespace detail { @@ -58,22 +58,22 @@ namespace options { namespace detail { template struct default_rstar_reinserted_elements { - static const size_t value = (MaxElements * 3) / 10; + static const size_t value = (MaxElements * 3) / 10; }; }} // namespace options::detail template ::value - > + size_t MinElements, + size_t OverlapCostThreshold = 0, + size_t ReinsertedElements = options::detail::default_rstar_reinserted_elements::value + > struct rstar { - static const size_t max_elements = MaxElements; - static const size_t min_elements = MinElements; - static const size_t overlap_cost_threshold = OverlapCostThreshold; - static const size_t reinserted_elements = ReinsertedElements; + static const size_t max_elements = MaxElements; + static const size_t min_elements = MinElements; + static const size_t overlap_cost_threshold = OverlapCostThreshold; + static const size_t reinserted_elements = ReinsertedElements; }; namespace options { @@ -81,12 +81,12 @@ namespace options { template struct rtree { - typedef Parameters parameters_type; - typedef InsertTag insert_tag; - typedef ChooseNextNodeTag choose_next_node_tag; - typedef SplitTag split_tag; - typedef RedistributeTag redistribute_tag; - typedef NodeTag node_tag; + typedef Parameters parameters_type; + typedef InsertTag insert_tag; + typedef ChooseNextNodeTag choose_next_node_tag; + typedef SplitTag split_tag; + typedef RedistributeTag redistribute_tag; + typedef NodeTag node_tag; }; } // namespace options @@ -96,46 +96,46 @@ namespace detail { namespace rtree { template struct options_type { - // TODO: awulkiew - use static assert + // TODO: awulkiew - use static assert }; template struct options_type< linear > { - typedef options::rtree< - linear, - insert_default_tag, - choose_by_content_diff_tag, - split_default_tag, - linear_tag, - node_default_static_tag - > type; + typedef options::rtree< + linear, + insert_default_tag, + choose_by_content_diff_tag, + split_default_tag, + linear_tag, + node_default_static_tag + > type; }; template struct options_type< quadratic > { - typedef options::rtree< - quadratic, - insert_default_tag, - choose_by_content_diff_tag, - split_default_tag, - quadratic_tag, - node_default_static_tag - > type; + typedef options::rtree< + quadratic, + insert_default_tag, + choose_by_content_diff_tag, + split_default_tag, + quadratic_tag, + node_default_static_tag + > type; }; template struct options_type< rstar > { - typedef options::rtree< - rstar, - insert_reinsert_tag, - choose_by_overlap_diff_tag, - split_default_tag, - rstar_tag, - node_default_static_tag - > type; + typedef options::rtree< + rstar, + insert_reinsert_tag, + choose_by_overlap_diff_tag, + split_default_tag, + rstar_tag, + node_default_static_tag + > type; }; }} // namespace detail::rtree diff --git a/include/boost/geometry/extensions/index/rtree/predicates.hpp b/include/boost/geometry/extensions/index/rtree/predicates.hpp new file mode 100644 index 000000000..05d74ae16 --- /dev/null +++ b/include/boost/geometry/extensions/index/rtree/predicates.hpp @@ -0,0 +1,52 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) +// +// Boost.SpatialIndex - Spatial index query predicates +// +// Copyright 2011 Adam Wulkiewicz. +// 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_EXTENSIONS_INDEX_RTREE_PREDICATES_HPP +#define BOOST_GEOMETRY_EXTENSIONS_INDEX_RTREE_PREDICATES_HPP + +#include + +namespace boost { namespace geometry { namespace index { + +namespace detail { + +namespace rtree { + +struct value_predicates_tag {}; +struct node_predicates_tag {}; + +} // namespace rtree + +template +struct predicate_check, rtree::node_predicates_tag> +{ + template + static bool apply(covered_by const& p, Indexable const& i) + { + return geometry::intersects(i, p.geometry); + } +}; + +template +struct predicate_check, rtree::node_predicates_tag> +{ + template + static bool apply(within const& p, Indexable const& i) + { + // TODO: awulkiew - possibly change to the version without border case + // e.g. intersects_without_border(0,0x1,1, 1,1x2,2) should give false + return geometry::intersects(i, p.geometry); + } +}; + +} // namespace detail + +}}} // namespace boost::geometry::index + +#endif // BOOST_GEOMETRY_EXTENSIONS_INDEX_RTREE_PREDICATES_HPP diff --git a/include/boost/geometry/extensions/index/rtree/rtree.hpp b/include/boost/geometry/extensions/index/rtree/rtree.hpp index 73d00e6dd..a8275e9d4 100644 --- a/include/boost/geometry/extensions/index/rtree/rtree.hpp +++ b/include/boost/geometry/extensions/index/rtree/rtree.hpp @@ -22,11 +22,13 @@ #include #include -#include +#include +//#include #include #include +#include #include #include #include @@ -42,19 +44,19 @@ namespace boost { namespace geometry { namespace index { template < typename Value, typename Parameters, - typename Translator = translator::def + typename Translator = translator::def > class rtree - : public boost::noncopyable + : public boost::noncopyable { public: typedef Value value_type; typedef Translator translator_type; - typedef typename translator_type::indexable_type indexable_type; + typedef typename translator_type::indexable_type indexable_type; typedef typename index::default_box_type::type box_type; - typedef typename detail::rtree::options_type::type options_type; - typedef typename options_type::node_tag node_tag; + typedef typename detail::rtree::options_type::type options_type; + typedef typename options_type::node_tag node_tag; typedef typename detail::rtree::node::type node; typedef typename detail::rtree::internal_node::type internal_node; @@ -75,8 +77,16 @@ public: detail::rtree::apply_visitor(del_v, *m_root); } - // TODO: awulkiew - change name to query? + template + inline void query(Predicates const& pred, OutIter out_it) const + { + detail::rtree::visitors::query + find_v(m_translator, pred, out_it); + detail::rtree::apply_visitor(find_v, *m_root); + } + + // TODO: delete find method template inline void find(Geometry const& geom, OutIter out_it) const { diff --git a/include/boost/geometry/extensions/index/rtree/visitors/are_boxes_ok.hpp b/include/boost/geometry/extensions/index/rtree/visitors/are_boxes_ok.hpp index ce9e43478..7a1acd23a 100644 --- a/include/boost/geometry/extensions/index/rtree/visitors/are_boxes_ok.hpp +++ b/include/boost/geometry/extensions/index/rtree/visitors/are_boxes_ok.hpp @@ -19,8 +19,8 @@ namespace detail { namespace rtree { namespace visitors { template class are_boxes_ok - : public rtree::visitor::type - , index::nonassignable + : public rtree::visitor::type + , index::nonassignable { typedef typename rtree::internal_node::type internal_node; typedef typename rtree::leaf::type leaf; @@ -76,27 +76,27 @@ public: typedef typename rtree::elements_type::type elements_type; elements_type const& elements = rtree::elements(n); - // non-root node + // non-root node if (!m_is_root) { - if ( elements.empty() ) - { - result = false; - return; - } + if ( elements.empty() ) + { + result = false; + return; + } - Box box_exp; - geometry::convert(m_tr(elements.front()), box_exp); - for(typename elements_type::const_iterator it = elements.begin() + 1; - it != elements.end() ; ++it) - { - geometry::expand(box_exp, m_tr(*it)); - } + Box box_exp; + geometry::convert(m_tr(elements.front()), box_exp); + for(typename elements_type::const_iterator it = elements.begin() + 1; + it != elements.end() ; ++it) + { + geometry::expand(box_exp, m_tr(*it)); + } - result = geometry::equals(box_exp, m_box); - } - else - result = true; + result = geometry::equals(box_exp, m_box); + } + else + result = true; } bool result; @@ -115,7 +115,7 @@ bool are_boxes_ok(rtree const& tree) typedef rtree rt; detail::rtree::visitors::are_boxes_ok< typename rt::value_type, - typename rt::options_type, + typename rt::options_type, typename rt::translator_type, typename rt::box_type> v(tree.get_translator()); diff --git a/include/boost/geometry/extensions/index/rtree/visitors/are_levels_ok.hpp b/include/boost/geometry/extensions/index/rtree/visitors/are_levels_ok.hpp index d905853f0..c1d88b2a0 100644 --- a/include/boost/geometry/extensions/index/rtree/visitors/are_levels_ok.hpp +++ b/include/boost/geometry/extensions/index/rtree/visitors/are_levels_ok.hpp @@ -18,8 +18,8 @@ namespace detail { namespace rtree { namespace visitors { template class are_levels_ok - : public rtree::visitor::type - , index::nonassignable + : public rtree::visitor::type + , index::nonassignable { typedef typename rtree::internal_node::type internal_node; typedef typename rtree::leaf::type leaf; @@ -40,10 +40,10 @@ public: return; } - size_t current_level_backup = m_current_level; - ++m_current_level; + size_t current_level_backup = m_current_level; + ++m_current_level; - for ( typename elements_type::const_iterator it = elements.begin(); + for ( typename elements_type::const_iterator it = elements.begin(); it != elements.end() ; ++it) { rtree::apply_visitor(*this, *it->second); @@ -52,7 +52,7 @@ public: return; } - m_current_level = current_level_backup; + m_current_level = current_level_backup; } inline void operator()(leaf const& n) @@ -60,7 +60,7 @@ public: typedef typename rtree::elements_type::type elements_type; elements_type const& elements = rtree::elements(n); - // empty leaf in non-root node + // empty leaf in non-root node if (0 < m_current_level && elements.empty()) { result = false; @@ -68,13 +68,13 @@ public: } if ( m_leafs_level == std::numeric_limits::max() ) - { - m_leafs_level = m_current_level; - } - else if ( m_leafs_level != m_current_level ) - { - result = false; - } + { + m_leafs_level = m_current_level; + } + else if ( m_leafs_level != m_current_level ) + { + result = false; + } } bool result; @@ -82,7 +82,7 @@ public: private: Translator const& m_tr; size_t m_leafs_level; - size_t m_current_level; + size_t m_current_level; }; }}} // namespace detail::rtree::visitors @@ -93,7 +93,7 @@ bool are_levels_ok(rtree const& tree) typedef rtree rt; detail::rtree::visitors::are_levels_ok< typename rt::value_type, - typename rt::options_type, + typename rt::options_type, typename rt::translator_type, typename rt::box_type> v(tree.get_translator()); diff --git a/include/boost/geometry/extensions/index/rtree/visitors/find.hpp b/include/boost/geometry/extensions/index/rtree/visitors/find.hpp index 83026bc2d..aa13ec189 100644 --- a/include/boost/geometry/extensions/index/rtree/visitors/find.hpp +++ b/include/boost/geometry/extensions/index/rtree/visitors/find.hpp @@ -142,8 +142,8 @@ namespace detail { namespace rtree { namespace visitors { template struct find - : public rtree::visitor::type - , index::nonassignable + : public rtree::visitor::type + , index::nonassignable { typedef typename rtree::node::type node; typedef typename rtree::internal_node::type internal_node; diff --git a/include/boost/geometry/extensions/index/rtree/visitors/gl_draw.hpp b/include/boost/geometry/extensions/index/rtree/visitors/gl_draw.hpp index 122cfedeb..bbe1c035c 100644 --- a/include/boost/geometry/extensions/index/rtree/visitors/gl_draw.hpp +++ b/include/boost/geometry/extensions/index/rtree/visitors/gl_draw.hpp @@ -196,7 +196,7 @@ void gl_draw(rtree const& tree, ) { typedef typename rtree::value_type value_type; - typedef typename rtree::options_type options_type; + typedef typename rtree::options_type options_type; typedef typename rtree::translator_type translator_type; typedef typename rtree::box_type box_type; diff --git a/include/boost/geometry/extensions/index/rtree/visitors/insert.hpp b/include/boost/geometry/extensions/index/rtree/visitors/insert.hpp index 0521ff1c6..93bdc368c 100644 --- a/include/boost/geometry/extensions/index/rtree/visitors/insert.hpp +++ b/include/boost/geometry/extensions/index/rtree/visitors/insert.hpp @@ -40,7 +40,7 @@ struct choose_next_node { children_type & children = rtree::elements(n); - BOOST_GEOMETRY_INDEX_ASSERT(!children.empty(), "can't choose the next node if children are empty"); + BOOST_GEOMETRY_INDEX_ASSERT(!children.empty(), "can't choose the next node if children are empty"); size_t children_count = children.size(); @@ -94,61 +94,61 @@ template class split { protected: - typedef typename rtree::node::type node; - typedef typename rtree::internal_node::type internal_node; - typedef typename rtree::leaf::type leaf; + typedef typename rtree::node::type node; + typedef typename rtree::internal_node::type internal_node; + typedef typename rtree::leaf::type leaf; - typedef typename Options::parameters_type parameters_type; + typedef typename Options::parameters_type parameters_type; public: - template - static inline void apply(node* & root_node, - size_t & leafs_level, - Node & n, - internal_node *parent_node, - size_t current_child_index, - Translator const& tr) - { - // create additional node - node * second_node = rtree::create_node(Node()); - Node & n2 = rtree::get(*second_node); + template + static inline void apply(node* & root_node, + size_t & leafs_level, + Node & n, + internal_node *parent_node, + size_t current_child_index, + Translator const& tr) + { + // create additional node + node * second_node = rtree::create_node(Node()); + Node & n2 = rtree::get(*second_node); - // redistribute elements - Box box1, box2; - redistribute_elements:: - apply(n, n2, box1, box2, tr); + // redistribute elements + Box box1, box2; + redistribute_elements:: + apply(n, n2, box1, box2, tr); - // check numbers of elements - BOOST_GEOMETRY_INDEX_ASSERT(parameters_type::min_elements <= rtree::elements(n).size() && - rtree::elements(n).size() <= parameters_type::max_elements, - "unexpected number of elements"); - BOOST_GEOMETRY_INDEX_ASSERT(parameters_type::min_elements <= rtree::elements(n2).size() && - rtree::elements(n2).size() <= parameters_type::max_elements, - "unexpected number of elements"); + // check numbers of elements + BOOST_GEOMETRY_INDEX_ASSERT(parameters_type::min_elements <= rtree::elements(n).size() && + rtree::elements(n).size() <= parameters_type::max_elements, + "unexpected number of elements"); + BOOST_GEOMETRY_INDEX_ASSERT(parameters_type::min_elements <= rtree::elements(n2).size() && + rtree::elements(n2).size() <= parameters_type::max_elements, + "unexpected number of elements"); - // node is not the root - just add the new node - if ( parent_node != 0 ) - { - // update old node's box - rtree::elements(*parent_node)[current_child_index].first = box1; - // add new node to the parent's children - rtree::elements(*parent_node).push_back(std::make_pair(box2, second_node)); - } - // node is the root - add level - else - { - BOOST_GEOMETRY_INDEX_ASSERT(&n == rtree::get(root_node), "node should be the root"); + // node is not the root - just add the new node + if ( parent_node != 0 ) + { + // update old node's box + rtree::elements(*parent_node)[current_child_index].first = box1; + // add new node to the parent's children + rtree::elements(*parent_node).push_back(std::make_pair(box2, second_node)); + } + // node is the root - add level + else + { + BOOST_GEOMETRY_INDEX_ASSERT(&n == rtree::get(root_node), "node should be the root"); - // create new root and add nodes - node * new_root = rtree::create_node(internal_node()); + // create new root and add nodes + node * new_root = rtree::create_node(internal_node()); - rtree::elements(rtree::get(*new_root)).push_back(std::make_pair(box1, root_node)); - rtree::elements(rtree::get(*new_root)).push_back(std::make_pair(box2, second_node)); + rtree::elements(rtree::get(*new_root)).push_back(std::make_pair(box1, root_node)); + rtree::elements(rtree::get(*new_root)).push_back(std::make_pair(box2, second_node)); - root_node = new_root; - ++leafs_level; - } - } + root_node = new_root; + ++leafs_level; + } + } }; // ----------------------------------------------------------------------- // @@ -156,15 +156,15 @@ public: // Default insert visitor template class insert - : public rtree::visitor::type - , index::nonassignable + : public rtree::visitor::type + , index::nonassignable { protected: typedef typename rtree::node::type node; typedef typename rtree::internal_node::type internal_node; typedef typename rtree::leaf::type leaf; - typedef typename Options::parameters_type parameters_type; + typedef typename Options::parameters_type parameters_type; inline insert(node* & root, size_t & leafs_level, @@ -174,7 +174,7 @@ protected: ) : m_element(element) , m_tr(t) - , m_relative_level(relative_level) + , m_relative_level(relative_level) , m_level(leafs_level - relative_level) , m_root_node(root) , m_leafs_level(leafs_level) @@ -182,8 +182,8 @@ protected: , m_current_child_index(0) , m_current_level(0) { - BOOST_GEOMETRY_INDEX_ASSERT(m_relative_level <= leafs_level, "unexpected level value"); - BOOST_GEOMETRY_INDEX_ASSERT(m_level <= m_leafs_level, "unexpected level value"); + BOOST_GEOMETRY_INDEX_ASSERT(m_relative_level <= leafs_level, "unexpected level value"); + BOOST_GEOMETRY_INDEX_ASSERT(m_level <= m_leafs_level, "unexpected level value"); // TODO // assert - check if Box is correct } @@ -209,13 +209,13 @@ protected: template inline void post_traverse(Node &n) { - BOOST_GEOMETRY_INDEX_ASSERT(0 == m_parent || &n == rtree::get(rtree::elements(*m_parent)[m_current_child_index].second), - "if node isn't the root current_child_index should be valid"); + BOOST_GEOMETRY_INDEX_ASSERT(0 == m_parent || &n == rtree::get(rtree::elements(*m_parent)[m_current_child_index].second), + "if node isn't the root current_child_index should be valid"); // handle overflow if ( parameters_type::max_elements < rtree::elements(n).size() ) { - split(n); + split(n); } } @@ -241,17 +241,17 @@ protected: m_current_level = current_level_bckup; } - template - inline void split(Node & n) const - { - detail::split::apply(m_root_node, m_leafs_level, n, m_parent, m_current_child_index, m_tr); - } + template + inline void split(Node & n) const + { + detail::split::apply(m_root_node, m_leafs_level, n, m_parent, m_current_child_index, m_tr); + } // TODO: awulkiew - implement dispatchable split::apply to enable additional nodes creation Element const& m_element; Translator const& m_tr; - const size_t m_relative_level; + const size_t m_relative_level; const size_t m_level; node* & m_root_node; @@ -272,7 +272,7 @@ struct insert; // Default insert visitor used for nodes elements template struct insert - : public detail::insert + : public detail::insert { typedef detail::insert base; typedef typename base::node node; @@ -290,7 +290,7 @@ struct insert inline void operator()(internal_node & n) { - BOOST_GEOMETRY_INDEX_ASSERT(base::m_current_level < base::m_leafs_level, "unexpected level"); + BOOST_GEOMETRY_INDEX_ASSERT(base::m_current_level < base::m_leafs_level, "unexpected level"); if ( base::m_current_level < base::m_level ) { @@ -299,7 +299,7 @@ struct insert } else { - BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_current_level, "unexpected level"); + BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_current_level, "unexpected level"); // push new child node rtree::elements(n).push_back(base::m_element); @@ -317,7 +317,7 @@ struct insert // Default insert visitor specialized for Values elements template struct insert - : public detail::insert + : public detail::insert { typedef detail::insert base; typedef typename base::node node; @@ -335,8 +335,8 @@ struct insert inline void operator()(internal_node & n) { - BOOST_GEOMETRY_INDEX_ASSERT(base::m_current_level < base::m_leafs_level, "unexpected level"); - BOOST_GEOMETRY_INDEX_ASSERT(base::m_current_level < base::m_level, "unexpected level"); + BOOST_GEOMETRY_INDEX_ASSERT(base::m_current_level < base::m_leafs_level, "unexpected level"); + BOOST_GEOMETRY_INDEX_ASSERT(base::m_current_level < base::m_level, "unexpected level"); // next traversing step base::traverse(*this, n); @@ -346,8 +346,8 @@ struct insert inline void operator()(leaf & n) { - BOOST_GEOMETRY_INDEX_ASSERT(base::m_current_level == base::m_leafs_level, "unexpected level"); - BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_current_level || base::m_level == std::numeric_limits::max(), "unexpected level"); + BOOST_GEOMETRY_INDEX_ASSERT(base::m_current_level == base::m_leafs_level, "unexpected level"); + BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_current_level || base::m_level == std::numeric_limits::max(), "unexpected level"); rtree::elements(n).push_back(base::m_element); diff --git a/include/boost/geometry/extensions/index/rtree/visitors/print.hpp b/include/boost/geometry/extensions/index/rtree/visitors/print.hpp index 282f35553..26e16a3e5 100644 --- a/include/boost/geometry/extensions/index/rtree/visitors/print.hpp +++ b/include/boost/geometry/extensions/index/rtree/visitors/print.hpp @@ -182,7 +182,7 @@ template std::ostream & operator<<(std::ostream & os, rtree const& tree) { typedef typename rtree::value_type value_type; - typedef typename rtree::options_type options_type; + typedef typename rtree::options_type options_type; typedef typename rtree::translator_type translator_type; typedef typename rtree::box_type box_type; detail::rtree::visitors::print print_v(os, tree.get_translator()); diff --git a/include/boost/geometry/extensions/index/rtree/visitors/query.hpp b/include/boost/geometry/extensions/index/rtree/visitors/query.hpp new file mode 100644 index 000000000..75978c53b --- /dev/null +++ b/include/boost/geometry/extensions/index/rtree/visitors/query.hpp @@ -0,0 +1,70 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) +// +// Boost.Index - R-tree spatial query +// +// Copyright 2011 Adam Wulkiewicz. +// 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_EXTENSIONS_INDEX_RTREE_VISITORS_QUERY_HPP +#define BOOST_GEOMETRY_EXTENSIONS_INDEX_RTREE_VISITORS_QUERY_HPP + +#include + +namespace boost { namespace geometry { namespace index { + +namespace detail { namespace rtree { namespace visitors { + +template +struct query + : public rtree::visitor::type + , index::nonassignable +{ + typedef typename rtree::node::type node; + typedef typename rtree::internal_node::type internal_node; + typedef typename rtree::leaf::type leaf; + + inline query(Translator const& t, Predicates const& p, OutIter out_it) + : tr(t), pred(p), out_iter(out_it) + {} + + inline void operator()(internal_node const& n) + { + typedef typename rtree::elements_type::type elements_type; + elements_type const& elements = rtree::elements(n); + + for (typename elements_type::const_iterator it = elements.begin(); + it != elements.end(); ++it) + { + if ( index::predicates_check(pred, it->first) ) + rtree::apply_visitor(*this, *it->second); + } + } + + inline void operator()(leaf const& n) + { + typedef typename rtree::elements_type::type elements_type; + elements_type const& elements = rtree::elements(n); + + for (typename elements_type::const_iterator it = elements.begin(); + it != elements.end(); ++it) + { + if ( index::predicates_check(pred, tr(*it)) ) + { + out_iter = *it; + ++out_iter; + } + } + } + + Translator const& tr; + Predicates const& pred; + OutIter out_iter; +}; + +}}} // namespace detail::rtree::visitors + +}}} // namespace boost::geometry::index + +#endif // BOOST_GEOMETRY_EXTENSIONS_INDEX_RTREE_VISITORS_QUERY_HPP diff --git a/include/boost/geometry/extensions/index/rtree/visitors/remove.hpp b/include/boost/geometry/extensions/index/rtree/visitors/remove.hpp index 5db8b079b..326a5a050 100644 --- a/include/boost/geometry/extensions/index/rtree/visitors/remove.hpp +++ b/include/boost/geometry/extensions/index/rtree/visitors/remove.hpp @@ -23,14 +23,14 @@ namespace detail { namespace rtree { namespace visitors { // Default remove algorithm template class remove - : public rtree::visitor::type - , index::nonassignable + : public rtree::visitor::type + , index::nonassignable { typedef typename rtree::node::type node; typedef typename rtree::internal_node::type internal_node; typedef typename rtree::leaf::type leaf; - typedef typename Options::parameters_type parameters_type; + typedef typename Options::parameters_type parameters_type; public: inline remove(node* & root, @@ -104,8 +104,8 @@ public: // n is root node else { - BOOST_GEOMETRY_INDEX_ASSERT(&n == rtree::get(m_root_node), "node must be the root"); - BOOST_GEOMETRY_INDEX_ASSERT(m_is_value_removed, "value not found"); + BOOST_GEOMETRY_INDEX_ASSERT(&n == rtree::get(m_root_node), "node must be the root"); + BOOST_GEOMETRY_INDEX_ASSERT(m_is_value_removed, "value not found"); // reinsert elements from removed nodes // begin with levels closer to the root diff --git a/include/boost/geometry/extensions/index/translator/getter.hpp b/include/boost/geometry/extensions/index/translator/getter.hpp index be0c6ea55..702b2779c 100644 --- a/include/boost/geometry/extensions/index/translator/getter.hpp +++ b/include/boost/geometry/extensions/index/translator/getter.hpp @@ -17,7 +17,7 @@ struct getter { typedef Indexable indexable_type; - indexable_type const& operator()(Value const& v) const + indexable_type const& operator()(Value const& v) const { return (v.*Getter)(); } @@ -25,7 +25,7 @@ struct getter bool equals(Value const& v1, Value const& v2) const { //return geometry::equals(operator()(v1), operator()(v2)); - return v1 == v2; + return v1 == v2; } }; diff --git a/include/boost/geometry/extensions/index/translator/helpers.hpp b/include/boost/geometry/extensions/index/translator/helpers.hpp index 44b364650..1bc57ccd3 100644 --- a/include/boost/geometry/extensions/index/translator/helpers.hpp +++ b/include/boost/geometry/extensions/index/translator/helpers.hpp @@ -173,15 +173,15 @@ struct equals< std::pair > static bool apply(std::pair const& p1, std::pair const& p2) { return - dispatch::equals< - First, - typename traits::tag::type - >::apply(p1.first, p2.first) - && dispatch::equals< - Second, - typename traits::tag::type - >::apply(p1.second, p2.second); + First, + typename traits::tag::type + >::apply(p1.first, p2.first) + && + dispatch::equals< + Second, + typename traits::tag::type + >::apply(p1.second, p2.second); } }; diff --git a/tests/additional_sizes_and_times.cpp b/tests/additional_sizes_and_times.cpp index 20bbdfd27..d54002af6 100644 --- a/tests/additional_sizes_and_times.cpp +++ b/tests/additional_sizes_and_times.cpp @@ -26,16 +26,16 @@ int main() namespace bg = boost::geometry; namespace bgi = bg::index; - //typedef bg::model::d2::point_xy P; + //typedef bg::model::d2::point_xy P; typedef bg::model::point P; typedef bg::model::box

B; - //typedef bgi::rtree, bgi::linear<32, 8> > RT; + typedef bgi::rtree, bgi::linear<32, 8> > RT; //typedef bgi::rtree, bgi::quadratic<32, 8> > RT; - typedef bgi::rtree, bgi::rstar<32, 8> > RT; - /*typedef bgi::rtree< - std::pair, - bgi::options::rtree, bgi::reinsert_tag, bgi::choose_by_area_diff_tag, bgi::rstar_tag, bgi::default_tag> - > RT;*/ + //typedef bgi::rtree, bgi::rstar<32, 8> > RT; + /*typedef bgi::rtree< + std::pair, + bgi::options::rtree, bgi::reinsert_tag, bgi::choose_by_area_diff_tag, bgi::rstar_tag, bgi::default_tag> + > RT;*/ // load config file std::ifstream file_cfg("config.txt"); @@ -89,13 +89,13 @@ int main() else { boost::mt19937 rng; - //rng.seed(static_cast(std::time(0))); + //rng.seed(static_cast(std::time(0))); - float max_val = static_cast(values_count / 2); + float max_val = static_cast(values_count / 2); boost::uniform_real range(-max_val, max_val); - boost::variate_generator > rnd(rng, range); - + boost::variate_generator > rnd(rng, range); + std::cout << "randomizing data\n"; for ( size_t i = 0 ; i < values_count ; ++i ) { @@ -127,14 +127,14 @@ int main() std::cout << "BOXES OK\n"; else std::cout << "WRONG BOXES\n"; - if ( bgi::are_levels_ok(t) ) - std::cout << "LEVELS OK\n"; - else - std::cout << "WRONG LEVELS\n"; + if ( bgi::are_levels_ok(t) ) + std::cout << "LEVELS OK\n"; + else + std::cout << "WRONG LEVELS\n"; // searching test { - std::cout << "searching time test...\n"; + std::cout << "find(B) searching time test...\n"; tim.restart(); size_t temp = 0; for (size_t i = 0 ; i < queries_count ; ++i ) @@ -149,6 +149,40 @@ int main() std::cout << "found: " << temp << "\n"; } + // searching test + { + std::cout << "query(intersects(B)) searching time test...\n"; + tim.restart(); + size_t temp = 0; + for (size_t i = 0 ; i < queries_count ; ++i ) + { + float x = coords[i].first; + float y = coords[i].second; + std::deque< std::pair > result; + t.query(bgi::intersects(B(P(x - 10, y - 10), P(x + 10, y + 10))), std::back_inserter(result)); + temp += result.size(); + } + std::cout << "time: " << tim.elapsed() << "s\n"; + std::cout << "found: " << temp << "\n"; + } + + // searching test + { + std::cout << "query(B) searching time test...\n"; + tim.restart(); + size_t temp = 0; + for (size_t i = 0 ; i < queries_count ; ++i ) + { + float x = coords[i].first; + float y = coords[i].second; + std::deque< std::pair > result; + t.query(B(P(x - 10, y - 10), P(x + 10, y + 10)), std::back_inserter(result)); + temp += result.size(); + } + std::cout << "time: " << tim.elapsed() << "s\n"; + std::cout << "found: " << temp << "\n"; + } + // elements removing test { std::cout << "removing time test...\n"; @@ -164,15 +198,15 @@ int main() std::cout << "time: " << tim.elapsed() << "s\n"; } - // check - if ( bgi::are_boxes_ok(t) ) - std::cout << "BOXES OK\n"; - else - std::cout << "WRONG BOXES\n"; - if ( bgi::are_levels_ok(t) ) - std::cout << "LEVELS OK\n"; - else - std::cout << "WRONG LEVELS\n"; + // check + if ( bgi::are_boxes_ok(t) ) + std::cout << "BOXES OK\n"; + else + std::cout << "WRONG BOXES\n"; + if ( bgi::are_levels_ok(t) ) + std::cout << "LEVELS OK\n"; + else + std::cout << "WRONG LEVELS\n"; // searching test { @@ -184,7 +218,7 @@ int main() float x = coords[i].first; float y = coords[i].second; std::deque< std::pair > result; - t.find(B(P(x - 10, y - 10), P(x + 10, y + 10)), std::back_inserter(result)); + t.query(bgi::intersects(B(P(x - 10, y - 10), P(x + 10, y + 10))), std::back_inserter(result)); temp += result.size(); } std::cout << "time: " << tim.elapsed() << "s\n"; @@ -206,15 +240,15 @@ int main() std::cout << "time: " << tim.elapsed() << "s\n"; } - // check - if ( bgi::are_boxes_ok(t) ) - std::cout << "BOXES OK\n"; - else - std::cout << "WRONG BOXES\n"; - if ( bgi::are_levels_ok(t) ) - std::cout << "LEVELS OK\n"; - else - std::cout << "WRONG LEVELS\n"; + // check + if ( bgi::are_boxes_ok(t) ) + std::cout << "BOXES OK\n"; + else + std::cout << "WRONG BOXES\n"; + if ( bgi::are_levels_ok(t) ) + std::cout << "LEVELS OK\n"; + else + std::cout << "WRONG LEVELS\n"; // searching test { @@ -226,7 +260,7 @@ int main() float x = coords[i].first; float y = coords[i].second; std::deque< std::pair > result; - t.find(B(P(x - 10, y - 10), P(x + 10, y + 10)), std::back_inserter(result)); + t.query(bgi::intersects(B(P(x - 10, y - 10), P(x + 10, y + 10))), std::back_inserter(result)); temp += result.size(); } std::cout << "time: " << tim.elapsed() << "s\n"; diff --git a/tests/main.cpp b/tests/main.cpp index 1f97014a0..7d6d94067 100644 --- a/tests/main.cpp +++ b/tests/main.cpp @@ -18,7 +18,7 @@ int main() tests_translators_hpp(); tests_rtree_native_hpp >(); tests_rtree_native_hpp >(); - tests_rtree_native_hpp >(); + tests_rtree_native_hpp >(); tests_rtree_filters_hpp(); /* {