Proceedings of the 2006 IEEE/RSJ

International Conference on Intelligent Robots and Systems

October 9 - 15, 2006, Beijing, China

Anytime RRTs
Dave Ferguson and Anthony Stentz
Robotics Institute
Carnegie Mellon University
Pittsburgh, Pennsylvania
{dif,tony}@cmu.edu

Abstract— We present an anytime algorithm for planning paths to this task are anytime planners, which quickly find an initial,
through high-dimensional, non-uniform cost search spaces. Our highly suboptimal plan, and then improve this plan until time
approach works by generating a series of Rapidly-exploring runs out.
Random Trees (RRTs), where each tree reuses information from
previous trees to improve its growth and the quality of its In this paper, we present a sampling-based anytime al-
resulting path. We also present a number of modifications to gorithm for generating solution paths through both uniform
the RRT algorithm that we use to bias the search in favor of and non-uniform cost search spaces. Our approach works
less costly solutions. The resulting approach is able to produce by generating a series of Rapidly-exploring Random Trees,
an initial solution very quickly, then improve the quality of this where each tree reuses information from previous trees to
solution while deliberation time allows. It is also able to guarantee
that subsequent solutions will be better than all previous ones improve its growth and the quality of its resulting path. The
by a user-defined improvement bound. We demonstrate the first tree is generated using an unmodified RRT algorithm
effectiveness of the algorithm on both single robot and multirobot to ensure that a valid solution is available in the minimum
planning domains. possible time. We also present a number of modifications to
the Rapidly-exploring Random Tree algorithm that we use to
I. I NTRODUCTION
bias the subsequent searches in favor of less costly solutions.
Rapidly-exploring Random Trees (RRTs) have been shown The resulting approach is able to produce an initial solution
to be very effective for solving robotic path planning problems very quickly, then improve the quality of this solution while
involving complex configuration spaces [1], [2], [3], [4], [5]. deliberation time allows. It is also able to guarantee that
By combining random sampling of the configuration space subsequent solutions will be better than all previous ones by
with biased sampling around a desired goal configuration, a user-defined improvement bound.
RRTs efficiently provide solutions to problems involving We begin by describing the basic RRT algorithm and ex-
vast, high-dimensional configuration spaces that would be tensions that have been made to this algorithm to improve the
intractable using discrete approaches. quality of the solutions produced. We then introduce Anytime
However, while RRTs have been found to be extremely Rapidly-exploring Random Trees and show how this approach
effective at generating feasible solutions, they provide no can be used to generate less costly solutions through both
control over the quality of the solutions produced. In many uniform and non-uniform cost search spaces. We go on to
situations, in particular when dealing with non-uniform cost present a number of results from a single robot navigation
search spaces, the difficulty of executing different solution domain and a multirobot constrained exploration domain, and
paths may vary substantially. It is thus important that solution conclude with discussions and extensions.
cost is taken into account during the search process.
Nevertheless, few efforts have been made to incorporate cost II. R APIDLY- EXPLORING R ANDOM T REES
considerations into sampling-based planning algorithms. One The standard RRT algorithm for planning a path from some
notable exception is work by Urmson and Simmons [6], who initial configuration qstart to a goal configuration qgoal is
developed a series of modified versions of the RRT algorithm presented in Fig. 1. This algorithm initializes a search tree
that select tree nodes for expansion based on the cost of their with the initial robot configuration as the root node, then
current path from the initial node. Their approaches were incrementally grows the tree until the goal configuration is
able to produce less costly solutions through both uniform reached. To grow the tree, first a target configuration qtarget
and non-uniform cost search spaces. However, as might be is randomly selected from the configuration space using the
imagined, this improvement in solution quality usually came function ChooseTarget. Then, a NearestNeighbor function
at a computational price: the approach that produced the best selects the node qnearest in the tree closest to qtarget . Finally, a
solutions required significantly more computation than the new node qnew is created in an Extend function by growing the
unmodified RRT algorithm. tree some distance from qnearest towards qtarget . If extending
For agents operating in the real world under time con- the tree towards qtarget requires growing through an obstacle,
straints, it is important both that high quality solutions are no extension occurs. This process is repeated until the tree
produced and that these solutions can be produced within the grows to within some user-defined threshold of the goal (line
time available for planning. One class of planners well-suited 3). A very nice property that follows from this method of

