Rectilinear Obstacles Research Articles

Minimum-link shortest paths for polygons amidst rectilinear obstacles

We compute shortest paths connecting two axis-aligned rectilinear simple polygons in the domain consisting of axis-aligned rectilinear obstacles in the plane. The bounding boxes, one defined for each polygon and one defined for each obstacle, are disjoint. We present an algorithm that computes a minimum-link rectilinear shortest path connecting the two polygons and avoiding the obstacles in O(nlog⁡n) time using O(n) space, where n is the total number of vertices of two polygons and obstacles in the domain.

An Efficient Obstacle-Avoiding Rectilinear Steiner Tree Construction Method Using PB-SAT

ABSTRACT Rectilinear Steiner tree (RST) construction is an important part of recent VLSI physical design. This article presents an efficient satisfiability (SAT) based approach to construct an obstacle-avoiding Rectilinear Steiner tree for a given set of pins in the presence of a given set of rectilinear obstacles. Initially, a spanning tree is generated without considering the obstacles and the net is decomposed into 2-pin sub-nets. Then, the RST is constructed for each subnet considering obstacles. RST is generated by applying a Pseudo-Boolean (PB) SAT-based technique. The proposed technique has been verified on several benchmark circuits. The results indicate that the proposed technique is able to produce a shorter wire length than other state-of-the-art RST tools in many cases.

Shortest paths among transient obstacles

