INTERNATIONAL JOURNAL OF PRECISION ENGINEERING AND MANUFACTURING Vol. 16, No. 10, pp.

2073-2080 SEPTEMBER 2015 / 2073

DOI: 10.1007/s12541-015-0269-9 ISSN 2234-7593 (Print) / ISSN 2005-4602 (Online)

Local Map-based Exploration using a Breadth-First

Search Algorithm for Mobile Robots

Hyejeong Ryu1,2,# and Wan Kyun Chung2

1 School of Information Science, Japan Advanced Institute of Science and Technology, 1-1 Asahidai, Nomi, Ishikawa, 923-1211, Japan
2 Department of Mechanical Engineering, Pohang University of Science and Technology, 77, Cheongam-ro, Nam-gu, Pohang-si, Gyeongsangbuk-do, 790-784, South Korea
# Corresponding Author / E-mail: roohj@postech.ac.kr, TEL: +82-54-279-2842, FAX: +82-54-279-8459

KEYWORDS: Exploration, Localization, Mapping, Mobile robot, Scan-matching

This paper describes a local map-based exploration strategy. Segmented frontiers and relative transformations constitute a tree
structure. This frontier tree structure, which manages multiple local maps, effectively overcomes the limitations of conventional
exploration methods, which maintain only a single global map. Although this method uses only local maps and adjacent node
information, mapping completion and efficiency can be improved greatly by merging and updating the frontier nodes. In addition, a
modified breadth-first search (BFS) algorithm is used to determine the next exploration target. BFS exploration is appropriate for
large environments because it induces a loop-closing event from the root node, which is necessary to recover the estimation accuracy
when the uncertainty of the robot’s pose has become large. The proposed local map-based BFS exploration can construct an accurate
map, even in large environments.

Manuscript received: December 3, 2014 / Revised: May 25, 2015 / Accepted: June 30, 2015

1. Introduction
Exploration is the process of determining a target position to move
to next to achieve efficient mapping. A number of approaches to this
process have been reported, and they can be categorized according to
the method by which the environment is represented. The environment
can be represented as structured geometric features,1,2 using a graph,3-6
or using occupancy grids.7,8 Among these approaches, the frontier-based
method using a grid map has become a popular basis for exploration.
Frontiers are defined as regions on the boundary between empty
(i.e., explored) and unknown (i.e., unexplored) areas.8-10 In frontier-based
exploration, when frontiers are detected on the grid map, the robot goes
to the most valuable frontier region. By moving toward frontiers on the
grid map, the robot can gain new information about the environment
more efficiently and, consequently, reduce the size of the unmapped
areas.
Frontier-based exploration generally constructs and maintains (i.e.,
updates) a single global grid map, which is used to detect new frontier
regions. The local sensor data obtained at a frontier contributes to
updating the global grid map, which corresponds to the position of the
robot and its surroundings in the global reference frame.
The efficiency of exploration depends on the frontier information in
the grid map, which is updated using the current robot position, so the
resulting grid map is affected by the localization accuracy. However,
the uncertainty of the robot’s position increases with the distance the
robot travels before loop-closing occurs, which means that the robot
returns to a previously explored area.11 If the grid map is updated with
respect to the uncertain position, the quality of the resulting map will
not be sufficient to obtain accurate frontier information. This problem
is crucial for mapping large, complex environments. Although the
algorithms developed to date12-14 consider the expected uncertainty of
the estimated position of each frontier candidate during exploration,
they do not include a strategy for managing the previously constructed
part of the grid map before loop-closing.
To cope with a large, complex environment or a long travel distance,
local map-based mapping approaches have been developed.15-18 In local
map-based approaches, each local map has its own reference frame,
and relative transformations between local maps construct a global
topological graph. These local map-based methods focused on accurate,
consistent mapping, but did not consider the next target decision to
achieve autonomous mapping.
During exploration, the robot should be able to inspect the mapping
state and select the subsequent target position autonomously. The
mapping state refers to the coverage of the entire environment. However,

© KSPE and Springer 2015

 2074 / SEPTEMBER 2015
