int main()
{
gst_check_init (NULL, NULL);
create_queries();
test_queries();
}
static gboolean
next_test (InsanityTest * test)
{
switch (glob_in_progress) {
case TEST_NONE:
glob_in_progress = TEST_QUERIES;
test_queries (test);
break;
case TEST_QUERIES:
glob_in_progress = TEST_POSITION;
break;
case TEST_POSITION:
if (glob_seekable == FALSE) {
/* Do not enter seek mode tests and finnish the test */
unvalidate_seeking_tests (test);
insanity_test_done (test);
return FALSE;
}
glob_in_progress = TEST_BACKWARD_PLAYBACK;
glob_waiting_segment = TRUE;
g_timeout_add (1000, (GSourceFunc) & seek_mode_testing, test);
break;
case TEST_BACKWARD_PLAYBACK:
glob_in_progress = TEST_FAST_FORWARD;
glob_waiting_segment = TRUE;
g_timeout_add (1000, (GSourceFunc) & seek_mode_testing, test);
break;
case TEST_FAST_FORWARD:
glob_in_progress = TEST_FAST_BACKWARD;
glob_waiting_segment = TRUE;
g_timeout_add (1000, (GSourceFunc) & seek_mode_testing, test);
break;
default:
insanity_test_done (test);
return FALSE;
}
LOG (test, "%s in progress", test_get_name (glob_in_progress));
return FALSE;
}
int main()
{
//typedef bgi::rtree<V, bgi::linear<4, 2> > RT;
//typedef bgi::rtree<V, bgi::linear<16, 4> > RT;
//typedef bgi::rtree<V, bgi::quadratic<4, 2> > RT;
typedef bgi::rtree<V, bgi::rstar<8, 2> > RT;
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 = 20000;
unsigned neighbours_count = 10;
size_t max_range_inserts = 10;
#else
size_t values_count = 10000;
size_t queries_count = 1000;
size_t nearest_queries_count = 100;
unsigned neighbours_count = 10;
size_t max_range_inserts = 10;
#endif
float max_val = static_cast<float>(values_count / 2);
std::vector< std::pair<float, float> > coords;
std::vector<V> values;
//randomize values
{
boost::mt19937 rng;
//rng.seed(static_cast<unsigned int>(std::time(0)));
boost::uniform_real<float> range(-max_val, max_val);
boost::variate_generator<boost::mt19937&, boost::uniform_real<float> > rnd(rng, range);
coords.reserve(values_count);
std::cout << "randomizing data\n";
for ( size_t i = 0 ; i < values_count ; ++i )
{
float x = rnd();
float y = rnd();
coords.push_back(std::make_pair(x, y));
values.push_back(generate_value<V>::apply(x, y));
}
std::cout << "randomized\n";
}
for (;;)
{
// packing test
{
clock_t::time_point start = clock_t::now();
RT t(values.begin(), values.end());
BOOST_ASSERT(bgi::detail::rtree::utilities::are_boxes_ok(t));
BOOST_ASSERT(bgi::detail::rtree::utilities::are_counts_ok(t));
BOOST_ASSERT(bgi::detail::rtree::utilities::are_levels_ok(t));
dur_t time = clock_t::now() - start;
std::cout << "pack(" << values_count << ") - " << time.count() << ", ";
test_queries(t, coords, queries_count);
}
{
size_t n_per_max = values_count / max_range_inserts;
for ( size_t j = 0 ; j < max_range_inserts ; ++j )
{
clock_t::time_point start = clock_t::now();
RT t;
// perform j range-inserts
for ( size_t i = 0 ; i < j ; ++i )
{
t.insert(values.begin() + n_per_max * i,
values.begin() + (std::min)(n_per_max * (i + 1), values_count));
}
if ( !t.empty() )
{
BOOST_ASSERT(bgi::detail::rtree::utilities::are_boxes_ok(t));
BOOST_ASSERT(bgi::detail::rtree::utilities::are_counts_ok(t));
BOOST_ASSERT(bgi::detail::rtree::utilities::are_levels_ok(t));
}
// perform n-n/max_inserts*j inserts
size_t inserted_count = (std::min)(n_per_max*j, values_count);
for ( size_t i = inserted_count ; i < values_count ; ++i )
{
t.insert(values[i]);
}
if ( !t.empty() )
{
BOOST_ASSERT(bgi::detail::rtree::utilities::are_boxes_ok(t));
BOOST_ASSERT(bgi::detail::rtree::utilities::are_counts_ok(t));
BOOST_ASSERT(bgi::detail::rtree::utilities::are_levels_ok(t));
}
dur_t time = clock_t::now() - start;
std::cout << j << "*insert(N/" << max_range_inserts << ")+insert(" << (values_count - inserted_count) << ") - " << time.count() << ", ";
test_queries(t, coords, queries_count);
}
}
std::cout << "------------------------------------------------\n";
}
return 0;
}
