Autonomous Exploration in Unknown Indoor 2D Environments Using Harmonic Fields and Monte Carlo Integration

Abstract

Efficient autonomous exploration in unknown obstacle cluttered environments with interior obstacles remains a challenging task for mobile robots. In this work, we present a novel exploration process for a non-holonomic agent exploring 2D spaces using onboard LiDAR sensing. The proposed method generates velocity commands based on the calculation of the solution of an elliptic Partial Differential Equation with Dirichlet boundary conditions. While solving Laplace’s equation yields collision-free motion towards the free space boundary, the agent may become trapped in regions distant from free frontiers, where the potential field becomes almost flat, and consequently the agent’s velocity nullifies as the gradient vanishes. To address this, we solve a Poisson equation, introducing a source point on the free explored boundary which is located at the closest point from the agent and attracts it towards unexplored regions. The source values are determined by an exponential function based on the shortest path of a Hybrid Visibility Graph, a graph that models the explored space and connects obstacle regions via minimum-length edges. The computational process we apply is based on the Walking on Sphere algorithm, a method that employs Brownian motion and Monte Carlo Integration and ensures efficient calculation. We validate the approach using a real-world platform; an AmigoBot equipped with a LiDAR sensor, controlled via a ROS-MATLAB interface. Experimental results demonstrate that the proposed method provides smooth and deadlock-free navigation in complex, cluttered environments, highlighting its potential for robust autonomous exploration in unknown indoor spaces.

1. Introduction

Mobile autonomous exploration, also known as Active Simultaneous Localization and Mapping (A-SLAM) [1], in indoor environments, refers to the capability of robots to navigate and gather information in unknown environments with minimal or no human guidance. It is a challenging topic in the robotics field, as it seeks to address three interconnected challenges simultaneously: trajectory planning, localization, and mapping. Essentially, the primary objective for a mobile robot in such scenarios is to build a reliable map of an unknown region while navigating safely in it without any prior information.

This process relies on data collected from the robot’s onboard sensors, such as LiDAR [2], RGB-D cameras [3], and IMUs [4]. Such sensor data helps the robot to understand the surrounding environment and make intelligent decisions to move to the next state, expanding the explored space safely. The ability to autonomously map unknown areas is vital for numerous real-world applications, including domestic and service robotics, autonomous warehouse and factory operations, and also critical missions like search and rescue in disaster or hazardous areas without human responders to be in danger.

1.1. Related Works

Recent advances in robotics have led to the development of sophisticated algorithms that address the challenges of autonomous exploration. These exploration algorithms can be classified according to how they represent and exploit the exploration space to navigate and map unknown regions. One such category is the methods based on Reinforcement Learning (RL). In this method, the mobile robot learns an exploration policy by interacting with the environment and maximizing a reward function that encourages efficient coverage of the map and goal-directed behavior in unknown spaces. In the research community, the RL method is state-of-the-art, and a great number of works have been presented. In [5], the authors propose a Cumulative Curriculum Reinforcement Learning (CCRL) framework to enhance Deep RL-based autonomous exploration by introducing a size-adaptive map representation and accelerating training through a custom lightweight grid-based simulator. The work in [6] presents a Deep RL-based exploration architecture that predicts long-term visiting sequences for unexplored sub-regions and integrates Next Best of View (NBV) selection. And finally, the authors in [7] develop a Graph-based Spatiotemporal Neural Network (G-STNN) combined with Deep RL to guide autonomous robot exploration, using previous trajectories and exploration space boundaries for enhancing the decision-making. Similar approaches have been presented in [8,9,10,11].

Another class of algorithms is based on sampling methods, where the robot randomly samples points within the explored space and selects the next best goal to expand it. They usually use motion graph planners [12] to navigate through an unknown area to the next state following utility-based criteria. For example, in [13], the authors propose a Dynamic Exploration Planner (DEP) that uses incremental sampling and Probabilistic Roadmaps to efficiently and safely explore dynamic environments by optimizing paths based on the NBV point. In [14], a Sampling-based Frontier-Block Detection (SFBD) method is presented that improves RRT-based exploration by reducing redundant sampling and costly nearest-point searches through a block-based structure for efficient collision avoidance and frontier detection. Finally, the work in [15] introduces an improved sampling-based exploration method that extends RRT until frontier endpoints are found and evaluates them using an enhanced utility function, leading to more efficient indoor exploration in 2D environments.

Another type of algorithms is based on the frontiers exploration. In these exploration algorithms, the mobile robot identifies and moves toward free boundaries to expand the explored region, exploiting the information from occupied and free explored boundaries. The paper of Yamauchi [16] was the first attempt that addressed this kind of problem, where the agent navigates to the free frontiers with A* algorithm. A class of frontier-based methods, on which our paper relies, is the Harmonic Potential Field (HPF). The HPF provides the agent with smooth navigation to unknown areas and easy implementation. These fields are typically derived from the solution of an elliptic Partial Differential Equation (PDE) with boundary conditions. We obtain their solution with numerical methods as the analytical solution is intractable [17]. A first attempt was presented in [18], which applies a HPF to explore an unknown area, solving with relaxation methods the Boundary Value Problem (BVP) with Dirichlet condition. That HPF leads the agent to the free frontiers (low values), avoiding collision with obstacles (high values). However, such kind of condition exhibits large flat areas of the potential, which result in the agent being stuck in regions which are far away from the frontier. Certain works proposed solutions of the above problem, such as [19], which applies potential rails that guide the robot to regions that are either unexplored or were visited a long time ago. The work in [20] develops a strategy to distort the potential field without loosing the qualities of the HPF, and the work in [21] enhances the BVP for integrated exploration by introducing active loop closure through dynamic barriers and a Voronoi-based local update window. Moreover, in the research community, there are projects which apply another boundary condition, the Neumann. The papers [22,23] solve the BVP using as a numerical method the Fast Multipole accelerated Boundary Element Method (FMBEM), which yields linear complexity in terms of computational effort and required memory. In [24], the authors use the panel method to create an HPF that leads the agent to the goal point. Finally, the paper [25] introduces a novel reactive, frontier-based exploration scheme that utilizes harmonic transformation to map a workspace onto a disk, ensuring safe navigation and enabling selective exploration of frontiers. Alternatively, Sawhney et al. [26] proposed another method to solve the BVP based on Brownsian Motion, known as the Walking on Sphere (WoS) Algorithm, which is a stochastic process applying Monte Carlo Integration (MCI) [27]. This method calculates the potential, and also its gradient, of a linear elliptic equation at any point in a connected region with different boundary value conditions, e.g., Dirichlet [26], Neumann [28], and Robin [29]. The aforementioned method is a grid-free algorithm and has been applied to geometrical problems in computer graphics exhibiting low computational cost.

1.2. Contributions

In this work, we address the problem of autonomous exploration for a mobile agent in an unknown indoor 2D environment that may contain interior obstacles. Our focus is on the map building problem and we assume the agent calculates its position via a certain localization process. We calculate velocity commands for navigating the agent by solving an elliptic PDE with Dirichlet condition over the explored space boundary. Most specifically, we solve a Poisson equation with a source point on the closest located free frontier. In this way, the agent escapes from potential flat regions created by the Dirichlet condition. The potential function associated with the source point is defined using a Hybrid Visibility Graph (HVG), which gives an estimate of the distance to the source point. The HVG involves the vertices and edges of the explored space boundary, as well as the minimum-length edges between the interior obstacles, enabling more accurate field estimation. Finally, we use the stochastic process WoS [26] for computational and memory efficiency. The key properties of our algorithm are (1) it is grid-free, i.e., it does not need to discretize the explored space to calculate the field and (2) we can calculate the gradient at the agent’s position without finding the potential field anywhere, thus reducing significantly the computational cost. We validated the approach using a real-world platform: an AmigoBot equipped with a LiDAR sensor, controlled via a ROS-MATLAB interface. Experimental results demonstrate that the proposed method provides smooth and deadlock-free navigation in complex, cluttered environments, highlighting its potential for robust autonomous exploration in unknown indoor spaces. In the results, we provide a comparative analysis of our method against other exploration approaches, aiming to present its advantages and disadvantages.