Fig. 1 Difficulty of detecting frontiers using only local maps: one
frontier area in the second local map (the region in the yellow box) is
not a real frontier, but an explored area in the global map
it is difficult to determine whether mapping has been completed using
only local information, and this makes it problematic to discriminate
among proper target candidates for exploration (Fig. 1). Therefore, to
apply the local map-based approach to exploration, a method to register
local maps that considers the mapping coverage and frontier detection
is needed.
For accurate, efficient exploration, we propose a local map-based
exploration strategy that is an integrated approach and combines
frontier-based exploration and a graph search algorithm. Multiple local
maps at frontier positions are created and the relative transformations
between local maps construct the tree structure for the entire
environment. Because the conventional graph exploration methods did
not deal with how to abstract the graph structure by interpreting sensor
data,3-6 it is hard to directly apply them to the real world environment.
In pose-graph approaches, graph is not constructed based on frontier
positions but the trajectory of the robot.19,20
In this paper, using the frontier tree structure and a modified breadth-
first search (BFS) algorithm, the next exploration target is decided. The
proposed frontier tree structure is suitable for updating or merging local
grid maps according to the pose uncertainty, and the modified BFS
algorithm can decide whether to expand information about the
environment or to improve the pose accuracy.
This paper is organized as follows. Section II presents an overview
of the local map-based exploration algorithm. Section III describes the
procedure used to construct and update the frontier tree structure. The
method used to decide the next exploration target is presented in Section
IV. Finally, the experimental results and conclusion are presented in
Sections V and VI, respectively.
2. Algorithm Overview
Fig. 2 presents an overview of the local map-based exploration
procedure. The algorithm consists of three steps: constructing the
frontier tree using the local map; updating the frontier tree by loop-
closing; and deciding the next target node.
If the current node is a new location that the robot has never visited
before, the first step is carried out to extract frontier regions on the
INTERNATIONAL JOURNAL OF PRECISION ENGINEERING AND MANUFACTURING Vol. 16, No. 10
Fig. 2 An overview of local map-based exploration
current local grid map and to add new frontier nodes to the frontier tree.
The second step is performed if loop-closing occurs, which means
that the current node is one that the robot has already visited. Since the
loop-closing constraints, which depend on the loop sequence, can lead
to accurate edge information between loop nodes, the local maps that
are assigned to the loop nodes can be merged using corrected edge
information.
The next target node to explore is decided by using the frontier tree
and BFS algorithm. In general, the BFS algorithm is used to search for
the shortest path on a predetermined, unchanged graph or tree. In
exploration, however, the tree structure of the environment is initially
unknown and it is expanded until no further frontier nodes are found.
We modified the BFS algorithm to deal with this situation. In BFS
exploration, the next target node might be an unvisited node that was
registered to the frontier tree, but has not yet been visited, and this
decision expands the map and tree. Alternatively, the robot could select
a known node to improve the accuracy of the pose and map by loop-
closing. When all nodes have been explored completely, i.e., there are
no frontier nodes to visit in the tree, the process of exploration is
complete.
3. Frontier Tree Structure
3.1 Constructing the frontier tree structure
In the proposed method, the robot moves between the nodes of the
frontier tree during exploration. Therefore, the number of registered
frontier nodes affects the efficiency of exploration. Since registering
every frontier cell on the grid map is computationally inefficient, we
group nearby frontier cells using the polar histogram and register one
representative node for each group.21 Before this segmentation, we
 INTERNATIONAL JOURNAL OF PRECISION ENGINEERING AND MANUFACTURING Vol. 16, No. 10
