Automatic Generation of Staged Geometric Predicates

Algorithms in Computational Geometry and Computer Aided Design are often developed for the Real RAM model of computation, which assumes exactness of all the input arguments and operations. In practice, however, the exactness imposes tremendous limitations on the algorithms—even the basic operations become uncomputable, or prohibitively slow. In some important cases, however, the computations of interest are limited to determining the sign of polynomial expressions. In such circumstances, a faster approach is available: one can evaluate the polynomial in floating-point first, together with some estimate of the rounding error, and fall back to exact arithmetic only if this error is too big to determine the sign reliably. A particularly efficient variation on this approach has been used by Shewchuk in his robust implementations of Orient and InSphere geometric predicates.We extend Shewchuk's method to arbitrary polynomial expressions. The expressions are given as programs in a suitable source language featuring basic arithmetic operations of addition, subtraction, multiplication and squaring, which are to be perceived by the programmer as exact. The source language also allows for anonymous functions; the use of such functions enables the common functional programming technique of staging. The method is presented formally through several judgments that govern the compilation of the source expression into target code, which is then easily transformed into SML or, in case of single-stage expressions, into C.     

Solid Modeling Based on a New Paradigm

The technique of solid modeling is essential in CAD/CAM applications, and is currently well established. However, problems remain, such as the lack of uniformity in geometric computations and the lack of stability of Boolean operations of two solids. In this paper, we introduce a theoretical solid modeling system that operates on boundary representations of polyhedral objects and is based on a new paradigm. The characteristics of the system are the following: (I) in Boolean Operations and modeling transformations, all geometric computations are performed by the 4 × 4 determinant method or the 4 × 4 matrix method in homogeneous space, which allows the system to avoid division operations, (2) all geometric computations are performed by the exact integer arithmetic, which makes the geometric algorithms stable and simple, and (3) primitive solids are constructed consistently in the integer domain, and the consistency is assured throughout Boolean operations and transformations.     

ESOLID—a system for exact boundary evaluation

We present a system, ESOLID, that performs exact boundary evaluation of low-degree curved solids in reasonable amounts of time. ESOLID performs accurate Boolean operations using exact representations and exact computations throughout. The demands of exact computation require a different set of algorithms and efficiency improvements than those found in a traditional inexact floating-point based modeler. We describe the system architecture, representations, and issues in implementing the algorithms. We also describe a number of techniques that increase the efficiency of the system based on lazy evaluation, use of floating-point filters, arbitrary floating-point arithmetic with error bounds, and lower-dimensional formulation of subproblems.ESOLID has been used for boundary evaluation of many complex solids. These include both synthetic datasets and parts of a Bradley Fighting Vehicle designed using the BRL-CAD solid modeling system. It is shown that ESOLID can correctly evaluate the boundary of solids that are very hard to compute using a fixed-precision floating-point modeler. In terms of performance, it is about an order of magnitude slower as compared to a floating-point boundary evaluation system on most cases.     

The design of the Boost interval arithmetic library

We present the design of the Boost interval arithmetic library, a C++$++$ library designed to handle mathematical intervals efficiently and in a generic way. Interval computations are an essential tool for reliable computing. Increasingly a number of mathematical proofs have relied on global optimization problems solved using branch-and-bound algorithms with interval computations; it is therefore extremely important to have a mathematically correct implementation of interval arithmetic. Various implementations exist with diverse semantics. Our design is unique in that it uses policies to specify three independent variable behaviors: rounding, checking, and comparisons. As a result, with the proper policies, our interval library is able to emulate almost any of the specialized libraries available for interval arithmetic, without any loss of performance nor sacrificing the ease of use. This library is openly available at www.boost.org.     

An Exact, Complete and Efficient Computation of Arrangements of BÉzier Curves

Arrangements of planar curves are fundamental structures in computational geometry. The arrangement package of Cgal can construct and maintain arrangements of various families of curves, when provided with the representation of the curves and some basic geometric functionality on them. It employs the exact computation paradigm in order to handle all degenerate cases in a robust manner. We present the representations and algorithms needed for implementing arrangements of BÉzier curves using exact arithmetic. The implementation is efficient and complete, handling all degenerate cases. In order to avoid the prohibitive running times incurred by an indiscriminate usage of exact arithmetic, we make extensive use of the geometric properties of BÉzier curves for filtering. As a result, most operations are carried out using fast approximate methods, and only in degenerate (or near-degenerate) cases do we resort to the exact, and more computationally demanding, procedures. To the best of our knowledge this is the first complete implementation that can construct arrangements of BÉzier curves of any degree, and handle all degenerate cases in a robust manner.      

