1. Introduction
Unmanned aerial vehicles, sometimes generically called drones, are becoming increasingly popular to provide mobility solutions for congested smart cities [
1,
2]. Equipped with a wide range of sensors and real-time processing capabilities, drones combine the key principles of technological modernity: data processing, networking, autonomy, and mobility. In smart city environments, drones are called to play a major role in a variety of applications, including package delivery [
3,
4], data collection [
5], traffic policing [
6], surveillance [
7], Search and Rescue (SAR) operations [
8,
9,
10], and even as transportation devices [
11]. The integration of drones into densely populated areas presents many challenges due to safety, security, and privacy considerations. This is especially true when considering autonomous operations with little or no human intervention.
To fulfill their intended purposes, drones must be provided with the ability to explore complex urban environments and search for mission-dependent targets. Motivated by this fact, [
12] recently considered a multi-resolution probabilistic approach for searching for a landing site in an urban environment by maintaining a probability map quantifying the probability of different areas being suitable for landing. Note that in that paper, as well as in the current one, "multi-resolution” refers to the fact that information is gathered from different altitudes, giving increased
spatial resolution when flying at lower altitudes. This is not to be confused with other usages of multiple-resolution, such as image processing tools (e.g., a pyramid parametrization) or employing a sequence of images as in super-resolution. These probabilities are updated based on images taken from a downward-looking camera and by re-visiting certain areas from different viewpoints. In order to do this efficiently, a trajectory planning scheme is required that selects which areas should be re-visited and then computes an efficient and safe trajectory.
In this work, we address the trajectory planning problem outlined above. Following [
13], we propose a solution for the Global Path Planning (GPP) problem that aims to plan safe trajectories to explore an area at a constant altitude. Due to time and energy constraints, the trajectories are necessarily limited in length and must cover areas with a high probability of being appropriate for landing.
The remainder of this paper is organized as follows:
Section 2 reviews existing work regarding well-known coverage path planning algorithms and related computational geometry problems. The formulation of the GPP problem is provided in
Section 3.
Section 4 presents a baseline algorithm for the GPP problem based on an exhaustive search.
Section 5 introduces SST—an efficient heuristic algorithm for the GPP problem. Performance results are reported in
Section 6, and
Section 7 concludes the paper.
2. Related Work
The GPP problem studied in this work is related to a wide range of studies in the literature spread across several fields, from computational geometry problems to coverage and optimal trajectory planning. Indeed, the problem can be considered a variation of area coverage, initially formulated by [
14] and extensively studied since then. Coverage Path Planning (CPP) can be formulated as follows: given a specified region in 2D or 3D, plan a trajectory for one or multiple robots such that every point in the region is visited while avoiding obstacles. Applications of the CPP problem are numerous and include part painting in the automobile industry, guaranteeing full floor cleaning or grass cutting, and finding people in distress in emergency areas. The survey provided by [
15] provides a good introduction and pointers to the literature.
In a typical CPP formulation, the area to be visited is divided into two sub-regions: the Area of Interest (AOI) and obstacles. The AOI is sometimes divided into smaller cells, and each cell may have a deterministic or probabilistic value attached to it. Probabilistic values may help establish an order in which the cells are to be visited and are commonly used when performing search tasks. For instance, Refs. [
9] and [
16] calculate a discrete path for a drone by using probability maps where each cell represents the potential risk/occupancy degree. In particular, [
16] develops a greedy algorithm that uses clustering to accumulate maximum probabilities and is limited by the maximum allowed length.
Another extensive survey [
17] specifically considers the coverage problem using drones. Although the land and air versions of the problem are strongly related, planning a coverage path for a drone includes some additional features, including the limited endurance of the platform, its maneuverability limitations, restricted payload, obstacles that may cause occlusions, and other similar issues. The survey revises different CPP approaches, from simple geometric flight patterns for non-complex AOI to more complex grid-based solutions considering full and partial information about the AOI.
The use of drones for coverage tasks requires considering their mounted camera properties, which can only capture points with a cone-shaped Field of View (FOV). The FOV of the camera can be further reduced by obstacles like buildings and walls. To achieve complete coverage of the AOI, each point must be mapped onto the image plane at least once in a complete trajectory. This was considered, for instance, in [
7,
18], which introduce two-step trajectory planning algorithms for coverage missions of geometrically complex environments that consider camera sensing constraints. First, they find a set of waypoints from which the AOI can be covered fully; then, they plan a smooth trajectory along these waypoints such that the completion time is minimal. In [
19], a flight path planning algorithm is proposed to find collision-free, minimum-length paths for drones’ coverage missions. The authors use a footprints’ sweeps fitting method to address this problem, considering the camera footprint as a coverage unit.
In drone coverage missions, the AOI is sometimes partitioned using a grid where the camera footprint determines the size of each cell [
20]. As a result, the drone can observe an entire cell when located at its geometrical center, and the area is said to be fully covered when it visits the centers of all cells.
The GPP problem discussed in this paper consists of finding a safe path covering an AOI while meeting a time constraint—i.e., the path length is limited. As a result, it is not possible to scan the entire AOI but to choose which sub-areas have a high priority for scanning. In the case described in [
5,
21], a drone needs to visit several spatially distributed Points of Interest (POIs) to maximize the information collected subject to energy constraints. Similarly, [
8] suggests an efficient localization solution for SAR missions. For this case, given a map indicating the importance level of each area, the planning algorithm should determine strategic waypoints at which the UAV hovers and collects data while an efficient trajectory composed of all waypoints is generated using a solution to the Traveling Salesman Problem (TSP).
The tasks of selecting a set of waypoints and optimal routing between these points are dealt with in familiar computational geometry problems. The art gallery problem [
22] considers a polygonal gallery where a minimum number of guards are to be positioned such that at least one guard can see every point in the gallery; the watchman route problem [
23] seeks the shortest route a watchman should take so that every point in a given space can be seen from at least one point along the route; the orienteering problem [
24] aims to construct a path through a set of nodes that maximizes the total score and does not exceed a given budget; and probably the most famous one, the TSP [
25]—all these problems have been proven to be NP-hard and are often solved by approximation algorithms.
One heuristic method commonly used for solving the optimization problems mentioned above is local search [
26]. In a typical local search algorithm, an initial solution is first constructed, for instance, by a greedy algorithm. Then, in an iterative manner, the initial solution is modified by local operations, with a slight improvement in each iteration. Ref. [
27] presents a random mixed local search method for finding an optimal solution for the Open-Loop Traveling Salesman Problem (OLTSP). Starting with some initial trajectory, the algorithm improves this method (in terms of length) by mixing in local search operators (NodeSwap, 2opt, LinkSwap).
Most of the approaches mentioned above use offline solutions computed before the mission is actually executed. Therefore, computing time is of secondary importance and is usually not a measure of the algorithm’s quality. In the case considered in this study, computation time is a significant factor. During the mission of autonomous landing, it is necessary to find a trajectory at decreasing altitudes—i.e., the GPP problem is to be solved several times in a short period. Therefore, in addition to the requirement of finding a near-optimal solution, we aim to develop an algorithm that is also efficient in terms of computation time.
3. System Model and Problem Definition
In this section, the system model and the GPP problem are introduced. The GPP problem is then formulated as an optimization problem and shown to be NP-hard.
3.1. System Model
Consider the problem of finding a landing site for a drone in an urban region . The region is assumed to be a plane partially occupied by structures, including buildings, traffic lights, billboards, vegetation, and similar obstacles typical of built environments. The drone, equipped with a downward-looking camera, explores the region by following a trajectory that lies on the plane parallel to at a constant altitude h. The region is divided into two complementary sub-regions , where the former is the area where the drone is permitted to fly safely and securely while the latter is a no-fly zone (NFZ), i.e., an area where the drone cannot fly due to obstacles or regulations.
Throughout the flight, subsets of
are projected onto the camera image plane. Let
and
denote the image taken by the camera at the waypoint
and the corresponding footprint on
. The image taken at waypoint
will be such that its center lies at the intersection between the camera’s line of sight and the image plane. As illustrated in
Figure 1, the size of the camera footprint
is a function of the drone altitude and the FOV of the camera. The dimensions of the footprint can be calculated using the following:
In order to guarantee a safe landing place,
can be discretized into
identical grid cells
such that
. As shown in
Figure 2, the cell dimensions are derived from the size of the body and propellers of the drone together with the flying conditions (e.g., wind). This partition is in line with discrete search theory (see, e.g., [
28]) but with a different motivation.
Following this, a probability
, with
, is attached to each cell
, resulting in a probability map modeling the likelihood that each cell is suitable for landing. Then, the idea is to re-explore cells with a relatively high probability and update their values. As the level of certainty increases, the probabilities are likely to approach ‘1’ or ‘0’ until one or more probabilities exceed a certain threshold, making it possible to determine that the corresponding cell is suitable for landing. See [
12] for a detailed discussion.
3.2. Initialization
The information available prior to the beginning of the landing mission is a Digital Surface Model (DSM) of the explored area, from which the locations of the obstacles at any height can be extracted. The obstacles are approximated by polygons, and their vertices are given in the world coordinate system.
According to the DSM, an initial probability map is built. As no additional information is available, the values in this probability map are ‘0’ for cells that belong to obstacles and ‘0.5’ otherwise, meaning that, at first, all cells in the free area are equal candidates for a landing site.
3.3. Global Path Planning Problem
The objective of the GPP problem is to find a safe trajectory that begins at an initial position and covers areas with a high potential of being a proper landing site. As the drone has limited energy and performs the trajectory in an urban area, the planned trajectory must comply with a time-of-flight constraint and avoid NFZ.
For a given image footprint
, let the set of pairs of indices
be
Also, given
, let
be the following set of pairs of indices:
With this definition, we can treat as a threshold value that separates the cells of interest from the remaining cells.
Definition 1. The set of waypoints , is said to be a -Coverage (note that this definition is different from the one in [29] for k-coverage—the latter ensures each cell is covered by at least k covers) at altitude h if for all there exists at least one such that . In general, a footprint contains numerous cells; therefore, -Coverage sets are far from unique, and two different ones may have a different number of elements.
Definition 2. A trajectory passing through is a continuous map such that and there exists a set of time instants such that . The trajectory is said to be -covering if is a -Coverage.
In the following, T will simply be referred to as a trajectory, since will be clear from the context. Note that the set of time instants in the definition is, in general, not ordered—namely, .
Definition 3. A cell is said to be visited by a trajectory T if for some k.
Definition 4. A trajectory is said to be safe if for all .
As a standard when introducing new planning algorithms, no dynamic constraints are placed in the definition of feasible trajectories.
3.4. Exact Formulation
Define a cost function over all safe trajectories T. The cost function measures a property of the trajectory that one would like to control. For definiteness, a total traveling time constraint is assumed here; hence, let be the maximal time-of-flight allowed for the trajectory.
With these definitions, the GPP can be translated into the problem of finding the minimum value of
p such that there exists a safe,
p-covering trajectory for which
:
The first constraint guarantees that the desired cost is not violated. For a given p, the second constraint requires T to be p-covering. Finally, the third constraint promises the safeness of T.
Notice that for , the -coverage set will be relatively small, and hence, one would expect to meet the upper bound of the cost function. As gets smaller, the number of cells to be visited increases, and so eventually, the upper bound might not be met by any feasible trajectory. The problem, therefore, captures the desirable property of visiting as many cells as possible while concentrating on the higher probability ones.
Theorem 1. GPP is an NP-hard problem.
Proof. To prove the NP-hardness of the problem, we use a known NP-hard problem, the Orienteering Problem (OP) [
30], and reduce it to the GPP problem in a polynomial time. The OP is formulated as follows. Given
n nodes in the Euclidean plane
, each with a score
, find a route of maximum score through these nodes beginning at
and ending at
of length no greater than
.
Consider an instance of the OP. We reduce it to a GPP problem by the following operations.
Place the nodes on a grid such that a single cell does not contain more than one node.
Convert the scores to probabilities by normalizing them.
Generate a probability map out of the grid by assigning the score values to cells containing nodes and 0 otherwise.
To ensure the selection of and its position at the end of the path, set and .
Set the required initial waypoint as .
Define as a GPP problem with a probability map , initial position , and time constraint . With the assumption of a single-cell size footprint, the minimization of p in is equivalent to the maximization of the total score in . □
The optimization problem considered above provides a mathematical formulation of the GPP problem. In
Section 4 and
Section 5, two alternative approaches for solving the GPP problem that trade the simplicity of exhaustive search with a more complex and efficient algorithm will be discussed.
4. Baseline Algorithm
As GPP is a new problem, we have first developed a solution based on an exhaustive search to serve as a baseline. A naive approach for finding the optimal probability threshold
for the GPP problem presented in Equation (
4) is to list all possible candidates for the solution and check whether each meets the problem’s requirements. This approach results in a factorial algorithm that is, in principle, computationally infeasible for large problems.
As stated before, the value of and the size of the -coverage set are inversely proportional. For instance, assume a specific probability threshold and define the corresponding -covering trajectory . In case violates the cost constraint, then the minimum cannot be lower than . Alternatively, if complies with the constraints, it is certain that the minimum is lower than or equal to . Referring to this behavior, a binary search is appropriate for finding the optimal solution.
The Exhaustive Search (ES) algorithm, initially developed, iteratively searches for the minimum probability threshold for which the constraints are met. In each iteration, is fixed, and a corresponding -covering trajectory is found. Then, is updated according to whether the found trajectory complies with the constraints until convergence. A detailed description is provided in Algorithm 1.
The inputs to the algorithm are a probability map and obstacle locations corresponding to the region at flight altitude h, the required first waypoint, and mission constraints. The output of the algorithm is a trajectory covering a sub-area of at a constant altitude that avoids obstacles and meets the time constraints of the mission.
First, a visibility graph [
31] is built based on the known obstacle locations. The visibility graph allows for finding collision-free optimal paths between points in the free area
. It is used as an auxiliary graph at a later stage when it is desirable to present the connectivity between waypoints. The visibility graph can be built efficiently using, e.g., the Plane Sweep algorithm in [
32].
To determine the search boundaries, two variables
and
are initialized with the minimum and the maximum probabilities found in
. The iterative part begins with calculating the threshold
as the middle of the search boundaries. Considering the probability map, obstacle locations, and the required first waypoint, a corresponding trajectory
is then found. Starting at
, the planned trajectory is
-covering and safe. In case
,
since it meets all the constraints and corresponds to the minimal threshold found so far. Finally, the search range is narrowed according to the previous comparison: the upper boundary
is reduced to
in case the constraints are met, or the lower boundary
is enlarged to
if the opposite is true. The search continues until the search interval, i.e., the difference between
and
, is less than some
.
Algorithm 1: Exhaustive Search |
Input: Probability map , obstacle locations , first waypoint , mission constraints Output:Trajectory T - 1:
= buildVisibilityGraph() - 2:
min_prob(), max_prob() initialization - 3:
- 4:
while diff do - 5:
updateThreshold () - 6:
planTrajectory(, , , ) - 7:
if then - 8:
- 9:
{continue the search in the lower half of the range} - 10:
else - 11:
{continue the search in the upper half of the range} - 12:
end if - 13:
- 14:
end while - 15:
return T
|
Inspired by [
7,
8], the process of planning a
-covering trajectory presented in Algorithm 2 consists of two main parts: waypoint selection and efficient waypoint arrangement. See
Figure 3 for a graphical representation. For a given threshold
, the POIs are described by the set
. As Equation (
2) states, multiple cells are included in the camera footprint when passing through a single waypoint. It is then possible to find a minimum set of strategic waypoints
, which is
-covering and guarantees complete and effective coverage of all the POIs. For this purpose, the POIs are clustered such that the size of each cluster does not exceed the camera footprint size. The set
is then built by collecting the centers of the clusters so that visiting all
guarantees
-coverage. Among the different clustering methods examined, the single-pass algorithm described in [
33] proved to be the fastest.
Algorithm 2: planTrajectory |
Input: Probability map , visibility graph , first waypoint , threshold Output: Trajectory - 1:
applyThreshold(, ) - 2:
ClusterPOI() - 3:
.add() - 4:
buildeGraph() - 5:
solveOLTSP(G, I, R) - 6:
return
|
To construct an efficient path that visits all the waypoints, a complete graph
G with vertices
is built, with the shortest path lengths as its weights. The visibility graph guarantees that the shortest path between each pair of waypoints is collision-free. Based on the complete graph, the visiting order is determined by solving an OLTSP in which the goal is to find the shortest path that visits each waypoint exactly once without returning to the starting position. In particular, the near-optimal algorithm presented in [
27] is used with the nearest-neighbor (NN) algorithm [
25] as an initialization heuristic. The algorithm is based on local-search operations with two input parameters: the number of iterations
I and the number of repetitions
R.
The resulting algorithm generates a trajectory that complies with the entire set of constraints and corresponds to the smallest feasible probability threshold.
5. SST—An Efficient Heuristic Algorithm for the GPP Problem
The ES algorithm is memory-less in the sense that it finds a trajectory each time it is called without taking advantage of the fact that the planned trajectories for different altitudes are not entirely uncorrelated. As a result, time-consuming operations are performed repeatedly, resulting in long computation times. This section presents a heuristic algorithm that exploits the mission properties to reduce the computation times while maintaining good performance.
5.1. Overview
Together with being safe and complying with time constraints, the planned trajectory has to maximize the relevant information collected while following that information, allowing better decision-making regarding which landing spot to select. Since any point in the free area is an appropriate candidate for a trajectory waypoint, selecting a subset of waypoints that maximizes the information among infinitely many possibilities is a great challenge.
To tackle this problem, a pre-processing stage has been added with the aim of finding a finite, narrow set of candidate waypoints that will serve the task of trajectory planning throughout the entire mission. Considering this set of candidate waypoints, the planning stage includes three main steps: Score–Select–Traverse (SST).
Score—Assign each candidate waypoint a score that represents some measure of its corresponding footprint.
Select—Select a subset of waypoints to form the trajectory.
Traverse—Determine the visiting order to minimize travel time.
The detailed algorithms for the pre-processing and planning stages are presented in Algorithms 3 and 4, respectively, and further discussed in the following sections.
Algorithm 3: SST—Pre-Processing |
Input: A preliminary probability map , the minimum flying altitude , obstacle locations in Output: A set of candidate waypoints , a visibility graph - 1:
extractPOI() - 2:
calcFootprintSize() - 3:
ClusterPOI() - 4:
PlaneSweep() - 5:
return
|
Algorithm 4: SST—Planning |
Input: A probability map , first waypoint , mission constraints , visibility graph Output: A trajectory T - 1:
scoreAndSelect() - 2:
solveOLTSP(, I, R) - 3:
post_processing() - 4:
return T
|
5.2. Candidate Waypoint Set—
As part of the planning process (SST), the second step is to select the set of waypoints that will form the trajectory in order to ensure that it visits high-probability areas. In the absence of any preliminary operations, the search space is very large since any point included in the map boundaries and within the free space is valid.
In order to reduce computation times for the planning stage, the search space is narrowed down to a set of candidate waypoints
that are found in a pre-processing stage. This set of points is created by dividing the free space into clusters such that the area of each cluster is fully covered by the footprint of the drone when hovering above its center. As opposed to the ES algorithm, this time, the entire free space is clustered, regardless of the probability values. Moreover, the clustering operation occurs only once, and the footprint size considered is the one obtained at the lowest flight altitude as it increases with height. The set of candidate waypoints
is the collection of all cluster centers. With this set of waypoints as a baseline, any point in the free space can be covered by the drone footprint at any height by simply selecting the cluster center closest to that point of interest:
5.3. Pre-Processing Stage
The pre-processing stage is described in Algorithm 3. This part of the solution is performed once, before the beginning of the mission, and the preliminary probability map, the value of the lowest flight altitude, and a list of obstacle vertices at this altitude are received as inputs.
To determine the smallest area the drone could cover in a single time instant during flight, its footprint size is calculated at the lowest flight altitude; see
Figure 1a and Equation (
1). As the orientation of the drone is unknown at the early stages of planning, the circle inscribed in the rectangle image is considered its footprint.
The set of points of interest is extracted using the probability map and obstacle locations. It contains all cell coordinates in the map boundaries with a probability larger than zero and within the free space . is then clustered with a bandwidth of —the drone footprint size. The collection of all clusters’ centers creates the set of candidate waypoints that are used as a baseline for the planning stage.
In addition to the set , a visibility-graph is built as part of the pre-processing stage corresponding to the obstacles of the lowest altitude. Based on the assumption that obstacles at all altitudes are contained within obstacles at the lowest altitude, the visibility graph represents safe flight routes at all altitudes.
Note: To enable the drone to safely travel the free space while avoiding obstacles, the obstacle locations given as input are first edited such that an offset is added to each of the obstacles. This allows the drone to be treated as a point vehicle while planning the trajectory.
5.4. Planning Stage
The planning stage of the suggested SST algorithm is presented in Algorithms 4–6, as well as in
Figure 4, as follows:
Algorithm 5: scoreAndSelect |
Input: A probability map , first waypoint , mission constraints , visibility graph Output: A graph - 1:
scoreAndSort() - 2:
.addVertex() - 3:
.addVertex() - 4:
- 5:
estimated time to perform current trajectory - 6:
- 7:
while do - 8:
- 9:
chooseNextVertex( - 10:
copy() - 11:
.addVertex() - 12:
estimatePathLength( - 13:
if then - 14:
- 15:
- 16:
- 17:
end if - 18:
.remove() - 19:
if covers entire free area or then - 20:
return - 21:
end if - 22:
end while - 23:
return
|
Algorithm 6: chooseNextVertex |
Input: sorted by scores, footprint size , remaining time-of-flight Output: - 1:
- 2:
- 3:
for v in do - 4:
- 5:
- 6:
if then - 7:
if then - 8:
return v - 9:
end if - 10:
end if - 11:
.remove(v) - 12:
end for
|
scoreAndSelect. The algorithm’s first aim is to select trajectory waypoints that allow it to explore high-probability areas without exceeding the time-of-flight limit. Furthermore, to represent the connectivity between the selected waypoints, a graph is constructed with as its vertices and the shortest path lengths as its weights. This graph will later allow for establishing the shortest path visiting all selected waypoints. The procedure of selecting out of and the construction of is presented in Algorithm.
Each waypoint in
is assigned a score based on the probability map and the flight altitude, indicating the potential for finding a landing zone in its environment (
Section 5.5.1). The candidate waypoints are then sorted according to their scores in decreasing order. The subset of waypoints
that will ultimately form the trajectory is chosen from
in an iterative manner. In each iteration, a waypoint
is selected and added to a temporal copy of
. An upper bound is then calculated for the length of the path visiting every vertex in the temporal graph, as described in
Section 5.5.3. In case the path length meets the time constraint, the set
and the graph
are updated, as well as the value of
presenting the current path length estimation. The process terminates in one of the following cases:
All candidate waypoints have been examined.
The waypoints in cover the entire free area .
The mission constraint has been met by .
To determine the next waypoint to add to (Algorithm 6), two parameters are considered:
min_dist is the minimal distance allowed between two waypoints to avoid redundancy in the data collected during the flight. Its value depends on the flight altitude (footprint size) and a parameter that defines how much overlap is allowed between footprints.
max_dist is the difference between the allowed trajectory length and the currently estimated trajectory length.
is the waypoint with the highest score that has not been examined yet where the following holds:
Here,
is defined as follows:
and
is the Euclidean distance between the waypoints
v and
w.
To build a complete graph with the shortest path lengths as its weights, adding a new vertex to the graph requires finding the shortest path from the new vertex to each of the existing vertices. To calculate these paths, the new vertex is first connected to the visibility graph , where the shortest paths are found.
solveOLTSP. Given the graph , the final step of trajectory planning is to find the shortest path starting at and traversing all its vertices. This problem is an instance of the OLTSP and, similarly to the ES algorithm, is solved using a random mixed local search algorithm with NN as an initialization heuristic.
Post-Processing The local paths found during the construction of are optimal regarding the graph , i.e., according to the obstacles at the lowest altitude. Assuming obstacles at altitude are contained in the obstacles at where , there might be redundant detours around obstacles that are not present at the current altitude. To avoid this, a post-processing procedure checks for possible shortcuts. Denote the waypoints in T that originated in as . The trajectory must pass through these waypoints, which cannot be eliminated. Denote the rest of the waypoints in T as . These waypoints are a part of the local paths, which are used to avoid obstacles and can be eliminated if a valid shortcut is found. A valid shortcut means eliminating a waypoint from T that ends with an edge connecting its adjacent waypoints in the free space . By editing the trajectory in this way, the safeness of T is not violated as well as the mission constraints, since the edges’ weights are the Euclidean distances and the triangle inequality holds.
It should be pointed out that the manner in which is constructed results in a set that does not necessarily fulfill Definition 1 and hence, cannot be determined as a p-coverage. However, it exhausts the mission constraints by covering as many cells as possible while prioritizing those with a high probability.
5.5. Heuristics and Methods
This section describes the heuristics used throughout the SST algorithm.
5.5.1. Scoring—The Information Gain
Given
as a baseline, planning a trajectory
T at altitude
h requires finding a subset
that includes the most informative waypoints for the drone to traverse. The scores attached to each candidate waypoint can be any heuristic representing its information gain. As an example, according to the probability map and flight altitude, the information gain of each point can be measured by the following two properties:
By sorting the waypoints in
according to these properties in decreasing order (first by
, then by
), the algorithm is able to choose as many waypoints as possible for
while concentrating on those with the highest probabilities. In this manner, we will favor waypoints from which the highest probabilities can be observed, even if they are isolated, as required by the optimization problem (Equation (
4)).
5.5.2. Euclidean Distance
In the presence of obstacles, the Euclidean distance is a lower bound for the length of the shortest path between two points .
According to their scores, waypoints are added one by one to the subset . Prior to adding a waypoint to the subset , it has to meet two criteria regarding the distance from current members:
Calculating the Euclidean distance is an operation, as opposed to finding the shortest path, which requires , where n is the number of vertices of the visibility graph (number of obstacle vertices). Therefore, for better performance, a heuristic based on the Euclidean distance is used to decide whether a waypoint should be further examined or not.
5.5.3. Nearest Neighbor
Nearest Neighbor Search (NNS), in the context of proximity search, is the process of finding the point in a set S that is closest to a given point q.
In this case, the NN algorithm is used both to determine an upper bound for the minimum length of a tour that visits all graph vertices and as a heuristic algorithm for OLTSP. Given the first waypoint, this algorithm chooses the nearest yet unvisited waypoint as its next move.
The time complexity of the
NN algorithm is
, where
n is the number of points to visit and the following is guaranteed [
34]:
7. Conclusions and Future Work
This paper dealt with the global path planning problem that arises when considering the autonomous landing of a drone in a dense urban environment. From the overall problem formulation, searching for a landing site required planning collision-free trajectories, meeting time constraints, and performing almost real-time computations. During the planning process, a probability map of the area of interest was considered, containing the likelihood of each sub-area being suitable for landing. In addition, a DSM was used to identify obstacle locations.
We first formulated GPP as a minimization problem and showed that it belongs to the NP-hard computational geometry problem class. Then, we developed two computational algorithms: one based on exhaustive search and a family of approximating ones, generically called Score–Select–Traverse (SST). The first is easy to implement but involves a potentially exponential number of computations. The second includes a number of different variations and is the main contribution of this paper.
The algorithms in the SST family comprise two stages—pre-processing and planning. The pre-processing stage was created to perform time-consuming operations before the beginning of the mission, using only prior knowledge. The planning stage uses the information acquired throughout the search to reduce the area of interest.
The performance of the algorithms was compared using a simulation study. Not surprisingly, our experiments showed that some variations of the SST algorithm can significantly outperform the baseline heuristic in terms of computational times. Although being best in terms of coverage, ES and SST-AC were seen to be computationally expensive, making them unsuitable for almost real-time performance. On the other hand, the coverage performance of the vanilla SST algorithm was sufficiently close to that of ES, hence providing a good tradeoff between computation times and coverage.
Further work should probably be directed at deepening the way we dilute the set of candidate waypoints, in particular by considering using previously planned trajectories. To improve the exhaustion of time constraints, a fast-to-compute, tighter upper bound for the trajectory length should be developed. Lastly, since the proposed algorithm contains several parts that can be computed in parallel, the use of a GPU should be considered to reduce computation times in actual implementations.