We present an optimal algorithm for determining a time-minimal rectilinear path among transient rectilinear obstacles. An obstacle is transient if it exists only for a specific time interval, i.e., it appears and then disappears at specific times. Given a point robot moving with bounded speed among non-intersecting transient rectilinear obstacles and a pair of points (s, d), we determine a time-minimal, obstacle-avoiding path from s to d. Our algorithm runs in $$\varTheta (n \log n)$$ time, where n is the total number of vertices in the obstacle polygons. The main challenge in solving this problem arises when the robot may be required to wait for an obstacle to disappear, before it can continue moving towards its destination. Our algorithm builds on the continuous Dijkstra paradigm, which simulates propagating a wavefront from the source point. We also present an $$O(n^2 \log n)$$ time algorithm for computing the Euclidean shortest path map among transient polygonal obstacles in the plane. This decreases the time complexity of the existing algorithm (Fujimura, in: Proceedings 1992 IEEE international conference on robotics and automation, vol 2, pp 1488–1493, 1992. https://doi.org/10.1109/ROBOT.1992.220041 ) by a factor of n. The shortest path map can be preprocessed for point location, after which a shortest path query from s to any point d can be answered in time $$O(\log n + k)$$ where, k is the number of edges in the path.

Computing Skeletons for Rectilinearly Convex Obstacles in the Rectilinear Plane

We introduce the concept of an obstacle skeleton, which is a set of line segments inside a polygonal obstacle $$\omega $$ that can be used in place of $$\omega $$ when performing intersection tests for obstacle-avoiding network problems in the plane. A skeleton can have significantly fewer line segments compared to the number of line segments in the boundary of the original obstacle, and therefore performing intersection tests on a skeleton (rather than the original obstacle) can significantly reduce the CPU time required by algorithms for computing solutions to obstacle-avoidance problems. A minimum skeleton is a skeleton with the smallest possible number of line segments. We provide an exact $$O(n^2)$$ algorithm for computing minimum skeletons for rectilinear obstacles in the rectilinear plane that are rectilinearly convex.

Bicriteria Rectilinear Shortest Paths Among Rectilinear Obstacles in the Plane

Given a rectilinear domain \(\mathcal {P}\) of h pairwise-disjoint rectilinear obstacles with a total of n vertices in the plane, we study the problem of computing bicriteria rectilinear shortest paths between two points s and t in \(\mathcal {P}\). Three types of bicriteria rectilinear paths are considered: minimum-link shortest paths, shortest minimum-link paths, and minimum-cost paths where the cost of a path is a non-decreasing function of both the number of edges and the length of the path. The one-point and two-point path queries are also considered. Algorithms for these problems have been given previously. Our contributions are threefold. First, we find a critical error in all previous algorithms. Second, we correct the error in a not-so-trivial way. Third, we further improve the algorithms so that they are even faster than the previous (incorrect) algorithms when h is relatively small. For example, for the minimum-link shortest paths, we obtain the following results. Our algorithm computes a minimum-link shortest \(s\)-\(t\) path in \(O(n+h\log ^{3/2} h)\) time. For the one-point queries, we build a data structure of size \(O(n+ h\log h)\) in \(O(n+h\log ^{3/2} h)\) time for a source point s, such that given any query point t, a minimum-link shortest \(s\)-\(t\) path can be computed in \(O(\log n)\) time. For the two-point queries, with \(O(n+h^2\log ^2 h)\) time and space preprocessing, a minimum-link shortest \(s\)-\(t\) path can be computed in \(O(\log n+\log ^2 h)\) time for any two query points s and t; alternatively, with \(O(n+h^2\cdot \log ^{2} h \cdot 4^{\sqrt{\log h}})\) time and \(O(n+h^2\cdot \log h \cdot 4^{\sqrt{\log h}})\) space preprocessing, we can answer each two-point query in \(O(\log n)\) time. Note that \(h^2\cdot \log ^{2} h \cdot 4^{\sqrt{\log h}}=O(h^{2+\epsilon })\) for any \(\epsilon >0\). These results are particularly interesting when h is relatively small. For example, if \(h=O(n^{1/2-\epsilon })\) for any \(\epsilon >0\), then all above results match the best results for the problems in simple rectilinear polygons, which are optimal. The complexities for the other two types of paths are slightly worse, but still linearly depend on n (in addition to g(h) for some functions g(h) of h).

Non-crossing Rectilinear Shortest Minimum Bend Paths in the Presence of Rectilinear Obstacles

The paper presents a new algorithm to determine the shortest, non-crossing, rectilinear paths in a twodimensional grid graph. The shortest paths are determined in a manner ensuring that they do not cross each other and bypass any obstacles present. Such shortest paths are applied in robotic chip design, suburban railway track layouts, routing traffic in wireless sensor networks, printed circuit board design routing, etc. When more than one equal length noncrossing path is present between the source and the destination, the proposed algorithm selects the path which has the least number of corners (bends) along the path. This feature makes the path more suitable for moving objects, such as unmanned vehicles. In the author’s scheme presented herein, the grid points are the vertices of the graph and the lines joining the grid points are the edges of the graph. The obstacles are represented by their boundary grid points. Once the graph is ready, an adjacency matrix is generated and the Floyd-Warshall all-pairs shortest path algorithm is used iteratively to identify the non-crossing shortest paths. To get the minimum number of bends in a path, we make a modification to the Floyd-Warshall algorithm, which is constitutes the main contribution of the author presented herein.

An Optimal Algorithm for Minimum-Link Rectilinear Paths in Triangulated Rectilinear Domains

We present a new algorithm for finding minimum-link rectilinear paths among h rectilinear obstacles with a total of n vertices in the plane. After the plane is triangulated, for any point s, our algorithm builds an O(n)-size data structure in \(O(n+h\log h)\) time, such that given any query point t, we can compute a minimum-link rectilinear path from s to t in \(O(\log n+k)\) time, where k is the number of edges of the path, and the query time is \(O(\log n)\) if we only want to know the value k. The previously best algorithm solves the problem in \(O(n\log n)\) time.

On Time-Optimal Trajectories in Non-Uniform Mediums

This paper addresses the problem of finding time-optimal trajectories in two-dimensional space, where the mover's speed monotonically decreases or increases in one of the space's coordinates. We address such problems in different settings for the velocity function and in the presence of obstacles. First, we consider the problem without any obstacles. We show that the problem with linear speed decrease is reducible to the de l'Hopital's problem, and that, for this case, the time-optimal trajectory is a circular segment. Next, we show that the problem with linear speed decreases and rectilinear obstacles can be solved in polynomial time by a dynamic program. Finally, we consider the case without obstacles, where the medium is non-uniform and the mover's velocity is a piecewise linear function. We reduce this problem to that of solving a system of polynomial equations of fixed degree, for which algebraic elimination theory allows us to solve the problem to optimality.

ObSteiner: An Exact Algorithm for the Construction of Rectilinear Steiner Minimum Trees in the Presence of Complex Rectilinear Obstacles

In this paper, we present ObSteiner, an exact algorithm for the construction of obstacle-avoiding rectilinear Steiner minimum trees (OARSMTs) among complex rectilinear obstacles. This is the first paper to propose a geometric approach to optimally solve the OARSMT problem among complex obstacles. The optimal solution is constructed by the concatenation of full Steiner trees among complex obstacles, which are proven to be of simple structures in this paper. ObSteiner is able to handle complex obstacles, including both convex and concave ones. Benchmarks with hundreds of terminals among a large number of obstacles are solved optimally in a reasonable amount of time.

An [formula omitted] algorithm for the Rectilinear Minimum Link-Distance Problem in three dimensions

In this paper we consider the Rectilinear Minimum Link Path Problem among rectilinear obstacles in three dimensions. The problem is well studied in two dimensions, but is relatively unexplored in higher dimensions. We solve the problem in O ( β n log n ) time, where n is the number of corners among all obstacles, and β is the size of a binary space partition (BSP) decomposition of the space containing the obstacles. There exist methods to find a BSP where in the worst-case β = Θ ( n 3 / 2 ) , giving us an overall worst-case time of O ( n 5 / 2 log n ) . Previously known algorithms have had worst-case running times of Ω ( n 3 ) .

EBOARST: An Efficient Edge-Based Obstacle-Avoiding Rectilinear Steiner Tree Construction Algorithm

Obstacle-avoiding Steiner routing has arisen as a fundamental problem in the physical design of modern VLSI chips. In this paper, we present EBOARST, an efficient four-step algorithm to construct a rectilinear obstacle-avoiding Steiner tree for a given set of pins and a given set of rectilinear obstacles. Our contributions are fourfold. First, we propose a novel algorithm, which generates sparse obstacle-avoiding spanning graphs efficiently. Second, we present a fast algorithm for the minimum terminal spanning tree construction step, which dominates the running time of several existing approaches. Third, we present an edge-based heuristic, which enables us to perform both local and global refinements, leading to Steiner trees with small lengths. Finally, we discuss a refinement technique called segment translation to further enhance the quality of the trees. The time complexity of our algorithm is <i xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">O</i> ( <i xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">n</i> log <i xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">n</i> ). Experimental results on various benchmarks show that our algorithm achieves 16.56 times speedup on average, while the average length of the resulting obstacle-avoiding rectilinear Steiner trees is only 0.46% larger than the best existing solution.

$\lambda$-OAT: $\lambda$-Geometry Obstacle-Avoiding Tree Construction With $O(n\log n)$ Complexity

Obstacle-avoiding rectilinear Steiner minimal tree (OARSMT) construction is an essential part of routing. Recently, IC routing and related researches have been extended from Manhattan architecture (lambda <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sub> -geometry) to Y-/X-architecture (lambda <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">3</sub> -lambda <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">4</sub> -geometry) to improve the chip performance. This paper presents an O(n log n) heuristic, lambda-OAT, for obstacle-avoiding Steiner minimal tree construction in the lambda-geometry plane (lambda-OASMT). In this paper, based on obstacle-avoiding constrained Delaunay triangulation, a full connected tree is constructed and then embedded into lambda-OASMT by zonal combination. To the best of our knowledge, this is the first work addressing the lambda-OASMT problem. Compared with most recent works on OARSMT problem, lambda-OAT obtains up to 30-Kx speedup with quality solution. We have tested randomly generated cases with up to 10 K terminals and 10-K rectilinear obstacles within 4 seconds on a Sun V880 workstation (755-MHz CPU and 4-GB memory). The high efficiency and accuracy of lambda-OAT make it extremely practical and useful in the routing phase.

New approximations for the rectilinear steiner arborescence problem

A new approach for approximating the minimum rectilinear Steiner arborescence is presented. The approach yields a simple two-approximation algorithm that runs in O(nlogn) time. Unlike earlier approaches, this can be naturally extended to deal with situations where we have isothetic rectilinear obstacles. This gives us the first O(nlogn) two-approximation algorithm for the rectilinear Steiner arborescence problem in the presence of obstacles.

An efficient direct approach for computing shortest rectilinear paths among obstacles in a two-layer interconnection model

In this paper, we present a direct approach for routing a shortest rectilinear path between two points among a set of rectilinear obstacles in a two-layer interconnection model that is used for VLSI routing applications. The previously best known direct approach for this problem takes O(n log 2n) time and O(n logn) space, where n is the total number of obstacle edges. By using integer data structures and an implicit graph representation scheme (i.e., a generalization of the distance table method), we improve the time bound to O(n log 3/2n) while still maintaining the O(n logn) space bound. Comparing with the indirect approach for this problem, our algorithm is simpler to implement and is probably faster for a quite large range of input sizes.

Finding Rectilinear Paths Among Obstacles in a Two-Layer Interconnection Model

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 log 2 e) time.