1-4244-0259-X/06/$20.00 ©2006 IEEE

5369
 InitializeRRT(rrt T )
desired. The agents may not know a priori how much planning
1 T .add(qstart );
time is available and they certainly will not know how long it
GrowRRT(rrt T )
will take a particular algorithm to generate a solution. Thus,
2 qnew = qstart ;
it is useful to generate a series of solutions and then employ
3 while (Distance(qnew , qgoal ) > distance-threshold)
the best of these solutions when an action has to be executed.
4 qtarget = ChooseTarget();
In the discrete planning community, there exist a number of
5 qnearest = NearestNeighbor(qtarget , T );
efficient algorithms that can provide this performance [7], [8].
6 qnew = Extend(qnearest , qtarget , T );
For example, the ARA* algorithm developed by Likhachev,
7 if (qnew =null)
Gordon, and Thrun works by creating an initial, highly-
8 T .add(qnew )
suboptimal solution by running an inflated A* search with
ChooseTarget()
9 p = RandomReal([0.0, 1.0]);
a high suboptimality bound , then improves this solution by
10 if (p < goal-sampling-prob)
repeatedly running new searches with decreasing values of
11 return qgoal ;
. After each search terminates, the cost of the most recent
12 else
solution is guaranteed to be at most  times the cost of an
13 return RandomConfiguration();
optimal solution.
In order to plan through complex, very high-dimensional
Main()
14 InitializeRRT(tree); configuration spaces (as might be encountered when planning
15 GrowRRT(tree); for teams of agents), we would like a sampling-based analog
to these discrete anytime algorithms. In the following section,
Fig. 1. The RRT Algorithm. we present a sampling-based anytime algorithm that efficiently
constructs an initial solution using the standard RRT algorithm,
then improves this result by generating a series of solutions,
construction is that the tree growth is strongly biased towards each guaranteed to be better than all the previous ones by
unexplored areas of the configuration space. Consequently, some improvement factor f . These successive solutions are
exploration occurs very quickly. The RRT algorithm can also generated by using modified versions of the RRT algorithm
be made significantly more efficient if the search is focussed that take into account cost—both of nodes in the current tree
towards the goal. This can be achieved through using a and of previous solutions—to influence the sampling of the
goal bias (lines 9 to 11): with probability 1 − p, qtarget is search space, the selection of nodes in the tree for extension,
randomly selected; with probability p, qtarget is set to the and the extension operation itself.
goal configuration. As the value of p is increased, the RRT
behaves increasingly like best-first search. III. A NYTIME R APIDLY- EXPLORING R ANDOM T REES
As mentioned earlier, the original RRT algorithm does not Discrete anytime algorithms such as ARA* achieve their
take into account solution cost during the search. Thus, it anytime performance by efficiently generating a series of
can produce paths that are grossly suboptimal, particularly solutions, where each solution is better than the previous ones.
in non-uniform cost search spaces. To improve upon this, At any point in time the best solution found thus far can be
Urmson and Simmons presented three modified versions of returned, along with a suboptimality bound on the quality of
the RRT algorithm that take cost into account when selecting this solution.
nodes in the tree for extension [6]. They replaced the simple We can use this same basic idea to create a sampling-based
NearestNeighbor function (Fig. 1 line 5) with a function that anytime algorithm. We start out by generating an initial RRT
found the k nearest neighbors to the current qtarget point, then without any cost considerations. We then record the cost Cs
selected from these k nodes either (1) the closest node qnearest of the solution returned by this RRT. Next, we generate a new
to qtarget , as long as an estimate of the cost of a path from RRT and ensure that its solution is better than the previous
qstart through qnearest to qgoal is less than some probabilistic solution by limiting the nodes added to the tree to only those
threshold r, or (2) the first of the k nodes (ordered by estimated that could possibly contribute to a solution with a lower overall
path cost) whose current estimated path cost is less than r, cost than Cs . We can also multiply our cost bound Cs by
or (3) the node with the minimum estimated path cost, as some factor (1 − f ), where 0 ≤ f < 1, to ensure that the
long as this cost was less than r. These 3 different selection next solution will be at least f times less expensive than our
methods resulted in 3 different algorithms. Of these, the third previous solution. In such a case, f is known as the solution
method produced the best overall solutions, but required more improvement factor. We then update our cost bound Cs based
computation than the standard RRT algorithm. on the cost of the new solution and repeat the process until
We are interested in using RRTs for navigation of single time for planning runs out.
agents and multi-agent teams in partially-known outdoor en- Such an approach guarantees that each solution produced
vironments. Because our agents are acting in the real world, will be better than all the previous solutions. However, it
there may be situations where plans must be generated and does not guarantee that new solutions will be able to be
executed extremely quickly. There may also be other situations produced. In order for this approach to be truly effective we
where there is more time for deliberation and better plans are require dependable methods for generating each successive

