Chapter 55
Interval Skip List
Andreas Fabri
55.1 Definition
An interval skip list is a data strucure 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 [Han91], and it is called
interval skip list, because it is an extension of the randomized list
structure known as skip list [Pug90].
55.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 -ranges
of the faces of a terrain, allowing to answer level queries.
55.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 .
The interval skip list class has as template argument an interval
class. In this example we use the class Interval_skip_list_interval.
// file: examples/Interval_skip_list/intervals.C
#include <CGAL/Interval_skip_list.h>
#include <CGAL/Interval_skip_list_interval.h>
#include <vector>
#include <list>
#include <iostream>
typedef CGAL::Interval_skip_list_interval<double> Interval;
typedef CGAL::Interval_skip_list<Interval> Interval_skip_list;
int main()
{
Interval_skip_list isl;
int i, n, d;
n = 10;
d = 3;
//std::cin >> n >> d;
std::vector<Interval> intervals(n);
for(i = 0; i < n; i++) {
intervals[i] = Interval(i, i+d);
}
std::random_shuffle(intervals.begin(), intervals.end());
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;
}
55.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 -coordinate of the face.
// file: examples/Interval_skip_list/terrain.C
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Delaunay_triangulation_2.h>
#include <CGAL/Triangulation_euclidean_traits_xy_3.h>
#include <CGAL/Interval_skip_list.h>
#include <CGAL/Level_interval.h>
#include <iostream>
#include <fstream>
typedef CGAL::Simple_cartesian<double> SC;
typedef SC::Point_3 Point_3;
typedef CGAL::Triangulation_euclidean_traits_xy_3<SC> K;
typedef CGAL::Delaunay_triangulation_2<K> Delaunay;
typedef Delaunay::Face_handle Face_handle;
typedef Delaunay::Finite_faces_iterator Finite_faces_iterator;
typedef CGAL::Level_interval<Face_handle> Interval;
typedef CGAL::Interval_skip_list<Interval> Interval_skip_list;
int main()
{
std::ifstream fin("terrain.pts"); // elevation ranges from 0 to 100
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){
isl.insert(Interval(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;
}