Approximate Environment Decompositions for Robot Coverage Planning using Submodular Set Cover
Megnath Ramesh Frank Imeson Baris Fidan Stephen L. Smith


QHDOPT: A Software for Nonlinear Optimization with Quantum Hamiltonian Descent
    [
    
==============================================================================



§ ABSTRACT 
In this paper, we investigate the problem of decomposing 2D environments for robot coverage planning. Coverage path planning (CPP) involves computing a cost-minimizing path for a robot equipped with a coverage or sensing tool so that the tool visits all points in the environment. CPP is an NP-Hard problem, so existing approaches simplify the problem by decomposing the environment into the minimum number of sectors. Sectors are sub-regions of the environment that can each be covered using a lawnmower path (i.e., along parallel straight-line paths) oriented at an angle. However, traditional methods either limit the coverage orientations to be axis-parallel (horizontal/vertical) or provide no guarantees on the number of sectors in the decomposition. We introduce an approach to decompose the environment into possibly overlapping rectangular sectors. We provide an approximation guarantee on the number of sectors computed using our approach for a given environment. We do this by leveraging the submodular property of the sector coverage function, which enables us to formulate the decomposition problem as a submodular set cover (SSC) problem with well-known approximation guarantees for the greedy algorithm. Our approach improves upon existing coverage planning methods, as demonstrated through an evaluation using maps of complex real-world environments.










§ INTRODUCTION


Coverage path planning (CPP) is the problem of generating a minimum cost path for a robot equipped with a sensing or coverage tool such that the tool visits all points of the robot's environment <cit.>. CPP has a wide range of applications in cleaning <cit.>, agriculture <cit.>, and surveillance tasks for search-and-rescue robots <cit.>. CPP is an NP-Hard problem <cit.> and thus research is primarily focused on computing approximations to the optimal coverage path. Planning approaches in literature typically use a two-step framework to make CPP more tractable, albeit at the cost of solution quality. This framework involves: (i) decomposing the environment into sub-regions which can each be individually covered, and (ii) computing a visitation order or a tour of the sub-regions. In this work, we refer to these sub-regions as "sectors". The environment decomposition step is critical as it determines the majority of the coverage path, and also affects the cost of the tour connecting the sectors. Therefore, it is important to compute decompositions that account for these effects on the coverage path.







In literature, CPP algorithms are grouped into exact or approximate approaches depending on the choice of environment decomposition. Exact approaches usually involve decomposing the environment into convex (or monotone) sectors <cit.>. Each sector is then covered by a lawnmower path (i.e. using parallel coverage lines) along an optimal orientation as determined by the geometry of the sector. However, when applied to complex environments with irregular boundaries, exact CPP approaches are susceptible to over-decomposition where some sectors are thinner than the coverage tool. This is a consequence of covering the entire environment and results in many instances of double coverage where the robot returns to areas it has already covered. Additionally, these approaches provide few guarantees on the number of sectors in the decomposition.



In contrast, approximate CPP approaches use grid decompositions to cover areas of the environment that are reachable by the coverage tool. The decomposition is composed of non-overlapping (usually square) grid cells of size equal to the coverage tool <cit.>. The CPP problem is then to compute an optimal tour that visits each grid cell and minimizes the amount of double coverage. In our previous works <cit.>, we proposed an approach that minimizes double coverage by minimizing the number of coverage lines (i.e. straight-line paths). However, using grid cells constrains the robot to cover the environment along axis-parallel (horizontal or vertical) orientations, leading to “staircase-like" coverage paths which are sub-optimal. We look to achieve a decomposition that addresses the shortcomings of both exact and approximate approaches by (i) preventing over-decomposition and (ii) removing axis-parallel constraints. 





In this paper, we propose a decomposition of the environment into possibly overlapping rectangular sectors. We choose rectangles for the following reasons: (i) the lawnmower path to cover a rectangle can be optimally oriented along the longest edge <cit.>, and (ii) one can efficiently identify the largest rectangle in an environment <cit.>. We refer to this as the sector decomposition problem. Inspired by works in sensor coverage <cit.>, we leverage the submodularity property of covering the environment with sectors to design our solution approach. Specifically, we show that the sector decomposition problem is an instance of the submodular set cover (SSC) problem, which has been studied extensively in literature <cit.>. In our proposed approach, we use the result that the greedy algorithm for SSC has a well-known approximation guarantee <cit.>.



Contributions: Our specific contributions are as follows:

    
  * We formulate the sector decomposition problem that aims to minimize the number of sectors and show that this is an instance of the submodular set cover problem.
    
  * We propose a greedy algorithm to solve the sector decomposition problem, for which we provide an approximation guarantee on the number of sectors following that of <cit.>.
    
  * Finally, we present simulation results using maps of real-world environments and perform comparisons against state-of-the-art coverage planning approaches. 




The paper is organized as follows. In Section <ref>, we provide some background on the submodular set cover (SSC) problem. In Section <ref>, we introduce the sector decomposition problem. In Section <ref>, we motivate the minimization of sectors and show that the sector decomposition problem is an instance of SSC. In Section <ref>, we present our solution approach that greedily computes a sector decomposition for an environment. In Section <ref>, we briefly describe how the decomposition is used to compute a coverage path for the environment. Finally, in Section <ref>, we provide the results of generating coverage paths for real-world environments using the proposed approach.



§ PRELIMINARIES



In this section, we provide a brief background on submodular functions and the submodular set cover (SSC) problem on which our decomposition approach is based.



 §.§ Submodular functions


Let us consider a set X (not necessarily finite) and let the set 2^X be the power set of X, i.e., the set of all subsets of X. A function f : 2^X →ℝ_≥ 0 is submodular if for all A ⊆ B ⊆ X and x ∈ X ∖ B, we have

    f(A ∪{x}) - f(A) ≥ f(B ∪{x}) - f(B).

This is known as the property of diminishing returns. Equivalently, a function f : 2^X →ℝ_≥ 0 is submodular if for every A,B ⊆ X, 

    f(A) + f(B) ≥ f(A ∪ B) + f(A ∩ B).



In addition to submodularity, we consider functions f that possess the following additional properties:

    
  * Monotonicity: For all A ⊆ B ⊆ X, f(A) ≤ f(B),
    
  * Normalization: For the empty set ∅, f(∅) = 0.




 §.§ Submodular Set Cover




Consider a set X and a monotone submodular function f: 2^X →ℝ for which f(X) is finite. The submodular set cover problem aims to compute a minimum cardinality subset S ⊆ X subject to a submodular constraint f(S) = f(X). Formally, it can be represented by the following optimization problem:

    min_S ⊆ X      |S|
    s.t.     f(S) = f(X).


The submodular set cover problem is NP-Hard. However, a simple greedy algorithm provides the best-known performance guarantee for this problem <cit.>. Let δ_x(S) for some S ⊆ X and x ∈ X ∖ S denote the marginal return obtained by adding x to S: 

    δ_x(S) = f(S ∪{x}) - f(S).
 

The greedy algorithm for this problem iteratively constructs a set S as follows: at each iteration r, the algorithm adds the element x ∈ X ∖ S that maximizes the marginal return δ_x(S). The greedy algorithm terminates after a feasible solution S where f(S) = f(X) is obtained.












§ PROBLEM DEFINITION



Consider an indoor environment as represented by a set 𝒲⊆ℝ^2. We look to cover the environment using the robot's coverage tool, which we assume to be a square of width l. This assumption follows from other works in coverage planning including <cit.>. Specifically, we look to decompose 𝒲 into (possibly overlapping) rectangular subsets called sectors. Let 𝒬 denote a set of candidate sectors where each sector Q_i ∈𝒬 represents a rectangle in the environment (i.e., Q_i ⊆𝒲) with the longest edge oriented along an angle θ_i ∈ [0,π). Note that the set 𝒬 can be uncountably infinite.



We now define the functions to compute the coverage of the environment using sectors. Let |Q| denote the area of a set Q ⊆ℝ^2, and let a:2^𝒬→ℝ be a function that computes the area of the union of a subset 𝒮⊆𝒬:

    a(𝒮) = |⋃_Q_i ∈𝒮 Q_i|.

We consider a set of candidate sectors 𝒬 such that its union covers 𝒲, i.e. a(𝒬) = |𝒲| (i.e., total area of the environment). This is so that there exists a decomposition that covers the entire environment if necessary. 

We are now ready to present the main problem of this paper. Given the environment 𝒲, we look to decompose 𝒲 into the minimum number of rectangular sectors. However, we also look to prevent cases of over-decomposition, where the decomposition may contain small sectors covering inaccessible areas in the environment. To do this, we seek to find a decomposition such that the area within 𝒲 covered by the sectors is at least γ|𝒲|, where γ∈ (0,1] is a design parameter we call the minimum coverage ratio.

[Sector Decomposition]
    Given an environment 𝒲, a set of candidate rectangular sectors 𝒬 and a minimum coverage ratio γ, compute a set of sectors 𝒮⊆𝒬 that solves:
    
    min_𝒮⊆𝒬      |𝒮|
    s.t.      a(𝒮) ≥γ|𝒲|.

    
    


Using the sectors computed by solving Problem <ref>, we obtain the coverage lines (i.e., straight-line paths) that form the lawnmower path for the sector. Note that there are two possible lawnmower paths depending on the connections between the coverage lines. From this, we generate a coverage path for the environment using an approach called sector touring where: (i) we pick a lawnmower path for each sector, and (ii) connect the lawnmower paths by computing a cost-minimizing tour between the path endpoints. We refer to the connections between the lawnmower paths as transition paths. An example coverage path for a set of three sectors is shown in Fig. <ref>. We provide more details on sector touring in Section <ref>.




    While we consider rectangular sectors in this paper, one could more generally consider sectors that are monotone with a well-defined orientation for the lawnmower path. However, in our solution approach, we leverage existing approaches <cit.> that efficiently compute the largest inscribed rectangle within the environment at an orientation.











§ LINK TO SUBMODULAR SET COVER



In this section, we establish that Problem <ref> is an instance of SSC. We motivate minimizing the number of sectors by deriving a bound on the worst-case coverage path length resulting from a decomposition of rectangular sectors. We then prove the submodularity of the area function a, which, based on <cit.>, implies that the greedy algorithm provides a polynomial-time approximation algorithm. Following <cit.> and the submodularity of the area function a (proof deferred to extended version due to space constraints), this implies that the greedy algorithm provides a polynomial-time approximation algorithm.



 §.§ Coverage Path Optimality

Here, we motivate the minimization of the number of sectors in the decomposition by considering the length of the coverage path resulting from sector touring. Giving an exact characterization of the relationship between the sector decomposition and the coverage path length is challenging. Thus, our approach is to bound the length of the coverage path obtained from sector touring and minimizing this bound. For convex environments, we may trivially bound the coverage path length using a single sector covering the environment. However, for non-convex environments, such as those considered in this paper, obtaining a similar bound requires more in-depth analysis.

Consider a decomposition of the environment into rectangular sectors. The lawnmower path length to optimally cover a rectangular sector can be tightly bounded using the rectangle dimensions and the coverage tool width l. Consider a rectangular sector Q of width w and height h. Without loss of generality, let w ≥ h and consider a lawnmower path with coverage lines along the longest edge (i.e. width) of the rectangle. Now, let P_Q be the path to cover Q and let L(P_Q) be its length.


    Given a rectangular sector Q of width w and height h, the coverage path P_Q has a length L(P_Q) satisfying
    
    L(P_Q) ≤ w ⌈h/l⌉.

    
    




    The length of each coverage line in the lawnmower path is w - l as the tool can stay at a distance of l/2 away from the perimeter of the rectangle to cover it. To connect each coverage line to an adjacent line, we require a connecting path of length at most l. So each line-connection pair has a length of w. 
    
    If h is a multiple of l, then the number of line-connection pairs is exactly h/l, and the bound is tight. If h is not a multiple of l, i.e., h ≠ cl for some c ∈ℕ. The number of coverage lines needed to cover Q is ⌈ h/l ⌉. Therefore, the total path length is upper-bounded by w ⌈ h/l ⌉, which proves the lemma.


Due to space constraints, we defer the proof of Lemma <ref> to the extended version. Let 𝒮 be a set of rectangular sectors that cover the environment 𝒲, i.e. a(𝒮) = |𝒲|. Given 𝒮, let P be the coverage path obtained by connecting the lawnmower paths using the aforementioned approach, and let L(P) be the length of P. Since the sectors can overlap, the sum of sector areas is given by

    ∑_Q ∈𝒮 |Q| = (1 + α) |𝒲|,

where α is the ratio of |𝒲| that is double-covered by sectors in 𝒮. Also, let w' represent the longest width of all sectors in 𝒮.

Now, let P^* be the optimal coverage path of 𝒲 (unconstrained by sectors). We now bound L(P) with respect to L(P^*).


    Given an environment 𝒲 and a coverage tool of width l, let P^* be an optimal coverage path of 𝒲, with length L(P^*). Consider a decomposition of 𝒲 into rectangular sectors 𝒮, and let α be the ratio of sector overlap and w' be the longest sector width. Then, the coverage path P resulting from sector touring has length L(P) that satisfies:
    
    L(P)    ≤ (2 + α) L(P^*) + (√(2) + 1)w'|𝒮|.

    
    


    First, note that
    
    L(P^*) ≥|𝒲|/l.

    This follows since the area covered by a tool of width l along any path of length L is at most lL, with equality if the path is a straight line.
    The path P is obtained by (i) covering each sector individually using lawnmower paths, and (ii) connecting the lawnmower paths using transition paths. Let L_s be the total length of the lawnmower paths. Following Lemma <ref>,
    
    L_s ≤∑_Q ∈𝒮( |Q|/l + w' ) ≤∑_Q ∈𝒮 |Q|/l + |𝒮|w'


    Following the definition of α, we get the following ratio between the sum of sector areas and l:
    
    ∑_Q ∈𝒮 |Q|/l= (1 + α)|𝒲|/l≤ (1 + α) L(P^*).

    
    We now bound the length of the transition paths L_t that connect the lawnmower paths. We split the transition paths into two path segments: (i) inter-sector (path between sectors), and (ii) intra-sector (path traveled within each sector). Fig. <ref> illustrates these path segments in an example coverage path. To bound L_t, we consider computing transition paths as follows: (i) we use a TSP tour that visits a single corner of each sector (inter-sector), and (ii) connect each ends of the lawnmower path to the corner (intra-sector).
    
    To bound the inter-sector path segments, let TOUR(𝒮) be the length of the TSP tour of the sector corners. Note that the optimal coverage path P^* for the environment visits each sector at least once. So, we have that
    
    TOUR(𝒮) ≤ L(P^*).


    We now bound the intra-sector path segments for each sector. A lawnmower path for a rectangle starts close to one sector corner and ends at a different corner. Therefore, the cumulative path length to reach any corner from the endpoints of a lawnmower path is at most the diameter of the sector (length of the diagonal). Given that w' is the longest sector width in the decomposition, this diameter is at most √(2) w'. As a result, we have that
    
    L_t ≤ L(P^*) + √(2)|𝒮|w'.


    Adding all the path lengths, we arrive at the final result:
    
    L(P)    = L_s + L_t 
       ≤ (1 + α) L(P^*) + (1 + √(2))|𝒮|w' + TOUR(𝒮), 
       ≤ (2 + α) L(P^*) + (1 + √(2))|𝒮|w'

    which proves our proposition.













Following Proposition <ref>, we observe two factors of the sector decomposition that affect the length of the worst-case coverage path: (i) the number of sectors |𝒮|, and (ii) the area of sector overlap. Therefore, reducing the number of sectors in the decomposition reduces the second term in the bound. Additionally, in our solution approach (Section <ref>), we address sector overlap by constraining the overlap area between sectors when computing the environment decomposition.



 §.§ Submodularity of sector coverage



We now show that the coverage function a is a submodular function defined on the set of all candidate sectors 𝒬. This is not immediately obvious as 𝒬 is uncountably infinite.

Since the set of all candidate sectors 𝒬 is uncountably infinite, it is not immediately obvious that the coverage function a is a submodular function defined on 𝒬.


    The coverage function a: 2^𝒬→ℝ as defined in Eq. (<ref>) is a normalized, monotone and submodular function.
    




    Normalization holds trivially as the coverage of 𝒲 is 0 if no sectors are picked from 𝒬. Similarly, monotonicity holds trivially, since for any set A ⊆𝒬, each sector in A must cover a non-negative amount of area in 𝒲. 
    
    To show the submodularity of a, consider sets A ⊆ B ⊂𝒬 and a sector Q ∈𝒬∖ B. From the definition of submodularity in Section <ref>, the following must hold:
    
    a(A ∪{Q}) - a(A) ≥ a(B ∪{Q}) - a(B).

    For the set B, let δ_Q(B) = a(B ∪{Q}) - a(B) represent the marginal return of adding Q to the set B. First, notice that
    
    δ_Q(B) = | Q ∖ (∪_Q_B ∈ B Q_B) |.

    Now, manipulating this expression we get
    
    δ_Q(B) 
               = | Q ∖ (∪_Q_B ∈ B Q_B) |
       =  | Q ∖((∪_Q_A ∈ A Q_A) ∪ (∪_Q_B ∈ B∖ A Q_B))|
       = |(Q ∖ (∪_Q_A ∈ A Q_A)) ∩(Q ∖ (∪_Q_B ∈ B∖ A Q_B))|
       ≤| Q ∖ (∪_Q_A ∈ A Q_A) |
       = δ_Q(A),

where the equality in the third line follows from an application of DeMorgan's Laws (i.e., A ∖ (B∪ C) = (A ∖ B) ∩ (A ∖ C)). This proves the proposition.


We provide a proof for Proposition <ref> in the extended version. Following Proposition <ref>, we have that Problem <ref> is an instance of SSC which allows us to use the result from <cit.> to propose a greedy decomposition approach.

    
    
    
    
    



§ SECTOR DECOMPOSITION APPROACH



In this section, we describe our solution approach for the sector decomposition problem. Our approach greedily adds large rectangular sectors to the decomposition that cover new areas of environment. We first describe an approach that leverages computational geometry algorithms to identify large rectangular sectors in the environment (or its subset). We then present a greedy algorithm that computes a sector decomposition while constraining the overlap between the sectors. For the case where the overlap is not constrained, we provide an approximation factor for the greedy algorithm following <cit.>. 



 §.§ Sector identification



We first identify the largest candidate sector for a given environment 𝒲 (or its subset). For this, we solve the problem of computing a rectangle of maximum area in 𝒲. In computational geometry literature, this is known as the convex skull or the "potato peeling" problem. Computing a convex skull of general shape and orientation requires O(n^7) runtime, where n is the number of vertices in the polygonal representation of 𝒲<cit.>. Another alternative is to use approximation algorithms <cit.> which reduce runtime at the sacrifice of optimality. However, one can compute the largest area axis-parallel rectangle in the environment efficiently using existing algorithms <cit.>. Additionally, for the case of coverage planning, one can use the orientations of the environment's edges (both boundary and hole edges) to constrain the robot's coverage directions <cit.>. This is to ensure that the robot driving the coverage path covers along long walls and moves predictably in the environment.

Our approach to identify the largest sector is as follows. First, we use a polygonal representation of 𝒲 and extract the orientations of the edges to construct a set of candidate orientations Θ. We limit our set of candidate sectors 𝒬 to rectangles oriented along an angle in θ∈Θ. Given this constraint, we define an axis oriented along each θ and obtain the largest axis-parallel rectangular sector in 𝒲 for each angle. Repeating this for every candidate orientation gives us a set of candidate sectors 𝒬 from which we choose the largest one in our greedy approach.



 §.§ Greedy decomposition


We now propose an algorithm that decomposes the environment 𝒲 by greedily choosing rectangular sectors that cover the largest remaining uncovered area of 𝒲. The pseudocode for our approach is given in Algorithm <ref>. Until the minimum coverage of the environment is achieved (Line <ref>), we compute a candidate rectangular sector for each candidate orientation θ∈Θ (Line <ref>). We then pick the candidate sector with the largest area and add it to our decomposition 𝒮 (Lines <ref>-<ref>). Once the sector is added, we remove the area covered by the sector from the environment so that future sectors may not have overlapping coverage (Line <ref>).

However, in some cases, a small amount of overlap between sectors is useful to cover more area and have better fitting neighbouring sectors. To do this, we introduce a parameter called sector erosion radius β. This radius is used to compute a Minkowski difference between Q and a disk of radius β. The difference Q is removed from the environment so that future sectors may overlap with Q. Setting β to 0 leads to truly non-overlapping sectors, while arbitrarily large values lead to unconstrained overlapping. In our simulation results in Section <ref>, we further motivate the allowance of a small amount of overlap. 




For the case of unconstrained overlap, the candidate sectors must be computed using an alternate approach, as the convex skull method may return the same rectangle repeatedly. One approach is to use a checkerboard decomposition of the environment <cit.> to identify rectangular sub-regions at each orientation. However, the candidate sectors only need to be computed once for this case.




 §.§ Analysis


We now provide a brief analysis of the G-Sect algorithm. In the case of overlapping sectors (large β), we obtain an approximation factor for the G-Sect algorithm as a function of the minimum coverage ratio γ. We derive this factor following that of Wolsey's analysis of the greedy algorithm in <cit.>. Given a set of candidate orientations Θ, let 𝒮^* be the minimum sector decomposition of the environment, i.e. |𝒮^*| ≤ |𝒮| for any 𝒮.


    Given an environment 𝒲 and a minimum coverage ratio of γ, let 𝒮^* be the minimum sector decomposition given candidate orientations Θ. Then, the G-Sect algorithm computes a sector decomposition 𝒮 satisfying
    
    |𝒮|/|𝒮^*|≤ 1 + ln( 1/1 - γ).

    
    



    We first prove this proposition for a finite set of candidate sectors 𝒬 that cover the environment 𝒲. Let T be the number of iterations run by the greedy algorithm, and let 𝒮^r for 1 ≤ r ≤ T be the subset that is picked by the greedy algorithm after r iterations. Following Wolsey's analysis of the greedy algorithm for SSC over a finite set <cit.>, we have the following approximation factor:
    
    |𝒮|/|𝒮^*|   ≤ 1 + ln( a(𝒬) - a(∅)/a(𝒬) - a(𝒮^T-1)).

    Since a is normalized, we have a(∅) = 0. Since 𝒬 covers 𝒲, we have that a(𝒬) = |𝒲|. Given that G-Sect terminates after a minimum coverage of γ|𝒲|, we have that a(𝒮^T-1) ≤γ|𝒲|. Substituting these values in Eq. (<ref>), we get
    
    |𝒮|/|𝒮^*|   ≤ 1 + ln( |𝒲|/|𝒲| - γ |𝒲|) = 1 +  ln( 1/1 - γ)

    
    We now show that this bound also applies when 𝒬 is infinite. Let 𝒮^* = {Q^*_1, Q^*_2, … Q^*_k} be the minimum sector decomposition of 𝒲 from all of 𝒬. Now, let 𝒮 = {Q_1, Q_2, … Q_T} be the sector decomposition obtained by G-Sect given γ. Using these sets, we construct a finite set of candidate sectors 𝒬' = 𝒮∪𝒮^*. On this finite set 𝒬', we can run G-Sect and for each greedy iteration r, we have the following for all Q_i^* ∈𝒮^*:
    
    a(𝒮^r ∪ Q_r+1) - a(𝒮^r) ≥ a(𝒮^r ∪ Q^*_i) - a(𝒮^r).
  
    This follows from the correctness of the greedy step for a set of candidate orientations Θ. As a result, the approximation factor holds on the finite set 𝒬'. However, since 𝒬' contains the choices of G-Sect from 𝒬 and the optimal set from 𝒬, the approximation factor also holds on the infinite set 𝒬. This proves the proposition.






The proof of Proposition <ref> is deferred to the extended version due to space constraints. Obtaining a similar approximation factor for the case of minimally-overlapping sectors is a non-trivial task. However, we have found that decompositions using minimally overlapping sectors are better suited for coverage planning as they reduce instances of double coverage. In Section <ref>, we provide simulation results of planning coverage paths using minimally overlapping sectors.



 §.§ Local sector merges


After G-Sect computes a decomposition, we merge neighbouring sectors to further reduce the number of sectors. Specifically, we conduct merges where the lawnmower path of one sector can be extended to cover a neighbouring sector. Note that these merges may result in sectors that are not necessarily rectangular, i.e. they do not strictly satisfy Problem <ref>. However, they still satisfy the key restriction that each sector is covered by a lawnmower path. More details about the merging is provided in the extended version.


After a decomposition is computed using G-Sect, we merge neighbouring sectors to further reduce the number of sectors. Specifically, we conduct merges where the lawnmower path of one sector can be extended to cover a neighbouring sector. Given the sector decomposition and corresponding sector orientations, we start by counting the number of coverage lines required to cover each sector. We then iterate through the sectors in the order of increasing sector area (i.e. smallest to largest) to check for possible merges. For each sector Q, we look for an adjacent sector Q_adj with a coverage orientation θ_adj such that the number of coverage lines to cover Q ∪ Q_adj along the orientation θ_adj is less than or equal to the cumulative number of lines required to cover each sector individually. The reduction in coverage lines indicates that the lawnmower path of Q_adj can be extended to cover Q. Any ties are broken by choosing Q_adj with the largest area. The merged sector is added back to the set of sectors and the process is repeated until all possible merges have been completed. The resulting sector decomposition forms our final solution to Problem <ref>.

Note that these merges may result in sectors that are not necessarily rectangular, i.e. they do not strictly satisfy Problem <ref>. However, they still satisfy the key restriction that each sector is covered by a lawnmower path. To obtain a strictly rectangular decomposition, this step may be skipped. In practice, a similar strategy may also be used to cover areas that are uncovered by the sector decomposition.



§ SECTOR TOURING





We now describe our approach to obtain a coverage path for the environment using the sector decomposition from Section <ref>. Similar to <cit.>, we formulate this as a GTSP that aims to minimize the time to cover all sectors by determining (i) the visitation order of the sectors in the decomposition, and (ii) entry and exit points for each sector. We create an auxiliary graph where the vertices are grouped into sets. Each set in the graph represents the coverage of a sector and consists of at most four vertices that represent the directed paths to cover the sector, i.e. two possible lawnmower paths per sector where each path can be traversed in two directions. The chosen path and traversal direction determine the entry and exit points for each sector. The graph edges represent the transition paths to traverse from one sector to another. The edge costs are determined by the time to travel along an obstacle-free path from one end of a lawnmower path to another determined using a visibility graph planner <cit.>. We determine this travel time using a piecewise constant acceleration robot model where the robot travels along a straight line with constant acceleration until a maximum velocity is reached. An example set of parameters for this model is given in Table <ref>. In this work, we do not directly penalize the turning time of the robot, but the above robot model penalizes the time to stop to perform an upcoming turn. The GTSP tour on the resulting graph gives the coverage path for the environment as a series of connected sectors.




§ RESULTS



In this section, we present simulation results of coverage planning using the proposed sector decomposition approach for maps of real-world environments. Specifically, our dataset includes 2 street maps of New York and Shanghai cities from <cit.> and 2 anonymized environments obtained from combining maps of real-world environments obtained from our industry partner Avidbots. We compare the coverage performance of our approach against two state-of-the-art approaches: (i) an exact decomposition approach called boustrophedon cell decomposition (BCD) <cit.>, and (ii) our previous approximate decomposition approach called Optimal Axis-Parallel Rank Partitioning (OARP) approach <cit.>.




















For our simulations, we set the desired coverage of the decomposition γ to be 95% of the environment, after which the greedy algorithm is terminated. This choice helps eliminate sectors that cover small and inaccessible areas and effectively reduces the number of sectors in the decomposition. We identify the environment's walls using Probabilistic Hough Transform <cit.> and obtain the set of candidate coverage orientations Θ. Table <ref> shows the robot parameters used for the simulations, including the coverage tool width l. For the BCD and sector decomposition approaches, we ignore small obstacles (obstacle area < 4l^2) as they can be evaded effectively during coverage and do not affect the coverage orientation. For OARP, some these obstacles are removed automatically during the construction of the grid decomposition.

To motivate our configuration of G-Sect pertaining to sector overlap, we present the results of computing a sector decomposition for a simpler test map using two values of the sector erosion radius β: l/4 and 2l. Figure <ref> shows the resulting decompositions, where we observe that increasing the amount of overlap reduces the number of sectors but also results in overlapping coverage lines (i.e., double coverage). However, we observe that a small amount of overlap with local sector merges identifies a decomposition with non-overlapping coverage lines. Therefore, we conduct the rest of the experiments with β = l/4 and conduct sector merges.






Figure <ref> shows the decompositions computed using G-Sect for our test maps. We observe that sector decomposition results in intuitive coverage lines, especially in narrow regions where the coverage lines are oriented along the edges of the environment. Table <ref> shows the results of comparing sector decomposition against that of BCD (exact decomposition) <cit.>. We observe that sector decomposition approach covers the environment with fewer sectors, predominantly due to (i) our choice of γ, and (ii) sector merging. In contrast, BCD results in over-decomposition due to the large number of reflex vertices present in the test environments. G-Sect is less influenced by these vertices for the chosen γ.



We now compare the coverage planning performance of the sector decomposition approach against that of BCD and OARP. The robot model from Section <ref> is used to compute the coverage path cost with parameters as per Table <ref>. Table <ref> shows the results of comparing (i) number of coverage lines, (ii) percent area covered, and (iii) coverage path cost. For every map, we run each approach for 5 trials and present the average for each metric. We observe that the proposed approach achieves the best coverage path cost for all test maps. We believe that this is due to the intuitive coverage line placements achieved by G-Sect, e.g., the coverage lines align with the boundaries and the holes. For the New York and Shanghai maps, we observe that OARP computes paths with higher cost than the proposed approach despite having fewer coverage lines. This is because constraining the robot's motion to axis-parallel (horizontal/vertical) orientations creates longer transition paths (where the robot performs no coverage) that add to the cost. However, for environments with axis-parallel boundaries, we expect the OARP approach to perform better because minimizing the number of coverage lines results in fewer transitions. Thus, a future direction we look to explore is a combination of sector decomposition and OARP <cit.> that minimizes the number of coverage lines in the path while considering multiple coverage orientations. Meanwhile, the BCD approach covers the environment entirely, but results in relatively expensive coverage paths as a result of over-decomposition.















§ CONCLUSION


In this paper, we proposed an environment decomposition approach called sector decomposition for robot coverage planning. The proposed approach aims to decompose the environment into the minimum number of rectangular sectors, which can each be covered using a lawnmower path oriented along its longest edge. We showed that sector decomposition is an instance of the submodular set cover (SSC) problem, and proposed a greedy approximation algorithm with a guarantee on the number of sectors in the decomposition. Finally, we present coverage planning results using the proposed approach for real-world environments and show that it improves upon existing coverage planning approaches <cit.>. A future direction of this work is to minimize the number of turns in the coverage path generated using sector decomposition, for cases when robot turning is detrimental to coverage time and quality.





§ ACKNOWLEDGMENT

This work was supported by Canadian Mitacs Accelerate Project IT16435 and Avidbots Corp, Kitchener, ON, Canada.


IEEEtran