5370
 (a) (b) (c) (d) (e)
Fig. 2. Anytime RRT Planning. Given a partial RRT (shown in (a)) being grown from an initial configuration (the bottom filled circle) to a goal configuration
(the top filled circle), this illustration shows how the Anytime RRT approach samples, selects, and extends the tree. To begin with, we assume some previous
solution has already been generated. (b) When using the Anytime RRT approach to sample the configuration space, only areas that could potentially lead to
an improved solution are considered (indicated by the shaded oval). Thus, the black nodes are rejected while the white node is accepted. (c) When selecting
the next node in the tree to extend, the k nodes closest to the sample point are found and ordered according to both their distance from the sample point
and the cost of their path from the start node. Here, k = 3 and the white node and two black nodes are the closest; the white node is selected first since
its path is less expensive than those of the two black nodes. (d) The tree node from (c) is then extended by generating a set of possible extensions and then
probabilistically choosing the one that is least expensive. The cost of the extension to the white node is cheaper than the extensions to the black nodes, so
the white node is chosen as the next element to be added to the tree. (e) After checking that the sum of the cost of the path from the start node through the
tree to the new element and the heuristic cost of a path from the new element to the goal is less than the solution bound, the element is added to the tree.

low-cost solution. We rely upon novel node sampling, node samples, the above approach could make it even more difficult
selection, and node extension operations that incorporate cost for the tree to grow down any narrow passages. Further, by
considerations and variable bias factors to efficiently produce reducing our consideration of sample points to only those
solutions satisfying a specified cost bound. We discuss each whose heuristic values are promising, we are in effect cutting
of these operations in turn. off large chunks of the configuration space. This is entirely
the point of restricting our sampling, but it can also introduce
A. Node Sampling
new narrow passages. For example, imagine an obstacle that
If we are only interested in generating a solution that is resides near the edge of the promising configurations, as
cheaper than some upper bound value Cs , then we can use determined by our heuristic values. It may be possible to plan
this upper bound to influence the sampling process used by a path around this obstacle, but finding such a path may be
the RRT algorithm. Rather than randomly sampling the entire difficult using our restricted sampling approach, as very few
configuration space, we restrict our sampling to just those samples exist that will pull the tree towards this edge. Thus,
areas of the configuration space that could possible provide it is important to use conservative heuristic estimates and not
a solution satisfying the upper bound. Given a node qtarget in disregard points that reside in configuration space obstacles.
the configuration space, we can check whether qtarget could One way of implementing this restricted sampling idea is to
be part of such a solution by calculating a heuristic cost continue generating random samples qtarget from the configu-
from the initial node qstart to qtarget , h(qstart , qtarget ), as ration space until we find one whose combined heuristic cost is
well as a heuristic cost from qtarget to the goal node qgoal , less than our upper bound. This approach is illustrated in Fig.
h(qtarget , qgoal ). If these heuristic values do not overestimate 2(b). Another method is to use the heuristic functions to do
the costs of optimal paths between these nodes then the the sampling itself, so that every node sampled will satisfy the
combination of these heuristic values gives us a lower bound upper bound. On the whole, this restricted sampling technique
on the cost of any path from qstart through qtarget to qgoal . If saves us a lot of unnecessary computation spent on irrelevant
this lower bound cost is greater than our upper bound Cs , then areas of the configuration space.
there is no way qtarget could be part of a solution satisfying
our upper bound and so qtarget can be ignored. B. Node Selection
However, depending on the complexity of the configuration Once a sample node qtarget has been generated using the
space and what heuristics are used, this approach could make above technique, we then select a node from the tree qtree
it very difficult for the RRT to find a solution. For example, if to extend out towards the sample node. In the original RRT
there are narrow passages in the configuration space between algorithm, the closest node in the tree to qtarget is selected to
large obstacles, then it may be very difficult to sample nodes be qtree . However, as Urmson and Simmons show [6], much
inside the passages. This is a well-known problem with cheaper solutions can be obtained if we modify this selection
the original RRT algorithm, but it could be exacerbated by process to incorporate cost considerations.
disregarding any samples that fall inside configuration space Our selection approach is based on their ideas but uses
obstacles. Depending on how the heuristic deals with such bias factors to vary over time the influence of cost, so that

