Autonomous Navigation of MAVs in Unknown Cluttered Environments

TL;DR

This paper introduces a real-time autonomous navigation framework for MAVs in unknown cluttered environments, combining efficient mapping, safe path planning, and dynamic motion control, demonstrated on a lightweight drone platform.

Contribution

The paper presents a novel integrated framework with real-time mapping, safe path generation, and dynamic motion planning specifically designed for MAVs in unknown environments.

Findings

Outperforms existing methods in goal-reaching and exploration tasks

Successfully runs onboard in real-time on a lightweight drone

Demonstrated in diverse indoor and outdoor environments

Abstract

This paper presents an autonomous navigation framework for reaching a goal in unknown 3D cluttered environments. The framework consists of three main components. First, a computationally efficient method for mapping the environment from the disparity measurements obtained from a depth sensor. Second, a stochastic method to generate a path to a given goal, taking into account field of view constraints on the space that is assumed to be safe for navigation. Third, a fast method for the online generation of motion plans, taking into account the robot's dynamic constraints, model, and environmental uncertainty and disturbances. To highlight the contribution with respect to the available literature, we provide a qualitative and quantitative comparison with the state of the art methods for reaching a goal and for exploration in unknown environments, showing the superior performance of our approach. To illustrate the effectiveness of the proposed framework, we present experiments in multiple indoors and outdoors environments running the algorithm fully on board and in real-time, using a robotic platform based on the Intel Ready to Fly drone kit, which represents the implementation in the most frugal platform for navigation in unknown cluttered environments demonstrated to date. Open source code is available at:~\url{https://github.com/IntelLabs/autonomousmavs}. The video of the experimental results can be found at~\url{https://youtu.be/Wq0e7vF6nZM}.

Figures

Tables

Table 1. TABLE I: Qualitative Comparison of state-of-the-art methods for navigation in Unknown Environments. Continues on Table  II

	Oleynikova et. al. [20]	Gao et. al. [15]	Florence et. al. [16]	Usenko et. al. [14]	Mohta et al. [13]	Lin et al.[12]	Ours
Navigation Objectives	Goal	Goal	Goal	Goal	Goal	Goal	Goal
Navigation in FoV	Yes	No	Yes	No	No	No	Yes
Feasible Yaw Dynamics	No	No	Yes	No	No	No	Yes
Feasible Positional Dynamics	Yes	Yes	Yes	Yes	Yes	No	Yes
Map Type	Voxel Hashing TSDF & ESDF	Regular ESDF Grid Map	Search over views	Egocentric Grid	3D local map and 2D global map	TSDF	Linear Octree
Escaping Pockets	Yes	Yes	No	No	Yes	Yes	Yes
Hardware Characteristics	2.4 GHz i7 dual-core	3.00 GHz i7 Nvidia TX1	i7 dual-core	2.1 GHz i7 dual-core	3.40 GHz Intel i7-5557U	Intel i7-5500U Nvidia TX1	1.6 GHz Atom x7-Z8750
Operation Frequency	4Hz	10Hz	200-250Hz	N/A	3Hz	4 Hz	33Hz
Code Available	Not Complete	Yes	Not Complete	Yes	No	No	Will be made available

Table 2. TABLE II: Continuation of Table  I : Qualitative Comparison of state-of-the-art methods for navigation in Unknown Environments

	Cieslewski et. al [30]	Papachristos et. al. [9]	Selin et. al. [10]
Navigation Objectives	Exploration	Exploration	Exploration
Navigation in FoV	Yes	No	No
Feasible Yaw Dynamics	No	Yes	No
Feasible Positional Dynamics	No	No	No
Map Type	Octomap	Octomap	Octomap
Escaping Pockets	Yes	No	Yes
Hardware Characteristics	N/A	3.4 GHz i7 dual-core	N/A
Operation Frequency	N/A	N/A	N/A
Code Available	No	Yes	Yes

Table 3. TABLE III: The overall performance of the generated trajectories

Algorithm	Avg. Path Length [m]	Avg. Velocity [m/s]	Avg. Nav. Time [s]
Gao et. al. [15]	82.56	0.2182	406.41
Usenko et. al. 222Results for this method are shown although not all tests were completed i.e., the robot crashed with the obstacles since several generated trajectories were dynamically unfeasible [14]	77.572	0.48937	170.02
Ours	92.752	0.79753	146.30

Equations

$$\mathcal{Z}_{\text{safe}}[k]=\left\{z\ :\begin{array}[]{l}p\in\mathcal{V}_{\text{safe}}[k],\\ \|v\|_{\infty}\leq V_{\mbox{\scriptsize max}},\ \|a\|_{\infty}\leq A_{\mbox{\scriptsize max}},\\ \|j\|_{\infty}\leq J_{\mbox{\scriptsize max}},\ |\omega|\leq\Omega_{\mbox{\scriptsize max}},\end{array}\right\}.$$

$$\text{key.spatial}(x,y,z,l)=\text{cat}\left\{\bar{x},\bar{y},\bar{z}\right\}$$

$$\begin{array}[]{lll}\bar{x}=\left\lfloor\frac{x}{2^{L-l}r}\right\rfloor,&\bar{y}=\left\lfloor\frac{y}{2^{L-l}r}\right\rfloor,&\bar{z}=\left\lfloor\frac{z}{2^{L-l}r}\right\rfloor,\end{array}$$

$$W[k]=\{[p_c^T,{\psi }_c],[p_2^T,{\psi }_2],[p_3^T,{\psi }_3],\dots ,[p_f^T,{\psi }_f]\}.$$

$$\zeta (t)=$$

$$+k_{2}v(t)+k_{3}a(t)+k_{4}j(t)$$

$$\alpha (t)=$$

$$\dot{s}(t)=$$

$${\mathcal{Z}}_{\eta }(t)=\{z:$$

$$\Vert p(t)-[{\eta }_x(s(t)),{\eta }_y(s(t)),{\eta }_z(s(t)){]}^T{\Vert }_{\infty }\le E_p,$$

$$\Vert v(t){\Vert }_{\infty }\le V_{\text{mbox}max},\Vert a(t){\Vert }_{\infty }\le A_{\text{mbox}max},$$

$$\Vert j(t){\Vert }_{\infty }\le J_{\text{mbox}max},|\omega (t)|\le {\Omega }_{\text{mbox}max}\},$$

Full text

I Introduction

Autonomous navigation in unknown cluttered environments is one of the fundamental problems in robotics with applications in search and rescue, information gathering and inspection of industrial and civil structures, among others. Multirotor Micro Aerial Vehicles (MAVs) are an ideal robotic platform for many of these tasks due to their small size and high maneuverability. MAVs have also been demonstrated to be powerful enough platforms to operate autonomously in GPS-denied environments using only onboard processing and sensing. In many practical use cases, navigation is goal-oriented, meaning that there is a premium on reaching a specific target location as directly as possible, for example, while minimizing time, energy or total distance traveled by the MAV.