Rectilinear paths among rectilinear obstacles

Given a set of obstacles and two distinguished points in the plane the problem of finding a collision-free path subject to a certain optimization function is a fundamental problem that arises in many fields, such as motion planning in robotics, wire routing in VLSI and logistics in operations research. In this survey we emphasize its applications to VLSI design and limit ourselves to the rectilinear domain in which the goal path to be computed and the underlying obstacles are all rectilinearly oriented, i.e., the segments are either horizontal or vertical. We consider different routing environments, and various optimization criteria pertaining to VLSI design, and provide a survey of results that have been developed in the past, present current results and give open problems for future research.

Rectilinear Path Problems among Rectilinear Obstacles Revisited

Efficient algorithms are presented for finding rectilinear collision-free paths between two given points among a set of rectilinear obstacles. The results improve the time complexity of previous results for finding the shortest rectilinear path the minimum-bend shortest rectilinear path, the shortest minimum-bend rectilinear path and the minimum-cost rectilinear path. For finding the shortest rectilinear path, a graph-theoretic approach is used and an algorithm is obtained with $O(m \log t + t \log^{3/2}t)$ running time, where t is the number of extreme edges of given obstacles and m is the number of obstacle edges. Based on this result an $O(N \log N + (m + N) \log t + (t+N) \log^{2} (t + N))$ running time algorithm for computing the $L_{1}$ minimum spanning tree of given N terminals among rectilinear obstacles is obtained. For finding the minimum-bend shortest path, the shortest minimum-bend rectilinear path, and the minimum-cost rectilinear path, we devise a new dynamic-searching approach and derive algorithms that run in $O(m \log^{2} m)$ time using $O(m \log m)$ space or run in $O(m \log^{3/2} m)$ time and space.

