Jeff Yakey
This project's purpose is to coordinate multiple robots (2 or 3) so that they do not collide with one another. For various situations when multiple robots are coordinated, there can be many optimal solutions for scheduling the robots. This algorithm computes all of the optimal solutions and allows the user to determine which these is most appropriate for a particular situation. (An example of its usefulness is when a certain robot has a higher priority than the others, so that it should reach its goal first if possible). The algorithm presented takes a decoupled approach to coordinating the robots, which means that the paths of the robots are computed without taking any of the other robots into consideration. Some assumptions made are that the robots are convex, polygonal, and exist in a 2D plane. Also, it is assumed that the paths of the robots were previously computed, so there is no worry of collision with obstacles other than the remaining robots.
In this algorithm, the notion of a path coordination space is presented. This is simply a Cartesian product of the paths of the robots, where a path is defined to be a function from [0,1] to the free configuration space. . As a consequence, each robot added to the coordination adds another dimension to the path coordination space. This is the major difficulty with this approach to multiple robot coordination, and results in that the algorithm doesn't scale up well for a large number of robots. Basically, the algorithm computes a path in this space from the location [0,0] to [1,1] (or [0,0,0] to [1,1,1] in the three robot case). The algorithm also keeps track of the set of optimal paths (called strategies) in the coordination space.
In order to compute these paths, we start at the [1,1] or [1,1,1] location in the coordination space and work towards the starting location. We also need to check for collision in order to insure that no two robots collide. The following are the main components needed to implement the algorithm.
First, a parser needed to be created to read the input file. Since this algorithm doesn't compute robot paths, each of the robot's paths needed to be specified in the input file. Also, the paths needed to be discretized according to a specified resolution and turned into a list of configurations.
The collision detector for the two robot case was very simple. For each pair of configuration in the coordination space, we checked to see if there was a collision. In the case of three robots, the collision bitmap computed was three dimensional. In order to efficiently compute the collisions in the coordination space bitmap, the cylindrical structure of collisions was exploited. If two robots collide in the configuration space, then an entire column in the space will be labeled a collision. This is because no matter where the third robot is configured, the other two robots will still be in collision. To use this to our advantage, all pairs of configurations on the paths were checked for collision between each pair of robots. This resulted in 3*n^2 time to compute the entire bitmap for collision, as opposed to n^3 time using a naive approach.
For each location in the coordination space, a neighborhood function needed to be called. This function checked neighboring locations in the coordination space and extended all of their strategies. These new strategies were then checked to see if they were minimal, and those that were not were tossed out. The minimal strategies were then stored in the coordination space location. Another aspect of the algorithm is that it uses the principle of optimality, allowing it to use a dynamic programming approach. This algorithm is very similar to Dijkstra's algorithm, and can be best explained by looking in the referenced paper.
The biggest problem with this implementation is that the data structure is not very efficient. Using C++ vectors may have been more efficient, but troubles integrating them with the LEDA package prevented me from using them. Also, the collision detector could possibly be improved by implementing an incremental approach similar to the one presented in class.
Computational Considerations
This algorithm works very well for cases involving only a few robots, but performs progressively worse as the number of robots increases. Another problem with this algorithm is that it is not complete. Since the the other robots are not considered when computing paths, possible solutions could be missed that would be found by using a centralized approach (at the expense of computation time). Example 3 illustrates this problem.
References
Optimal Motion Planning for Multiple Robots Having Independent Goals by Steven M. Lavalle and Seth A. Hutchinson
Computed Examples
Source Code:
Input Data Files: