Batch Theta for path planning to the best goal in a goal set

Pursuing the solutions for robot path planning, this paper presents a variant of searching method Theta* for choosing the best goal among given goals and the lowest-cost path to it, call

Full Terms & Conditions of access and use can be found at http://www.tandfonline.com/action/journalInformation?journalCode=tadr20

Advanced Robotics

ISSN: 0169-1864 (Print) 1568-5535 (Online) Journal homepage: http://www.tandfonline.com/loi/tadr20

Batch-Theta* for path planning to the best goal in

a goal set Viet-Hung Dang, Nguyen Duc Thang, Hoang Huu Viet & Le Anh Tuan

To cite this article: Viet-Hung Dang, Nguyen Duc Thang, Hoang Huu Viet & Le Anh Tuan

(2015) Batch-Theta* for path planning to the best goal in a goal set, Advanced Robotics, 29:23, 1537-1550, DOI: 10.1080/01691864.2015.1073121

To link to this article: http://dx.doi.org/10.1080/01691864.2015.1073121

Published online: 08 Oct 2015

Submit your article to this journal

Article views: 70

View related articles

View Crossmark data

Vol 29, No 23, 1537–1550, http://dx.doi.org/10.1080/01691864.2015.1073121

FULL PAPER Batch-Theta* for path planning to the best goal in a goal set

Viet-Hung Danga∗, Nguyen Duc Thangb, Hoang Huu Vietcand Le Anh Tuand

a Institute of Research and Development, DuyTan University, Da Nang, Vietnam; b Department of Biomedical Engineering, International University, Vietnam National University-HiChiMinh City, Vietnam; c Department of Information Technology, Vinh University, Nghe An,

Vietnam; d Department of Automotive Engineering, Vietnam Maritime University, Hai Phong, Vietnam

(Received 20 November 2014; revised 7 July 2015; accepted 9 July 2015)

The development of 3D cameras and many navigation-supporting sensors has recently enabled robots to build their working maps and navigate accurately, making path planning popular not just on computer graphics, but in real environments as well Pursuing the solutions for robot path planning, this paper presents a variant of searching method Theta* for choosing the best goal among given goals and the lowest-cost path to it, called Batch-Theta* The novelty lies

at the proposed line-of-sight checking function during the searching process and the manner that the method handles the batch of goals during one search instead of repeatedly considering a single goal or blindly doing the exhausted search The analysis and simulations show that the proposed Batch-Theta* efficiently finds the lowest-cost path to the best goal

in a given goal set under Theta*’s mechanism

Keywords: shortest path; Batch-Theta*; Theta*; Lazy-Theta*; multi goals; goal set; line-of-sight

1 Introduction

Planning a path to a goal through a sequence of grid points

has been studied and implemented for decades Yet,

address-ing the shortest path plannaddress-ing problem from a position to the

nearest goal in a set of goals has not received much attention

in spite of its importance in a wide range of applications It

can be found in the tools for routing electronic circuits when

the software wants to wire a point to one of the others that

share the connectivity on a board It is also useful for most

strategy games such as Age-Of-Empire, Heroes, Star-Craft,

etc., in which the computer players must frequently make

wise decisions to find a short path to the nearest resource

mine from the house, choose where to retreat the troops for

medical aid, select the nearest safe market to go for trading,

or assign the workers to chase the nearest moving resource,

etc (by nearest we mean having the shortest non-collision

path in this paper) Because the computation for a real-time

strategy game is huge and the task is performed regularly,

even a slight improvement of reducing computational time

is crucial Moreover, path planning to one among several

goals is also necessary for robotics In specific applications,

robots are designed to serve food and beverages, collect

litter, or guide visitors in large sites like entertainment parks

These robots must be capable of figuring out the shortest

path to one among several desired positions such as

restau-rants, rubbish bins, or especially battery recharge stations

For automatic controls of moving indoors, the vehicles may

∗Corresponding author Email: dangviethungha@gmail.com

demand an optimal route through a set of targets selected

by a user, which can be solved with a greedy manner via iterations of planning the path to the best target in the set and dropping it out Besides, the problem can be found

