Memory-constrained algorithms for simple polygons

2004

We study a constrained version of the shortest path problem in simple polygons, in which the path must visit a given target polygon. We provide a worst-case optimal algorithm for this problem and also present a method to construct a subdivision of the simple polygon to efficiently answer queries to retrieve the shortest polygon-meeting paths from a single-source to the query point. The algorithms are linear, both in time and space, in terms of the complexity of the two polygons.

2016

An s-workspace algorithm is an algorithm that has read-only access to the values of the input, write-only access to the output, and only uses O(s) additional words of space. We give a random-ized s-workspace algorithm for triangulating a simple polygon P of n vertices, for any s ∈ O(n). The algorithm runs in O(n 2 /s + n(log s) log 5 (n/s)) expected time using O(s) variables, for any s ∈ O(n). In particular, when s ∈ O(n log n log 5 log n) the algorithm runs in O(n 2 /s) expected time. 1998 ACM Subject Classification I.3.5 Computational Geometry and Object Modeling

ACM-SIAM Symposium on Discrete Algorithms, 1992

We develop a data structure for answering link distance queries between two arbitrary points in a simple polygon. The data structure requires O(n3) time and space for its construction and answers link distance queries in O(log n) time. Our result extends to link distance queries between pairs of segments or polygons. We also propose a simpler data structure for computing

Algorithmica, 2019

We are given a read-only memory for input and a write-only stream for output. For a positive integer parameter s, an s-workspace algorithm is an algorithm using only O(s) words of workspace in addition to the memory for input. In this paper, we present an O(n 2 /s)-time s-workspace algorithm for subdividing a simple polygon into O(min{n/s, s}) subpolygons of complexity O(max{n/s, s}). As applications of the subdivision, the previously best known time-space trade-offs for the following three geometric problems are improved immediately by adopting the proposed subdivision: (1) computing the shortest path between two points inside a simple n-gon, (2) computing the shortest path tree from a point inside a simple n-gon, (3) computing a triangulation of a simple n-gon. In addition, we improve the algorithm for problem (2) further by applying different approaches depending on the size of the workspace.

International Journal of Computational Geometry & Applications, 1999

This paper presents a simple O(n+k) time algorithm to compute the set of knon-crossing shortest paths between k source-destination pairs of points on the boundary of a simple polygon of n vertices. Paths are allowed to overlap but are not allowed to cross in the plane. A byproduct of this result is an O(n) time algorithm to compute a balanced geodesic triangulation which is easy to implement. The algorithm extends to a simple polygon with one hole where source-destination pairs may appear on both the inner and outer boundary of the polygon. In the latter case, the goal is to compute a collection of non-crossing paths of minimum total cost. The case of a rectangular polygonal domain where source-destination pairs appear on the outer and one inner boundary12 is briefly discussed.

Discrete & Computational Geometry, 1997

We give an algorithm to compute a (Euclidean) shortest path in a polygon with h holes and a total of n vertices. The algorithm uses O(n) space and requires O(n +h 2 log n) time.

2003

Given a sequence of k polygons in the plane, a start point s, and a target point, t, we seek a shortest path that starts at s, visits in order each of the polygons, and ends at t. If the polygons are disjoint and convex, we give an algorithm running in time O(kn log(n/k)), where n is the total number of vertices specifying the polygons. We also extend our results to a case in which the convex polygons are arbitrarily intersecting and the subpath between any two consecutive polygons is constrained to lie within a simply connected region; the algorithm uses O(nk 2 log n) time. Our methods are simple and allow shortest path queries from s to a query point t to be answered in time O(k log n + m), where m is the combinatorial path length. We show that for nonconvex polygons this "touring polygons" problem is NP-hard.

Journal of Algorithms, 1986

Computational Geometry, 1997

