Optimal piecewise linear motion of an object among obstacles

We present an algorithm for determining the shortest restricted path motion of a polygonal object amidst polygonal obstacles. The class of motions which are allowed can be described as follows: a designated vertex,P, of the polygonal object traverses a piecewise linear path, whose breakpoints are restricted to the vertices of the obstacles. The distance measure being minimized is the length of the path traversed byP. Our algorithm runs in timeO(n ⁴kogn). We also discuss a variation of this algorithm which minimizes any positive linear combination of length traversed byP and angular rotation of the ladder aboutP. This variation requiresO(n ₅) time.     

A new algorithm for shortest paths among obstacles in the plane

We introduce a new algorithm for computing Euclidean shortest paths in the plane in the presence of polygonal obstacles. In particular, for a given start points, we build a planar subdivision (ashortest path map) that supports efficient queries for shortest paths froms to any destination pointt. The worst-case time complexity of our algorithm isO(kn log² n), wheren is the number of vertices describing the polygonal obstacles, andk is a parameter we call the illumination depth of the obstacle space. Our algorithm usesO(n) space, avoiding the possibly quadratic space complexity of methods that rely on visibility graphs. The quantityk is frequently significantly smaller thann, especially in some of the cases in which the visibility graph has quadratic size. In particular,k is bounded above by the number of different obstacles that touch any shortest path froms.Partially supported by NSF Grants IRI-8710858 and ECSE-8857642 and by a grant from Hughes Research Laboratories, Malibu, CA.     

L1 shortest paths among polygonal obstacles in the plane

We present an algorithm for computingL ₁ shortest paths among polygonal obstacles in the plane. Our algorithm employs the continuous Dijkstra technique of propagating a wavefront and runs in timeO(E logn) and spaceO(E), wheren is the number of vertices of the obstacles andE is the number of events. By using bounds on the density of certain sparse binary matrices, we show thatE =O(n logn), implying that our algorithm is nearly optimal. We conjecture thatE =O(n), which would imply our algorithm to be optimal. Previous bounds for our problem were quadratic in time and space.Our algorithm generalizes to the case of fixed orientation metrics, yielding anO(n^–1/2 log² n) time andO(n^–1/2) space approximation algorithm for finding Euclidean shortest paths among obstacles. The algorithm further generalizes to the case of many sources, allowing us to compute anL ₁ Voronoi diagram for source points that lie among a collection of polygonal obstacles.Partially supported by a grant from Hughes Research Laboratories, Malibu, California and by NSF Grant ECSE-8857642. Much of this work was done while the author was a Ph.D. student at Stanford University, under the support of a Howard Hughes Doctoral Fellowship, and an employee of Hughes Research Laboratories.     

Minimum-link paths among obstacles in the plane

Given a set of nonintersecting polygonal obstacles in the plane, thelink distance between two pointss andt is the minimum number of edges required to form a polygonal path connectings tot that avoids all obstacles. We present an algorithm that computes the link distance (and a corresponding minimum-link path) between two points in timeO(E(n) log² n) (and spaceO(E)), wheren is the total number of edges of the obstacles,E is the size of the visibility graph, and (n) denotes the extremely slowly growing inverse of Ackermann's function. We show how to extend our method to allow computation of a tree (rooted ats) of minimum-link paths froms to all obstacle vertices. This leads to a method of solving the query version of our problem (for query pointst).Joseph Mitchell was partially supported by NSF Grants IRI-8710858 and ECSE-8857642, and by a grant from Hughes Research Laboratories. This work was begun while Günter Rote and Gerhard Woeginger were at the Freie Universität Berlin, Fachbereich Mathematik, Institut für Informatik, and it was partially supported by the ESPRIT II Basic Research Actions Program of the EC under Contract No. 3075 (project ALCOM). Gerhard Woeginger acknowledges the support by the Fonds zur Förderung der Wissenschaftlichen Forschung, Projekt S32/01.     

A parallel algorithm for surface-based object reconstruction

This paper presents a parallel algorithm that approximates the surface of an object from a collection of its planar contours. Such a reconstruction has wide applications in such diverse fields as biological research, medical diagnosis and therapy, architecture, automobile and ship design, and solid modeling. The surface reconstruction problem is transformed into the problem of finding a minimum-cost acceptable path on a toroidal grid graph, where each horizontal and each vertical edge have the same orientation. An acceptable path is closed path that makes a complete horizontal and vertical circuit. We exploit the structure of this graph to develop efficient parallel algorithms for a message-passing computer. Givenp processors and anm byn toroidal graph, our algorithm will find the minimum cost acceptable path inO(mn log(m)/p) steps, ifp =O(mn/((m + n) log(mn/(m + n)))), which is an optimal speedup. We also show that the algorithm will sendO(p ²(m + n)) messages. The algorithm has a linear topology, so it is easy to embed the algorithm in common multiprocessor architectures.     

