An Effective Algorithmic Framework for Near Optimal Multi-Robot Path Planning

An Effective Algorithmic Framework for Near Optimal Multi-Robot Path Planning

Jingjin Yu    Daniela Rus Jingjin Yu and Deniela Rus are with the Computer Science and Artificial Intelligence Lab, Massachusetts Institute of Technology. E-mails: {jingjin, rus}

We present a centralized algorithmic framework for solving multi-robot path planning problems in general, two-dimensional, continuous environments while minimizing globally the task completion time. The framework obtains high levels of effectiveness through the composition of an optimal discretization of the continuous environment and the subsequent fast, near-optimal resolution of the resulting discrete planning problem. This principled approach achieves orders of magnitudes better performance with respect to both speed and the supported robot density. For a wide variety of environments, our method is shown to compute globally near-optimal solutions for robots in seconds with robots packed close to each other. In the extreme, the method can consistently solve problems with hundreds of robots that occupy over of the free space.

I Introduction

We study the problem of planning collision-free paths for multiple labeled disc robots operating in two-dimensional, multiply-connected, continuous environments (i.e., environments with holes). The primary goal of this work is to develop a practical, extensible framework toward the efficient resolution of multi-robot path planning (Mpp) problems, in which the robots are densely packed, while simultaneously seeking to minimize globally the task completion time. The framework is composed of two key algorithmic components, executed in an sequential order. Using the example illustrated in Fig. 1(a), first, we compute the configuration space for a single robot, over which an optimal lattice structure is overlaid (Fig. 1(b)). Using the lattice structure as a roadmap, each start (resp., goal) location is assigned to a nearby node of the roadmap as its unique discrete start (resp., goal) node, which translates the continuous problem into a discrete one (Fig. 1(c)). Then, a state-of-the-art discrete planning algorithm is applied to solve the roadmap-based problem near-optimally (Fig. 1(d)). Through the tight composition of these two algorithmic components, our framework proves to be highly effective in a variety of settings, pushing the boundaries on optimal multi-robot path planning to new grounds in terms of the number of robots supported and the allowed robot density.

(a) (b)
(c) (d)
Fig. 1: An illustrative example of our algorithmic framework. a) A problem instance with three disc robots. The start and goal locations are indicated by the blue and red labeled discs, respectively. b) The configuration space (shaded area) for a single robot and the fitted hexagonal lattice. The blue circles are the start positions, and the red circles are the goal positions. c) The discrete abstraction of the original problem. d) Solution to the original continuous problem.

Related work. Mpp  finds applications in a wide spectrum of domains such as navigation Alonso-Mora (2014); Snape et al. (2014), manufacturing and assembly Knepper and Rus (2012), warehouse automation Wurman et al. (2008), computer video games Snape (2012), and microfluidics Griffith and Akella (2005). Given the important role it holds in robotics-related applications, Mpp  problems has received considerable attention in robotics research with dedicated study on the subject dating back at least three decades Schwartz and Sharir (1983), in which a centralized approach is taken that considers all robots as a single entity in a high dimensional configuration space. Because the search space in such problems grows exponentially as the number of robots increases linearly, a centralized approach Schwartz and Sharir (1983), although complete, would be extremely inefficient in practice. As such, most ensuing research take the approach of decomposing the problem. One way to do this is by assigning priorities to the robots so that robots with higher priority take precedence over robots with lower priority Buckley (1989); Erdmann and Lozano-Pérez (1986). Another often adopted partitioning method is to plan a path for each robot separately without considering robot-robot interaction. The paths are then coordinated to yield collision free paths Bien and Lee (1992); O’Donnell and Lozano-Pérez (1989). Following these initial efforts, the decomposition scheme is further exploited and improved Ghrist et al. (2005); LaValle and Hutchinson (1998); Peng and Akella (2002); van den Berg and Overmars (2005); van den Berg et al. (2009); Švestka and Overmars (1998). Many of the mentioned works also consider optimality in some form. We emphasize that, since finding feasible solution for Mpp  is already PSPACE-hard Hopcroft et al. (1984), i.e., no polynomial-time complete algorithm may even exist for such problems unless P = PSPACE, computing globally near-optimal solution for a large number of robots is extremely challenging.

Recent years have witnessed a great many new approaches being proposed for solving Mpp. One such method, reciprocal velocity obstacles van den Berg et al. (2008, 2011), which can be traced back to Kant and Zucker (1986), explicitly looks at velocity-time space for coordinating robot motions. In Griffith and Akella (2005), mixed integer programming (MIP) models are employed to encode the interactions between the robots. A method based on network-flow is explored in I. Karamouzas (2012). In Peasgood et al. (2008), similar to our framework upon a first look, an -based search is performed over a discrete roadmap abstracted from the continuous environment. However, the authors addressed a much narrower class of problems for which they can bound the computation cost but cannot guarantee the solution optimality. It is also unclear how the complex geometric problem of efficiently computing a discrete roadmap from the continuous environment is resolved in the paper. In Solovey et al. (2014), discrete-RRT (d-RRT) is proposed for the efficient search of multi-robot roadmaps. Lastly, as a special case of Mpp  in continuous domains, efficient algorithms are proposed Solovey et al. (2015); Turpin et al. (2013) for interchangeable robots (i.e., in the end, the only requirement is that each goal location is occupied by an arbitrary robot). At the same time, discrete (e.g., graph-based) Mpp  has also been a subject of active investigation. This line of research originates from the mathematical study of the 15-puzzle and related pebble motion problems Kornhauser et al. (1984); Wilson (1974). Since then, many heuristics augmenting the algorithm have been proposed for finding optimal solution, e.g., Ryan (2008); Standley and Korf (2011); Wagner and Choset (2011), to name a few. These heuristics essentially explore the same decoupling idea used in the continuous case to trim down the search space. A method based on network-flow also exists here Yu and LaValle (2013a). Some of these discrete solutions, such as Kornhauser et al. (1984), have helped solving continuous problems Krontiris et al. (2012); Solovey and Halperin (2012).

