Finding the Shortest Path Between Two Points in a Simple Polygon by Applying a Rubberband Algorithm

A simple polygon is said to be weakly internally visible from a line segment lying inside it (chord, if the endpoints of the segment lie on the boundary of the polygon), if every point on the boundary of the polygon is visible from some point of this line segment. In this paper we describe a simple linear time algorithm for computing such a chord, when it exists. We also computed all non-redundant components of P which must be intersected by any chord of P from which P is wiv. The most interesting aspects of this algorithm are that we have been able to dispense with the complicated triangulation algorithm of Chazelle [2] as well as the algorithm in [7] for computing all shortest paths from a given vertex in a triangulated polygon. As a consequence of this, we can now use this algorithm to derive an optimal algorithm for triangulating a weakly internally visible polygon. Also these results can now be used in [3] to find a shortest line segment from which a polygon is weakly internally visible in optimal linear time.

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

Characterizing LR-visibility polygons and related problems

We investigate the $$L_1$$ geodesic farthest neighbors in a simple polygon P, and address several fundamental problems related to farthest neighbors. Given a subset $$S \subseteq P$$ , an $$L_1$$ geodesic farthest neighbor of $$p \in P$$ from S is one that maximizes the length of $$L_1$$ shortest path from p in P. Our list of problems include: computing the diameter, radius, center, farthest-neighbor Voronoi diagram, and two-center of S under the $$L_1$$ geodesic distance. We show that all these problems can be solved in linear or near-linear time based on our new observations on farthest neighbors and extreme points. Among them, the key observation shows that there are at most four extreme points of any compact subset $$S \subseteq P$$ with respect to the $$L_1$$ geodesic distance after removing redundancy.

We consider the problem of finding the staircase kernel in orthogonal polygons, with or without holes, in the plane. Orthogonal polygon is a simple polygon in the plane whose sides are either horizontal or vertical. We generalize the notion of visibility in the following way: We say that two points a and b in an orthogonal polygon P are visible to each other via staircase paths if and only if there exist an orthogonal chain connecting a and b and lying entirely in the interior of P. Furthermore, the orthogonal chain should have the property that the angles between the consecutive segments in the chain are either +90 ∘ or −90 ∘ , and these should alternate along the chain. There are two principal types of staircases, NW-SE and NE-SW. The notion of staircase visibility has been studied in the literature for the last three decades. Based on this notion we can generalize the notion of star-shapedness. A polygon P is called star-shaped under staircase visibility, or simply s-star if and only if there is nonempty set of points S in the interior of P, such that any point of S sees any point of P via staircase path. The largest such set of points is called the staircase kernel of P and denoted ker P. Our work is motivated by the work of Breen (1). She proves that the staircase kernel of an orthogonal polygon without holes is the intersection of all maximal orthogonally convex polygons contained in it. We extend Breen's results for the case when the orthogonal polygon has holes. We prove the necessary geometric properties, and use them to derive a quadratic time, O(���� 2 ) algorithm for computing the staircase kernel of an orthogonal polygon with holes, having n vertices in total, including the holes' vertices. The algorithm is based on the plane sweep technique, widely used in Computational Geometry(4). Our result is optimal in the case of orthogonal polygon with holes, since the kernel (as proven) can consist of quadratic number of disjoint regions. In the case of polygon without holes, there is a linear time algorithm by Gewali(3), that is specific to the case of a polygon without holes. We present ex- amples of our algorithm's results.

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

We present the first polynomial time algorithm that finds the shortest route in a simple polygon such that all points of the polygon are visible from the route. This route is called the shortest watchman route, and we do not assume any restrictions on the route or on the simple polygon. Our algorithm runs in worst case O(n 6 ) time, but it is adaptive, making it run faster on polygons with a simple structure.

This paper proposes a new algorithm for querying the shortest path between two points s and t in a simple polygon P based on Voronoi diagram(VD). Based on the polygon's VD, we first find the Voronoi skeleton path S(s, t) from point s to t, and then along which we compute the shortest path SP(s, t) by visibility computing simultaneously. SP(s, t) can be reported in time O(n). It can be used in our 3D virtual museum system, in which the polygon's VD is used as a data structure for path planning, visibility computing, collision detection, and so on.

The Steiner problem leads to solutions in several scientific and business applications, computer networks' routing and electronic integrated circuits are few examples. The computational features of this problem make it an important research subject in computational geometry. Assuming some points in the Euclidean plane, we can construct a minimum spanning tree connecting these (terminal) nodes. It is possible to add some extra points (Steiner Points) in order to decrease the length of this tree which would in turn lead to Euclidean Steiner minimal tree (ESMT). This problem is considered as a NP-hard problem, as it may contain some nodes that are not in the set of given nodes. Assuming a simple polygon P with m vertices and n terminals in it, we try to find a Euclidean Steiner minimal tree connecting all these n terminals in P. In this paper we propose solutions for any number of terminals in a simple polygon. Proposed algorithms can also solve the problem in a simple polygon with some obstacles inside. These algorithms are simple to implement and lead to good results.