L 1 shortest paths among polygonal obstacles in the plane

We present an algorithm for computingL ₁ shortest paths among polygonal obstacles in the plane. Our algorithm employs the “continuous Dijkstra” technique of propagating a “wavefront” and runs in timeO(E logn) and spaceO(E), wheren is the number of vertices of the obstacles andE is the number of “events.” By using bounds on the density of certain sparse binary matrices, we show thatE =O(n logn), implying that our algorithm is nearly optimal. We conjecture thatE =O(n), which would imply our algorithm to be optimal. Previous bounds for our problem were quadratic in time and space. Our algorithm generalizes to the case of fixed orientation metrics, yielding anO(n?^?1/2 log² n) time andO(n?^?1/2) space approximation algorithm for finding Euclidean shortest paths among obstacles. The algorithm further generalizes to the case of many sources, allowing us to compute anL ₁ Voronoi diagram for source points that lie among a collection of polygonal obstacles.     

Planning Robot Navigation among Movable Obstacles (NAMO) through a Recursive Approach

This paper addresses the NP-complete problem of Navigation Among Movable Obstacles (NAMO) in which a robot is required to find a collision-free path toward a goal through manipulating and transferring some movable objects on its way. The robot’s main goal is to optimize a performance criterion such as runtime, length of transit or transfer paths, number of manipulated obstacles, total number of displacements of all objects, etc. We have designed a recursive algorithm capable of solving various NAMO problems, ranging from linear monotone to nonlinear non-monotone, and with convex or concave polygonal obstacles. Through the adopted approach, the original problem is decomposed into recursively-solved subproblems, in each of which only one movable object is manipulated. In each call of the algorithm, first a Visibility Graph determines a path from the robot’s current configuration to an intermediate goal configuration, and then a tentative final configuration for the last object intercepting the path is calculated using the Penetration Depth concept. It is assumed that the objects can be pulled or pushed, but not rotated, in a continuous space, and under such assumptions the method is complete and locally optimal for convex objects, with a worst-case time complexity of O(n⁴3^m) in which m is the number of movable objects and n is the number of all vertices on them. Several computational experiments showed that compared to the existing methods in the literature, the proposed recursive method achieved equal or smaller number of transferred obstacles or the total number of displacements of all objects in majority of the test problems.     

Using spine decompositions to efficiently solve the length-constrained heaviest path problem for trees

The length-constrained heaviest path (LCHP) in a weighted tree T, where each edge is assigned a weight and a length, is the path P in T with maximum total path weight and total path length bounded by a given value B. This paper presents an O(nlogn) time LCHP algorithm which utilizes a data structure constructed from the spine decomposition of the input tree. This is an improvement over the existing algorithm by Wu et al. (1999), which runs in O(nlog²n) time. Our method also improves on a previous O(nlogn) time algorithm by Kim (2005) for the special case of finding a longest nonnegative path in a constant degree tree in that we can handle trees of arbitrary degree within the same time bounds.     

Efficient construction of a bounded-degree spanner with low weight

LetS be a set ofn points in ℝ ^d and lett>1 be a real number. At-spanner forS is a graph having the points ofS as its vertices such that for any pairp, q of points there is a path between them of length at mostt times the Euclidean distance betweenp andq. An efficient implementation of a greedy algorithm is given that constructs at-spanner having bounded degree such that the total length of all its edges is bounded byO (logn) times the length of a minimum spanning tree forS. The algorithm has running timeO (n log ^d n). Applying recent results of Das, Narasimhan, and Salowe to thist-spanner gives anO(n log ^d n)-time algorithm for constructing at-spanner having bounded degree and whose total edge length is proportional to the length of a minimum spanning tree forS. Previously, noo(n ²)-time algorithms were known for constructing at-spanner of bounded degree. In the final part of the paper, an application to the problem of distance enumeration is given. This work was supported by the ESPRIT Basic Research Actions Program, under Contract No. 7141 (Project ALCOM II).     

Minimum-link paths among obstacles in the plane