Rounding Voronoi diagram

Computational geometry classically assumes real-number arithmetic which does not exist in actual computers. A solution consists in using integer coordinates for data and exact arithmetic for computations. This approach implies that if the results of an algorithm are the input of another, these results must be rounded to match this hypothesis of integer coordinates. In this paper, we treat the case of two-dimensional Voronoi diagrams and are interested in rounding the Voronoi vertices to grid points while interesting properties of the Voronoi diagram are preserved. These properties are the planarity of the embedding and the convexity of the cells. We give a condition on the grid size to ensure that rounding to the nearest grid point preserves the properties. We also present heuristics to round vertices (not to the nearest grid point) and preserve these properties.     

Efficient method of adaptive sign detection for 4×4 determinants using a standard arithmetic processing unit

We propose an efficient and exact method for the adaptive sign detection of 4×4 determinants using a standard arithmetic unit. The entities of determinants are variable length integers (integers of arbitrary bit length). The integers are expressed in 16-bit data units, and the sign detection is reduced to the computation of 4×4 determinants of 16-bit integers. To accelerate the computation, the calculation is performed by using a standard arithmetic unit. We have implemented our method and confirmed that it significantly improves the computation time of 4×4 determinants. The method can be applicable to many geometric algorithms that need the exact sign evaluation of 4×4 determinants, especially to construct robust geometric algorithms.     

Good reduction of Puiseux series and applications

We have designed a new symbolic-numeric strategy for computing efficiently and accurately floating point Puiseux series defined by a bivariate polynomial over an algebraic number field. In essence, computations modulo a well-chosen prime number p are used to obtain the exact information needed to guide floating point computations. In this paper, we detail the symbolic part of our algorithm. First of all, we study modular reduction of Puiseux series and give a good reduction criterion for ensuring that the information required by the numerical part is preserved. To establish our results, we introduce a simple modification of classical Newton polygons, that we call “generic Newton polygons”, which turns out to be very convenient. Finally, we estimate the size of good primes obtained with deterministic and probabilistic strategies. Some of these results were announced without proof at ISSAC’08.     

Fast, Exact, Linear Booleans

We present a new system for robustly performing Boolean operations on linear, 3D polyhedra. Our system is exact, meaning that all internal numeric predicates are exactly decided in the sense of exact geometric computation. Our BSP-tree based system is 16-28× faster at performing iterative computations than CGAL's Nef Polyhedra based system, the current best practice in robust Boolean operations, while being only twice as slow as the non-robust modeler Maya. Meanwhile, we achieve a much smaller substrate of geometric subroutines than previous work, comprised of only 4 predicates, a convex polygon constructor, and a convex polygon splitting routine. The use of a BSP-tree based Boolean algorithm atop this substrate allows us to explicitly handle all geometric degeneracies without treating a large number of cases.     

Distance functions and skeletal representations of rigid and non-rigid planar shapes

Shape skeletons are fundamental concepts for describing the shape of geometric objects, and have found a variety of applications in a number of areas where geometry plays an important role. Two types of skeletons commonly used in geometric computations are the straight skeleton of a (linear) polygon, and the medial axis of a bounded set of points in the k-dimensional Euclidean space. However, exact computation of these skeletons of even fairly simple planar shapes remains an open problem.In this paper we propose a novel approach to construct exact or approximate (continuous) distance functions and the associated skeletal representations (a skeleton and the corresponding radius function) for solid 2D semi-analytic sets that can be either rigid or undergoing topological deformations. Our approach relies on computing constructive representations of shapes with R-functions that operate on real-valued halfspaces as logic operations. We use our approximate distance functions to define a new type of skeleton, i.e, the C-skeleton, which is piecewise linear for polygonal domains, generalizes naturally to planar and spatial domains with curved boundaries, and has attractive properties. We also show that the exact distance functions allow us to compute the medial axis of any closed, bounded and regular planar domain. Importantly, our approach can generate the medial axis, the straight skeleton, and the C-skeleton of possibly deformable shapes within the same formulation, extends naturally to 3D, and can be used in a variety of applications such as skeleton-based shape editing and adaptive motion planning.     