Contribution. Our work brings two contributions toward solving Mpp  effectively and optimally. First, we introduce a two-phase framework that allows any roadmap building (i.e., discretization) method to be combined with any suitable discrete Mpp  algorithm for solving continuous Mpp  problems. The framework achieves this by imposing a partial collision avoidance constraint during the roadmap building phase while preserving path near-optimality. Second, we deliver a practical integrated algorithmic implementation of the two-phase framework for computing near optimal paths for a large number of robots. We accomplish this by combining (i) a fast algorithm for superimposing dense regular lattice structures over a bounded two-dimensional environment with holes and (ii) an integer linear programming (ILP) based algorithm for computing near-time-optimal solutions to discrete MppYu and LaValle (2013b). To the best of our knowledge, we present the first such algorithm that can quickly plan near optimal, continuous paths for hundreds of robots densely populated in multiply-connected environments111Warehousing systems from Kiva Systems Wurman et al. (2008) can work effectively with hundreds of robots. However, these robots essentially live on a grid within a structured environment..

Paper organization. The rest of the paper is organized as follows. We formulate the Mpp problem in Section II. In Section III, we describe the overall algorithmic framework architecture and the first component of the framework on roadmap-based problem construction. In Section IV, we describe how the second component of the framework may be realized. In Section V, we demonstrate the effectiveness of our framework over a variety of environments. We hold an extensive discussion and conclude in Section VI.222An accompanying video demonstrating our algorithm and software developed in this paper are available from the corresponding author’s website.

Ii Problem Statement

Let denote a bounded, open, multiply-connected (i.e., with holes), two-dimensional region. We assume that the boundary and obstacles of can be approximated using polygons with an overall complexity of (i.e, there are a total of edges). There are unit disc robots residing in . These robots are assumed be omnidirectional with a velocity satisfying . Let denote the free configuration space for a single robot (the shaded area in Fig. 1(b)). The centers of the robots are initially located at , with goals . For all , a robot initially located at must be moved to .

In addition to planning collision-free paths, we are interested in optimizing path quality. Our particular focus in this paper is minimizing the global task completion time, also commonly known as makespan333Note that our algorithmic framework also applies to other time- and distance-based optimality objectives through the use of an appropriate discrete planning algorithm.. Let denote a feasible path set with each a continuous function, defined as

The makespan objective seeks solutions that minimize . In other words, let denote the set of all solution path sets, the task is to find a path set with close to


We emphasize that the aim of this work is a method for quickly solving “typical” problem instances with many robots and high robot density (i.e., the ratio between robot footprint and the free space is high) with optimality assurance. By typical, we mean that: (i) the start location and goal locations are reasonably separated, (ii) a start or goal location is not too close to static obstacles in the environment, and (iii) there are no narrow passages in the environment that cause the discretized roadmap structure to have poor connectivity. More formally, we assume that assumptions (i) and (ii), respectively, take the forms 444(2) and  (3) are unit-less given the unit disc robot assumption. If the robots have radius , the right side of the inequalities from (2) and  (3) should be scaled by a multiplicative factor of .




For (iii), the discretized roadmap should capture the topology of the continuous environment well. To be more concrete, see Figure 2(a). In this environment, there are two holes. The lattice graph, after contraction of faces that do not contain any obstacles, does not have any holes. We expect the discrete roadmap to be connected and have number of holes (after face contraction) equal to the number of holes of the continuous environment (e.g., Fig. 1(d)).

(a) (b)
Fig. 2: a) An environment with a discretization that does not capture its original topology. b) The roadmap after restoring connectivity (the operations are performed automatically from our code), which then captures the topology of the original environment.

Remark. We provide these assumptions only to suggest situations in which our framework is expected to perform well. In our evaluation, these assumptions are not enforced. We in fact greatly relax (2) (from to ) and do not enforce (3) at all. We also give an efficient subroutine for restoring connectivity when assumption (iii) is not satisfied. For example, the routine, when applied to the example in Fig. 2(a), yields the result in Fig. 2(b), which is a screen capture from our program. We also emphasize that, given that optimal Mpp is an extremely challenging task computationally Hopcroft et al. (1984) and our focus on method effectiveness, we do not consider the problem from the angle of solution completeness.

Iii Algorithmic Framework Architecture and Roadmap-Based Discrete Problem Construction

