Enhanced discrete particle swarm optimization path planning for UAV vision-based surface inspection

TL;DR

This paper introduces an enhanced discrete particle swarm optimization algorithm for UAV surface inspection path planning, effectively addressing coverage and obstacle avoidance with GPU acceleration for faster computation.

Contribution

It presents a novel DPSO algorithm with deterministic initialization, mutation, and edge exchange, optimized for GPU implementation to improve efficiency in UAV inspection tasks.

Findings

Improved path planning efficiency demonstrated on real UAV inspection datasets.

GPU-based implementation significantly reduces computation time.

Effective handling of coverage and obstacle avoidance in large surface inspections.

Abstract

In built infrastructure monitoring, an efficient path planning algorithm is essential for robotic inspection of large surfaces using computer vision. In this work, we first formulate the inspection path planning problem as an extended travelling salesman problem (TSP) in which both the coverage and obstacle avoidance were taken into account. An enhanced discrete particle swarm optimization (DPSO) algorithm is then proposed to solve the TSP, with performance improvement by using deterministic initialization, random mutation, and edge exchange. Finally, we take advantage of parallel computing to implement the DPSO in a GPU-based framework so that the computation time can be significantly reduced while keeping the hardware requirement unchanged. To show the effectiveness of the proposed algorithm, experimental results are included for datasets obtained from UAV inspection of an office building and a bridge.

Tables

Table 1. Table 1 : Percent improvement of the DPSO by augmentations

Algorithm	Building dataset		Bridge dataset
	Time	Travelling cost	Time	Travelling cost
	(%)	(%)	(%)	(%)
Initialization	280	1.4	310	1.7
Random mutation	x	5.0	x	5.5
Edge exchange	x	13.8	x	15.7
Parallel on GPU	6570	x	6720	x
x: not applicable

Table 2. Table 2 : Comparison between the enhanced DPSO, DPSO and ACS algorithms.

Algorithm	Building dataset		Bridge dataset
	Time (s)	Travelling cost	Time (s)	Travelling cost
Enhanced DPSO	32.9$\pm$1.2	2490.2$\pm$38.9	41.6$\pm$1.5	3358.5$\pm$59.7
DPSO	2253.8$\pm$25.2	2998.1$\pm$44.3	2928.4$\pm$33.8	4130.7$\pm$65.8
ACS	2560.1$\pm$16.3	2763.6$\pm$56.8	3617.2$\pm$23.4	3862.3$\pm$87.4

Equations

$$a_{fov}=\frac{1}{2}{r}_c{s}_f,$$

$$p_i=(1-o_p)a_{fov}.$$

$$d_k=\frac{a_{fov}f}{s_s},$$

$$L(\alpha ,\beta ,\gamma )=a_1{\alpha }^2+a_2{\beta }^2+a_3{\gamma }^2,$$

$$f(p)=\sum _{k=1}^n{L}_k+\Vert p-g{\Vert }^2,$$

