Indirect predicates for geometric constructions

TL;DR

This paper tackles the robustness gap in floating point geometric predicates when intermediate constructions are used. It introduces indirect geometric predicates that treat the intermediate constructions as implicit parameters represented by polynomial fractions, enabling arithmetic filtering to preserve exactness with near-FP performance. The authors develop specialized FP, interval, and exact evaluation paths, plus caching and code-generation techniques to tailor implementations to input configurations. Experiments in 2D and 3D, explicit and implicit data, show that indirect predicates outperform state-of-the-art approaches while maintaining robustness, with practical memory and speed benefits. The work demonstrates a feasible path to robust, efficient geometric algorithms that rely on intermediate constructions, and discusses remaining limitations and avenues for future research.

Abstract

Geometric predicates are a basic ingredient to implement a vast range of algorithms in computational geometry. Modern implementations employ floating point filtering techniques to combine efficiency and robustness, and state-of-the-art predicates are guaranteed to be always exact while being only slightly slower than corresponding (inexact) floating point implementations. Unfortunately, if the input to these predicates is an intermediate construction of an algorithm, its floating point representation may be affected by an approximation error, and correctness is no longer guaranteed. This paper introduces the concept of indirect geometric predicate: instead of taking the intermediate construction as an explicit input, an indirect predicate considers the primitive geometric elements which are combined to produce such a construction. This makes it possible to keep track of the floating point approximation, and thus to exploit efficient filters and expansion arithmetic to exactly resolve the predicate with minimal overhead with respect to a naive floating point implementation. As a representative example, we show how to extend standard predicates to the case of points of intersection of linear elements (i.e. lines and planes) and show that, on classical problems, this approach outperforms state-of-the-art solutions based on lazy exact intermediate representations.

Figures (3)

• Figure 1: Implicit point examples. Left - line-line intersection: four explicit 2D points define the implicit point p. Right - line-plane intersection: five explicit 3D points define the implicit point p.
• Figure 2: Elapsed time for experiments 1.2, 1.3, 2.2 and 2.3 using indirect predicates (blue) and CGAL (orange).
• Figure 3: Code produced by our tool for an indirect version of the orient2d predicate. The first of the three points is implicitly defined by the intersection of two lines that, in turn, are defined by explicit points $w_1, \ldots, w_4$. The values for $\lambda_x$, $\lambda_y$ and $d$ (l1x, l1y, d1) are calculated externally and passed to this function along with the maximum $\beta$ deriving from the $w$'s (prev_maxval). The constant value of $\delta(1)$ ( = 1.048458195263004e-13) accumulates the error bounds of this function and those of the external function that calculates the $\lambda$'s and $d$.