Susan Hert

A Computational Basis for Conic Arcs and Boolean Operations on Conic Polygons

We give an exact geometry kernel for conic arcs, algorithms for exact computation with low-degree algebraic numbers, and an algorithm for computing the arrangement of conic arcs that immediately leads to a realization of regularized boolean operations on conic polygons. A conic polygon, or polygon for short, is anything that can be obtained from linear or conic halfspaces (= the set of points where a linear or quadratic function is non-negative) by regularized boolean operations. The algorithm and its implementation are complete (they can handle all cases), exact (they give the mathematically correct result), and efficient (they can handle inputs with several hundred primitives).

Polygon Area Decomposition for Multiple-Robot Workspace Division

A new polygon decomposition problem, the anchored area partition problem, which has applications to a multiple-robot terrain-covering problem is presented. This problem concerns dividing a given polygon P into n polygonal pieces, each of a specified area and each containing a certain point (site) on its boundary or in its interior. First the algorithm for the case when P is convex and contains no holes is presented. Then the generalized version that handles nonconvex and nonsimply connected polygons is presented. The algorithm uses sweep-line and divide-and-conquer techniques to construct the polygon partition. The input polygon P is assumed to have been divided into a set of p convex pieces (p = 1 when P is convex), which can be done in O(vPloglog vP) time, where vP is the number of vertices of P and p = O(vP), using algorithms presented elsewhere in the literature. Assuming this convex decomposition, the running time of the algorithm presented here is O(pn2+vn), where v is the sum of the number of vertices of the convex pieces.

Boolean operations on 3D selective Nef complexes : data structure, algorithms, and implementation

We describe a data structure for three-dimensional Nef complexes, algorithms for boolean operations on them, and our implementation of data structure and algorithms. Nef polyhedra were introduced by W. Nef in his seminal 1978 book on polyhedra. They are the closure of half-spaces under boolean operations and can represent non-manifold situations, open and closed boundaries, and mixed dimensional complexes. Our focus lies on the generality of the data structure, the completeness of the algorithms, and the exactness and efficiency of the implementation. In particular, all degeneracies are handled.

An adaptable and extensible geometry kernel

Geometric algorithms are based on geometric objects such as points, lines and circles. The term kernel refers to a collection of representations for constant-size geometric objects and operations on these representations. This paper describes how such a geometry kernel can be designed and implemented in C++, having special emphasis on adaptability, extensibility and efficiency. We achieve these goals following the generic programming paradigm and using templates as our tools. These ideas are realized and tested in Cgal, the Computational Geometry Algorithms Library, see http://www.cgal.org/.

EXACUS: efficient and exact algorithms for curves and surfaces

We present the first release of the Exacus C++ libraries. We aim for systematic support of non-linear geometry in software libraries. Our goals are efficiency, correctness, completeness, clarity of the design, modularity, flexibility, and ease of use. We present the generic design and structure of the libraries, which currently compute arrangements of curves and curve segments of low algebraic degree, and boolean operations on polygons bounded by such segments.

Multiple-Robot Motion Planning = Parallel Processing + Geometry

We present two problems in multiple-robot motion planning that can be quite naturally solved using techniques from the parallel processing community to dictate how the robots interact with each other and techniques from computational geometry to apply these techniques in the geometric environment in which the robots operate. The first problem we consider is a load-balancing problem in which a pool of work must be divided among a set of processors in order to minimize the amount of time required to complete all the work. We describe a simple polygon partitioning algorithm that allows techniques from parallel processor scheduling to be applied in the multiple-robot setting in order to achieve a good balance of the work. The second problem is that of collision avoidance, where one must avoid that two (or more) processors occupy the same resource at the same time. For this problem, we describe a procedure for robot interaction that is derived from procedures used in shared-memory computers along with a geometric data structure that can efficiently determine when there are potential robot collisions.