Geometric classification of triangulations and their enumeration in a convex polygon

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.

We present a heterogeneous architecture that contains a fine grained, massively parallel SIMD component called the data structure accelerator and demonstrate its use in a number of problems in computational geometry including polygon filling and convex hull. The data structure accelerator is extremely dense and highly scalable. Systems of 106 processing elements can be embedded in workstations and personal computers, without dramatically changing their cost. These components are intended for use in tandem with conventional single sequence machines and with small scale, shared memory multiprocessors. A language for programming these heterogeneous systems is presented that smoothly incorporates the SIMD instructions of the data structure accelerator with conventional single sequence code. We then demonstrate how to construct a number of higher level primitives such as maximum and minimum, and apply these tools to problems in logic and computational geometry. For computational geometry problems, we demonstrate that simple algorithms that take advantage of the parallelism available on a data structure accelerator perform as well or better than the far more complex algorithms which are needed for comparable efficiency on single sequence computers.

Determining whether two segments s and t in a planar polygonal scene weakly see each other is a classical problem in computational geometry. In this problem we seek for a segment connecting two points of s and t without intersecting edges of the scene. In planar polygonal scenes, this problem is 3sum-hard and its time complexity is Ω(n 2) where n is the complexity of the scene. This problem can be defined in the same manner when s and t are any kind of objects in the plane. In this paper we consider this problem when s and t can be points, segments or convex polygons. We preprocess the scene so that for any given pair of query objects we can solve the problem efficiently. In our presented method, we preprocess the scene in O(n 2 + ε ) time to build data structures of O(n 2) total size by which the queries can be answered in O(n 1 + ε ) time. Our method is based on the extended visibility graph [1] and a range searching data structure presented by Chazelle et al. [2].

The problem of cutting a convex polygon P out of a planar piece of material Q (P is already drawn on Q) with minimum total cutting cost is a well studied problem in computational geometry that has been studied with several variations such as P and Q are convex or non-convex polygons, Q is a circle, and the cuts are line cuts or ray cuts. In this paper, we address this problem without the restriction that P is fixed inside Q and consider the variation where Q is a circle and the cuts are line cuts. We show that if P can be placed inside Q such that P does not contain the center of Q, then placing P in a most cornered position inside Q gives a cutting cost of 6.48 times the optimal. We also give an O(n 2)-time algorithm for finding such a position of P, a problem that may be of independent interest. When any placement of P must contain the center of Q, we show that P can be cut of Q with cost 6.054 times the optimal.KeywordsPolygon cuttingline cutcutting costmost cornered positioncornerable and non-cornerable polygon

The theme of this chapter is a rather simple method that has proved very potent in the analysis of the expected performance of various randomized algorithms and data structures in computational geometry. The method can be described as “analyze a randomized algorithm as if it were running backwards in time, from output to input.” We apply this type of analysis to a variety of algorithms, old and new, and obtain solutions with optimal or near optimal expected performance for a plethora of problems in computational geometry, such as computing Delaunay triangulations of convex polygons, computing convex hulls of point sets in the plane or in higher dimensions, sorting, intersecting line segments, linear programming with a fixed number of variables, and others.

