Path Planning for Mobile Robots

Path Planning for Mobile Robots

Sriraj Gowthaman Srilakshmi

U5025162

Project Supervisor: Dr. Jonghyuk Kim

ENGN2706 – Research & Development Project (Methods)

Submission Date: 16 November 2012

Sriraj Gowthaman Srilakshmi R&D Thesis u5025162

i

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.


ii

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


iii

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


1

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.


2

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.


3

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].


4

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


5

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


6

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


7

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


8

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.


9

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.


10

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 Coordinate

Goal Coordinate

Computation Time

Path Length

Optimal Length

Optimality Comments

(2,6) (4,8) 0.51s 2.82 2.82 100 % diagonal

path

(2,6) (4,4) 0.50s 2.82 2.82 100 % diagonal

path

(2,11) (7,9) 0.63s 5.82 5.82 100 % turns

involved

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.

i

g


11

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% -

(3,10) (2,6) 0.54s 4.41 4.41 100 % Reverse of previous

(2,6) (11,8) 0.92s 10.64 10.64 100 % -

(2,6) (8,6) 1.1s 10.82 9.64 89.09 % -


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%.

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

i g g i


12

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

(2,6) (9,11) 1.68s 11.87 9.64 81.21 % Complex

turns


(2,6) (11,2) 1.4s 21.46 16.64 77.54 % Complex

navigation

(11,2) (2,6) 1.6s 19.46 16.64 85.51 % Reverse of 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%.

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

i

g i

g


13

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

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.

i

g


14

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

(2,50) (36,30) 6.378s YES Minor

obstruction

(2,50) (76,60) 61.266s NO Large central

obstacle

(76,60) (2,50) 51.175s YES Reverse of previous

(2,50) (76,75) 35.327s YES Easy

navigation

(2,50) (76,68) 42.5s NO Minor

obstruction


(2,50) (25,95) 13.2s NO Single small

obstacle


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.

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

i

g i

g


15

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

(2,50) (101,70) 54.9s NO Medium

complexity

(101,70) (2,50) 93s NO Reverse of 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.

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.

i

g i

g


16

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.


17

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.


18

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


19

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.


20

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.


21

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.

(-3.5, 0) (-2.5, 3) 2.507s Mostly straight before bend in end. ~95%

optimal.

(-4.5, -4.5) (1, -2.5) 3.328s Few slight bends. ~95% optimal. Better than Cell Decomposition Method (CDM)

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.

i

g


22

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

(-4.5, 0) (1.5, -1.5) 127.936s Sub-optimal path. Lots of confusion with

navigation near the obstacle.

(1.5, -1.5) (-4.5, 0) 6.777s Reverse path of previous. Even more sub-optimal with path going around in circles.

(-4.5, 0) (1.5, 0.5) 261.896s Lots of confusion around obstacle with

too much time and distance wasted.

(1.5, 0.5) (-4.5, 0) 47.22s Reverse path of previous and much better

result. Still has some loops though.

(-4.5, 0) (-3.5, -3.5) 2.577s Path zig-zags slightly but very quickly

generated and ~90% optimal.

(-4.5, 0) (4.5, -1.5) 16.899s Extremely similar to path computed by

CDM with better resolution.

(4.5, -1.5) (-4.5, 0) 670.377s Reverse path of previous. This time runs

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.

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

i g i g


23

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

(-4.5, 0) (2.5, -4.5) 26.011s Little bit of problem going around the

obstacle like seen before.

(2.5, -4.5) (-4.5, 0) 5.097s Reverse path of previous. Much better

result; about ~85% optimal.

(-2.5, 4.5) (4.5, -4.5) 216.364s Highly complex path but very good result.

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.

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

i

g i

g


24

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.


25

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


26

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


27

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.


28

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.


29

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.


30

[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.

Education

Path Planning for Mobile Robots