We solve the proposed problem using an algorithmic framework with two algorithmic components–discretization of the continuous problem followed by resolution of the roadmap-based problem. The overall framework contains four sequential procedures:

  • select and overlay a regular lattice structure over the configuration space,

  • restore environment connectivity lost in the discretization process,

  • snap start and goal locations to roadmap nodes to create a discrete problem on the roadmap, and

  • solve the discrete Mpp  problem optimally or near-optimally.

We note that, when compared with motion planning methods such as PRM Kavraki et al. (1996) and RRT LaValle (1998), our framework, looking somewhat similar on the surface, is in fact rather different. In methods like PRM and RRT, the discretization deals with the configuration space encompassing all degrees of freedom of the target system. Our approach, on the other hand, performs a careful, mostly uniform discretization of the configuration space for a single robot with two degrees of freedom. In doing so, we trade probabilistic completeness for the faster computation of near-optimal solutions. In the rest of this section, we describe the first key component of our algorithmic framework–the construction of the roadmap-based discrete problem, which subsumes the first three algorithmic procedures of the overall framework.

Iii-a Lattice Selection and Imposition

Appropriate lattice structure selection In selecting the appropriate lattice structure, we aim to allow the packing of more robots simultaneously on the resulting roadmap and obtain the structure fast. Clearly, if an insufficient number of nodes exists in the roadmap, the resulting discrete problem can be crowded with robots, which is difficult to solve and may not even have a solution. On the other hand, to allow a clean separation between the roadmap building phase and the discrete planning phase of the framework, the nodes cannot be too close to each other, e.g., two robots occupying two different nodes should not be in collision. Moreover, it is desirable that two robots moving on different edges in parallel will not collide with each other.

Considering all these factors together, we resort to adopting uniform tilings of the plane Robert (1978). A uniform tiling of the plane is a regular network structure that can be repeated infinitely to cover the entire two-dimensional plane. Due to the regularity of uniform tilings, it is computationally easy to overlay a tiling pattern over . Choosing such a tiling then relieves us from selecting each node for the roadmap individually. Over the uniform tilings555These tilings are: triangular, trihexagonal, square, elongated triangular, hexagonal, truncated square, truncated trihexagonal, truncated hexagonal, snub square, rhombitrihexagonal, snub hexagonal. of the plane Robert (1978), we computed the density of robots supported by each. To allow concurrent moves of robots on nearby edges, take square tiling as an example, a square must have a side length of to avoid potential collision incurred by such moves (see, e.g., Fig. 3(a)). Indeed, it is straightforward to show that the closest inter-robot distance is reached when two robots are in the middle of two edges connecting to the same node. For hexagonal tilings, this results in a minimum side length of (Fig. 3(b)).

(a) (b)
Fig. 3: Minimum distance between robots. To ensure no collision when executing a discrete plan, the distance between two lattice nodes must be for square tilings (a) and for hexagonal tilings (b). At exactly (resp. ) the robots will touch when reaching the midpoint of the edge. The contact point is shown as a red doc in both figures.

After obtaining the required side length parameters for all tilings, the maximum robot density allowed by these tilings can then be computed. We compute the density by assuming that all nodes of the regular tiling patterns are occupied by robots and compute the ratio between the area occupied by robots and the free space when it is unoccupied. For an infinite lattice with no obstacles, the hexagonal tiling is the best with about density, followed by the square tiling with roughly density. Triangular tilings have a density of only . This leads us to choose hexagonal lattices as the base structure of the discrete roadmap.

Fig. 4: Efficient computation of the hexagonal lattice that falls inside .

Imposing the lattice structure After deciding on the lattice structure, we need a procedure for imposing the structure on . Essentially, every edge must be checked to determine whether it is entirely contained in the free configuration space . Note that if this is performed naively, i.e., performing collision checking of each edge with all obstacles, the overall complexity is on the order of , in which is the complexity of the workspace and is the area contained in the outer boundary. The naive approach quickly becomes time-consuming as either or grows.

To complete this step efficiently, we start by making an arbitrary alignment between a sufficiently large piece of the infinite hexagonal lattice and the continuous environment (Fig. 4). Then, we look at one C-space obstacle (including the outer boundary) at a time. For each obstacle, we pick an arbitrary vertex on the boundary (red dot in Fig. 4) and locate the hexagon from the lattice it belongs to (in case of the example in Fig. 4, the shaded hexagonal with the label “1” ). We then follow the obstacle boundary and find all (green) edges of the lattice that intersect the boundary. The edges found this way do not belong to and the final discrete graph structure; moreover, they partition the lattice into pieces that are either completely inside or completely outside . This allows us to efficiently check whether the rest of the lattice edges belong to . To do so, we start with a vertex that is within that also belongs to one of these green edges and perform a breath first search over the lattice structure, now with all the green edges deleted. All edges found this way must be long to . We repeat this until all vertices of the lattice that fall inside are exhausted. Note that this BFS is a discrete search without performing geometric computation over real numbers, which can be done much faster than edge intersection checks. In the end, we obtain an output sensitive algorithm that typically takes time between and , depending the total length of obstacle boundaries. In practice, using the said method, the computation time used by this step is trivial in comparison to the time it takes to do the discrete planning.

