Computational geometry

We give a deterministic algorithm for triangulating a simple polygon in linear time. The basic strategy is to build a coarse approximation of a triangulation in a bottom-up phase and then use the information computed along the way to refine the triangulation in a top-down phase. The main tools used are the polygon-cutting theorem, which provides us with a balancing scheme, and the planar separator theorem, whose role is essential in the discovery of new diagonals. Only elementary data structures are required by the algorithm. In particular, no dynamic search trees, of our algorithm.

Triangulating a simple polygon in linear time

Computational geometry.

Origami describes rules for creating folded structures from patterns on a flat sheet, but does not prescribe how patterns can be designed to fit target shapes. Here, starting from the simplest periodic origami pattern that yields one-degree-of-freedom collapsible structures-we show that scale-independent elementary geometric constructions and constrained optimization algorithms can be used to determine spatially modulated patterns that yield approximations to given surfaces of constant or varying curvature. Paper models confirm the feasibility of our calculations. We also assess the difficulty of realizing these geometric structures by quantifying the energetic barrier that separates the metastable flat and folded states. Moreover, we characterize the trade-off between the accuracy to which the pattern conforms to the target surface, and the effort associated with creating finer folds. Our approach enables the tailoring of origami patterns to drape complex surfaces independent of absolute scale, as well as the quantification of the energetic and material cost of doing so.

Programming curvature using origami tessellations

Voting based extreme learning machine

We study the problem of Nearest-Neighbor Searching under locational uncertainty. Here, an uncertain query or site consists of a set of points in the plane, and their distance is defined as distance between the two farthest points within them. In L∞ metric, we present an algorithm with O(n log n+s) expected preprocessing time, O(n log n) space, and O(log n + k) query time, where s is the total number of site points, n is the number of sites, and k is the size of the query. We also propose a √ 2-approximation algorithm for the L2 version of the problem.

Nearest-Neighbor Search Under Uncertainty.

Consider a pair of plane straight-line graphs whose edges are colored red and blue, respectively, and let n be the total complexity of both graphs. We present a $O(n\log {n})$-time O(n)-space technique to preprocess such a pair of graphs, that enables efficient searches among the red-blue intersections along edges of one of the graphs. Our technique has a number of applications to geometric problems. This includes: (1) a solution to the batched red-blue search problem [Dehne et al. 2006] in $O(n\log {n})$ queries to the oracle; (2) an algorithm to compute the maximum vertical distance between a pair of 3D polyhedral terrains, one of which is convex, in $O(n\log {n})$ time, where n is the total complexity of both terrains; (3) an algorithm to construct the Hausdorff Voronoi diagram of a family of point clusters in the plane in $O((n+m)\log ^3{n})$ time and $O(n+m)$ space, where n is the total number of points in all clusters and m is the number of crossings between all clusters; (4) an algorithm to construct the farthest-color Voronoi diagram of the corners of n disjoint axis-aligned rectangles in $O(n\log ^2{n})$ time; (5) an algorithm to solve the stabbing circle problem for n parallel line segments in the plane in optimal $O(n\log {n})$ time. All these results are new or improve on the best known algorithms.

Searching edges in the overlap of two plane graphs

We consider preprocessing a set $S$ of $n$ points in convex position in the plane into a data structure supporting queries of the following form: given a point $q$ and a directed line $\ell$ in the plane, report the point of $S$ that is farthest from (or, alternatively, nearest to) the point $q$ among all points to the left of line $\ell$. We present two data structures for this problem. The first data structure uses $O(n^{1+\varepsilon})$ space and preprocessing time, and answers queries in $O(2^{1/\varepsilon} \log n)$ time, for any $0 < \varepsilon < 1$. The second data structure uses $O(n \log^3 n)$ space and polynomial preprocessing time, and answers queries in $O(\log n)$ time. These are the first solutions to the problem with $O(\log n)$ query time and $o(n^2)$ space. 
The second data structure uses a new representation of nearest- and farthest-point Voronoi diagrams of points in convex position. This representation supports the insertion of new points in clockwise order using only $O(\log n)$ amortized pointer changes, in addition to $O(\log n)$-time point-location queries, even though every such update may make $\Theta(n)$ combinatorial changes to the Voronoi diagram. This data structure is the first demonstration that deterministically and incrementally constructed Voronoi diagrams can be maintained in $o(n)$ amortized pointer changes per operation while keeping $O(\log n)$-time point-location queries.

Data Structures for Halfplane Proximity Queries and Incremental Voronoi Diagrams

We present subquadratic algorithms in the algebraic decision-tree model for several 3Sumhard geometric problems, all of which can be reduced to the following question: Given two sets A, B, each consisting of n pairwise disjoint segments in the plane, and a set C of n triangles in the plane, we want to count, for each triangle ∆ ∈ C, the number of intersection points between the segments of A and those of B that lie in ∆. The problems considered in this paper have been studied by Chan (2020), who gave algorithms that solve them, in the standard real-RAM model, in O((n/ log n) log log n) time. We present solutions in the algebraic decision-tree model whose cost is O(n), for any ε > 0. Our approach is based on a primal-dual range searching mechanism, which exploits the multi-level polynomial partitioning machinery recently developed by Agarwal, Aronov, Ezra, and Zahl (2020). A key step in the procedure is a variant of point location in arrangements, say of lines in the plane, which is based solely on the order type of the lines, a “handicap” that turns out to be beneficial for speeding up our algorithm.

Subquadratic Algorithms for Some 3Sum-Hard Geometric Problems in the Algebraic Decision Tree Model

The minimum feature size of a planar straight-line graph is the minimum distance between a vertex and a nonincident edge. When such a graph is partitioned into a mesh, the degradation is the ratio of original to final minimum feature size. For an n-vertex input, we give a triangulation (meshing) algorithm that limits degradation to only a constant factor, as long as Steiner points are allowed on the sides of triangles. If such Steiner points are not allowed, our algorithm realizes $\ensuremath{O}(\lg n)$ degradation. This addresses a 14-year-old open problem by Bern, Dobkin, and Eppstein.

/pdf/meshes-preserving-minimum-feature-size-28tfig85fj.pdf

John Iacono

Papers

Nearest-Neighbor Search Under Uncertainty.

Searching edges in the overlap of two plane graphs

Data Structures for Halfplane Proximity Queries and Incremental Voronoi Diagrams

Subquadratic Algorithms for Some 3Sum-Hard Geometric Problems in the Algebraic Decision Tree Model

Meshes Preserving Minimum Feature Size