Since the environment is unknown, building a map is an important part of the solution as it provides a world representation to the robot that may include metric, topological and semantic information needed by the robot to plan trajectories towards its global goal. Continuous advances in computing hardware and software, availability of powerful sensors, and algorithmic developments [1], enable maps to be processed fast enough to also be useful for collision avoidance with objects entering the field of view of the robot. As the map is created and new areas are discovered, online planning is required as it helps the robot identify shortcuts and escape local minima. Such planning algorithms must take into account the dynamical constraints of the robot to guarantee that the trajectories planned can be executed.

Although mapping, planning, and trajectory generation can be considered mature fields considering certain combinations of robotic platforms and environments, a framework combining elements from all these fields for MAV navigation in general environments is still missing. Recent surveys on classical approaches for mapping can be found in [1], for planning in [2] and for robotic navigation in general in [3].

I-A Contributions

In this paper, we present a framework for MAV navigation in complex, unknown 3D environments. This framework enables robust autonomous navigation in resource-constrained platforms that, using previous methods, would not be able to navigate in cluttered unknown environments.

It consists of three main components. First, a computationally efficient method for mapping the environment from the disparity measurements obtained from an RGB-D camera. Second, a stochastic method to generate a path to a goal located on the map, taking into account field of view constraints on the space that is assumed to be safe for navigation. This method is efficient because it plans only in three-dimensional space and does not require taking into account high order dynamics of the robot which are handled in the motion planning method. In addition, in order to detect collisions, the path planning exploits the structure defined by our map representation for fast collision checking. Third, a lightweight method for the online generation of motion plans over a three-dimensional path, taking into account the MAV’s dynamic constraints, model and environmental uncertainty, and disturbances. Contrary to existing approaches, this method does not require the use of any optimization solver, making it suitable for online planning, even in platforms with low computing power. In addition, the combination of these three main components allows our system to reach a global goal without getting stuck in dead ends. To demonstrate the efficiency of our method, experiments in multiple indoors and outdoors environments, like the ones shown in Figure 1, were implemented in a MAV platform equipped with a low power microprocessor. It is important to highlight that existing implementations solving similar problems require high-end general purpose and graphics processors and significantly higher compute resources.

I-B Related work

The papers [4, 5] are among the earliest works demonstrating fully autonomous MAV navigation. The authors in [4] presented a system that enables autonomous navigation for multi-floor mapping with all the processing onboard a MAV including loop closure, localization, planning, and control. However, the map was constructed using a simplified incremental SLAM algorithm assuming 2.5D environment models formed by vertical walls and horizontal ground planes. The work in [5] demonstrated the feasibility of autonomous mapping and exploration for a quadrotor MAV with a forward-looking stereo camera as its main sensor. The MAV was capable of path planning and exploration, moving autonomously from one point to another with collision avoidance. However, global planning was done using frontier-based exploration applied on a 2D slice of the current occupancy grid map.

More recent papers have continued the strategy of using refinements on the frontiers-based algorithm [6] for global exploration, combined with some variation of the next best view algorithm [7] for local planning. The paper [8] proposes an exploration algorithm that is designed to fly at high velocities as much as possible. Instead of planning trajectories, a reactive mode generates instantaneous velocity commands based on currently observed frontiers. The desired velocity at a frontier is proportional to its distance from the MAV so that for a frontier at the detection range the velocity will be maximum and pointing towards the unknown volume. Unfortunately, the method does not guarantee alignment between the field of view of the camera and the direction of motion, which may hinder obstacle avoidance. In case that no frontiers are observed in the field of view their method falls back to classical frontier-based exploration using a regular 3D voxel grid representation of the environment. In contrast, in our framework we use a more efficient environment representation based on a linear octree.

The contribution in [9] aims to provide accurate mapping simultaneously with the exploration of unknown environments. Their method combines paths sampled from two random trees, where the first tree selects viewpoints to visit next based on the number of unexplored voxels and the second tree is used to find a path to the selected viewpoint that minimizes the robot’s pose and landmarks uncertainty. Paths are only planned inside free space such that they are collision free and can be tracked by the vehicle, given possible motion constraints. However, to guarantee that the paths are collision free they use expensive simulation/optimization-based methods.

In [10], receding horizon Next-Best-View (NBV) planning and frontier exploration are combined for local and global exploration, respectively. The potential information gain for every yaw angle is estimated using sparse raycasting to select the next direction to explore in NBV. Nevertheless, this method does not have a goal oriented objective. The work in [11] describes a system for mapping and planning based on incrementally built signed distance fields in dynamically growing maps. An intermediate goal-finding algorithm complements a conservative local planner which treats unknown space as occupied and inaccessible. The method uses an incrementally-built, dynamically-growing Truncated Signed Distance Field (TSDF) map representation to compute collision costs and gradients. The next intermediate goal for navigation is selected from a set of candidate points sampled from the unoccupied space of the TSDF around the robot by solving an optimization problem to maximize a reward combining an exploration gain and the distance to the global goal. Compared to our proposed method, computing signed distance fields and the need to solve optimization problems online makes their approach computationally more expensive.

The papers [12] and [13] focused on navigation at high speeds to a goal in fully unknown and cluttered 3D environments. In [12] the authors used a local planner to find a path to a target on a global guiding path. The local map is built from depth images using GPU-accelerated TSDF fusion. The perception-action loop is closed using a standard multirotor controller to execute the trajectory generated by a nonlinear optimization solver, which is initialized with the path computed by the local planner. The overall method is compute intensive, requiring both a high-end CPU and a GPU. They report flying in a sparsely cluttered environment at up to 2.2 m/s but with an average whole system delay of 230 ms navigation at such high velocities would not be safe in general unknown environments. In [13] the authors used a local robot-centric map and a local planner to generate the robot trajectory. To escape dead ends and obtain globally consistent local actions an A* planner is provided with a hybrid map formed by combining a local 3D map with a 2D global map. The piecewise linear path from the planner guides the convex decomposition of the local map to find a safe corridor in free space formed as linear equality constraints in a quadratic program (QP) for collision checking. The QP also takes into account dynamic constraints and a modified cost functional such that the generated trajectories are close to the center of the safe corridor. According to the authors, one of the limiting factors for reaching high speeds in their real-world experiments was the size of the map for planning. The other key factor was the sparsity of the map which in their case was determined by the use of a nodding 2D lidar which could reliably run at only around 1.5 Hz. In contrast, our complete system runs at 30 Hz with an average delay of around 3.4 ms.