in robots imposed by a coverage mission like cleaning, mowing, mine sweeping, or harvesting A workspace is usually decomposed into a grid where a robot needs to visit all of the accessible grid points Since this coverage mission

is an NP-hard problem [1,2] (a vertex must be visited at least once), approaches for coverage path planning so far have been using strategy motions such as spiral motion [3 5] or boustrophedon motion [6 8] to cover the workspace part by part After one strategy motion, the robot has to choose the nearest unvisited grid point for the next strategy motion

In another application of motion planning, a robot must find a set of consecutive connected configurations while avoiding blocked ones, usually by sampling-based motion planning methods.[9] In reality, although there are many target configurations, the robot needs to achieve only one Obviously, path planning to one among multiple goals is found in many important applications

Constructing the path to the best goal in a goal set must rely on the well-developed path planning techniques to one goal, which can be classified into two types: static plan-ning where the environment is assumed to be stable, and dynamic planning where the previous planning results are utilized for re-planning to deal with environment changes

For static planning approaches, Dijkstra [10,11] is the

sim-plest version that only uses cost values for the incremental

search to the nearest goal A* [12,13] improves Dijkstra

by adding heuristic evaluation to narrow the search space

However, the result returned by A* is commonly a zigzag

path through a set of neighboring grid points, which is

not effective for robot routing and controlling Many A*

variants have been developed to make the path found more

suitable in practice, that means the path does not connect a

set of adjacent points but a set of line-of-sight ones Some

use A* for the rough path, then smooth it up as in

A*-PS [14,15] while others insert the smoothing process into

the searching iterations like Theta*, consisting of

Basic-Theta* and Angle Propagation.[16,17] Theta* has then been

upgraded to Lazy-Theta* [18] in which the computational

cost is reduced because the line-of-sight calculation

be-tween a point and its parent is delayed until actually

nec-essary instead of being computed as soon as a new point

is added into the list of candidates to be expanded next

Overall, optimality is not guaranteed by Theta* and several

techniques have been introduced to improve Theta*’s path

lengths, like re-expanding points, changing the weight of

the heuristic value,[17] or using the visibility graphs for

the true shortest path.[19](chapter 15),[17] Nevertheless,

efforts of improving path length so far involve much

ad-ditional computation.[17] Meanwhile, dynamic planning

methods such as Lifelong Planning A* [20], D* [21],

D* Lite [22], Dynamic Fringe saving A* [23], blocked A*

[24], Filed D* [25], etc are mainly developed from A* In

fact, the dynamic methods always require a static path

plan-ning in both of the initializing and re-planplan-ning phases for

adapting to environment changes Therefore, although the

solution of finding the best path to the nearest goal like the

one proposed in this paper focuses on a static method, it can

be utilized to improve other dynamic planning approaches

as well when multiple goals are dealt with

Conventionally, determining the lowest cost path to the

best goal requires either an exhausted path search around

the starting point until the nearest goal is found or the

path search to each of the goals for later decision Both

approaches are inefficient because the number of expanded

points is high and many points are expanded more than once

Obviously, it is necessary to investigate a path planning

method that can mitigate this inefficiency while retaining

the loop structure of the techniques listed above to avoid

recursive search in big work spaces Specifically, at each

loop a new point is expanded, the path to it is updated,

and its neighbors are considered to be put in a waiting list

for further expansion In addition, the method must aim

at minimizing both path length results and searching time

as all path planning approaches do This paper presents a

new approach that fulfills the aforementioned requirements,

namely Batch-Theta*, to form a path from a starting point

to one among goals in a known squared grid 2D map In

such, all of the goals are considered in each loop and the

smoothing phase is constructed in parallel via iterations Moreover, a new development of line-of-sight checking and parent indicating is proposed to improve the performance of Theta*’s variants in terms of path length, expanded space size and runtime Analysis in Section 3, simulations and discussions in Section4show that Batch-Theta* gives better performance compared with other current best methods, which are reviewed in Section2

2 Backgrounds of heuristic path planning methods

