geometry.index: test - fixed varray warnings, example - code using packing added to glut_vis and benchmark_experimental.

[SVN r84721]

index/example/benchmark_experimental.cpp

@@ -35,11 +35,14 @@ void mycopy(I1 first, I2 last, O o)
         *o = *first;
 }
 
+//#define BOOST_GEOMETRY_INDEX_BENCHMARK_DEBUG
+
 int main()
 {
     typedef boost::chrono::thread_clock clock_t;
     typedef boost::chrono::duration<float> dur_t;
 
+#ifndef BOOST_GEOMETRY_INDEX_BENCHMARK_DEBUG
     size_t values_count = 1000000;
     size_t queries_count = 100000;
     size_t nearest_queries_count = 10000;
@@ -47,9 +50,19 @@ int main()
     size_t path_queries_count = 2000;
     size_t path_queries_count2 = 10000;
     unsigned path_values_count = 10;
+#else
+    size_t values_count = 1000;
+    size_t queries_count = 1;
+    size_t nearest_queries_count = 1;
+    unsigned neighbours_count = 10;
+    size_t path_queries_count = 1;
+    size_t path_queries_count2 = 1;
+    unsigned path_values_count = 10;
+#endif
 
     float max_val = static_cast<float>(values_count / 2);
     std::vector< std::pair<float, float> > coords;
+    std::vector<B> values;
 
     //randomize values
     {
@@ -63,39 +76,62 @@ int main()
         std::cout << "randomizing data\n";
         for ( size_t i = 0 ; i < values_count ; ++i )
         {
-            coords.push_back(std::make_pair(rnd(), rnd()));
+            float x = rnd();
+            float y = rnd();
+            coords.push_back(std::make_pair(x, y));
+            values.push_back(B(P(x - 0.5f, y - 0.5f), P(x + 0.5f, y + 0.5f)));
         }
         std::cout << "randomized\n";
     }
 
-    typedef bgi::rtree<B, bgi::linear<16, 4> > RT;
+    //typedef bgi::rtree<B, bgi::linear<100, 50> > RT;
     //typedef bgi::rtree<B, bgi::quadratic<8, 3> > RT;
-    //typedef bgi::rtree<B, bgi::rstar<8, 3> > RT;
+    typedef bgi::rtree<B, bgi::rstar<8, 3> > RT;
 
     std::cout << "sizeof rtree: " << sizeof(RT) << std::endl;
 
     for (;;)
     {
+        std::vector<B> result;
+        result.reserve(100);
+        B result_one;
+
+        // packing test
+        {
+            clock_t::time_point start = clock_t::now();
+
+            RT t(values.begin(), values.end());
+
+            dur_t time = clock_t::now() - start;
+            std::cout << time << " - pack " << values_count << '\n';
+
+            {
+                clock_t::time_point start = clock_t::now();
+                size_t temp = 0;
+                for (size_t i = 0 ; i < queries_count ; ++i )
+                {
+                    float x = coords[i].first;
+                    float y = coords[i].second;
+                    result.clear();
+                    t.query(bgi::intersects(B(P(x - 10, y - 10), P(x + 10, y + 10))), std::back_inserter(result));
+                    temp += result.size();
+                }
+                dur_t time = clock_t::now() - start;
+                std::cout << time << " - query(B) " << queries_count << " found " << temp << '\n';
+            }
+        }
+        
         RT t;
 
         // inserting test
         {
             clock_t::time_point start = clock_t::now();
-            for (size_t i = 0 ; i < values_count ; ++i )
+            t.insert(values);
-            {
-                float x = coords[i].first;
-                float y = coords[i].second;
-                B b(P(x - 0.5f, y - 0.5f), P(x + 0.5f, y + 0.5f));
-
-                t.insert(b);
-            }
             dur_t time = clock_t::now() - start;
             std::cout << time << " - insert " << values_count << '\n';
         }
 
-        std::vector<B> result;
+        
-        result.reserve(100);
-        B result_one;
 
         {
             clock_t::time_point start = clock_t::now();

index/example/glut_vis.cpp

@@ -622,6 +622,36 @@ void keyboard(unsigned char key, int /*x*/, int /*y*/)
 
             glutPostRedisplay();
         }
+        else if ( current_line == "bulk" )
+        {
+            vect.clear();
+
+            for ( size_t i = 0 ; i < 35 ; ++i )
+            {
+                float x = ( rand() % 100 );
+                float y = ( rand() % 100 );
+                float w = ( rand() % 2 ) + 1;
+                float h = ( rand() % 2 ) + 1;
+
+                B b(P(x - w, y - h),P(x + w, y + h));
+                vect.push_back(b);
+
+                std::cout << "inserted: ";
+                bgi::detail::utilities::print_indexable(std::cout, b);
+                std::cout << '\n';
+            }
+
+            RTree t2(vect);
+            t = boost::move(t2);
+
+            std::cout << ( bgi::detail::rtree::utilities::are_boxes_ok(t) ? "boxes OK\n" : "WRONG BOXES!\n" );
+            std::cout << ( bgi::detail::rtree::utilities::are_levels_ok(t) ? "levels OK\n" : "WRONG LEVELS!\n" );
+            std::cout << "\n";
+
+            search_valid = false;
+
+            glutPostRedisplay();
+        }
         else
         {
             if ( current_line == "knn" )

index/test/movable.hpp

@@ -1,15 +1,15 @@
-//////////////////////////////////////////////////////////////////////////////
+// Boost.Geometry.Index varray
-//
+// Unit Test
-// (C) Copyright Ion Gaztanaga 2009.
+
-// Distributed under the Boost Software License, Version 1.0.
+// Copyright (c) 2009 Ion Gaztanaga
-// (See accompanying file LICENSE_1_0.txt or copy at
+// Copyright (c) 2012-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)
-//
+
-// See http://www.boost.org/libs/move for documentation.
+#ifndef BOOST_GEOMETRY_INDEX_TEST_MOVABLE_HPP
-//
+#define BOOST_GEOMETRY_INDEX_TEST_MOVABLE_HPP
-//////////////////////////////////////////////////////////////////////////////
-#ifndef BOOST_MOVE_TEST_MOVABLE_HPP
-#define BOOST_MOVE_TEST_MOVABLE_HPP
 
 //[movable_definition 
 //header file "movable.hpp"
@@ -39,10 +39,10 @@ public:
 class copy_movable
 {
     BOOST_COPYABLE_AND_MOVABLE(copy_movable)
-    int value_;
+    size_t value_;
     
 public:
-    copy_movable(int value = 1) : value_(value){}
+    copy_movable(size_t value = 1) : value_(value){}
     
     //Move constructor and assignment
     copy_movable(BOOST_RV_REF(copy_movable) m)
@@ -89,4 +89,4 @@ struct has_nothrow_move<copy_movable>
 }  //namespace boost{
 //]
 
-#endif //BOOST_MOVE_TEST_MOVABLE_HPP
+#endif //BOOST_GEOMETRY_INDEX_TEST_MOVABLE_HPP

index/test/varray.cpp

@@ -659,98 +659,98 @@ int test_main(int, char* [])
 {
     BOOST_CHECK(counting_value::count() == 0);
 
-    test_ctor_ndc<int, 10>();
+    test_ctor_ndc<size_t, 10>();
     test_ctor_ndc<value_ndc, 10>();
     test_ctor_ndc<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_ctor_ndc<shptr_value, 10>();
     test_ctor_ndc<copy_movable, 10>();
 
-    test_ctor_nc<int, 10>(5);
+    test_ctor_nc<size_t, 10>(5);
     test_ctor_nc<value_nc, 10>(5);
     test_ctor_nc<counting_value, 10>(5);
     BOOST_CHECK(counting_value::count() == 0);
     test_ctor_nc<shptr_value, 10>(5);
     test_ctor_nc<copy_movable, 10>(5);
 
-    test_ctor_nd<int, 10>(5, 1);
+    test_ctor_nd<size_t, 10>(5, 1);
     test_ctor_nd<value_nd, 10>(5, value_nd(1));
     test_ctor_nd<counting_value, 10>(5, counting_value(1));
     BOOST_CHECK(counting_value::count() == 0);
     test_ctor_nd<shptr_value, 10>(5, shptr_value(1));
     test_ctor_nd<copy_movable, 10>(5, produce());
 
-    test_resize_nc<int, 10>(5);
+    test_resize_nc<size_t, 10>(5);
     test_resize_nc<value_nc, 10>(5);
     test_resize_nc<counting_value, 10>(5);
     BOOST_CHECK(counting_value::count() == 0);
     test_resize_nc<shptr_value, 10>(5);
     test_resize_nc<copy_movable, 10>(5);
 
-    test_resize_nd<int, 10>(5, 1);
+    test_resize_nd<size_t, 10>(5, 1);
     test_resize_nd<value_nd, 10>(5, value_nd(1));
     test_resize_nd<counting_value, 10>(5, counting_value(1));
     BOOST_CHECK(counting_value::count() == 0);
     test_resize_nd<shptr_value, 10>(5, shptr_value(1));
     test_resize_nd<copy_movable, 10>(5, produce());
 
-    test_push_back_nd<int, 10>();
+    test_push_back_nd<size_t, 10>();
     test_push_back_nd<value_nd, 10>();
     test_push_back_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_push_back_nd<shptr_value, 10>();
     test_push_back_nd<copy_movable, 10>();
 
-    test_pop_back_nd<int, 10>();
+    test_pop_back_nd<size_t, 10>();
     test_pop_back_nd<value_nd, 10>();
     test_pop_back_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_pop_back_nd<shptr_value, 10>();
     test_pop_back_nd<copy_movable, 10>();
 
-    test_copy_and_assign_nd<int, 10>(1);
+    test_copy_and_assign_nd<size_t, 10>(1);
     test_copy_and_assign_nd<value_nd, 10>(value_nd(1));
     test_copy_and_assign_nd<counting_value, 10>(counting_value(1));
     BOOST_CHECK(counting_value::count() == 0);
     test_copy_and_assign_nd<shptr_value, 10>(shptr_value(1));
     test_copy_and_assign_nd<copy_movable, 10>(produce());
 
-    test_iterators_nd<int, 10>();
+    test_iterators_nd<size_t, 10>();
     test_iterators_nd<value_nd, 10>();
     test_iterators_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_iterators_nd<shptr_value, 10>();
     test_iterators_nd<copy_movable, 10>();
 
-    test_erase_nd<int, 10>();
+    test_erase_nd<size_t, 10>();
     test_erase_nd<value_nd, 10>();
     test_erase_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_erase_nd<shptr_value, 10>();
     test_erase_nd<copy_movable, 10>();
 
-    test_insert_nd<int, 10>(50);
+    test_insert_nd<size_t, 10>(50);
     test_insert_nd<value_nd, 10>(value_nd(50));
     test_insert_nd<counting_value, 10>(counting_value(50));
     BOOST_CHECK(counting_value::count() == 0);
     test_insert_nd<shptr_value, 10>(shptr_value(50));
     test_insert_nd<copy_movable, 10>(produce());
 
-    test_capacity_0_nd<int>();
+    test_capacity_0_nd<size_t>();
     test_capacity_0_nd<value_nd>();
     test_capacity_0_nd<counting_value>();
     BOOST_CHECK(counting_value::count() == 0);
     test_capacity_0_nd<shptr_value>();
     test_capacity_0_nd<copy_movable>();
 
-    test_exceptions_nd<int, 10>();
+    test_exceptions_nd<size_t, 10>();
     test_exceptions_nd<value_nd, 10>();
     test_exceptions_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_exceptions_nd<shptr_value, 10>();
     test_exceptions_nd<copy_movable, 10>();
 
-    test_swap_and_move_nd<int, 10>();
+    test_swap_and_move_nd<size_t, 10>();
     test_swap_and_move_nd<value_nd, 10>();
     test_swap_and_move_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
@@ -763,7 +763,7 @@ int test_main(int, char* [])
     test_emplace_2p<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
 
-    test_sv_elem<int, 10>(50);
+    test_sv_elem<size_t, 10>(50);
     test_sv_elem<value_nd, 10>(value_nd(50));
     test_sv_elem<counting_value, 10>(counting_value(50));
     BOOST_CHECK(counting_value::count() == 0);

index/test/varray_test.hpp

@@ -19,38 +19,38 @@
 class value_ndc
 {
 public:
-    explicit value_ndc(int a) : aa(a) {}
+    explicit value_ndc(size_t a) : aa(a) {}
     ~value_ndc() {}
     bool operator==(value_ndc const& v) const { return aa == v.aa; }
     bool operator<(value_ndc const& v) const { return aa < v.aa; }
 private:
     value_ndc(value_ndc const&) {}
     value_ndc & operator=(value_ndc const&) { return *this; }
-    int aa;
+    size_t aa;
 };
 
 class value_nd
 {
 public:
-    explicit value_nd(int a) : aa(a) {}
+    explicit value_nd(size_t a) : aa(a) {}
     ~value_nd() {}
     bool operator==(value_nd const& v) const { return aa == v.aa; }
     bool operator<(value_nd const& v) const { return aa < v.aa; }
 private:
-    int aa;
+    size_t aa;
 };
 
 class value_nc
 {
 public:
-    explicit value_nc(int a = 0) : aa(a) {}
+    explicit value_nc(size_t a = 0) : aa(a) {}
     ~value_nc() {}
     bool operator==(value_nc const& v) const { return aa == v.aa; }
     bool operator<(value_nc const& v) const { return aa < v.aa; }
 private:
     value_nc(value_nc const&) {}
     value_nc & operator=(value_ndc const&) { return *this; }
-    int aa;
+    size_t aa;
 };
 
 class counting_value
@@ -58,7 +58,7 @@ class counting_value
     BOOST_COPYABLE_AND_MOVABLE(counting_value)
 
 public:
-    explicit counting_value(int a = 0, int b = 0) : aa(a), bb(b) { ++c(); }
+    explicit counting_value(size_t a = 0, size_t b = 0) : aa(a), bb(b) { ++c(); }
     counting_value(counting_value const& v) : aa(v.aa), bb(v.bb) { ++c(); }
     counting_value(BOOST_RV_REF(counting_value) p) : aa(p.aa), bb(p.bb) { p.aa = 0; p.bb = 0; ++c(); }                      // Move constructor
     counting_value& operator=(BOOST_RV_REF(counting_value) p) { aa = p.aa; p.aa = 0; bb = p.bb; p.bb = 0; return *this; }   // Move assignment
@@ -70,7 +70,7 @@ public:
 
 private:
     static size_t & c() { static size_t co = 0; return co; }
-    int aa, bb;
+    size_t aa, bb;
 };
 
 namespace boost {
@@ -85,13 +85,13 @@ struct has_nothrow_move<counting_value>
 
 class shptr_value
 {
-    typedef boost::shared_ptr<int> Ptr;
+    typedef boost::shared_ptr<size_t> Ptr;
 public:
-    explicit shptr_value(int a = 0) : m_ptr(new int(a)) {}
+    explicit shptr_value(size_t a = 0) : m_ptr(new size_t(a)) {}
     bool operator==(shptr_value const& v) const { return *m_ptr == *(v.m_ptr); }
     bool operator<(shptr_value const& v) const { return *m_ptr < *(v.m_ptr); }
 private:
-    boost::shared_ptr<int> m_ptr;
+    boost::shared_ptr<size_t> m_ptr;
 };
 
 #endif // BOOST_GEOMETRY_INDEX_TEST_VARRAY_TEST_HPP