A simple polygon P with two distinguished vertices, s and t, is called a street if the two boundary chains from s to t are mutually weakly visible. We present an on-line strategy that walks from s to t, in any unknown street, on a path at most $\sqrt{2}$ times longer than the shortest path. This matches the best lower bound previously known and settles an open problem in the area of competitive path planning. (The result was simultaneously and independently obtained by the first three authors and by the last two authors. Both papers, [C. Icking, R. Klein, and E. Langetepe, Proceedings of the 16th Symposium on Theoretical Aspects in Computer Science, Lecture Notes in Comput. Sci. 1563, Springer-Verlag, Berlin, 1999, pp. 110--120] and [S. Schuierer and I. Semrau, Proceedings of the 16th Symposium on Theoretical Aspects of Computer Science, pp. 121--131], were presented at STACS'99. The present paper contains a joint full version.)

Let p and q be two points on the surface of a polytope Π. This paper provides a rubberband algorithm for computing a Euclidean shortest path between p and q (a so-called surface ESP) that is contained on the surface of Π. The algorithm has \(\kappa_1(\varepsilon) \cdot \kappa_2(\varepsilon) \cdot {\cal O}(n^2)\) time complexity, where n is the number of vertices of Π, κ i (ε) = (L 0 i − L i )/ε, for the true length L i of some shortest path with initial (polygonal path) length L 0 i (used when approximating this shortest path), for i = 1, 2. Rubberband algorithms follow a straightforward design strategy, and the proposed algorithm is easy to implement and thus of importance for applications, for example, when analyzing 3D objects in 3D image analysis, such as in biomedical or industrial image analysis, using 3D image scanners.

Given a plane graph it is known how to compute the union of non-crossing shortest paths. These algorithms do not allow neither to list each single shortest path nor to compute length of shortest paths. Given the union of non-crossing shortest paths, we introduce the concept of shortcuts that allows us to establish whether a path is a shortest path by checking local properties on faces of the graph. By using shortcuts we can compute the length of each shortest path, given their union, in total linear time, and we can list each shortest path p in O(max{ℓ,ℓloglogkℓ}), where ℓ is the number of edges in p and k the number of shortest paths.

We present an O(n) time algorithm for computing row-wise maxima or minima of an implicit, totally monotone $n \times n$ matrix whose entries represent shortest-path distances between pairs of vertices in a simple polygon. We apply this result to derive improved algorithms for several well-known problems in computational geometry. Most prominently, we obtain linear-time algorithms for computing the geodesic diameter, all farthest neighbors, and external farthest neighbors of a simple polygon, improving the previous best result by a factor of O(log n) in each case.

Plithogenic cubic sets extend the cubic set framework into new mathematical territory that enables superior handling of decision-making and pattern recognition when dealing with uncertainty. Through Plithogenic logic researchers could develop advanced methods to represent complex patterns by supporting inconsistent and self-contradictory or combined features. This research paper explores the schematic explanation of Plithogenic cubic sets and their use in pattern recognition applications. The strong nature of pattern recognition emerge from Plithogenic logic's dimensionality flexibility when combined with a two-member structure in cubic sets while resolving imprecision and vagueness and the complexity of information aspects. Through theoretical foundations and illustrative examples the author presented their capability to employ Plithogenic cubic sets successfully in pattern recognition and classification applications. The schematic method delivers a complete grasp of Plithogenic cubic sets as an enabling instrument for pattern recognition research.

Random polygon Generation from a given set of points is very important for different applications. A heuristic termed as “GRP_AS” has been proposed here to generate a random simple polygon from a given set of `n' points in 2-Dimensional plane. The “2-Opt Move” heuristic with time complexity O(n <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">4</sup> ) is the best known among the existing heuristics to generate a simple polygon. We recently designed another heuristic “GRP_CH” for the same problem with time complexity O(n <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">3</sup> ) which was shown to be better than that of “2-Opt Move” heuristic in terms of random behaviour and time complexity. In this work, our main objective is to design an algorithm with reduced time complexity. The proposed heuristic, “GRP_AS” is based on the principle of random selection of a line segment and angular sorting of the point set. This “GRP_AS” heuristic takes O(nlogn) time which is less than that of “2-Opt Move” heuristic as well as “GRP_CH” heuristic. The lower bound and upper bound on the number of polygons generated in “GRP_AS” heuristic has been computed.