Among the recent methods focusing on navigation in cluttered environments, not necessarily on exploration, are the works of [14, 15, 16]. The paper [14] proposes a robocentric, fixed-size three-dimensional circular buffer to maintain local information about the environment, trading off the ability to arbitrarily large occupancy maps for faster lookup and measurement insertion operations. Points are inserted into the occupancy buffer by using raycast operations and voxels are updated by using the hit and miss probabilities similar to Octomap. The replanning problem is represented as an optimization of an endpoint cost that penalizes position and velocity deviations at the end of the trajectory, a collision cost function, the cost of the integral over the squared derivatives (acceleration, jerk, snap) and a soft limit on the norm of time derivatives (velocity, acceleration, jerk and snap) over the trajectory. However, this method may get stuck in local minima and the optimization does not take into account the yaw dynamics. The authors in [15] consider the navigation problem in unknown cluttered environments by a MAV equipped with a monocular fish-eye camera. A time-indexed path is generated by fast marching on a velocity field induced from an Euclidead Signed Distance Field (ESDF). The nodes from the path are then used for building a flight corridor in a voxel grid. Trajectory generation is done by posing a constrained quadratic optimization problem and solving it for the coefficients of a Bernstein polynomial which minimize the jerk along the trajectory for each of the three spatial dimensions. The constraints ensure the smoothness, safety as well as the dynamical feasibility of the trajectory. However this method is computationally expensive and does not guarantee that a feasible solution will be found. The work in [16] propose uncertainty-aware proximity queries for planning without any prior discretization of the data in a world frame. The method works by reverse searching over time through sensor measurement views until finding a satisfactory view of a subset of space. The pose uncertainty associated with depth sensor measurements is incorporated into planning by treating each pose with frame-specific uncertainty relative to the current body frame. Nonetheless, this method may get stucked in dead ends.

II Problem Statement and Overview of the Solution

In this work, we address the problem of autonomous navigation of a holonomic robot in a 3D space, from an initial pose to a desired feasible pose in a cluttered unknown environment. It is considered that the robot has an odometry module to measure position and orientation with respect to the robot’s initial pose. Existing visual inertial odometry techniques, such as [17] [18], are adequate for navigation as drift can be expected to be low at least within the local planning area around the robot. In addition, we assume that the robot is equipped with at least one 3D sensor, for instance RGB-D or stereo cameras with finite resolution and known horizontal and vertical field of view.

II-A Notation

The following notation is introduced to define the different regions used along the paper. These regions are illustrated in Figure 2.

Let $\mathcal{B}_{R}(p)$ be a ball in $\mathbb{R}^{3}$ of radius $R=R_{\text{r}}+E_{p}$ centered at a point $p$, where $R_{\text{r}}$ is the radius of the smallest ball containing the robot and $E_{p}$ is a safety distance. Continuous-time is represented by $t$ while $k$ represents discrete-time. The frame rate of the 3D sensor is denoted as $f_{\text{cam}}$, and the field of view at the $k$-th frame, which is assumed to be a frustum, is denoted by $\mathcal{F}[k]$. The configuration space is a bounded 3D cubic volume $\mathcal{V}\subset\mathbb{R}^{3}$. The obstacle region is denoted by $\mathcal{V}_{\mathrm{occ}}\subset\mathcal{V}$ which characterizes the environment. Portions of $\mathcal{V}_{\mathrm{occ}}$ that are sensed to be occupied are added to the volume $\mathcal{V}^{*}_{\mathrm{occ}}[k]$, when a portion of $\mathcal{V}^{*}_{\mathrm{occ}}[k]$ is sensed to be free it is removed from $\mathcal{V}^{*}_{\mathrm{occ}}[k]$. Thus, $\mathcal{V}^{*}_{\mathrm{occ}}$ represents the volume that is assumed to be occupied. Let $\mathcal{V}^{*}_{\mathrm{cst}}[k]$ be the volume swept by all the rays originating at the sensor and terminating either at a detected point or at the border of the $\mathcal{F}[k]$. $\mathcal{V}^{*}_{\mathrm{free}}[k]=\{p\in\mathcal{V}^{*}_{\mathrm{cst}}[k]:\mathcal{B}_{R}(p)\cap\mathcal{V}^{*}_{\mathrm{occ}}[k]=\emptyset\}$, represents the volume inside the field of view that is free. The volume that is assumed to be traversable is denoted by $\mathcal{V}_{\mathrm{nav}}[k]=\{p\in\mathcal{V}:\mathcal{B}_{R}(p)\cap\mathcal{V}^{*}_{\mathrm{occ}}[k]=\emptyset\}$. Moreover, let $\mathcal{V}_{\text{safe}}[k]=\{p\in\mathcal{V}^{*}_{\mathrm{cst}}[k]:\mathcal{B}_{R_{\text{r}}}(p)\cap\mathcal{V}^{*}_{\mathrm{occ}}=\emptyset\}$ be a volume in $\mathcal{V}^{*}_{\mathrm{cst}}[k]$ containing all points with a distance greater than $R_{\text{r}}$ to any obstacle. Note that as long as the robot remains inside $\mathcal{V}_{\text{safe}}[k]$ it is collision free. Our path planning is constrained to sampling points inside $\mathcal{V}_{\mathrm{nav}}[k]$, since the trajectory generation considers a maximum deviation of $E_{p}$ as explained in Section III-B.

A voxel $v$ represents the space contained in a cubic volume, obtained by recursively dividing $\mathcal{V}$ into eight equally sized volumes. The smallest voxel edge length is $r$.

The position, linear velocity, linear acceleration, linear jerk and linear snap are denoted by $p,v,a,j,\zeta\in\mathbb{R}^{3}$, respectively. The yaw orientation and its derivatives, angular velocity, angular acceleration, are denoted by $\psi,\omega,\alpha\in\mathbb{R}$, respectively.

A trajectory is defined as the vector $[p(t)^{T},\ \psi(t)]^{T}$ containing a time-dependant sequence of positions and yaw orientations, where $[\cdot]^{T}$ is the transpose operator. The augmented state for the trajectory is defined as $z(t)=[p(t)^{T},\psi(t),v(t)^{T},\omega(t),a(t)^{T},j(t)^{T}]^{T}$. The set of feasible states is defined as

[TABLE]

II-B Problem Definition

Problem 1

Consider an holonomic robot modeled as a ball $\mathcal{B}_{R}(p(t))$ with dynamics described by $\dot{p}(t)=v(t)$, $\dot{v}(t)=a(t)$, $\dot{a}(t)=j(t)$, $\dot{j}(t)=\zeta(t)$, $\dot{\psi}(t)=\omega(t)$ and $\dot{\omega}(t)=\alpha(t)$. Given an initial and final positions $p_{i},p_{f}\notin\{p\in\mathcal{V}:\mathcal{B}_{R}(p)\cap\mathcal{V}_{\mathrm{occ}}=\emptyset\}$, and initial and final yaws $\psi_{i},\psi_{f}$, respectively, navigate from $z(t_{i})=[p_{i}^{T},\psi_{i},0,\cdots,0]^{T}$ to $z(t_{f})=[p_{f}^{T},\psi_{f},0,\cdots,0]^{T}$ such that $z(t)\in\mathcal{Z}_{\text{safe}}[k]$, $\forall t\in[t_{i},t_{f}]$ and $k=\lfloor(t~{}-~{}t_{i})f_{\text{cam}}\rfloor$, with some finite-time $t_{f}$.