Table 1 Frontier tree database
Node = {nodeid | 1 ≤ id ≤ N}
nodeid = id, idmap, idparent, flag exp lored, Pid, {idchild1, …, idchildn }
Map = {mapid | 1 ≤ id ≤ N}
⎧ id, gid, {idnode1, …, idnodem}, ⎫
mapid = ⎨ ⎬
⎩ {poseid, node1, …, poseid, nodem } ⎭
− ⎧ edge−i, j |predicted relative transformation, ⎫
Edge = ⎨ ⎬
⎩ 1 ≤ i ≤ N, 1 ≤ j ≤ N ⎭
− − −
edgei, j = {distancei, j, tri, j }
+ ⎧ edge+i, j |actual relative transformation, ⎫
Edge = ⎨ ⎬
⎩ 1 ≤ i ≤ N, 1 ≤ j ≤ N ⎭ Pi,j is the corresponding covariance.
+ + + In the frontier tree structure, all child nodes have one parent node.
edgei, j = {distancei, j, tri, j, Pi, j }
N : the number of nodes
n : the number of cild nodes
M : the number of maps
m : the number of nodes which share the mapid
− − − − T
tri, j = [xi, j, yi, j,θ i, j ]
+ + + + T
tri, j = [xi, j, yi, j,θ i, j ]
merge local maps of adjacent nodes with the current local map to
prevent known areas in the adjacent local maps from being detected as
frontiers again in the current local map. The local maps of the previous
and parent nodes are transformed with respect to the current node. At
this time, we use the rigid transformation of the grid map.22 Grid cells
that are revealed to be frontiers in both the current and merged maps
are assigned as frontiers.
Table 1 lists the components of the frontier tree database (DB). The
frontier tree contains three DBs: the node, local map, and edge DBs.
The node DB stores information on each node, including the
identifications (IDs) of parent node and child nodes, the ID of
corresponding local map, exploration state (flagexplored), and two-
dimensional (2D) point cloud map (Pid).The point cloud map is a set of
laser data points, extracted when the robot visits the node for the first
time, and can be used to compute the loop-closing observation if the
robot revisits the node. The map DB contains information about the
local grid map (Gid).When the robot visits the current node for the first
time, the local map, constructed with respect to the current node, has
one node ID and the position of the current node, (0, 0, 0), on this local
map. If loop-closing occurs, multiple local maps will be merged.
Therefore, after loop-closing, the map information has several node
IDs, and the positions of the loop nodes on the merged map. If the
exploration process has been completed, all frontier nodes share one
grid map for the entire environment. The edge DB contains the geometric
relations and connectivity between frontier nodes: the relative
transformation, (xi,j, yi,j, θi,j), and the shortest distance, distancei,j. The
predicted edge information, Edge−, is obtained when new nodes are
detected at the parent node and added to the node DB. The shortest
travel distance between the current node and the predicted position of
−
the child node, distancei, j , is computed by the A* algorithm23 and the
current local grid map. The actual edge information, Edge+, is calculated
SEPTEMBER 2015 / 2075
Fig. 3 (a) An example of scan points (b) The direction histogram for (a)
from the actual travel path after the robot has arrived at the node, and
Since we can compute the relative transformation between sibling
nodes when new child nodes are detected on the grid map, the edge DB
contains not only the edges between parent and child nodes, but also
the edges between child nodes, i.e., between sibling nodes. Using this
graph-like property, the robot can go directly to the sibling node
without going through the parent node.
3.2 Updating the frontier tree structure by loop-closing
After exploring the child or sibling nodes, the robot can return to the
parent node to reduce the uncertainty of edge information. This is
called “induced” loop-closing in the proposed exploration strategy. The
robot can also revisit the same node by chance during exploration. Such
“accidental” loop-closing results from using only local information
when the robot determines the exploration state of the node, whether it
is known or not. We use the scan-matching algorithm to detect loop-
closing events: whether the current node is close to the previously
visited node and how close the current node is to the revisited node.
Scan-matching refers to the problem of calculating the relative
translation and rotation between a current point cloud and a reference
point cloud in such a way that maximal overlap occurs.24 The
performance of most scan-matching algorithms is sensitive to rotational
displacement. That is, if two point clouds were obtained at locations
close to each other, but the heading directions of the robot were
different, matching might fail to detect loop-closing and compute the
correct relative transformation. If detecting loop-closing is failed at the
previously visited position, that is, the robot does not realize that the
current position is in the already explored node, multiple nodes can be
created at the similar positions. Because the exploration continues until
all registered node turns out to be explored, these unnecessary nodes
decrease the exploration efficiency. Moreover, in most cases, although
the robot comes back to the similar position, its heading direction is
mostly different from the previous heading direction and there is a large
rotational displacement between the current point cloud and the
previous point cloud of the revisited node.
To prevent the failure to detect loop-closing, we compute the
direction histogram of the 2D point cloud.25 The slope of a line fitted
to each point and its two neighboring points is accumulated in the
histogram. The histogram is normalized so that its sum is unity. Fig. 3
shows an example of a point cloud map in the node DB, and its
direction histogram. The direction histogram can represent the
 2076 / SEPTEMBER 2015