Restore Configuration Space Connectivity We now address how we may ensure that the topology of is preserved in the discrete roadmap. Essentially, we must locate places where connectivity in the continuous environment is lost. We illustrate our algorithmic solution for doing so using an example. For the problem given in Fig. 3(a), for each C-space obstacle, it is straightforward to obtain the smallest cycle on the lattice enclosing the obstacle (e.g., the green and red cycles in Fig. 5). Then, for each pair of obstacles, we check whether the corresponding enclosing cycles share non-trivial interior and if so, locate a minimum segment on the overlapping section (em e.g., the red segments between the two orange nodes in Fig. 5). Using visibility graph Lozano-Pérez and Wesley (1979), we may then restore the lost connectivity and obtain the roadmap shown in Fig. 3(b). Most of the computation time in this step is spent on computing the visibility graph itself, which takes time Ghosh et al. (1993), with being the complexity of the environment and being the number of edges in the resulting visibility graph.

Fig. 5: Smallest cycles fully surrounding the two obstacles.

Remark. In the process of restoring connectivity, it is possible that the resulting roadmap cannot guarantee that simultaneous movements of disc robots are collision-free. Without getting into details, we mention that this issue can be fully addressed by sacrificing some time optimality.

We also note that the preservation of the connectivity or topology of the continuous environment can be crucially important. A better connected environment has a more diverse set of candidate paths, making the resulting problem easier to solve. Perhaps more importantly, the preservation of the connectivity of is essential to preserving path optimality. For a roadmap built from an overlaid square lattice, given a shortest path between two points, due to the strong equivalence between the Euclidean metric and the Manhattan metric, the shortest path and the corresponding shortest path on the square lattice-based roadmap are within a constant factor multiple of each other for any reasonably long path (that is, does not hold). The same argument applies to the roadmap-based hexagonal lattices. Without obstacles, the ratio over a long path is bounded by for square lattices and roughly the same for hexagonal lattices. The ratio is largely the same when obstacles are present. On the other hand, if the connectivity of is not preserved, then it becomes possible that is arbitrarily large. An example is given in Fig. 6.

Fig. 6: Suppose that the start and goal locations are at the center of the blue and the red discs, respectively. If the robot does not find the narrow passage on the left, it then needs to travel through a winding path on the right. By extending the width of the environment, we can make the winding path arbitrarily long when compared to the shortest path.

Once we establish that the roadmap preserves the near-optimality on path length, the same applies to time optimality. Given the preservation of near-optimality of individual paths, it does not directly imply that an optimal solution to the abstracted discrete problem also preserves optimality with respect to the original continuous problem, in terms of time or distance. However, our computational experiments show that this is generally the case when has good connectivity.

Iii-B Snapping Start and Goal Locations to Roadmap Nodes

After the full roadmap is built, each start or goal location in must be associated with a nearby roadmap node. We call this process snapping. For the snapping step, for each , we simply associate with the closest roadmap node that can reach without colliding with another . The same process is performed for all With the separation assumptions (2) and (3), this is almost always possible. In particular, (2) implies that each hexagon from the lattice contains (roughly) at most one start and one goal location. Therefore, the number of nodes on the roadmap is at least twice the number of robots. In rare cases when conflicts do happen, we may apply the rearrangement algorithms (e.g., Solovey et al. (2015)) to perform the snapping step without incurring much penalty on time optimality. The completeness of this step is guaranteed by (2) and (3).

With the snapping process complete, a discrete abstraction of the original continuous problem is obtained. For our example, this leads to the scenario captured in Fig. 1(c). If we are not interested in optimality, the discrete problem may be attempted using a non-optimal but polynomial time algorithm Kornhauser et al. (1984); Yu and Rus (2014). As stated in the individual subsections, the computation required in this section can be carried out using low-degree polynomial time algorithms. The relative time used for this portion is trivial as compared to the time required for solving the roadmap-based discrete problem.

Iv Fast, Near-Optimal Discrete Path Planning

After a high quality roadmap is obtained with near-optimality guarantees on time and distance (e.g., an optimality-preserving reduction from continuous space to discrete space), one may then freely choose an algorithm for finding solutions to the discrete abstraction (Fig. 1(c) in our example). Whereas an arbitrary number of globally optimal objectives can be conjured, four objectives are perhaps most natural. These four objectives minimize the maximum or the total arrival time or travel distance. Viewing from the angle of service provider (e.g., delivery drones) and end user (e.g., customers), minimizing the total distance or time allows the service provider to minimize energy cost or overall vehicle fleet usage. On the other hand, minimizing the maximum time or distance promises a more uniform service quality among customers. If minimizing the total arrival time or the total distance is the goal, then discrete search methods such as ID Standley and Korf (2011) can be applied. Here, we focus on the minimum makespan (i.e., maximum arrival time or task completion time). We describe an effective method for minimizing the makespan Yu and LaValle (2013a, b), which is also a good proxy to minimizing the maximum travel distance. The method is an ILP-based one with an optimal baseline algorithm, augmented with near-optimal heuristics to improve the computational performance.

