mirror of https://github.com/CGAL/cgal
115 lines
4.0 KiB
TeX
115 lines
4.0 KiB
TeX
\begin{ccRefClass}{Range_tree_k<Traits>}
|
|
|
|
\ccDefinition
|
|
|
|
An object of the class \ccClassName\ is a $k$-dimensional range tree
|
|
that can store k-dimensional keys of type \ccc{Key}.
|
|
The class allows to perform
|
|
window queries on the keys. The class \ccClassName\ is parameterized with
|
|
a range tree traits class \ccc{Traits} that defines, among other things,
|
|
the type of the \ccc{Key}.
|
|
|
|
\cgal\ provides traits class implementations that allow to use
|
|
the range tree with point classes from the \cgal\ kernel as keys.
|
|
These classes are \ccc{CGAL::Range_segment_tree_traits_set_2<R>},
|
|
\ccc{CGAL::Range_segment_tree_traits_set_3<R>},
|
|
\ccc{CGAL::Range_tree_traits_map_2<R>} and
|
|
\ccc{CGAL::Range_tree_traits_map_3<R>}. The concept
|
|
RangeSegmentTreeTraits\_d defines the requirements that range tree traits
|
|
classes must fulfill. This allows the advanced user to develop further
|
|
range tree traits classes.
|
|
|
|
\ccInclude{CGAL/Range_tree_k.h}
|
|
|
|
|
|
\ccTypes
|
|
|
|
\ccNestedType{Traits}{the type of the range tree traits class.}
|
|
\ccTypedef{typedef Traits::Key Key;}{}
|
|
\ccTypedef{typedef Traits::Interval Interval;}{}
|
|
|
|
\ccCreationVariable{R}
|
|
|
|
|
|
\ccCreation
|
|
|
|
\ccConstructor{Range_tree_k ();}
|
|
{Introduces an empty range tree \ccVar.}
|
|
|
|
\ccConstructor{template < class ForwardIterator >
|
|
Range_tree_k (ForwardIterator first,
|
|
ForwardIterator last);}
|
|
{Introduces a range tree \ccVar\ and initializes it with the data
|
|
in the range \ccc{[first, last)}.
|
|
\ccPrecond \ccc{value_type(first) == Traits::Key}.}
|
|
|
|
\ccOperations
|
|
|
|
\ccMethod{template < class ForwardIterator >
|
|
void
|
|
make_tree(ForwardIterator first,
|
|
ForwardIterator last);}%
|
|
{Introduces a range tree \ccVar\ and initializes it with the data
|
|
in the range \ccc{[first, last)}. This function can only be applied
|
|
once on an empty range tree.
|
|
\ccPrecond \ccc{value_type(first) == Traits::Key}.}
|
|
|
|
|
|
\ccMethod{template < class OutputIterator >
|
|
OutputIterator
|
|
window_query(Interval window,
|
|
OutputIterator out);}%
|
|
{writes all data that are in the interval \ccc{window} to the container
|
|
where \ccc{out} points to, and returns an output iterator that points
|
|
to the last location the function wrote to.
|
|
\ccPrecond \ccc{value_type(out) == Traits::Key}.}
|
|
|
|
|
|
\ccExample
|
|
The following example program uses the predefined \ccc{
|
|
Range_tree_2} data structure together with the predefined traits
|
|
class \ccc{Range_tree_map_traits_2} which has two template
|
|
arguments specifying the
|
|
type of the point data in each dimension
|
|
(\ccc{CGAL::Cartesian<double>}) and the value type of the
|
|
2-dimensional point data (\ccc{char}). Therefore the \ccc{
|
|
Range_tree_2} is defined on 2-dimensional point data
|
|
(\ccc{CGAL::Point_2<Cartesian<double> >}) each of which is
|
|
associated with a character.
|
|
Then, a few data items are created and put into a list. After
|
|
that the tree is constructed according to that list, a window
|
|
query is performed, and the query elements are given out.
|
|
|
|
\begin{verbatim}
|
|
|
|
#include <CGAL/Cartesian.h>
|
|
#include <CGAL/Range_segment_tree_traits.h>
|
|
#include <CGAL/Range_tree_k.h>
|
|
|
|
typedef CGAL::Cartesian<double> K;
|
|
typedef CGAL::Range_tree_map_traits_2<K, char> Traits;
|
|
typedef CGAL::Range_tree_2<Traits> Range_tree_2_type;
|
|
|
|
int main()
|
|
{
|
|
typedef Traits::Key Key;
|
|
typedef Traits::Interval Interval;
|
|
|
|
std::vector<Key> InputList, OutputList;
|
|
InputList.push_back(Key(K::Point_2(8,5.1), 'a'));
|
|
InputList.push_back(Key(K::Point_2(1,1.1), 'b'));
|
|
InputList.push_back(Key(K::Point_2(3,2.1), 'c'));
|
|
|
|
Range_tree_2_type Range_tree_2(InputList.begin(),InputList.end());
|
|
Interval win(Interval(K::Point_2(4,8.1), K::Point_2(5,8.2)));
|
|
std::cout << "\n Window Query:\n ";
|
|
Range_tree_2.window_query(win, std::back_inserter(OutputList));
|
|
std::vector<Key>::iterator current=OutputList.begin();
|
|
while(current!=OutputList.end()){
|
|
std::cout << (*current).first.x() << "," << (*current).first.y()
|
|
<< ":" << (*current++).second << std::endl;
|
|
}
|
|
}
|
|
\end{verbatim}
|
|
\end{ccRefClass}
|