[/============================================================================
  Boost.Geometry Index

  Copyright (c) 2011-2013 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)
=============================================================================/]

[section Experimental Features]

This section describes experimental features which are implemented but unavailable by default.
Be aware that they may not be released in the future or functionalities may be released but
behind different interface.

To enable them one must define `BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL` in compiler's command line or before
including spatial index.

[heading Nearest query distance calculation]

It is possible to define how distance to the non-point `__value__` should be calculated. To do this one may pass
a relation object instead of a Point to the nearest predicate, as follows:

 /* calculate distance to the Indexables' nearest points */
 rtree.query(index::nearest(index::to_nearest(pt), k), std::back_inserter(returned_values)); // same as default

 /* calculate distance to the Indexables' centroid */
 rtree.query(index::nearest(index::to_centroid(pt), k), std::back_inserter(returned_values));

 /* calculate distance to the Indexables' furthest points */
 rtree.query(index::nearest(index::to_furthest(pt), k), std::back_inserter(returned_values));

[heading Path query]

Path query returns `k` first `__value__`s intersecting a path defined by a `Segment` or a`Linestring`. The result of a query returning first 5
values intersecting a path is presented below. Path's flow is denoted by blue arrows, returned values are orange.

[$img/index/rtree/path.png]
 
To perform this query one may pass a `path()` predicate taking a `Segment` or a `Linestring` and maximum number of `__value__`s which
should be returned:

 rtree.query(index::path(segment, k), std::back_inserter(returned_values));
 rtree.query(index::path(linestring, k), std::back_inserter(returned_values));

[warning Only one distance predicate may be used in a query. This means that there can be only one `nearest()` or `path()` predicate passed. Passing more of them will result in compile-time error.]

[heading Incremental queries]

Sometimes there is a need to stop querying at some desired moment because for example the decision that query should find another value
is made after analysis of previously returned values. There can also be desirable to pause querying and resume it later. 

Currently, those kind of incremental queries are implemented as input (single pass) const iterators, relatively
big fat-iterators storing stack used in the tree-traversing process. Because the type of predicates passed
to the query varies, the type of the iterator varies as well.

Therefore to use query iterators one must pass them to some function template, then types will be deduced
automatically. If iterators objects must be stored one may use Boost.Typeof library to retrieve a type from
an expression or use C++11 `auto` or `decltype`.

 /* function call */
 std::copy(rtree.qbegin(index::intersects(box)), rtree.qend(index::intersects(box)), std::back_inserter(returned_values));
 
 /* Boost.Typeof */
 typedef BOOST_TYPEOF(rtree.qbegin(index::nearest(pt, 5))) const_query_iterator;
 const_query_iterator first = rtree.qbegin(index::nearest(pt, 5));
 const_query_iterator last = rtree.qend(index::nearest(pt, 5));
 // ...
 for ( ; first != last ; ++first )
     *first; // do something with Value
 
 /* C++11 */
 auto first = rtree.qbegin(index::nearest(pt, 5));
 auto last = rtree.qend(index::nearest(pt, 5));
 // ...
 for ( ; first != last ; ++first )
     *first; // do something with Value

`qend()` method is overloaded to return a different, lighter type of iterator which may be compared
with query iterator to check if the querying was finished. But since it has different type than the one returned by
`qbegin(Pred)` it can't be used with STL-like functions like `std::copy()` which expect that `first` and `last`
iterators have the same type.

 /* function call */
 template <typename First, typename Last, typename Out>
 void my_copy(First first, Last last, Out out)
 {
     for ( ; first != last ; ++out, ++first )
         *out = *first;
 }
 // ...
 my_copy(rtree.qbegin(index::intersects(box)), rtree.qend(), std::back_inserter(returned_values));
 
 /* Boost.Typeof */
 typedef BOOST_TYPEOF(rtree.qbegin(index::nearest(pt, 5))) const_query_iterator;
 typedef BOOST_TYPEOF(rtree.qend()) end_iterator;
 const_query_iterator first = rtree.qbegin(index::nearest(pt, 5));
 end_iterator last = rtree.qend();
 // ...
 for ( ; first != last ; ++first )
     *first; // do something with Value
 
 /* C++11 */
 auto first = rtree.qbegin(index::nearest(pt, 5));
 auto last = rtree.qend();
 // ...
 for ( ; first != last ; ++first )
     *first; // do something with Value

[endsect] [/ Experimental features /]