5371
 ReinitializeRRT(rrt T ) SelCost(rrt T, configuration q, configuration qtarget )
1 T .cleartree(); 1 return T.db · Distance(q, qtarget ) + T.cb · T.c(qstart , q);
2 T .add(qstart ); ExtendToTarget(rrt T, configuration qtarget )
GrowRRT(rrt T ) 2 Qnear = kNearestNeighbors(qtarget , k, T );
3 qnew = qstart ; time = 0; 3 while Qnear is not empty
4 while (Distance(qnew , qgoal ) > distance-threshold) 4 remove qtree with minimum SelCost(T, qtree , qtarget ) from Qnear ;
5 qtarget = ChooseTarget(T); 5 Qext = GenerateExtensions(qtree , qtarget );
6 if (qtarget = null) 6 qnew = argminq∈Qext c(qtree , q);
7 qnew = ExtendToTarget(qtarget , T ); 7 T.c(qstart , qnew ) = T.c(qstart , qtree ) + c(qtree , qnew );
8 if (qnew = null) 8 if (T.c(qstart , qnew ) + h(qnew , qgoal ) ≤ T.Cs )
9 T .add(qnew ); 9 return qnew ;
10 UpdateTime(time); 10 return null;
11 if (time > max-time-per-rrt) Main()
12 return null; 11 T.db = 1; T.cb = 0; T.Cs = ∞;
13 return T.c(qstart , qnew ); 12 forever
ChooseTarget(rrt T ) 13 ReinitializeRRT(T );
14 p = RandomReal([0.0, 1.0]); 14 T.Cn = GrowRRT(T );
15 if (p < goal-sampling-prob) 15 if (T.Cn = null)
16 return qgoal ; 16 PostCurrentSolution(T );
17 else 17 T.Cs = (1 − f ) · T.Cn ;
18 qnew = RandomConfiguration(); 18 T.db = T.db − δd ;
19 attempts = 0; 19 if (T.db < 0)
20 while (h(qstart , qnew ) + h(qnew , qgoal ) > T.Cs ) 20 T.db = 0;
21 qnew = RandomConfiguration(); 21 T.cb = T.cb + δc ;
22 attempts = attempts + 1; 22 if (T.cb > 1)
23 if (attempts > max-sample-attempts) 23 T.cb = 1;
24 return null;
25 return qnew ; Fig. 4. The Anytime RRT Algorithm: ExtendToTarget and Main Functions.

Fig. 3. The Anytime RRT Algorithm: GrowRRT and ChooseTarget Func-

tions. C. Node Extension
When a node in the tree is selected for extension, we take
initially nodes are selected based purely on their distance from into account the nature of the configuration space in its vicinity
qtarget , and in subsequent searches this gradually changes so to produce a new, low-cost branch of the tree. There are two
that some combination of distance from qtarget and the cost different approaches we use to do this. The first approach is
of the node is considered, eventually leading to purely cost- to generate a set of possible extensions that lead from the tree
based selection. We accomplish this by using a distance bias node qtree in the general direction of the sample node qtarget
parameter db and a cost bias parameter cb . First, the k nearest and then take the cheapest of these extensions. This results
neighbor nodes in the tree to qtarget are computed. Next, these in a new node qnew which is added to the tree if it could
nodes are ordered in increasing node selection cost: potentially contribute to a solution satisfying our upper bound
Cs , i.e., if
SelCost(q) = db · Distance(q, qtarget ) + cb · c(qstart , q),
c(qstart , qtree ) + c(qtree , qnew ) + h(qnew , qgoal ) ≤ Cs ,
where c(qstart , q) is the cost of the current path from qstart to
q in the tree. We then process these nodes in order until one is where c(qstart , qtree ) is the cost of the current path from
found from which a valid extension can be made (the extension qstart to qtree in the tree (as before), and c(qtree , qnew ) is
process is described below). Fig. 2(c) shows an illustration of the cost of the extension just constructed from qtree to qnew .
the node selection process. If qnew does not satisfy our solution bound then a new set
Initially, db = 1 and cb = 0 and so our node selection of extensions that do not lead as directly to the sample node
operates exactly as a nearest neighbor lookup. Between each is considered. This process continues, with each subsequent
successful search, db is reduced by some value δd and cb is set of extensions ‘fanning out’ further from the sample node,
increased by some value δc , so that the cost of the tree nodes until either a qnew is generated that satisfies our bound or
becomes increasingly important as time progresses. This has some maximum number of attempts have been made.
the effect of producing more costly solutions early on, when The second approach is to use a large initial set of possible
we are most concerned with ensuring that valid solutions are extensions and take the cheapest of these extensions. Again,
available, and then providing cheaper solutions if there is extra we check that the corresponding new node qnew satisfies our
time available for planning. solution bound before adding it to the tree. This approach is