Generally, static path planning methods like Dijkstra, A*, Theta*, and their variants share the main structure of Algorithm1, where the cost is commonly the path length since it is approximately proportional to other costs like fuel consumption or moving time These algorithms usually

have to maintain two main lists including open_li st and closed_li st while exploring the work space They

repeat-edly expand one point after another and consider adding

its neighbors into open_li st for further expansion The closed_li st stores all expanded points to ensure that no

point is expanded more than once Besides, a point’s re-lationships to the expanded points and the information of

the point’s cost f (s) are also stored and updated for

bet-ter paths through it The algorithms loop until the goal is

reached or open_li st is empty When the goal is found, by

tracing back along the points’ relationships, the path is

con-structed The two functions U pdate Relati on (s, parent) and U pdateCost Esti mati on (s, f ) examine whether the current expanded s is a better parent for sby the

measure-ment of f (s) If yes, they replace the previous parent and the total cost estimation of swith s and f (s), respectively.

In fact, A* is a generalized form of Dijkstra while Theta* [16,17] is an informed variant of A* Dijkstra chooses a point for expanding based only on the lowest cost from the

starting point to it, denoted with g (s) and called g-value,

which can be recursively presented by



g (s star t ) = 0

g

s

s =parent(s)



g (s) + cs , s , (1)

as illustrated in Figure1, where c (s, s) is the minimum cost to move the agent from s to s If the cost is evaluated

by distance measurement, then c (s, s) is the shortest path length from s to s.

Meanwhile, at the current point s, A*’s variants evaluate the cost from the starting point s star t via s to the given goal s g This evaluation is conducted by taking not only the

g-value, but also the cost estimation from s to s g, called

heuristic function or h-value, denoted with h (s), into

ac-count A point’s cost now is the summation of these two costs

f (s) = g(s) + h(s). (2)

Algorithm 1: Heuristic path planning framework.

Data: s star t , s goal

Result: f ound_ pat h, f ound_ pat h_lengt h

g(s star t ) = 0;

par ent (s star t ) = s star t;

open_li st = s star t;

f (s star t ) = g(s star t ) + h(s star t , s goal );

closed_li st = ∅;

while open_li st= ∅ do

s= arg min

si ∈open_list ( f (s i ));

open_li st = open_list\ {s};

if s == s goalthen

return [ f ound_ pat h, f ound_ pat h_lengt h];

else

closed_li st = closed_list ∪ {s};

foreach s∈ succ(s) do

if s /∈ closed_list then

if s /∈ open_list then

open_li st = open_list ∪ {s};

par ent = U pdateRelation(s, parent);

f = U pdateCost Estimation(s, f );

end end

return “No path found”;

Figure 1 Cost function construction of common heuristic search

algorithms, consisting of either real minimum cost g (s) or

estimated cost h (s) or both Solid lines denote the direct

connections while dashed lines denote relations which are not

necessarily direct connections

The heuristic function h (s) plays the role of guiding the

direction of expanding during the search It has been proved

that if h (s) is admissible, or

h (s) ≤ cs , s g



then the algorithm will find the lowest-cost path to the goal

point s g.[26] The straight line distance between two

differ-ent positions would never be longer than a real path

con-necting them; thus, the Euclidean distance between s with

coordinate(s.x, s.y) and s gwith coordinate(s g x, s g y) is

usually used as the h-value.

h (s) = Eds , s g



where

Ed

s , s g



=(s.x − s g x)2+ (s.y − s g y)2 (5)

Figure 2 Two weaknesses of Theta*’s variants Red lines denote found paths and dashed lines optimal paths

Since the path constructed by A* is through adjacent grid points, it is unnecessarily long and entails many robot head-ing changes Therefore, there have been proposals for smoothing the path, including post processing variants [14,

15] and Theta*’s variants.[17,18]

Theta* upgrades A* by inserting the smooth mission into the search iterations It tries to choose the better parent

for s from not only the direct neighbor s, but also the

parent of s via line-of-sight detection This recursive as-signing allows Theta* to determine the parent of s with

