A Constant-Factor Approximation Algorithm for Online Coverage Path Planning with Energy Constraint

TL;DR

This paper presents a constant-factor approximation algorithm for energy-constrained coverage path planning in unknown environments, ensuring efficient exploration with bounded path length and obstacle avoidance.

Contribution

It introduces an $O(1)$-approximation algorithm for coverage with energy constraints, improving upon previous logarithmic approximation methods.

Findings

Algorithm achieves constant-factor approximation guarantee.

Outperforms existing algorithms in path length and runtime.

Effective in environments with various obstacle shapes.

Abstract

In this paper, we study the problem of coverage planning by a mobile robot with a limited energy budget. The objective of the robot is to cover every point in the environment while minimizing the traveled path length. The environment is initially unknown to the robot. Therefore, it needs to avoid the obstacles in the environment on-the-fly during the exploration. As the robot has a specific energy budget, it might not be able to cover the complete environment in one traversal. Instead, it will need to visit a static charging station periodically in order to recharge its energy. To solve the stated problem, we propose a budgeted depth-first search (DFS)-based exploration strategy that helps the robot to cover any unknown planar environment while bounding the maximum path length to a constant-factor of the shortest-possible path length. Our $O(1)$-approximation guarantee advances the state-of-the-art of log-approximation for this problem. Simulation results show that our proposed algorithm outperforms the current state-of-the-art algorithm both in terms of the traveled path length and run time in all the tested environments with concave and convex obstacles.

Figures

Full text

I Introduction

Coverage planning is the task of finding a path or a set of paths to cover all the points in an environment [5]. In robotics, this problem has many potential real-world applications including autonomous sweeping, vacuum cleaning, and lawn mowing. In an online version of the problem, the area of interest is initially unknown to the robot. Therefore it needs to discover and avoid the unknown obstacles in the environment while covering all the points in the free space by traveling as minimum distance as possible [5].

Traditionally, this problem has been studied assuming that the robot has an unlimited energy budget, where given a robot, a single path can be planned to cover the given environment. The offline version of the problem where the robot(s) have a priori knowledge of the environment including obstacles has been well studied, e.g., see [9]. Many algorithms have been proposed such as the boustrophedon decomposition based coverage [4, 13], the spiral path coverage [10], and the spanning-tree based coverage [8]. These techniques can also be adapted to solve online coverage planning [20, 3].

In practice however, the robots do not have unlimited energy available. Therefore, even covering a standard-size environment (e.g., a farm) while simultaneously using on-board sensors (e.g., camera) becomes prohibitive with a single charge. A battery-powered robot needs to return to the charging station to get recharged before the battery runs out. Due to practical relevance, in the recent years, there has been a significant volume of work on the energy-constrained coverage planning problem [18, 14, 20, 19, 17, 16]. The offline version of the problem, denoted as OfflineCPP, is studied in [17, 20, 19] and the online version, denoted as OnlineCPP, is studied in [16, 17]. The state-of-the-art algorithm for OfflineCPP is due to [19], which provides $O(1)$-approximation. For OnlineCPP, the state-of-the-art algorithm is due to [16], which provides $O(\log(B/L))$-approximation, where $B$ is the energy budget and $L$ is the size of the robot (assuming a $L\times L$ square robot). Our goal in this paper is to provide a better approximation algorithm for OnlineCPP, i.e., to reduce the $O(\log(B/L))$-approximation of [16] to $O(1)$. This will show that asymptotically there is no approximation gap between OnlineCPP and OfflineCPP.

Our proposed algorithm covers an unknown environment through a DFS traversal approach tailored for the limited energy budget $B$. Robot $r$ performs a depth first search traversal while building a tree map of the environment on-the-fly. It returns to the charging station to get its battery fully recharged (stopping the DFS exploration) when the path length of the traversal becomes at most $B$. After the battery is fully charged, $r$ then moves to the cell where it stopped the DFS process, and continues traversing $P$. Simulation results show that our proposed algorithm is up to $5.80$ times faster and up to $2.53$ times less costlier (in terms of traversed path length) than the state-of-the-art algorithm [16].

Contributions. Initially, the robot is at the charging station $S$ that is inside $P$. The goal of OnlineCPP is to find a set of paths ${\cal Q}=\{{\cal Q}_{1},\ldots,{\cal Q}_{k}\}$ for the robot such that

