Multilevel queries on R-trees (Intersection, Union) - c++

Question

Say I have the following setup:
I have a boost::geometry::index::rtree that takes as a key a two-dimensional box and as a value a points.
The first dimension of the box, will in practice be applied to (real-valued closed) intervals, whereas the second only to point.
So my box looks like:
using namespace std;
typedef bg::model::point<unsigned long, 2, bg::cs::cartesian> _pt_t;
typedef bg::model::box<_pt_t> _box_t;
typedef pair<_box_t, unsigned long> tree_v_t;
typedef bgi::rtree<tree_v_t, bgi::quadratic<16> > rtree_t;
A box will allways be initialized using:
_box_t _mb(unsigned long i, unsigned long s, unsigned long d){
_box_t b(_pt_t(s, i), _pt_t(s + d, i));
return b;
}
Now let's say I have initialised the rtree and I want to do two sorts of complicate queries:
given a set si of intervalsset<pair<unsigned int, unsigned int> > and a set sp of points set<unsigned int>, I would like to iterate all the values that are the result of the following pseudocode query:
any(si, intersect(rtree_level1)) &&
any(sp, contains(rtree_level2)) &&
value in ps
In other words I want the subtree of the rtree that contains the intersection of intervals contained in si and of points contained in sp and that its values are also in sp. If you like you can assume that all intervals in si are disjoint.
given a set spi of points and intervals set<unsigned int, pair<unsigned int, unsigned int> >, I would like to iterate all the values that are the result of the following pseudocode query:
any(spi, intersect(rtree_level1)(spi.interval) &&
contains(rtree_level2)(spi.point) &&
value in spi.point
)
In other words I want the union of all subtrees that come from each element of spi, for which they are the intersection of the given interval and they contain only those points both as keys (second level) and values. This is like the union all the R-trees produced from query 1 if both si and sp have one element.
I can understand how I can do that using the satisfy predicate and applying transform to the iterator produced by qbegin, but
what is the most efficient way to do that in boost?

Answer 1

Here is a basic program with double index (R-tree and std::map) doing bi-directional indexing: from char to box/interval and from box/interval to char:
Includes, iostream is needed only for output.
#include <boost/geometry.hpp>
#include <map>
#include <vector>
#include <iostream>
Namespaces for convenience.
namespace bg = boost::geometry;
namespace bgi = boost::geometry::index;
Basic bi-directional index allowing to insert box/interval-char pairs and find box based on char or vector of chars based on box (intersecting). insert() merges boxes if needed.
template <typename Box, typename T>
class rtree_map_index
{
typedef std::map<T, Box> map_type;
typedef typename map_type::iterator map_iterator;
typedef typename map_type::const_iterator map_const_iterator;
typedef std::pair<Box, map_iterator> rtree_value;
typedef bgi::rtree<rtree_value, bgi::rstar<4> > rtree_type;
public:
void insert(Box const& box, T const& v)
{
std::pair<map_iterator, bool>
p = m_map.insert(std::make_pair(v, box));
map_iterator map_it = p.first;
T const& map_val = map_it->first;
Box & map_box = map_it->second;
// new key,value inserted into map
if (p.second)
{
// insert it to the r-tree
m_rtree.insert(rtree_value(map_box, map_it));
}
// key already exists in map and box has to be expanded
else if (! bg::covered_by(box, map_box))
{
// calculate expanded box
Box new_box = map_box;
bg::expand(new_box, box);
// update r-tree
m_rtree.remove(rtree_value(map_box, map_it));
m_rtree.insert(rtree_value(new_box, map_it));
// update map
map_box = new_box;
}
}
bool find(T const& v, Box & result) const
{
map_const_iterator it = m_map.find(v);
if (it != m_map.end())
{
result = it->second;
return true;
}
return false;
}
void find(Box const& box, std::vector<char> & result) const
{
std::vector<rtree_value> res;
m_rtree.query(bgi::intersects(box), std::back_inserter(res));
result.resize(res.size());
for (size_t i = 0; i < res.size(); ++i)
result[i] = res[i].second->first;
}
private:
rtree_type m_rtree;
map_type m_map;
};
Main function with basic use-case.
int main()
{
for 2-dimentional data stored in the r-tree (boxes).
{
typedef bg::model::point<double, 2, bg::cs::cartesian> point;
typedef bg::model::box<point> box;
rtree_map_index<box, char> index;
index.insert(box(point(0, 0), point(3, 3)), 'a');
index.insert(box(point(1, 1), point(4, 4)), 'a');
index.insert(box(point(5, 5), point(6, 6)), 'b');
box res1;
index.find('a', res1);
std::cout << bg::wkt(res1) << std::endl;
std::vector<char> res2;
index.find(box(point(4, 4), point(5, 5)), res2);
BOOST_ASSERT(res2.size() == 2);
std::cout << res2[0] << std::endl;
std::cout << res2[1] << std::endl;
}
for 1-dimensional data stored in the r-tree (intervals)
{
typedef bg::model::point<double, 1, bg::cs::cartesian> point;
typedef bg::model::box<point> box;
rtree_map_index<box, char> index;
index.insert(box(point(0), point(3)), 'a');
index.insert(box(point(1), point(4)), 'a');
index.insert(box(point(5), point(6)), 'b');
box res1;
index.find('a', res1);
std::cout << "(" << bg::get<0, 0>(res1) << ", " << bg::get<1, 0>(res1) << ")" << std::endl;
std::vector<char> res2;
index.find(box(point(4), point(5)), res2);
BOOST_ASSERT(res2.size() == 2);
std::cout << res2[0] << std::endl;
std::cout << res2[1] << std::endl;
}
The end.
return 0;
}
Note that instead of rtree you could use interval_map. You should be able to build on top of rtree_map_index. You could add a constructor creating map and rtree from a container of elements of type std::pair<Box, T> to take advantage from r-tree packing algorithm. You could implement whatever find() function you need. Etc.