some faraway ancestor and give a better path which does not pass through a sequence of adjacent points as usual but

a sequence of line-of-sight ones According to [17], Theta* includes Theta* andAngle-Propagation Since Basic-Theta*’s performance is better than that of the latter, it gets more attention and discussion in this paper

Overall, parent indication based on line-of-sight in Basic-Theta* has two weaknesses shown in Figure 2 First,

al-though point a is visible to point b, in order for b to get a as

a parent, all the intermediate points expanded from a to b must have line-of-sight to a If this is not satisfied, b takes some intermediate point as its parent, i.e b1 Second, when

constructing a path from a to c, Basic-Theta* expands c3

and chooses c3as c’s parent since there is no line-of-sight between a and c Later on, c’s parent will be updated as

c1 due to c1’s lower evaluated cost In other words, the

path from a to c via c2can never be constructed because a point’s parent is only either its direct neighbor or its direct neighbor’s parent

Although Lazy-Theta* improves Theta*’s runtime and is the fastest among Theta*’s variants, it retains the two

weak-nesses mentioned When a point is added into open_li st,

Lazy-Theta* determines its cost as if it were visible to the parent of its direct neighbor The line-of-sight information

is examined only when this point is expanded This implies while Basic-Theta* performs several line-of-sight checks for a new point, Lazy-Theta* does so only once Conse-quently, Lazy-Theta* is faster, but may return worse cost evaluations which increase the search space size and the path length

Figure 3 Example results of applying Basic-Theta* and

lazy-Theta* Bold blue lines present the found paths while the thin

blue lines denote the relations of expanded points

The resulting path can also be improved by using a

re-expanding approach without closed_li st, or by reducing

the contribution of the h-value via the parameter w [17]:

f (s) = g(s) + w.c(s, s g ). (6) However, the re-expanding approach increases

computa-tional cost remarkably Meanwhile, choosing w depends

strongly on specific maps and tuning it for the shorter path

length always needs much runtime [17] as a trade-off In

addition,w > 1 does not guarantee the admission condition

as illustrated in Figure4where the result path is lengthened

with the mediate point (16,24) To overcome those

draw-backs, this paper will introduce an idea of deciding a better

parent for a point without both of the tuned parameterw and

additional line-of-sight computation, in order to enhance

our method’s efficiency

3 Proposed Batch-Theta*

In order to handle a set of goals in each expanding loop, we

change the way that Theta*s variants estimate a point’s cost

and choose the next point to be expanded from open_li st

as follows

s= arg min

si ∈open_list



g (s i ) + min

sg ∈goal_set



Ed

s i , s g



(7)

Figure 4 w > 1 does not guarantee admission condition Bold

blue lines indicate the found paths while the thin blue lines denote the relations of expanded points

In other words, the h-value is not computed by considering

a specific goal but the entire set of goals

h (s i ) = min

sg ∈goal_set



Ed

s i , s g



It is obvious that the proposed h (s i ) is admissible for any pair of s i and s g , where s g belongs to the given goal set Indeed,

min

s g ∈goal_set



Ed

s i , s g



≤ Ed(s i , s g ) s g ∈goal_set , (9) thus h (s i ) = min s g ∈goal_set

Ed

s i , s g



is never

overesti-mated from any s i to any goal s gin the goal set

As mentioned before, this leads to the fact that when some

specific goal s g is reached, the constructed path from s star t

to s g is guaranteed to be the best to s g It is remarked that this cost evaluation is straightforward; however, the unsolved question in the literature with this cost evaluation is whether there exists a shorter collision-free path to another goal found by Theta*’s mechanism when the first goal is reached

In this paper, Theta*’s mechanism is referred to as a search manner using (i) the cost evaluation in Equation (2) and (ii) the point’s parent indication of Basic-Theta* Following is the answer with detailed proofs

t h e o r e m 1 With h (s i ) = min s g ∈goal_set

Ed

s i , s g



, the first reached goal is the one to which there is the shortest collision-free path from the starting point under Theta*’s mechanism.