geometric structural tendency of the point cloud.
Each time the robot arrives at a new node, that is, the predicted
frontier position, the current point cloud map is compared with the
point cloud map of each node in the node DB to detect accidental loop-
closing. The computational cost increases with the increasing number
of former point clouds until the exploration procedure is completed,
and most scan matching algorithms use the iteration method to minimize
the mean square distance between the current and reference point
clouds. To enhance the computational efficiency of the loop-detection
step, we can select matching candidates which are geometrically similar
with the current point cloud and have the high probabilities of loop-
closing using the direction histogram.
To determine whether the current point cloud map is similar to the
point cloud map of each node, that is, to calculate the similarity between
two direction histograms, we apply the Bhattacharyya distance, which
can compute the relative closeness of two distributions. For two direction
histograms, Hi = [hi(1o), …, hi(180o)] and Hj = [hj(1o), …, hj(180o)], the
Bhattacharyya distance is as follows
180°
DB ( Hi , Hj ) = – ln ∑ hi ( k )hj ( k )
k=1°
To make the proposed scan-matching algorithm invariant to the
heading direction, we calculate the distance between Hi and Hj+δθ,
shifted histogram of Hj by an angle δθ, and determine the similarity,
SimD, as follows
–1
SimD ( Hi, Hj) = [ min DB ( Hi, Hj +δθ ) ] , δθ = 1°, …, 180°
δθ
Empirically, the Bhattacharyya distance between the histograms of
two point cloud maps that were taken from nearby locations is less than
0.12. Therefore, if the similarity between the direction histogram of the
current point cloud and the direction histogram of each node exceeds
0.12-1, the node is selected as a loop-closing candidate. We can also
predict the initial rotational displacement as the shifted angle where the
similarity value is determined.
To calculate the relative transformation between the current point
cloud and the point cloud of each loop-closing candidate node, we use
the iterative closest point (ICP) algorithm26,27 and the predicted initial
rotational displacement using the direction histogram. At this time, the
matching ratio is defined as follows
Cor ( i, j) = Ci, j /min ( Ni, Nj )
where Ci,j is the number of corresponding point sets, and Ni and Nj are
the number of points in point cloud maps i and j, respectively. The
matching ratio means how much area is overlapped in two point cloud
maps, that is, how close two positions where point cloud maps obtained
to each other. If the matching ratio is small and there is not an adequate
number of correspondences, loop-closing rarely occurs and the resulting
relative transformation is not robust.
The enough matching ratio is related with the maximum detection
range of the laser scanner. In this research, the maximum range was 8
m, and empirically loop-closing was robustly detected with the low
mean square distance when the matching ratio was larger than 0.85.
Therefore, if the matching ratio exceeds a certain value, 0.85 in this
INTERNATIONAL JOURNAL OF PRECISION ENGINEERING AND MANUFACTURING Vol. 16, No. 10
Fig. 4 The loop constraint for accidental loop-closing
paper, the robot recognizes that loop-closing is possible, and updates
the frontier tree according to the loop constraint. When there are
multiple loop-closing candidates that satisfy this criterion, the node
which has the highest matching ratio is selected as the revisiting node.
(1) When the robot revisits a node to induce loop-closing from the child
node to the parent node, without the above candidate selecting process,
we just calculate the direction histograms of the current point cloud and
that of the revisited parent node in the node DB, and predict the initial
rotational displacement by comparing the two histograms to deal with
the case in which that heading directions are quite different.
For both induced and accidental loop-closing, we can compute an
(2) accurate relative transformation using the direction histogram, although
there might be a large rotational displacement between the current and
registered point clouds in the node DB.
Fig. 4 shows the loop constraint corresponding to accidental loop-
closing: the robot does not realize that the current node i' is close to
previously visited node i until it arrives at node i'. Using actual edge
information, the loop constraint can be generated between loop nodes
as follows
+ + +
h (tr ) = tri, s ⊕ … ⊕ trs , k ⊕ trk, i′ ⊕ zi, i′ = 0 (4)
1 n
where zi,i' is the loop-closing observation obtained by the scan-matching
algorithm and the direction histogram. The edge between loop nodes
can be updated by using the loop constraint and iterated extended
Kalman filter (IEKF).28 At this time, the covariance of zi,i' is set to be
(3) the zero matrix. If the edge is updated once, its covariance becomes the
zero matrix and it acts on later loop-closing as a constraint.
After updating the edge information, the corresponding local maps
are merged. After every map-merging process with loop-closing, we
inspect whether the child nodes of the loop nodes are known on the
merged map using the sum of the entropy within a window W around
the child node cell as follows
H= ∑ [– Pi, j (O )log Pi, j (O ) – Pi, j (E) log Pi, j (E )] (5)
i, j ∈W
where Pi,j(O) is the occupancy probability and Pi,j(E) is the empty
probability of grid cell (i, j). If the child node cell is empty and the sum
of the entropy around the child node cell is lower than a certain limit,
the child node is considered as the known area.
 INTERNATIONAL JOURNAL OF PRECISION ENGINEERING AND MANUFACTURING Vol. 16, No. 10
