Lecture Notes CS 506

CS 506: Computational Geometry
Spring 2001 Robert Pless

This course is modeled on the Computational Geometry Course taught by
Dave Mount, at the University of Maryland.  These notes are
modifications of his Lecture Notes, which are copyrighted as follows:


Copyright, David M. Mount, 2000, Dept. of Computer Science,
University of Maryland, College Park, MD, 20742. These lecture notes
were prepared by David Mount for the course CMSC 754, Computational
Geometry, at the University of Maryland, College Park. Permission to
use, copy, modify, and distribute these notes for educational purposes
and without fee is hereby granted, provided that this copyright notice
appear in all copies.


Lecture 1: Introduction (Tuesday, Jan 16, 2001) 

What is Computational Geometry? Computational geometry is a term
claimed by a number of different groups. The term was coined perhaps
first by Marvin Minsky in his book "Perceptrons", which was about
pattern recognition, and has been used often to describe algorithms
related to solid-modeling. But its most widely recognized use is to
describe the subfield of algorithm theory that involves the design and
analysis of efficient algorithms for problems involving geometric
inputs, primarily in 2-, 3-, or perhaps constant dimensional
spaces. It primarily involves straight or flat objects (lines, line
segments, polygons, planes, and polyhedra) as opposed to curves and
surfaces. It is this latter sense of the term that we will be covering
in this course.

The field developed rapidly in the late 70's and through the 80's and
90's, and it still continues to develop. Because of the area from
which it grew (discrete algorithm design), the field of computational
geometry has always emphasized problems of a discrete mathematic
nature. For most problems in computational geometry the input is a
finite set of points or other geometric objects, and the output is a
typically some sort of structure consisting of a finite set of points
or line segments.

Here is an example of a typical problem, called the shortest path
problem. Given a set polygonal obstacles in the plane, find the
shortest obstacle-avoiding path from some given start point to a given
goal point. Although it is possible to reduce this to a shortest path
problem on a graph (called the visibility graph, which we will discuss
later this semester), and then apply a nongeometric algorithm such as
Dijkstra's algorithm, it seems that by solving the problem in its
geometric domain it should be possible to devise more efficient
solutions. This is one of the main reasons for the growth of interest
in geometric algorithms.



Figure 1: Shortest path problem. 

The measure of the quality of an algorithm in computational geometry
has traditionally been its asymptotic worst-case running time. Thus,
an algorithm running in O(n) time is better than one running in O(n
log n) time which is better than one running in O(n^2) time. (This
particular problem can be solved in O(n^2 log n) time by a fairly
simple algorithm, and in O(n log n) by a very complex algorithm.) In
some cases average case running time is considered instead.

However, for many types of geometric inputs it is difficult to define
input distributions that are both easy to analyze and representative
of typical inputs.

There are many fields of computer science that deal with solving
problems of a geometric nature. These include computer graphics,
computer vision and image processing, robotics, computer-aided design
and manufacturing, computational fluid-dynamics, and geographic
information systems, to name a few. One of the goals of computational
geometry is to provide the basic geometric tools needed from which
application areas can then build their programs. There has been
significant progress made towards this goal, but it is still far from
being fully realized.


Limitations of Computational Geometry: 

There are some fairly natural reasons why computational geometry may
never fully address the needs of all these applications areas, and
these limitations should be understood before undertaking this
course. One is the discrete nature of computational geometry. In some
sense any problem that is solved on digital computers must be
expressed in a discrete form, but many applications areas deal with
discrete approximations to continuous phenomenon. For example in image
processing the image may be a discretization of a continuous
2-dimensional gray-scale function, and in robotics issues of
vibration, oscillation in dynamic control systems are of a continuous
nature. Nonetheless, there are many applications in which objects are
of a very discrete nature. For example, in geographic information
systems, road networks are discretized into collections of line
segments.

The other limitation is the fact that computational geometry deals
primarily with straight or flat objects. To a large extent, this is a
result of the fact that computational geometers were not trained in
geometry, but in discrete algorithm design. So they chose problems for
which geometry and numerical computation plays a fairly small
role. Much of solid modeling, fluid dynamics, and robotics, deals with
objects that are modeled with curved surfaces. However, it is possible
to approximate curved objects with piecewise planar polygons or
polyhedra. This assumption has freed computational geometry to deal
with the combinatorial elements of most of the problems, as opposed to
dealing with numerical issues. This is one of the things that makes
computational geometry fun to study, you do not have to learn a lot of
analytic or differential geometry to do it. But, it does limit the
applications of computational geometry.

One more limitation is that computational geometry has focused
primarily on 2-dimensional problems, and 3-dimensional problems to a
limited extent. The nice thing about 2-dimensional problems is that
they are easy to visualize and easy to understand. But many of the
daunting applications problems reside in 3-dimensional and higher
dimensional spaces. Furthermore, issues related to topology are much
cleaner in 2- and 3-dimensional spaces than in higher dimensional
spaces.


Trends in CG in the 80's and 90's: 