Proof Note that our algorithm does not consistently ex-plore a direction toward one goal, but changes the direc-tion of expanding toward different goals during the search,

making the g-value of the picked point inconsistently

in-crease Therefore, we cannot prove the theorem based on the searching process as in Dijkstra, but on the result of this process by contradiction as follows

When the first goal s g1is reached, assume that there exists

another path to goal s g j , 1 ≤ j ≤ n in the goal set which is

shortest, and of course is shorter than the one just found, or

Figure 5 Expanding behaviors of (a) Dijkstra, (b) Theta*, and (c) Batch-Theta* when trying to find the shortest path to a goal in the goal set

g

s gj

< gs g1

First of all, it can be concluded that j = 1, since the path

to s g1is shorter than any other paths to s g1as just mentioned

Therefore,

s g j = s g1. (11)

Let t0 be the moment right before s g1 is popped out of

open_li st for expanding According to Algorithm1, at t0,

s g1 is in open_li st and its parent has already been checked

and updated so that the cost from the starting point to s g1is

minimal Combined with the fact that s g1 ∈ goal_set, s g1’s

cost value is

f (s g1) = g(s g1) + min

sg ∈goal_set



Ed

s g1, s g



Supporting illustration is in Figure6where s star t is

de-noted by the big white dot, the s g ∈ goal_set by big black

dots and the intermediate points along the shortest path

connecting s star t and s gj by small white dots Let this best

path be P band assume that the grid resolution is high so

that intermediate point s k can be regarded as on P b Before

t0, considering all the points s k along P bincluding the both

ends, we have:

f (s k ) = g(s k ) + min

sg ∈goal_set



Ed

s k , s g sk ∈P b (13) and

f (s k ) ≤ g(s k ) + Eds k , s gj



≤ g(s gj ) sk ∈P b (14) Equations (11), (12) and (14) lead to:

f (s k ) < f (s g1 ) sk ∈P b (15)

before t

In addition, Batch-Theta* always considers s star t to be

first expanded, thus s star t ’s neighbor on this path, called s k1,

have been in open_li st before t0 According to Equation (15),

f (s k1 ) < f (s g1) (16)

thus s k1must be picked up for expansion and its next

neigh-bor on the path must be added to open_li st before t0

By continuously inferring, all the points on the shortest

path from s star t to s g j including the ends must be picked

and expanded before t0 That means s g j must be reached

before s g1, which is f alse under the fact that s g1 is the first reached goal Therefore, there does not exist any path shorter than the path found to the first reached goal under Theta*’s mechanism In other words, when applying Theta*

to plan the paths to individual goals, the best resulting path length is the one found by Batch-Theta*, although this path

is not optimal due to Theta*’s limitations  With this cost evaluation, Batch-Theta* can reduce the search space size while expanding a point only once Figure 5 illustrates the search space of Dijkstra, Theta*, and Batch-Theta* in gray Dijkstra’s expanded region is the circle around the starting point due to an exhaustive search and in Theta* many points are expanded more than once (overlapping gray portions) Meanwhile, Batch-Theta* only expands to equivalently good candidate goals, with smaller non-overlapping search space

This part proposes an improvement of Theta* through the line-of-sight checking process Specifically, when putting

Figure 6 When the first goal is reached by Batch-Theta*, it is

proved that the resulting path to it is the shortest or there cannot

exist another shorter path under Theta*’s mechanism If s gj is the

nearest goal, it must be reached first

a point sinto open_li st, Batch-Theta* avoids considering

two sub paths as Theta* does It just performs the

line-of-sight check from sto the parent of s If available, it assigns

the parent of s to be the parent of s Otherwise, it indicates

the blocked cell and chooses one out of the two points

of this cell to be the parent of s This new procedure of

checking is executed by the function candi t_L O S (s i , s j ),

which returns the candidate parents for s iwithout extra

line-of-sight computation

Figure 7 supports illustrations of the parent indication

of this function When b0, whose parent is a, is expanded

and the neighbor b is inserted into open_li st, candi t_L O S

(b, a) is revoked to detect obstacles along the straight line

from b to a via a sequence of on-edge points (small white

points) If some obstacle blocks the line, the function stops

checking and locates the position where the line hits the

obstacle Then, the two nearest grid points, i.e b1and b2,

will be considered as the candidates for b’s parent Besides,

when candi t_L O S (c, a) is called, c is the impact-point,

then c1 and c2 are c’s parent candidates Obviously, the

process of checking two sub-paths of Basic-Theta* is

in-cluded in our method and if a line-of-sight is not present then

our method chooses the parent of smore wisely Note that

candi t_L O S () can help the search overcome the second

weakness mentioned in Section2.2and Figure 2 In that

situation (see Figure2), Batch-Theta* will assign c2as the

parent of c when doing the line-of-sight check from c to a

and shortens the path found

For line-of-sight checking, the conventional function

Li neO f Sight () (seeAppendixAof [17]) works well based

on the drawing-line algorithm in computer graphics, finding

all cells that a line goes through with calculation on integers

Nevertheless, utilizing this algorithm structure to find the

impact location is difficult because it requires examining too

many situations while Li neO f Sight () performs several

block-cell checks in one iteration Therefore, we come up

with another structure for our own purpose (see Figure8)

Figure 7 Illustrations for candidate parent indication of

candi t_L O S () Red bold lines represent parent–child relations

and dashed lines denote the line-of-sight checks

Algorithm 2: Function candi t_L O S (s1, s2).

Data: s1, s2

Result:{candit}, los los = true;

candi t= ∅;

if s1 x == s2.x | s1.y == s2.y then

return;

d x = (s2.x − s1.x);

d y = (s2.y − s1.y);

sx = sign(dx);

sy = sign(dy);

x0 = s1.x; y0 = s1.y;

f 1 = f 2 = mark = 0;

while(x0! = s2.x) do

if gr i d (x0 + (sx − 1)/2, y0 + (sy − 1)/2) then

los = f alse;

block = (x0 + (sx − 1)/2, y0 + (sy − 1)/2);

break;

if abs ( f 1 + dx) > ( f 2 + dy) then

f 2 = f 2 + dy;

x0 = x0 + sx;

mar k= 1;

else

f 1 = f 1 + dx;

y0 = y0 + sy;

mar k= 2;

if f 1 == f 2 + dy then

f 2 = f 1;

x0 = x0 + sx;

mar k= 0;

end

if!los then

if mar k== 1 then

candi t = {(x0, block.y), (x0, block.y + 1)};

else if mar k== 2 then

candi t = {(block.x, y0), (block.x + 1, y0)};

else

if sx == sy then

candi t=

{(block.x, block.y + 1), (block.x + 1, block.y)};

else

candi t=

{(block.x, block.y), (block.x + 1, block.y + 1)}; candi t = candit ∩ succ(s1)

Figure 8 Illustrations for checked cell indication of

candi t_L O S () which is able to return the hit point position

based on the edge points along the line checked

The main idea is locating the on-edge points along the

line checked Letx be the pace along the x axis when

y increases 1 and y be the pace along the y axis when

x increases 1 An on-edge point along the line checked

then has the coordinates of (x, y), in which x takes the

form of either(s1.x + m x ) or (s1.x + n x ∗ x), and y

has the form of either(s1.y + m y ) or (s1.y + n y ∗ y)

where m x , n x , m y , and n y are integers The current point

C (x0, y0) is s1 at the beginning When drawing a line

from s1 to s2, the next edge point N is indicated as the

nearest edge point from C and then C replaces N repeatedly

until the line drawn meets a blocked cell or reaches s2.

Note that the function gr i d (i, j) returns true if the cell at

position(i, j), which covers the square with four corners

{(i, j) , (i + 1, j) , (i, j + 1) , (i + 1, j + 1)}, is a blocked

cell

In fact, this idea of checking procedure is slow due to

floating point calculations and may fail due to the errors

caused by the floating point numerical system in computer

Fortunately, it can be interpreted to work with integers,

avoiding floating point numbers and their errors sincex

andy are the fractions of integers Algorithm2presents