Fig. 5 The BFS exploration algorithm
4. Deciding the Next Target: BFS Exploration
While conventional frontier-based approaches find the next target
by calculating the costs of the detected frontier cells on the single
global grid map, the proposed method uses the frontier tree structure
and applies the BFS algorithm. Since edge information includes the
distance as well as the relationship between adjacent nodes, the frontier
tree structure is useful for finding the frontier node nearest to the
current node.
In BFS exploration, the robot moves along the edge between nodes,
and unvisited sibling nodes take higher priority over child nodes. If all
sibling nodes are explored, the robot will return to the parent node to
close the loop consisting of the current node, sibling nodes, and parent
node. Since loop-closing is induced from the root node, local maps can
be merged sequentially from the beginning of the exploration process
and it is appropriate for large environments.
Fig. 5 shows the BFS exploration algorithm. The robot first
determines whether there are unvisited sibling nodes. If all siblings
have been explored, the loop-closing state of each adjacent node is
considered (see lines 3 to 10). The loop-closing state of the node is
decided according to the map merging state of the node and its child
nodes: if the node and its child nodes share the same local map, the
loop at that node is closed completely. The fact that loop-closing has
not been completed at a node means that there are not enough links to
make a loop between the node and its child nodes. Therefore, the robot
explores to obtain edge information, which might be a portion of a
loop.
5. Results
5.1 Simulation results
We simulated our exploration system to verify that (i) mapping can
SEPTEMBER 2015 / 2077
Fig. 6 (a) The simulated environment and starting position (blue dots),
(b) The resulting node positions for the 9th starting position. The
numbers show the node IDs; the red line shows the edge between
parent and child nodes; the green dotted line shows the edge between
sibling nodes; and blue nodes are inactive nodes.
be completed for the entire environment using the proposed local map-
based approach and (ii) that BFS exploration can determine the next
target in a large environment more efficiently than depth-first search
(DFS) exploration, which we proposed previously.16 All simulations
were carried out using MATLAB. The robot had a 360° laser scanner,
and the maximum range that was simulated using a ray-tracing algorithm
to obtain a local grid map was identical in all simulations.
Table 2 lists the simulation results for different starting positions in
the environment in Fig. 6(a). The travel distance is the sum of the
distance that the robot moved along the A* path between the current
node and the next target node on the local grid map until the mapping
is completed, and the unit is a grid cell. The number of nodes is the
total number of registered nodes in the frontier tree. Active nodes are
the nodes that the robot actually visited, and this is the same as the
number of local maps used to construct the resulting map of the entire
environment. In all simulations, the robot continued the exploration
process until there were no remaining unexplored frontiers. Eventually,
in each simulation, the entire environment was mapped. Since the robot
explores the shortest unvisited child node rather than the parent node
for loop-closing in DFS exploration, it is appropriate for mapping in
simple environments like corridors. However, because updating edge
information and merging local maps with loop-closing are delayed until
the robot reaches the end of a branch, DFS exploration is inefficient in
a large environment, such as halls. As shown in Table 2, the travel
 2078 / SEPTEMBER 2015 INTERNATIONAL JOURNAL OF PRECISION ENGINEERING AND MANUFACTURING Vol. 16, No. 10