Spatial data structures form a core ingredient of many geometric algorithms, both in theory and in practice. Many of these data structures, especially the ones used in practice, are based on partitioning the underlying space (examples are binary space partitions and decompositions of polygons) or partitioning the set of objects (examples are bounding-volume hierarchies). The efficiency of such data structures---and, hence, of the algorithms that use them---depends on certain characteristics of the partitioning. For example the performance of many algorithms that use binary space partitions (BSPs) depends on the size of the BSPs. Similarly, the performance of answering range queries using bounding-volume hierarchies (BVHs) depends on the so-called crossing number that can be associated with the partitioning on which the BVH is based. Much research has been done on the problem of computing partitioning whose characteristics are good in the worst case. In this thesis, we studied the problem from a different point of view, namely instance-optimality. In particular, we considered the following question: given a class of geometric partitioning structures---like BSPs, simplicial partitions, polygon triangulations, …---and a cost function---like size or crossing number---can we design an algorithm that computes a structure whose cost is optimal or close to optimal for any input instance (rather than only worst-case optimal). We studied the problem of finding optimal data structures for some of the most important spatial data structures. As an example having a set of n points and an input parameter r, It has been proved that there are input sets for which any simplicial partitions has crossing number ¿(vr). It has also been shown that for any set of n input points and the parameter r one can make a simplicial partition with stabbing number O(vr). However, there are input point sets for which one can make simplicial partition with lower stabbing number. As an example when the points are on a diagonal, one can always make a simplicial partition with stabbing number 1. We started our research by studying BSPs for line segments in the plane, where the cost function is the size of the BSPs. A popular type of BSPs for line segments are the so-called auto-partitions. We proved that finding an optimal auto-partition is NP-hard. In fact, finding out if a set of input segments admits an auto-partition without any cuts is already NP-hard. We also studied the relation between two other types of BSPs, called free and restricted BSPs, and showed that the number of cuts of an optimal restricted BSP for a set of segments in R2 is at most twice the number of cuts of an optimal free BSP for that set. The details are being represented in Chapter 1 of the thesis. Then we turned our attention to so-called rectilinear r-partitions for planar point sets, with the crossing number as cost function. A rectilinear r-partition of a point set P is a partitioning of P into r subsets, each having roughly |P|/r points. The crossing number of the partition is defined using the bounding boxes of the subsets; in particular, it is the maximum number of bounding boxes that can be intersected by any horizontal or vertical line. We performed some theoretical as well as experimental studies on rectilinear r-partitions. On the theoretical side, we proved that computing a rectilinear r-partition with optimal stabbing number for a given set of points and parameter r is NP-hard. We also proposed an exact algorithm for finding optimal rectilinear r-partitions whose running time is polynomial when r is a constant, and a faster 2-approximation algorithm. Our last theoretical result showed that considering only partitions whose bounding boxes are disjoint is not sufficient for finding optimal rectilinear r-partitions. On the experimental side, we performed a comparison between four different heuristics for constructing rectilinear r-partitions. The so-called windmill KD-tree gave the best results. Chapter 2 of the thesis describes all the details of our research on rectilinear r-partitions. We studied another spatial data structure in Chapter 3 of the thesis. Decomposition of the interior of polygons is one of the fundamental problems in computational geometry. In case of a simple polygon one usually wants to make a Steiner triangulation of it, and when we have a rectilinear polygon at hand, one typically wants to make a rectilinear decomposition for it. Due to this reason there are algorithms which make Steiner triangulations and rectangular decompositions with low stabbing number. These algorithms are worst-case optimal. However, similar to the two previous data structures, there are polygons for which one can make decompositions with lower stabbing numbers. In 3 we proposed a 3-approximation for finding an optimal rectangular decomposition of a rectilinear polygon. We also proposed an O(1)-approximation for finding optimal Steiner triangulation of a simple polygon. Finally, in Chapter 4 of the thesis, we considered another optimization problem, namely how to approximate a piecewise-linear function F: R ¿R with another piecewise-linear function with fewer pieces. Here one can distinguish two versions of the problem. The first one is called the min-k problem; the goal is then to approximate the function within a given error e such that the resulting function has the minimum number of links. The second one is called the min-e problem; here the goal is to find an approximation with at most k links (for a given k) such that the error is minimized. These problems have already been studied before. Our contribution is to consider the problem for so-called uncertain functions, where the value of the input function F at its vertices is given as a discrete set of different values, each with an associated probability. We show how to compute an approximation that minimizes the expected error.

Querying visible points is a fundamental problem in computational geometry and spatial databases. With the development of new applications such as trip planning and nearest neighbors, querying visible points plays a key role in obstacle space and the result can be further used such as defining the shortest path. Thereby, efficiently finding the result is essentially important. However, the performance of current methods decrease substantially for large datasets. To solve the problem, we proposes a new and fast algorithm to find visible points for an arbitrary query location inside a large polygon containing obstacles. The method is based on polygon triangulation. By decomposing the polygon into a set of triangles, we manage the polygon by organizing triangles in an efficient way instead of maintaining a large number of vertices. We propose a data structure to partition the searching space into several parts, each of which is independently processed. Afterwards, by recursively calling a method we search visible points by accessing triangles and return the result in a progressive way. Through a theoretical analysis, assuming the polygon contains N vertices in total, the time complexity of our algorithm is O(N), improving the existing method O(N l o g N). We prove the correctness of the algorithm and analyze the space complexity, which is O(N). The technique is extended to return visible points less than a threshold distance to the query location. Using both synthetic and real datasets, we perform extensive experiments to test our algorithm and demonstrate its efficiency and effectiveness. Visible points are efficiently processed in a large obstacle space with over one million vertices. Experimental results show that our technique gains more than one order of magnitude speedup compared to competitive methods using large datasets.

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$.

In computational geometry, problems involving only rectilinear objects with edges parallel to the x -and y-axes have attracted great attention. They are often easier to solve than the same problems for arbitrary objects, and solutions are of high practical value, for instance in VLSI design. This is because in VLSI design technology requirements often dictate the use of only two orthogonal orientations for the boundary edges of objects as well as wires.The restriction on the boundary edges motivates the study of rectilinear objects, while the restriction on wires brings the focus on the well-known L1-metric (the Manhattan distance). In short, given the two orthogonal orientations, both the shape of objects and the distance function are determined in a natural way.More recent VLSI fabrication technology is capable of creating edges and wires in both the orthogonal and diagonal orientations. This motivates us to study more general polygons, and to generalize the distance concept to the case where any fixed set of orientations is allowed. We introduce a family of naturally induced metrics, and the subsequent generalization of geometrical concepts. A shortest connection between two points is in this case a path composed of line segments with only the given orientations. We derive optimal solutions for various basic planar distance problems in this setting, such as the computation of a Voronoi diagram, a minimum spanning tree, and the (minimum and maximum) distance between two convex polygons. Many other theoretically interesting and practically relevant problems remain to be solved. In particular, the new family of metrics may help bridge the gap between the L1- and the L2-metrics, as those are the limiting cases for two and infinitely many regularly distributed orientations.

The Art Gallery Problem (AGP) is one of the classic problems in Computational Geometry. For a given art gallery, represented by a polygon, the AGP seeks for the minimum number of guards that are necessary for overseeing the entire polygon. Many variants of this problems have already been studied. In this paper, we are interested in examining and visualizing two algorithms for the distributed version of the AGP, where guards are autonomous and have limited communication abilities. For this purpose, we present a self-contained simulator that is able to read or generate non convex polygons and to simulate the movements of robotic guards inside the polygonal environment by using the navigation algorithms. In particular, we study two algorithms: Random Search (RS) and Depth-First Search (DFS). We compare RS and DFS, in terms of computation time, by testing them on benchmark instances as well as randomly generated polygons. According to our experiments, each algorithm has a better performance on specific types of polygons.

The (axis-parallel) stabbing number of a given set of line segments is the maximum number of segments that can be intersected by any one (axis-parallel) line. We investigate problems of finding perfect matchings, spanning trees, or triangulations of minimum stabbing number for a given set of points. The complexity of these problems has been a long-standing open problem; in fact, it is one of the original 30 outstanding open problems in computational geometry on the list by Demaine, Mitchell, and O'Rourke.We show that minimum stabbing problems are NP-complete. We also show that an iterated rounding technique is applicable for matchings and spanning trees of minimum stabbing number by showing that there is a polynomially solvable LP-relaxation that has fractional solutions with at least one heavy edge. This suggests constant-factor approximations. Our approach uses polyhedral methods that are related to another open problem (from a combinatorial optimization list), in combination with geometric properties. We also demonstrate that the resulting techniques are practical for actually solving problems with up to several hundred points optimally or near-optimally.