A diagonal of a planar, simple polygon P is an open line segment that connects two nonadjacent vertices and lies in the relative interior of P. We present a linear time algorithm for finding a shortest diagonal (in the L2 norm) of a simple polygon, improving the previous best result by a factor of log n. Our result provides an interesting contrast to a known Y2(n log r 0 lower bound for finding a closest pair of vertices in a simple polygon-observe that a shortest diagonal is defined by a closest pair of vertices satisfying an additional visibility constraint.

Proceedings of the third annual symposium on Computational geometry - SCG '87, 1987

The problem of finding a rectilinear shortest path amongst obstacles may be stated as follows: Given a set of obstacles in the plane find a shortest rectilinear (L 1) path from a point s to a point t which avoids all obstacles. The path may touch an obstacle but may not cross an obstacle. We study the rectilinear shortest path problem for the case where the obstacles are non-intersecting simple polygons, and present an O(n (logn) 2) algorithm for finding such a path, where n is the number of vertices of the obstacles. This algorithm requires O(nlogn) space. Another algorithm is given that requires O(n(logn) 3/2) time and space. We also study the case of rectilinear obstacles in three dimensions, and show that L 1 shortest paths can be found in O(n 2 (log n) 3) time.

Lecture Notes in Computer Science, 1994

The kernel of a polygon P is the set of all points that see the interior of P. It can be computed as the intersection of the halfplanes that are to the left of the edges of P. We present an O(log log n) time CRCW-PRAM algorithm using n=log log n processors to compute a representation of the kernel of P that allows to answer point containment and line intersection queries eciently. Our approach is based on computing a subsequence of the edges that are sorted by slope and contain the \relevant" edges for the kernel computation.

Arxiv preprint arXiv: …, 2008

The polygon retrieval problem on points is the problem of preprocessing a set of n points on the plane, so that given a polygon query, the subset of points lying inside it can be reported efficiently. It is of great interest in areas such as Computer Graphics, CAD applications, Spatial Databases and GIS developing tasks. In this paper we study the problem of canonical k-vertex polygon queries on the plane. A canonical k-vertex polygon query always meets the following specific property: a point retrieval query can be transformed into a linear number (with respect to the number of vertices) of point retrievals for orthogonal objects such as rectangles and triangles (throughout this work we call a triangle orthogonal iff two of its edges are axisparallel). We present two new algorithms for this problem. The first one requires O(n log 2 n) space and O(k log 3 n loglogn +A) query time. A simple modification scheme on first algorithm lead us to a second solution, which consumes O(n 2 ) space and O(k logn loglogn + A) query time, where A denotes the size of the answer and k is the number of vertices. The best previous solution for the general polygon retrieval problem uses O(n 2 ) space and answers a query in O(k log n + A) time, where k is the number of vertices. It is also very complicated and difficult to be implemented in a standard imperative programming language such as C or C++.

Let P be a simple polygon in 2 with n vertices. The detour of P between two points, p, q ∈ P , is the length of a shortest path contained in P and connecting p to q, divided by the distance of these points. The detour of the whole polygon is the maximum detour between any two points in P . We first analyze properties of pairs of points with maximum detour. Next, we use these properties to achieve a deterministic O(n 2 )-algorithm for computing the maximum Euclidean detour and a deterministic O(n log n)-algorithm which calculates a (1+ε)approximation. Finally, we consider the special case of monotone rectilinear polygons. Their L 1 -detour can be computed in time O(n).

Cccg, 2010

The straight skeleton of a simple polygon is defined as the trace of the vertices when the initial polygon is shrunken in self-parallel manner . In this paper, we propose a simple algorithm for drawing the straight skeleton of a monotone polygon. The time and space complexities of our algorithm are O(nlogn) and O(n) respectively.

Computers & Geosciences, 1997

Point-in-polygon is one of the fundamental operations of Geographic Information Systems. A number of algorithms can be applied. Different algorithms lead to different running efficiencies. In the study, the complexities of eight point-in-polygon algorithms were analyzed. General and specific examples are studied. In the general example, an unlimited number of nodes are assumed; whereas in the second example, eight nodes are specified. For convex polygons, the sum of area method, the sign of offset method, and the orientation method is well suited for a single point query. For possibly concave polygons, the ray intersection method and the swath method shod be seiected. For eight node polygons, the ray intersection method with bounding rectangles is faster.