The rest of this paper is organized as follows: in Section 2, we formulate mathematically the exploration problem, in Section 3, we discuss the basic theory of elliptic PDEs with Dirichlet conditions and we present the WoS algorithm. In Section 4, we present the implementation of the proposed exploration process, and in Section 5, we describe the tools for realizing the real-world experiment. In Section 6, we present the results of the proposed exploration algorithm in three studies, and in Section 7, we discuss the results. Finally, we draw conclusions and future research directions.

1.3. Notations

1.3.1. Mathematic Symbols

For any set $\mathcal{A}\subset {\mathbb{R}}^n$, we use $\partial A$ to denote its boundary, $int\left(\mathcal{A}\right)$ to denote its interior, and $\left|\mathcal{A}\right|$ to denote its volume. We use $p^{\mathcal{A}}$ to denote a probability density function on $\mathcal{A}$ and write $x\sim p^{\mathcal{A}}$ for a random point $x\in \mathcal{A}$ drawn from $p^{\mathcal{A}}$. The uniform probability density function on $\mathcal{A}$ is $\mathcal{U}\left(A\right)=1/\left|\mathcal{A}\right|$. Moreover, we use $B(x,r)$ to denote a ball contained in n-dimensional space ${\mathbb{R}}^n$ with radius r centered at x. Additionally, $d(x,\mathcal{A})=mi{n}_{y\in \partial \mathcal{A}}\left|\right|y-x\left|\right|$ is denoted as the Euclidean distance from a point $x\in \mathcal{A}$ to the closest point on the $\partial \mathcal{A}$ and $\overline{x}=argmi{n}_{y\in \partial \mathcal{A}}\left|\right|y-x\left|\right|$ is denoted as the closet point. Furthermore, we define the $\epsilon$-shell around $\partial A$ as $\partial {\mathcal{A}}^{\epsilon }=\{x\in \mathcal{A}:||x-\overline{x}\left|\right|<\epsilon \}$. Finally, we use $\Delta$ for the Laplace operator on ${\mathbb{R}}^n$.

1.3.2. Pseudocode Formation

For our exploration method, we introduce pseudocodes to clarify the WoS algorithm and the structure of the HVG. The notation for arrays and sets aligns with the MATLAB framework. Additionally, we denote a zero matrix as zeros$(N,M)$ and a matrix of ones as ones$(N,M)$, consistent with MATLAB properties.

2. Problem Formulation

In this section, we formulate our problem. First, we define the unknown workspace and the properties of the mobile agent, including its kinematic model and the onboard sensor model. Then, we discuss the properties of the explored region. Finally, we explain the data structure in which we store the unexplored region.

2.1. Workspace and Kinematics

We denote as W the unknown workspace, a compact and connected subset of ${\mathbb{R}}^2$ and $W_f\triangleq int\left(W\right)$ the free space. Let $\mathcal{O}=\partial W$ consist of the mutually disjoint sets of the obstacle boundaries, ${\mathcal{O}}_i,i\in \{1,\dots ,M\}$ as well as of the external boundary ${\mathcal{O}}_0$, such that $\mathcal{O}={\bigcup }_{i=0,\dots ,M}{\mathcal{O}}_i$. For this paper, we assume that the workspace W is time invariant and does not involve dynamic obstacles.

For simplicity, we use a differential mobile agent, which is a disk-shaped robot with radius $\rho$. The configuration space of the agent is defined as $W_c=W_f/\partial W^{\rho }$. The kinematic equation of a differential drive robot is given by:

$$\left\{\begin{array}{c}{\dot{p}}_x=v_l·cos\left(\theta \right)\hfill \\ {\dot{p}}_y=v_l·sin\left(\theta \right)\hfill \\ \dot{\theta }=v_a\hfill \end{array}\right.$$

(1)

where $p={[p_x,p_y]}^T$ is the position of the robot, the orientation of the agent is $\theta \in [-\pi ,\pi ]$, and $v_l$ and $v_a$ denote the linear and angular velocity of the agent with $v={[v_l,v_a]}^T$. Notice that the agent relies on two motions to navigate in its free configuration space $W_c$; it rotates and moves forward. Moreover, we assume that the position and orientation of the agent are known through the exploration processes via a localization algorithm that assumes a known initial position $p_0$.

Additionally, we equip the agent with a range sensor, which gives the robot the capability to determine how close it is to the workspace boundary and explore unknown regions. The range sensor in each specific time step creates a sensing space $\mathcal{S}(p;R_{max})=\{p_c\in \partial W_c:\left|\right|p-p_c\left|\right|\le R_{max}\}$, where $R_{max}>0$ is the maximum range of the sensor. We assume that the minimum range $R_{min}$ of the sensor is rather small with $\rho >R_{min}$.

2.2. Explored Region

We define $\mathcal{P}(t_s,t_f)$ as the path traversed by the agent during the time interval $[t_s,t_f]$; for brevity, when $t_s=0$ and $t_f>0$, $\mathcal{P}\left(t_f\right)\equiv \mathcal{P}(0,t_f)$. Given a continuous path $\mathcal{P}\left(t_f\right)\subset W_c$, we define the explored region of W as $\mathcal{E}\left(\mathcal{P}\left(t_f\right)\right)={\bigcup }_{p\in \mathcal{P}}\mathcal{S}(p;R_{max})$. The boundary of the explored region at some time instance is denoted as $\partial \mathcal{E}=\partial {\mathcal{E}}_f\cup \partial {\mathcal{E}}_o$, where $\partial {\mathcal{E}}_f$ and $\partial {\mathcal{E}}_o$ belong to the agent’s known free space $\partial {\mathcal{E}}_f\subset W_f$ and workspace boundaries $\partial {\mathcal{E}}_o\subseteq \partial W$, respectively. In general, each of $\partial {\mathcal{E}}_f$ and $\partial {\mathcal{E}}_o$ consists of zero or more disjoint line curves, that is, $\partial {\mathcal{E}}_f={\bigcup }_{i\in {\mathcal{I}}_f}\partial {\mathcal{E}}_{fi}$ and $\partial {\mathcal{E}}_o={\bigcup }_{i\in {\mathcal{I}}_o}\partial {\mathcal{E}}_{oi}$ with ${\mathcal{I}}_f=\{1,2,\dots ,N_f\}$ and ${\mathcal{I}}_o=\{1,2,\dots ,N_o\}$, indexing the distinct parts of the respective set.

One should note that any point $p\in \partial {\mathcal{E}}_f$ that enters the agent’s sensing region becomes instantly part of $int\left(\mathcal{E}\right)$. In this way, as the agent approaches the free boundary, the interior of the explored space augments. In contrast, occupied boundary points will remain on the boundary, since if some point $p\in \partial W\cap \mathcal{S}$, then $p\in \partial \mathcal{S}$ [22]. So the problem that we try to solve is formulated as follows.

Problem. 

Design a control law $u=f(p,\theta ,t,\mathcal{E})$ such that there exists a finite time instant $T>0$ for which $\mathcal{E}\left(\mathcal{P}\right(t\left)\right)=W,\forall t\ge T$.

2.3. Map Representation

The unknown workspace is discretized in a 2D grid, called an occupancy matrix [30]. We use this kind of matrix so that we can estimate the real form of the workspace. This grid is a 2D matrix consisting of cells $m_i$ centered at $c_i$, $i\in {\mathcal{I}}_G$ with ${\mathcal{I}}_G=\{1,2,\dots ,N_G\}$. To associate each point $p\in W$ with a cell, we define a map $m\left(p\right)=m_i$, where $\left|\right|c_i-p{\left|\right|}_{\infty }\le {\displaystyle \frac{m_r}{2}}$ and $m_r$ denotes the grid resolution. We attach in each cell a binary occupancy value $Pr\left(m\right(p\left)\right):W\to [0,1]$, specifying whether the cell is free ($Pr\left(m\right(p\left)\right)\to 0$), occupied ($Pr\left(m\right(p\left)\right)\to 1$), or unknown ($Pr\left(m\right(p\left)\right)=0.5$). In the exploration process, we use the binary occupancy map, which takes zero value for free and the unknown cells ($Pr\left(m\right(p\left)\right)=0$) and true value for the occupied ones ($Pr\left(m\right(p\left)\right)=1$). This structure is applied for simplicity and minimization of both memory and time complexity of the algorithm. Thus, we classify the points of the explored boundary, $p\in \partial \mathcal{E}$, as occupied or free and we also define the sets $\partial {\mathcal{E}}_o=\{p\in \partial \mathcal{E}:Pr\left(m\left(p\right)\right)=1\}$ and $\partial {\mathcal{E}}_f=\{p\in \partial \mathcal{E}:Pr\left(m\left(p\right)\right)=0\}$ or $\partial {\mathcal{E}}_f=\partial \mathcal{E}\setminus \partial {\mathcal{E}}_o$. Finally, we initialize the values of the occupancy grid map with zero value.

Remark 1. 

We apply the binary occupancy map for mapping because it is particularly simple and well suited for our proposed method. Unlike other methods that might benefit from detailed probabilistic representations, our approach does not necessitate intermediate probabilities of matrix cells. This choice contributes to the low memory and time complexity of our exploration method.

3. Solving PDEs with Monte Carlo Integration

3.1. Linear Elliptic Equation

The central idea behind the design of our exploration controller is to find a potential field $\phi \left(p\right):\mathcal{E}\to \mathbb{R}$ by solving a Poisson equation, subject to boundary conditions that assign low potential to unexplored frontiers and high potential to boundaries corresponding to obstacles. The Poisson equation with pure Dirichlet boundary condition is:

$$\begin{array}{cccc}\hfill \Delta \phi \left(p\right)& =f\left(p\right),\hfill & \hfill & p\in \mathcal{E}\hfill \\ \hfill \phi \left(p\right)& =g\left(p\right),\hfill & \hfill & p\in \partial \mathcal{E}\hfill \end{array}$$

(2)

Here, $f\left(p\right):\mathcal{E}\to \mathbb{R}$ is the source term and $g\left(p\right):\partial \mathcal{E}\to \mathbb{R}$.

Under the Dirichlet boundary condition, the values of the potential function at the boundaries are fixed, assigning the highest values to obstacles and the lowest to the unexplored boundary. Thus, this formulation generates a vector field that safely guides the agent towards the unexplored area. However, in complex environments, the agent may become trapped in regions distant from free frontiers, where the potential field becomes almost flat, and consequently the agent’s velocity nullifies as the gradient vanishes. To address this problem, a source point is introduced at the nearest free frontier relative to the agent’s position so that the agent moves away from low-gradient regions. The definition of the source function $f\left(p\right)$ will be discussed later in the next section.

The solution of the Poisson equation at any point $p\in \mathcal{E}$ is based on the generalized mean value property of Laplace equation.

Proposition 1 (Generalized Mean Value Property [31]).

If the boundary of the exploration space $\partial \mathcal{E}$ is sufficiently smooth, and the solution of (2) with the source term $f\left(p\right)$ is continuous in $\mathcal{E}$, then the solution of the Poisson Equation (2) attains the integral term:

$$\phi \left(p\right)={\displaystyle \frac{1}{|\partial B(p\left)\right|}}{\int }_{\partial B\left(p\right)}\phi \left(y\right)dy+{\int }_{B\left(p\right)}f\left(y\right)G^{B\left(p\right)}(p,y)dy$$

(3)

where $B\left(p\right)$ is the largest ball contained in $\mathcal{E}$ with radius R centered at p, and $G^{B\left(p\right)}(p,y)$ is the Green’s function for the ball (see Appendix B).

Notice that the above form attains a probabilistic interpretation, as the value $\phi \left(p\right)$ at the center of the sphere is the uniform average of the boundary values on the surface of the ball plus the average of the source term $f\left(p\right)$ w.r.t. the Green function for the ball. Therefore, if the boundary values on the sphere are known, we may apply the MCI method (see Appendix A) to estimate the solution $\phi \left(p\right)$.

However, the solution of the Poisson equation is not sufficient. We have to calculate the gradient of the solution $\nabla \phi \left(p\right)$ in order to determine the velocity commands of the controller. In [26], the authors provide the gradient of the solution based on Malliavin Calculus [32]:

$$\nabla \phi \left(p\right)={\displaystyle \frac{1}{\left|B\right(p\left)\right|}}{\int }_{\partial B\left(p\right)}\phi \left(y\right)\nu \left(y\right)dy+{\int }_{B\left(p\right)}f\left(y\right)\nabla G^{B\left(p\right)}(p,y)dy$$

(4)

where $\nu \left(y\right):=(y-p)/R$ is the outward unit normal at y.

3.2. The Walking on Sphere

In this subsection, we discuss the algorithm that we will use to find the solution of (2) and its gradient at a specific position in the explored region $\mathcal{E}$, following the integral (4). According to [26], we can find the solution (3) following Kakutani’s principle.

Definition 1 (Kakutani’s principle [33]).

the solution value $\phi \left(p\right)$ at any point $p\in \mathcal{E}$ is equal to the expected value $E\left[g\right(y\left)\right]$, where $y\in \partial \mathcal{E}$ is the first boundary point reached by a random walk starting at p.

For simplicity, let us assume $f\left(p\right)=0$. Following the Kakutani’s principle or Brownian motion process, we can exploit the occupancy grid map by taking random steps from a starting cell $m\left(p_0\right)$ until reaching $\partial \mathcal{E}$ and get the specific Dirichlet value. Nevertheless, this process has a lot of computational effort, as we decrease the resolution of the grid and the unexplored workspace is quite large. For that reason, we use a more efficient grid-free algorithm, which was proposed in [34], called Walking on Sphere. Essentially, this algorithm proposes taking the largest steps from the starting point $p_0$ over a sphere boundary centered at $p_0$ with radius the minimum distance to $\partial \mathcal{E}$. This walk is equal to the walk occurring from Brownian motion, since the point that we take on the sphere is independent of which steps we take in the sphere, as we see in Figure 1a. Thus, the WoS algorithm provides less computational and memory complexity.

The WoS algorithm for finding the solution (3) of the Poisson equation relies on a recursive Monte Carlo single-sample estimator at point $p_k\in \mathcal{E}$:

$$\widehat{\phi }\left(p_k\right):=\left\{\begin{array}{cc}g\left(\overline{p_k}\right),\hfill & \mathrm{if}{p}_k\in \partial {\mathcal{E}}^{\epsilon }\hfill \\ {\displaystyle \frac{1}{|\partial B(p_k,r_k\left)\right|}}{\displaystyle \frac{\widehat{\phi }\left(p_{k+1}\right)}{p^{\partial B(p_k,r_k)}\left(p_{k+1}\right)}}+{\displaystyle \frac{G^{B(p_k,r_k)}f\left(y_{k+1}\right)}{p^{B(p_k,r_k)}\left(y_{k+1}\right)}},\hfill & \mathrm{if}{p}_k\notin \partial {\mathcal{E}}^{\epsilon }\hfill \end{array}\right.$$

(5)

where $r_k=mi{n}_{p\in \partial \mathcal{E}}\left|\right|p-p_k\left|\right|$ is the closest distance from point $p_k$ to explored region boundary $\partial \mathcal{E}$, $p_{k+1}\in \partial B(p_k,r_k)$ and $y_{k+1}\in B(p_k,r_k)$ are sampled from uniform probabilities $p^{\partial B(p_k,r_k)}=\mathcal{U}(\partial B(p_k,r_k))$ and $p^{B(p_k,r_k)}=\mathcal{U}\left(B(p_k,r_k)\right)$, respectively. Because we deal with the problem in the 2D world, then the above estimator becomes:

$$\widehat{\phi }\left(p_k\right):=\left\{\begin{array}{cc}g\left(\overline{p_k}\right),\hfill & \mathrm{if}{p}_k\in \partial {\mathcal{E}}^{\epsilon }\hfill \\ \widehat{\phi }\left(p_{k+1}\right)+\pi r_k^{2}f\left(y_{k+1}\right)G^{B(p_k,r_k)},\hfill & \mathrm{if}{p}_k\notin \partial {\mathcal{E}}^{\epsilon }\hfill \end{array}\right.$$

(6)

Essentially, as we also see in Figure 1b, the algorithm determines a random walk starting at point $p_0$, finds the largest ball $B(p_0,r_0)$ contained in $\mathcal{E}$, picks a point $p_1\in \partial B(p_0,r_0)$ and another one $y_1\in B(p_0,r_0)$, and continues the same process with starting point $p_1$. The algorithm terminates when $p_k$ is in the region $\partial {\mathcal{E}}^{\epsilon }$, e.g., $r_k<\epsilon$, and then we get the Dirchlet value $g\left(\overline{p_k}\right)$. For $N>0$ random walks, the solution of the Poisson equation is:

$$\phi \left(p_0\right)={\displaystyle \frac{1}{N}}\sum _{i=1}^N\widehat{\phi }\left(p_0\right)$$

(7)

Algorithm 1 involves the process that we discussed above. It should be noted that in line 7, the function closestPointOfBoundary returns the closest point $\overline{p_i^{\prime }}\in \partial \mathcal{E}$ from a point $p_i^{\prime }\in \mathcal{E}$ and the distance $r_i$ of these points. Also, in lines 11 and 13, we call the sampling functions over a ball. The function samplePointInBall samples a point $y_i\sim \mathcal{U}\left(B(p_i^{\prime },r_i)\right)$, and samplePointOnBallBoundary samples a new point $p_i^{\prime }\sim \mathcal{U}(\partial B(p_i^{\prime },r_i))$.

Algorithm 1 WalkingOnSpherePoissonEquation$(p_0,\mathcal{E},N,\epsilon )$

Input: Starting point $p_0$, explored region $\mathcal{E}$, N number of walks, $\epsilon$ termination parameter.     Output: The solution of the Poisson Equation $\phi \left(p_0\right)$                             ▹ Initialize the Poisson’s solution 1: $\phi \left(p_0\right)\leftarrow 0$                                   ▹ Start the process 2: $i\leftarrow 1$ 3: while $i\le N$ do 4:     $p_i^{\prime }\leftarrow p_0$ 5:     $\phi \left(p_i^{\prime }\right)\leftarrow 0$                                  ▹ Start the i-th walk 6:     while true do                        ▹ Find the closest point from point $p_i^{\prime }$ to $\partial \mathcal{E}$ 7:         $\overline{p_i^{\prime }},r_i\leftarrow$ closestPointOfBoundary$(p_i^{\prime },\mathcal{E})$                          ▹ Check if $p_i^{\prime }$ is closed enough to the $\partial \mathcal{E}$ 8:         if $r_i<\epsilon$ then 9:            break 10:         end if                          ▹ Sample point in the ball the $B(p_i^{\prime },r_i)$ 11:         $y_i\leftarrow$ samplePointInBall$(p_i^{\prime },r_i)$                                ▹ Add the source value 12:         $\phi \left(p_i^{\prime }\right)\leftarrow \phi \left(p_i^{\prime }\right)+\pi r_i^{2}f\left(y_i\right)G^{B(p_i^{\prime },r_i)}(p_i^{\prime },r_i)$                      ▹ Sample new point on the boundary $\partial B(p_i^{\prime },r_i)$ 13:         $p_i^{\prime }\leftarrow$ samplePointOnBallBoundary$(p_i^{\prime },r_i)$ 14:         $i\leftarrow i+1$ 15:     end while                               ▹ Add the Dirichlet Value 16:     $\phi \left(p_0\right)\leftarrow \phi \left(p_0\right)+\phi \left(p_i^{\prime }\right)+g\left(\overline{p_i^{\prime }}\right)$ 17: end while                              ▹ Caclulate the Mean Value 18: $\phi \left(p_0\right)\leftarrow {\displaystyle \frac{1}{N}}\phi \left(p_0\right)$ 19: return: $\phi \left(p_0\right)$

Since we analyzed how to find the solution of the Poisson equation, now we will present how to calculate its gradient $\nabla \phi \left(p_0\right)$. According to [26], a basic WoS estimator for calculating the gradient of the solution $\phi \left(p_0\right)$ for the ball $B(p_0,r_0)$ is shown below:

$$\nabla \phi \left(p_0\right)={\displaystyle \frac{1}{N_G}}(\sum _{i=1}^{N_G}\nabla \widehat{\phi }\left(p_0\right)+\pi r_0^{2}f\left(y_i\right)\nabla G^{B(p_0,r_0)}(p_0,y_i)),$$

(8)

where $\nabla \widehat{\phi }\left(p_0\right)={\displaystyle \frac{2}{r_0}}\phi \left(p_1\right)\nu \left(p_1\right)$. Essentially, in (8), we sample $N_G$ uniform points on the boundary of the largest sphere in $\mathcal{E}$ and calculate the solution $\phi \left(p_1\right)$ for each point $p_1$ with Algorithm 1. Notice that instead of sampling randomly in the $\partial B(p_0,r_0)$, we rather use a deterministic method so that each point maintains an approximately equal geodesic distance from its neighbors, as we present in Figure 2. In this manner, we do not violate the uniform distribution properties. Furthermore, we uniformly sample in the ball $B(p_0,r_0)$$N_G$ points $y_1$ to calculate the Green term of our estimator. In Algorithm 2, we demonstrate the calculation process of the gradient. The extra function that is added to the algorithm is the outwardVectorPoints that returns an array ${\mathbf{p}}_{\mathbf{i}}$ of dimension ${\mathbb{R}}^{N_G\times 2}$ with the radial directions of points sampled as we said before.

Algorithm 2 WalkingOnSphereGradientSolution$(p_0,\mathcal{E},N_G,N,\epsilon )$

Input: Starting point $p_0$, explored region $\mathcal{E}$, $N_G$ number of samples for calculating the gradient of boundary term, N number of walks, $\epsilon$ termination parameter.     Output: The gradient of the solution of the Poisson Equation $\nabla \phi \left(p_0\right)$                     ▹ Initialize the gradient Poisson’s solution 1: $\nabla \phi \left(p_0\right)\leftarrow {[0,0]}^T$                 ▹ Initialize the outward vector points ${\mathbf{p}}_{\mathbf{1}}\in {\mathbb{R}}^{N_G\times 2}$ 2: $\overline{p_0},r_0\leftarrow$ closestPointOfBoundary$(p_0,\mathcal{E})$ 3: ${\mathbf{p}}_{\mathbf{1}}\leftarrow$ outwardVectorPoints$(p_0,r_0,N_G)$                          ▹ Calculate Gradient Solution 4: $i\leftarrow 1$ 5: while $i\le N_G$do 6:     $p_i\leftarrow {\mathbf{p}}_{\mathbf{1}}\left[i\right]$ 7:     $\phi \left(p_i\right)=$ WalkingOnSpherePoissonEquation$(p_i,\mathcal{E},N,\epsilon )$                      ▹ Sample point in the ball the $B(p_0,r_0)$ 8:     $y_i\leftarrow$ samplePointInBall$(p_0,r_0)$                    ▹ Add the i-th gradient of boundary term 9:     $\nabla \phi \left(p_0\right)\leftarrow \nabla \phi \left(p_0\right)+{\displaystyle \frac{2}{r_0}}\phi \left(p_i\right)\nu \left(p_i\right)+\pi r_0^{2}f\left(y_i\right)\nabla G^{B(p_0,r_0)}(p_0,y_i))$ 10: end while                           ▹ Caclulate the gradient 11: $\nabla \phi \left(p_0\right)\leftarrow {\displaystyle \frac{1}{N_G}}\nabla \phi \left(p_0\right)$ 12: return: $\nabla \phi \left(p_0\right)$

Remark 2. 

The complexity of the WoS algorithm depends on the number of sampled points as well as on the termination factor $\epsilon$ that effects the number of steps needed to reach the $\partial {\mathcal{E}}^{\epsilon }$. According to [35], the typical number of steps for a single walk is $O(ln(1/\epsilon \left)\right)$. Consequently, the time complexity of Algorithm 2 is $O(N_G·N·ln(1/\epsilon ))$, which can be computationally expensive. In order to resolve this, we modify the algorithm by introducing a dynamic, vectorized implementation. This approach allows the execution of multiple parallel walks, approaching $O(ln(1/\epsilon \left)\right)$ step complexity, and improves the overall computational efficiency of the WoS algorithm. The dynamic modification of the algorithms is not complicated.

4. Implementation of the Exploration Process

In this section, we discuss the process followed to address the exploration problem. More specifically, we present the controller architecture and we provide the safety and completeness guarantees of the proposed control law.

4.1. Control Architecture

In Figure 3, we present the main steps of the proposed method. First, we gather data from the range sensor—set $\mathcal{S}(p;R_{max})$)—with the map of the workspace and the position of the agent. The agent updates this data as it moves in the workspace. Afterwards, in the block Define Data Structure, we construct the explored space and the Hybrid Visibility Graph, and we determine the boundary value conditions and source function. Then, we check if the map is complete. If it is not, we calculate in the block Calculation Velocity Commands the velocity commands of the agent through the WoS algorithm and execute it. As the agent moves, in the block Find Dead-End Regions, we inspect if some region is Dead-End, e.g., a region that the agent has explored and does not need to traverse it again. If the dead-end algorithm finds a region in block Define Data Structure, it removes it from the explored set $\mathcal{E}$. So, the above exploration process is recursive and stops when the map is fully explored.

4.2. Velocity Control Law

The velocity control law is given by:

$$u=-{\displaystyle \frac{\nabla \phi \left(p\right)}{\left|\right|\nabla \phi \left(p\right)\left|\right|+\eta }}$$

(9)

where $\eta >0$ is a small positive constant so as to prevent the discontinuity when $\nabla \phi \to 0$. The control law is a normalized vector w.r.t. the x-coordinate and y-coordinate, i.e., $u={\left[\begin{array}{cc}{u}_x,& u_y\end{array}\right]}^{\mathsf{T}}$.

As we mentioned previously, the agent moves in two ways: it rotates to reduce the orientation error $e_{\theta }={\theta }_d-\theta$, where ${\theta }_d=atan2\left({\displaystyle \frac{u_y}{u_x}}\right)$, and as $e_{\theta }\to 0$, the agent moves forward, following the linear and angular velocity commands defined as $v_l=K_l·s$ and $v_a=K_a·e_{\theta }$, where $K_l,K_a>0$ are the gains of linear and angular velocity and $s=S_a\left(d(p,\partial \mathcal{E})\right)$, with $\alpha >0$, where $S_{\alpha }(.)$ is a bump function that asymptotically approaches zero as the agent approaches the boundary. A candidate function is [22]:

$$S_{\alpha }=\left\{\begin{array}{cc}1,\hfill & x>\alpha \hfill \\ 3{\left({\displaystyle \frac{x}{a}}\right)}^2-2{\left({\displaystyle \frac{x}{a}}\right)}^3,\hfill & 0\le x\le a\hfill \\ 0,\hfill & x<0\hfill \end{array}\right.$$

(10)

Notice that whenever the minimum Euclidean distance $d(p,\partial \mathcal{E})<\alpha$, the agent slows down.

4.3. Structure of Explored Region and Definition of Hybrid Visibility Graph

The boundary of the explored space $\partial \mathcal{E}$ involves disjoint continuous curves of free and occupied cells, $\partial {\mathcal{E}}_f$ and $\partial {\mathcal{E}}_o$, respectively, which form a polygon in 2D space, defined by a connected undirected graph ${\mathcal{G}}_{\mathcal{E}}=(V_{\mathcal{E}},E_{\mathcal{E}},w_{\mathcal{E}})$, with $V_{\mathcal{E}}=\{v_{01},v_{02},\dots ,v_{0n_0},v_{11},\dots ,v_{N_h{n}_h}\}$ denoting the vertices of the polygon, where $n_0$ is the number of vertices of the exterior boundary of the polygon, $n_i,i=1,\dots ,n_h$ is the number of vertices in the interior, $E_{\mathcal{E}}=\{(v_{01},v_{02}),(v_{02},v_{03}),\dots ,(v_{0n_0},v_{01}),(v_{11},v_{12}),\dots ,\left(v_{N_h{n}_h},v_{N_{h}1}\right)\}$ is the edge list of the graph, and $w_{\mathcal{E}}=\{w_{01},w_{02},\dots ,w_{0n_0},w_{11},\dots ,w_{N_h{n}_h}\}$ denotes the weight’s set of the graph’s edges. Notice that the distances of the edges are the same and equal to the resolution of the map $m_r$. Beyond the aforementioned graph, we define a set of points ${\mathcal{Q}}_m=\{p_{01},p_{02},\dots ,p_{0n_0},p_{11},\dots ,p_{N_h{n}_h}\}$ that belong to the middle of the edges, with the total number of them to be $N_{V_{\mathcal{E}}}$. Some of them are on the free boundary $\partial {\mathcal{E}}_f$ and others on the occupied $\partial {\mathcal{E}}_o$, denoted as ${\mathcal{Q}}_{mf},{\mathcal{Q}}_{mo}\subset {\mathcal{Q}}_m$, respectively. Also, the sets ${\mathcal{Q}}_{mf}={\bigcup }_{i\in {\mathcal{I}}_f}{\mathcal{Q}}_{m{f}_i}$ and ${\mathcal{Q}}_{mo}={\bigcup }_{i\in {\mathcal{I}}_o}{\mathcal{Q}}_{m{o}_i}$ involve the subsets of the free and occupied middle points of the discretized curves.

Now, in order to solve the problem of the flat gradient, we first have to define the HVG. The HVG ${\mathcal{G}}_{\mathcal{H}}=(V_{\mathcal{H}},E_{\mathcal{H}},w_{\mathcal{H}})$ is a connected undirected graph. Its vertices $V_{\mathcal{H}}$ involve the set of middle points ${\mathcal{Q}}_m$ and the set of points forming minimum-length edges between exterior and interior obstacles, denoted by ${\mathcal{Q}}_m^{\prime }$. In Algorithm 3, we introduce the steps for constructing this graph. We initialize the ${\mathcal{G}}_{\mathcal{H}}$ by adding the middle points ${\mathcal{Q}}_m$, edge list of this set, and the edge’s weight such as in the ${\mathcal{G}}_{\mathcal{E}}$ (lines 1–3). We use the boolean function isInvolveObstacles to check if the ${\mathcal{G}}_{\mathcal{E}}$ involves inner obstacles or holes (lines 4–6). If the explored space has no holes, the algorithm returns the pre-initialized graph. However, if holes are present, we begin the process of finding the minimum-length edges, connecting each exterior and interior obstacle. First of all, we separate the holes from the explored region and store them in a set $\mathcal{H}=\{{\mathcal{H}}_0,\dots ,{\mathcal{H}}_{M_h}\}$ where ${\mathcal{H}}_0$ represents the exterior boundary of the explored space and ${\mathcal{H}}_i,i=1,\dots ,{\mathcal{H}}_{M_h}$ the boundary of interior obstacles. This separation is handled by the function getObstaclesSet, a property of structure ${\mathcal{G}}_{\mathcal{E}}$ (line 7). After separating the obstacles, we proceed with the connection process as detailed in the lines 8–21. This involves taking two obstacles and using the function findMinimumVisibleEdge to locate points that make the minimum-length edge and not cross the occupied cells. If the above properties are true, the boolean variable isVisible will be equal to the true value (line 12). If isVisible is false, we continue the process; otherwise, we start the process by adding this edge to the ${\mathcal{G}}_{\mathcal{H}}$ (lines 13–15). Before adding the edge to the graph, the function discretizeEdge discretizes it into smaller segments, each with a distance of $m_r$ (line 16). Finally, we add the newly generated vertices $q_m^{\prime }\subset {\mathcal{Q}}_m^{\prime }$ and edges to ${\mathcal{G}}_{\mathcal{H}}$ (lines 17–19). At the end of the process, the algorithm returns the final HVG (line 22). In Figure 4, we present some results of this algorithm, one workspace without (Figure 4a) and one with (Figure 4b) obstacles.

Remark 3. 

The time and memory complexity of the aforementioned process depend on the number of explored interior obstacles. As the number of holes increases in the explored region, our approach slows down when extracting the new state of the agent. To address this, we apply techniques like the Dead-End algorithm (Section 4.5), which restricts the number of obstacles within the exploration space.

The extraction of this graph is helpful because we have to make an approximation of the geodesic distance from any point in $\mathcal{E}$ to free continuous curves. In that way, we can determine the source function that attracts the agent from the dead lock regions to the free space.

Algorithm 3 DefineHybricVisibilityGraph$({\mathcal{G}}_{\mathcal{E}},{\mathcal{Q}}_m,N_{V_{\mathcal{E}}})$

Input: The explored region graph ${\mathcal{G}}_{\mathcal{E}}$, the middle point ${\mathcal{Q}}_m$ of the edges in the set $E_{\mathcal{E}}$, $N_{V_{\mathcal{E}}}$ the number of middle points.     Output: The HVG ${\mathcal{G}}_{\mathcal{H}}$                                   ▹Initialize the ${\mathcal{G}}_{\mathcal{H}}$ 1: ${\mathcal{G}}_{\mathcal{H}}.V_{\mathcal{H}}\leftarrow$ addnodes$\left(Q_m\right)$ 2: ${\mathcal{G}}_{\mathcal{H}}.E_{\mathcal{H}}\leftarrow$ addedges$(Q_m,{[Q_m{(2:end,:)}^T,Q_m{(1,:)}^T]}^T)$ 3: ${\mathcal{G}}_{\mathcal{H}}.w_{\mathcal{H}}\leftarrow$ addweight$(m_r·$ ones$(N_{V_{\mathcal{E}}},1)$                   ▹Check if explored region doesn’t involve obstacles 4: if not(isInvolveObstacles$\left({\mathcal{G}}_{\mathcal{E}}\right)$) then 5:     return: $G_{\mathcal{H}}$ 6: end if             ▹Get the obstacles set $\mathcal{H}=\{{\mathcal{H}}_0,\dots ,{\mathcal{H}}_{M_h}\}$ from the explored region 7: $\mathcal{H},M_h\leftarrow {\mathcal{G}}_{\mathcal{E}}.$getObstaclesSet()              ▹Connect each obstacle with the minimum-length visible edge 8: for i in range$(1,M_h)$do                              ▹Get the i-th element of $\mathcal{H}$ 9:     $h_i\leftarrow \mathcal{H}\left\{i\right\}$ 10:     for j in range$(2,M_h+1)$ do                             ▹Get the j-th element of $\mathcal{H}$ 11:         $h_j\leftarrow \mathcal{H}\left\{j\right\}$        ▹Find the points of minimum-length visible edge of i-th and j-th obstacle 12:         $v_i,v_j,isVisible\leftarrow$ findMinimumVisibleEdge$(h_i,h_j)$                 ▹Check if the point $v_i$ is in the field of view of point $v_j$ 13:         if not(isVisible) then 14:            continue 15:         end if        ▹Discretize the resulting edge into points set $q_m^{\prime }$ with distance $m_r$ and total number $N_{q_m^{\prime }}$ 16:         $q_m^{\prime },N_{q_m^{\prime }}\leftarrow$ discretizeEdge$(v_i,v_j,m_r)$                         ▹Add the new elements into the ${\mathcal{G}}_{\mathcal{H}}$ 17:         ${\mathcal{G}}_{\mathcal{H}}.V_{\mathcal{H}}\leftarrow$ addnodes$\left(q_m^{\prime }\right)$ 18:         ${\mathcal{G}}_{\mathcal{H}}.E_{\mathcal{H}}\leftarrow$ addedges$(q_m^{\prime },{[q_m^{\prime }{(2:end,:)}^T,q_m^{\prime }{(1,:)}^T]}^T)$ 19:         ${\mathcal{G}}_{\mathcal{H}}.w_{\mathcal{H}}\leftarrow$ addweight$(m_r·{\mathbb{J}}_{N_{q_m^{\prime }}})$ 20:     end for 21: end for                            ▹Finally, return the HVG $G_{\mathcal{H}}$ 22: return: $G_{\mathcal{H}}$

4.4. Dirichlet Boundary Value and Source Function

Having defined the explored polygon ${\mathcal{G}}_{\mathcal{E}}$ and the sets of middle points, let us define the boundary values (2). We determine the weight of each edge of the graph ${\mathcal{G}}_{\mathcal{E}}$ equal to a Dirichlet boundary value $g\left(p_m\right)$, where $p_m\in {\mathcal{Q}}_m$.

To determine the closest free curve $\partial {\mathcal{E}}_{fi}$ from the current agent’s position p, which is assigned attractive, let $p_{mi}\in {\mathcal{Q}}_{m{f}_i}$ be a point that belongs to the continuous free curve $\partial {\mathcal{E}}_{fi}$ and is located in the middle of this curve. The distance is calculated by:

$$d_g(p,p_{mi})=\left\{\begin{array}{cc}\left|\right|p-p_{mi}\left|\right|,\hfill & p_{mi}\in \mathcal{V}(p;\mathcal{E})\hfill \\ D_{\mathcal{H}}(p,p_{mi};V_{\mathcal{H}})\hfill & p_{mi}\notin \mathcal{V}(p;\mathcal{E})\hfill \end{array}\right.$$

(11)

where $\mathcal{V}(p;\mathcal{E})=\{z\in \mathcal{E}|(1-t)z+tz\in \mathcal{E},\forall t\in [0,1]\}$ is the visibility region of the agent in the explored space $\mathcal{E}$ and $D_{\mathcal{H}}(p,p_{mi};V_{\mathcal{H}})=d(p,V_{\mathcal{H}})+d_{{\mathcal{G}}_{\mathcal{H}}}(p_m^{\prime },p_{mi})$ is the sum of the minimum distance $d(p,V_{\mathcal{H}})$ from the agent’s position to the set $V_{\mathcal{H}}$ and the distance $d_{{\mathcal{G}}_{\mathcal{H}}}(p_m^{\prime },p_{mi})$, with $p_m^{\prime }=argmi{n}_{p_m^{\prime }\in V_{\mathcal{H}}}\left|\right|p-p_m^{\prime }\left|\right|$, which is the shortest path from $p_m^{\prime }$ to $p_{mi}$ based on the HVG. An example of this metric is shown in Figure 5. The aforementioned distance indicates that if the free curve $\partial {\mathcal{E}}_{fi}$ lies in the field of view, we calculate the Euclidean distance. If it is not, then we take the distance from the HVG. We follow this policy for the shortest point, because the Euclidean distance is not a proper choice to estimate the distance from one point to another in non-convex regions [36].

Remark 4. 

The selection of agent’s free frontier is not governed by a utility function. Thus, optimal path determination is not guaranteed. Consequently, if the agent proceeds in a sub-optimal direction, it will explore and will approach the next closest free frontier.

So, the attractive curve is calculated by $\partial {\mathcal{E}}_f^a=argmi{n}_{p_{mi}\in \partial {\mathcal{E}}_{fi}}\left(d_g(p,p_{mi})\right)$, and the rest of the free curves, which are set as repulsive, are denoted as $\partial {\mathcal{E}}_f^o$. Since we have defined the attractive and occupied regions, we assign the boundary value function as follows:

$$g\left(p\right)=\left\{\begin{array}{cc}-k_f,\hfill & p\in \partial {\mathcal{E}}_f^a\hfill \\ k_o,\hfill & p\in \partial {\mathcal{E}}_f^o\cup \partial {\mathcal{E}}_o\hfill \end{array}\right.$$

(12)

where $k_f,k_o>0$ are constant variables.

Remark 5. 

The policy selection of a single free frontier as attractive serves to create a potential field, leading agents from anywhere in the explored region towards it effectively.

As we chose the attractive free curve, the middle point $p_{mi}\in \partial {\mathcal{E}}_f^a$ is defined as the source point denoted by $p_s$. In a workspace with obstacles, we connect the point $p_s$ to any obstacles within its field of view, adding these new edges to ${\mathcal{G}}_{\mathcal{H}}$. In this manner, we improve the estimation of geodesic distances to $p_s$, i.e., the function $D_{\mathcal{H}}(y,p_s;V_{\mathcal{H}})$. The choice of the source function of point $p_s$ will be based on the attributes of the above distance metric. In Figure 6, we have two workspaces—without (Figure 6a) and with (Figure 6b) obstacles—and see the distribution of the distance metric in these platforms with respect to the source point $p_s$, denoted by the black dot.

As we expected, boundaries are created in the explored space (like the Voronoi Diagram), which separate the regions close to the source point and those far from it. Thus, we have to enhance the regions which are close to the source point and reduce the influence of the distant regions so that it promotes the sampling of outward vectors $\nu$ of $\nabla \phi$ to lead the agent toward the attractive region $\partial {\mathcal{E}}_f^a$. To achieve, this we proposed the following exponential source function:

$$f(p;p_s)=-{(1-{\displaystyle \frac{D_{\mathcal{H}}(p,p_s;V_{\mathcal{H}})}{\mathsf{\Pi }(\partial \mathcal{E})}})}^{k_s}$$

(13)

where $\mathsf{\Pi }(\partial \mathcal{E})$ is the perimeter of the explored space boundary and $k_s$ is a fixed positive gain. Hence, the function f attains values in $[-1,0]$, which means that if the agent is close enough to the source point, then $f(.)\to -1$, and when it is far away, then $f(.)\to 0$. So, the value of $f\left(y_i\right)$ with $y_i$ denoting the sampling point we get in the process of the WoS algorithm approximates value $-1$ when $D_{\mathcal{H}}(y_i,p_s;V_{\mathcal{H}})\to 0$. As a result, the solution (8) amplifies the vectors $\nu \left(p_i\right)$, thus leading the agent to the free frontier.

Remark 6.

The source function is derived heuristically, based on the distribution of the distance function $D_{\mathcal{H}}$ (Figure 6) with respect to the source point $p_s$. The primary goal of this design is to enable the agent, when situated in a region distant from point $p_s$, to escape that area and be led toward the free frontier. Figure 7 illustrates the distribution of the source values in decibel ($20log\left(\right|f(p;p_s)\left|\right)$) to the the workspaces of Figure 6 for different values of variable $k_s(=5,10,20)$. As observed in the heat maps, increasing the variable $k_s$ reduces the influence of distant regions, thereby achieving our stated objective.

4.5. Dead-End Region Algorithm

During the WoS algorithm, walkers may enter regions containing only occupied cells with a single escape path. This leads to increased computational and memory complexity, as walkers must traverse substantial distances to reach the explored region’s boundary. As a result, this does not offer further exploratory value. To eliminate this, our exploration process introduces an algorithm, based on [24], that removes these explored, dead-end regions, preventing the agent from re-traversing them.

The identification method of dead-end regions is handled within the Find Dead-End Regions block. The process is as follows: Let $t_{{\mathcal{I}}_c}$ be the current exploration time step at position $p_c$, where ${\mathcal{I}}_c$ presents the number of current iteration number of exploration process. Up to this point, the agent has traversed a path $\mathcal{P}\left(t_c\right)$ and stored all scanned regions at each time step in a set denoted as ${\mathcal{S}}_T=\{{\mathcal{S}}_1,{\mathcal{S}}_2,\dots ,{\mathcal{S}}_{{\mathcal{I}}_c}\}$, where ${\mathcal{S}}_i=\mathcal{S}(p\left(t_i\right);R_{max})$ for $i=1,\dots ,{\mathcal{I}}_c$ with $t_1$ being the initial exploration time step. At each exploration time step, the dead-end method checks all regions within ${\mathcal{S}}_{\mathcal{T}}$ to determine if they are dead-end. If the method identifies regions as dead-end and the agent is not currently within them, these regions are removed from $S_T$ and stored in a separate set, ${\mathcal{S}}_{\mathcal{D}}$. So, in the Define Data Structure block, it subtracts these regions from the overall exploration space. To optimize the algorithm’s time performance, the removal of dead-end regions is not executed at every exploration step. Instead, we perform this subtraction every $N_D>0$ iterations, as the process can become computationally slow if executed too frequently or if the set $S_D$ contains a large number of regions.

Remark 7. 

The aforementioned process can become computationally slow if executed too frequently or if the set $S_D$ contains a large number of regions. As a result, the agent can be stopped in order to calculate the new exploration region or be trapped if the cutting is abrupt. To optimize our algorithm’s time performance and ensure the agent to be distant from the reducing region, the subtraction of dead-end regions is not executed always at every exploration step, but it performs every $N_D>0$ iterations.

For a region $S_i\in S_T$ to be labeled as dead-end and then removed from exploration space, its boundaries must contain a specific number of continuous free boundary curves. This number is related to the number of occupied boundaries from known interior obstacles within region $S_i$. Specifically, a region is considered as dead-end if it possesses one plus the number of occupied boundary obstacles as continuous free boundaries. In Figure 8, we introduce this concept with two examples of removed regions (yellow area). In the first example (Figure 8a,b), the removed region contains no occupied boundaries from any obstacle. So, it is labeled as dead-end, since it includes only one continuous free boundary curve. Similarly, in the second example (Figure 8c,d), the region contains a continuous occupied boundary curve from an obstacle. Therefore, it requires two continued free boundary curves to be identified as dead-end.

4.6. Safety and Completeness of Exploration

The proposed exploration process is safe and complete. Based on the proposed controller $u\left(p\right)$, and the definition of the Dirichlet boundary conditions as well as of the source function, the agent always is repulsed by the occupied boundary of the explored region. Moreover, owning to the term s in the linear velocity command, the agent never collides with the boundary, since $d(p,\mathcal{E})\to 0$ leads to $v_l\to 0$. Regarding the completeness, if we tune properly the exploration parameter for boundary conditions and source function values, the agent is led to the pre-defined free regions and there is no deadlock situation in the flat areas. In Figure 9, we illustrate a workspace with obstacles and the potential field created by the proposed controller, which leads the agent towards the free frontier without colliding with the obstacles from anywhere in the workspace.

The aforementioned solution is heuristic, as the agent occasionally demonstrates regressions in its exploration process. However, by tuning the exploration parameters and incorporating a lot of walkers within the Walk on Spheres (WoS) method, the agent is able to move away from regions with flat gradients and expand the explored domain.

5. Tools for Real Experiment

In this project, we test our exploration process with a real experiment, utilizing a differential drive AmigoBot [37] (see Figure 10). The AmigoBot is a mobile robot appropriate for motion planning applications, which can be monitored using the ROS framework and Matlab. For our experiment, the AmigoBot is integrated with an RPLIDAR A1 laser scanner, developed by SLAMTEC (Shanghai, China), and an odroid processing unit embedded with Ubuntu 20.04.6 LTS (Focal Fossa), 2GB RAM, and ARMv7 processor. Also, the MATLAB environment version 2023b is installed in our laptop with the operating system Ubuntu 20.04, 8GB RAM, and Intel(R) Core(TM) i7-7500U processor. The ROS Noetic and ARIA library for gathering sensor data and monitoring the AmigoBot are installed in both systems.

The robot’s position is obtained from the gmapping package version 1.4.2, which is a library of the ROS Noetic framework that provides laser-based SLAM. The AmigoBot is assumed to be a disk-shaped robot with radius $0.3$ m with the LiDAR sensor mounted at its center with maximum range 3 m.

The workspace of our experiment was in the Autonomous Robotics Lab of the Department of Electrical & Computer Engineering at the University of Patras. We built within a space two different maps to test our method, one labyrinth and another that involves only obstacles as we see in Figure 11.

6. Results

In this section, we present the results of the proposed method in three studies. First, we present a simulation in Matlab, where we demonstrate the safety and completeness of our algorithm. In the second part, we present a real-world experiment with the AmigoBot unit. Finally, in the third part, we introduce a comparison study of our method’s results with other exploration methods. In

Table 1. Values of exploration method parameters for two parts.

Exploration Parameter Values		Part A: Matlab		Part B: Real-World		Part C: Comparison
		Simulation 1 Labyrinth	Simulation 2 Workspace with Obstacles	Simulation 1 Labyrinth	Simulation 2 Workspace with Obstacles
Agent
	$p_0$	[4.0 m, 1.0 m, 0.0rad]	[−4.25 m, −4.25 m, 0.0 rad]	[0 m, 0 m, 0 rad]	[0 m, 0 m, 0 rad]	[−4.50 m, 0.92 m, 0 rad]
	$\rho$	0.3 m	0.3 m	0.3 m	0.3 m	0 m
Range Sensor
	$R_{max}$	4 m	4 m	3 m	3 m	2 m
Map
	$m_r$	0.0833 m/cell	0.0833 m/cell	0.05 m/cell	0.05 m/cell	0.0667 m/cell
WoS
	$N_G$	10	10	8	8	8
	N	100	100	100	100	100
	$\epsilon$	0.667 m	0.667 m	0.05 m	0.05 m	0.0533 m
Control Law
	$K_l$	$0.25$	$0.25$	$0.18$	$0.2$	$0.15$
	$K_a$	$0.25$	$0.25$	$0.25$	$0.2$	$0.2$
	$\alpha$	0.3 m	0.3 m	0.3 m	0.3 m	0.05 m
Boundary and Source Condition
	$k_f$	5	5	$2.5$	5	5
	$k_o$	$0.5$	$0.5$	$0.05$	$0.5$	$0.2$
	$k_s$	40	40	16	20	50
Dead-End
	$N_D$	1	1	10	10	10

, we define the parameter values of the exploration process for the three parts.

Furthermore, to evaluate our algorithm’s efficiency, we use three metrics: (1) the number of exploration steps, (2) the total path length, and (3) the overall exploration time. Moreover, for each iteration, we also report the average time required to (i) collect and process data, (ii) calculate the velocity command with the WoS algorithm, (iii) move the agent to the new state, and (iv) discover the dead-end regions. Finally, we provide the average iteration time both with and without the robot’s movement.

In the first study, we present two simulations. We have two 11 m × 11 m maps to explore, as we see in Figure 12. The first map (see Figure 12a) is a labyrinth and the second one is a workspace with obstacles (see Figure 12b). In the results, we omit the time of the agent’s movement to examine only the average time of exploration algorithms. In Figure 13, we see the exploration process of the mobile agent into the labyrinth and in Figure 14 the workspace with obstacles. In

Table 2. Simulation results of part A: Matlab.

	Simulation 1: Labyrinth	Simulation 2: Workspace with Obstacles
Time Average
Extract Data	0.0683 s	0.0109 s
WoS Algorithm	0.0859 s	0.1419 s
Dead-End	0.0152 s	0.1134 s
Iteration Process	0.1695 s	0.2662 s
Total Results
Iterations	149	180
Trajectory Length	36.97 m	44.34 m
Exploration Time	110.24 s	155.20 s

, we introduce the results of the first part. For these simulations, we use the same hardware as in the real experiment.

Next, we demonstrate two real-world experiments. As previously mentioned, we use an AmigoBot unit for our experiment and as a communication tool, the ROS framework. We constructed two maps similar to the first study, as we can see in Figure 11. In Figure 15, we see the exploration process of the AmigoBot unit into the labyrinth and in Figure 16 in the workspace with obstacles. The corresponding experimental results are summarized in

Table 3. Simulation results of part B: real world.

	Simulation 1: Labyrinth	Simulation 2: Workspace with Obstacles
Time Average
Extract Data	0.4880 s	0.4976 s
WoS Algorithm	0.1373 s	0.1967 s
Agent’s Movement	4.0861 s	2.9283 s
Dead-End	0.1644 s	0.2196 s
Iteration Process (Without Movement)	0.7897 s	0.9139 s
Iteration Process	4.8758 s	3.8421 s
Total Results
Iterations	82	47
Trajectory Length	13.72 m	7.52 m
Exploration Time	399.80 s	180.58 s

. In this video https://youtu.be/EmfcYx3QZMo accessed on 12 June 2025, we present the simulation of the labyrinth of the first part and the workspace with obstacles of the second part.

Finally, in the last stage of our results, we run our exploration method 100 times for different initial positions in the workspace illustrated in Figure 17. The same process appears in the papers [22,25,38]. In

Table 4. Numerical results of part C: comparison study.

Methods	[25]	[22]	[38]	Ours
Mean Exploration Time Process	0.065 s	1.210 s	3.710 s	0.037 s

, we have the time exploration process of each method and also ours. In Figure 17a, we see the exploration process of the mobile agent at a specific initial position, such as in [25] and in Figure 17b, where it presents the process time per iteration of the WoS algorithm (red dash line) and our exploration method (blue dash line). In Figure 17b, we have the mean processing time of the WoS algorithm, which is 0.0255 s and the method 0.0388 s. The computer’s hardware that runs the third part of the simulations operates with Win11 Home, AMD Ryzen 7 7840HS processor, and RAM 16 GB.

7. Discussion

Figure 13f and Figure 14f, show the final results of the agent’s exploration in the first part of the simulations, while Figure 15f and Figure 16f present the results of the experiment with the AmigoBot unit. These plots illustrate the completeness of the workspace mapping and the no-collision trajectories provided by the proposed control architecture. Nevertheless, some irregularities can be observed in the agent’s trajectory, especially in the workspace with obstacles of the first part. This lack of smoothness is influenced by the complexity of the environment and the tuning of the exploration parameters, particularly the boundary values and source parameters of the Poisson equation.

In Table 2, we introduce the metrics of the overall results and average execution time of the sub-routines of the first study. Notice that the exploration parameters are identical for both simulations (see Table 1). As we observe, the agent needs more iterations and processing time to explore the workspace with obstacles compared to the labyrinth. This is due to the higher complexity involved in the obstacle-cluttered workspace and the fact that the exploration area remains large over many iterations, which is attributed to a result of the weakness of the Dead-End algorithm to manage such workspaces. This behavior is also reflected in the average time of the Dead-End sub-routine, which increases as the number of iterations grows, since more regions have to be checked. Thus, the time of the iteration process and particularly of the WoS algorithm increases in proportion to the complexity and the area of the explored region.

Similarly, in Table 3, we show the metrics of the second study, which involved real-world experiments using the AmigoBot. First of all, one notable observation is the relatively high average time of the Extract Data sub-routine. This is primarily due to the communication delay in transferring data from the AmigoBot to the PC during the experiment as well as the overhead introduced by the dead-end removal process, which is affected by the low map resolution (see Table 1). However, notice that the agent needs more iterations in the first workspace (labyrinth) than the second one (workspace with obstacles). This happens because the labyrinth involves narrow corridors; as a result, the agent is close enough to the workspace boundary and thus reduces its velocity. Furthermore, since the agent starts near the center, it must explore three separate sub-regions of the labyrinth. This behavior is evident in the high average time of the Agent’s Movement and Iteration Process sub-routines. However, the average time of the WoS Algorithm and Iteration Process (Without Movement) are less than the obstacle-cluttered workspace, since the Dead-End algorithm decreases significantly the explored region area.

Regarding the comparative simulation results, Table 4 presents the numerical results for the mean exploration time per iteration. According to these results, our method overcomes the methods presented by [22,38] in this metric. Our performance is also marginally better than [25], with a difference of only 0.028 s. Furthermore, comparing our Figure 17a with the corresponding figure in [25], we observe a significant distinction. While the author’s method exhibits a better exploration time, its solution time increases as the area of exploration space increases. In contrast, our method maintains an exploration time that remains close to its average value, due to applying the Dead-End algorithm—that reduces the exploration space—and the behavior of the WoS algorithm.

8. Conclusions

In this work, we proposed a novel method for autonomous exploration in unknown 2D indoor environments with obstacles using harmonic potential fields and the Monte Carlo Integration method. Velocity commands are computed by solving a Poisson equation with Dirichlet boundary conditions, placing a source point at the agent’s closest free frontier. The adapting WoS method ensures efficient, grid-free computation and direct gradient estimation. Moreover, the use of HVG plays a vital role in the exploration process, as the agent may possibly become stuck in the flat gradient region without it. Finally, real-world validation on an AmigoBot with LiDAR verified smooth, deadlock-free navigation in cluttered workspaces, and also a comparison study highlighted the advantages of our method. For future work, we aim at applying the exploration process to a CrazyFlie [39] equipped with a range sensor and expanding the method to 3D environments like a block of flats.