the pseudo code of function candi t_L O S () which deals

with integers only The variable mar k stores the information

of how the previously and currently checked cells contact

each other When a blocked cell is detected, this information

is used to find the impact edge and the candidate parents

Ob-viously, Li neO f Sight ()’s structure is more complicated

than ours in which the total number of gr i d () checks is

unchanged and the parent candidate indication occurs only

once outside the loops with simple assignments

One may argue that if the candidate parents are not yet

ex-panded or do not have parent–child relationships to previous

expanded points, the proposed line-of-sight check would

fail the searching process However, the algorithm expands

the workspace gradually from the starting point and picks

the lowest f -value point to expand next Hence, if a point

(e.g b in Figure7) is already expanded and its neighbors

(e.g b) are about to be inserted to open_li st, then the intermediate points along the line checked (e.g b2) are both

already expanded and visible to the point’s parent (e.g a).

The proof of this claim can be found in [17] (Lemma 1) That

means the neighbors of these intermediate points (e.g b1)

have at least appeared in open_li st Moreover, our method

indicates a point’s parent and its cost evaluation before

adding it to open_li st Consequently, when the function candi t_L O S returns the candidates, each of them already

has a parent and the respective evaluated cost Therefore, the search algorithm with this modified line-of-sight check

is guaranteed to work properly

The algorithm is described with pseudo code in Algorithm3 Although Batch-Theta* shares the framework of heuristic search, it possesses several differences First, it has a new version of the line-of-sight checking function to utilize the information of the impact-point and returns the parent

can-didates for s The resulting candi t is a list of at most two

candidate parents when los is f alse (no line-of-sight) and

is empty when los is tr ue Function candi t_L O S allows not only s and s’s parent but also the intermediate points along the line checked to be the parent of s while

addi-tional line-of-sight computation is mitigated Second, our proposed idea gives an added point a chance for choosing

a better parent, which helps eliminate the two functions

U pdate Relati on (s, parent) and U pdateCost Esti − mati on (s, f ) A point’s parent and its related f -value are examined only once when being added to open_li st Be-sides, better g-value evaluation decreases the f -value of

points on the path found, leading to a lower number of expanded points and runtime Third, Batch-Theta* handles all goals in each iteration; thus, it compresses the search area while guaranteeing that the first reached goal is the best goal

4 Simulations and discussions

All algorithms presented in this section were implemented

in a Matlab platform on a computer equipped with 2.4 GHz Core i5-2430M CPU and 4GB RAM For comparison, they were pruned to follow the same main structure and to mini-mize redundancy (no console printing and figure plotting) This paper chooses two competitors including Basic-Theta* and Lazy-Theta* for comparison due to two reasons On the one hand, according to Daniel et al.’s work (Figure 2, Tables

1 and 2 of [17]), the Basic-Theta* gives the best path length results compared to other suboptimal methods like FD*,

AP Theta*, and A* PS while requiring less time than FD* and AP Theta* Although A* PS’s runtime is shorter than Basic-Theta*, its path length results are poor (nearly 5% longer than that of Basic-Theta* with low obstacle density); thus, it is not considered as a good competitor here On the

Algorithm 3: Batch-Theta*.

Data: s star t , goal_set

Result: f ound_ pat h, f ound_ pat h_lengt h

g(s i ) = ∞;

g(s star t ) = 0;

par ent (s star t ) = s star t;

open_li st = s star t;

f (s star t ) = g(s star t ) + min

sgoal ∈goal_set (Ed(s star t , s goal ));

closed_li st = ∅;

while open_li st= ∅ do

s= arg min

si ∈open_list ( f (s i ));

open_li st = open_list\ {s};

if s ∈ goal_set then return [ f ound_ pat h, f ound_ pat h_lengt h];

closed_li st = closed_list ∪ {s};

foreach s∈ succ(s) do

if(s /∈ closed_list) & (s /∈ open_list) then

open_li st = open_list ∪ {s};

[{candit}, los] = candit_L OS(s, parent(s));

if los then

par ent (s) = parent(s);

else

par ent (s) = candit(1);