Table 2 Simulation results

Starting position 1 2 3 4 5
Method BFS DFS BFS DFS BFS DFS BFS DFS BFS DFS
Travel distance 2400 3575 3019 4685 2954 4362 2352 2624 2904 3207
# of movements 50 91 65 117 63 111 52 67 63 82
# of nodes 30 76 30 123 36 120 29 105 30 80
# of active nodes 22 46 24 63 26 66 21 55 23 46
# of accidental loop-closing 0 4 0 6 0 5 0 2 0 2
Starting position 6 7 8 9 10
Method BFS DFS BFS DFS BFS DFS BFS DFS BFS DFS
Travel distance 3088 3201 3059 4340 2988 4541 2443 3501 2690 3840
# of movements 70 81 67 111 66 116 54 88 64 98
# of nodes 31 66 33 99 35 107 31 143 31 83
# of active nodes 24 41 26 56 26 62 23 71 23 51
# of accidental loop-closing 0 5 0 5 0 5 0 6 0 6

Fig. 7 (a) The floor plan of the environment: the robot explored the red
lined area, (b) The experimental setup: we used ActiveMedia P3-DX
robot platform with two laser scanners (Hokuyo: URG-08LX) and the
quad-core laptop computer
distance of BFS exploration is shorter than that of DFS exploration.
Moreover, the number of nodes for DFS exploration is much higher
than that for BFS exploration. This is because multiple nodes were
registered in a similar area in the case of DFS exploration. Fig. 6(a) is
the resulting position of nodes and edges in the case of the 9th starting
position. The nodes were well-distributed for the entire environment.
Fig. 8 Example of scan-matching using the direction histogram (a).
Scani is the current point cloud, Scanj is the reference point cloud, Scanij
is the transformed point cloud of Scanj with respect to the reference
frame of Scani by the resulting relative transformation of the ICP
without the direction histogram. (b) The magenta dots are transformed
point cloud of Scanj using the initial rotation, 138°, estimate computed
by the direction histogram. The cyan dots show the final matching
result: the transformed point cloud of Scanj with the resulting relative
transformation of the ICP with the direction histogram

5.2 Experimental results

We conducted the experiment in the real world environment. The position and the registered position of the frontier node, we used the
robot used two laser scanners to obtain the point cloud map. The direction histogram described in Section 3.2. Fig. 8 shows a scan-
experimental setup is shown in Fig. 7(b). To detect loop-closing events matching example in which the rotational displacement is large
and calculate an accurate relative transformation between the current between the current point cloud i and the reference point cloud j.
 INTERNATIONAL JOURNAL OF PRECISION ENGINEERING AND MANUFACTURING Vol. 16, No. 10