An efficient strategy for robot navigation in unknown environment

We study the ratio of the dead-free path length made by a new strategy to the shortest path length in unknown environment containing rectangular and rectilinear obstacles satisfying some limitations on their aspect ratios and side lengths. We show that the ratio is at most arbitrarily close to 1 + 3 5 f , as n grows, if the start point and the target are at the same horizontal level, where the aspect ratio of each obstacle is at most f. We also study the ratio for unknown environment where the start point and the target may be at different levels.

On bends and distances of paths among obstacles in two-layer interconnection model

We consider problems of finding assorted rectilinear paths among rectilinear obstacles in a two-layer interconnection model according to the number of bends and the 1-layer distance (y-distance). Using a horizontal wave-front approach, optimal /spl theta/(e log e) time algorithms are presented to find the shortest path and the minimum-bend path using linear space, and to find the shortest minimum-bend path and the minimum-bend shortest path using O(e log e) space, where e is the number of obstacle edges. By the same approach, we also derive an algorithm for finding a shortest two-layer distance (xy-distance) minimum-bend path in optimal /spl theta/(e log e) time using O(e log e) space. >

ON BENDS AND LENGTHS OF RECTILINEAR PATHS: A GRAPH-THEORETIC APPROACH

We consider the problem of finding a rectilinear path between two designated points in the presence of rectilinear obstacles subject to various optimization functions in terms of the number of bends and the total length of the path. Specifically we are interested in finding a minimum bend shortest path, a shortest minimum bend path or a least-cost path where the cost is defined as a function of both the length and the number of bends of the path. We provide a unified approach by constructing a path-preserving graph. guaranteed to preserve all these three kinds of paths and give an O(K+e log e) algorithm to find them, where e is the total number of obstacle edges, and K is the number of intersections between tracks from extreme point and other tracks (defined in the text). K is bounded by O(et), where t is the number of extreme edges. In particular, if the obstacles are rectilinearly convex, then K is O(ne), where n is the number of obstacles. Extensions are made to find a shortest path with a bounded number of bends and a minimum-bend path with a bounded length. When a source point and obstacles are pre-given, queries for the assorted paths from the source to given points can be handled in O( log e+k) time after O(K+e log e) preprocessing, where k is the size of the goal path. The trans-dichotomous algorithm of Fredman and Willard8 and the running time for these problems are also discussed.