In spite of these limitations, there is still a remarkable array of
interesting problems that computational geometry has succeeded in
addressing. Throughout the 80's the field developed many techniques
for the design of efficient geometric algorithms. These include
well-known methods such as divide-and-conquer and dynamic programming,
along with a number of newly discovered methods that seem to be
particularly well suited to geometric algorithm. These include
plane-sweep, randomized incremental constructions,
duality-transformations, and fractional cascading.

One of the major focuses of this course will be on understanding
techniques for designing efficient geometric algorithms. A major part
of the assignments in this class will consist of designing and/or
analyzing the efficiency of problems of a discrete geometric nature.

However throughout the 80's there a nagging gap was growing between
the "theory" and "practice" of designing geometric algorithms. The
80's and early 90's saw many of the open problems of computational
geometry solved in the sense that theoretically optimal algorithms
were developed for them. However, many of these algorithms were
nightmares to implement because of the complexity of the algorithms
and the data structures that they required. Furthermore,
implementations that did exist were often sensitive to geometric
degeneracies that caused them to produce erroneous results or
abort. For example, a programmer designing an algorithm that computes
the intersections of a set of line segments may not consider the
situation when three line segments intersect in a single point. In
this rare situation, the data structure being used may be corrupted,
and the algorithm aborts.

Much of the recent work in computational geometry has dealt with
trying to make the theoretical results of computational geometry
accessible to practitioners. This has been done by simplifying
existing algorithms, dealing with geometric degeneracies, and
producing libraries of geometric procedures. This process is still
underway. Whenever possible, we will discuss the simplest known
algorithm for solving a problem. Often these algorithms will be
randomized algorithms. We will also discuss (hopefully without getting
too bogged down in details) some of the techniques for dealing with
degenerate situations in order to produce clean and yet robust
geometric software.


A Grand Overview: 

Here are some of the topics that we will discuss this semester.

Convex Hulls: Convexity is a very important geometric property. A
geometric set is convex if for every two points in the set, the line
segment joining them is also in the set. One of the first problems
identified in the field of computational geometry is that of computing
the smallest convex shape, called the convex hull, that encloses a set
of points.


Figure 2: Convex hulls and polygon triangulation. 

Intersections: One of the most basic geometric problems is that of
determining when two sets of objects intersect one
another. Determining whether complex objects intersect often reduces
to determining which individual pairs of primitive entities (e.g.,
line segments) intersect. We will discuss efficient algorithms for
computing the intersections of a set of line segments.

Triangulation and Partitioning: Triangulation is a catchword for the
more general problem of subdividing a complex domain into a disjoint
collection of "simple" objects. The simplest region into which one can
decompose a planar object is a triangle (a tetrahedron in 3-d and
simplex in general). We will discuss how to subdivide a polygon into
triangles and later in the semester discuss more general subdivisions
into trapezoids.

Low-dimensional Linear Programming: Many optimization problems in
computational geometry can be stated in the form of a linear
programming problem, namely, find the extreme points (e.g. highest or
lowest) that satisfies a collection of linear inequalities. Linear
programming is an important problem in the combinatorial optimization,
and people often need to solve such problems in hundred to perhaps
thousand dimensional spaces. However there are many interesting
problems (e.g. find the smallest disc enclosing a set of points) that
can be posed as low dimensional linear programming problems. In
low-dimensional spaces, very simple efficient solutions exist.

Line arrangements and duality: Perhaps one of the most important
mathematical structures in computational geometry is that of an
arrangement of lines (or generally the arrangement of curves and
surfaces). Given n lines in the plane, an arrangement is just the
graph formed by considering the intersection points as vertices and
line segments joining them as edges. We will show that such a
structure can be constructed in O(n2) time. These reason that this
structure is so important is that many problems involving points can
be transformed into problems involving lines by a method of
duality. For example, suppose that you want to determine whether any
three points of a planar point set are collinear. This could be
determines in O(n3) time by brute-force checking of each
triple. However, if the points are dualized into lines, then (as we
will see later this semester) this reduces to the question of whether
there is a vertex of degree greater than 4 in the arrangement.

Voronoi Diagrams and Delaunay Triangulations: Given a set S of points
in space, oneof the most important problems is the nearest neighbor
problem. Given a point that is not in S which point of S is closest to
it? One of the techniques used for solving this problem is to
subdivide space into regions, according to which point is
closest. This gives rise to a geometric partition of space called a
Voronoi diagram. This geometric structure arises in many applications
of geometry. The dual structure, called a Delaunay triangulation also
has many interesting properties.



Figure 3: Voronoi diagram and Delaunay triangulation. 

Search: Geometric search problems are of the following general
form. Given a data set (e.g. points, lines, polygons) which will not
change, preprocess this data set into a data structure so that some
type of query can be answered as efficiently as possible. For example,
a nearest neighbor search query is: determine the point of the data
set that is closest to a given query point. A range query is:
determine the set of points (or count the number of points) from the
data set that lie within a given region. The region may be a
rectangle, disc, or polygonal shape, like a triangle.