III Reaching a goal in an unknown environment

The outline of the solution proposed to solve Problem 1 is shown in Figure 3. Since the robot is navigating in an unknown environment, we propose a framework divided in three main elements: Map representation, Path planning and Trajectory generation.

First, at the map representation stage, a point cloud is computed taking as an input a disparity image and the odometry of the robot and added to a map representation of the occupied space $\mathcal{V}^{*}_{\mathrm{occ}}[k]$. Note that at any time $k$ the contents of the map inside $\mathcal{F}[k]$ may change. This may be due to measurement errors at the current frame or sensor drift errors accumulated over time. When a voxel previously marked as occupied is observed to be free, the $\mathcal{V}^{*}_{\mathrm{occ}}[k]$ is updated. Second, at the path planning stage, the next exploration action is generated by creating a path inside $\mathcal{V}_{\mathrm{nav}}[k]$, using a variation of the RRT connect, where one tree is expanded using the current position as root and sampling only inside $\mathcal{V}^{*}_{\mathrm{free}}[k]$, and it is connected with the other tree expanded from the goal used as root, which samples in $\mathcal{V}_{\mathrm{nav}}[k]$. In this way, the next position is always contained in $\mathcal{V}^{*}_{\mathrm{free}}[k]$. Finally with the next planned action obtained, a trajectory is generated in such a way that drives the robot from its current state to the next planned action taking into account the robot’s dynamical constraints. The yaw is controlled in such a way that the robot always moves inside $\mathcal{F}[k]$.

III-A Map Representation

Recent work has advocated the use of spatial hash tables to represent the environment. Hash tables provide a sparse representation that can be dynamically expanded with constant time insertion and look up. Following a spatial hashing approach similar to [19], [20] showed that voxel hashing can be used advantageously for robotic exploration and mapping. As an alternative to voxel hashing, hierarchical data structures, such as octrees, sacrifice raw speed for single queries but their additional structure can be advantageous for planning, as shown for example in [21].

In this work, a linear octree is used to represent the map of the environment. Linear octrees trade-off reduced memory usage for speed by storing only leaf nodes instead of all tree nodes as is the case for regular octrees, while preserving the hierarchical structure [22].

The map creation is illustrated in Fig. 4. The Map is implemented as a linear octree with $L$ levels and with axes-aligned bounding boxes. When a new disparity image is received, a point cloud is created by reprojecting occupied pixels to 3D-space in the world coordinate system (block Get point cloud in Figure 4). For each point, a key is generated formed by a level code indicating the depth $l$ in the octree (i.e. $\texttt{\small key.level}=l$) and a spatial code computed by

[TABLE]

where

[TABLE]

$\texttt{\small cat}\{\cdot,\cdot,\cdot\}$ concatenates its arguments represented in $m$ digits and $\lfloor\cdot\rfloor$ represents the floor operation. To find the key corresponding to the current location of the point in the map, equation (2) is used to generate different keys from the root level $l=0$ up to $l=L$ until the key is found in Map (block find point in Map in Figure 4). As is common in octrees, Map insertion is logarithmic in the size of the map, which can be dynamically expanded as needed at practically no cost. For each level $l$, if the obtained key does not correspond to one in $l$, the key is removed from Map and the space represented by this voxel is subdivided into eight equal volume subspaces and their centers are used to generate new keys that are added to the Map (block Add children in Map in Figure 4). Then, key.level is incremented. This process (block Update tree in Figure 4) is repeated until key.level is equal to $L-1$. Finally, when key.level is equal to $L$ the occupancy probability of the corresponding voxel is increased using the stereo error model from [23] (block Update probability in Figure 4). This model has been found to provide an effective method to account for measurement errors, in particular temporally and spatially correlated errors which occur in stereo vision systems. When the voxel probability is larger than a certain threshold $P_{\text{occ}}$, it is considered as part of $\mathcal{V}^{*}_{\mathrm{occ}}[k]$.

After processing all points in the point cloud, the grouped raycasting method, suggested by [24], is applied to all voxels in $\mathcal{V}^{*}_{\mathrm{occ}}[k]\cap\mathcal{F}[k]$ with occupancy probability larger than a threshold $P_{\text{ray}}$, with $P_{\text{ray}}>P_{\text{occ}}$ (block Grouped raycasting in Figure 4). This step consists on updating the occupancy probability of the voxels in $\mathcal{V}^{*}_{\mathrm{cst}}[k]$ by decreasing their occupancy probability according to the stereo error model [23].

Even though a flat grid representation of the map, i.e. only saving observed voxels at maximum discretization, would be faster for map creation, our linear octree implementation presents a significant advantage for collision checking between points during path planning. Notice that the linear octree is similar to a sparse grid representation with an additional block Update tree (see Figure 4). Also notice that all points inserted into the map must be inside $\mathcal{F}[k]$ and that typically there will be some overlap between $\mathcal{F}[k]$ and $\mathcal{F}[k+1]$ as the robot needs to update it’s map frequently during navigation. Therefore, since the method Update tree is only applied to points in $\mathcal{F}[k+1]\setminus\mathcal{F}[k]$ the worst case in terms of computation cost would be expected to happen only at the start when the first frame is processed. Nonetheless, in the worst case, that is, when $100\%$ of the points in $\mathcal{F}[k]$ are added to the map, the penalty in computation time to implement our linear octree has been found experimentally to be only a small fraction of complete perception pipeline.

III-B Motion Planning

In our approach, the robot always has to move in its field of view, i.e., inside $\mathcal{V}^{*}_{\mathrm{free}}[k]$, to ensure collision-free navigation. Te proposed motion planning algorithm is described in the flow diagram of Figure 6 and illustrated in Figure 5.

At the beginning, the robot has a starting position $p_{i}$, a goal position $p_{f}$, a current position $p_{c}=p_{i}$ and has no information about the map as illustrated in Figure 5a. When a new disparity image from the depth sensor arrives, it is converted to a point cloud and serves as an input to the map representation described in Section III-A. The map representation, the current position $p_{c}$ and the goal position $p_{f}$ serve as the input to the path planning algorithm which is solved using a variation of the RRT-Connect [25] algorithm (block Solve RRT-Connect in Figure 6). The solution of this problem generates a sequence of positions that connects through $\mathcal{V}_{\mathrm{nav}}[k]$ the current position $p_{c}$ and the goal $p_{f}$, as illustrated in Figure 5b.