Fig. 9 Experimental results in a hall environment: (a) the positions of
the nodes; (b) the frontier tree structure; (c) the exploration path, the
red arrow indicates the movement for induced loop-closing to the
parent node; and (d) the number of local maps for each decision step
Without the direction histogram, scan-matching failed (yellow dots in
Fig. 8(a)). However, using the direction histogram, a reliable rotation
estimate was obtained (magenta dots in Fig. 8(b)) and two point cloud
maps were successfully matched together (cyan dots in Fig. 8(b)).
Fig. 9 shows the experimental result for the hall environment. The
robot explored the 24 m × 22 m area and the robot’s position was
estimated using the Delayed-state Extended Kalman Filter SLAM,29
while moving between nodes. In the BFS exploration, the robot merged
the local maps incrementally from the root node, 0. At each node,
adjacent nodes are inspected to determine whether they are known on
the merged map, so that BFS exploration can avoid registering multiple
new nodes at nearby locations and several nearby nodes are eliminated
from the exploring target list for efficiency. Frontier nodes were
SEPTEMBER 2015 / 2079
distributed over the entire environment and an accurate, complete map
was constructed by merging local maps of frontier nodes. Fig. 9(d)
shows the number of local maps in the map DB for each decision step.
Because of the induced loop-closing of BFS exploration, the number of
local maps was small during the exploration process. The final number
of local maps was one, which means that the proposed algorithm can
efficiently manage the frontier tree structure and local maps.
6. Conclusions
We described local map-based exploration for autonomous mapping
in large environments. The proposed method can construct and manage
a frontier tree structure using only local information, and decide the
next target autonomously using the BFS algorithm. Since the tree
structure efficiently defines the segmented frontier nodes extracted on
the local map, the robot can expand its knowledge about the
environment by moving along an edge. In addition, BFS exploration
induces loop-closing, so that the local information assigned to each
frontier node is updated accurately according to the loop constraint.
The performance of BFS exploration was compared to that of DFS
exploration using simulations. We verified that BFS exploration was
more efficient than DFS exploration in terms of the total distance
travelled and the number of nodes. The experiment was also conducted
in a real-world environment. As a result, an accurate, complete map of
the entire environment was obtained by constructing the frontier tree
and deciding the next target according to BFS exploration.
ACKNOWLEDGEMENT
This work was supported in part by the Engineering Research Center
(no. 2011-0030075) and the Industrial Source Technology Development
Programs (no. 10043928).
REFERENCES
1. Blum, A., Raghavan, P., and Schieber, B., “Navigating in Unfamiliar
Geometric Terrain,” SIAM Journal on Computing, Vol. 26, No. 1,
pp. 110-137, 1997.
2. Deng, X., Kameda, T., and Papadimitriou, C., “How to Learn an
Unknown Environment. I: The Rectilinear Case,” Journal of the
ACM (JACM), Vol. 45, No. 2, pp. 215-245, 1998.
3. Dudek, G., Jenkin, M., Milios, E., and Wilkes, D., “Robotic
Exploration as Graph Construction,” IEEE Transactions on Robotics
and Automation, Vol. 7, No. 6, pp. 859-865, 1991.
4. Panaite, P. and Pelc, A., “Exploring Unknown Undirected Graphs,”
Proc. of the 9th Annual ACM-SIAM Symposium on Discrete
Algorithms, pp. 316-322, 1998.
5. Marinakis, D. and Dudek, G., “Pure Topological Mapping in Mobile
Robotics,” IEEE Transactions on Robotics, Vol. 26, No. 6, pp. 1051-
 2080 / SEPTEMBER 2015 INTERNATIONAL JOURNAL OF PRECISION ENGINEERING AND MANUFACTURING Vol. 16, No. 10

1064, 2010.
6. Cabrera-Mora, F. and Jizhong, X., “A Flooding Algorithm for
Multirobot Exploration,” IEEE Transactions on Systems, Man, and
Cybernetics, Part B: Cybernetics, Vol. 42, No. 3, pp. 850-863, 2012.
7. Moravec, H. P. and Elfes, A., “High Resolution Maps from Wide
Angle Sonar,” Proc. of IEEE International Conference on Robotics
and Automation, Vol. 2, pp. 116-121, 1985.
8. Yamauchi, B., “A Frontier-based Approach for Autonomous
Exploration,” Proc. of IEEE International Symposium on
Computational Intelligence in Robotics and Automation, pp. 146-
151, 1997.
20. Valencia, R., Morta, M., Andrade-Cetto, J., and Porta, J. M.,
“Planning Reliable Paths with Pose Slam,” IEEE Transactions on
Robotics, Vol. 29, No. 4, pp. 1050-1059, 2013.
21. Ryu, H. and Chung, W. K., “Local Map-based Exploration for
Mobile Robots,” Intelligent Service Robotics, Vol. 6, No. 4, pp. 199-
209, 2013.
22. Carpin, S., “Fast and Accurate Map Merging for Multi-Robot
Systems,” Autonomous Robots, Vol. 25, No. 3, pp. 305-316, 2008.
23. Lester, P., “A* Pathfinding for Beginners,” http://www.gamedev.net/
page/resources/_/technical/artificial-intelligence/a-pathfinding-for-
beginners-r2003 (Accessed 14 JUL 2015)