Iv-a The Baseline, ILP Model-Based Algorithm

We describe here an integer linear programming (ILP) model based algorithm from Yu and LaValle (2013a). The algorithm delivers an exact method for computing a minimum makespan solution to a discrete Mpp  instance. The key idea is to perform time expansion over the discrete roadmap and then build the ILP model over the resulting forward only space-time graph. This allows the consideration of robot-robot time interaction to go from being implicit over the (spatial) roadmap to being explicit on the space-time graph. For a hexagonal (spatial) roadmap, between subsequent time steps, the time expansion has the intuitive local structure illustrated in Fig. 7, which basically says that a robot at a node and its neighbors can reach in the next time step. Then, in the ILP constraint setup phase, two additional constraints are enforced:

  1. At most a single edge leading to from time step can be used (i.e., all but one such edge binary variable can be set to ), this enforces that only a single robot may reach node at time step . This prevents collision on a node.

  2. At most one edge from and can be used. This prevents collision on an edge.

Fig. 7: In a single time expansion step, a node’s neighbors (including the node itself) at time step are connected to the node at time step .

The above constraints can be encoded easily using linear inequalities. To optimize for minimum time, an underestimate of the minimum required time is used as the number of time steps in the time expansion. This underestimate can be easily obtained by computing the minimum path length for each robot ignoring the rest of the robots and then taking the maximum of the path lengths. To complete the model setup, for a robot starting at node that has node as its goal, an edge is added to the model and is forced to be used. This forces a solution to find a path through the space-time graph connecting and . If the model is infeasible, is then increased and the model is rerun until a solution is found. The number of time steps required for finding the first feasible solution is then the optimal time (for the discrete problem). When the initial roadmap has good connectivity, which is the case targeted by our work, this method appears to work reasonably well for instances with robots, taking only minutes to solve such problems (see Yu and LaValle (2013a) for details).

Iv-B Heuristic: Divide-and-Conquer Over Time Domain

In exploring the ILP model-based algorithm, we observe the general trend that the model solution time grows exponentially with respect to the size of the model. This prevents the baseline algorithm from being very useful as it does not work very well beyond 10-20 robots when the robot density is also high, even without the presence of static obstacles.

The same observation, though limiting the performance of the (exact) baseline algorithm, turns out to offer an useful insight toward a highly efficient divide-and-conquer heuristic. We notice that by limiting the size of the ILP model, we generally get fairly good performance from an ILP solver (we used Gurobi Inc. (2015) in this paper). To apply the method to more challenging problems (e.g., solving problems with hundreds of robots quickly), we simply limit the individual ILP model that is fed to the solver. One way to achieve this is through divide-and-conquer over the time domain. We use a simple example (see Fig. 8) to illustrate this idea.

(a) (b)
Fig. 8: a) A simple two-robot problem. b) The time-divided instances.

In Fig. 8(a), we have a simple planning problem for two robots on a grid. To carry out the heuristic, we first compute a shortest path for every pair of start and goal locations. In this case, we get the orange and green paths for robots and , respectively. Then, if we decide to split the problem into two smaller problems, for each of the paths, it is split into two (generally) equal length pieces and the middle node is set as the intermediate goal. In our example, we may do this for robot easily and set the intermediate goal location at from the top-left corner (the brown disc labeled in Fig. 8(b)). For robot , because the middle location coincides with that of robot , we pick an alternative location that is not already occupied as the intermediate goal for robot , in this case from the top-left corner. The intermediate goals for the first instance will also serve as the start locations of the second instance. This yields two child instances with both requiring a time expansion with steps each, whereas the original problem also requires a time expansion with steps. In general, we may divide a problem into arbitrarily many smaller instances in the time domain.

If a problem is divided in this manner to sub problems, we call the resulting heuristic a -way split. Because the division is over time, there is in fact no interaction between the individual, smaller instances. Once we obtain the solution for each child instance, the solutions can be glued together by simple concatenation. In practice, it turns out that this simple heuristic dramatically improves the performance without heavy negative impact on path optimality. In computational experiments, we observe a consistent speedup.

Iv-C Heuristic: Reachability Analysis

Another method to effectively reduce ILP model size (without losing any guarantee) is through reachability analysis. Again using the example from Fig. 8(a) and focusing on robot , if the time expansion uses time steps, then the reachable nodes (from both the start and the goal) of the graph at is illustrated in Fig. 9. Constructing the time-expanded graph from these then greatly reduces the resulting ILP model size.

(a) (b) (c)
Fig. 9: The reachable portions of the grid at time steps , respectively.

Remark. Because the problem we are to solve in this section is NP-complete
Yu and LaValle (2013c) and we are aiming to solve it exactly, no meaningful analysis on computational complexity can be provided; we only note that the computational time required by this part of the framework dominates all other parts.

V Computational Evaluation

We implemented the roadmap building phase in C++ using CGAL cga (). The discrete path planning module, written in Java, uses Gurobi Inc. (2015) as the ILP solver. The experiments were carried out on an Intel i7-4850HQ laptop PC. For evaluation, we tested of our algorithmic framework over five distinct environments. The first one is a simple square with a side length of 35 (recall that the robots are unit discs), with no internal obstacles. The rest of the environments have the same bounding square but contain different obstacle setups. We randomly select start and goal locations for all our tests. These environments, along with a typical -robot problem instance, are illustrated in Fig. 10.