if g (candit(1)) + Ed(candit(1), s) >

g (candit(2)) + Ed(candit(2), s) then

par ent (s) = candit(2);

g(s) = g(parent(s)) + Ed(parent(s), s);

f (s) = g(s) + min

sg ∈goal_set (Ed(s, s g ));

end end

return “No path found”;

other hand, Lazy-Theta* is currently the fastest improved

variant of Theta* that has the best trade-off for path length

(see [18]) That means it reduces the computational time

significantly with inconsiderable path length increment

This simulation demonstrates the efficiency of the proposed

function candi t_L O S Figure9and Table1are the results

of applying Batch-Theta* for one goal to solve the path

planning example in Figure3 The blue thin lines and the

bold lines denote the parent–child relations among the

ex-panded points and the resulting path, respectively

Compared to the results in Figure 3, every expanded

point in Figure9 has the optimal parent and its g-value

is evaluated correctly As a consequence, the path length

found by Batch-Theta* in this example is 19.1658, equal to

that by Basic-Theta* and shorter than that by Lazy-Theta*

which is 19.2070 Moreover, since appropriate evaluation

of the g-value can be constructed more directly by

Batch-Theta*, the number of intermediate points can be reduced

(see Table1) Hence, the total computational time of

Batch-Theta* is less than those of both Basic-Batch-Theta* and

Lazy-Figure 9 Batch-Theta* assigns parent for added points wisely

Theta* thanks to less line-of-sight computation as well as to the absence of updating the relations and estimated values

for the points in open_li st In this case, Batch-Theta* needs

around 0.028 s while Basic-Theta* and Lazy-Theta* around 0.043 and 0.034 s respectively

Extensively, we use the conventional map of 500× 500 grid cells in which the obstacle cells are set randomly at a probability of 10, 20, and 30% alternately The starting point and the goal are also chosen arbitrarily as long as there is a path between them Applying Basic-Theta*, Lazy-Theta*, and Batch-Theta* (for one goal in this simulation set) yields the comparisons in Table2

It is seen that although Lazy-Theta* gives a slightly longer path length and higher number of expanded points compared to Basic-Theta*, its runtime is considerably lower Lazy-Theta* requires at most only 88.46% of the runtime

of Basic-Theta* for the 30% obstacle case and 66.71% for the 10% obstacle case Meanwhile, equipped with the proposed line-of-sight check, Batch-Theta* even needs less time than Lazy-Theta* in all tests while its results of path length are even better than those of Basic-Theta* The rea-son is rechecking and updating the information of points in

open_li st are performed many times by Basic-Theta* and Lazy-Theta* before the points are dumped into closed_li st.

This repeated procedure contributes most of Basic-Theta*’s and Lazy-Theta*’s computational time while being elim-inated with our method As a result, it gives better cost evaluation in a direct manner and narrows the search space While Lazy-Theta* cannot guarantee to reduce the search space, our method always does with nearly 20% reduction for the 30% obstacle case and even with only about 50% re-duction for the 10% obstacle case In addition, Batch-Theta* can yield shorter path length because it overcomes the sec-ond drawback of Basic-Theta*’s variants mentioned in Sec-tion2.2 Obviously, the improvements by our candi t_L O S

function in terms of search space size and runtime are con-siderable while no trade-off of length is paid

Actually, in some situations, Batch-Theta* may find longer paths than Basic-Theta* because it does not fully recheck for better parents However, these situations appear with

a low probability and on average, the mean path length found by our method is shorter With higher obstacle density,

Table 1 Performance comparison between Basic-Theta*, Lazy-Theta*, and Batch-Theta* on the example in Figure3.

Table 2 The average percentage results for maps of size 500× 500 comparing to those of Basic-Theta* when constructing path to one goal

#Goal Method Path length percentage Expanded point number percentage Time percentage

10% obstacles

20% obstacles

30% obstacles

Figure 10 Comparison among Basic-Theta*, Lazy-Theta*, and Batch-Theta* in one goal situation in terms of path length, runtime, and

expanded space size when tuning the weight of h-value w.