Stefan Schirra

On the design of CGAL a computational geometry algorithms library

CGAL is a Computational Geometry Algorithms Library written in C++, which is being developed by research groups in Europe and Israel. The goal is to make the large body of geometric algorithms developed in the field of computational geometry available for industrial application. We discuss the major design goals for CGAL, which are correctness, flexibility, ease‐of‐use, efficiency, and robustness, and present our approach to reach these goals. Generic programming using templates in C++ plays a central role in the architecture of CGAL. We give a short introduction to generic programming in C++, compare it to the object‐oriented programming paradigm, and present examples where both paradigms are used effectively in CGAL. Moreover, we give an overview of the current structure of the CGAL‐library and consider software engineering aspects in the CGAL‐project. Copyright

Classroom examples of robustness problems in geometric computations

The algorithms of computational geometry are designed for a ma- chine model with exact real arithmetic. Substituting floating point arithmetic for the assumed real arithmetic may cause implementations to fail. Although this is well known, there is no comprehensive documentation of what can go wrong and why. In this extended abstract, we study a simple incremental algorithm for planar convex hulls and give examples which make the algorithm fail in all pos- sible ways. We also show how to construct failure-examples semi-systematically and discuss the geometry of the floating point implementation of the orientation predicate. We hope that our work will be useful for teaching computational ge- ometry. The full paper is available at www.mpi-sb.mpg.de/˜mehlhorn/ ftp/ClassRoomExamples.ps. It contains further examples, more theory, and color pictures. We strongly recommend to read the full paper instead of this extended abstract.

Approximate motion planning and the complexity of the boundary of the union of simple geometric figures

We study rigid motions of a rectangle amidst polygonal obstacles. The best known algorithms for this problem have a running time of Ω(n2), wheren is the number of obstacle corners. We introduce thetightness of a motion-planning problem as a measure of the difficulty of a planning problem in an intuitive sense and describe an algorithm with a running time ofO((a/b · 1/ɛcrit + 1)n(logn)2), wherea ≥b are the lengths of the sides of a rectangle and ɛcrit is the tightness of the problem. We show further that the complexity (= number of vertices) of the boundary ofn bow ties (see Figure 1) isO(n). Similar results for the union of other simple geometric figures such as triangles and wedges are also presented.

Checking geometric programs or verification of geometric structures

A program checker verifies that a particular program execution is correct. We give simple and efficient program checkers for some basic geometric tasks. We report about our experiences with program checking in the context of the LEDA system. We discuss program checking for data structures that have to rely on user-provided functions.

A Separation Bound for Real Algebraic Expressions

Abstract Real algebraic expressions are expressions whose leaves are integers and whose internal nodes are additions, subtractions, multiplications, divisions, k-th root operations for integral k, and taking roots of polynomials whose coefficients are given by the values of subexpressions. We consider the sign computation of real algebraic expressions, a task vital for the implementation of geometric algorithms. We prove a new separation bound for real algebraic expressions and compare it analytically and experimentally with previous bounds. The bound is used in the sign test of the number type leda::real.

The CGAL Kernel: A Basis for Geometric Computation

A large part of the Cgal-project is devoted to the development of a Computational Geometry Algorithms Library, written in C++. We discuss design issues concerning the Cgal-kernel which is the basis for the library and hence for all geometric computation in Cgal.

Exact geometric computation in LEDA

Almost all geometric algorithms are based on the RealRAM model. Implementors often simply replace the exact real arithmetic of this model by fixed precision arithmetic, thereby making correct algorithms incorrect. Two approaches have been taken to remedy this sit uation. The first approach is redesigning geometric algorithms for fixed precision arithmetic. The redesign is difficult and can inherently not lead to exact results. Moreover it prevents application areas from making use of the rich literature of geometric algorithms developed in computational geometry. The other approach advocat es the use of exact real arithmetic.

Topologically Correct Subdivision Simplification Using the Bandwidth Criterion

The line simplification problem is an old and well studied problem in cartography. Although there are several algorithms to compute a simplification there seem to be no algorithms that perform line simplification in the context of other geographical objects. This paper presents a nearly quadratic time algorithm for the following line simplification problem: Given a polygonal line, a set of extra points, and a real e> 0, compute a simplification that guarantees (i) a maximum error e (ii) that the extra points remain on the same side of the simplified chain as of the original chain; and (iii) that the simplified chain has no self-intersections. The algorithm is applied as the main subroutine for subdivision simplification and guarantees that the resulting subdivision is topologically correct.

Efficient exact geometric computation made easy

We show that the combination of the CGAL framework for geometric computation and the number type ledareal yields easy-to-write, correct and efficient geometric programs.

A Strong and Easily Computable Separation Bound for Arithmetic Expressions Involving Radicals

Abstract. We consider arithmetic expressions over operators + , - , * , / , and