(a) (b)
(c) (d)
Fig. 10: Environments with obstacles and start and goal locations. The labeled blue discs mark the start locations and the labeled pink discs mark the goal locations. Zoom-in on the digital version of the paper for more details. a) Plus. b) (Halloween) Jack. c) Triangles. d) Bars.

V-a Performance in Bounded, Obstacle-Free Environment

We first characterize how our framework performs in terms computation speed and solution optimality, as -way split heuristic is used with different values of . For this task, we carry out two sets of computations. The first set, covered in this subsection, focuses on bounded, obstacle-free environment. For this environment, we let the number of robots vary between to and evaluate the performance of the framework with the baseline algorithm (i.e., a single sub-problem), 2-way split (i.e., two sub-problems), 4-way split, and 8-way split. For each choice of the number of robots and the heuristic, test cases are randomly generated sequentially and solved. The average running time and optimality ratio is plotted in Fig. 11. Note that our computation of the optimality ratio is conservative. To compute this ratio, we find the shortest distance between each pair of start and goal locations and use the maximum of these distances as the estimate of optimal time (since the robot has maximum speed of ). We then obtain the optimality ratio by dividing the actual task completion time by the estimated value.

Fig. 11: Performance of our algorithmic framework with various choices of heuristics for a square environment without internal obstacles. [left] Computation time. [right] Optimality ratio.

From the experiments, we observe that the baseline algorithm actually performs quite well for up to robots in the absence of obstacles. With that said, both 2-way and 4-way splits do much better without losing much optimality–all three achieves optimality ratio between 1.2 to 1.6 in our experiments. With the 8-way split, sacrificing some optimality, we were able to consistently solve problems with robots in seconds on average. Such settings correspond to robots occupying over of the free space, a setting that has never been attempted before in optimal multi-robot path planning. With 8-way split, problems with robots in the same environment, which corresponds to a robot density over , can be comfortably solved in about minutes. We note that, if robot density is around , our method can readily solve problems with over robots (in a larger environment).

V-B Performance in Bounded Environment with Obstacles

The second set of experiments shifts the focus to an environment with obstacles. For this we use the “Jack” environment. We choose this environment because it is in fact a relatively difficult setting as many shortest paths have to pass through the middle, causing conflicts. The experimental result, for to robots, is plotted in Fig. 12, which is consistent with our first set of experiments. We note that obstacles, while affecting the computation time, do not heavily impact the optimality of the result.

Fig. 12: Performance of our algorithmic framework with various choices of heuristics for the “Jack” environment. [left] Computation time. [right] Optimality ratio.

V-C Evaluation of Overall Framework Performance

Our last set of experiments is aimed at showing the overall effectiveness of our framework. For this purpose we select the splitting heuristic automatically. Roughly, we do this by increasing (in a -way split) to keep each time expansion with time steps, which we have found to strike a good balance between speed and optimality. For the set of environments illustrated in Fig. 10, the experimental result is plotted in Fig. 13. Our method is able to consistently solve all instances with an average solution time from to seconds while providing good optimality assurance on minimum makespan. The two spikes in Fig. 13(a) at robots are due to the switching to 8-way split at robot for these two environments.

Fig. 13: Performance of the overall framework in a wide variety of environments. [left] Computation time. [right] Optimality ratio.

Vi Conclusion

In this paper, we present an algorithmic framework for tackling the multi-robot path planning problem in continuous, multiply-connected environments. Our framework partitions the planning task into two phases. In the first phase, the configuration space is tiled with a carefully selected regular lattice pattern, taking into account robot-robot collision avoidance. The imposed lattice is then processed to yield a roadmap that preserves the connectivity of the continuous configuration space, which is essential for achieving near optimality in the final solution. Snapping the robots and their goal locations to the roadmap then transforms the initial continuous planning problem to a discrete planning problem. In the second phase, the discrete planning problem can be solved using any graph-based multi-robot path planning algorithms, after which the solution can be readily used in continuous domains. With a good optimal planner for discrete Mpp, our overall algorithm can consistently solve large problem instances with tens to hundreds of robots in seconds to minutes.

As we make an important first step here toward a generic framework for near-optimal multi-robot path planning in continuous domains with obstacles, we also bring about many natural next steps. We discuss a few of these here, which we plan to fully explore in our future research.

Nonholonomic constraints. An important issue not addressed in this paper is path planning for nonholonomic robots. We briefly touch upon this issue here. Our algorithmic framework supports quite naturally nonholonomic robots that are small-time locally controllable (STLC) with reasonable minimum turning radius. Essentially, to apply our method to a nonholonomic robot, the robot only need the capability to: (i) move from its start location to a nearby roadmap node with a given orientation, (ii) trace any path on the roadmap without incurring collision, and (iii) move from a roadmap node to a nearby goal location (with an arbitrary orientation). A car-like robot, or any robot that is STLC, possesses the first and the third capabilities. Then, as long as the robot has a minimum turning radius of , it can follow any path on a hexgonal lattice without violating its nonholonomic constraints (see Fig. 14). More importantly, multiple robots may move concurrently in such a manner without causing collisions. The introduction of nonholonomic constraints does not significantly affect optimality.

