This project focuses on path planning for mobile robots, specifically evaluating two algorithms: the cell decomposition method and rapidly-exploring random trees (RRT). It highlights the importance of understanding the differences between these approaches to select the most suitable planner for navigation tasks, demonstrating a trade-off between computation time and path optimality. The study also suggests future improvements and possible extensions to include other algorithms in the evolving field of robotics.

1. Path Planning for Mobile Robots
Sriraj Gowthaman Srilakshmi
U5025162
Project Supervisor: Dr. Jonghyuk Kim
ENGN2706 – Research & Development Project
(Methods)
Submission Date: 16 November 2012

2. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
Abstract
The path planning problem is important in developing autonomous navigation robots
where a route to a specified goal needs to be computed while avoiding obstacles in the
environment. With the development of various algorithms to tackle this problem over
years of research, it is critical for a user to understand the differences between them in
order to choose the most suitable planner for their application. This study implemented 2
industry-standard algorithms, the Cell Decomposition Method and Rapidly-Exploring
Random Trees, and evaluated their performance.
Further, both the algorithms were also compared head-to-head and it was hence found
that a trade-off between computation time and path optimality is the key differentiator
between them. Finally, there are also some suggestions discussed in order to improve
both the planners’ current performance. This study can also be extended in the future to
include other widely used approaches like the Probabilistic Roadmap and Potential Field
Methods.
i

3. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
Table of Contents
1. Aims and Contributions .......................................................................................................... 1
2. Introduction ............................................................................................................................ 2
3. Literature Review.................................................................................................................... 3
4. Cell Decomposition Method ................................................................................................... 6
4.1. Theoretical Background ................................................................................................... 6
4.2. Pseudocode ..................................................................................................................... 7
4.3. Experimental procedure .................................................................................................. 8
4.4. Results and Discussion................................................................................................... 10
4.4.1. 12x12 resolution grid environment ........................................................................ 10
4.4.2. 120x120 resolution grid environment .................................................................... 13
4.4.3. Discussion of observations ..................................................................................... 16
4.5. Future improvements to be considered........................................................................ 17
5. Rapidly-Exploring Random Trees .......................................................................................... 18
5.1. Theoretical Background ................................................................................................. 18
5.2. Pseudocode ................................................................................................................... 19
5.3. Experimental procedure ................................................................................................ 20
5.4. Results and Discussion................................................................................................... 21
5.4.1. Obstacle-free paths ................................................................................................ 21
5.4.2. Paths involving 1 obstacle ...................................................................................... 22
5.4.3. Paths involving 2 or more obstacles ....................................................................... 23
5.4.4. Discussion of observations ..................................................................................... 24
5.5. Future improvements to be considered........................................................................ 26
6. Comparison of the CDM and RRT approaches ..................................................................... 27
7. Conclusion ............................................................................................................................ 28
8. Bibliography .......................................................................................................................... 29
ii

4. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
List of Tables
Table 1: Simulation data for paths with 0 obstacles in a 12x12 environment ......................... 10
Table 2: Simulation data for paths with 1 obstacle in a 12x12 environment .......................... 11
Table 3: Simulation data for paths with 2 or more obstacles in a 12x12 environment ........... 12
Table 4: Simulation data for paths with 0 obstacles in a 120x120 environment ..................... 13
Table 5: Simulation data for paths with 1 obstacle in a 120x120 environment ...................... 14
Table 6: Simulation data for paths with 2 or more obstacles in a 120x120 environment ....... 15
Table 7: Simulation data for paths with 0 obstacles using RRTs .............................................. 21
Table 8: Simulation data for paths with 1 obstacle using RRTs ............................................... 22
Table 9: Simulation data for paths with 2 or more obstacles using RRTs ................................ 23
List of Figures
Figure 1: Environment designed for testing of path planning algorithms ................................. 9
Figure 2: Computed result for a path with 0 obstacles in a 12x12 environment .................... 10
Figure 3: Computed results for paths with 1 obstacle in a 12x12 environment ...................... 11
Figure 4: Computed results for paths with 2 or more obstacles in a 12x12 environment ...... 12
Figure 5: Computed result for a path with 0 obstacles in a 120x120 environment ................ 13
Figure 6: Computed results for paths with 1 obstacle in a 120x120 environment .................. 14
Figure 7: Computed results for paths with 2 or more obstacles in a 120x120 environment .. 15
Figure 8: Expected planning steps in optimising the algorithm ............................................... 18
Figure 9: The effect of increasing area sampling density of an RRT by increasing the number
of iterations from n=1 to n=8 .................................................................................................. 20
Figure 10: Computed result for a path with 0 obstacles using RRT ......................................... 21
Figure 11: Computed results for paths with 1 obstacle using RRTs ......................................... 22
Figure 12: Computed results for paths with 2 or more obstacles using RRTs ......................... 23
Figure 13: Head-to-head comparison of the CDM and RRT approaches ................................. 27
iii

5. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
1. Aims and Contributions
The current work involving path planning techniques for use in mobile robots was
primarily a simulation project which sought to replicate results from previously developed
algorithms in the field. The aim of this project was to investigate current state-of-the-art
path planning algorithms being used in the industry and understand the principles behind
their operation. Further, 2 particular algorithms were chosen to be implemented in a
MATLAB environment for simulation and analysis of their performances.
The 2 algorithms chosen for simulation in this project were the A* algorithm incorporated
with the Cell Decomposition Method and Rapidly-Exploring Random Trees (RRTs) each.
The student contribution to this work was in the implementation of these algorithms
using the MATLAB language and interface based on the understanding of the algorithms’
methods and pseudocodes. Further, once the algorithms were implemented, suitable
code for rendering the visual output of the environment was also written. Finally, the
algorithms were tested using different variables to assess their performance.
The final outcome of the project was that both the CDM and RRT approaches were fully
implemented using the A* search algorithm. Apart from testing the performance of both
these approaches independently with varying environment conditions, they were also
finally compared head-to-head to evaluate their relative performance.
Further, there were several new skills learnt during the project of which the acquisition of
the basic research methods was the foremost and most important one. By conducting a
detailed literature review of the path planning field, I learnt about the different
approaches and algorithms used for the path planning problem and also the theoretical
basis for mathematically modelling it. Further, in proceeding to implement the chosen
algorithms, I learnt a lot about using the MATLAB programming language and interface as
well which could be important in future engineering applications as well. Finally, after the
implementation of the algorithms, I learnt how to design experiments to analyse the
performance of an algorithm by controlling variables in a simulated environment.
1

6. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
2. Introduction
Since the field of robotics was kick-started in 1956 with the first commercial robot from
Unimation [1,2], researchers have constantly been in pursuit of creating completely
autonomous robots. Autonomous robots are such that they can undertake high-level
tasks and processes and accomplish them without the need for any human intervention
[3,4]. In other words, they possess sufficient artificial intelligence to operate
independently so that the user only needs to specify a command and the robot will be
able to identify how to accomplish it using its own intelligence.
The mission to create autonomous robots stimulates several open-ended problems to be
solved in order to develop their artificial intelligence. One of these issues under
investigation is path planning for a mobile robot [3]. Most commercial robots used in
industry have to accomplish their tasks by either moving themselves or parts like
manipulator arms and actuators. For this, the robot needs to have the ability to plan what
motions it needs to undertake to achieve its goal position(s) without colliding with any
obstacles in the workspace [3,5].
Previous research in the field of path planning has led to the development of various
algorithms using different approaches to tackle this problem [6]. It is therefore natural
that one may wonder which of these would be the best to implement in their robot. The
answer lies in the subtle fact that obtaining a perfectly efficient path planning algorithm
has little chance of success given that numerous constraints and properties vary between
different workspace environments [7]. Therefore, it is crucial to identify which of the
approaches is most suitable for the conditions the user intends to operate the robot in.
However, the last comparative study on the different path planning algorithms was
written a few years ago in 1992 [6]. Considering that the research landscape has further
developed since then, especially with the introduction of the new RRT method [7],
present users would need more information to identify a suitable path planner for
implementing an autonomous navigation robot. Therefore, the current need of the day
would be for a comparative study investigating the properties of the current industry-
standard algorithms. This project aims to take a step towards this direction by studying
the performance of 2 different approaches.
2

7. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
The algorithms chosen in this study incorporate the cell decomposition method and
rapidly-exploring random trees. Since we are only concerned with the study of the path
planner’s performance, it will be assumed that a map of the environment and the robot’s
position are already known to the robot from other mapping systems. Under these
constraints, the chosen algorithms will be simulated in a MATLAB environment and their
performance will be investigated and compared.
In the following sections of the report, a literature review will be presented to summarise
the previous research in this field and then the technical details of the study will be
discussed. In each chapter covering the particular algorithm in focus, a short theoretical
background will be provided before the implementation details and experimentation
results are discussed.
3. Literature Review
The concept of path planning is very closely related to the mathematical problem of
finding the shortest route between two points in a network which has been studied by
mathematicians from a much earlier time in the form of the popular ‘Piano Mover’s
Problem’ [8]. The computationally most efficient procedure for the shortest path between
a specified pair of nodes in a network was first described by Dijkstra in 1956 who used the
principle of successive approximation to solve it [9]. Due to the algorithm’s fast running
time, it gained popularity amidst different fields and is now generally formalised as
Dijkstra’s algorithm.
The problem of path planning in relevance to robotics (which is encapsulated under the
subject of motion planning) was first formally encountered by a team of researchers from
the Stanford Research Institute as they worked on developing a robot called Shakey for
navigating a room with obstacles [10]. In 1968, they first suggested a heuristic approach
to determine the minimum cost paths for the robot to navigate [11]. Applying this new
approach to Dijkstra’s algorithm which was currently in use, they suggested some
significant improvements to develop the A* algorithm which could run faster to obtain the
optimal solution [12]. This algorithm marked a significant step to this field such that it is
still the most popular algorithm in use [3].
3

8. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
In an attempt to further develop the grid-based approach of the A* algorithm, Udupa
pioneered the concept of shrinking the robot to a point representation on the grid in 1977
[13]. This proved to be a major development as it finally led to the formulation of the
geometrical theory behind motion planning and boosted future study and research in this
subject [3]. This idea was almost immediately exploited in a systematic fashion as it led to
the development of the first path planning algorithm for polyhedral robots and obstacles
by Lozano-Perez and Wesley [14]. Their work is widely considered to be the first
contribution to the exact study of motion planning as it had not been identified as a
unique field prior to this development [3].
The ability to represent robots and obstacles as points or polygons in grid coordinates led
to the birth of the notion of configuration space. A configuration of a robot is a
specification of its position and orientation in its workspace and its configuration space is
the mathematical space of all such possible configurations [5]. The development of this
formal mathematical basis for the robot and environment specification has made it easier
for researchers to apply the knowledge of linear algebra and geometry to the study of
path planning.
Using the above geometrical basis, Lozano-Perez proceeded to introduce the principle of
the approximate cell decomposition approach [15] which is the first of the 4 different path
planning approaches identified currently. The basic idea behind this method is to sub-
divide the free space of the robot’s configuration into smaller polygonal cells [15]. The
unique feature however lies in the fact that each cell will continue to be recursively
subdivided till it is found that every cell in the space is known to be either completely full
(with an obstacle) or empty [16]. While the polygonal cells can introduce inaccuracies in
the exact shape of the obstacle, the advantage is that we can gain a finer resolution only
in spaces where needed which saves computational complexity. After this decomposition,
a connectivity graph is established to identify the adjacency relationships between the
cells [15]. Using this graph, a channel and path can subsequently be obtained by linking
adjacent cells in the goal direction.
Though the above method feels intuitive to a person given the geometric data, it is not
necessarily the only way to interpret the information. While Lozano-Perez constructed the
cell decomposition approach, Khatib explored a radically different approach in parallel
4

9. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
which led to the pioneering of potential field methods [17]. This approach treats the
robot’s point representation in the configuration space as a particle under the influence of
a potential field generated by the structure of its surroundings [17]. Obstacles in the free
space will generate a repulsive potential force on the robot while the goal position has
attractive potential. Therefore, the motion of the robot at any given time is guided by the
potential field at its present location [16].
Though the localised nature of this method affects the actual success rate of the planner
to find a path even when available, its real-time efficiency in saving computation time
makes it a viable approach to study and develop further [18]. This motivated Barraquand
and Latombe to develop a planner integrating both the cell decomposition and potential
field approaches discussed above [18]. They applied a Monte Carlo technique which
escaped the local minima by executing randomised Brownian motions [18]. This resulted
in an improvement of the original algorithm’s performance in terms of speed and
handling multiple Degrees of Freedom [18].
The geometrical concepts of the configuration space and polyhedral obstacles have also
motivated further research into exploiting them and a further approach developed to
tackle the path planning problem is the probabilistic roadmap (PRM) method. This
approach pioneered by Kavraki uses the principles of configuration space and a
continuous path by connecting all the vertices of the polyhedral obstacles with each other
using line segments [19]. This set of paths is called the roadmap and the program searches
for a continuous path between the initial and goal positions in this free space. If more
than one continuous path is identified in this search, Dijkstra’s algorithm is used to select
the optimal one [16].
Though the above mentioned approaches have led to the development of successful
algorithms, they cannot be easily extended to path planning problems with non-
holonomic constraints [7] which involve the dynamics of the robot and environment. In a
search to address this issue, LaValle was led to the pioneering of the Rapidly-Exploring
Random Tree (RRT) approach which is relatively new in this field [7].
Random trees are a data structure is computer science which grow and connect different
vertices with line segments using randomised variables [20]. Therefore, they essentially
represent an exploration of unknown area starting from a single point and branching out
5

10. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
in random directions. However, a problem with most trees is that their growth pattern
tends to be heavily biased in the direction of spaces already explored [7]. In LaValle’s
words, this can be practically understood using the analogy of a random walk a human
takes which will also bias towards familiar places already visited. Therefore, the final
outcome would reflect that the tree is not actually randomly exploring new spaces.
LaValle addressed this issue in his development of RRTs by using a Monte Carlo technique
to bias the tree’s search into the largest Voronoi regions (undecomposed spaces) [7]. This
alteration results in a tree which is more effective in filling the spaces of the area to be
explored. Therefore, these trees perform very efficiently in searching high-dimensional
spaces for robot path planning [21]. Hence, the promising properties of this approach
motivates further research into it as the method is still relatively new in use.
4. Cell Decomposition Method
4.1. Theoretical Background
This approach uses geometrical and algebraic techniques to process the workspace
information and since this tends to be highly intuitive to most people, it is one of the most
popular approaches to the path planning problem [3]. The basic principle behind the cell
decomposition method is, as described by its name, to decompose or sub-divide the
configuration space of the robot into polygonal cells [15]. Once the workspace has been
divided into cells, each cell can be classified as either being a non-traversable obstacle or a
free space with specific traversal costs through it.
Once such an occupancy grid has been created, a graph or node searching algorithm can
be used to find a path within this free space. In this project, the A* algorithm is used for
this purpose since it is currently the most widely-used in the industry [3, 22]. The A*
algorithm is a pathfinding and graph traversal algorithm which was first described by
Peter Hart, Nils Nilsson and Bertram Raphael in 1972 [12]. It extends the principles of
Dijkstra’s path searching algorithm by using heuristic functions.
The path finding problem is basically one where a robot is required to navigate between
specified starting and goal coordinates in an environment which may be filled with
6

11. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
obstacles. Therefore, the robot needs to acquire knowledge of the positions of the
obstacles to plan a path which traverses completely through the free space.
The A* algorithm uses a one-step look-ahead function to identify such obstacles and plan
the robot’s movements [12]. The first step in the implementation of the algorithm is to
identify a cost function to be used in the grid-based map environment. This cost function
which measures the expenditure in moving the robot from one point to the next could be
a function of distance, traversal time or combinations of both if known. Further a heuristic
cost function is also chosen which estimates the cost of traversing between the next
possible point in the path to the goal coordinate [23]. Therefore, the total cost of the path
will be the lowest possible sum of the cost of travelling to the next point and the heuristic
cost.
By calculating the lowest possible costs at each point of the robot’s position, the
algorithm is finally able to identify the path of lowest cost for the robot to travel between
the two initially specified coordinates. Therefore, it is quite obvious to see that the
definitions of the traversal costs and heuristic costs play an imperative role in the A*
algorithm.
4.2. Pseudocode
The pseudocode used to implement the A* algorithm is shown below.
OPEN = Ø
PARENTS = sstart
while (min sopen ≠ sgoal)
add neighbours of last PARENT to OPEN
for each of these neighbours
if current neighbour = any PARENT
total_cost = ∞
elseif current neighbour = obstacle
total_cost = ∞
else traversal_cost = cost of moving from last PARENT
to current neighbour
heurisitic_cost = estimated cost of moving from
current neighbour to sgoal
total_cost = traversal_cost + heuristic_cost
next_node = min (total_cost of current neighbours)
add next_node to PARENTS
return PARENTS list as shortest found path
7

12. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
The algorithm first starts with the creation of an empty OPEN set which contains all the
points already considered and tested by the algorithm. A PARENTS list is also initiated
which contains the points of the shortest calculated path. Initially, only the initial
coordinate belongs to this last.
Once these sets have been defined, as long as none of the OPEN points is already the goal
coordinate, the computational part is started. The last traversed point in the PARENTS list
is taken and all of its 8 neighbouring points are added to the open list. Then the total cost
of traversal for each neighbour is computed and the lowest possible cost is found.
The neighbour point which had the lowest traversal cost is then chosen as the next node.
In case there is more than 1 point with the lowest cost and there is a tie between points,
the last point used in the calculations is chosen as the next node. This next node as then
added to the parents list and the while loop continues. The algorithm terminates when
one of the points in the OPEN list is actually the goal coordinate. At this point, the
PARENTS list is returned as the shortest found path by the algorithm.
4.3. Experimental procedure
Once the cell decomposition method incorporating the A* algorithm was implemented in
a MATLAB environment (See Appendix A), the next step was to simulate it to gauge its
performance under varying conditions. The key independent variables identified to test
the algorithm were the number of obstacles in the path, the resolution of the grid
environment and the choice of the heuristic function. The dependent variable in all these
cases was the optimality of the computed path.
For this purpose, the first need was to create a suitable testing environment which could
accommodate all the 3 variables, especially the varying number of obstacles. Therefore, I
had to design a workspace which had regions where no obstacles would be encountered
while also having potential paths which could include 2 or more obstacles as well. Based
on this requirement, the following environment was developed for the robot.
8

13. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
Figure 1: Environment designed for testing of path planning algorithms
The above environment was constructed as a grid-based environment of 12x12 cells
initially and then 120x120 cells so that the independent variable of resolution could be
varied. Though the environment can theoretically be decomposed into cells of any
polygonal shape such as rectangles or hexagons [15], I chose to work with squares due to
their relative simplicity. Once the workspace was ready, a starting coordinate as well as a
goal coordinate could be specified in the program and the algorithm would compute and
return a path between those 2 points.
In order to vary the number of obstacles in the path, different starting and goal
coordinates in corresponding regions were specified in the experiments. For example,
obstacle-free paths were specified in the free space in the left-most side of the
environment. When multiple obstacles were required, the goal coordinate was placed in
the top-right corner to increase the complexity.
In order to quantify the performance of the algorithm, its computation time was
measured and the optimality of the path was also verified. In cases where the lengths of
the paths were able to be manually verified, the percentage optimality of the computed
paths was also measured.
9

14. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
4.4. Results and Discussion
4.4.1. 12x12 resolution grid environment
4.4.1.1. Obstacle-free paths
The first test with the A* algorithm was started in a 12x12 grid environment and had zero
obstacles involved. Under these constraints, 3 sets of data were computed and the
obtained measurements are summarised in Table 1.
Table 1: Simulation data for paths with 0 obstacles in a 12x12 environment
Start Goal Computation Path Optimal
Coordinate Coordinate Time Length Length Optimality Comments
diagonal
(2,6) (4,8) 0.51s 2.82 2.82 100 %
path
diagonal
(2,6) (4,4) 0.50s 2.82 2.82 100 %
path
turns
(2,11) (7,9) 0.63s 5.82 5.82 100 %
involved
g
i
Figure 2: Computed result for a path with 0 obstacles in a 12x12 environment
In the example shown above in Figure 2, the initial coordinate of the robot was chosen to
be (2,11) and the goal coordinate was specified as (7,9). In this case as well as all the other
obstacle-free instances, it was found that the optimality of the computed path was always
100%. Therefore, the A* algorithm works exactly as intended and always manages to find
the shortest path to the goal in terms of Euclidean distance. So the A* algorithm can be
effectively used in such obstacle-free scenarios.
10

15. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
4.4.1.2. Paths involving 1 obstacle
As the next incremental step, paths involving a solitary obstacle were simulated and the
results from the 6 data sets for this constraint have been summarised in Table 2.
Table 2: Simulation data for paths with 1 obstacle in a 12x12 environment
Optimality Comments
(2,6) (8,8) 0.71s 7.64 7.64 100 % -
(2,6) (3,10) 0.63s 5.23 4.41 84.32% -
Reverse of
(3,10) (2,6) 0.54s 4.41 4.41 100 %
previous
(2,6) (11,8) 0.92s 10.64 10.64 100 % -
(2,6) (8,6) 1.1s 10.82 9.64 89.09 % -
Reverse of
(8,6) (2,6) 0.86s 9.64 9.64 100 %
previous
In the 6 tests involving scenarios with 1 obstacle, 4 of the paths were computed optimally
and the overall average optimality returned by the algorithm was 95.57%.
i g g i
Figure 3: Computed results for paths with 1 obstacle in a 12x12 environment
In the examples shown above in Figure 3, the robot had to navigate between the
coordinates specified to be (2,6) and (8,6). However, in the leftmost case, the starting
coordinate was (2,6) and the goal coordinate was (8,6). This specification resulted in a
sub-optimal path as seen from the picture where the path’s optimality was only 89.09%.
However, when the starting and goal coordinates were reversed in the rightmost picture
in Figure 3, the algorithm managed to compute the most optimal path. This implies that
11

16. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
the complexity of the original path and the reverse path may not necessarily be the same
in all cases and therefore, we may get different path results for the same set of
coordinates depending on the direction of traversal. The same effect was also noticed in
the other sub-optimal data set in Table 2 where specifying the reverse direction resulted
in the computation of an optimal path.
4.4.1.3. Paths involving 2 or more obstacles
As a final step up in the complexity of the environment, paths involving multiple obstacles
were simulated and the results from 4 trials for this scenario are summarised in Table 3.
Table 3: Simulation data for paths with 2 or more obstacles in a 12x12 environment
Optimality Comments
Complex
(2,6) (9,11) 1.68s 11.87 9.64 81.21 %
turns
Reverse of
(9,11) (2,6) 0.866s 9.64 9.64 100 %
previous
Complex
(2,6) (11,2) 1.4s 21.46 16.64 77.54 %
navigation
Reverse of
(11,2) (2,6) 1.6s 19.46 16.64 85.51 %
previous
In the 4 trials above involving 2 or more obstacles, only 1 of the computed paths was
found to be perfectly optimal and the average path optimality achieved by the algorithm
was 86.07%.
g i
i g
Figure 4: Computed results for paths with 2 or more obstacles in a 12x12 environment
In the 2 examples depicted in Figure 4, the robot had to plan a path between the
coordinates (2,6) and (11,2). In the leftmost case, the starting coordinate was (2,6) and
the goal coordinate was specified to be (11,2) and the computed path was sub-optimal. In
12

17. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
the rightmost case, the starting and goal coordinates were reversed and while the
computed path was still sub-optimal, the degree of optimality improved slightly by almost
8%. This once again confirms the previously identified notion that the path between 2
points may have different complexity depending on the direction of traversal.
4.4.2. 120x120 resolution grid environment
4.4.2.1. Obstacle-free paths
The simulation data using the environmental constraints of a 120x120 grid and paths with
0 obstacles is summarised in Table 4. However, since manually verifying the optimal path
lengths in the larger 120x120 resolution grid was too tedious, the percentage optimality
of the computed path was not calculated in the following simulations. Instead, a binary
YES/NO check was used to confirm whether the computed path was optimal.
Table 4: Simulation data for paths with 0 obstacles in a 120x120 environment
Optimality Comments
(2,50) (36,70) 8.736s YES Diagonal path
(4,31) (36,79) 17.5s YES Diagonal path
i
g
Figure 5: Computed result for a path with 0 obstacles in a 120x120 environment
In the scenario depicted in Figure 5, the starting coordinate was specified as (4,31) and
the goal coordinate was (36,79). Just as it was found in the previous resolution
environment, all the paths computed involving obstacle-free cases were optimal even in
the higher resolution environment. Though this may seem sceptical at first look since the
computed path is not a straight line, a closer look will reveal that it is indeed the best
possible path under the constraints of the environment’s resolution. As expected, the
computation times were much higher using the larger grid.
13

18. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
4.4.2.2. Paths involving 1 obstacle
There were 8 trials conducted with paths containing a single obstacle in a 120x120
environment. The results from these tests are summarised in Table 5.
Table 5: Simulation data for paths with 1 obstacle in a 120x120 environment
Optimality Comments
Minor
(2,50) (36,30) 6.378s YES
obstruction
Large central
(2,50) (76,60) 61.266s NO
obstacle
Reverse of
(76,60) (2,50) 51.175s YES
previous
Easy
(2,50) (76,75) 35.327s YES
navigation
Minor
(2,50) (76,68) 42.5s NO
obstruction
Reverse of
(76,78) (2,50) 58.9s YES
previous
Single small
(2,50) (25,95) 13.2s NO
obstacle
Reverse of
(25,95) (2,50) 9.61s YES
previous
Out of the 8 trials done, 5 of the computed paths were found to completely optimal while
the others were sub-optimal to varying degrees.
i g
g
i
Figure 6: Computed results for paths with 1 obstacle in a 120x120 environment
In the examples shown in Figure 6, the navigation coordinates were specified as (2,50) and
(76,78). In the rightmost case, the goal coordinate was (76,78) while in the leftmost case
the goal coordinate was (2,50). While the rightmost case resulted in the computation of a
sub-optimal path, the leftmost one had an optimal path. Therefore, the phenomenon of
14

19. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
using the reverse path to decrease complexity and increase optimality was observed even
in the 120x120 resolution environments as well.
4.4.2.3. Paths involving 2 or more obstacles
Table 6: Simulation data for paths with 2 or more obstacles in a 120x120 environment
Optimality Comments
Medium
(2,50) (101,70) 54.9s NO
complexity
Reverse of
(101,70) (2,50) 93s NO
previous
There were only 2 trials done in the 120x120 environment for multiple paths and their
results are summarised in Table 6. In this case, it was found that none of the computed
paths were optimal at all.
i g
g
i
Figure 7: Computed results for paths with 2 or more obstacles in a 120x120 environment
In the examples shown in Figure 7 for this scenario, the specified coordinates were (2,50)
and (101,70). In the first case, the starting coordinate was (2,50) and the goal coordinate
was (101,70) and in the second case, the coordinates and direction were reversed. While
both of the computed paths in this case were sub-optimal, on this occasion it was
observed that reversing the direction worsened the optimality by a large degree since the
first case was only marginally inefficient. Therefore, reversing the path direction does not
necessarily help in all occasions.
15

20. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
4.4.3. Discussion of observations
Despite the several varying trials and results discussed in the experiments above, there
were a few common threads found between all of the results which will be discussed in
detail in the following sections.
4.4.3.1. Probabilistic Completeness
From all of the completed trials in the experimentation, the algorithm managed to find a
path (optimal or sub-optimal) whenever one existed in the environment. This property of
path planners is known as probabilistic completeness [3] and the therefore, it can be
concluded that the implemented algorithm is probabilistically complete. Therefore, if a
possible path exists, it will surely be found by the planner and if such a path does not
exist, failure will be reported.
4.4.3.2. Optimality in obstacle-free environments
Further, another observation from both the 12x12 and 120x120 grid resolutions was that
when given obstacle-free environments, the algorithm always computed the shortest and
most optimal path between the specified coordinates. Therefore, in simple environments,
there is no issue in using the above method to achieve perfect path optimality.
4.4.3.3. Sub-optimality in complex environments
However, when the complexity involving the obstacles in the environment increases, the
performance of the algorithm suffers and path optimality is affected. While the results of
the computed paths were reasonable in the 12x12 grid environment, as the resolution of
the grid was made finer, the degree of optimality worsened as the number of obstacles
were increased.
On analysis of the visual results of the computed paths obtained, it can be inferred that
the reason behind this sub-optimality is the fact that the heuristic function did not take
the presence of obstacles in the environment into account. The Euclidean heuristic
function implemented in the algorithm estimates the shortest possible distance between
a specified coordinate and the goal coordinate by computing the virtual straight-line
length between them [23]. However, this definition completely neglects the possibility
that the straight-line distance between the 2 points may have an obstacle between them.
16

21. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
This implementation meant that the algorithm behaved like what is commonly referred to
as a greedy best-first planner [3, 23]. That is, the algorithm always tried to use the
straightest possible path to the goal without realising an obstacle may be impeding its
way. It does not realise the presence of the obstacle until it is right next to it as the A*
algorithm uses a 1-step look-ahead. Therefore, the robot would have traversed an extra
unnecessary distance before reaching an obstacle and having to redirect itself.
4.5. Future improvements to be considered
In order to correct this issue of sub-optimality, there are a few options that could be
considered. The first possibility looked at was considering the reverse-path between the 2
specified coordinates. During the experimental trials, it was observed that the complexity
between the original and reverse paths can be different in most cases and even though
reversing the path cannot guarantee perfect optimality, it can improve the optimality in
most cases. Therefore, a viable option could be to ask the user to specify 2 coordinates
and compute paths for both the directions between them, compare the 2 paths and
finally return the most optimal of them. Though the computation time of the algorithm
will be more than doubled by this modification, it ensures that the output of the method
is maximised to the best of its ability.
Another option could be to use multiple-step look-aheads instead of the 1-step currently
implemented. This can help the robot identify an obstacle before-hand instead of only
finding it only when right next to it. However, a key question which arises here is how
many steps forward do we need to look? While a small number like 3 steps is enough in
small environments like the 12x12 grid, we would need to look ahead more than 10 times
that number in larger and finer grid environments. Therefore, the computation time of
the algorithm would increase by an extremely large amount and hence this option is not
viable.
However, the key problem was with the heuristic function not taking the obstacles into
account and both of the above options do not solve that particular issue. Therefore, the
best possible option is to develop a new heuristic function which can account for the
presence of obstacles in the environment. As of current research from the literature
review, there is no current heuristic function which accomplishes this.
17

22. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
Therefore, it is likely that a new algorithm would need to be developed for this purpose.
The rough background of this algorithm would be to first calculate the straight-line path
and check if it passes through an obstacle. If an obstacle is detected, a secondary path
could be constructed traversing around the boundary of the obstacle. However, this
secondary path will not be optimal yet.
Once this path is obtained, periodic samples from it can be extracted such as 1 in every 3
or 1 in 5 of the total points (See Figure 8b) depending on the length of the path and the
desired computational complexity. Finally, these sampled points can be used to construct
the final path by drawing straight-lines between each of them. Therefore, this method will
use the current heuristic function but attempt to optimise it step-by-step using obstacle
detection. While the final results can be expected to be as shown in Figure 8c, this
algorithm will have to be implemented and tested before we can make any conclusive
statements about its performance.
Figure 8: Expected planning steps in optimising the algorithm
5. Rapidly-Exploring Random Trees
5.1. Theoretical Background
Rapidly-Exploring Random Trees (referred to as RRTs from here on) are basically a kind of
data structure in computer science [20]. Inspired by biological trees, these data structures
start from a single node and branch out to various sub-nodes recursively and hence are
named after the more commonly known trees [20]. In this context of path planning, they
are used as a tool to aid us in the exploration of the configuration space and environment
around the robot [7].
When developed in conjunction by Steven LaValle and James Kuffner while at the Iowa
State University, the key motivation behind the creation of a new approach was to
18

23. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
accommodate the kinodynamic constraints of the robot into path planning [7]. In other
words, this algorithm can also take account of the robot’s velocity, acceleration or jerk
properties (if known) to plan a more realistic and smoother path with no sharp turns.
The basic principle behind this algorithm is to create a tree node at the specified starting
coordinate and then randomly branch out in all the directions to create further nodes in
the free space [7]. By the positioning of these sub-nodes, we indirectly gain an idea of the
positions of the obstacles in the environment and we can sample the free space to varying
densities. So while the previous cell decomposition method evenly sampled the space
using equally sub-divided geometric cells, RRTs sample the space unevenly and randomly
which reduces the computational complexity associated with arranging the cells.
Therefore, despite being given the same environment and starting/goal coordinates, no
two RRTs can be expected to be the same each time.
The generation and growth of the above tree is stopped once the goal coordinate has
been sampled as a sub-node of tree within a specified proximity. Once the RRT for the
given environment is established, a graph-searching or node-searching algorithm can be
used to search the branches of the tree to find the shortest possible path between the
starting and goal coordinates [7]. The A* algorithm used previously in the cell
decomposition method fits this need and hence, it can be used with the RRTs as well.
5.2. Pseudocode
GENERATE_RRT(sstart, K, Δt)
tree.init(sstart)
for n = 1 to K, do
srand RANDOM_STATE();
snear NEAREST_NEIGHBOR(srand, tree);
u SELECT_INPUT(srand, snear);
snew NEW_STATE(snear, u, Δt);
tree.add_vertex(snew);
tree.add_edge(snear, snew, u);
return tree
The pseudocode above grows a RRT originating at the point sstart with K branches per node
for every time step Δt. In each iteration, K random points (srand) are generated and
connected to the nearest node on the tree (snear). These points (snew) are then connected
to the tree with a branch representing the kinodynamic state (u) pertaining to the robot.
19

24. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
5.3. Experimental procedure
After the algorithm for the RRT approach was implemented (See Appendix B), its
performance has to be evaluated. The environment used to test the RRTs developed was
the same as that used for the Cell Decomposition Method (CDM) as well (See Figure 1).
While this is partly because this environment can accommodate varying number of
obstacles as discussed before, it also enables a justified means of comparison between
the 2 different methods implemented.
The key variables affecting the performance of a RRT are the number of obstacles in its
path and its growth parameters. These parameters include the number of branches per
node, the length of each branch and the number of iterations of growth. These growth
parameters primarily influence the area and density of the tree. For example, increasing
the branch length will increase the area covered by the tree while increasing the number
of branches or iterations increases the density of the tree as shown in Figure 9.
Figure 9: The effect of increasing area sampling density of an RRT by increasing the
number of iterations from n=1 to n=8 (view from L to R)
However, since the effects of changing these growth parameters are very difficult to
numerically compute due to the limited time available for this project, they will not be
experimented with in detail. After some preliminary informal simulation, the fixed
parameters used further for the growth of RRTs in this project are 4 branches per node, a
branch length of 3 units and iterations till the goal coordinate has been sampled.
Therefore, the only independent variable used in the experimentation with RRTs is the
number of obstacles in the specified path and the resulting dependent variable was the
optimality of the computed path.
20

25. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
5.4. Results and Discussion
5.4.1. Obstacle-free paths
The first test using the RRTs was carried out with paths with no obstacles and the results
from the simulations are summarised in Table 7. Due to the fact that the RRTs are
implemented on a continuous domain, manually calculating the path optimality is a
tedious task and hence the performance of the computation is holistically judged and
summarised in the comments.
Table 7: Simulation data for paths with 0 obstacles using RRTs
Optimality Comments
(-3.5, 0) (-2.5, 1.5) 1.833s More or less a straight line. ~99% optimal.
Mostly straight before bend in end. ~95%
(-3.5, 0) (-2.5, 3) 2.507s
optimal.
Few slight bends. ~95% optimal. Better
(-4.5, -4.5) (1, -2.5) 3.328s
than Cell Decomposition Method (CDM)
g
i
Figure 10: Computed result for a path with 0 obstacles using RRT
In the scenario depicted in Figure 10, the robot’s starting coordinate was from the
southwest corner of the environment to the edge of the nearest obstacle. From the
picture, it can be seen that the computed path is almost a straight-line. While this result is
theoretically sub-optimal since the shortest path is always a straight line in a continuous
domain, it is important to note that this computed path is much shorter in length than the
path computed using the Cell Decomposition Method (CDM). While the CDM’s path was
perfectly optimal within the constraint of its limited resolution, it was far from being a
straight line to the goal coordinate. Therefore, the RRT path is actually more optimal if
measured in terms of the length of the path.
21

26. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
5.4.2. Paths involving 1 obstacle
There were 7 trials carried out for the RRTs with paths consisting of a single obstacle. The
results from these tests are summarised in Table 8.
Table 8: Simulation data for paths with 1 obstacle using RRTs
Optimality Comments
Sub-optimal path. Lots of confusion with
(-4.5, 0) (1.5, -1.5) 127.936s
navigation near the obstacle.
Reverse path of previous. Even more sub-
(1.5, -1.5) (-4.5, 0) 6.777s
optimal with path going around in circles.
Lots of confusion around obstacle with
(-4.5, 0) (1.5, 0.5) 261.896s
too much time and distance wasted.
Reverse path of previous and much better
(1.5, 0.5) (-4.5, 0) 47.22s
result. Still has some loops though.
Path zig-zags slightly but very quickly
(-4.5, 0) (-3.5, -3.5) 2.577s
generated and ~90% optimal.
Extremely similar to path computed by
(-4.5, 0) (4.5, -1.5) 16.899s
CDM with better resolution.
Reverse path of previous. This time runs
(4.5, -1.5) (-4.5, 0) 670.377s
into problems near the obstacle as before.
When obstacles were introduced into the paths for the RRTs, it was found in most cases
that the planner ran into confusion in the proximity of the obstacles. The robot navigates
right next to the obstacle and then searches for a way past it. However, at this point, it
tends to move left and right in loops till it can get past it. This means that a lot of
computation time is spent trying to get past the obstacle and the robot also wastes
resources traversing an unnecessary amount of distance.
g i
i g
Figure 11: Computed results for paths with 1 obstacle using RRTs
In the examples shown in Figure 11, the navigation coordinates for the robot were (-4.5,0)
and (1.5,0.5). In the leftmost case, the starting coordinate is (-4.5,0) and this path is
22

27. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
reversed in the rightmost case. Though the path computed in the right has spent lesser
distance travelling in loops around the obstacle, both paths have run into the problem
discussed above. Therefore, unlike as observed in the case of the CDM, using reverse-
paths cannot always solve the problem caused by the heuristic function.
5.4.3. Paths involving 2 or more obstacles
For complex paths with multiple obstacles involved, there were 3 tests done and the
results from these are summarised in Table 9.
Table 9: Simulation data for paths with 2 or more obstacles using RRTs
Optimality Comments
Little bit of problem going around the
(-4.5, 0) (2.5, -4.5) 26.011s
obstacle like seen before.
Reverse path of previous. Much better
(2.5, -4.5) (-4.5, 0) 5.097s
result; about ~85% optimal.
Highly complex path but very good result.
(-2.5, 4.5) (4.5, -4.5) 216.364s
Roughly about ~90% optimal.
While the problem involving the heuristic function discussed above was observed in the
1st of the 3 trials, it was not as severe as seen before. This was probably because the
obstacle in this case was smaller in size than the previous tests which involved the largest
obstacle in the space. Therefore, the size and/or the boundary length of the obstacle can
be identified as a potential factor affecting the performance of the RRTs as well.
i g
g i
Figure 12: Computed results for paths with 2 or more obstacles using RRTs
In the scenarios depicted in Figure 12, the robot had to navigate between the points (2.5,
-4.5) and (-4.5,0). The leftmost case starts from the coordinate (2.5,-4.5) while the
direction is reversed in the other scenario. The travelling-in-loops problem can be
23

28. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
observed in the original path but the reverse path did not run into the problem. In fact,
the reverse path is very close to being an optimal one.
5.4.4. Discussion of observations
In the following sections, the common characteristic properties of the RRTs observed will
be discussed in detail.
5.4.4.1. Probabilistic Completeness
Just like as observed with the Cell Decomposition Method, the algorithm incorporating
the Rapidly-Exploring Random Trees is also probabilistically complete. This means that if a
path between the 2 specified coordinates exists in the environment, it will certainly be
found given finite time [3].
This is because the RRT propagates from the starting coordinate and grows in continuous
iterations till it is confirmed that the goal coordinate has been sampled as one of its
nodes. Therefore, once a RRT has finished growing, it is definite that both starting and end
points are part of its node network and since all of its nodes are only part of the free
space, it follows that a path will always exist between the 2 coordinates and the A*
algorithm will find it even if the computation takes a practically long time.
5.4.4.2. Perceived Sub-optimality
The key distinction between the CDM and the RRT approaches is in the sampling of the
free space. While the CDM decomposes the space into polygons and samples it in regular
discretized fashion, the RRT treats the space as a uniformly continuous domain and
samples it randomly. Therefore, if a RRT is grown to sufficient iterations as shown in
Figure 9, the free space is practically similar to an infinite resolution grid.
On such a continuous domain of points, the theoretical shortest path between 2 points is
always the straightest possible line between them. However, this is not true in the case of
a grid which is constrained by its resolution. This means that while some paths computed
using the CDM which were not straight-lines were theoretically optimal under its
resolution constraint. However, none of the paths computed using the RRTs were
theoretically optimal because none of them were a perfect straight-line.
24

29. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
However, when both the paths computed by the 2 different methods are compared, it is
found most often than not that the paths computed using the RRTs were shorter in length
than those computed using the CDM. Since real-life applications intend to minimize the
length of the path as much as possible, this result implies that the paths computed by the
RRTs were more optimal in terms of path length despite being theoretically sub-optimal.
5.4.4.3. Randomness of the RRT Approach
As the name of the approach implies, the trees in this method grow in a randomised
nature with every node being selected using MATLAB’s in-built rand function. Therefore,
this randomness is subsequently reflected in the computed results of the algorithm as
well. No two RRTs have a practical probability of being the same. Therefore, even if the
same 2 coordinates are specified to the algorithm for a path to be computed, each
simulation will generate a different path and have different computation times as well.
For example, it was noted during the simulation testing that 1 particular problem took
nearly 11 minutes to compute a path but when it was re-simulated once more, it took
only 17 seconds to generate a slightly different path. This is because each time the
algorithm is run, the tree grown might have different sampling densities or sampling area
and this sampling pattern affects the path that can be chosen. If the particular iteration
had a high sampling density, it is likely that a more optimal path can be found but the
computation time can be longer due to the higher number of points to be considered.
Therefore, the simulation data discussed previously in the results are indicative of only 1
possible random scenario and these results cannot be replicated again. So, if the same
experiments and run again, we are likely to obtain different data which can be either
better or worse than before. However, in the case of the CDM, the environment is
sampled regularly and therefore, repeated simulations will always return the same results
and this forms a distinction between the 2 approaches. Hence, the results obtained from
RRTs carry uncertainty around them and it is recommended that the results obtained
using this approach be treated with caution.
5.4.4.4. Problems involving the heuristic function
It was previously discussed in the Section 4.4.3.3 that the heuristic function implemented
in the A* search algorithm did not take the presence of obstacles into account [23]. Just
25

30. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
like how this resulted in the problem of sub-optimality in the paths computed using the
CDM, the RRT paths were also similarly affected.
As highlighted most vividly in Figure 11, the robot immediately heads straight in the
direction of the goal coordinate like a greedy best-first planner without realising that an
obstacle impedes that path. Therefore, when the robot reaches the vicinity of the
obstacle, it gets confused as to which direction it should head next to cross the obstacle.
This results in a series of sharp left and right movements in order to find a way out and
the heuristic function is unable to provide a clear answer to the algorithm.
While the planner will eventually find a way past due to its property of being
probabilistically complete, a lot of computation time and traversal cost is wasted in the
robot moving this unnecessary distance around the obstacle. In a real-life application
where traversal costs have to be minimized, this is an undesirable effect and the issue
needs to be addressed.
5.5. Future improvements to be considered
While the best possible way to correct the traversal problem discussed above is to
formulate a new heuristic function which can take obstacles into account (as explained in
Section 4.5), there are other possibilities that can be considered as well.
One option that could help is inspired by the Tabu Search approach developed by
researches previously in tackling the reactive path planning problem [24]. In this method,
the robot is banned (or tabooed) against reversing its direction once it has chosen to
move ahead in a particular one [24]. For example, if the robot has chosen its initial
direction of navigation along the 0° direction, it can next head in any direction except the
region covered between 150° and 210° since the 180° direction is exactly opposite to it.
This constraint on the robot’s movement means that if it is confused by the heuristic
function, it is forced not to run into haphazard loops to try and get out. Instead, an
alternative median direction is chosen and adhered to so that a smoother path with lesser
waste of resources can be found even if it may be sub-optimal. If this constraint can be
adopted into the algorithm for the RRTs as well, the problem of the robot repeatedly
turning left and right in loops near the obstacle can be avoided. We will be able to
26

31. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
constrain it to choose only 1 of the 2 directions and stay in that direction to compute a
path around the obstacle.
6. Comparison of the CDM and RRT approaches
Now that 2 different approaches to the path planning problem have been investigated,
implemented and tested, they can both be compared head-to-head in order to identify
their relative areas of strengths and weaknesses. In order to aid the qualitative
comparison, both methods were run in a complex environment involving multiple
obstacles to assess their relative performance as shown in Figure 13.
Figure 13: Head-to-head comparison of the CDM (Left) and RRT (Right) approaches
Interestingly, both the approaches computed roughly similar paths which are almost
optimal. However, the CDM approach needed 69.193 seconds to compute a result while
the RRT approach took 204.818 seconds which is nearly 3 times longer.
The RRT path is however more smoother and realistic due to the fact that its environment
is based on a continuous domain of points and hence has an infinitely fine resolution. The
CDM path’s environment had a resolution of 120x120 cells and hence, it has sharper turns
in it which could place kinematic constraints on the actual robot being used. If we did try
to implement the CDM using a much finer grid to try and match the effect of infinite
resolution, it would take much longer computation time than that currently achieved by
the RRT. But it should also be kept in mind that the randomised nature of the RRT means
there is uncertainty in being able to replicate its results.
To summarise this trade-off, the RRT approach has the potential to generate a smoother
and shorter path than the CDM approach but needs a much longer computation time.
27

32. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
7. Conclusion
From the implementation and testing of the Cell Decomposition Method and Rapidly-
Exploring Random Tree approaches to the path planning problem, it was found that both
algorithms work effectively for use in obstacle-free environments where the most optimal
possible paths are always computed. However when the complexity involving the
obstacles in the environment increases, the performance of both the algorithms start to
degrade. While they still compute reasonably effective paths for scenarios involving 1
obstacle, they tend to run into problems for larger number of obstacles.
This problem is mainly caused due to the heuristic function not taking the presence of
obstacles into account while searching for a path which means both algorithms act like
greedy best-first planners. While this can be overcome by formulating a new function
which can identify the presence of obstacles, a few simpler alternatives were also
suggested and discussed to improve the algorithms’ performance.
Finally when both the approaches were compared head-to-head, a key trade-off was
found to distinguish their relative performance. While the RRT approach has the potential
to compute more achievable, smoother and shorter paths than the CDM approach, it also
needs a much longer computation time to accomplish this. Therefore, if a user needs to
identify which path planner would be more suited to their needs, the relevance of this
trade-off to their environment must be considered.
If the scenario is such that shorter computation time is more important than the nature of
the path computed for the robot, the CDM approach is more attractive since its grid-
based approach simplifies the computation process. However if path optimality and
kinodynamic constraints are critical to the users’ needs, the RRT approach is more useful
due to the fact that it is implemented on a continuous domain of space which practically
resembles an infinite resolution.
However, in order to help users make better informed choices of path planners, this study
should also be extended in the future to investigate the performance of other available
approaches in the industry. Moreover, implementing the recommended improvements to
the currently investigated approaches can also improve their current performance and
thus shed more light on their relative characteristics.
28

33. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
8. Bibliography
[1] S.Y. Nof, Handbook of Industrial Robotics, 2nd ed. New Jersey: John Wiley & Sons,
1999, pp. 3 – 5.
[2] P. Mickle. (August, 2012). 1961: The first robot. Capital Century. [Online]. Available:
http://www.capitalcentury.com/1961.html
[3] J.C. Latombe, Robot Motion Planning. Boston: Kluwer Academic Publishers, 1991, pp.
1 - 6.
[4] G.A. Bekey, Autonomous Robots: From Biological Inspiration to Implementation and
Control. Boston: MIT Press, 2005, pp. xiii – xiv.
[5] M.W. Spong, S. Hutchinson, M. Vidyasagar, Robot Modelling and Control. New Jersey:
John Wiley & Sons, 2006, pp. 5 – 6.
[6] Y.K. Hwang and N. Ahuja, “Gross Motion Planning: A Survey”, ACM Computing
Surveys, vol. 24, (3), pp. 219 – 291, 1992.
[7] S.M. LaValle, “Rapidly-Exploring Random Trees: A New Tool for Path Planning”. TR 98-
11, Computer Science Department, Iowa State University, USA, 1998.
[8] J.T. Schwartz and M. Sharir, “On the Piano Mover’s Problem I: The Case of a Two-
Dimensional Rigid Polygonal Body Moving Amidst Polygonal Barriers”, dissertation,
Courant Institute of Mathematical Sciences, New York University, NY, USA, 1982.
[9] E.W. Dijkstra, “A note on two problems with connexion with graphs”, Numerische
Mathematik, vol. 1, (1) , pp. 269 – 271, 1959.
[10] Stanford Research Institute. (August, 2012). AI Center :: Shakey. SRI. [Online].
Available: http://www.ai.sri.com/shakey/
[11] P.E. Hart, N.J. Nilsson, B. Raphael, “ A Formal Basis for the Heuristic Determination of
Minimum Cost Paths”, IEEE Transactions on Systems Science and Cybernetics, vol. 4,
(2), pp. 100 – 107, 1968.
[12] P.E. Hart, N.J. Nilsson, B. Raphael, “Correction to a Formal Basis for the Heuristic
Determination of Minimum Cost Paths”, SIGART Newsletter, (37), pp. 28 – 29, 1972.
[13] S.M. Udupa, “Collision Detection and Avoidance in Computer Controlled
Manipulators” in Proceedings of the 5th joint international conference on Artificial
Intelligence, 1977, pp. 737 – 748.
[14] T. Lozano-Perez and M.A. Wesley, “An Algorithm for Planning Collision-Free Paths
Among Polyhedral Obstacles”, Communications of the ACM, vol. 22, (10), pp. 560 –
570, 1979.
[15] T. Lozano-Perez, “Spatial Planning: A Configuration Space Approach”, IEEE
Transactions on Computers, vol. C-31, (2), pp. 108 – 120, 1983.
29

34. Sriraj Gowthaman Srilakshmi R&D Thesis u5025162
[16] Computer Science Faculty. (August, 2012). Robotics: Motion Planning. Stanford
University. [Online]. Available: http://www-cs-
faculty.stanford.edu/~eroberts/courses/soco/projects/robotics/basicmotion.html
[17] O. Khatib, “Real-Time Obstacle Avoidance for Manipulators and Mobile Robots”, The
International Journal of Robotics Research, vol.5, (1), pp. 90 – 98, 1986.
[18] J. Barraquand and J.C. Latombe, “Robot Motion Planning: A Distributed
Representation Approach”, The International Journal of Robotics Research, vol. 10,
(6), pp. 628 – 649, 1991.
[19] L.E. Kavraki, P. Svestka, J.C. Latombe, M.H. Overmars, “Probabilistic roadmaps for
path planning in higher-dimensional configuration spaces”, IEEE Transactions on
Robotics and Automation, vol. 12, (4), pp. 566 – 580, 1996.
[20] D.E. Knuth, The Art of Computer Programming: Fundamental Algorithms, 3rd ed.
Boston: Addison-Wesley, 1997, pp. 308 – 423.
[21] S.M. LaValle and J.J. Kuffner, “Rapidly-Exploring Random Trees: Progress and
Prospects”, Algorithmic and Computational Robotics: New Directions, pp. 293 – 308,
2001.
[22] B. Siciliano, O. Khatib, Spirnger Handbook of Robotics. Berlin: Springer
Science+Business Media, 2008, pp. 109 – 128, pp. 827 – 850.
[23] A. Patel. (October, 2012). Amit’s A* Pages. Stanford University. [Online]. Available:
http://theory.stanford.edu/~amitp/GameProgramming/
[24] E. Masehian and M.R. Amin-Naseri, “Sensor-Based Robot Motion Planning – A Tabu
Search Approach”, IEEE Robotics and Automation Magazine, vol. 15, (2), pp. 48 – 57,
2008.
30