9. Keidar, M. and Kaminka, G. A., “Efficient Frontier Detection for 24. Lu, F. and Milios, E., “Robot Pose Estimation in Unknown
Robot Exploration,” The International Journal of Robotics Research, Environments by Matching 2D Range Scans,” Journal of Intelligent
Vol. 33, No. 2, pp. 215-236, 2014. and Robotic Systems, Vol. 18, No. 3, pp. 249-275, 1997.

10. Al khawaldah, M., and Nuchter, A., “Enhanced Frontier-based 25. Ryu, H. and Chung, W. K., “Efficient Scan Matching Method using
Exploration For Indoor Environment with Multiple Robots,” Direction Distribution,” Electronics Letters, Vol. 51, No. 9, pp. 686-
Advanced Robotics, ahead-of-print, pp. 1-13, 2015. 688, 2015.

11. Choi, K.-S. and Lee, S.-G., “Enhanced Slam for a Mobile Robot 26. Besl, P. J. and McKay, N. D., “A Method for Registration of 3-D
using Extended Kalman Filter and Neural Networks,” Int. J. Precis. Shapes,” IEEE Transactions on Pattern Analysis and Machine
Eng. Manuf., Vol. 11, No. 2, pp. 255-264, 2010. Intelligence, Vol. 14, No. 2, pp. 239-256, 1992.

12. Makarenko, A., Williams, S. B., Bourgault, F., and Durrant-Whyte, 27. Martinez, J. L., Gonzalez, J., Morales, J., Mandow, A., and Garcia-
H. F., “An Experiment in Integrated Exploration,” Proc. of IEEE/ Cerezo, A. J., “Mobile Robot Motion Estimation by 2D Scan
RSJ International Conference on Intelligent Robots and Systems, Matching with Genetic and Iterative Closest Point Algorithms,”
Vol. 1, pp. 534-539, 2002. Journal of Field Robotics, Vol. 23, No. 1, pp. 21-34, 2006.

13. Stachniss, C., Grisetti, G., and Burgard, W., “Information Gain-based 28. Yaakov, B.-S., Li, X., and Thiagalingam, K., “Estimation with
Exploration using Rao-Blackwellized Particle Filters,” Proc. of Applications to Tracking and Navigation,” New York: Johh Wiley
Robotics: Science and Systems, Vol. 2, pp. 65-72, 2005. and Sons, pp. 404-407, 2001.

14. Sim, R. and Roy, N., “Global A-Optimal Robot Exploration in 29. Cole, D. M. and Newman, P. M., “Using Laser Range Data for 3D
SLAM,” Proc. of IEEE International Conference on Robotics and Slam in Outdoor Environments,” Proc. of IEEE International
Automation, pp. 661-666, 2005. Conference on Robotics and Automation, pp. 1556-1563, 2006.

15. Pinies, P. and Tardos, J. D., “Large-Scale SLAM Building

Conditionally Independent Local Maps: Application to Monocular
Vision,” IEEE Transactions on Robotics, Vol. 24, No. 5, pp. 1094-
1106, 2008.

16. Estrada, C., Neira, J., and Tardos, J. D., “Hierarchical SLAM: Real-
Time Accurate Mapping of Large Environments,” IEEE Transactions
on Robotics, Vol. 21, No. 4, pp. 588-596, 2005.

17. Ahn, S. H., Choi, J., Doh, N. L., and Chung, W. K., “A Practical
Approach for EKF-SLAM in an Indoor Environment: Fusing
Ultrasonic Sensors and Stereo Camera,” Autonomous Robots, Vol.
24, No. 3, pp. 315-335, 2008.

18. Blanco, J.-L., Fernandez-Madrigal, J.-A., and Gonzalez, J., “A New

Approach for Large-Scale Localization and Mapping: Hybrid Metric-
Topological SLAM,” Proc. of IEEE International Conference on
Robotics and Automation, pp. 2061-2067, 2007.

19. Vallve, J. and Andrade-Cetto, J., “Potential Information Fields for

Mobile Robot Exploration,” Robotics and Autonomous Systems,
Vol. 69, pp. 68-79, 2015.