• •

Condition (a): Each path ${\cal Q}_{i}$ starts and ends at $S$

• •

Condition (b): Each path ${\cal Q}_{i}$ has length $l({\cal Q}_{i})\leq B$

• •

Condition (c): The paths in ${\cal Q}$ collectively cover the environment $P$, i.e., $\cup_{i=1}^{n}{\cal Q}_{i}=P$,

and the following two performance metrics are optimized:

• •

Performance metric 1: The number of paths in ${\cal Q}$, denoted as $|{\cal Q}|$, is minimized, and

• •

Performance metric 2: The total lengths of the paths in ${\cal Q}$, denoted as $l({\cal Q})=\sum_{i=1}^{n}l({\cal Q}_{i})$, is minimized.

We establish the following main theorem for OnlineCPP.

Theorem 1** (Main Result)**

Given an unknown planar polygonal environment $P$ possibly containing obstacles and a robot $r$ of size $L\times L$ consisting of position and obstacle detection sensors initially situated at a charging station $S$ inside $P$ with energy budget $B$, there is an algorithm that correctly solves OnlineCPP and guarantees $10$-approximation to both performance metrics compared to the optimal algorithm that has complete knowledge about $P$.

This result clearly advances the current state-of-the-art as it improves upon the log-approximation provided in [16] and provides a constant-factor approximation. Furthermore, the proposed algorithm is easier to implement than [16].

Related Work. The most closely related works to ours are [16, 20, 19, 17]. Shnaps and Rimon [17] proposed an $1/(1-\rho)$-approximation algorithm for OfflineCPP, where $\rho$ is the ratio between the furthest distance between any two cells in the environment and half of the energy budget [17]. For OnlineCPP, they proposed an $O(B/L)$-approximation algorithm. Wei and Isler [20] presented an $O(\log(B/L))$-approximation algorithm for OfflineCPP, which has been improved to a constant-factor approximation by them in [19]. Recently, Sharma et al. [16] provided an $O(\log(B/L))$-approximation algorithm for OnlineCPP. In this paper, we improve upon the log-approximation bound and provide the $O(1)$-approximation to OnlineCPP.

The other related work is the coverage of a graph. The goal is to design paths to visit every vertex of the given graph. Without energy constraints, it becomes the well-known Traveling Salesperson Problem (TSP) [1] and a DFS traversal provides a constant-approximation of the TSP. With energy constraints, this coverage problem becomes the Vehicle Routing Problem (VRP) [11]. One version of VRP is the Distance Vehicle Routing Problem (DVRP), which models the energy consumption proportional to the distance travelled. For DVPR on tree metrics, Nagarajan and Ravi [15] proposed a 2-approximation algorithm. Li et al. [12] used a TSP-partition method and their algorithm has a similar approximation to the work in [17]. Most of these work studied the offline version so that pre-processing on the environment can be done prior to exploration obtaining better approximation. This is also the case in the algorithm of [20, 19] for OfflineCPP. Coverage with multiple robots has also received a lot of attention (e.g., see [2, 7]). In some cases, the paths planned for a single robot under energy constraints can also be executed by multiple robots by assigning the planned paths to the robots, without affecting the total cost. In this paper, we consider coverage planning with a single robot.

II Problem setup

In this paper, we use the same model as in [16, 20, 17].

Environment. The environment $P$ is a planar polygon containing a single charging station $S$ inside it. $P$ may possibly contain polygonal, static obstacles. See left of Fig. 1 for an illustration of $P$ with an obstacle $O_{1}$. The environment $P$ is discretized into cells forming a 4-connected grid.