The output of the RRT-Connect consists in a sequence of waypoints $\{p_{c},p_{2},p_{3},\dots,p_{f}\}$ in $\mathcal{V}_{\mathrm{nav}}[k]$. Let

[TABLE]

be a path in $\mathbb{R}^{4}$ from the robot’s current position and orientation $[p_{c}^{T},\psi_{c}]$ to the given goal configuration $[p_{f}^{T},\psi_{f}]$, in such a way that all positions are elements of the RRT-Connect solution and each $\psi_{i}$ corresponds to the angle from the $x$-axis to the vector $p_{i+1}-p_{i}$. Choosing $\psi_{i}$ in this way ensures that at each waypoint the field of view of the robot is aligned with the direction of the next waypoint. Hence, the robot always navigates in $\mathcal{V}^{*}_{\mathrm{free}}[k]$.

To execute the path, the subset $\tilde{W}[k]$ of $m$ waypoints in $W[k]$ together with the point $[p_{b},\psi_{m}]$ where $p_{b}$ is the intersection between the boundary of $\mathcal{V}^{*}_{\mathrm{free}}[k]$ and line segment connecting $p_{m}$ and $p_{m+1}$ (block Get sub-path in $\mathcal{V}^{*}_{\mathrm{free}}[k]$ in Figure 6) is pushed to the trajectory planning algorithm which is explained in detail in Section III-C (block Send $\tilde{W}[k]$ to trajectory planning in Figure 6). Since $p_{m+1}$ is not in $\mathcal{V}^{*}_{\mathrm{free}}[k]$, the point $p_{b}$ is added at the boundary of $\mathcal{V}^{*}_{\mathrm{free}}[k]$, in this way $\tilde{W}[k]$ contains only points in $\mathcal{V}^{*}_{\mathrm{free}}[k]$. Afterwards, $p_{c}$ is updated as $p_{b}$.

Whenever the map is updated, if the line segments connecting consecutive points in $W[k]$ are not $\mathcal{V}^{*}_{\mathrm{occ}}[k]$ (decision is path in $\mathcal{V}^{*}_{\mathrm{occ}}[k]$ ? in Figure 6), then $\tilde{W}[k]$ is pushed to the trajectory planning and $p_{c}$ is updated as before. Otherwise, a replanning is needed. Hence, a new RRT-Connect solution is obtained from $p_{c}$ to $p_{f}$ as shown in Figure 5c (block Solve RRT-Connect in Figure 6). This process continues, exploring new regions as illustrated in Figure 5d, until the goal is reached.

III-B1 RRT-Connect

An RRT-Connect algorithm is used to generate a sequence of points inside $\mathcal{V}_{\mathrm{nav}}[k]$ connecting the initial and final positions. It receives as input the field of view $\mathcal{F}[k]$ of the robot, the initial and final positions and $\mathcal{V}_{\mathrm{nav}}[k]$ defined by the map representation and uses two separate trees, $T_{c}$ and $T_{f}$ initialized at the current position $p_{c}$ and final position $p_{f}$, respectively. Both trees are extended simultaneously as an RRT* [26], i.e. a random point is obtained from $\mathcal{V}$ and rejected if it is not in $\mathcal{V}_{\mathrm{nav}}[k]$, otherwise an attempt is made to connect it with the tree while minimizing a cost function. In this work, we use the Euclidean distance as cost function.

Having a tree sampling inside $\mathcal{F}[k]$ ensures that the navigation is always inside $\mathcal{F}[k]$. To see why this is of paramount importance consider a situation where the goal position is above the starting position with an obstacle in-between; the robot is a quadcopter with a front-facing camera. For this scenario, a naive approach, based on a single RRT*, would create a path in a straight line from the starting position to the goal, leading toward the obstacle above the robot, but since the trajectory for the pitch is a function of the $x$, $y$, $z$, and $\psi$ trajectories, then the robot will not discover the obstacle before a collision. In our approach, the robot wouldn’t be allowed to fly directly towards the goal. Instead it would have been forced to navigate inside $\mathcal{F}[k]$, discovering the obstacle in the process.

The $T_{c}$ tree has the peculiarity that the sampling region to generate random points is confined to $\mathcal{V}^{*}_{\mathrm{free}}[k]$. Nodes in $T_{c}$ are ordered by distance to the robot, such that farthest nodes are checked first when trying to connect $T_{f}$ with $T_{c}$. This critical feature forces the robot to always move in its field of view even in a previously explored area, which is essential due to uncertainty introduced by the sensors.

Figure 5b illustrates both trees, $T_{f}$ with blue lines and nodes, and $T_{c}$ with green lines and nodes lying in $\mathcal{F}[k]$, which is represented by the purple polygon. Finally the solution is shown with red lines.

III-B2 Collision test during planning

Besides point cloud processing, collision detection during planning is the bottle neck in our framework. The basic operation of RRT-Connect algorithm is the random sampling of the map space in search of new points that can be joined to an existing node in the search tree via a straight line, without intersecting occupied voxels in the map. Our algorithm for collision detection takes advantage of the octree structure for efficiency and it is presented in Algorithm 1. It receives the line to be collision tested and the key of a voxel containing both ends of the line. This algorithm tests recursively for collisions in all levels starting from key.level up to $L$.

Fig. 7 presents a benchmark comparison between Algorithm 1, which exploits our map representation, and the naive way of collision checking on the same map by testing every voxel between the two points defining a line. Fig. 7 shows the average computing time for 10000 lines with lengths between 5 to 400 voxels in the same random forest environment described in Section V. In contrast with the naive method, which has a computation time that grows close to linearly with the size of the line, the computation time remains nearly flat with our map representation and Algorithm 1 as it mainly depends on the depth $l$ of the linear octree. Note that the expected length between two random points in this map is 165 voxels.

III-C Trajectory Generation

The solution of the path planning algorithm is used for the generation of dynamically feasible trajectories. The proposed trajectory generation algorithm is described in this section. Given that the model of the UAV is differentially flat, the dynamics for each component of the position and yaw are considered to be decoupled fourth and second order integrator chains, respectively [27].

The given path is specified in terms of the sets of waypoints $\tilde{W}[k]$ that the path planning has generated and pushed to a stack $H_{K}=\{h_{1},\dots,h_{K}\}$ where $h_{i}\in\mathbb{R}^{4}$ consist of the $i$-th position and orientation point, as illustrated in Figure 6. In this section, we propose an algorithm to traverse the path while navigating in the region $\mathcal{Z}_{\text{safe}}[k]$ given in (1). The trajectory generation guarantees that the dynamic constraints are satisfied while allowing an a priori defined maximum separation $E_{p}$ from the path (notice that the regions definition given in Figure 2 takes into account $E_{p}$) and a maximum deviation $E_{\psi}$ from the desired orientation $\psi_{i}$ at any waypoint in the trajectory. The latter constraint ensures that during navigation the next waypoint is always inside the field of view of the robot from the last waypoint reached. The former constraint guarantees that the position $p(t)$ remains inside $\mathcal{V}_{\text{safe}}[k]$, as illustrated in Fig. 8, where $k=\lfloor(t~{}-~{}t_{i})f_{\text{cam}}\rfloor$.