5372
 (a) (b) (c) (d) (e)
Fig. 5. Anytime RRTs used for single robot path planning. The start node is the vehicle at the bottom of the environment, the goal is the square at the
top. Shaded regions represent higher-cost areas to traverse through; black regions represent obstacles. (a) Initial RRT generated without cost consideration.
(b) Fifth RRT generated, using costs of previous solutions and nodes of the current tree to bias the growth of the current tree. (c) Final RRT generated. (d)
Path corresponding to initial RRT from (a). (e) Path corresponding to final RRT from (c). These images correspond to the results presented in Fig. 7(a).

illustrated in Fig. 2(d). Because the first of these approaches is than Cs .

generally faster and the second produces less costly solutions,
Theorem 1. When the solution bound is Cs , the cost of any
both are useful in our anytime framework: the first can be used
solution generated by the Anytime RRT algorithm will be less
to efficiently produce RRTs at early stages of our planning,
than or equal to Cs .
while the second can be used to produce later trees with less
costly solutions. It can also be beneficial to include some By updating the solution bound each time a new path is
randomness in the extension operation: with some probability generated, the algorithm is also able to guarantee that the next
a random extension operation is selected and tested against solution will be better than the previous one, by at least our
our solution bound. user-defined solution improvement factor f .
Pseudocode of the basic Anytime RRT approach is given Theorem 2. Each time a solution is posted by the Anytime
in Figures 3 and 4. For space and simplicity we have not RRT algorithm, the cost of this solution will be less than (1 −
included all the features mentioned in the previous discussion. f ) times the cost of the previous solution posted.
In particular, our actual implementation begins by generating
a standard RRT and uses this to provide an initial solution Together, these properties ensure that solutions produced
and bound, and the ExtendToTarget function is modified over by the Anytime RRT algorithm improve over time and that
time to switch between our different extension approaches. the rate of improvement is at least as good as the solution
In the pseudocode, UpdateTime(time) increments an elapsed improvement factor f .
time counter, kNearestNeighbors(qtarget , k, T ) returns the Corollary 1. If f > 0 then the solutions posted by the
k closest nodes in the tree T to a sample node qtarget , Anytime RRT algorithm will have associated costs that are
GenerateExtensions generates a set of extension operations strictly decreasing. Moreover, these costs will decrease by at
(in the manner discussed earlier) and returns the nodes at least a factor of f between each successive solution.
the endpoints of these extensions, and PostCurrentSolution
publishes the current solution so that it can be executed if
deliberation time runs out. The plaintext identifiers (e.g. ‘num- IV. E XPERIMENTS AND R ESULTS
neighbors’) are constants. Other identifiers (e.g. db ) are as The primary motivation behind this work was efficient
described earlier, prefixed with the tree identifier T to illustrate multirobot path planning in non-uniform cost environments. In
that they are variables associated with the tree. particular, we are interested in constrained exploration, where
Because the Anytime RRT approach uses a solution bound a team of robots is tasked with exploring an environment while
to influence the growth of each RRT, it has a number of nice abiding by some constraints on their paths [10]. For instance,
properties. We include the major ones here; proofs of these imagine an environment containing areas through which no
can be found in [9]. Firstly, because the algorithm restricts communication is possible (due to eavesdropping adversaries
nodes added to the tree based on the solution bound Cs , it is or environmental characteristics), and the team must maintain
guaranteed not to produce any solution whose cost is greater line-of-sight communication at all times. RRTs are useful for

