Showing papers in "International Journal of Computational Geometry and Applications in 1997"
TL;DR: This paper proves a sufficient condition for $\bigcup {\cal D}_{\Bbb X}$ and ${BbbX}$ be homeomorphic.
Abstract: Given a subspace ${\Bbb X} \subseteq {\Bbb R}^d$ and a finite set S⊆ℝd, we introduce the Delaunay complex, ${\cal D}_{\Bbb X}$, restricted by ${\Bbb X}$. Its simplices are spanned by subsets T⊆S for which the common intersection of Voronoi cells meets ${\Bbb X}$ in a non-empty set. By the nerve theorem, $\bigcup {\cal D}_{\Bbb X}$ and ${\Bbb X}$ are homotopy equivalent if all such sets are contractible. This paper proves a sufficient condition for $\bigcup {\cal D}_{\Bbb X}$ and ${\Bbb X}$ be homeomorphic.
176 citations
TL;DR: A linear-time algorithm is presented which, given an n-vertex 3-connected plane G (with n ≥ 3), finds such a straight-line convex embedding of G into a (n - 2) × (n- 2) grid.
Abstract: We consider the problem of embedding the vertices of a plane graph into a small (polynomial size) grid in the plane in such a way that the edges are straight, nonintersecting line segments and faces are convex polygons. We present a linear-time algorithm which, given an n-vertex 3-connected plane G (with n ≥ 3), finds such a straight-line convex embedding of G into a (n - 2) × (n - 2) grid.
156 citations
TL;DR: An O(n log2 n) time algorithm which, given a set V of n points in k-dimensional space (for any fixed k), and any real constant t > 1, produces a t-spanner of the complete Euclidean graph of V, which is similar to the size and weight of spanners constructed by the greedy algorithm.
Abstract: Let G = (V,E) be a n-vertex connected graph with positive edge weights, and let t > 1 be a real constant. A subgraph G' is a t-spanner if for all u,v ∊ V, the weight of the shortest path between u and v in G' is at most t times the weight of the corresponding shortest path in G. We design an O(n log2 n) time algorithm which, given a set V of n points in k-dimensional space (for any fixed k), and any real constant t > 1, produces a t-spanner of the complete Euclidean graph of V. This algorithm retains the spirit of a recent O(n3logn) time greedy algorithm which produces t-spanners; we use graph clustering techniques to achieve a more efficient implementation. Our spanners have O(n) edges and weight O(1)· wt(MST), which is similar to the size and weight of spanners constructed by the greedy algorithm. The constants implicit in the O-notation depend upon t and k.
121 citations
TL;DR: This paper builds in linear time the 4-block tree of a planar graph, which improves previous time bounds and is the first time that the technique of splitting a graph into its 4-connected components is used successfully in graph drawing.
Abstract: In this paper we present a linear time and space algorithm for constructing a visibility representation of a planar graph on an grid, thereby improving the previous bound of (2n-5)×(n-1). To this end we build in linear time the 4-block tree of a planar graph, which improves previous time bounds. Moreover, this is the first time that the technique of splitting a graph into its 4-connected components is used successfully in graph drawing
66 citations
TL;DR: The focus of the paper is the general study of reference points (like the Steiner point) and their properties with respect to shape matching and a very simple algorithm to translate one set so that the Hausdorff distance between the two sets is not larger than a constant factor times the minimum Hausdorf distance.
Abstract: For two given point sets, we present a very simple (almost trivial) algorithm to translate one set so that the Hausdorff distance between the two sets is not larger than a constant factor times the minimum Hausdorff distance which can be achieved in this way. The algorithm just matches the so-called Steiner points of the two sets. The focus of our paper is the general study of reference points (like the Steiner point) and their properties with respect to shape matching. For more general transformations than just translations, our method eliminates several degrees of freedom from the problem and thus yields good matchings with improved time bounds.
61 citations
TL;DR: In this article, it was shown that lights of specified angles not exceeding π can be placed at n fixed points in the plane to illuminate the entire plane if and only if the angles sum to at least 2π.
Abstract: Given three angles summing to 2π, given n points in the plane and a tripartition k1 + k2 + k3 = n, we can tripartition the plane into three wedges of the given angles so that the i-th wedge contains ki of the points. This new result on dissecting point sets is used to prove that lights of specified angles not exceeding π can be placed at n fixed points in the plane to illuminate the entire plane if and only if the angles sum to at least 2π. We give O(nlog n) algorithms for both these problems.
49 citations
TL;DR: Papadimitriou's approximation approach to the Euclidean shortest path (ESP) in 3-space is revisited and a complete treatment in the framework of bit complexity is given.
Abstract: Papadimitriou's approximation approach to the Euclidean shortest path (ESP) in 3-space is revisited. As this problem is NP-hard, his approach represents an important step towards practical algorithms. However, there are several gaps in the original description. Besides giving a complete treatment in the framework of bit complexity, we also improve on his subdivision method. Among the tools needed are root-separation bounds and nontrivial applications of Brent's complexity bounds on evaluation of elementary functions using floating point numbers.
46 citations
TL;DR: A query-sensitive data structure for ray shooting is proposed, which means that the performance of the data structure depends on the local geometry of obstacles near the query segment, and the complexity of theLocal geometry near the segment is measured by a parameter called the simple cover complexity.
Abstract: Ray (segment) shooting is the problem of determining the first intersection between a ray (directed line segment) and a collection of polygonal or polyhedral obstacles. In order to process queries efficiently, the set of obstacle polyhedra is usually preprocessed into a data structure. In this paper we propose a query-sensitive data structure for ray shooting, which means that the performance of our data structure depends on the local geometry of obstacles near the query segment. We measure the complexity of the local geometry near the segment by a parameter called the simple cover complexity, denoted by scc(s) for a segment s. Our data structure consists of a subdivision that partitions the space into a collection of polyhedral cells, each of O(1) complexity. We answer a segment shooting query by wallking along the segment through the subdivision. Our first result is that, for any fixed dimension d, there exists a simple hierarchical subdivision in which no query segment s intersects more than O(scc(s)) cells. Our second result shows that in two dimensions such a subdivision of size O(n) can be constructed in time O(nlogn), where n is the total number of vertices in all the obstacles.
44 citations
TL;DR: It is shown that a hierarchy of space decompositions corresponding to different representation schemes can be used to enhance the theory and to develop a systematic approach to maintenance of geometric representations.
Abstract: The ability to transform between distinct geometric representations is the key to success of multiple-representation modeling systems. But the existing theory of geometric modeling does not directly address or support construction, conversion, and comparison of geometric representations. A study of classical problems of CSG ↔ b-rep conversions, CSG optimization, and other representation conversions suggests a natural relationship between a representation scheme and an appropriate decomposition of space. We show that a hierarchy of space decompositions corresponding to different representation schemes can be used to enhance the theory and to develop a systematic approach to maintenance of geometric representations.
43 citations
TL;DR: This paper investigates arrangements of curves and of surfaces that have a certain sparseness property and shows that this type of arrangements (sparse arrangements) is relevant to the study of the maximum number of topologically different views of a polyhedral terrain.
Abstract: In this paper we study several instances of the problem of determining the maximum number of topologically distinct two-dimensional images that three-dimensional scenes can induce. To bound this number, we investigate arrangements of curves and of surfaces that have a certain sparseness property. Given a collection of n algebraic surface patches of constant maximum degree in 3-space with the property that any vertical line stabs at most k of them, we show that the maximum combinatorial complexity of the entire arrangement that they induce is Θ(n2 k). We extend this result to collections of hypersurfaces in 4-space and to collections of (d > 1)-simplices in d-space, for any fixed d. We show that this type of arrangements (sparse arrangements) is relevant to the study of the maximum number of topologically different views of a polyhedral terrain. For polyhedral terrains with n edges and vertices, we introduce a lower bound construction inducing Ω(n5 α(n)) distinct views, and we present an almost matching upper bound. We then analyze the case of perspective views, point to the potential role of sparse arrangements in obtaining a sharp bound for this case, and present a lower bound construction inducing Ω(n8α(n)) distinct views. For the number of views of a collection of k convex polyhedra with a total of n faces, we show a bound of O(n4 k2) for views from infinity and O(n6 k3) for perspective views. We also present lower bound constructions for such scenes, with Ω(n4 + n2 k4) distinct views from infinity and Ω(n6 + n3 k6) views when the viewpoint can be anywhere in 3-space.
30 citations
TL;DR: This work shows how to pack a non-simple polygon with O(n) tangent circles, so that the union of the polygon boundary components and circles is connected, in total time O( n log n), and extends this to a circle packing in which each portion of thepolygon outside the circles is adjacent to at most four circles or boundary edges.
Abstract: We show how to pack a non-simple polygon with O(n) tangent circles, so that the union of the polygon boundary components and circles is connected, in total time O(n log n). This improves a previous O(n log2 n) bound. By combining this with methods of Bern, Mitchell, and Ruppert we can extend this to a circle packing in which each portion of the polygon outside the circles is adjacent to at most four circles or boundary edges, and as a consequence we can triangulate the polygon with right and acute triangles, using O(n) Steiner points, again in the same O(n log n) time bound.
TL;DR: The heart of the algorithm is the solution to a red-blue dominance reporting problem (the "merge" step) and a novel solution is given which is based on the iterative application of a sequence of non-trivial sweep routines.
Abstract: We consider the problem of reporting the pairwise enclosures in a set of n axes-parallel rectangles in ℝ 2, which is equivalent to reporting dominance pairs in a set of n points in ℝ 4. Over a decade ago, Lee and Preparata7 gave an O(n log n + k)-time and O(n)-space algorithm for these problems, where k is the number of reported pairs. Since that time, the question of whether there is a faster algorithm has remained an intriguing open problem. In this paper, we give an algorithm which uses O(n + k) space and runs in O(n log n log log n + k log log n) time. Thus, although our result is not a strict improvement over the Lee-Preparata algorithm for the full range of k, it is, nevertheless, the first result since Ref. (6) to make any progress on this long-standing open problem. Our algorithm is based on the divide-and-conquer paradigm. The heart of the algorithm is the solution to a red-blue dominance reporting problem (the "merge" step). We give a novel solution for this problem which is based on the iterative application of a sequence of non-trivial sweep routines. This solution technique should be of independent interest. We also present another algorithm whose bounds match the bounds given in Ref. (6), but which is simpler. Finally, we consider the special case where the rectangles have a small number, α, of different aspect ratios, which is often the case in practice. For this problem, we give an algorithm which runs in O(α n log n + k) time and uses O(n) space.
TL;DR: This paper is concerned with the problem of capturing meaningful and useful visibility information inside a simple polygon given only an inaccurate representation of the vertices of the polygon.
Abstract: This paper is concerned with the problem of capturing meaningful and useful visibility information inside a simple polygon given only an inaccurate representation of the vertices of the polygon. We...
TL;DR: Efficient algorithms for contact determination and inference between geometric models in dynamic environments that include polyhedra and surfaces described by algebraic sets or piecewise algebraic functions are presented.
Abstract: The problem of contact determination among multiple objects is fundamental in computer simulated environments and robotics. Most of the earlier work is restricted to either polyhedral models or static environments. In this paper, we present efficient algorithms for contact determination and inference between geometric models in dynamic environments. The set of models include polyhedra and surfaces described by algebraic sets or piecewise algebraic functions. The algorithms make use of temporal and spatial coherence between successive instances and their running time is a function of the motion between successive instances. The main characteristics of these algorithms are their simplicity and efficiency. They have been implemented; their performance on many applications indicates their potential for real-time simulations.
TL;DR: This paper presents two new algorithms for computing optimal rectilinear Steiner minimal trees that are provably better than the best known bounds of any previous algorithm.
Abstract: This paper presents two new algorithms for computing optimal rectilinear Steiner minimal trees. The first algorithm is a simple, easily implemented dynamic programming algorithm that computes an optimal rectilinear Steiner minimal tree on n points in O(n3n) time. The second algorithm improves upon the first using the concept of full-set screening and runs in at most O(n22.62n) time. The analysis of the second algorithm includes a proof that there are at most O(n 1.62n) full sets on n terminals. For instances small enough to practically solve, these time bounds are provably better than the best known bounds of any previous algorithm. Experimental evidence is presented that demonstrates that the algorithms are fast in practice as well. The paper also includes a brief survey of previous algorithms for computing optimal rectilinear Steiner minimal trees.
TL;DR: This paper considers an unanchored n-link robot arm in a square with side length at least as long as the longest arm link to find a necessary and sufficient condition for a point in the square region to be reachable by a specified end of the arm.
Abstract: This paper considers an unanchored n-link robot arm in a square with side length at least as long as the longest arm link. The main result is a necessary and sufficient condition for a point in the square region to be reachable by a specified end of the arm. The condition takes O(n) time to determine. This result represents a continuation of previous work published by Hopcroft, Joseph, and Whitesides, by Kantabutra and Kosaraju, and by Kantabutra.
TL;DR: The criteria that have inspired the preliminary design of GeomLib are presented and the guidelines that have followed in the initial implementation of the project are discussed.
Abstract: The goal of this paper is to prove the applicability of some advanced software design concepts to geometric computing through a vertical case study. The work is presented within the framework of the GeomLib project, aimed at developing an easy to use, reliable, open library of robust and efficient geometric algorithms. We present the criteria that have inspired the preliminary design of GeomLib and discuss the guidelines that we have followed in the initial implementation.
TL;DR: It is shown that every faithful rational quadratic parameterization of a quadric can be generated by a stereographic projection from a point on the quadric, called the center of projection (COP).
Abstract: Every irreducible quadric in E3 has infinitely many different rational quadratic parameterizations. These parameterizations and the relationships between them are investigated. It is shown that every faithful rational quadratic parameterization of a quadric can be generated by a stereographic projection from a point on the quadric, called the center of projection (COP). Two such parameterizations for the same quadric are related by a rational linear reparameterization if they have the same COP; otherwise they are related by a rational quadratic reparameterization. We also consider unfaithful parameterizations for which, in general, a one-to-one correspondence between points on the surface and parameters in the plane does not exist. It is shown that all unfaithful rational quadratic parameterizations of a properly degenerate quadric can be characterized by a simple canonical form, and there exist no unfaithful rational quadratic parameterizations for a nondegenerate quadric. In addition, given a faithful rational quadratic parameterization of a quadric, a new technique is presented to compute its base points and inversion formula. These results are applied to solve the problems of parameterizing the intersection of two quadrics and reparameterizing a given quadric parameterization with respect to a different COP without implicitization.
TL;DR: It is shown that shortest-path queries can be performed optimally in time O(logh + logn) (plus O(k) time for reporting the k edges of the path) using a data structure with O(n) space and preprocessing time, and that minimum-link- path queries can also be performed in optimal time.
Abstract: We present efficient algorithms for shortest-path and minimum-link-path queries between two convex polygons inside a simple polygon P, which acts as an obstacle to be avoided. Let n be the number of vertices of P, and h the total number of vertices of the query polygons. We show that shortest-path queries can be performed optimally in time O(logh + logn) (plus O(k) time for reporting the k edges of the path) using a data structure with O(n) space and preprocessing time, and that minimum-link-path queries can be performed in optimal time O(logh + logn) (plus O(k) to report the k links), with O(n3) space and preprocessing time. We also extend our results to the dynamic case, and give a unified data structure that supports both queries for convex polygons in the same region of a connected planar subdivision . The update operations consist of insertions and deletions of edges and vertices. Let n be the current number of vertices in . The data structure uses O(n) space, supports updates in O(log2 n) time, and performs shortest-path and minimum-link-path queries in times O(log h+ log2n) (plus O(k) to report the k edges of the path) and O(log h + k log2 n), respectively. Performing shortest-path queries is a variation of the well-studied separation problem, which has not been efficiently solved before in the presence of obstacles. Also, it was not previously known how to perform minimum-link-path queries in a dynamic environment, even for two-point queries.
TL;DR: This work gives an explicit lower bound γopt on the maximum angle in any covering triangulation of a particular input graph in terms of its local geometry, and shows that this result represents the first nontrivial bound on a coveringTriangulation's maximum angle.
Abstract: We consider the following problem: given a planar straight-line graph, find a covering triangulation whose maximum angle is as small as possible. A covering triangulation is a triangulation whose vertex set contains the input vertex set and whose edge set contains the input edge set. The covering triangulation problem differs from the usual Steiner triangulation problem in that we may not add a vertex on any input edge. Covering triangulations provide a convenient method for triangulating multiple regions sharing a common boundary, as each region can be triangulated independently. We give an explicit lower bound γopt on the maximum angle in any covering triangulation of a particular input graph in terms of its local geometry. Our algorithm produces a covering triangulation whose maximum angle γ is provably close to γopt. Specifically, we show that , i.e., our γ is not much closer to π than is γopt. To our knowledge, this result represents the first nontrivial bound on a covering triangulation's maximum angle. Our algorithm adds O(n) Steiner points and runs in time O(n log n), where n is the number of vertices of the input. We have implemented an O(n2) time version of our algorithm.
TL;DR: This paper shows how to solve the problem of computing a ray R emanating from the origin such that minp ∈ s w(p) · d(p,R) is maximal, and gives algorithms that are based on the parametric search technique and run in O(n log4 n) time.
Abstract: Let S be a set of n points in ℝd, and let each point p of S have a positive weight w(p). We consider the problem of computing a ray R emanating from the origin (resp. a line l through the origin) such that minp ∈ s w(p) · d(p,R) (resp. minp ∈ S w(p) · d(p,l)) is maximal. If all weights are one, this corresponds to computing a silo emanating from the origin (resp. a cylinder whose axis contains the origin) that does not contain any point of S and whose radius is maximal. For d = 2, we show how to solve these problems in O(n log n) time, which is optimal in the algebraic computation tree model. For d = 3, we give algorithms that are based on the parametric search technique and run in O(n log4 n) time. The previous best known algorithms for these three-dimensional problems had almost quadratic running time. In the final part of the paper, we consider some related problems.
TL;DR: An algorithm is presented to transform any problem instance in the two-layer model to one in a one- layer model, so that almost all algorithms for finding rectilinear paths among obstacles in the plane can be applied.
Abstract: Finding the best rectilinear path with respect to the bends and teh lengths of paths connecting two given points in the presence of rectilinear obstacles in a two-layer model is studied in this paper. In this model, rectilinear obstacles on each layer are specified separately, and the orientation of routing in each layer is fixed. An algorithm is presented to transform any problem instance in the two-layer model to one in a one-layer model, so that almost all algorithms for finding rectilinear paths among obstacles in the plane can be applied. The transformation algorithm runs in O(e log e) time where e is the number of edges on obstacles lying on both layers. A direct graph-theoretic approach to finding a shortest path in the two-layer model, which is easier to implement is also presented. The algorithm runs in O(e log2 e) time.
TL;DR: This algorithm is significantly faster than the brute force O(n7) time solution for computing the optimal approximate axis-parallel box A* of P such that the symmetric difference of the volume between P and A* is minimized.
Abstract: In this paper, we present an O(n4log2n) time algorithm to compute an approximate discrete axis-parallel box of a given n-vertex convex polyhedron P such that the given polyhedron is minimized. Here, "discrete" means that each plane containing a face of the approximate box passes through a vertex of P (or, more generally, passes through a point of a set of given points). This algorithm is significantly faster than the brute force O(n7) time solution for computing the optimal approximate axis-parallel box A* of P such that the symmetric difference of the volume between P and A* is minimized. We present a linear time algorithm to compute a pseudo-optimal (with factor approximate axis-parallel box of a convex polyhedron under the Hausdorff distance criterion. We also present O(n) and O(n7logn) time algorithms to compute the optimal approximate ball, with or without a fixed center, of a convex polyhedron under the Hausdorff distance criterion.
TL;DR: A parallel algorithm that is based on the work mentioned above, and achieves O(log2n) time complexity, with work complexity O((k + nα(n))logn) in a CREW PRAM model, improves on previous parallel complexity while maintaining work efficiency with respect to the best sequential complexity known.
Abstract: The best known output-sensitive sequential algorithm for computing the viewshed on a polyhedral terrain from a given viewpoint was proposed by Katz, Overmars, and Sharir,10 and achieves time complexity O((k + nα(n))logn) where n and k are the input and output sizes respectively, and α() is the inverse Ackermann's function. In this paper, we present a parallel algorithm that is based on the work mentioned above, and achieves O(log2n) time complexity, with work complexity O((k + nα(n))logn) in a CREW PRAM model. This improves on previous parallel complexity while maintaining work efficiency with respect to the best sequential complexity known.
TL;DR: The problem ofFinding the simplest cable configuration for a given set of target points is shown to reduce to the problem of finding a minimal set of nonintersecting routes in a Euclidean graph whose nodes are the robots' cable line.
Abstract: The following problem appears in robotics. A number of small, circular robots live in a common planar workspace. Each is attached by a flexible cable of finite length to a point on the boundary of this workspace. Each robot has a target point in the workspace it must reach. When a robot has reached its target, its cable will have been dragged out into the workspace and possibly pushed and bent by other robots. The cables remain taut at all times and may not overlap, but may bend around other robots. When only the target points are specified for the robots, their motion can produce arbitrarily complex cable configurations. The more complex a cable configuration is, the more restrictive it is to the motion of the robots. To keep restrictions on the robots' motions at a minimum, it is necessary to specify, in addition to the target points, a configuration of the cables that is as simple as possible but allows all robots to reach their targets. The problem of finding the simplest cable configuration for a given set of target points is shown to reduce to the problem of finding a minimal set of nonintersecting routes in a Euclidean graph whose nodes are the robots' cable line. That no set of edges can intersect any other set of edges is an unusual characteristic of this graph problem. This consideration leads to interesting geometric analysis used to determine which relative placements of the graph edges represent overlapping cable lines. An algorithm is suggested that uses an exhaustive search method with pruning to find a set of nonintersecting routes in the graph that is minimal according to a chosen criterion. The algorithm has been implemented and tested; examples of its performance are given.
TL;DR: An efficient algorithm is presented which finds "non-crossing" rectilinear paths in the plane region A, each connecting a terminal pair without passing through any obstacles, and whose total length is minimum.
Abstract: Let A be a plane region inside an outer rectangle with r rectangular obstacles, and let k terminal pairs lie on the boundaries of the outer rectangle and one of the obstacles. This paper presents an efficient algorithm which finds "non-crossing" rectilinear paths in the plane region A, each connecting a terminal pair without passing through any obstacles, and whose total length is minimum. Non-crossing paths may share common points or line segments but do not cross each other in the plane. The algorithm takes time O(n log n) where n = k + r.
TL;DR: Given a simply connected orthogonal polygon P, a polynomial time algorithm is presented to cover the polygon with the minimum number of rectangles, under the restriction that if A and B are two overlapping rectangles in the cover then either A - B or B - A is connected.
Abstract: Given a simply connected orthogonal polygon P, a polynomial time algorithm is presented to cover the polygon with the minimum number of rectangles, under the restriction that if A and B are two overlapping rectangles in the cover then either A - B or B - A is connected. The algorithm runs in O(n log n + nm) time, where n is the number of vertices of P and m is the number of edges in the visibility graph of P that are either horizontal, vertical or form the diagonal of an empty rectangle.
Journal Article•
TL;DR: In this article, given a cycle of length k on a triangulated 2-manifold, they determine if it is null-homologous (bounds a surface) in O(n+k) optimal time and space where n is the size of the triangulation.
Abstract: Given a cycle of length k on a triangulated 2-manifold, we determine if it is null-homologous (bounds a surface) in O(n+k) optimal time and space where n is the size of the triangulation. Further, with a preprocessing step of O(n) time we answer the same query for any cycle of length k in O(g+k) time, g the genus of the 2-manifold. This is optimal for k < g.
TL;DR: Several topics related to packing on a sphere are discussed: packing points, packing lines through the center, and packing k-flats in dimension d.
Abstract: Several topics related to packing on a sphere are discussed: packing points, packing lines through the center, and packing k-flats in dimension d.
TL;DR: Given a cycle of length k on a triangulated 2-manifold, it is determined if it is null-homologous (bounds a surface) in O(n+k) optimal time and space where n is the size of the triangulation.
Abstract: Given a cycle of length k on a triangulated 2-manifold, we determine if it is null-homologous (bounds a surface) in O(n+k) optimal time and space where n is the size of the triangulation. Further, with a preprocessing step of O(n) time we answer the same query for any cycle of length k in O(g+k) time, g the genus of the 2-manifold. This is optimal for k < g.