A linear-time algorithm for computing the voronoi diagram of a convex polygon

Geostationary (GEO) satellites used for civilian, military and various other strategic requirements are critical space assets for a country. Given a satellite of interest, an assessment of the area of influence of neighborhood satellite operations is critical for the safety of the satellite asset. Nearest neighbor search is a fundamental problem in computational geometry. Voronoi diagram is a geometric structures that is based on proximity and can be used for nearest neighbour identification. A solution methodology for assessment of threat perception is presented using Voronoi diagrams, Delaunay triangulation, and power diagram. The intuitive properties based on the topology and geometry of Voronoi diagrams, and the adjacency relations of Delaunay triangulation help in describing some kind of region of influence around each satellite. The influence exerted by non-cooperative GEO satellites over the satellite of interest, aid in estimating the threat perception. Once the threat is narrowed down, the costly and limited number of ground surveillance sensors like telescopes and radars will be optimally reoriented to closely monitor the non-cooperative satellites of interest.

Chapter 7 A survey of computational geometry

Minimizing the total length has been one of the main optimality criteria for triangulations and other kinds of partitions. Indeed, the minimum weight triangulation or MWT (i.e. a triangulation of minimum total edge length) has frequently been referred to as the optimal This triangulation has some good properties [1] and is e.g. useful in numerical approximation of bivariate data [23]. Its complexity is one of the most intriguing problems in computational geometry. No proof has yet been presented showing that it is NP-hard. On the other hand, no polynomial time heuristic for it was shown to guarantee even a constant approximation factor. However, very recently we proved that what we called the quasi-greedy triangulation has length within a constant factor from the minimum [13]. A standard implementation of that heuristic using known results would yield a quadratic time algorithm. In this paper, we improve on this by describing an O(n log n) algorithm for quasi-greedy triangulation. Moreover, if the Delaunay triangulation is given, our algorithm runs in linear time. The minimum weight convex partition (MWCP) problem has been shown to be NP-complete [7, 17]. By a MWCP we mean a set of non-crossing diagonals (i.e. without Steiner points) of minimum total length which includes the convex hull and partitions it into empty convex polygons. In [13] it was shown that, given the quasi-greedy triangulation, a convex partition of length within a constant factor from the MWCP can be computed in linear time. Thus from the results in this paper we also obtain a fast heuristic for approximating the MWCP. The quasi-greedy triangulation is very closely related to the greedy triangulation (both are defined in the next section). In fact, we will describe an algorithm that, given the Delannay triangulation, computes the greedy triangulation in linear time. This algorithm behaves in such a way that it is very easily adapted to yield an algorithm for the quasi-greedy triangulation. Consequently, we also present the first O(n log n) algorithm for greedy triangulation. (By using a substantially different approach, an attempt to develop an O(n log n) algorithm for greedy triangulation was done in [21]. Even if that approach could be corrected

SummaryVoronoi diagram is a versatile geometric structure used in solving many computational geometry problems in the field of image analysis, computer vision, engineering, medicine, molecular biology and various other disciplines. As a result it is a popular research domain. The literature boasts of many elegant and efficient methods for the construction of the Voronoi diagram in the real space. But these algorithms often fail to perform well when applied to the discrete domain. We present in this paper a novel algorithm for the construction of discrete Voronoi diagram using digital geometric concepts that takes care of the geometric perspective of the Voronoi diagram in the discrete domain. Although our technique is more suited for the CPU but by careful use of some cut‐off heuristics we are able to design a parallel programming approach for the construction of the Voronoi diagram making use of the GPU computational power. The speedup of our algorithm is compatible with the popular GPU technique for Voronoi diagram construction, namely, Jump flood algorithm. But since our algorithm uses the geometric perspective for the construction of Voronoi diagram it gives more accurate output and hence requires no correction step as is the case for the Jump flood algorithm. Furthermore, our approach focuses on extensibility, allowing for easy amenability for construction of higher dimensional Voronoi diagram. This ensures that the Voronoi diagram generation process can be adapted and expanded upon to meet specific requirements or incorporate future enhancements. We present an implementation of the proposed algorithm on a GPU using TAICHI language and describe its performance benefits on multiple input sites.

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2022 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Polygon Placement Revisited: (Degree of Freedom + 1)-SUM Hardness and an Improvement via Offline Dynamic Rectangle UnionMarvin Künnemann and André NusserMarvin Künnemann and André Nusserpp.3181 - 3201Chapter DOI:https://doi.org/10.1137/1.9781611977073.124PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract We revisit a classical problem in computational geometry: Determine the largest copy of a simple polygon P that can be placed into the simple polygon Q. Despite significant effort studying a number of settings, known algorithms require high polynomial running times, even for the interesting case when either P or Q have constant size. (Barequet and Har-Peled, 2001) give a conditional lower bound of n2–o(1) under the 3SUM conjecture when P and Q are (convex) polygons with Θ(n) vertices each. This leaves open whether we can establish (1) hardness beyond quadratic time and (2) any superlinear bound for constant-sized P or Q. In this paper, we affirmatively answer these questions under the higher-order kSUM conjecture, proving natural hardness results that increase with each degree of freedom (scaling, x-translation, y-translation, rotation): (scaling, x-translation:) Finding the largest copy of P that can be x-translated into Q requires time n2–o(1) under the 3SUM conjecture, even for orthogonal (rectilinear) polygons P, Q with O(1) and n vertices, respectively. (scaling, x-translation, y-translation:) Finding the largest copy of P that can be arbitrarily translatedinto Q requires time n2–o(1) under the 4SUM conjecture, even for orthogonal polygons P, Q with O(1) and n vertices, respectively. This establishes the same lower bound under the assumption that Subset Sum cannot be solved in time O((2–∊)n/2) for any ∊ > 0. The above lower bounds are almost tight when one of the polygons is of constant size: Using an offline dynamic algorithm for maintaining the area of a union of rectangles due to Overmars and Yap, we obtain an -time algorithm for orthogonal polygons P, Q with p and q vertices, respectively. This matches the lower bounds up to an n1/2+o(1)-factor when P, Q have O(1) and n vertices. (scaling, x-translation, y-translation, rotation:) Finally, finding the largest copy of P that can be arbitrarily rotated and translated into Q requires time n3–o(1) under the 5SUM conjecture. As in our reductions, each degree of freedom determines one summand in a kSUM instance, these lower bounds appear likely to be best possible under kSUM. We are not aware of any other such natural (degree of freedom + 1)-SUM hardness for a geometric optimization problem. Finally, we prove an additional tight OV hardness of the translations-only case. Previous chapter Next chapter RelatedDetails Published:2022eISBN:978-1-61197-707-3 https://doi.org/10.1137/1.9781611977073Book Series Name:ProceedingsBook Code:PRDA22Book Pages:xvii + 3771

The problem of cutting a convex polygon P out of a piece of paper Q with minimum total cutting length is a well studied problem in computational geometry. Researchers studied several variations of the problem, such as P and Q are convex or non-convex polygons and the cuts are line cuts or rays cuts. In this paper we consider yet another variation of the problem where Q is a circle and P is convex polygon such that P is bounded by a half circle of Q and all the cuts are line cuts. We give a simple linear time O(log n)-approximation algorithm for this problem where n is the number of vertices of P.

A frequently arising problem in computational geometry is when a physical structure, such as an ad-hoc wireless sensor network or a protein backbone, can measure local information about its geometry (e.g., distances, angles, and/or orientations), and the goal is to reconstruct the global geometry from this partial information. More precisely, we are given a graph, the approximate lengths of the edges, and possibly extra information, and our goal is to assign coordinates to the vertices that satisfy the given constraints up to a constant factor away from the best possible. We obtain the first subexponential-time (quasipolynomial-time) algorithm for this problem given a complete graph of Euclidean distances with additive error and no extra information. For general graphs, the analogous problem is NP-hard even with exact distances. Thus, for general graphs, we consider natural types of extra information that make the problem more tractable, including approximate angles between edges, the order type of vertices, a model of coordinate noise, or knowledge about the range of distance measurements. Our quasipolynomial-time algorithm for no extra information can also beviewed as a polynomial-time algorithm given an extremum oracle as extra information. We give several approximation algorithms and contrasting hardness results for these scenarios.

We revisit a classical problem in computational geometry that has been studied since the 1980s: in the rectangle enclosure problem we want to report all k enclosing pairs of n input rectangles in 2D. We present the first deterministic algorithm that takes O(nlogn + k) worst-case time and O(n) space in the word-RAM model. This improves previous deterministic algorithms with O((nlogn + k)loglogn) running time. We achieve the result by derandomizing the algorithm of Chan, Larsen and Pătraşcu [SoCG’11] that attains the same time complexity but in expectation.The 2D rectangle enclosure problem is related to the offline dominance range reporting problem in 4D, and our result leads to the currently fastest deterministic algorithm for offline dominance reporting in any constant dimension d ≥ 4.A key tool behind Chan et al.’s previous randomized algorithm is shallow cuttings for 3D dominance ranges. Recently, Afshani and Tsakalidis [SODA’14] obtained a deterministic O(nlogn)-time algorithm to construct such cuttings. We first present an improved deterministic construction algorithm that runs in O(nloglogn) time in the word-RAM; this result is of independent interest. Many additional ideas are then incorporated, including a linear-time algorithm for merging shallow cuttings and an algorithm for an offline tree point location problem.KeywordsQuery PointDeterministic AlgorithmInput PointOuter CornerPlanar SeparatorThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In this work we study quantum algorithms for Hopcroft’s problem which is a fundamental problem in computational geometry. Given n points and n lines in the plane, the task is to determine whether there is a point-line incidence. The classical complexity of this problem is well-studied, with the best known algorithm running in O ( n 4/3 ) time, with matching lower bounds in some restricted settings. Our results are two different quantum algorithms with time complexity \(\widetilde{O}(n^{5/6}) \) . The first algorithm is based on partition trees and the quantum backtracking algorithm. The second algorithm uses a quantum walk together with a history-independent dynamic data structure for storing line arrangement which supports efficient point location queries. In the setting where the number of points and lines differ, the quantum walk-based algorithm is asymptotically faster. The quantum speedups for the aforementioned data structures may be useful for other geometric problems. Finally, we examine the connections between Hopcroft’s problem and other computational problems via fine-grained complexity. For example, we show a conditional Ω ( n 3/4 ) time lower bound on Hopcroft’s problem in 5 dimensions based on the quantum analogue of a classical hardness conjecture, which is stronger than the (optimal) Θ ( n 2/3 ) query complexity bounds.

We study the problem of searching for a mobile intruder in a polygonal region P by two guards. The objective is to decide whether there should exist a search schedule for the two guards to detect the intruder, no matter how fast the intruder moves, and if so, generate a search schedule. During the search, the two guards are required to walk on the boundary of P continuously and be mutually visible all the time. We present a characterization of the class of polygons searchable by two guards in terms of non-redundant components, and thus solve a long-standing open problem in computational geometry. Also, we give an optimal O(n) time algorithm to determine the two-guard searchability in a polygon, and an O(n log n + m) time algorithm to generate a search schedule, if it exists, where n is the number of vertices of P and m (≤ n 2) is the number of search instructions reported.

This paper has two goals. First, we point out that most problems in computational geometry in fact have fast parallel algorithms (that is, in NC*) by reduction to the cell decomposition result of Kozen and Yap. We illustrate this using a new notion of generalized Voronoi diagrams that subsumes all known instances. While the existence of NC* algorithms for computational geometry is theoretically significant, it leaves much to be desired for specific problems. Therefore, the second part of the paper surveys some recent results in a fast growing list of parallel algorithms for computational geometry.

A two-dimensional arrayA={a[i, j]} is calledtotally monotone if, for alli1<i2 andj1<j2,a[i1,j1]<a[i1,j2] impliesa[i2,j1]<a[i2,j2]. Totally monotone arrays were introduced in 1987 by Aggarwal, Klawe, Moran, Shor, and Wilber, who showed that several problems in computational geometry and VLSI river routing could be reduced to the problem of finding a maximum entry in each row of a totally monotone array. In this paper we consider several selection and sorting problems involving totally monotone arrays and give a number of applications of solutions for these problems. In particular, we obtain the following results for anm × n totally monotone arrayA: 1. Thek largest (ork smallest) entries in each row ofA can be computed inO(k(m + n)) time. This result allows us to determine thek farthest (ork nearest) neighbors of each vertex of a convexn-gon inO(kn) time. 2. Provided the transpose ofA is also totally monotone, thek largest (ork smallest) entries overall inA can be computed inO(m + n + k lg(mn/k)) time. This result allows us to find thek farthest (ork nearest) pairs of vertices from a convexn-gon inO(n + k lg(n2/k)) time. 3. The rows ofA can be sorted inO(mn) time whenm ≥n and inO(mn(1 + lg(n/m))) time whenm < n. This result allows us to solve the of Ω(S) on the number of combinations of row permutations possible for a totally monotone array would imply an Ω(lgS) lower bound on the time necessary to sort the array's rows in a linear decision tree model.) 4. In Subsection 4.2 we applied our algorithm for sorting the rows of a totally monotone array to the neighbor-ranking problem for the vertices of a convex polygonP. We then extended this technique to arbitrary point sets. It remains open whether our two selection algorithms for totally monotone arrays, which we also applied to the vertices of a convex polygon, can likewise be applied to arbitrary point sets.

Off-Line Maintenance of Planar Configurations

The “radii” considered here are the inradius $\rho $, the circumradius R, the diameter $\delta $, and the width $\Delta $. The convex polygons in question have their vertices at points of the integer lattice in $\mathbb{R}^2 $, and their radii are measured with respect to an $\ell ^p $ norm. Computation of these radii for convex polygons (and of their higher-dimensional analogues for convex polytopes) is of interest in connection with a number of applications, and may be regarded as a basic problem in computational geometry. The terms good radius and bad radius refer to the existence or nonexistence of a rationalizing polynomial—a nonconstant rational polynomial q such that $q(\varphi (C))$ is rational whenever C is a convex lattice polygon and $\varphi $ is the radius function in question. When a radius is good, the polynomial is a tool for implicit computation of the radius in the binary model of computation; otherwise it seems to be necessary to resort to approximation. It is proved here that all four radii are good when $p \in \{ 1,\infty \} $, while $\delta $ is good when p is an integer and $\Delta $ is good when $p / (p - 1)$ is an integer. Thus $\delta $ and $\Delta $ are both good when $p = 2$, and it turns out that R is also good in this case. However, the main results are that r is bad when $p = 2$ and R is bad for each integer $p \geq 3$.

Computational geometry is the study of algorithms for manipulating sets of points, lines, polygons, planes and other geometric objects. For many problems in this realm, the sets considered are static and the data structures representing them do not permit efficient insertion and deletion of objects (e.g. points). Dynamic problems, in which the set and the geometric data structure change over time, are also of interest. The topic of this thesis is the presentation of fast algorithms for fully dynamic maintenance of some common geometric structures. The following configurations are examined: planar nearest-point and farthest-point Voronoi diagrams, convex hulls (in two and three dimensions), common intersection of halfspaces (2-D and 3-D), and contour of maximal vectors (2-D and 3-D). The principal techniques exploited are fast merging of substructures, and the use of extra storage. Dynamic geometric search structures based upon the configurations are also presented.