Robot. We consider the robot $r$ to be initially positioned at the charging station $S$. $r$ has size $L\times L$ that it fits within a grid-cell in $P$. The robot $r$ moves rectilinearly in $P$, i.e., it may move to any of the four neighbor cells (if the cell is not occupied by an obstacle) from its current cell. We also assume that $r$ has the knowledge of the global coordinate system through a compass on-board, that means it knows left (West), right (East), up (North), and down (South) cells consistently from its current cell. Robot $r$ is equipped with a position sensor (e.g., GPS) and an obstacle-detection sensor (e.g., laser rangefinder). We assume that with the laser rangefinder, the robot can detect obstacles in any of its neighbor cells. The robot has sufficient on-board memory to store information necessary to facilitate the coverage process. Moreover, we assume that initially $r$ does not have any knowledge about $P$, i.e., $P$ is an unknown environment. For the feasibility of covering all cells of $P$, we assume that $P$ is as big as a circle of radius $\lfloor B/2\rfloor$ with center at $S$. It is assumed that the energy consumption of the robot is proportional to the distance travelled, i.e., the energy budget of $B$ allows the robot to move $B$ units distance.

A path (route) ${\cal Q}_{i}$ is a list of cells that $r$ visits starting and ending with $S$. Notice that if there are some obstacles within $P$ located in such a way that they divide $P$ into two sub-polygons $P_{1}$ and $P_{2}$ with $P_{1}$ and $P_{2}$ sharing no common boundary, then $r$ cannot fully cover $P$. Therefore, we assume that there is no such cell $c$ in $P$. That means, there is (at least) a route from $S$ to any obstacle-free cell of $P$.

We call a cell free if it is not occupied by an obstacle. We call a cell reachable if it satisfies the definition below.

Definition 1** (Reachable Cell)**

Any cell $c$ in $P$ is called reachable by the robot $r$, if and only if (a) it is a free cell, (b) it is within distance $\lfloor B/2\rfloor$ from $S$, and (c) there must be at least a route of consecutive free cells from $S$ to $c$.

OnlineCPP**.** The problem is formally defined as follows.

Definition 2

Given an unknown planar polygonal environment $P$ possibly containing obstacles with a robot $r$ having battery budget of $B$ initially positioned at a charging station $S$ inside $P$, OnlineCPP is for $r$ to visit all the reachable cells of $P$ through a set of paths so that

• •

Conditions (a)–(c) are satisfied, and

• •

Performance metrics (1) and (2) are minimized.

Following [16, 19], we measure the efficiency of any algorithm for OnlineCPP in terms of approximation ratio which is the worst-case ratio of the cost of the online algorithm for some environment $P$ over the cost of the optimal, offline algorithm for the same environment.

III Processing Unknown Environment

In this section, we discuss how the robot decomposes the environment into square grid cells and then construct a tree map of the environment on-the-fly.

Decomposition of the Environment.

Following [16, 19], we decompose the environment $P$ into square cells of size $L\times L$, which is the size of the robot itself.

An equi-distance contour is a poly-line where the cells on it has the same distance to/from the base point $S$ (the left of Fig. 1). The cells on a contour can be ordered from one side to the other.

Let $c$ be a cell and $C$ be a contour. Let $d(c)$ denote the distance to $S$ from $c$ and let $d(C)$ denote the distance to $S$ from $C$. If $d(C_{j})=d(C_{i})+1$, we say that contour $C_{j}$ is contour $C_{i}$’s next contour. The contour $C$ with $d(C)=1$ is called the first contour. Each cell in a contour has at most $4$ reachable cells from $S$ that are its neighbors.

Constructing a Tree Map.

Initially, the robot $r$ is placed at the fixed charging station $S$. In this case, the tree, denoted by $T_{P}$, has only one node $S$, which we call the root of $T_{P}$. If there is no obstacle in $P$, each cell except the boundary cells of $P$ will have exactly four neighbor cells.

Robot $r$ picks the first free cell $c_{1}$ according to a clockwise ordering of its neighbors starting from the west and ending in the south neighbor cell. $r$ then inserts it into $T_{P}$ as a child of $S$. If the cell labeled West is a reachable cell, then $r$ picks that cell. Otherwise, it goes in order of North, East, and South until it finds the first cell that is reachable. We now have two nodes in $T_{P}=\{S,c_{1}\}$, with $c_{1}$ as a child node of $S$. Furthermore, $c_{1}$ is a cell in the first contour $C_{1}$.