$$\lambda_{ij}=\left\{\begin{array}[]{ll}1\quad\text{if edge $e_{ij}\in E$ is in tour}\\ 0\quad\mathrm{otherwise}\end{array}\right.$$

$$\text{min}\sum _{e_{ij}\in E}{l}_{ij}{\lambda }_{ij}$$

$$\text{subject to}\sum _{j\in V,i\ne j}{\lambda }_{ij}=2\forall i\in V$$

$$\sum _{i,j\in T,i\ne j}{\lambda }_{ij}\le \left|T\right|-1\forall T\subset V,T\ne \varnothing$$

$${\lambda }_{ij}\in \{0,1\},$$

$$v_{k+1}\leftarrow w.v_k+{\phi }_1{r}_1.(P_k-x_k)+{\phi }_2{r}_2.(G_k-x_k)$$

$$x_{k+1}\leftarrow x_k+v_{k+1},$$

$$x=(n_1,n_2,...,n_N,n_{N+1}),n_i\in V,n_1=n_{N+1},$$

$$v=((n_{i,1},n_{j,1}),(n_{i,2},n_{j,2}),...,(n_{i,\Vert v\Vert },n_{j,\Vert v\Vert })),$$

Full text

††journal: Arxiv

1 Introduction

For robotics inspection of built infrastructure, computer vision can be used to detect most surface deficiencies such as cracking, spalling, rusting, distortion, misalignment, and excessive movements. Over the last decade, much research effort has been devoted to this theme with computer vision becoming an important component of modern Structural Health Monitoring (SHM) systems for built infrastructure such as rust detection of steel bridges [1], crack detection of concrete bridges [2, 3, 4], or bridge condition assessment [5]. In this regard, it is promising to integrate a computer vision system into mobile inspection robots, such as unmanned aerial vehicles (UAVs) [6, 7] or ubiquitous robots [8, 9], especially when dealing with large and hardly accessible structures like tunnels [10]. For this purpose, an efficient inspection path planning (IPP) algorithm is therefore of crucial importance.

In vision-based inspection path planning, it is required to find a trajectory that is informative enough to collect data from different views of a given structure so that the inspection robot can carry out the data acquisition of the region of interest. Depending on size of the inspecting region, the trajectory can be planned for multiple robots to coordinately conduct the data collection [11]. To be visibly processed at a later time, the data collected are often from a sensor of the time-of-flight (optical, sonar or radar) or passive optical (CCD camera) type. Since the computational time for IPP rapidly increases with the area of the region of interest, an IPP algorithm should meet the following criteria:

(i) capability of viewing/covering every surface of the region of interest via at least one planned viewpoint of the inspection sensor,

(ii) obstacle avoidance for the robot,

(iii) generation of an ”optimal” path under available conditions, and

(iv) effectiveness in terms of processing time (for online re-planning and large structure inspection).

Studies on IPP, in general, can be categorised into three groups, namely cell decomposition, sub-problem separation, and other methods. In cell decomposition, the target space is decomposed in sub-regions called cells. The cell shape can be trapezoidal, square, cubic, or customised depending on critical points of Morse functions, often with a uniform size [12, 13, 14]. An exhaustive path connecting each cell is then computed for the coverage, using typically a heuristic algorithm such as wavefront [15] or spiral spanning tree [16]. Methods based on cell decomposition yield good results in terms of coverage and obstacle avoidance. As the path generated, however, may not be optimal, it is worth seeking a better and more feasible alternative. In this context, the IPP separation approach tackling the non-deterministic polynomial time (NP)-hard problems can be divided into two, the art gallery problem that finds the smallest set of viewpoints to cover the whole gallery, and the travelling salesman problem (TSP) that finds the shortest path to visit a set of given cities [17, 18, 19, 20, 21, 22]. Each problem can be solved separately using known methods such as the randomised, incremental algorithm for the art gallery problem [23, 24] and the chained Lin-Kernighan heuristics for the TSP [25]. Other approaches have focused on sampling the configuration space [26], using sub-modular objective function [27], or employing genetic algorithms [28] but they often require constraining the robot to certain dynamic models or end with near-optimal solutions. The requirements remain not only a shorter path but also collision-free.

In this paper, the IPP problem is addressed by first formulating it as an extended TSP. The enhanced discrete particle swarm optimisation (DPSO) is then employed to solve the IPP. Finally, parallel computing based on graphical processing units (GPU) is deployed to obtain the real-time performance. The contributions of our approach are three folds: (i) By formulating the IPP as an extended TSP, both the coverage and obstacle avoidance are simultaneously taken into account. In addition, constraints related to the kinematic and dynamic models of the robot are separated from the DPSO solution so that this solution can be applied to a broad range of robots. (ii) Three techniques including deterministic initialisation, random mutation, and edge exchange have been proposed to improve the accuracy of DPSO. (iii) Parallel computation has been implemented to significantly improve the time performance of DPSO. By utilising GPU, the parallel implementation does not add additional requirements to the hardware, i.e. the developed software can run on popular laptop computers.

The rest of this paper is structured as follows. Section 2 introduces the steps to formulate the IPP as an extended TSP. Section 3 presents the proposed DPSO and its deployment for solving the IPP. Section 4 provides experimental results. Finally, a conclusion is drawn to end our paper.

2 Problem formulation

Our ultimate goal is to design a path planning system for an UAV used for inspecting planar surfaces of largely built structures like buildings or bridges. The sensor used for the inspection is a CCD camera attached to a controllable gimbal. We suppose that the 3D model of the structure and the environment are known prior to planning, for example, by using laser scanners. Here, the IPP objective is to find the shortest path for the UAV’s navigation and taking photos of the target surfaces so that the images captured can be later processed to detect potential defects or damages. We first consider the IPP as an extended TSP and then solve it using the developed DPSO. This section presents the computation of viewpoint selection and point-to-point pathfinding, which are fundamental to formulate the extended TSP problem.

2.1 Viewpoint selection

The viewpoint selection involves finding a set of camera configurations that together cover the whole surfaces of interest. Let $P$ be a finite set of geometric primitives $p_{i}$ comprising the surfaces to be covered. Each geometric primitive $p_{i}$ corresponds to a surface patch within the field of view of the camera. Let $C$ be the configuration space such that every feasible configuration $c_{j}\in C$ maps to a subset of $P$. Each configuration $c_{i}$ corresponds to a position $(x_{i},y_{i},z_{i})$ and an orientation $(\varphi_{i},\theta_{i},\psi_{i})$ of the camera. Given a finite set of configurations $C$, the viewpoint selection problem on one hand calls generally for the minimum number of configurations $c_{i}$ such that all elements $p_{i}\in P$ are covered. On the other hand, from image sticking and defect detection, the following requirements are added to the system: (i) image capturing moment is when the camera is perpendicular to the inspected surface, (ii) sufficiently high resolution to distinguish the smallest feature, $s_{f}$, and (iii) overlapping of images to a percentage $o_{p}$ specified by the sticking algorithm.

It turns out that those requirements simplify our selection problem. The perpendicular requirement confines the camera orientation to the normal of the inspected surface. The resolution requirement suggests the computation of the field of view of the camera as:

[TABLE]

where $r_{c}$ is the camera resolution (see Fig. 1). Taken the overlapping percentage into account, the geometric primitive $p_{i}$ is then:

[TABLE]

The working distance from the camera to the surface can also be computed as:

[TABLE]

where $f$ and $s_{s}$ are respectively the focal length and sensor size of the camera. From (2) and (3), it is possible to determine configurations $c_{i}$ to cover the set of primitives $P$, as illustrated in Fig. 2. Specifically, for each surface $P_{k}\subset P$, a grid with the cell size of $p_{i}$ is first established to cover $P_{k}$. A working surface $P_{k}^{*}$, parallel to $P_{k}$ and distant $d_{k}$ from $P_{k}$, is then created. Projecting the center of each cell of $P_{k}$ to $P_{k}^{*}$ gives the position component of viewpoint $c_{i}$. The normal of $P_{k}$ defines the orientation component of $c_{i}$, which is supposed to be fully controlled by the inspecting UAV so that it can be omitted in our computation.

2.2 Point-to-point pathfinding

Given the viewpoints, the shortest, obstacle-free path between every pair of them need be found to form a graph for later processing. Without loss of generality, different motion planning approaches such as roadmap, decoupling, potential field and mathematical programming can be used here depending on the UAV model and dynamic constraints [29, 30]. In this work, the hierarchical decoupled approach is employed in which open- and closed-loop controllers operating at a variety of rate are linked together from top to bottom [29, 31, 32]. Since the majority of UAVs currently in production often already equipped with an inner-loop tracking controller and a waypoint following system, this approach can be simplified to a discrete search that produces a set of waypoints connecting two viewpoints while avoiding obstacles. For this, the workspace is first divided into a grid of voxels. Each voxel has the free or occupied status corresponding to the presence or absence of an object in that voxel. In order to consider the UAV as a particle moving without collision between voxels, all the free voxels in a sphere of a radius equal to the largest dimension of the UAV are marked as occupied. Thus, the A* algorithm [33] can be used to find the shortest path between viewpoints. In each step, the cost to move from one voxel to another surrounding neighbour is computed as:

[TABLE]

where coordinates $\alpha,\beta,\gamma\in\{-1,0,1\}$ indicate the position of neighbor, and coefficients $a_{1}$, $a_{2}$ and $a_{3}$ assign a particular weight to each direction. The total cost to move from a voxel $p$ to the viewpoint $g$ at step $n$ is given by:

[TABLE]

where $L_{k}$ is the motion cost at step $k$.

2.3 Modelling the IPP as a TSP

For given viewpoints and paths between them, a graph can be built to model the IPP as an extended TSP. We define each viewpoint as a node, $i$, and the path between two viewpoints as an edge, $e_{ij}$. The length, $l_{ij}$, of edge $e_{ij}$ is the cost to travel from node $i$ to node $j$ determined by (5). If the path between node $i$ and node $j$ is blocked due to obstacles, a virtual path between them is defined and a very large cost is assigned for the path. Denoting the set of all nodes by $V$ and the set of all edges by $E$, we restrict motion of the UAV to the graph $G=(V,E)$. The IPP task is now to find a tour, with a minimum cost, that visits each node (viewpoint) exactly once, including the way back to the initial node. Let $T$ be the set of these nodes.

By associating a binary variable

[TABLE]

with each edge in the graph, the IPP is then formulated as follows:

[TABLE]

[TABLE]

[TABLE]

[TABLE]

where $\left|{T}\right|$ is the number of nodes in the tour. The objective function in (7) defines the shortest tour. The constraint in (8) implies each node in the graph has exactly one incoming edge and one outgoing edge, i.e., the tour passes through each node once, while condition (9) ensures no sub-tours, i.e., the tour returns to the original node after visiting all other nodes.

3 Enhanced Discrete Particle Swarm Optimization for Inspection Path Planning

Particle swarm optimization (PSO), inspired by social behavior of bird flocking or fish schooling, is a population-based stochastic technique designed for solving optimization problems [34]. In PSO, a finite set of particles is generated, each particle seeks the global optimum by moving and evolving through generations. Initially, each particle is assigned to a random position and velocity. It then moves by updating its best previous position, $P_{k}$, and the best position of the swarm, $G_{k}$. Let $x_{k}$ and $v_{k}$ be respectively the position and velocity of a particle at generation $k$. The position and velocity of that particle in the next generation is given by:

[TABLE]

[TABLE]

where $w$ is the inertial coefficient, $\varphi_{1}$ is the cognitive coefficient, $\varphi_{2}$ is the social coefficient, and $r_{1}$, $r_{2}$ are random samples of a uniform distribution in the range [0,1]. Equations (11) and (12) imply that the motion of a given particle is a compromise between three possible choices including following its own way, moving toward its best previous position, or toward the swarm’s best position. The ratio between choices is determined by the coefficients $w$, $\varphi_{1}$, and $\varphi_{2}$.

3.1 DPSO approach to the IPP

Since the IPP defined in (7) – (10) is a discrete optimization problem, enhanced algorithms for discrete particle optimization (DPSO) will be developed for our problem, motivated by [35]. For this, let us begin with an outline of our approach to solve the IPP problem using DPSO with improvements in initialization, mutation, edge exchange and parallel implementation.

First, let define the position of particles as sequences of $N+1$ nodes, all distinct, except that the last node must be equal to the first one:

[TABLE]

where $N$ is the number of nodes, $N=|V|$. Since each sequence is a feasible tour satisfying (8) and (9), to minimise the objective function (7) according to (11) and (12), we need to define the velocity and numerical operators for the particles’ motion.

From (12), it can be seen that a new position of a particle can be evolved from the position of its current generation via the velocity operator, considered here as a list of node transpositions:

[TABLE]

where $n_{i},n_{j}\in V$ and $\lVert v\lVert$ is the length of the transposition list.

In DPSO, particle velocities and positions are updated by using the following operations:

The $addition$ between a position $x$ and a velocity $v$ is found by applying the first transposition of $v$ to $x$, then the second one to the result, etc. For example, with $x=(1,4,2,3,5,1)$ and $v=((1,2),(2,3))$, by applying the first transposition of $v$ to $x$ and keeping in mind the equality between the first and last nodes, we obtain (2,4,1,3,5,2). Then applying the second transposition of $v$ to that result gives (3,4,1,2,5,3), which is the final result of $x+v$.

• 2.

The $subtraction$ between a position $x_{2}$ and a position $x_{1}$ is defined as the velocity $v$, i.e., $x_{2}-x_{1}=v$, such that by applying $v$ to $x_{1}$ we obtain back $x_{2}$.

• 3.

The $addition$ between a velocity $v_{1}$ and a velocity $v_{2}$ is defined as a new velocity, $v_{1}\oplus v_{2}=v,$ which contains the transpositions of $v_{1}$ followed by the transpositions of $v_{2}$.

• 4.

The $multiplication$ between a real coefficient $c$ with a velocity $v$ is a new velocity, $c.v$, defined as follows:

• (a)

For $c=0,~{}c.v=\emptyset$.

• (b)

For $0<c\leq 1,~{}c.v=((n_{i,1},n_{j,1}),(n_{i,2},n_{j,2}),...,(n_{i,c\lVert v\lVert},n_{j,c\lVert v\lVert}))$.

• (c)

For $c<0$ and $c>1$, we omit these cases since they do not occur in our DPSO.

3.2 Augmentations to the DPSO

In order to speed up the convergence and avoid being stuck in the local minimum, we propose to enhance optimisation performance of the DPSO as follows.

3.2.1 Deterministic initialization

The swarm in DPSO, having no prior knowledge of the searching space, is initialized with its particles at random positions. This initialization works well for a relatively small search space.

For large structure, the searching result depends, to a great extent, on the initial positions of the particles. Therefore, in order to increase the probability of reaching the global optimum, we propose to exploit features of viewpoints to generate several seeding particles to facilitate the evolution of the swarm in the search space. In our application, viewpoints are generated based on a grid decomposition. Consequently, a back-and-forth tour would generate a near-optimal path, as shown in Fig. 3, if no obstacles occur. From this observation, positions are deterministically assigned for several particles during the initialization process.

3.2.2 Random mutation

Similar to other evolutionary optimisation techniques such as the genetic algorithm or ant colony system, the PSO performs both exploration and exploitation of the search space. Initially, particles are far from each other so they explore different regions in the search space. After evolving through generations, the swarm converges and starts to make more exploitation. At this stage, distances between particles will gradually reduce to the size termed ”swarm collapse” [34], whereby many particles will become almost identical.

In order to avoid the collapse situation and keep the balance between exploration and exploitation, random mutations for particles are employed. After every $i$ generations, identical particles are filtered. The remaining are then sorted according to their cost values. Finally, only one-third of the smallest particles are kept for the next generation. All others are disturbed, each in different and randomly-chosen dimensions.

3.2.3 Edge exchange

The enhancement is based on the geometric feature for which crossing edges can be exchanged to result in a shorter tour. Here, as 3D cross checking may be difficult, a complete search similarly to the 2-opt algorithm is employed to compare each valid combination of the swapping mechanism for edges [36]. In this search, every possible exchange of edges is evaluated and the one with the most improvement is chosen. Figure 4 illustrates the case when an edge exchange between (2,6) and (3,7) to shorten the tour. Since this augmentation is computational demanding, it should be used only when the random mutation does not make any difference.

3.2.4 Parallel implementation on GPU

Owing to the rapidly increased performance with thousands of cores, a graphics processing unit (GPU) can outperform the traditional CPUs for problems that are suitable for processed by SIMD (single instruction multiple data). As our optimisation algorithms are also a SIMD-based, we can take this advantage to implement in parallel the proposed DPSO in GPUs to reduce computation time.

The diagram and pseudo code for parallel implementation are shown in Fig. 5 and Fig. 6 respectively. After initialization, parameters of a particle such as the velocity, position, and fitness are computed in parallel, each particle in a different thread. At the end of each generation, the results are saved to the global memory to update these particle parameters and then a new parallel computation round starts.

In UAVs, parallel programs can be implemented in recent onboard computers having good GPU capability and low power consumption such as Jetson TK1 with 192 CUDA Cores (Kepler GPU), 5 W [37]. The board can be configured as either the main or supplemental board communicated with other components via standard communications protocols like MAVLink. However, if the battery power is highly limited as in some micro UAVs, an alternative solution is to stream the sensory data to the ground control station (GCS) and utilise the GPU of a laptop to conduct the path planning. The result is then uploaded to the UAV via GCS for planning/re-planning and navigation.

3.3 Enhanced DPSO Pseudo Code

For vision-based inspection, to take into account obstacle avoidance of the UAV, a selected combination of random and deterministic initialization for each particle in the swarm is performed on a CPU while its evolutions, including computation of updated particles’ velocity and position, random mutation and edge exchange, are implemented in parallel on a GPU.

By making use of all advantages of the enhanced DPSO algorithm, the pseudo code for our proposed algorithm incorporating the above-mentioned augmentations is shown in Fig. 7.

4 Experimental results

Experiments have been carried out on two real datasets recorded by laser scanners mounted on a UAV for inspection of an office building and a concrete bridge. The first dataset represents a floor of the building with a size of 25 m $\times$ 12 m $\times$ 8 m. The second dataset represents a part of the bridge including piers and surfaces with a size of 22 m $\times$ 10 m $\times$ 4.5 m. Figures 8(a) and 9(a) show the datasets in point cloud representation. In order to apply the IPP algorithm to the datasets, planar surfaces and boundaries need to extracted from them. For this task, we have developed a software for automatic interpretation of unordered point cloud data described in details in [38]. The software uses the Random sample consensus (RANSAC) algorithm combined with data obtained from an inertial measurement unit (IMU) to detect planar surfaces. The convex hull algorithm is then employed to determine their boundaries. The remaining point cloud is clusterized to obstacle objects by finding the nearest neighbour in a 3D Kd-tree structure. Through the software, users are able to select the surfaces they want to inspect, as shown in Fig. 8(b) and Fig. 9(b), respectively.

In all experiments, coefficients $w=1$, $\varphi_{1}=0.4$, $\varphi_{2}=0.4$ are chosen for the DPSO. The number of particles is set to 100. The random mutation is executed in every three generations and the edge exchange is carried out if the random mutation does not improve the result. The parallel implementation is developed based on the CUDA platform. The programs, including both serial and parallel versions, are executed in a laptop computer with CoreTMi7 CPU and GeForce$@$ GTX 960M GPU.

4.1 Path Generation and DPSO Convergence

Figures 8(c) and 9(c) show the paths generated to inspect three selected surfaces of each dataset. Figures 8(d) and 9(d) show the paths in the appearance of obstacles. It can be seen that the back-and-forth pattern is dominant in those paths, except essential changes when having obstacles or switching between surfaces. Figures 8(e) and 8(f) present the front and side views of a zoom-in part of the inspection path showing that obstacles were avoided. Figures 9(e) and 9(f) show similar results for the bridge dataset.

Figure 10 shows the graphs of the fitness value as an objective function of the generation number for the two inspection cases of a building and a bridge. In each graph, the fitness represents the cost to traverse the inspection path. From the dataset of the office building, the DPSO by solving the extended TSP improves 22.2 % of the travelling cost and converges within 60 generations. For the second dataset of the bridge, those numbers are 37.9 % and 80, respectively. The difference is accounted for by the variation in size of the inspection surfaces and the structural complexity of the environments. That is to say in terms of algorithms, care should be given when considering parameters for the exploration (number of particles) and exploitation (number of generations).

4.2 Effect of the augmentations on the DPSO

Table 1 presents the effect of augmentations on the performance improvement over DPSO in percentage by applying our enhanced algorithm. Here, with the dataset obtained from building inspection, the deterministic initialization significantly improves the processing time by 2.8 times and slightly improves the travelling cost by 1.4 %. Notably, the computational efficiency in terms of fast convergence actually comes from the improvement of evolving generations of the swarm by means of initialization. On the other hand, it is not surprised that the edge exchange introduces some enhancement on the travelling cost as it uses brute force transpositions. Likewise, the parallel implementation introduces the most significant impact on the computation time thanks to the parallel processing capability taking advantage of the SIMD feature of the DPSO.

To show consistency in the effectiveness of the proposed approach, we compare our enhanced DPSO algorithm not only with the conventional DPSO but also with an ant colony system (ACS), where the ACS is implemented as in [39]. In the comparison, each algorithm was executed over 15 trials. Table 2 shows the results expressed in the average value and the standard deviation of the processing time and the travelling cost. Compared with the ACS algorithm, our enhanced DPSO for the bridge inspection dataset has shown on average an improvement of 15% in the travelling cost and 87 times in the computation time. Owing to a significant improvement in processing time, the enhanced DPSO can be applied for real-time automated inspection.

5 Conclusion

In this paper, we have presented an enhanced discrete particle optimisation (DPSO) algorithm for solving the inspection path planning (IPP) problem that is formulated as an extended travelling salesman problem (TSP) considering simultaneously the coverage and obstacle avoidance. By augmenting with deterministic initialization, random mutation, edge exchange and parallel implementation on GPU, the proposed DPSO can greatly improve its performance in both time and travelling cost. The validity and effectiveness of the proposed technique are verified in successful experiments with two real-world datasets collected by UAV inspection of an office building and a concrete bridge. In a future work, the algorithm will be extended for inspection of non-planar surfaces and incorporation of online re-planning strategies to deal with inspection of built infrastructure of an irregular shape.

Acknowledgments

The first author would like to acknowledge an Endeavours Research Fellowship (ERF-PDR-142403-2015) provided by the Australian Government. This work is supported by the University of Technology Sydney Data Arena Research Exhibit Grant 2016 and Vietnam National University Grant QG.16.29.