Chapter 34
Interval Skip List

34.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].

34.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.

34.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: 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;

}

34.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: 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;
}