Our method consists of two components. The first one is a virtual control (for the snap of each of the spatial coordinates and the yaw’s angular acceleration) that induces an asymptotically stable equilibrium point $z^{*}=[\eta^{T},0,\dots,0]^{T}\in\mathbb{R}^{14}$ which has an associated basin of attraction around $z^{*}$. In particular, given the requirement of maintaining the trajectory $z(t)$ inside $\mathcal{Z}_{\text{safe}}[k]$, we can find the set $\mathcal{E}(t)\subset\mathcal{Z}_{\text{safe}}[k]$ of points around $z^{*}$ satisfying this requirement, such that the trajectory $z(t)$ passing through $z_{0}\in\mathcal{E}(t)$ at $t=t_{0}$ cannot leave $\mathcal{E}(t)$ for $t\geq t_{0}$. Moreover, the possible values for the equilibrium points are restricted to lie in the line segments connecting consecutive waypoints in $H_{K}$. Thus, $\eta$ is parametrized by $s$ where $s\in\mathbb{R}$ and $\eta(S)$ is the end of the path.

The second component of the trajectory generation provides a dynamic for $s(t)$ to evolve $\eta(s(t))$ (thus moving the equilibrium point $z^{*}$) along the path defined by $H_{K}$, such that $\dot{s}(t)>0$ (thus, moving forward along the path) as long as the trajectory $z(t)$ is in the interior of $\mathcal{E}(t)$, and $\dot{s}(t)$ goes to zero as $z(t)$ approaches the boundary of $\mathcal{E}(t)$. Assuming that at the beginning, $z(0)=[\eta(s(0))^{T},0,\dots,0]\in\mathcal{E}(t)$ then, $s(t)$ is a monotonically increasing function and evolves guaranteeing that $z(t)\in\mathcal{E}(t)\subset\mathcal{Z}_{\text{safe}}[k]$, $\forall t\geq 0$.

Theorem 2

Let $\dot{p}(t)=v(t)$, $\dot{v}(t)=a(t)$, $\dot{a}(t)=j(t)$, $\dot{j}(t)=\zeta(t)$, $\dot{\psi}(t)=\omega(t)$, $\dot{\omega}(t)=\alpha(t)$ be the dynamics of the center point of a robot. Let $\eta(s(t))=[\eta_{x}(s(t)),\eta_{y}(s(t)),\eta_{z}(s(t)),\eta_{\psi}(s(t))]^{T}$ represent the parametrization of the line segments connecting consecutive points in $H_{K}$ and let $z^{*}(t)=[\eta(s(t)),0,\dots,0]^{T}$. Therefore, if $z(0)=z^{*}(0)$ then for the given $E_{p}$ and $E_{\psi}$, by using

[TABLE]

where $z(t)=[p(t)^{T},\psi(t),v(t)^{T},\omega(t),a(t)^{T},j(t)^{T}]^{T}$; $A$ is such that with the above definition of $\zeta$ and $\alpha$, \dot{z}=Az\big{\rvert}_{\eta(s)=0} holds; $P$ satisfies $PA+A^{T}P=-I$; and $\rho>0$ is chosen such that the hyper-ellipse $\mathcal{E}(t)=\{z:(z-z^{*}(t))^{T}P(z-z^{*}(t))\leq\rho\}$ lies inside the set

[TABLE]

$z(t)$* is maintained inside $\mathcal{Z}_{\eta}(t)\subset\mathcal{Z}_{\text{safe}}[k]$ for all $t\geq 0$ and asymptotically reaches $[\eta(S),0,\dots,0]^{T}$.*

Proof:

Notice that $z(0)\in\mathcal{E}(0)$, moreover while $z(t)\in\mathcal{E}(t)$, $\dot{s}\geq 0$ and $\eta(s)$ progresses along the path. Let $e(t)=z(t)-z^{*}(t)$ with $\dot{e}=Ae-\dot{z}^{*}$. Consider the Lyapunov function candidate $V=e^{T}Pe$. Therefore, $\dot{V}=e^{T}(PA+A^{T}P)e+2e^{T}P\dot{z}^{*}=-e^{T}e+2e^{T}P\dot{z}^{*}$ and the value of $V$ decreases for $2e^{T}P\dot{z}^{*}(t)\leq 0$.

Suppose that, due to the evolution of $s(t)$ and as a consequence the evolution of $z^{*}(t)$, $z(t)$ evolves from $z(t_{1})\in\mathcal{E}(t_{1})$ to $z(t_{2})$ in the boundary of $\mathcal{E}(t_{2})$, i.e. where $e(t_{2})^{T}Pe(t_{2})=\rho$, with $e(t)^{T}Pe(t)\leq\rho,\forall t\in[t_{1},t_{2}]$. This implies that, as $z(t)$ approaches the boundary of $\mathcal{E}$ the velocity of $s(t)$ decreases, until $\dot{s}(t_{2})=0$. Thus, 2e^{T}(t_{2})P\dot{z}^{*}(t_{2})=2e^{T}(t_{2})P\left[\frac{d}{ds}\eta(s)\big{\rvert}_{s=s(t_{2})},0,\dots,0\right]\dot{s}(t_{2})=0. Hence, $V$ is decreasing at $t=t_{2}$ and $z(t)$ will move toward the interior of $\mathcal{E}(t)$ where $\dot{s}(t)>0$. Thus, $\eta(s)$ progresses along the path. Therefore, the condition $V<\rho$ will remain. If eventually, for a time $t_{3}$, $e^{T}(t_{3})Pe^{T}(t_{3})=\rho$, then the process is repeated and $\eta(s(t))$ progresses along the path satisfying $z(t)\in\mathcal{E}(t)$. Eventually, $s$ will be such that $\eta(s(t))$ is at the end of the path and remains there i.e. $\eta(s(t))$ remain constant, under this scenario $\dot{V}=e^{T}(PA+A^{T}P)e=-e^{T}e<0$ for all $z\neq[\eta(S),0,\dots,0]^{T}$. Thus, $z(t)$ will approach $[\eta(S),0,\dots,0]^{T}$ asymptotically. ∎

This method is similar to contouring control [28] in that the path is traversed by continuously making a trade-off between separation from the path and velocity. However, unlike existing contouring methods, our approach doesn’t require solving an optimization problem online. It is also similar to LQR-Trees [29] in that Lyapunov analysis is used to induce “funnels” along the path. However, our method is significantly simpler since LQR-Trees are computationally equivalent to Kinodynamic planning in $\mathbb{R}^{14}$. Our method on the other hand exploits the fast exploration of RRTs in $\mathbb{R}^{3}$ to find an obstacle-free path online. This is coupled with an offline stage of LQR virtual control design and Lyapunov analysis to compute the basin of attraction. Thus, given a path, to generate a dynamically feasible trajectory, in the online stage, we only require to evolve the chain of integrators of position and yaw together with evolving $s(t)$, to move the equilibrium point, progressing along the path.

