CGAL - the Computational Geometry Algorithm Library

History

The goal: make the large body of geometric algorithms developed in the field of computational geometry available for industrial applications
Developed in C++ and follows the Generic Programming paradigm
Development started at 1995
First release appeared in June 1997
Current public version is 3.2.1
Developed by a consortium consisting of a few institutions in Europe and Israel (ETH, FUB, TAU, ...)
- Correctness
- Flexibility
- Efficiency
- Ease of use

Architecture

Geometric Kernel
- Constant-size geometric objects (e.g., points, lines, planes, etc.)
- Predicates and constructors of these objects
Basic Library
- Data structure and algorithms (e.g., Triangulations, Polyhedrons, Arrangements, etc.)
Support Library
- Number types
- Geometric-object generators
- Input/Output
- Visualization
- More none geometric types (e.g., Circulators, etc.)

Flexibility

Open library
- Depends on other libraries (e.g., Boost, Gmp, Mpfr, Qt, Core)
Modular structure. Separation between to geometry and topology.
Adaptable to user code
Extensible, e.g., data structures can be extended.

Correctness

Addresses robustness problems
Relies on exact predicate evaluation
- Exact arithmetic
- Explicit degeneracy handling

Ease of use

Manuals
Follows standard concepts (C++, STL, etc.)
Smooth learning-curve

Efficiency

Follows the generic programming paradigm.
Polymorphism is resolved at compile time
- Has no run-time overhead cost
- Large code footprint and exhausting compilation processes
Flexibility alows user to pick the best choice at the application level.

Geometric Kernel Classification

Dimension - 2, 3, arbitrary
Number types:
- Euclidean ring (adds integer division and gcd) (e.g., CGAL::Gmpz)
- Field - +,-,*,\ (e.g., CGAL::Quotient(CGAL::Gmpz))
- Exact sign evaluation for expressions with roots (Field_with_sqr)
Coordinate representation
- Cartesian - requires a field number type or Euclidean ring if no constructions are performed
- Homogeneous - requires Euclidean ring
Reference Counting

Geometric Kernel (easy) Choices

CGAL::Exact_predicates_inexact_constructions_kernel
CGAL::Exact_predicates_exact_constructions_kernel
CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt

Orientation of a triple: Version 1

Computing the orientation of 3 points in the plane.

#include <CGAL/MP_Float.h>
#include <CGAL/Homogeneous.h>

typedef CGAL::Homogeneous<CGAL::MP_Float>  Kernel
typedef Kernel::Point_2                    Point_2

int main()
{
  Point_2 p(0,0), q(10,3), r(12,19);
  if (CGAL::orientation(q,p,r) == CGAL::LEFT_TURN)
    return 0;
  return 1
}

Orientation of a triple: Version 2

Increasing flexibility.

#include <CGAL/MP_Float.h>
#include <CGAL/Homogeneous.h>

typedef CGAL::Homogeneous<CGAL::MP_Float>  Kernel
typedef Kernel::Point_2                    Point_2
typedef Kernel::Orientation_2              Orientation_2;

int main()
{
  Kernel kernel;
  Orientation_2 orientation = Kernel.orientation_2_object();

  Point_2 p(0,0), q(10,3), r(12,19);
  if (orientation(q,p,r) == CGAL::LEFT_TURN)
    return 0;
  return 1
}

Basic Library

Generic data structures are parameterized with Traits
- Separates alg. and data structure from the geometric kernel
Generic algorithms are parameterized with iterator ranges
- Decouples the alg. from the data structure

Convex Hull Definition

A subset

S ² is convex if for any two points

p and

q in the set the line segment with endpoints

p and

q is contained in

S. The convex hull of a set

S is the smallest convex set containing

S. The convex hull of a set of points

P is a convex polygon with vertices in

Upper Convex Hull: Version 1

Using Random Access Iterator
- Provides both increment and decrement
- Constant-time methods for moving forward and backward in arbitrary-sized steps ('[]' operator)

template <class Iterator, class Output, class Traits>
Output
upper_hull1(Iterator first, Iterator beyond, Output result, Traits traits)
{ 
  typename Traits::Less_xy_2 less_xy = traits.less_xy_2_object();
  typename Traits::Left_turn_2 left_turn = traits.left_turn_2_object();
  
  if (first == beyond)                  // empty sequence
    return result;
  std::sort(first, beyond, less_xy);    // lexicographic sorting
  std::vector<typename Traits::Point_2> hull;
  hull.push_back(*first);               // sentinel
  hull.push_back(*first);

  // upper convex hull (left to right)
  for (++first; first != beyond; ++first) {
    while (left_turn(hull.end()[-2], hull.back(), *first))
      hull.pop_back();
    hull.push_back(*first);
  }
  return std::copy(hull.begin() + 1, hull.end(), result); // return result
}

upper_hull_2.C

Upper Convex Hull: Version 2

Maintaining the current point separately.