5373
Relative Cost

(a) (b) (c)

Fig. 7. Anytime RRT results. (a) Example results from a single run in one of the single robot environments. Shown are the RRT solution costs generated as
time progresses - the regular RRT approach does not use previous solution costs to influence the growth of future trees. (b,c) Average relative solution cost
as a function of time for our (b) single robot, and (c) three robot runs. The minimum-cost solution generated by each of the approaches (relative to the best
overall solution generated) is presented at each point in time.

Anytime RRT approach was recorded and all solution costs

were then computed relative to this cost.
Our second set of experiments had a similar setup, except
that we planned joint paths for a team of 3 agents and main-
tained a line-of-sight communication constraint over the entire
path. Again, we randomly generated 100 different non-uniform
cost environments, and the obstacles in the environment acted
as both navigation obstacles (i.e., no agent could have its path
intersect any of these obstacles) and communication obstacles
(i.e., if the direct line between two agents intersected one of
these obstacles at any point in the agents’ paths, line-of-sight
communication was broken between these agents). We allowed
the planner 10 seconds of planning time, and each individual
tree was allowed up to 2 seconds. Results from this second
set of experiments are shown in Fig. 7(c); as with the first
experiment, these results have been normalized.
For both these experiments, the Anytime RRT approach
began by growing a standard RRT using the standard nearest
neighbor and extension operators. Then, it slowly decreased
Fig. 6. Anytime RRTs used for multirobot constrained exploration. On the
left is one of the trees produced by our anytime approach. On the right is the db by δd = 0.1 each iteration and increased cb by δc = 0.1.
corresponding path. It switched its extension operator from the former approach
mentioned in Section III-C to the latter approach after the third
solution was found. f was set to 0.1 so that each successive
solving this problem because they cope well with the very solution was guaranteed to be 10% less costly than the pre-
high dimensional configuration space. vious solution. For our heuristics we used Euclidean distance
To analyse the performance of Anytime RRTs, we generated and our available extensions were straight-line segments for
two different sets of experiments. In the first, we planned each agent.
paths for a single agent across a 300 × 600 non-uniform cost There are a couple points worth noting from the results of
environment in which there was a set of randomly placed these experiments. Firstly, both the regular RRT approach and
obstacles and a set of randomly placed, random cost areas (see the Anytime RRT approach both start with the same solution
Fig. 5 for an example such environment). We compared the (the graphs start from the same point in the upper left), so
solutions generated by Anytime RRTs to those generated by a that both are able to provide an initial, valid solution in the
series of standard RRTs. Each approach was allowed to run for minimum possible time. This is important for occasions where
a total time of 2 seconds (on a 1.5 GHz Powerbook G4), and the available planning time may turn out to be very small and
each individual RRT was allowed to take up to 0.5 seconds. We an agent has to act quickly.
repeated this process for 100 different environments. Fig. 7(b) Secondly, the Anytime RRT approach produces much better
plots the average cost of the best solutions generated versus solutions, and is able to improve upon initial solutions much
planning time for these experiments. These results have been more quickly than the regular RRT approach. Overall, the best
normalized: for each run, the best solution produced by the solutions generated by the regular RRT approach at the end