Since $r$ is building $T_{P}$ while exploring $P$, it will move to $c_{1}$ after it is included as a child in $T_{P}$. The robot $r$ then again repeats the process of building $T_{P}$ from its current cell $c_{1}$. While at $c_{1}$, $r$ is only allowed to add one of the neighboring cells of $c_{1}$ that are in the second contour $C_{2}$ (i.e., $d(C_{2})=2$) as a child of $c_{1}$. For this, $r$ will include a neighboring cell $c_{2}$ of $c_{1}$ in $T_{P}$ only if $c_{2}$ is a cell in contour $C_{2}$. Furthermore, if some cell is already a part of $T_{P}$, then this cell will not be included in $T_{P}$ again. This process will then continue. The right of Fig. 1 provides an illustration of the tree map $T_{P}$ developed for the environment $P$ shown on the left.

Essentially, any edge of $T_{P}$ connects two cells $c_{i},c_{i+1}$ of $P$ such that $c_{i}\in C_{i}$ and $c_{i+1}\in C_{i+1}$, for $0\leq i\leq\lfloor B/2L\rfloor-1$; in Fig. 1, each cell of contour $C_{i}$ on the environment $P$ on the left are at depth $i$ in $T_{P}$ shown on the right. Therefore, using this approach, all the cells in the first contour $C_{1}$ will be children of $S$ (the root of $T_{P}$), all the cells in the second contour $C_{2}$ will be children of the nodes of $T_{P}$ that are cells in the first contour $C_{1}$, and so on.

There is one potential problem in certain situations. Consider the environment shown in Fig. 2 where the horizontal line passing through $S$ is crossing obstacle $O_{1}$. The contour numbering and constructing $T_{P}$ based on contour numbers do not work as the cells in the right of $O_{1}$ may not be visited by $r$ following Algorithm 1 as it requires the robot to visit the cells in an increasing order of contour numbers. This is because the contour numbers for those cells are smaller than the contour number of the cells on North, South, and West of the obstacle. For example, see the left of Fig. 2.

We solve this problem in Algorithm 1 using an approach where the robot $r$ detects this problem and changes the contour numbers of those cells on-the-fly. See for example the right of Fig. 2 that depicts how the contour numbers for the cells on the right of $O_{1}$ are updated on-the-fly by the robot. Details are omitted on how $r$ detects the problem and solves it due to space constraints.

IV Algorithm

In the description of the algorithm and its analysis, we assume that $L=1$. A simple adaptation will work when $L>1$. The pseudocode is given in Algorithm 1 and illustration of the working principle of the algorithm is given in Fig. 3.

IV-A A Naive Approach without Energy Constraint

The main idea behind our algorithm is to let $r$ incrementally explore the environment $P$ while simultaneously constructing a tree map $T_{P}$ of $P$ to keep track of the new frontiers that need to be visited by it.

For simplicity, let us first consider that $T_{P}$ (or $P$) is known a priori and $r$ has no energy constraint (i.e., $B=\infty$). Let ${\cal Q}_{\infty}(r)$ be a route in $T$ that visits all the nodes of $T_{P}$, obtained performing a Depth First Search (DFS) traversal of $T_{P}$. Since $T_{P}$ is a tree, it is known that all the nodes of $T_{P}$ can be covered by the DFS traversal by visiting each node of $T_{P}$ at most twice. Therefore, if there are $n$ nodes in $T_{P}$, then the length of the route $l({\cal Q}(r))\leq 2n$. Moreover, an optimal algorithm for $r$ to traverse all $n$ nodes of $T_{P}$ must have length $l(Q_{OPT}(r))\geq n$, since $r$ can only visit the nodes of $T_{P}$ sequentially one after another using any algorithm. Therefore, without any energy constraint ($B=\infty$), we have a $2$-approximation algorithm. The 2-approximation can also be guaranteed for OnlineCPP when $B=\infty$ since with the knowledge of the global coordinate system, $r$ can visit all the nodes of $T_{P}$ as if $T_{P}$ is known a priori, satisfying the length of the route $l({\cal Q}(r))\leq 2n$.

IV-B Incorporating the Energy Constraint