Fig. 14: A car-like robot with a mininum turning radius of 2 can trace any given path on a hexagonal lattice with side length without violating its nonholonomic constraints or colliding with other robots.

Decentralized planner. The current implementation of our framework yields a centralized algorithm. It is possible, however, to make the algorithm decentralized at the global scale. For example, we may simply let each robot perform planning individually using a method such as reciprocal velocity obstacle (RVO) based algorithm and engage locally our centralized method as the density of robots surpass some critical threshold. Note that, as the density of robots increases, RVO-based or repulsion-force-based methods generally do not have optimality guarantees and may also create deadlocks.

Optimality of hexagonal lattice in general environments. While we have shown that a hexagonal lattice structure yields the optimal tiling in the absence of obstacles, it is unclear whether this holds well when there are obstacles in the bounded environment. In future work, we plan to study this through simulation under various obstacle settings. We will also characterize the performance using lattice structures other than hexagonal ones. The reason behind this is that, although hexagonal lattice allows the highest density, each node is only 3-connected. Square lattices, for example, has a 4-connected structure, which facilitates the discrete planning phase. Generally, discrete Mpp  problems with higher connectivity are easier to optimally solve.


  • Alonso-Mora (2014) J. Alonso-Mora, “Collaborative Motion Planning for Multi-Agent Systems,” Ph.D. dissertation, ETH Zurich, Mar. 2014.
  • Snape et al. (2014) J. Snape, S. J. Guy, J. van den Berg, and D. Manocha, “Smooth coordination and navigation for multiple differential-drive robots,” in Exp. Robot.   Springer, 2014.
  • Knepper and Rus (2012) R. A. Knepper and D. Rus, “Pedestrian-inspired sampling-based multi-robot collision avoidance,” in RO-MAN, 2012.
  • Wurman et al. (2008) P. R. Wurman, R. D’Andrea, and M. Mountz, “Coordinating hundreds of cooperative, autonomous vehicles in warehouses,” AI Mag., vol. 29, no. 1, pp. 9–19, 2008.
  • Snape (2012) J. R. Snape, “Smooth and collision-free navigation for multiple mobile robots and video game characters,” Ph.D. dissertation, University of North Carolina at Chapel Hill, 2012.
  • Griffith and Akella (2005) E. J. Griffith and S. Akella, “Coordinating multiple droplets in planar array digital microfluidic systems,” IJRR, vol. 24, no. 11, pp. 933–949, 2005.
  • Schwartz and Sharir (1983) J. Schwartz and M. Sharir, “On the piano movers’ problem: III. coordinating the motion of several independent bodies: the special case of circular bodies moving amidst polygonal barriers,” IJRR, vol. 2, no. 3, pp. 46–75, 1983.
  • Buckley (1989) S. J. Buckley, “Fast motion planning for multiple moving robots,” in ICRA, 1989.
  • Erdmann and Lozano-Pérez (1986) M. A. Erdmann and T. Lozano-Pérez, “On multiple moving objects,” in ICRA, 1986.
  • Bien and Lee (1992) Z. Bien and J. Lee, “A minimum-time trajectory planning method for two robots,” IEEE T. Robot. Autom., vol. 8, no. 3, pp. 414–418, 1992.
  • O’Donnell and Lozano-Pérez (1989) P. A. O’Donnell and T. Lozano-Pérez, “Deadlock-free and collision-free coordination of two robot manipulators,” in ICRA, 1989.
  • Ghrist et al. (2005) R. Ghrist, J. M. O’Kane, and S. M. LaValle, “Computing Pareto Optimal Coordinations on Roadmaps,” IJRR, vol. 24, no. 11, pp. 997–1010, 2005.
  • LaValle and Hutchinson (1998) S. M. LaValle and S. A. Hutchinson, “Optimal motion planning for multiple robots having independent goals,” IEEE T. Robot. Autom., vol. 14, no. 6, pp. 912–925, Dec. 1998.
  • Peng and Akella (2002) J. Peng and S. Akella, “Coordinating multiple robots with kinodynamic constraints along specified paths,” in Algo. Found. Robot. V, J.-D. Boissonat, J. Burdick, K. Goldberg, and S. Hutchinson, Eds.   Berlin: Springer-Verlag, 2002, pp. 221–237.
  • van den Berg and Overmars (2005) J. van den Berg and M. Overmars, “Prioritized motion planning for multiple robots,” in IROS, 2005.
  • van den Berg et al. (2009) J. van den Berg, J. Snoeyink, M. Lin, and D. Manocha, “Centralized path planning for multiple robots: Optimal decoupling into sequential plans,” in RSS, 2009.
  • Švestka and Overmars (1998) P. Švestka and M. H. Overmars, “Coordinated path planning for multiple robots,” Robotics and Autonomous Systems, vol. 23, no. 3, pp. 125–152, 1998.
  • Hopcroft et al. (1984) J. E. Hopcroft, J. T. Schwartz, and M. Sharir, “On the complexity of motion planning for multiple independent objects; PSPACE-Hardness of the ”Warehouseman’s Problem”,” IJRR, vol. 3, no. 4, pp. 76–88, 1984.
  • van den Berg et al. (2008) J. van den Berg, M. C. Lin, and D. Manocha, “Reciprocal velocity obstacles for real-time multi-agent navigation,” in ICRA, 2008.
  • van den Berg et al. (2011) J. van den Berg, J. Snape, S. J. Guy, and D. Manocha, “Reciprocal collision avoidance with acceleration-velocity obstacles,” in ICRA, 2011.
  • Kant and Zucker (1986) K. Kant and S. Zucker, “Towards efficient trajectory planning: The path velocity decomposition,” IJRR, vol. 5, no. 3, pp. 72–89, 1986.
  • I. Karamouzas (2012) A. F. v. d. S. I. Karamouzas, R. Geraerts, “Space-time group motion planning,” in WAFR, 2012.
  • Peasgood et al. (2008) M. Peasgood, C. Clark, and J. McPhee, “A complete and scalable strategy for coordinating multiple robots within roadmaps,” IEEE T. Robot., vol. 24, no. 2, pp. 283–292, 2008.
  • Solovey et al. (2014) K. Solovey, O. Salzman, and D. Halperin, “Finding a needle in an exponential haystack: Discrete RRT for exploration of implicit roadmaps in multi-robot motion planning,” in WAFR, 2014.
  • Solovey et al. (2015) K. Solovey, J. Yu, O. Zamir, and D. Halperin, “Motion planning for unlabeled discs with optimality guarantees,” in RSS, 2015.
  • Turpin et al. (2013) M. Turpin, N. Michael, and V. Kumar, “Concurrent assignment and planning of trajectories for large teams of interchangeable robots,” in ICRA, 2013.
  • Kornhauser et al. (1984) D. Kornhauser, G. Miller, and P. Spirakis, “Coordinating pebble motion on graphs, the diameter of permutation groups, and applications,” in FOCS, 1984.
  • Wilson (1974) R. M. Wilson, “Graph puzzles, homotopy, and the alternating group,” J. Combinat. Theo. (B), vol. 16, pp. 86–96, 1974.
  • Ryan (2008) M. R. K. Ryan, “Exploiting subgraph structure in multi-robot path planning,” J. Arti. Intel. Res., vol. 31, pp. 497–542, 2008.
  • Standley and Korf (2011) T. Standley and R. Korf, “Complete algorithms for cooperative pathfinding problems,” in IJCAI, 2011.
  • Wagner and Choset (2011) G. Wagner and H. Choset, “M*: A complete multirobot path planning algorithm with performance bounds,” in IROS, 2011.
  • Yu and LaValle (2013a) J. Yu and S. M. LaValle, “Planning optimal paths for multiple robots on graphs,” in ICRA, 2013.
  • Krontiris et al. (2012) A. Krontiris, Q. Sajid, and K. Bekris, “Towards using discrete multiagent pathfinding to address continuous problems,” AAAI-WoMP, 2012.
  • Solovey and Halperin (2012) K. Solovey and D. Halperin, “-color multi-robot motion planning,” in WAFR, 2012.
  • Yu and LaValle (2013b) J. Yu and S. M. LaValle, “Fast, near-optimal computation for multi-robot path planning on graphs,” in AAAI, 2013, late breaking papers.
  • Kavraki et al. (1996) L. E. Kavraki, P. Svestka, J.-C. Latombe, and M. H. Overmars, “Probabilistic roadmaps for path planning in high-dimensional configuration spaces,” IEEE T. Robot. Autom., vol. 12, no. 4, pp. 566–580, 1996.
  • LaValle (1998) S. M. LaValle, “Rapidly-exploring random trees: A new tool for path planning,” Iowa State University, Tech. Rep., Oct 1998, computer Science Department TR 98-11.
  • Robert (1978) W. Robert, The Geometrical Foundation of Natural Structure. A Source Book of Design.   Dover, 1978.
  • Lozano-Pérez and Wesley (1979) T. Lozano-Pérez and M. A. Wesley, “An algorithm for planning collision-free paths among polyhedral obstacles,” Comm. ACM, vol. 22, no. 10, pp. 560–570, 1979.
  • Ghosh et al. (1993) S. K. Ghosh, A. Maheshwari, S. P. Pal, S. Saluja, and C. V. Madhavan, “Characterizing and recognizing weak visibility polygons,” Comput. Geom., vol. 3, no. 4, pp. 213–233, 1993.
  • Yu and Rus (2014) J. Yu and D. Rus, “Pebble motion on graphs with rotations: Efficient feasibility tests and planning,” in WAFR, 2014.
  • Inc. (2015) G. O. Inc., “Gurobi optimizer reference manual,” 2015. [Online]. Available:
  • Yu and LaValle (2013c) J. Yu and S. M. LaValle, “Structure and intractability of optimal multi-robot path planning on graphs,” in AAAI, 2013.
  • (44) Cgal, Computational Geometry Algorithms Library,”
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
Add comment
Loading ...
This is a comment super asjknd jkasnjk adsnkj
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test description