5374
of the maximum time allowed for planning were on average It is also worth further investigating how heuristics can be
3.6 and 2.8 times more expensive than the corresponding most effectively used to focus the growth of the trees. For
Anytime RRT solutions for the single agent and multi-agent example, over the course of our experiments we have found
cases, respectively. But the intermediate solutions produced by that when the heuristic is not very informed, inflating the
Anytime RRTs were also much better: Anytime RRTs were heuristic values of nodes close to the root can prevent the
able to quickly and continually reduce the solution cost so RRTs from growing into ‘dead ends’, where no new nodes can
that at any point in time they provided less costly solutions. be added because the early nodes were too expensive. Using
To provide a more detailed look at the behavior of each information from previous searches and the current search to
approach during a single run, Fig. 7(a) shows the results for improve the heuristic estimates may be an even more effective
a single environment in our single agent planning scenario. approach. Finally, we are implementing the approach on a
Here, we have plotted the most recent solution cost versus team of autonomous John Deere E-Gator vehicles for outdoor
time over the course of planning. This graph shows the costs of constrained exploration.
the solutions generated by the Anytime RRT approach strictly
decreasing over time, while the solutions produced by the VI. ACKNOWLEDGEMENTS
regular RRT approach vary widely in cost and do not exhibit This work was sponsored by the U.S. Army Research Lab-
any general improvement. The environment from which these oratory, under contract ”Robotics Collaborative Technology
results came, along with some of the trees and solutions Alliance” (contract number DAAD19-01-2-0012). The views
produced by the Anytime RRT approach, are illustrated in and conclusions contained in this document are those of the
Fig. 5. authors and should not be interpreted as representing the
official policies or endorsements of the U.S. Government.
V. D ISCUSSION
Dave Ferguson is supported in part by a National Science
One of the most significant limitations of sampling-based Foundation Graduate Research Fellowship.
planners to date has been their inability to provide high quality
solutions or even bounds on the suboptimality of the solutions R EFERENCES
generated. In this work, we have presented techniques that
[1] S. LaValle and J. Kuffner, “Randomized kinodynamic planning,” In-
are very effective at biasing sampling-based planners in favor ternational Journal of Robotics Research, vol. 20, no. 5, pp. 378–400,
of better solutions. These techniques are extremely useful 2001.
for producing low cost solutions in non-uniform cost search [2] ——, “Rapidly-exploring Random Trees: Progress and prospects,” Al-
gorithmic and Computational Robotics: New Directions, pp. 293–308,
spaces. Further, we have shown how these techniques can be 2001.
incorporated into an anytime sampling-based planner that not [3] M. Kobilarov and G. Sukhatme, “Time Optimal Path Planning on
only improves its solution over time, but can provide (and Outdoor Terrain for Mobile Robots under Dynamic Constraints,” in
Proceedings of the IEEE International Conference on Intelligent Robots
accept) bounds on the quality of this improvement. and Systems (IROS), 2004.
Our anytime approach generates a series of RRTs, each [4] J. Kim and J. Ostrowski, “Motion planning of aerial robots using
producing a new solution that is guaranteed to be less expen- Rapidly-exploring Random Trees with dynamic constraints,” in Proceed-
ings of the IEEE International Conference on Robotics and Automation
sive than the previous solution by a user-defined improvement (ICRA), 2003.
factor f . Thus, a valid solution is returned as quickly as by [5] J. Kuffner, K. Nishiwaki, S. Kagami, M. Inaba, and H. Inoue, “Motion
the standard RRT algorithm, but the quality of this solution planning for humanoid robots,” in Proceedings of the International
Symposium on Robotics Research (ISRR), 2003.
is then improved while deliberation time allows. The result- [6] C. Urmson and R. Simmons, “Approaches for heuristically biasing
ing algorithm provides similar benefits as recently-developed RRT growth,” in Proceedings of the IEEE International Conference on
discrete anytime algorithms, but is able to plan over much Intelligent Robots and Systems (IROS), 2003.
[7] M. Likhachev, G. Gordon, and S. Thrun, “ARA*: Anytime A* with
larger, higher-dimensional search spaces. We have provided provable bounds on sub-optimality,” in Advances in Neural Information
key properties of the algorithm including relative bounds on Processing Systems. MIT Press, 2003.
the quality of the solutions generated, and have demonstrated [8] R. Zhou and E. Hansen, “Multiple sequence alignment using A*,”
in Proceedings of the National Conference on Artificial Intelligence
its effectiveness for both single agent navigation and multi- (AAAI), 2002, Student abstract.
agent constrained exploration. [9] D. Ferguson and A. Stentz, “Anytime RRTs: The Proofs,” Carnegie
We are currently investigating a number of extensions to Mellon School of Computer Science, Tech. Rep. CMU-RI-TR-06-07,
2006.
this work. Firstly, it may be possible to exploit even more [10] N. Kalra, D. Ferguson, and A. Stentz, “Constrained Exploration for
information from previous solutions to aid in the generation Studies in Multirobot Coordination,” in Proceedings of the IEEE In-
of new ones, such as low cost branches of previous RRTs or ternational Conference on Robotics and Automation (ICRA), 2006.
[11] B. Burns and O. Brock, “Toward optimal configuration space sampling,”
extracted knowledge concerning the nature of the configuration in Proceedings of Robotics: Science and Systems (RSS), 2005.
space (e.g. as in [11] but with cost considerations).

5375