Showing papers in "International Journal of Computational Geometry and Applications in 1995"
TL;DR: As a measure for the resemblance of curves in arbitrary dimensions the authors consider the so-called Frechet-distance, which is compatible with parametrizations of the curves, and for polygonal chains P and Q consisting of p and q edges an algorithm of runtime O(pq log( pq))) measuring the Frechet Distance.
Abstract: As a measure for the resemblance of curves in arbitrary dimensions we consider the so-called Frechet-distance, which is compatible with parametrizations of the curves. For polygonal chains P and Q consisting of p and q edges an algorithm of runtime O(pq log(pq)) measuring the Frechet-distance between P and Q is developed. Then some important variants are considered, namely the Frechet-distance for closed curves, the nonmonotone Frechet-distance and a distance function derived from the Frechet-distance measuring whether P resembles some part of the curve Q.
1,008 citations
TL;DR: This paper shows that for an arbitrary positive edge-weighted graph G, for any t>1, and any ∈>0, a t-spanner of G with weight can be constructed in polynomial time, and shows that (log2 n)-spanners of weight O(1) · wt(MST) can be constructing.
Abstract: Let G=(V, E) be an n-vertex connected graph with positive edge weights. A subgraph G′=(V, E′) is a t-spanner of G if for all u, v∈V, the weighted distance between u and v in G′ is at most t times the weighted distance between u and v in G. We consider the problem of constructing sparse spanners. Sparseness of spanners is measured by two criteria, the size, defined as the number of edges in the spanner, and the weight, defined as the sum of the edge weights in the spanner. In this paper, we concentrate on constructing spanners of small weight. For an arbitrary positive edge-weighted graph G, for any t>1, and any ∈>0, we show that a t-spanner of G with weight can be constructed in polynomial time. We also show that (log2 n)-spanners of weight O(1) · wt(MST) can be constructed. We then consider spanners for complete graphs induced by a set of points in d-dimensional real normed space. The weight of an edge xy is the norm of the vector. We show that for these graphs, t-spanners with total weight O(log n) · wt(MST) can be constructed in polynomial time.
118 citations
TL;DR: This paper considers the “open edge” variant of the polygon search problem, in which the given polygon P must be searched without allowing undetected intruders to reach a given edge u, under an additional assumption that any number of intruders can leave and enter P through another edge v at any time.
Abstract: The polygon search problem is the problem of searching for mobile intruders in a simple polygon by a single mobile searcher having various degrees of visibility. This paper considers the “open edge” variant of the problem in which the given polygon P must be searched without allowing undetected intruders to reach a given edge u, under an additional assumption that any number of intruders can leave and enter P through another edge v at any time. One may view P as representing a corridor with two open exits u and v, and the task of the searcher is to force all the intruders out of P through v (but not u). We present a simple necessary condition for a polygon to be searchable in this manner by the searcher having a light bulb, and then show that the same condition is sufficient for the polygon to be searchable by the searcher having two flashlights. The time complexity of generating a search schedule is also discussed.
71 citations
TL;DR: In this article, a general lemma on the existence of (1/r)-cuttings of geometric objects in Ed that satisfy certain properties was proved, and the authors used this lemma to construct small cuttings for arrangements of line segments in the plane and arrangements of triangles in 3-space.
Abstract: We prove a general lemma on the existence of (1/r)-cuttings of geometric objects in Ed that satisfy certain properties. We use this lemma to construct (1/r)-cuttings of small size for arrangements of line segments in the plane and arrangements of triangles in 3-space; for line segments in the plane we obtain a cutting of size O(r+Ar2/n2), and for triangles in 3-space our cutting has size O(r2+c+Ar3/n3). Here A is the combinatorial complexity of the arrangement. Finally, we use these results to obtain new results for several problems concerning line segments in the plane and triangles in 3-space.
55 citations
TL;DR: In this article, the authors consider the correctness of 2-d Delaunay triangulation algorithms implemented using floating-point arithmetic and show that flipping triangulations can be implemented in O(n∈)-time, where n is the number of point sites and ∈ is the relative error of floating point arithmetic.
Abstract: We consider the correctness of 2-d Delaunay triangulation algorithms implemented using floating-point arithmetic. The α-pseudocircle through points a, b, c consists of three circular arcs connecting ab, bc, and ac, each arc inside the circumcircle of a, b, c and forming angle α with the circumcircle; a triangulation is α-empty if the α-pseudocircle through the vertices of each triangle is empty. We show that a simple Delaunay triangulation algorithm—the flipping algorithm—can be implemented to produce O(n∈)-empty triangulations, where n is the number of point sites and ∈ is the relative error of floating-point arithmetic; its worst-case running time is O(n2). We also discuss floating-point implementation of other 2-d Delaunay triangulation algorithms.
47 citations
IBM1
TL;DR: It is shown that the Minkowski-sum boundary is describable as an algebraic curve (or subset thereof) when the given curves are algebraic, and the computation of its implicit equation is illustrated.
Abstract: The Minkowski sum of two plane curves can be regarded as the area generated by sweeping one curve along the other. The boundary of the Minkowski sum consists of translated portions of the given curves and/or portions of a more complicated curve, the “envelope” of translates of the swept curve. We show that the Minkowski-sum boundary is describable as an algebraic curve (or subset thereof) when the given curves are algebraic, and illustrate the computation of its implicit equation. However, such equations are typically of high degree and do not offer a practical basis for tracing the boundary. For the case of polynomial parametric curves, we formulate a simple numerical procedure to address the latter problem, based on constructing the Gauss maps of the given curves and using them to identifying “corresponding” curve segments that are to be summed. This yields a set of discretely-sampled arcs that constitutes a superset of the Minkowski-sum boundary, and can be regarded as a planar graph. To extract the true boundary, we present a method for identifying and “trimming” away extraneous arcs by systematically traversing this graph.
45 citations
TL;DR: If the line segments are constrained to lie in a fixed number of orientations it is shown that a minimum polygon transversal can be found in O(n log n) time.
Abstract: Let S be used to denote a finite set of planar geometric objects. Define a polygon transversal of S as a closed simple polygon that simultaneously intersects every object in S, and a minimum polygon transversal of S as a polygon transversal of S with minimum perimeter. If S is a set of points then the minimum polygon transversal of S is the convex hull of S. However, when the objects in S have some dimension then the minimum polygon transversal and the convex hull may no longer coincide. We consider the case where S is a set of line segments. If the line segments are constrained to lie in a fixed number of orientations we show that a minimum polygon transversal can be found in O(n log n) time. More explicitely, if m denotes the number of line segment orientations, then the complexity of the algorithm is given by O(3mn+log n). The general problem for line segments is not known to be polynomial nor is it known to be NP-hard.
35 citations
TL;DR: A new and simpler proof is given of Salowe’s theorem, i.e., a sequential algorithm is given that computes the k closest pairs in the set S in O(n log n+k) time, using O-dimensional space, and is, therefore, optimal.
Abstract: Let S be a set of n points in D-dimensional space, where D is a constant, and let k be an integer between 1 and . A new and simpler proof is given of Salowe’s theorem, i.e., a sequential algorithm is given that computes the k closest pairs in the set S in O(n log n+k) time, using O(n+k) space. The algorithm fits in the algebraic decision tree model and is, therefore, optimal. Salowe’s algorithm seems difficult to parallelize. A parallel version of our algorithm is given for the CRCW-PRAM model. This version runs in O((log n)2 log log n) expected parallel time and has an O(n log n log log n+k) time-processor product. Finally, actual running times are given of an implementation of our sequential algorithm.
32 citations
TL;DR: It is shown that the Voronoi diagram of a finite sequence of points in the plane which gives sorted order of the points with respect to two perpendicular directions can be computed in linear time.
Abstract: We show that the Voronoi diagram of a finite sequence of points in the plane which gives sorted order of the points with respect to two perpendicular directions can be computed in linear time. In contrast, we observe that the problem of computing the Voronoi diagram of a finite sequence of points in the plane which gives the sorted order of the points with respect to a single direction requires Ω(n log n) operations in the algebraic decision tree model. As a corollary from the first result, we show that the bounded Voronoi diagrams of simple n-vertex polygons which can be efficiently cut into the so called monotone histograms can be computed in o(n log n) time.
30 citations
TL;DR: This paper focuses on algebraic curves and surfaces, those that can be represented using rational parametric equations, and are particularly important in geometric modeling applications.
Abstract: Algebraic curves and surfaces are commonly used in geometric modeling. Parametric curves and surfaces are those that can be represented using rational parametric equations, and are particularly important. In geometric modeling applications, the parametric equations are restricted to some bounded portion of the domain, yielding a segment of a curve or a patch of a surface. However, the algebraic curve or surface is an image of the entire infinite parameter domain. Attempting to map the entire curve or surface using very large regions of the parameter domain is not a solution because some finite points may be images of infinite parameter values.
25 citations
TL;DR: It is proved that Θ(n3) area is necessary and sufficient to realize the complete visibility graph Kn and that for polygons P1 and P2, the problem of testing if they have isomorphic visibility graphs is isomorphism-complete.
Abstract: In this paper, we consider two distinct problems related to complexity aspects of the visibility graphs of simple polygons. Recognizing visibility graphs is a long-standing open problem. It is not even known whether visibility graph recognition is in NP. That visibility graph recognition is in NP would be established if we could demonstrate that any n vertex visibility graph is realized by a polygon which can be drawn on an exponentially-sized grid. This motivates a study of the area requirements for realizing visibility graphs. In this paper, we prove: • Θ(n3) area is necessary and sufficient to realize the complete visibility graph Kn. • There exist visibility graphs which require exponential area to realize. • Any maximal outerplanar graph of diameter d can be realized in O(d2 · 2d) area, which can be as small as O(n log2 n) for a balanced mop. Linear maximal outer-planar graphs can be realized in O(n8) area. The second part of this paper considers the complexity of specific optimization problems on visibility graphs. Given a polygon P, we show that finding a maximum independent set, minimum vertex cover, or maximum dominating set in the visibility graph of P are all NP-complete. Further we show that for polygons P1 and P2, the problem of testing if they have isomorphic visibility graphs is isomorphism-complete. These problems remain hard when given the visibility graphs as input.
TL;DR: Using only O(n) triangles, it is shown how to triangulate polygonal regions—adding extra vertices as necessary— with triangles of guaranteed quality with the guarantee that the smallest height of a triangle in a triangulation of an n-vertex polygon is a constant fraction of the largest possible.
Abstract: We show how to triangulate polygonal regions—adding extra vertices as necessary— with triangles of guaranteed quality. Using only O(n) triangles, we can guarantee that the smallest height (shortest dimension) of a triangle in a triangulation of an n-vertex polygon (with holes) is a constant fraction of the largest possible. Using O(n log n) triangles for simple polygons or O(n3/2) triangles for polygons with holes, we can guarantee that the largest angle is no greater than 150°. We can add the guarantee on smallest height to these no-large-angle results, without increasing the asymptotic complexity of the triangulation. Finally we give a nonobtuse triangulation algorithm for convex polygons that uses O(n1.85) triangles.
TL;DR: A data structure for answering link distance queries between two arbitrary points in a simple polygon that requires O(n3) time and space for its construction and answers linkdistance queries in O(log n) time, after which a minimum-link path can be reported in time proportional to the number of links.
Abstract: 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, after which a minimum-link path can be reported in time proportional to the number of links. Here, n denotes the number of vertices of the polygon. Our result extends to link distance queries between pairs of segments or polygons. We also propose a simpler data structure for computing a link distance approximately, where the error is bounded by a small additive constant. Finally, we also present a scheme for approximating the link and the shortest path distance simultaneously.
TL;DR: Two algorithms which compute a point in the common intersection of n convex sets are given and it is shown how these algorithms may be adapted to construct linear and spherical separators of a collection of sets, and to construct a translate of a given object which either contains, is contained by, or intersects aCollection of convex set.
Abstract: This paper investigates computational aspects of the well-known convexity theorem due to Helly, which states that the existence of a point in the common intersection of n convex sets is guaranteed by the existence of points in the common intersection of each combination of d+1 of these sets. Given an oracle which accepts d+1 convex sets and either returns a point in their common intersection, or reports its non-existence, we give two algorithms which compute a point in the common intersection of n such gets. The first algorithm runs in O(nd+1T) time and O(nd) space, where T is the time required for a single call to the oracle. The second algorithm is a multi-stage variant of the first by which the space complexity may be reduced to O(n) at the expense of an increase in the time complexity by a factor independent of n. We also show how these algorithms may be adapted to construct linear and spherical separators of a collection of sets, and to construct a translate of a given object which either contains, is contained by, or intersects a collection of convex sets.
TL;DR: The spider robot is modelled as a point where all its legs are attached, and the footholds where the robot can securely place its feet consist of a set of n points in the plane, and it is shown that the space F of admissible and stable placements of such robots has size Θ(n2) and can be constructed in O(n 2 log n) time and O( n2) space.
Abstract: We consider the problem of planning motions of a simple legged robot called the spider robot. The robot is modelled as a point where all its legs are attached, and the footholds where the robot can securely place its feet consist of a set of n points in the plane. We show that the space F of admissible and stable placements of such robots has size Θ(n2) and can be constructed in O(n2 log n) time and O(n2) space. Once F has been constructed, we can efficiently solve several problems related to motion planning.
TL;DR: A new technique for geometric enumeration problems which iteratively reduces the search space by a half and provides efficient algorithms, which are faster than trivial ones when k=o(n3/2).
Abstract: We study the problem of enumerating k farthest pairs for n points in the plane and the problem of enumerating k closest/farthest bichromatic pairs of n red and n blue points in the plane. We propose a new technique for geometric enumeration problems which iteratively reduces the search space by a half and provides efficient algorithms. As applications of this technique, we develop algorithms, using higher order Voronoi diagrams, for the above problems, which run in O(min{n2, n log n+k4/3log n/log1/3 k}) time and O(n+k4/3/log1/3 k+k log n) space for general Lp metric with p≠2, and O(min{n2, n log n+k4/3}) time and O(n+k4/3+k log n) space for L2 metric. For the problem of enumerating k closest/farthest bichromatic pairs, we shall also discuss the case where we have different numbers of red and blue points. To the authors’ knowledge, no nontrivial algorithms have been known for these problems and our algorithms are faster than trivial ones when k=o(n3/2).
TL;DR: This work provides optimal parallel solutions to several shortest path and visibility problems set in triangulated simple polygons, using the CREW PRAM model.
Abstract: We provide optimal parallel solutions to several shortest path and visibility problems set in triangulated simple polygons. Let P be a triangulated simple polygon with n vertices, preprocessed to support shortest path queries. We can find the shortest path tree from any point inside P in O(log n) time using O(n/log n) processors. In the game bounds, we can preprocess P for shooting queries (a query can be answered in O(log n) time by a uniprocessor). Given a set S of m points inside P, we can find an implicit representation of the relative convex hull of S in O(log(nm)) time with O(m) processors. If the relative convex hull has k edges, we can explicitly produce these edges in O(log(nm)) time with O(k/log(nm)) processors. All of these algorithms are deterministic and use the CREW PRAM model.
TL;DR: The minimum spanning tree of the vertices in the Manhattan metric that is contained in P can be computed within optimal linear time, and the same results hold for the L∞-metric.
Abstract: Let P be a simple planar polygon We present a linear time algorithm for constructing the bounded Voronoi diagram of P in the Manhattan metric, where each point z in P belongs to the region of the closest vertex of P that is visible from z Among other consequences, the minimum spanning tree of the vertices in the Manhattan metric that is contained in P can be computed within optimal linear time The same results hold for the L∞-metricα
TL;DR: This paper presents an optimal parallel algorithm for solving the problem of detecting the weak visibility of an n-vertex simple polygon P and shows that several other problems related to weak visibility can be optimally solved in parallel.
Abstract: The problem of detecting the weak visibility of an n-vertex simple polygon P is that of finding whether P is weakly visible from one of its edges and (if it is) identifying every edge from which P is weakly visible. In this paper, we present an optimal parallel algorithm for solving this problem. Our algorithm runs in O(log n) time using O(n/log n) processors in the CREW PRAM computational model, and is very different from the sequential algorithms for this problem. Based on this algorithm, several other problems related to weak visibility can be optimally solved in parallel.
TL;DR: A data structure is constructed for keeping all guard diagonals in O( n log n) time and O(n) space and it is shown that these problems concerning the diagonal visibility in a polygon P can be solved in O (n log n), O(N log n+k), and O (1) time, respectively.
Abstract: A diagonal guard is a guard capable of moving along an edge or an internal diagonal in a polygon. A polygon which can be guarded by a diagonal guard is called diagonal-visible. We consider the following three problems concerning the diagonal visibility in a polygon P. First, determine whether or not a guard diagonal exists in P, i.e., P is diagonal-visible. Second, compute all guard diagonals of P. Third, given a query diagonal, determine whether or not it is a guard diagonal. For these problems, we construct a data structure for keeping all guard diagonals in O(n log n) time and O(n) space. Using this data structure, we show that these problems can be solved in O(n log n), O(n log n+k), and O(1) time, respectively, where k is the number of guard diagonals.
TL;DR: It is shown that S can be preprocessed in O(n log n) time into a data structure of size O(m) such that a translation order for a query direction can be computed in O (m) time, if it exists, and that this technique can be used to generate displaying orders for polyhedral terrains.
Abstract: Let S be a set of m polygons in the plane with a total of n vertices. A translation order for S in direction is an order on the polygons such that no collisions occur if the polygons are moved one by one to infinity in direction according to this order. We show that S can be preprocessed in O(n log n) time into a data structure of size O(m) such that a translation order for a query direction can be computed in O(m) time, if it exists. It is also possible to test in O(log n) time whether a translation order exists, with a structure that uses O(n) storage. These results are achieved using new results on relative convex hulls and on embeddings with few vertices. Translation orders correspond to valid displaying orders for hidden surface removal with the painter’s algorithm. Our technique can be used to generate displaying orders for polyhedral terrains, for parallel as well as perspective views.
TL;DR: An algorithm for testing the inscribability of a trivalent polyhedron or, equivalently, testing the circumscribability of an simplicial polyhedrons is presented.
Abstract: We present an algorithm for testing the inscribability of a trivalent polyhedron or, equivalently, testing the circumscribability of a simplicial polyhedron. Our algorithm, which runs in linear tim...
TL;DR: A simple sequential algorithm for computing the matrix of longest chain lengths between all pairs of points in S, and the Matrix of “parent” pointers that describes the n longest chain trees is presented.
Abstract: Many problems on sequences and on special kinds of graphs involve the computation of longest chains passing points in the plane. Given a set S of n points in the plane, we consider the problem of computing the matrix of longest chain lengths between all pairs of points in S, and the matrix of “parent” pointers that describes the n longest chain trees. We present a simple sequential algorithm for computing these matrices. Our algorithm runs in O(n2) time, and hence is optimal. We also present a rather involved parallel algorithm that computes these matrices in O((log n)2) time using O(n2/log n) processors in the CREW PRAM model. These matrices enable us to report, in O(1) time, the length of a longest chain between any two points in S by using one processor, and the actual chain by using k processors, where k is the number of points of S on that chain. The space complexity of the algorithms is O(n2).