Now suppose that $r$ has energy budget $B<2n$. The aforementioned algorithm is not sufficient anymore since each route of $r$ can be at most of length $B$. Therefore, $r$ needs to return to $S$ to get recharged before the length of the robot’s path reaches $B$. Our proposed algorithm uses the same idea of performing a DFS traversal of $T_{P}$ as described in the previous subsection while stopping the DFS traversal process before the route of $r$ has length at most $B$. Let ${\cal Q}_{\infty}(r)=\{S,v_{1},v_{2},\ldots,v_{l}\}$ be the route with respective nodes visited by $r$ while running DFS assuming $B=\infty$. Let ${\cal Q}_{i}(r)$ denote a route of $r$ visiting the nodes of ${\cal Q}_{\infty}(r)$ when $B<2n$. The goal is to obtain ${\cal Q}^{\prime}(r)=({\cal Q}_{1}(r),{\cal Q}_{2}(r),\ldots,{\cal Q}_{k}(r))$, such that the three conditions listed in Section I are satisfied.

The challenge is to plan each route ${\cal Q}_{i}(r)$ in an online fashion satisfying all three criteria while minimizing both the number of paths $|{\cal Q}^{\prime}(r)|$ and the total length of the paths $l({\cal Q}^{\prime}(r))$. We use the following approach: ${\cal Q}_{1}(r)$ starts from $S$ and visits the nodes of ${\cal Q}_{\infty}(r)$ in a sequence. As soon as ${\cal Q}_{1}(r)$ reaches to a node $v_{i}\in{\cal Q}_{\infty}(r)$ such that ${\rm dist}(v_{i},S)\leq B_{remain}$, it terminates the DFS traversal and returns to $S$. $B_{remain}$ is the energy remained after each move. In route ${\cal Q}_{2}(r)$, $r$ moves to $v_{i}$ (where it stopped the DFS traversal in ${\cal Q}_{1}(r)$) from $S$ and continues the DFS traversal until it reaches to a node $v_{j}\in{\cal Q}_{\infty}(r)$ from which ${\rm dist}(v_{j},S)\leq B_{remain}$. Like last route, $r$ then returns to $S$. This process then continues until the last node $v_{l}\in{\cal Q}_{\infty}(r)$ is visited in some route ${\cal Q}_{k}(r)$. We later prove that using this approach, $r$ visits all nodes of $T_{P}$ providing correctness and approximation guarantee claimed in Theorem 1.

We call our algorithm OnlineCPPAlg (shown in Algorithm 1). Initially, the robot $r$ is at $S$ with the energy budget $B<2n$. This is a special situation where $v=S$ and $B_{remain}=B$. Robot $r$ then includes the child nodes of $S$ (in contour 1) in $T_{P}$ making them child nodes of root $S$ in $T_{P}$ and moves to the leftmost child node, say $v_{1,left}$. The node $v_{1,left}$ is marked visited. $B_{remain}$ is decreased by 1 (line $21$). Robot $r$ then moves from $v_{1,left}$ to the leftmost child node $v_{2,left}$ (in contour 2). The node $v_{2,left}$ is marked visited and $B_{remain}$ is decreased by 1. This process continues until at some node $v_{i}$ (in some contour $i$), $B_{remain}=D_{v_{i}}$, where $D_{v_{i}}$ is the distance from $v_{i}$ to $S$ in $T_{P}$. Robot $r$ then returns to $S$ following the path in $T_{P}$ (line $23$). After getting fully charged at $S$, $r$ follows the path in $T_{P}$ to reach $v_{i}$ to continue the DFS traversal.

At any cell of $P$ (node of $T_{P}$), if it has a unvisited neighbor cell in the next contour (child node in $T_{P}$), then $r$ moves to that cell. Otherwise, $r$ retreats back to the parent node cell of its current cell in $T_{P}$ (lines $18-19$). During the exploration, anytime $r$ realizes that it has just enough energy remaining $B_{remain}$ to reach back to $S$, it does so by visiting the parent nodes in the tree $T_{P}$ starting from its current node.

V Analysis of the Algorithm

In this section, we provide theoretical analysis of OnlineCPPAlg. We first prove its correctness and then analyze the costs for the performance metrics (1) and (2).

Correctness. We start with the following lemma.

Lemma 1

Let $\{S,v_{1},v_{2},\ldots,v_{l}\}$ be the order of the nodes of $T_{P}$ (i.e., cells in $P$) visited by the DFS traversal ${\cal Q}_{\infty}(r)$ when $B=\infty$. Let ${\cal Q}^{\prime}(r)=\{{\cal Q}_{1}(r),{\cal Q}_{2}(r),\ldots,{\cal Q}_{k}(r)\}$ be the routes of $r$ that collectively visit the nodes of $T_{P}$ at least once when $B<2n$. The not-yet-visited nodes of $T_{P}$ (or cells of $P$) are visited in ${\cal Q}^{\prime}(r)$ in the same order as in ${\cal Q}_{\infty}(r)$.