template <class Iterator, class Output, class Traits>
Output
upper_hull2(Iterator first, Iterator beyond, Output result, Traits traits)
{ 
  typename Traits::Less_xy_2 less_xy = traits.less_xy_2_object();
  typename Traits::Left_turn_2 left_turn = traits.left_turn_2_object();
    
  if (first == beyond)                  // empty sequence
    return result;
  std::sort(first, beyond, less_xy);    // lexicographic sorting
  std::vector<typename Traits::Point_2> hull;
  hull.push_back(*first);               // sentinel
  typename Traits::Point_2 p = *first;  // last point on the hull
  ++first;                              // next candidate for hull point
  // scan all points from left to right for upper convex hull
  for (; first != beyond; ++first) {
    while (left_turn(hull.back(), p, *first)) {
      p = hull.back();
      hull.pop_back();
    }
    hull.push_back(p);
    p = *first;
  }
  hull.push_back(p);
  return std::copy(hull.begin() + 1, hull.end(), result); // return result
}

upper_hull_2.C

Upper Convex Hull: Version 3

Maintaining an iterator that points to the current point separately.

template <class Iterator, class Output, class Traits>
Output
upper_hull3(Iterator first, Iterator beyond, Output result, Traits traits)
{ 
  typename Traits::Less_xy_2 less_xy = traits.less_xy_2_object();
  typename Traits::Left_turn_2 left_turn = traits.left_turn_2_object();
    
  if (first == beyond)                  // empty sequence
    return result;
  std::sort(first, beyond, less_xy);    // lexicographic sorting
  std::vector<Iterator> hull;
  hull.push_back(first);                // sentinel
  Iterator p = first;                   // last point on the hull
  ++first;                              // next candidate for hull point
  // scan all points from left to right for upper convex hull
  for (; first != beyond; ++first) {
    while (left_turn(*(hull.back()), *p, *first)) {
      p = hull.back();
      hull.pop_back();
    }
    hull.push_back(p);
    p = first;
  }
  typename std::vector<Iterator>::iterator i = hull.begin();
  ++i;                                  // skip sentinel
  while (i != hull.end())
    *result++ = **i++;
  return result;
}

upper_hull_2.C

Upper Convex Hull: Version 4

More generic - can be used for computing the lower hull.

template <class Iterator, class Pred>   // bidirectional iterator
Iterator remove_if_triple(Iterator first, Iterator beyond, Pred pred)
{ 
  if (first == beyond)
    return first;
  // setup iterators i,j,k for scanning triples
  Iterator i = first, j = first;
  if (++j == beyond)    // i,j mark two elements on top of stack
    return j;
  Iterator k = j;       // k marks the third value in the sequence
  while (++k != beyond) {
    while ((pred(*i, *j, *k))) { 
      j = i;            // remove one element from stack
      if (i == first)   // explicit test for stack underflow
        break;
      --i;              // remove one element from the stack, part 2
    }
    i = j;              // push new element from k on stack
    ++j;
    *j = *k;
  }
  return ++j;
}

template <class Iterator, class Output, class Traits>
Output upper_hull(Iterator first, Iterator beyond, Output result, Traits traits)
{ 
  typename Traits::Less_xy_2 less_xy = traits.less_xy_2_object();
  typename Traits::Left_turn_2 left_turn = traits.left_turn_2_object();
    
  if (first == beyond)              // empty sequence
    return result;
  std::sort(first, beyond, less_xy); // lexicographic sorting
  Iterator hull_end = remove_if_triple(first, beyond, left_turn);
  return std::copy(first, hull_end, result);
}

upper_hull_2.C

Exercise Notes

Installing CGAL
Minkowski_sum_2 package
- A new package. (Not part of the latest public release.)
- Documentation [html,pdf]
- Code (header files) [compressed tar]
  - tar zxvf include.tar.gz
Functions, classes, and libraries you probably need to use

Installing CGAL

CGAL Version
- Latest public version 3.2.1
- Version 3.2 is installed on the (Linux) Network Appliance.
- Latest internal version is 3.3-I
Dependencies
- Required
- Optional
  - Qt version 3
  - Core, comes with CGAL
- Other (Taucs)
Linux issues
- There are Debian and Fedore packages
- Requires link with the freetype library
Windows issues
- Installing Boost on Windows
- Cgal comes with an installation program
- Qt version 3 is free on Linux but not on Windows

Functions, Classes, and Libraries

glut

template<class Kernel, class Container>
Polygon_with_holes_2
  minkowski_sum_2(Polygon_2<Kernel,Container> P, Polygon_2<Kernel,Container> Q)

computes the Minkowski sum of the two polygons P and Q

template<typename Traits, typename Dcel, typename OutputIterator>
OutputIterator decompose(Arrangement_2<Traits,Dcel> arr, OutputIterator oi)

produces the symbolic vertical decomposition of arr.

template <class InputIterator, class OutputIterator> OutputIterator join(InputIterator begin, InputIterator end, OutputIterator oi)
Computes the union of the general polygons or general polygons with holes in the given range. The value type is CGAL::Polygon_with_holes_2<Kernel,Container>
CGAL::Polygon_set_2<Kernel>
represents sets of linear polygons with holes
CGAL::Arrangement_2<Traits,Dcel>

Last modified: November 20 2006.