Given a set of nonintersecting polygonal obstacles in the plane, thelink distance between two pointss andt is the minimum number of edges required to form a polygonal path connectings tot that avoids all obstacles. We present an algorithm that computes the link distance (and a corresponding minimum-link path) between two points in timeO(Eα(n) log² n) (and spaceO(E)), wheren is the total number of edges of the obstacles,E is the size of the visibility graph, and α(n) denotes the extremely slowly growing inverse of Ackermann's function. We show how to extend our method to allow computation of a tree (rooted ats) of minimum-link paths froms to all obstacle vertices. This leads to a method of solving the query version of our problem (for query pointst).     

On-line motion planning: Case of a planar rod

In this paper we develop an algorithm for planning the motion of a planar rod (a line segment) amidst obstacles bounded by simple, closed polygons. The exact shape, number and location of the obstacles are assumed unknown to the planning algorithm, which can only obtain information about the obstacles by detecting points of contact with the obstacles. The ability to detect contact with obstacles is formalized by move primitives that we callguarded moves. We call ours theon-line motion planning problem as opposed to the usualoff-line version. This is a significant departure from the usual setting for motion planning problems. What we demonstrate is that the retraction method can be applied, although new issues arise that have no counterparts in the usual setting. We are able to obtain an algorithm with path complexityO(n ²) guarded moves, wheren is the number of obstacle corners. This matches the known lower bound. The computational complexityO(n ²logn) of our algorithm matches the best known algorithm for the off-line version.This work is supported by NSF grants #DCR-84-01633, #DCR-84-01898 and PSC-CUNY 669287.     

Optimal Mesh Algorithms for the Voronoi Diagram of Line Segments and Motion Planning in the Plane

The motion planning problem of an object with two degrees of freedom moving in the plane can be stated as follows: Given a set of polygonal obstacles in the plane, and a two-dimensional mobile object B with two degrees of freedom, determine if it is possible to move B from a start position to a final position while avoiding the obstacles. If so, plan a path for such a motion. Techniques from computational geometry have been used to develop exact algorithms for this fundamental case of motion planning. In this paper we obtain optimal mesh implementations of two different methods for planning motion in the plane. We do this by first presenting optimal mesh algorithms for some geometric problems that, in addition to being important substeps in motion planning, have numerous independent applications in computational geometry. In particular, we first show that the Voronoi diagram of a set of n nonintersecting (except possibly at endpoints) line segments in the plane can be constructed in O(√ n) time on a √ n × √ n mesh, which is optimal for the mesh. Consequently, we obtain an optimal mesh implementation of the sequential motion planning algorithm described by Ó′Dúlainy and Yap (J. Algorithms 6 (1985), 104-111); in other words, given a disc B and a polygonal obstacle set of size n, we can plan a path (if it exists) for the motion of B from a start position to a final position in O(√ n) time on a mesh of size n. We also show that the shortest path motion between a start position and a final position for a convex object B (of constant size) moving among convex polygonal obstacles of total size n can be found in O(n) time on an n × n mesh, which is worst-case optimal.     

Motion planning in the presence of movable obstacles

Most motion planning algorithms have dealt with motion in a static workspace, or more recently, with motion in a workspace that changes in a known manner. We consider the problem of finding collision-free motions in a changeable workspace. That is, we wish to find a motion for an object where the object is permitted to move some of the obstacles. In such a workspace, the final positions of the movable obstacles may or may not be part of the goal. In the case where the final positions of the obstacles are specified, the general problem is shown to be PSPACE-hard. In the case where the final positions of the obstacles are unspecified, the motion planning problem is shown to be NP-hard. Algorithms that run inO(n ³) time are presented for the case where there is only one movable obstacle in a polygonal environment withn corners and the object to be moved and the obstacle are convex polygons of constant complexity.     

Algorithms for computing diffuse reflection paths in polygons

Let s be a point source of light inside a polygon P of n vertices. A polygonal path from s to some point t inside P is called a diffuse reflection path if the turning points of the path lie on edges of?P. A?diffuse reflection path is said to be optimal if it has the minimum number of reflections on the path. The problem of computing a diffuse reflection path from s to t inside P has not been considered explicitly in the past. We present three different algorithms for this problem which produce suboptimal paths. For constructing such a path, the first algorithm uses a greedy method, the second algorithm uses a transformation of a minimum link path, and the third algorithm uses the edge–edge visibility graph of?P. The first two algorithms are for polygons without holes, and they run in O(n+klogn) time, where k denotes the number of reflections in the constructed path. The third algorithm is for polygons with or without holes, and it runs in O(n ²) time. The number of reflections in the path produced by this third algorithm can be at most three times that of an optimal diffuse reflection path. Though the combinatorial approach used in the third algorithm gives a better bound on the number of reflections on the path, the first and the second algorithms stand on the merit of their elegant geometric approaches based on local geometric information.     