Efficient and accurate B-rep generation of low degree sculptured solids using exact arithmetic: I—representations

We present efficient representations and algorithms for exact boundary computation on low degree sculptured CSG solids using exact arithmetic. Most of the previous work using exact arithmetic has been restricted to polyhedral models. In this paper, we generalize it to higher order objects, whose boundaries are composed of rational parametric surfaces. We present the underlying representations necessary in our approach, and provide an overview of the boundary computation algorithm, which is described in more detail in a followup paper.     

Resegmentation using generic shape: Locating general cultural objects

As a step toward automating the ability to locate generic objects in an image, we propose an approach based on model-driven correction of an initial low-level scene partition. To accomplish this, we define generic data structures for geometric shapes, along with robust rules for parsing the image geometry and performing a shape-motivated resegmentation. We successfully apply the system to the task of locating and outlining complex rectilinear cultural objects in aerial imagery.     

Symbolic computation in nonlinear dynamics

This paper gives examples of how computer algebra systems can help us to understand nonlinear dynamical systems and their numerical simulations. We caution against naive use of exact arithmetic, but we give examples where elementary use is helpful. We also look at the use of polynomial computations — such as factoring, computation of discriminants, and Gröbner bases — in bifurcation studies.This paper is dedicated to the memory of M. A. H. Nerenberg (1936–1993).     

Twin-float arithmetic

We present a heuristically certified form of floating-point arithmetic and its implementation in CoCoALib. This arithmetic is intended to act as a fast alternative to exact rational arithmetic, and is developed from the idea of paired floats expounded by Traverso and Zanoni (2002). As prerequisites we need a source of (pseudo-)random numbers, and an underlying floating-point arithmetic system where the user can set the precision. Twin-float arithmetic can be used only where the input data are exact, or can be obtained at high enough precision. Our arithmetic includes a total cancellation heuristic for sums and differences, and so can be used in classical algebraic algorithms such as Buchberger’s algorithm. We also present a (new) algorithm for recovering an exact rational value from a twin-float, so in some cases an exact answer can be obtained from an approximate computation.     

Online region computations for Euler diagrams with relaxed drawing conventions

Euler diagrams are an accessible and effective visualisation of data involving simple set-theoretic relationships. Efficient algorithms to quickly compute the abstract regions of an Euler diagram upon curve addition and removal have previously been developed (the single marked point approach, SMPA), but a strict set of drawing conventions (called well-formedness conditions) were enforced, meaning that some abstract diagrams are not representable as concrete diagrams. We present a new methodology (the multiple marked point approach, MMPA) enabling online region computation for Euler diagrams under the relaxation of the drawing convention that zones must be connected regions. Furthermore, we indicate how to extend the methods to deal with the relaxation of any of the drawing conventions, with the use of concurrent line segments case being of particular importance. We provide complexity analysis and compare the MMPA with the SMPA. We show that these methods are theoretically no worse than other comparators, whilst our methods apply to any case, and are likely to be faster in practise due to their online nature. The machinery developed for the concurrency case could be of use in Euler diagram drawing techniques (in the context of the Euler Graph), and in computer graphics (e.g. the development of an advanced variation of a winged edge data structure that deals with concurrency). The algorithms are presented for generic curves; specialisations such as utilising fixed geometric shapes for curves may occur in applications which can enhance capabilities for fast computations of the algorithms' input structures. We provide an implementation of these algorithms, utilising ellipses, and provide time-based experimental data for benchmarking purposes.     

Relief extraction and editing