Proof:

Consider the paths in ${\cal Q}^{\prime}(r)$ when $B=\infty$. In this case, instead of stopping the DFS traversal at some node $\alpha$ and make a round trip to $S$ from $\alpha$, each subsequent paths continue their traversal without this stoppage. This simulates essentially the behavior of $r$ when $B=\infty$ giving ${\cal Q}_{\infty}(r)$ and hence the nodes of $T_{P}$ (or cells in $P$) are visited in the same order in both (except the nodes visited in the roundtrip to $S$ from the stopped node $\alpha$). ∎

Theorem 2** (Correctness)**

OnlineCPPAlg* completely covers the environment $P$.*

Proof:

When $P$ is known a priori, $r$ can visit all the reachable cells in $P$ with an unlimited budget. If $P$ is unknown but $B=\infty$, it is also known that through a DFS traversal, each reachable cell of $P$ is guaranteed to be visited where the traversal path is represented by ${\cal Q}_{\infty}(r)=\{S,v_{1},v_{2},\ldots,v_{l}\}$. We have proved in Lemma 1 that when $P$ is unknown but $B<2n$, the nodes of $T_{P}$ are visited in the same order. This immediately provides the guarantee that all reachable cells of $P$ will be visited by $r$. Hence, proved. ∎

Approximation Ratio. We prove the following theorem.

Theorem 3** (Approximation)**

OnlineCPPAlg* achieves $10$-approximation for both performance metrics – the number of paths and the total lengths of the paths.*

Proof:

Let $T$ be a tree of depth at most $\lfloor B/2\rfloor$. Let $r$ be a robot with energy budget at least $B$. After $r$ starts from $S$ to visit the nodes of $T$, due to the limited energy budget, $r$ may need to stop the coverage of $T$ and visit the charging station $S$ again before rest of the nodes in $T$ can be covered.

Let $OPT$ be the DFS exploration strategy for $r$ that consists of the minimum number of routes, i.e., the minimum number of times $r$ needs to visit $S$ before $T$ is completely covered. Let $ALG$ be the DFS exploration strategy that visits the nodes of $T$ (starting from $S$) using a DFS traversal where length of each route is bounded by $B$. As soon as the battery is fully charged at $S$, in the next route, $r$ directly goes to the node of $T$ where it stopped the DFS traversal in the last route and continues covering the unvisited nodes of $T$. For any tree $T$ of depth $\lfloor B/2\rfloor$ and any robot $r$ of energy budget at least $B$, we have the following result from [6] on the number of routes $|{\cal Q}_{ALG}(r)|$, of the strategy $ALG$, compared to the number of routes $|{\cal Q}_{OPT}(r)|$, of strategy $OPT$: $|{\cal Q}_{ALG}(r)|\leq 10\cdot|{\cal Q}_{OPT}(r)|$. Moreover, let $l({\cal Q}_{ALG}(r))$ be the total length traversed by $r$ while using the strategy $ALG$. Let $l(OPT(r))$ be the optimal length traversed by $r$. Again from [6], we have that $l({\cal Q}_{ALG}(r))\leq 10\cdot l(OPT(r))$.

The above results are interesting meaning that the bounds hold for any arbitrary DFS traversal ${\cal Q}(r)$ of $T$ by $r$. That means that the whole DFS traversal ${\cal Q}(r)$ does not need to be known beforehand (i.e., can be computed online not knowing $T$ in advance). Moreover, each route can be constructed without any knowledge on the yet unvisited part of $T$.

We now discuss how the two results can be adapted to prove the same bounds for OnlineCPPAlg. Consider a DFS traversal ${\cal Q}_{\infty}(r)$ of $P$ (or equivalently $T_{P}$) by $r$ when $B=\infty$. We have from Lemma 1 that the routes in ${\cal Q}^{\prime}(r)$ visit the not-yet-visited nodes of $P$ in the order same as in ${\cal Q}(r)$. Moreover, the tree map $T_{P}$ of $P$ formed during the exploration is of depth at most $\lfloor B/2\rfloor$. Therefore, $|{\cal Q}^{\prime}(r)|\leq 10\cdot|{\cal Q}_{OPT}(r)|$ and $l({\cal Q}^{\prime}(r))\leq 10\cdot l(OPT(r))$. ∎

