geometry/tests/additional_sizes_and_times.cpp

// Boost.Geometry (aka GGL, Generic Geometry Library)
//
// Boost.Index - example
//
// 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)

#include <iostream>
#include <fstream>

#include <boost/geometry/extensions/index/rtree/rtree.hpp>

#include <boost/geometry/extensions/index/rtree/visitors/are_boxes_ok.hpp>
#include <boost/geometry/extensions/index/rtree/visitors/are_levels_ok.hpp>

#include <boost/timer.hpp>
#include <boost/foreach.hpp>
#include <boost/random.hpp>

int main()
{
    boost::timer tim;

    namespace bg = boost::geometry;
    namespace bgi = bg::index;

	//typedef bg::model::d2::point_xy<double> P;
    typedef bg::model::point<double, 2, bg::cs::cartesian> P;
    typedef bg::model::box<P> B;
    //typedef bgi::rtree<std::pair<B, size_t>, bgi::linear<32, 8> > RT;
    //typedef bgi::rtree<std::pair<B, size_t>, bgi::quadratic<32, 8> > RT;
    typedef bgi::rtree<std::pair<B, size_t>, bgi::rstar<32, 8> > RT;
	/*typedef bgi::rtree<
		std::pair<B, size_t>,
		bgi::options::rtree<bgi::rstar<32, 8, 0, 10>, 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");
    size_t values_count = 0;
    size_t remove_count = 0;
    size_t queries_count = 0;
    std::string file_name("");
    file_cfg >> values_count;
    file_cfg >> remove_count;
    file_cfg >> queries_count;
    file_cfg >> file_name;
    std::cout << "v: " << values_count << ", r: " << remove_count << ", q: " << queries_count << "\n";

    if ( values_count < remove_count )
    {
        std::cout << "can't remove more data than was inserted\n";
        return 0;
    }

    // prepare data buffer
    std::vector< std::pair<float, float> > coords;
    coords.reserve(values_count);
    
    // load test coordinates
    if ( file_name != "" )
    {
        std::ifstream file(file_name.c_str());
        if ( !file.is_open() )
        {
            std::cout << "can't open file containing coordinates\n";
            return 0;
        }

        std::cout << "loading data\n";
        for ( size_t i = 0 ; i < values_count ; ++i )
        {
            std::pair<float, float> v;
            file >> v.first;
            file >> v.second;
            coords.push_back(v);
        }
        std::cout << "loaded\n";

        if ( coords.size() != values_count || coords.size() < remove_count )
        {
            std::cout << "not enough coordinates loaded\n";
            return 0;
        }
    }
    // randomize
    else
    {
        boost::mt19937 rng;
		//rng.seed(static_cast<unsigned int>(std::time(0)));
        
		float max_val = static_cast<float>(values_count / 2);
        boost::uniform_real<float> range(-max_val, max_val);
        
		boost::variate_generator<boost::mt19937&, boost::uniform_real<float> > rnd(rng, range);
		
        std::cout << "randomizing data\n";
        for ( size_t i = 0 ; i < values_count ; ++i )
        {
            coords.push_back(std::make_pair(rnd(), rnd()));
        }
        std::cout << "randomized\n";
    }
    
    // create rtree
    RT t;

    // elements inserting test
    {
        std::cout << "inserting time test...\n";
        tim.restart();
        for (size_t i = 0 ; i < values_count ; ++i )
        {
            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(std::make_pair(b, i));
        }
        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";

    // searching test
    {
        std::cout << "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<B, size_t> > result;
            t.find(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";
        tim.restart();
        for (size_t i = 0 ; i < remove_count ; ++i )
        {
            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.remove(std::make_pair(b, i));
        }
        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";

    // searching test
    {
        std::cout << "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<B, size_t> > result;
            t.find(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";
    }

    // inserting test
    {
        std::cout << "inserting time test...\n";
        tim.restart();
        for (size_t i = 0 ; i < remove_count ; ++i )
        {
            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(std::make_pair(b, i));
        }
        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";

    // searching test
    {
        std::cout << "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<B, size_t> > result;
            t.find(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";
    }

    std::cin.get();

    return 0;
}