IV Discussion

In this section, we present a qualitative comparison, summarized in Table I and Table II, with the state of the art methods. In particular, we focus this discussion in the contributions reported in [20, 15, 8, 9, 16, 14, 10, 13, 12], as in our opinion, they represent the closest approaches. These contributions can be divided into two problems, reaching a goal in an unknown environment [20, 15, 16, 14, 13, 12] summarized in Table I and exploration of an unknown environment [8, 9, 10], summarized in Table II. The former is the problem addressed in this paper, but since exploration require similar components contributions to both problems are discussed. In fact, the work of [20] is an extension to their previous exploration framework by introducing a soft cost for reaching a goal.

Once a goal has been determined, a critical aspect for collision-free navigation in unknown environments is imposing constraints on the motion plan to navigate within the current field of view, where the robot has the highest confidence on the traversable space. Our method incorporates this idea which has also been used by [20, 8, 16]. The work of [15] assumes that the sensors onboard the robot cover an entire spherical region centered at the robot, which is hard to achieve in practice.

Another important aspect related to navigation in the field of view is ensuring that the camera axis, and hence the yaw orientation is aligned with the direction of motion. The work in [20, 8] attempts to accomplish this restriction by implementing a velocity tracking yaw approach but they don’t guarantee that the generated yaw trajectories will meet angular dynamical constraints.

Additionally, positional dynamical constraints of the robot must be handled explicitly to guarantee that it will remain in safe regions. In particular, the work in [8, 10, 12] does not handle dynamical constraints explicitly. Moreover, [14] solve an optimization problem with soft limits on the time derivatives of the position over the trajectory. Finally, [20, 15, 9, 16, 13] solve a constrained optimization problem to handle positional dynamical constraints. However, solving optimization problems online is computationally expensive, even in the convex case. In our approach, the dynamical constraints are incorporated without the need of an optimization-based solution.

The ability to escape “pockets” or getting out of dead ends is fundamental to complete the navigation task in general cluttered environments. Beyond local collision avoidance, this requires maintaining and keeping an up to date map of the explored areas together with a strategy for handling unexplored regions. Based on this map the robot should be able to generate a motion plan from the current position to the goal. Of the methods reviewed, [9] is purely local while [14] uses an egocentric grid of fixed size to create a local map representation around the robot.  [16, 13] use global planning based on A* on a 2D map to guide local exploration. Compared to our solution, the methods in  [11, 15, 12] are computationally expensive due to the need to generate signed distance fields. As argued in section III-A, the map type and implementation have a significant impact not only on planning global trajectories but on the overall efficiency of the complete navigation framework.

Regarding the hardware characteristics in which the method was implemented, we can highlight that our approach was demonstrated to work with the lowest processor requirements, while [31, 20, 9, 16, 14, 13, 12] used high end Intel  i7 processors and [31, 12] used an additional Tx1 Nvidia GPU. Moreover, as detailed in the next section we were able to plan and replan trajectories at the camera frame rate ($33\mathrm{Hz}$), while [20] and [31] reported an operating frequency of $4\mathrm{Hz}$ and $10\mathrm{Hz}$, respectively. To the best of our knowledge, the platform used in our experiments represents the most frugal platform for autonomous navigation in unknown cluttered environments demonstrated to date.

In the next section, quantitative comparisons with state of the art methods are made. In particular, we focus on the contributions addressing the reaching a goal in an unknown environment problem [20, 15, 16, 14, 12, 13]. Unfortunately, from the contributions reviewed in Table I focusing on this problem, only  [15, 14] have an available code. For this reason, we limit our comparison to those works, even though [14] focuses on a narrowed problem which is based in the solution of a local replanning problem, which assumes the existence of a goal map and a preplanned trajectory.

V Results

The proposed algorithm was implemented using the C++ language and the ROS Kinetic framework [32]. The benchmark results are shown comparing the proposed algorithm with state-of-the-art navigation algorithms in several simulated Poisson forest scenarios generated using the method in [33]. The proposed algorithm was also tested in a simulated maze environment and several real-world scenarios. See the video of the experimental results at https://youtu.be/Wq0e7vF6nZM.

V-A Benchmark

The benchmark experiments were performed on an Intel Core i7-5557U @ 3.1 GHz, 8 GB of RAM, Ubuntu 16.04-LTS operating system, and using ROS Kinetic. The algorithm was compared against two state-of-the-art navigation algorithms [15] [14]. The simulated experiments were performed in several Poisson forest scenarios with a tree density of $0.3$ $trees/m^{2}$ in a space of $50\text{m}\times 50\text{m}\times 2\text{m}$. The trees were limited to a height of two meters and a radius of twenty centimeters. The start and goal positions of the simulated robot were chosen in opposite corners to maximize the distance traveled. The trees per cubic meter metric represent $26.6\%$ of the volume. The environments were simulated using Gazebo together with Rotor-S MAV [34] and RealSense simulation packages. The simulated robot was selected as the Hummingbird and its sensor a RealSense depth camera with 70 degrees of horizontal FoV and 43 degrees of vertical FoV. Two sets of metrics were analyzed in the benchmark. The first set relates to the computation time of each algorithm: map generation time and motion generation time. The second set describes the overall performance of the generated trajectories in each algorithm: total trajectory length, average velocity and time to reach the target goal.

Some parameters had to be tuned to obtain a high success rate in our simulated forest environments, starting from the configuration reported in each paper. The method as reported in [15] assumes a 360-degrees horizontal FoV and ten meters sensing range. For this reason, in the experiments for [15], the observable space was set to cover a front horizontal FoV of 180-degrees by using a multirotor MAV with three RealSense cameras with a depth limit of $7\text{m}$. The maximum velocity of the robot was set to $0.5\text{m}/\text{s}$, the maximum acceleration to $0.5\text{m}/\text{s}^{2}$ and the check horizon and stop horizon parameters were set to $8.5\text{m}$ and $1.0\text{m}$, respectively.

The implementation of the algorithm in [14] presented some limitations as we were not able to achieve a perfect success rate even after careful tuning. The main reason is that dynamic constraints in yaw and acceleration are not taken into account in the trajectory generation leading to two types of failures. On one hand collisions occur, either because the robot is moving too fast and is unable to stop before a detected obstacle, or because it changes direction too quickly and is unable to align the FoV with the velocity before running into unobserved obstacles. On the other hand, in some cases the robot became unstable when the controller tried to follow trajectories requiring large accelerations. The best success rate in our experiments was obtained by setting a maximum velocity of $0.7\text{m}/\text{s}$ and a maximum acceleration of $0.7\text{m}/\text{s}^{2}$ for the robot. The distance threshold, number of optimization points and the dt parameters of the algorithm were set to $0.5\text{m}$, $5$ and $0.5\text{s}$, respectively.

