Geometric Rounding and Feature Separation in Meshes

Geometric rounding of a mesh is the task of approximating its vertex coordinates by floating point numbers while preserving mesh structure. Geometric rounding allows algorithms of computational geometry to interface with numerical algorithms. We present a practical geometric rounding algorithm for 3D triangle meshes that preserves the topology of the mesh. The basis of the algorithm is a novel strategy: 1) modify the mesh to achieve a feature separation that prevents topology changes when the coordinates change by the rounding unit; and 2) round each vertex coordinate to the closest floating point number. Feature separation is also useful on its own, for example for satisfying minimum separation rules in CAD models. We demonstrate a robust, accurate implementation

Inner and Outer Rounding of Boolean Operations on Lattice Polygonal Regions

Robustness problems due to the substitution of the exact computation on real numbers by the rounded floating point arithmetic are often an obstacle to obtain practical implementation of geometric algorithms. If the adoption of the --exact computation paradigm--[Yap et Dube] gives a satisfactory solution to this kind of problems for purely combinatorial algorithms, this solution does not allow to solve in practice the case of algorithms that cascade the construction of new geometric objects. In this report, we consider the problem of rounding the intersection of two polygonal regions onto the integer lattice with inclusion properties. Namely, given two polygonal regions A and B having their vertices on the integer lattice, the inner and outer rounding modes construct two polygonal regions with integer vertices which respectively is included and contains the true intersection. We also prove interesting results on the Hausdorff distance, the size and the convexity of these polygonal regions

Recent progress in exact geometric computation

AbstractComputational geometry has produced an impressive wealth of efficient algorithms. The robust implementation of these algorithms remains a major issue. Among the many proposed approaches for solving numerical non-robustness, Exact Geometric Computation (EGC) has emerged as one of the most successful. This survey describes recent progress in EGC research in three key areas: constructive zero bounds, approximate expression evaluation and numerical filters

Snap Rounding with Restore: an Algorithm for Producing Robust Geometric Datasets

This paper presents a new algorithm called Snap Rounding with Restore (SRR), which aims to make ge- ometric datasets robust and to increase the quality of geometric approximation and the preservation of topological structure. It is based on the well-known Snap Rounding algorithm, but improves it by eliminat- ing from the snap rounded arrangement the configurations in which the distance between a vertex and a non-incident edge is smaller than half-the-width of a pixel of the rounding grid. Therefore, the goal of SRR is exactly the same as the goal of another algorithm, Iterated Snap Rounding (ISR), and of its evolution, Iterated Snap Rounding with Bounded Drift (ISRBD). However, SRR produces an output with a quality of approximation that is on average better than ISRBD, both under the viewpoint of the distance from the original segments and of the conservation of their topological structure. The paper also reports some cases where ISRBD, notwithstanding the bounded drift, produces strong topological modifications while SRR does not. A statistical analysis on a large collection of input datasets confirms these differences. It follows that the proposed Snap Rounding with Restore algorithm is suitable for applications that require both robustness, a guaranteed geometric approximation and a good topological approximation

Snap Rounding Line Segments Efficiently in Two and Three Dimensions

We study the problem of robustly rounding a set S of n line segments in R 2 using the snap rounding paradigm. In this paradigm each pixel containing an endpoint or intersection point is called "hot," and all segments intersecting a hot pixel are re-routed to pass through its center. We show that a snap-rounded approximation to the arrangement defined by S can be built in an output-sensitive fashion, and that this can be done without first determining all the intersecting pairs of segments in S. Specifically, we give a deterministic plane-sweep algorithm running in time O(n log n + P h2H jhj log n), where H is the set of hot pixels and jhj is the number of segments intersecting a hot pixel h 2 H. We also give a simple randomized incremental construction whose expected running time matches that of our deterministic algorithm. The complexity of these algorithms is optimal up to polylogarithmic factors. This research is supported by NSF grant CCR9625289 and by U.S. ARO grant DAAH04-..

Part of the Computer Sciences Commons Comments Victor Milenkovic & Elisha Sacks

We present two approximate Minkowski sum algorithms for planar regions bounded by line and circle segments. Both algorithms form a convolution curve, construct its arrangement, and use winding numbers to identify sum cells. The first uses the kinetic convolution and the second uses our monotonic convolution. The asymptotic running times of the exact algorithms are increased by km log m with m the number of segments in the convolution and with k the number of segment triples that are in cyclic vertical order due to approximate segment intersection. The approximate Minkowski sum is close to the exact sum of perturbation regions that are close to the input regions. We validate both algorithms on part packing tasks with industrial part shapes. The accuracy is near the floating point accuracy even after multiple iterated sums. The programs are 2% slower than direct floating point implementations of the exact algorithms. The monotonic algorithm is 42% faster than the kinetic algorithm

Rounding meshes in 3D

International audienceLet $\mathcal{P}$ be a set of $n$ polygons in $\mathbb{R}^3$, each of constant complexity and with pairwise disjoint interiors. We propose a rounding algorithm that maps $\mathcal{P}$ to a simplicial complex $\mathcal{Q}$ whose vertices have integer coordinates. Every face of $\mathcal{P}$ is mapped to a set of faces (or edges or vertices) of $\mathcal{Q}$ and the mapping from $\mathcal{P}$ to $\mathcal{Q}$ can be done through a continuous motion of the faces such that (i) the $L_\infty$ Hausdorff distance between a face and its image during the motion is at most 3/2 and (ii) if two points become equal during the motion, they remain equal through the rest of the motion. In the worst case the size of $\mathcal{Q}$ is $O(n^{13})$ and the time complexity of the algorithm is $O(n^{15})$ but, under reasonable assumptions, these complexities decrease to $O(n^{4}\sqrt{n})$ and $O(n^{5})$. Furthermore, these complexities are likely not tight and we expect, in practice on non-pathological data, $O(n\sqrt{n})$ space and time complexities

Exact polynomial system solving for robust geometric computation

I describe an exact method for computing roots of a system of multivariate polynomials with rational coefficients, called the rational univariate reduction. This method enables performance of exact algebraic computation of coordinates of the roots of polynomials. In computational geometry, curves, surfaces and points are described as polynomials and their intersections. Thus, exact computation of the roots of polynomials allows the development and implementation of robust geometric algorithms. I describe applications in robust geometric modeling. In particular, I show a new method, called numerical perturbation scheme, that can be used successfully to detect and handle degenerate configurations appearing in boundary evaluation problems. I develop a derandomized version of the algorithm for computing the rational univariate reduction for a square system of multivariate polynomials and a new algorithm for a non-square system. I show how to perform exact computation over algebraic points obtained by the rational univariate reduction. I give a formal description of numerical perturbation scheme and its implementation