There are many algorithms that compute the convex hull of a set of points in two and three dimensions, and the present chapter does not claim to give a comprehensive survey. In fact, our goal is mainly to explore the possibilities offered by the divide-and-conquer method in two and three dimensions, and to expand on the incremental method in the case of a planar polygonal line.

In dimension 2, the divide-and-conquer method leads, like many other methods, to a convex hull algorithm that is optimal in the worst case. The main advantage of this method is that it also generalizes to three dimensions while still leading to an algorithm that is optimal in the worst case, which is not the case for the incremental method described in chapter 8. The performances of this divide-andconquer algorithm rely on the existence of a circular order on the edges incident to a given vertex. In dimensions higher than three, such an order does not exist, and the divide-and-conquer method is no longer efficient for computing convex hulls. The 2-dimensional divide-and-conquer algorithm is described in section 9.2, and generalized to dimension 3 in section 9.3. But before these descriptions, we must comment on the representation of polytopes in dimensions 2 and 3, and describe a data structure that explicitly provides the circular order of the edges or facets around a vertex of a 3-dimensional polytope.

The geometric problems encountered in this chapter are again stated in the abstract framework of objects, regions, and conflicts introduced in chapter 4. A dynamic algorithm maintains the set of regions defined and without conflict over the current set of objects, when the objects can be removed from the current set as well as added. In contrast, on-line algorithms that support insertions but not deletions are sometimes called semi-dynamic.

Throughout this chapter, we denote by S the current set of objects and use the notation introduced in the previous two chapters to denote the different subsets of regions defined over S. In particular, F0(S) stands for the set of regions defined and without conflict over S. To design a dynamic algorithm that maintains the set F0(S) is a much more delicate problem than its static counterpart. In the previous chapter, we have shown how randomized incremental methods provide simple solutions to static problems. In addition, the influence graph techniques naturally lead to the design of semi-dynamic algorithms. In this chapter, we propose to show how the combined use of both conflict and influence graphs can yield fully dynamic algorithms.

The general idea behind our approach is to maintain a data structure that meets the following two requirements:

• It allows conflicts to be detected between any object and the regions defined and without conflict over the current subset.

• After deleting an object, the structure is identical to what it would have been, had the deleted object never been inserted.

A polytope is defined as the convex hull of a finite number of points, or also as the bounded intersection of a finite number of half-spaces. Section 7.1 recalls the equivalence of these definitions, and gives the definition of the faces of a polytope. Polarity is also introduced in this section. The polarity centered at O is a dual transform between points and hyperplanes in Euclidean spaces which induces a duality on the set of polytopes containing the center O. Simple and simplicial polytopes are also defined in this section. Section 7.2 takes a close interest in the combinatorics of polytopes. It contains a proof of Euler's relation and the Dehn–Sommerville relations. Euler's relation is the only linear relation between the numbers of faces of each dimension of any polytope, and the Dehn–Sommerville relations are linear relations satisfied by simple polytopes. These relations can be used to show the celebrated upper bound theorem which bounds the number of faces of all dimensions of a d-dimensional polytope as a function of the number of its vertices, or facets. Considering cyclic polytopes shows that the upper bound theorem yields the best possible asymptotic bound. Linear unbounded convex sets enjoy similar properties and are frequently encountered in the rest of this book. Section 7.3 extends these definitions and properties to unbounded polytopes. A simple method to enforce coherence in these definitions is to consider the Euclidean space as embedded in the oriented projective space, an oriented version of the classical projective space.

A new field

Many disciplines require a knowledge of how to efficiently deal with and build geometric objects. Among many examples, one could quote robotics, computer vision, computer graphics, medical imaging, virtual reality, or computer aided design. The first geometric results with a constructive flavor date back to Euclid and remarkable developments occurred during the nineteenth century. However, only very recently did the design and analysis of geometric algorithms find a systematic treatment: this is the topic of computational geometry which as a field truly emerged in the mid 1970s. Since then, the field has undergone considerable growth, and is now a full-fledged scientific discipline, of which this text presents the foundations.

Contents and layout of this book

The design of efficient geometric algorithms and their analysis are largely based on geometric structures, algorithmic data structuring techniques, and combinatorial results.

A major contribution of computational geometry is to exemplify the central role played by a small number of fundamental geometric structures and their relation to many geometric problems.

Geometric data structures and their systematic analysis guided the layout of this text. We have dedicated a part to each of the fundamental geometric structures: convex hulls, triangulations, arrangements, and Voronoi diagrams.

In order to control the complexity of an algorithm, one must know the complexity of the objects that it generates. For example, it is essential to have a sharp bound on the number of facets of a polytope as a function of the number of its vertices: this is the celebrated upper-bound theorem proved by McMullen in 1970.

Computational geometry aims at designing the most efficient algorithms to solve geometric problems. For this, one must clearly agree on the criteria to estimate or measure the efficiency of an algorithm or to compare two different algorithms. This chapter recalls a few basic notions related to the analysis of algorithms. These notions are fundamental to understanding the subsequent analyses given throughout this book. The first section recalls the definition of algorithmic complexity and the underlying model of computation used in the rest of this book. The second part introduces the notion of a lower bound for the complexity of an algorithm, and optimality.

The complexity of algorithms

The model of computation

From a practical standpoint, the performances of an algorithm can be evaluated by how much time and memory is required by a program that encodes this algorithm to run on a given machine. The running time and space both depend on the particular machine or on the programming language used, or even on the skills of the programmer. It is therefore impossible to consider them relevant measures of efficiency that could serve to compare different algorithms or implementations of the same algorithm. In order to compare, one is forced to define a standard model of a computer on which to evaluate the algorithms, called the model of computation. Thus, to define a model of computation is essentially to define the units of time and space.

Voronoi diagrams are very useful structures, frequently encountered in several disciplines because they model growth processes and distance relationships between objects: it is not surprising to see them appear in the study of crystal growth or in studies on the great structures of the universe. In nature, they can be observed in crystalline structures, on the shell of a turtle, or on the neck of a reticulate giraffe.

Voronoi diagrams are very closely related to the geometric structures encountered so far: polytopes, triangulations, and arrangements. Their mathematical properties are particularly numerous and interesting. Chapter 17 is entirely devoted to Voronoi structures with a Euclidean metric, whereas other metrics are studied in chapter 18. Chapter 19 presents results specific to dimension 2 that have no analogue in higher dimensions.

Voronoi diagrams can also be used as data structures to solve numerous problems: nearest neighbors and motion planning are two outstanding instances. Several examples are given in the exercises and throughout chapter 19.

The goal of this and subsequent chapters is to introduce the algorithmic methods that are used most frequently to solve geometric problems. Generally speaking, computational geometry has recourse to all of the classical algorithmic techniques. Readers examining all the algorithms described in this book from a methodological point of view will distinguish essentially three methods: the incremental method, the divide-and-conquer method, and the sweep method.

The incremental method is perhaps the method which is the most largely emphasized in the book. It is also the most natural method, since it consists of processing the input to the problem one item at a time. The algorithm initiates the process by solving the problem for a small subset of the input, then maintains the solution to the problem as the remaining data are inserted one by one. In some cases, the algorithm may initially sort the input, in order to take advantage of the fact that the data are sorted. In other cases, the order in which the data are processed is indifferent, sometimes even deliberately random. In the latter case, we are dealing with the randomized incremental method, which will be stated and analyzed at length in chapter 5. We therefore will not expand further on the incremental method in this chapter.

The divide-and-conquer method is one of the oldest methods for the design of algorithms, and its use goes well beyond geometry. In computational geometry, this method leads to very efficient algorithms for certain problems.