In our algorithm, we configured the maximum depth with three meters, the minimum voxel radius of 0.1 meters and the maximum virtual map size of 150 meters. The parameters used for the trajectory generation were $E_{p}=0.1\text{m}$, $E_{\psi}=1\text{rad}$, for the maximum separation in the position and the orientation, respectively. For the maximum velocity $V_{\max}=1\text{m}/\text{s}$, the maximum acceleration $A_{\max}=1.0\text{m}/\text{s}^{2}$, the maximum jerk $J_{\max}=1.0\text{m}/\text{s}^{3}$, and the maximum angular velocity $\Omega_{\max}=0.2\text{rad}/s$. Moreover, we use the following gains: $k_{1}=~{}55.0$, $k_{2}=-843.75$, $k_{3}=-5406.2$, $k_{4}=-10687.5$, $k_{5}=-10.5$, $k_{6}=-33.3$.

The results of this benchmark are presented in Figure 9 and Table III. Note that our algorithm outperforms [15] and [14] in the first set of metrics shown in Figure 9, with an average motion time of $3.37\text{ms}$ against $103.2\text{ms}$ obtained by [15] and $35.5\text{ms}$ obtained by [14]; and an average mapping time of $0.256\text{ms}$ against $700.7\text{ms}$ obtained by [15] and $2.035\text{ms}$ obtained by [14]. Regarding the benchmark of the performance of the trajectories, the results are presented in Table III where it can be noted that our method outperforms  [15] and [14] in average velocity of the robot and average navigation time. However, our approach generated, on average, slightly longer paths.

A second scenario in which the algorithms were tested is in the maze environment shown in Figure 11. This scenario is challenging as a successful completion requires the ability to escape “pockets” and to maneuver in very tight spaces. Hence, navigating inside the field of view becomes of paramount importance. A typical path execution using our algorithm is illustrated in Figure 11. Notice the loops in the trajectory where the MAV encountered pockets. Rather than stopping completely and then turning around while hovering in place, the MAV was able to turn around while continuing to make forward progress safely by navigating inside the field of view all the time. We did our best to complete this scenario with the algorithms  [14, 15] but unfortunately none of our attempts were successful. In the case of [14] we believe failure to account for yaw dynamical constraints of the system in the planning algorithm was the main cause for the navigation always ending in collisions with the maze walls. In the case of [15], we extended the setup to six cameras covering the full 360-degrees of horizontal field of view and we carefully tuned the algorithm parameters including the polynomial order in the optimizer. Nonetheless, the maze environment could not be completed as in every experiment there was a point where the optimizer was unable to find feasible solutions even after many re-plannings. This environment demonstrates the advantage of the trajectory generation algorithm here proposed. As the results indicate, compared to polynomial trajectories, our method has the advantage of navigating through tight corners, such as doorways in an indoor environment.

V-B Real-World Experiments

To illustrate the effectiveness of our approach for navigating in real unknown scenarios, experiments were performed in the different static and dynamic environments illustrated in Figure 10. The framework was implemented on an Intel Aero Ready-To-Fly drone333https://www.intel.com/content/www/us/en/products/drones/aero-ready-to-fly.html with an Intel Atom x7-Z8750 @ 1.6 GHz, 4 Gb of RAM, Ubuntu 16.04-LTS operating system with ROS Kinetic, an Intel RealSense Tracking Camera T265 444https://www.intelrealsense.com/tracking-camera-t265/ for visual-inertial odometry and an Intel RealSense Depth Camera D435555https://www.intelrealsense.com/depth-camera-d435/ for depth images sensing.

The entire framework runs completely on-board at 33Hz alongside with a custom nonlinear control algorithm for precise trajectory tracking. To the best of our knowledge, these experiments represent the implementation in the most frugal platform for navigation in unknown cluttered environments demonstrated to date. A video of the different tests can be found in  https://youtu.be/Wq0e7vF6nZM.

We configured the maximum depth with four meters, the minimum voxel radius of 0.06 meters and the maximum virtual map size of 20 meters. The parameters used for the trajectory generation were $E_{p}=0.1\text{m}$, $E_{\psi}=1\text{rad}$, for the maximum separation in the position and the orientation, respectively. For the maximum velocity $V_{\max}=1\text{m}/\text{s}$, the maximum acceleration $A_{\max}=0.1\text{m}/\text{s}^{2}$, the maximum jerk $J_{\max}=0.1\text{m}/\text{s}^{3}$, and the maximum angular velocity $\Omega_{\max}=0.2\text{rad}/s$. Moreover, we use the following gains: $k_{1}=~{}35.0$, $k_{2}=443.75$, $k_{3}=-2406.2$, $k_{4}=-4687.5$, $k_{5}=-10.5$, $k_{6}=-33.3$. We obtained the average computation time of each algorithm while running in the Intel Atom microprocessor: map generation time with $3.07\text{ms}$ and motion generation time with $5.1\text{ms}$ seconds.

The first scenario, shown in Figure 10a, is a 3D maze, where the quadcopter had to navigate from it’s initial position in one corner of the maze area to the opposite corner. This scenario is interesting since the robot had to navigate through narrow passages, around tight blind corners and through windows at different heights. The second scenario, shown in Figure 10b, is an industrial warehouse. This scenario was chosen because it presents a potential real-world application for autonomous MAVs, e.g., for capturing inventory and locating out of place items. The third scenario, shown in Figure 10c, is a dynamic cluttered environment with people walking inside a lab area. This experiment exhibits the importance of keeping an up-to-date occupied space since, without this feature, the dynamic obstacles would create “virtual” walls blocking the paths to the goal. It is important to highlight that, from the methods described in Table I only our framework has been demonstrated in a dynamic environment. Finally, the fourth scenario, shown in and Figure 1 and Figure 10d, is an outdoors exploration in a forest environment, which was chosen because represents a cluttered unstructured and natural scenario with irregular obstacles.

VI Conclusion

We have proposed a complete framework for autonomous navigation. In more detail, the framework allows robots to plan and execute trajectories in cluttered environments, simultaneously generating a map that can be used by the robot to escape pockets and reach target locations in complex 3D environments. Our analytical and numerical results show that the trajectories generated by the framework are safe because they take into account both field of view restrictions as well as dynamical constraints of the robot. The framework was implemented in a commercial multirotor MAV kit and was demonstrated to work real-time, at the camera frame rate of 30Hz, without a discrete GPU or a high-end CPU. Future extensions of this work include the integration of trajectory tracking and prediction of dynamic obstacles, which would allow the robot to navigate more effectively in crowded environments.