An Almost Quadratic Time Algorithm for Sparse Spliced Alignment

The sparse spliced alignment problem consists of finding a chain of zero or more exons from O(n) prescribed candidate exons of a DNA sequence of length O(n) that is most similar to a known related gene sequence of length n. This study improves the running time of the fastest known algorithm for this problem to date, which executes in O(n ^2.25) time, or very recently, in O(n ²log ² n) time, by proposing an O(n ²log n)-time algorithm.     

A new efficient motion-planning algorithm for a rod in two-dimensional polygonal space

We present here a new and efficient algorithm for planning collision-free motion of a line segment (a rod or a ladder) in two-dimensional space amidst polygonal obstacles. The algorithm uses a different approach than those used in previous motion-planning techniques, namely, it calculates the boundary of the (three-dimensional) space of free positions of the ladder, and then uses this boundary for determining the existence of required motions, and plans such motions whenever possible. The algorithm runs in timeO(K logn) =O(n ² logn) wheren is the number of obstacle corners and whereK is the total number of pairs of obstacle walls or corners of distance less than or equal to the length of the ladder. The algorithm has thus the same complexity as the best previously known algorithm of Leven and Sharir [5], but if the obstacles are not too cluttered together it will run much more efficiently. The algorithm also serves as an initial demonstration of the viability of the technique it uses, which we expect to be useful in obtaining efficient motion-planning algorithms for other more complex robot systems.Work on this paper has been supported in part by a grant from the Joint Ramot-Israeli Ministry of Industry Foundation.     

A new efficient motion-planning algorithm for a rod in two-dimensional polygonal space

We present here a new and efficient algorithm for planning collision-free motion of a line segment (a rod or a “ladder”) in two-dimensional space amidst polygonal obstacles. The algorithm uses a different approach than those used in previous motion-planning techniques, namely, it calculates the boundary of the (three-dimensional) space of free positions of the ladder, and then uses this boundary for determining the existence of required motions, and plans such motions whenever possible. The algorithm runs in timeO(K logn) =O(n ² logn) wheren is the number of obstacle corners and whereK is the total number of pairs of obstacle walls or corners of distance less than or equal to the length of the ladder. The algorithm has thus the same complexity as the best previously known algorithm of Leven and Sharir [5], but if the obstacles are not too cluttered together it will run much more efficiently. The algorithm also serves as an initial demonstration of the viability of the technique it uses, which we expect to be useful in obtaining efficient motion-planning algorithms for other more complex robot systems.     

Finding an Euclidean anti--centrum location of a set of points

An obnoxious facility is to be located inside a polygonal region of the plane, maximizing the sum of the k smallest weighted Euclidean distances to n given points, each protected by some polygonal forbidden region. For the unweighted case and k fixed an O(n²logn) time algorithm is presented. For the weighted case a thorough study of the relevant structure of the multiplicatively weighted order-k-Voronoi diagram leads to the design of an O(kn³+n³logn) time algorithm for finding an optimal solution to the anti-t-centrum problem for every t=1,…,k, simultaneously.     

Clamshell Casting

A popular manufacturing technique is clamshell casting, where liquid is poured into a cast and the cast is removed by a rotation once the liquid has hardened. We consider the case where the object to be manufactured is modeled by a polyhedron with combinatorial complexity n of arbitrary genus. The cast consists of exactly two parts and is removed by a rotation around a line in space. The following two problems are addressed: (1) Given a line of rotation l in space, we determine in O(nlog n) time whether there exists a partitioning of the cast into exactly two parts, such that one part can be rotated clockwise around l and the other part can be rotated counterclockwise around l without colliding with the interior of P or the cast. If the problem is restricted further, such a partitioning is only valid when no reflex edge or face of P is perpendicular to l, the algorithm runs in O(n) time. (2) An algorithm running in O(n ⁴log n) time is presented to find all the lines in space that allow a cast partitioning as described above. If we restrict the problem further and find all the lines in space that allow a cast partitioning as described above, such that no reflex edge or face of P is perpendicular to l, the algorithm’s running time becomes O(n ⁴ α(n)). All of the running times are shown to be almost optimal.     

Coordinated motion planning for two independent robots

We present anO(n ²) algorithm for planning a coordinated collision-free motion of two independent robot systems of certain kinds, each having two degrees of freedom, which move in the plane amidst polygonal obstacles having a total ofn corners. We exemplify our technique in the case of two planar Stanford arms, but also discuss the case of two discs or convex translating objects. The algorithm improves previous algorithms for this kind of problems, and can be extended to a fairly simple general technique for obtaining efficient coordinated motion planning algorithms.