Resultants were originally developed in the 18th and 19th centuries to solve certain simple algebraic problems. Here we shall present some applications of resultants to several important problems in computational geometry, including the implicitization, inversion, and intersection of parametric rational polynomial curves and surfaces.

The Art Gallery problem is a fundamental visibility problem in Computational Geometry. The input consists of a simple polygon P, (possibly infinite) sets G and C of points within P, and an integer k; the task is to decide if at most k guards can be placed on points in G so that every point in C is visible to at least one guard. In the classic formulation of Art Gallery, G and C consist of all the points within P. Other well-known variants restrict G and C to consist either of all the points on the boundary of P or of all the vertices of P. Recently, three new important discoveries were made: the above mentioned variants of Art Gallery are all W[1]-hard with respect to k [Bonnet and Miltzow, ESA'16], the classic variant has an O(log k)-approximation algorithm [Bonnet and Miltzow, SoCG'17], and it may require irrational guards [Abrahamsen et al., SoCG'17]. Building upon the third result, the classic variant and the case where G consists only of all the points on the boundary of P were both shown to be ∃ℝ-complete [Abrahamsen et al., STOC'18]. Even when both G and C consist only of all the points on the boundary of P, the problem is not known to be in NP. Given the first discovery, the following question was posed by Giannopoulos [Lorentz Center Workshop, 2016]: Is Art Gallery FPT with respect to r, the number of reflex vertices? In light of the developments above, we focus on the variant where G and C consist of all the vertices of P, called Vertex-Vertex Art Gallery. Apart from being a variant of Art Gallery, this case can also be viewed as the classic Dominating Set problem in the visibility graph of a polygon. In this article, we show that the answer to the question by Giannopoulos is positive: Vertex-Vertex Art Gallery is solvable in time r^O(r²)n^O(1). Furthermore, our approach extends to assert that Vertex-Boundary Art Gallery and Boundary-Vertex Art Gallery are both FPT as well. To this end, we utilize structural properties of almost convex polygons to present a two-stage reduction from Vertex-Vertex Art Gallery to a new constraint satisfaction problem (whose solution is also provided in this paper) where constraints have arity 2 and involve monotone functions.

A fundamental problem in computational geometry is to compute an obstacle-avoiding Euclidean shortest path between two points in the plane. The case of this problem on polygonal obstacles is well studied. In this paper, we consider the problem version on curved obstacles, commonly modeled as splinegons. A splinegon can be viewed as replacing each edge of a polygon by a convex curved edge (polygons are special splinegons). Each curved edge is assumed to be of O(1) complexity. Given in the plane two points s and t and a set of $h$ pairwise disjoint splinegons with a total of $n$ vertices, we compute a shortest s-to-t path avoiding the splinegons, in $O(n+h\log^{1+\epsilon}h+k)$ time, where k is a parameter sensitive to the structures of the input splinegons and is upper-bounded by $O(h^2)$. In particular, when all splinegons are convex, $k$ is proportional to the number of common tangents in the space (called free common tangents) among the splinegons. We develop techniques for solving the problem on the general (non-convex) splinegon domain, which also improve several previous results. In particular, our techniques produce an optimal output-sensitive algorithm for a basic visibility problem of computing all common tangents among $h$ pairwise disjoint convex splinegons with a total of $n$ vertices. Our algorithm runs in $O(n+h\log h+k)$ time and $O(n)$ space, where $k$ is the number of all common tangents. Even for the special case where all splinegons are convex polygons, the previously best algorithm for this visibility problem takes $O(n+h^2\log n)$ time.

An efficient VLSI architecture with applications to geometric problems