- Author
- Andreas Fabri
1
Definition
An interval skip list is a data structure for finding all intervals that contain a point, and for stabbing queries, that is for answering the question whether a given point is contained in an interval or not. The implementation we provide is dynamic, that is the user can freely mix calls to the methods insert(..)
, remove(..)
, find_intervals(..)
, and is_contained(..)
The interval skip list class is parameterized with an interval class.
The data structure was introduced by Hanson [1], and it is called interval skip list, because it is an extension of the randomized list structure known as skip list [2].
2
Example Programs
We give two examples. The first one uses a basic interval class. In the second example we create an interval skip list for the z-ranges of the faces of a terrain, allowing to answer level queries.
2.1
First Example with Simple Interval
The first example reads two numbers n
and d
from std::cin
. It creates n
intervals of length d
with the left endpoint at n
. It then reads out the intervals for the 1-dimensional points with coordinates 0 ... n+d.
The interval skip list class has as template argument an interval class. In this example we use the class Interval_skip_list_interval
.
File Interval_skip_list/intervals.cpp
#include <CGAL/Interval_skip_list.h>
#include <CGAL/Interval_skip_list_interval.h>
#include <CGAL/algorithm.h>
#include <vector>
#include <list>
#include <iostream>
int main()
{
Interval_skip_list isl;
int i, n, d;
n = 10;
d = 3;
std::vector<Interval> intervals(n);
for(i = 0; i < n; i++) {
}
isl.insert(intervals.begin(), intervals.end());
for(i = 0; i < n+d; i++) {
std::list<Interval> L;
isl.find_intervals(i, std::back_inserter(L));
for(std::list<Interval>::iterator it = L.begin(); it != L.end(); it++){
std::cout << *it;
}
std::cout << std::endl;
}
for(i = 0; i < n; i++) {
isl.remove(intervals[i]);
}
return 0;
}
The class Interval_skip_list_interval represents intervals with lower and upper bound of type Value.
Definition: Interval_skip_list_interval.h:18
The class Interval_skip_list is a dynamic data structure that allows to find all members of a set of ...
Definition: Interval_skip_list.h:22
The concept Interval describes the requirements for the template argument Interval of a Interval_skip...
Definition: Interval.h:21
void random_shuffle(RandomAccessIterator begin, RandomAccessIterator end, RandomGenerator &random)
2.2
Example with Faces of a Triangulated Terrain
The second example creates an interval skip list that allows to find all the faces of a terrain intersected by an horizontal plane at a given height. The data points for the terrain are read from a file.
As model for the interval concept, we use a class that is a wrapper around a face handle of a triangulated terrain. Lower and upper bound of the interval are smallest and largest z-coordinate of the face.
File Interval_skip_list/isl_terrain.cpp
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Delaunay_triangulation_2.h>
#include <CGAL/Projection_traits_xy_3.h>
#include <CGAL/Interval_skip_list.h>
#include <CGAL/Level_interval.h>
#include <iostream>
#include <fstream>
typedef EIK::Point_3 Point_3;
typedef CGAL::Delaunay_triangulation_2<K> Delaunay;
typedef Delaunay::Face_handle Face_handle;
typedef Delaunay::Finite_faces_iterator Finite_faces_iterator;
int main()
{
std::ifstream fin("terrain.pts");
Delaunay dt;
dt.insert(std::istream_iterator<Point_3>(fin),
std::istream_iterator<Point_3>());
Interval_skip_list isl;
for(Finite_faces_iterator fh = dt.finite_faces_begin();
fh != dt.finite_faces_end();
++fh){
}
std::list<Interval> level;
isl.find_intervals(50, std::back_inserter(level));
for(std::list<Interval>::iterator it = level.begin();
it != level.end();
++it){
std::cout << dt.triangle(it->face_handle()) << std::endl;
}
return 0;
}
The class Level_interval represents intervals for the minimum and maximum value of the z-coordinate o...
Definition: Level_interval.h:20