Proof of Theorem 1: Theorems 2 and 3 prove Theorem 1 for $L=1$. Since the cells are decomposed proportional to the robot size $L\times L$, a simple adaptation of the analysis again gives $10$-approximation for OnlineCPPAlg for $L>1$. The correctness analysis remains unchanged. ∎

VI Evaluation

Settings. We have implemented the proposed algorithm OnlineCPPAlg using Java programming language on a desktop computer with an Intel i7-7700 CPU and 16GB RAM. The robot size $L$ is set to $1$. We have created five different environments with both convex and concave obstacles in them. The test environments are of the same dimension – $8\times 8$ $(l=8)$. The budget $B$ is set to $4l$ (unless otherwise mentioned), i.e., four times the size of each side of the environment. Note that this is the lowest possible budget to completely cover the environment. The charging station $S$ is placed at the left-bottom corner in every test environment. These environments are shown in Fig. 4 (Conf1 to Conf5).

Empirically, we have mainly focused on three metrics to evaluate the quality of the proposed algorithm: 1) time to cover the environment, 2) total path length traversed by the robot, and 3) approximation ratio. We also compare our results against the current state-of-the-art algorithm that solves OnlineCPP under energy constraint [16].

Results. First we empirically verify the theoretically-proved constant-factor approximation bound. Let $n$ denote the number of reachable cells in the environment. Then $MIN=\frac{2n}{B}$ will indicate the absolute minimum number of paths required by the robot to completely cover the environment [16, 20]. No optimal DFS strategy ($OPT$) can guarantee a better approximation bound than $MIN$. Here, we compare our experimental result against $MIN$ as a comparison against any $OPT$ cannot make our empirical approximation bound worse. The result is shown in Fig. 5(a). The state-of-the-art bound of $\log(B)$ (when $L=1$) is also plotted for reference. The figure shows that in practice, the approximation bound is well below the $10$-factor theoretical worst-case bound. Also, in all of the test environments, our proposed algorithm outperforms the state-of-the-art $\log(B)$-approximation [16].

As we are minimizing the total path length travelled by the robot to completely cover the environment, we are interested to compare this metric for our algorithm against the algorithm in [16]. The result is shown in Fig. 5(b). It can be clearly observed from this plot, that our proposed algorithm outperforms the algorithm in [16] in terms of the travelled path length – by an average ratio of $2.03$ while the maximum ratio is $2.53$ (Conf3).

Next we are interested to investigate the effect of changing the budget amount on the travelled path length. In order to do this, we vary $B$ between $\{4l,6l,8l\}$. The result is shown in Fig. 6(a). With higher budget, $r$ could cover more cells in one path than with a lower budget. This fact is also reflected in the plot where travelled path length is higher with lower budget and vice-versa. Similarly, when the budget is higher and $r$ is covering more cells in a single path, it needs to come back to the charging station less often and consequently, the total number of paths also reduces. This can be observed in Fig. 6(b). On average, $r$ visited $S$ $2.30$ times more with $B=4l$ than with $B=8l$.

Next we are interested to investigate the run time of the proposed algorithm. We also compare this metric against the algorithm proposed in [16]. The result is shown in Fig. 7. On average, our algorithm is shown to be $2.74$ times faster than [16] while the maximum ratio is $5.80$ (Conf1). Finally, the paths followed by $r$ in different environment configurations are shown in Fig. 4; a video of the simulation is also submitted.

VII Conclusion and Future Work

We have presented an algorithm for OnlineCPP by an energy-constrained robot achieving $10$-approximation, improving significantly on the state-of-the-art $O(\log(B/L))$-approximation [16]. It is also simpler to implement compared to [16]. Our simulation results validate the approximation bound established theoretically. We have empirically shown that our proposed approach outperforms the state-of-the-art algorithm both in terms of run time and total traversal cost for the complete coverage. In the future, we plan to test our algorithm in a real-world setting.