Bas-reliefs are widely used in the world around us, for example, on coinage, for branding products, and for sculptural decoration. Reverse engineering of reliefs–extracting existing reliefs from input surfaces–makes it possible to apply them to new items; relief editing tools allow modification of reverse-engineered reliefs. This paper presents a novel approach to relief extraction based on differential coordinates, which offers advantages of speed and precise extraction. It also gives the first method in the literature specifically designed for relief editing. The base surface is estimated using normal smoothing and Poisson reconstruction, allowing a relief (which may lie on a smooth or textured input surface) to be automatically extracted by height thresholding. We also provide a range of relief editing tools, also using differential coordinates, permitting both global transformations (translation, rotation, and scaling) of the whole relief, as well as local modifications to the relief. Our relief editing algorithm, unlike generic mesh editing algorithms, is specifically designed to preserve the geometric detail of the relief over the base surface. The effectiveness of our methods is demonstrated on various examples of real industrial interest.     

PHAVer: algorithmic verification of hybrid systems past HyTech

In 1995, HyTech broke new ground as a potentially powerful tool for verifying hybrid systems. But due to practical and systematic limitations it is only applicable to relatively simple systems. We address the main problems of HyTech with PHAVer, a new tool for the exact verification of safety properties of hybrid systems with piecewise constant bounds on the derivatives, so-called linear hybrid automata. Affine dynamics are handled by on-the-fly overapproximation and partitioning of the state space based on user-provided constraints and the dynamics of the system. PHAVer features exact arithmetic in a robust implementation that, based on the Parma Polyhedra Library, supports arbitrarily large numbers. To force termination and manage the complexity of the polyhedral computations, we propose methods to conservatively limit the number of bits and constraints of polyhedra. Experimental results for a navigation benchmark and a tunnel diode circuit demonstrate the effectiveness of the approach. A preliminary version of this paper appeared in the Proceedings of Hybrid Systems: Computation and Control (HSCC 2005), Lecture Notes in Computer Science 3414, Springer-Verlag, 2005, pp. 258–273.     

Computing the Isolated Roots by Matrix Methods

Two main approaches are used, nowadays, to compute the roots of a zero-dimensional polynomial system. The first one involves Gröbner basis computation, and applies to any zero-dimensional system. But, it is performed withexact arithmetic and, usually, large numbers appear during the computation. The other approach is based on resultant formulations and can be performed with floating point arithmetic. However, it applies only to generic situations, leading to singular problems in several systems coming from robotics and computational vision, for instance.In this paper, reinvestigating the resultant approach from the linear algebra point of view, we handle the problem of genericity and present a new algorithm for computing the isolated roots of an algebraic variety, not necessarily of dimension zero. We analyse two types of resultant formulations, transform them into eigenvector problems, and describe special linear algebra operations on the matrix pencils in order to reduce the root computation to a non-singular eigenvector problem. This new algorithm, based on pencil decompositions, has a good complexity even in the non-generic situations and can be executed with floating point arithmetic.     

Enhancing the implementation of mathematical formulas for fixed-point and floating-point arithmetics

This article introduces some techniques to estimate and to improve the numerical quality of computations performed using different computer arithmetics. A general methodology is introduced and it is applied to the fixed-point and floating-point formats. We show how to globally measure the quality of the implementation of a formula with respect to some quality indicators. In the case of the floating-point arithmetic, the indicator measures the distance between the computer and exact results in the worst case. In the case of the fixed-point arithmetic, the indicator bounds the number of digits needed to represent all the intermediary results. Next, we show how the operations which make mostly decrease the quality of an indicator can be identified. This information helps the programmer to improve the implementation by underlying the main sources of degradation. Finally, we introduce a fully automatic expression transformation technique to rewrite a formula into a better, mathematically equivalent one. The new formula is more accurate than the original one with respect to the chosen quality indicator.     

Comparison of Distance Measures for Planar Curves

The Hausdorff distance is a very natural and straightforward distance measure for comparing geometric shapes like curves or other compact sets. Unfortunately, it is not an appropriate distance measure in some cases. For this reason, the Fréchet distance has been investigated for measuring the resemblance of geometric shapes which avoids the drawbacks of the Hausdorff distance. Unfortunately, it is much harder to compute. Here we investigate under which conditions the two distance measures approximately coincide, i.e., the pathological cases for the Hausdorff distance cannot occur. We show that for closed convex curves both distance measures are the same. Furthermore, they are within a constant factor of each other for so-called κ-straight curves, i.e., curves where the arc length between any two points on the curve is at most a constant κ times their Euclidean distance. Therefore, algorithms for computing the Hausdorff distance can be used in these cases to get exact or approximate computations of the Fréchet distance, as well.