ExAug: Robot-Conditioned Navigation Policies via Geometric Experience Augmentation

I Introduction

Machine learning methods can be used to train effective models for visual perception , natural language processing , and numerous other applications . However, broadly generalizable models typically rely on large and highly diverse datasets, which are usually collected once and then reused repeatedly for many different models and methods. In robotics, this presents a major challenge: every robot might have a different physical configuration, such that end-to-end learning of control policies usually requires specialized data collection for each robotic platform. This calls for developing techniques that can enable learning from experience collected across different robots and sensors.

In this work, we focus in particular on the problem of vision-based navigation, where heterogeneity between robots might include different cameras, sensor placement, sizes, etc., and yet there is structural similarity in the high-level objectives of collision-avoidance and goal-reaching. Training visual navigation policies across experience from multiple robots would require accounting for changes in these parameters, and learning navigation behavior for the target robot parameters — how do we train such a robot-conditioned policy? Akin to the use of data augmentation to learn invariances for generalization in computer vision and NLP , we propose a mechanism for extending the capabilities of learning-based visual navigation pipelines by introducing experience augmentation, or ExAug: a new form of data augmentation to learn navigation policies that can generalize to a variety of different robot parameters, such as dynamics or camera intrinsics, and is robust to small variations (due to wear or quality control). In contrast to typical augmentation schemes that operate on single data points of images or language, since we are dealing with sequential data, ExAug performs augmentations at the level of robot trajectories. Our key insight is that we can generate such augmentations for free if we have access to the geometry of the scene: using scene geometry, we can simulate what the robot’s observations would appear from a different viewpoint, with a different camera hardware, and even what actions the robot should take if it had different physical properties (e.g., size or turning radius).

ExAug uses a combination of self-supervised depth estimation to recover scene geometry, novel view synthesis for generating counterfactual robot observations, and training a policy assuming different robot parameters, to augment the robot behavior in the public datasets — in essence, giving us infinite data from the training environments. We train a shared navigation policy on a combination of trajectories from three distinct datasets representing indoor navigation, off-road driving, and on-road autonomy, on vastly different robot platforms with different sensor stacks — augmented with ExAug (Fig. 1), and show that the trained policy can successfully navigate to visual goals from novel viewpoints, in novel environments, as well on novel robot platforms, by leveraging the various affordances depicted by the different datasets.

The primary contribution of this paper is ExAug, a novel framework to augment the robot experiences in the multiple datasets to train multi-robot navigation policies. We successfully deploy policies trained with ExAug on two different robots in a variety of indoor and outdoor driving environments, and show that such policies can generalize across a range of robot parameters such as camera intrinsics (e.g. focal lengths, distortions), viewpoints, and dynamics (e.g. robot sizes or turning radii).

II Related Work

Geometric approaches to vision-based navigation have been well-studied in the robotics community for tasks such as visual servoing , model predictive control , and visual SLAM . However, such geometric methods rely strongly on the geometric layout of the scene, often being too conservative , and are susceptible to changes in the map due to dynamic objects.

Learning-based techniques have been shown to alleviate some of these challenges by operating on a topological, and not geometric, representation of the environment . Other methods have also successfully used predictive models , representation learning , and probabilistic representations to improve navigation over long distances . While these approaches have been shown to generalize to environmental modifications, they strongly rely on the deployment trajectories (visual observations, robot dynamics, viewpoint, etc.) to be “in-distribution” with respect to their training datasets, which are usually collected on a single robot platform. Our key insight is that we can develop an experience augmentation technique that utilizes data from various robots and augments it to support training policies conditioned on robot parameters that generalize even to new robot configurations.

Data augmentation is a popular mechanism used to artificially increase the “span” of a dataset to encourage learning of “invariances”, hence avoiding over-fitting to a small training dataset . A popular use-case of augmentations in robotics is to use a simulated environment , with randomized augmentations to boost data diversity. However, transferring policies from sim-to-real has a number of challenges due to the inability to simulate complex, real-world environments, and dynamic environmental changes . Some recent work has also studied augmenting the training dataset with non-natural images . ExAug proposes to use augmentations in a similar spirit to these works, but instead of applying simple image-space transformations, it applies augmentations at the level of entire trajectories by modifying both the observations as well as actions.

The closest concurrent works to ExAug are Ex-DoF , which studies synthetic view generation of spherical to augment training data but does not generalization across sensors and other physical robot parameters, and GNM , which studies direct generalization of simple goal-conditioned policies across different robots simply by training on highly diverse datasets. In contrast, ExAug studies how geometric understanding can be used to augment experience, in the form of counterfactual views and actions, and trains a policy conditioned on the robot’s configuration.

III Training Generalizable Policies with ExAug

ExAug uses a geometric framework for data augmentation, where a local point cloud representation of the scene is reconstructed from monocular images, and then used to synthesize novel views to augment the dataset observations. This point cloud is also used to learn novel behavior via our proposed geometry-aware policy objective, providing supervision for the policy conditioned on counterfactual robot configurations (e.g., if a larger robot were in the same place, what would it do?). These two techniques together allow us to augment the robot experiences in multiple datasets to train the policy with counterfactual images and actions. Goal-conditioned policies trained with ExAug can thus be deployed on robots with novel parameters, such as new camera viewpoints, robot sizes, turning radii etc. By combining our method with a topological graph , we obtain a system that performs long-range navigation in diverse environments.

Figure 2 overviews the synthetic image generation process to train the robot-conditioned policy: given a sequence of images $I$ from a dataset, our goal is to transform them into a sequence $I^{\prime}$ that matches the parameters of a different camera. For each image, we achieve this by (i) estimating the pixel-wise depth $D$, (ii) back-projecting to a 3D point cloud $Q_{s}$, and (iii) projecting the point cloud into the image frame of the target camera, resulting in images $I^{\prime}$. We formulate following process on standard image, camera, and robot coordinates (see. Fig. 4[e]).

To estimate depth from monocular RGB images, we use the self-supervised method proposed by and train it on our diverse training dataset from multiple robots. Given access to this depth estimate $D$, we estimate a point cloud $Q_{s}$ from image $I$ as $Q_{s}=f_{\text{bproj}}(D)$, where $f_{\text{bproj}}$ is the learned camera back-projection function .

To convert this point cloud into a synthetic image $I^{\prime}$ for a new camera (with different intrinsics and extrinsics), we first apply a coordinate-frame transformations $T_{st}$ to obtain target-domain point cloud $Q_{t}$, followed by the target camera projection function $f_{\text{proj}}$. Since the coordinate shift can induce mixed pixels, we use a technique of 3D-warping to project the points $Q_{t}$ to off-grid coordinates $[i_{c},j_{c}]$, followed by weighted bilinear interpolation to obtain the target-domain pixel values . Mathematically, this transforms the image $I[i,j]\rightarrow I_{p}[i_{c},j_{c}]$, which is then resampled to obtain the discretized image $I^{\prime}[i,j]$. To generate synthetic images corresponding to the target camera on the target robot, we only measure $f_{\text{proj}}$ and $T_{st}$ from the target robot and apply it in the above process.

It should be noted that our approach of view synthesis using self-supervised depth estimation is one of many different ways to synthesize novel views for augmenting the dataset , and the proposed experience augmentation framework is compatible with any of these alternatives.

III-B Geometry-Aware Policy Learning

The above process generates synthetic images via perceptual augmentation. We now discuss how the control policy is trained, leveraging the same point cloud representation that we used for augmentation to instead provide supervision suitable for a variety of robot types. The actions in the dataset are specific to the robot that collected each trajectory, and might not be appropriate for a robot with a different size or speed constraint. To train a policy that can generalize effectively over robot configurations, we aim to augment this data and provide supervision to the policy that indicates what a different robot would have done in the same situation. To this end, we derive a policy objective that incorporates this experience augmentation via a control objective guided by the estimated point cloud.

We design a policy architecture $\pi_{\theta}$ that predicts velocity commands $\{v_{i},\omega_{i}\}_{i=1\ldots N_{s}}$ and traversability estimates $\{t_{i}\}_{i=1\ldots N_{s}}$, corresponding to the inverse probability of collision. We condition this policy on the current and goal observations $\{I_{c},I_{g}\}$, and robot parameters corresponding to size $r_{s}$ and velocity constraints $v_{l}$, i.e., $\{v_{i},\omega_{i},t_{i}\}_{i=1\ldots N_{s}}=\pi_{\theta}(I_{c},I_{g},r_{s},v_{l})$, with the policy parameterized by neural network weights $\theta$. Note that $I_{c}$ and $I_{g}$ are synthetic images generated as per Section III-A during training, though at test time the policy uses raw images from the target robot’s actual camera. We parameterize the robot as a cylinder with radius $r_{s}$ and a finite height $h_{s}$, which is used for estimating collisions with point cloud from original image of $I_{c}$. We use integrated velocities to estimate future robot positions in the frame of the local point cloud, and define a objective $J$ to train the robot-conditioned policy $\pi_{\theta}$ encouraging goal-reaching while avoiding collisions:

Here $w_{g}$, $w_{d}$, and $w_{t}$ are weighting factors. To encourage collision-avoidance, we penalize positions that lead to collisions between the cylindrical robot body and the environment points:

where $L$ is a normalization factor, $g[i,j]$ is a masked normalization weight that penalizes points inside the robot’s body and accounts for the point cloud density, and $d_{k}[i,j]$ is distance on the horizontal plane between $k$-th predicted waypoint $p_{k}$ and the back-projection of $I[i,j]$,

The point $Q_{k}:=\{Q^{X}_{k},Q^{Y}_{k}\}$ on the robot coordinate of $k-$th waypoint is calculated as $Q_{k}=T_{sk}Q_{s}$, using a coordinate frame transform.

The other components of $J$ correspond to reaching the ground-truth pose $p_{gt}$, predicting the ground-truth traversability $\{t^{gt}_{i}\}_{i=1\ldots N_{s}}$, and a smoothness term:

To train $\pi_{\theta}$ we select pairs of observations $I_{c}$ and $I_{g}$ from synthetic images that are less than $N_{p}$ steps apart. $N_{p}$ is selected for each dataset based on the robot’s speed and dataset’s frame rate, to ensure that they are close enough to establish correspondence between the images.

We assign randomized radii $r_{s}\in\{r_{\text{min}},r_{\text{max}}\}$m to consider large data diversity in robot size. Besides, we set the robot height $h_{s}:=(h_{\text{max}}-h_{\text{min}})$ to a fixed 0.45 m, with the base $h_{\text{min}}$ set at 0.2 m to mask out noisy point cloud corresponding to the ground plane. To condition on robot velocity limitation $v_{l}$, we provide an angular velocity constraint of $\omega_{l}\in[\omega_{\text{min}},\omega_{\text{max}}]\,\text{rad/s}$.

By feeding $I_{c}$, $I_{g}$, $r_{s}$ and $v_{l}$, we can calculate the joint objective $J$ in Eqn. 1. We train $\pi_{\theta}$ by minimizing $J$ using the Adam optimizer with the learning rate $10^{-3}$. This training process enables us to train robot-conditioned policies that can accept different robot parameters.

IV Implementing ExAug in a Navigation System

We now instantiate ExAug in a navigation system by first implementing the low-level robot-conditioned policy and then integrating it with a navigation system based on topological graphs.

For our evaluation systems (see Section V-C), we set the limits of variation of the robot radii and the angular velocity as $\{r_{\text{min}},r_{\text{max}}\}$ = $\{$0.0, 1.0$\}$ and $\{\omega_{\text{min}},\omega_{\text{max}}\}$ = $\{$0.5, 1.5$\}$ to adapt to new robots. We choose $N_{p}=8$ steps and weights $\{w_{g},w_{d},w_{t}\}$ to be $\{5e3,0.025,0.25\}$ after running hyperparameter sweeps.

Figure 3 describes the neural network architecture of $\pi_{\theta}$. An 8-layer CNN is used to extract the image features $z$ from $I_{c}$ and $I_{g}$, with each layer using BatchNorm and ReLu activations. The predicted velocity commands $\{v_{i},\omega_{i}\}_{i=1\ldots N_{s}}$ from 3 fully-connected layers “FCv” are conditioned on the robot parameters $\{r_{s},v_{l}\}$ and $z$. A scaled tanh activation is given to limit the output velocities as per the specified constraints $v_{l}$.

For estimating traversability $\{t_{i}\}_{i=1\ldots N_{s}}$, we integrate the velocities to obtain waypoints predictions and feed them to a set of fully-connected layers “FCt” along with the observation embedding $z$ and target robot size $r_{s}^{\prime}$, followed by a sigmoid function to limit $t_{i}\in(0,1)$. Although $r_{s}=r_{s}^{\prime}$ in training, we found the flexibility of an independent $r_{s}^{\prime}\neq r_{s}$ crucial to the collision-avoidance performance of our system in inference: e.g. setting $r_{s}=0.3$ m dictates the conservativeness of the action commands, whereas $r_{s}^{\prime}=0.2$ dictates the collision predictions, which can be used as a hard safety constraint for triggering an emergency stop.

IV-B Navigation system

Since our policy does not allow us to feed the goal image at far position, we construct a mobile robot system that uses the trained policy at the low level, coupled with a topological graph for planning to evaluate in challenging long navigation scenarios . For the image-goal navigation task, the objective is to navigate to the desired goal image $I_{g_{N_{g}}}$ by solely relying on egocentric visual observations $I_{c}$ and searching for a sequence of subgoals $\{I_{g_{i}}\}_{i=1\ldots N_{g}}$ in the topological graph $\mathcal{M}$.

Following , the navigation system comprises three “modules”, tasked with (i) localization, (ii) low-level control, and (iii) safety. For (i), we follow the setup of Hirose et. al. , where the current observation is localized to the nearest node $i_{c}$ from the $N_{t}=5$ adjacent subgoal images, and pass the subgoal image $I_{g(i_{c}+1)}$ as the next subgoal to the policy module. The policy module uses $\pi_{\theta}$ to obtain velocity commands, which are used in a receding-horizon manner to control the robot, and traversability estimates, which are used by the safety module for emergency stoppage.

V Multi-Robot Datasets and Setup

In this section, we describe the datasets used for training the point cloud estimator and our policy, and the robot platforms used for evaluation.

In order to train a generalizable policy that can leverage diverse datasets, we pick three publicly available navigation datasets that vary in their collection platform, visual sensors, and dynamics. This allows us to train policies that can learn shared representations across these widely varying datasets, and generalize to new environments (both indoors and outdoors) and new robots.

GO Stanford (GS): The GS dataset consists of 10 hours of tele-operated trajectories collected across multiple buildings in a university campus. The data was collected on a TurtleBot2 platform equipped with the Ricoh Theta S spherical camera.

RECON: The RECON dataset consists of 30 hours of self-supervised trajectories collected in an off-road environment. This data was collected on a Clearpath Jackal UGV equipped with an ELP fisheye camera.

KITTI: KITTI is a dataset collected on the roads of Germany, with trajectories recorded from a narrow FoV camera mounted on a driving car. We use a subset of 10 sequences from the KITTI Odometry dataset for training .

In training, we set the maximum interval $N_{p}$ between $I_{c}$ and $I_{g}$ as 12 for GS and RECON and 2 for KITTI due to the maximum speed of each platform and the frame rate.

V-B Implementation Details: View Synthesis

Since each dataset contains actions from a single camera, we use the view synthesis process described in Sec. III-A to augment the datasets with novel viewpoints. We synthesize views for three target cameras: Intel Realsense (narrow FoV), ELP Fisheye (wide FoV) and Ricoh Theta S (spherical) at a hypothetical camera pose $[0.2,0.0,0.3]$ on the robot coordinate to train three policies for each target camera.

We use a self-supervised depth and pose estimation pipeline . We resize the images for each dataset to a standard size of $416\times 128=(N_{U}\times N_{V})$; for data with a spherical camera, we discard the rear-facing camera due to robot body occlusions. Following Hirose et. al. , we introduce the learnable camera model to use the dataset without camera parameters and provide supervision for pose estimation during training to resolve scale ambiguities in depth estimates. Please refer to the original paper for further implementation details. To generate novel views, we project the 2.5D reconstruction of the scene into a 128$\times$128 image frame for each target camera, obtained by using its camera parameters.

V-C Evaluation Setup

We evaluate policies trained with ExAug on two new robot platforms with a variety of modifications to evaluate different robot sizes, camera hardware, viewpoints etc., as shown in Figure 4: [a-c] show a custom robot platform, Vizbot , which is a new robot without any training data. We deploy the Vizbot in multiple different configurations, such as with a spherical, narrow, or wide FoV camera, artificially boosted robot size (with a cardboard cut-out), and modified camera pose (by mounting the camera on a raised platform). We also evaluate our policies on the LoCoBot platform (Figure 4[d]), with a different robot base and camera pose.

In addition to closed-loop evaluation, we also perform offline evaluation using one hour’s worth of navigation trajectories collected with a Vizbot by teleoperating it in both indoor and outdoor environments. Offline evaluation serves as a proxy for closed-loop evaluation during the training process to identify the best hyperparameters.

VI Evaluation

Our experiments aim to study the following questions:

Can ExAug augment experience from multiple datasets to train a control policy that generalizes to new robot configurations and robots?

Can ExAug outperform prior methods, as well as policies trained on single-robot datasets?

We implement ExAug on a Vizbot and compare it against competitive baselines in a number of challenging indoor and outdoor environments. All our baselines use privileged omni-directional observations from a spherical camera, and we compare the downstream navigation performance against ExAug with access to different camera observations, including narrow FoV cameras. Despite this, ExAug consistently outperforms baselines, with a higher success rate and fewer collisions.

Random: A control policy that randomly generates velocities between same upper and lower velocity boundaries.

DVMPC : A controller based on a velocity-conditioned predictive model that is trained via minimizing the image difference between the predicted images and the goal image.

Imitation Learning and DVMPC use raw images from the best single-robot dataset (GS), since sharing heterogeneous data leads to worse performance.

In evaluation on an offline dataset of real-world trajectories, Table I reports the predicted goal arrival, collision-free rates, traversability accuracy, and test loss values of each method. From Table I[a], we observe that ExAug consistently achieves higher goal-arrival rates and collision-free rates, as well as a lower loss estimate. We also ablate the augmentation and geometric loss components of ExAug. ExAug (full) with synthetic images at target camera pose can outperform the ablation of view augmentation with raw images at different camera pose. In addition, our geometric loss performs to avoid collision.

We further compare ExAug against DVMPC in 12 challenging real-world indoor and outdoor environments for the task of goal-reaching, with 3 trials per environment. Note that DVMPC expects spherical images due to its strong reliance on the geometry of the scene, whereas our method can work with any camera type. In each environment, we collect a topological map by manually teleoperating the robot from start to goal, saving “image nodes” at 0.5Hz. We randomly place novel obstacles on or between subgoal positions, after subgoal collection, in half of the environments.

Table I[b] presents the performance of the different variants of ExAug and DVMPC. Comparing performance with the same camera (spherical), our method vastly outperforms DVMPC: with over a $100\%$ improvement in goal-arrival rates (GA) and $75\%$ reduction in collisions. The performance gap is most significant in challenging environments sharp, dynamic maneuvers and novel obstacles, where DVMPC fails to avoid the obstacle and loses track of the goal. Furthermore, we find that ExAug continues to perform strongly from cameras with limited FoV, like the RealSense camera, outperforming DVMPC from a spherical camera.

VI-B Can ExAug Control Different Robots?

Next, we qualitatively show the above behaviors in a closed-loop evaluation with novel robot configurations (Fig. 4). We systematically evaluate ExAug on modified versions of a Vizbot with (i) different camera mounting heights, (ii) with different physical sizes, and (iii) with different dynamics constraints. We also show that the same policy can control a LoCoBot, a new robot absent in the training datasets.

For evaluating invariance to viewpoint change, we evaluate the two methods on a robot with two different camera height configurations that are 30cm apart. For ExAug, we train two separate policies, one for each target camera height, and compare against DVMPC. Table II shows that, while DVMPC struggles with goal-reaching and collision avoidance due to the out-of-distribution observations, ExAug continues to perform strongly and suffers no degradation.

We also perturb the robot size $r_{s}$ and dynamics constraints on angular velocity $\omega_{l}$ and find that the trained policies can account for these differences. Fig. 5[a] shows the qualitative behavior of ExAug under different size parameters: when its radius is increased to 1m, it takes an alternative path around the obstacle because the shortest path would lead to collision with its large footprint, and it successfully reaches the goal. Fig. 6[a] shows the output of our policy for different values of $r_{s}$, overlaid on a point cloud cross-section, showing that large $r_{s}$ leads to increasingly conservative trajectories. Fig. 5[b] shows the qualitative behavior of the robot under different dynamics constraints: when the angular velocity is limited (blue), the robot cannot take sharp maneuvers and instead takes a smoother trajectory to avoid the obstacles. Fig.6[b] shows the outputs of our policy for different $\omega_{l}$, suggesting that the policy can account for different constraints.

Lastly, Fig. 6[c] shows a timelapse of ExAug deployed on a LoCoBot. Despite having a higher camera pose and smaller angular velocity range, our method can successfully guide a LoCoBot to the goal while avoiding unseen obstacles in a challenging outdoor environment.

VI-C Does Training on Multiple Datasets Help?

A central hypothesis in our work is that, by leveraging datasets from different platforms in different environments and combining them with experience augmentation, we can train generalizable policies that can control robots with different sensors and physical properties. In this section, we evaluate the relative contribution of each portion of our combined dataset to overall performance, so as to ascertain whether more diverse data actually improves performance.

Towards this, we train policies with ExAug using subsets of the three datasets and evaluate the policies with RealSense on offline real-world trajectories. Table I[c] shows the 3-dataset policy consistently outperforming other variants, with the lowest loss value (Eqn. 1). We hypothesize that training on larger, more diverse datasets encourages the model to learn a more generalizable representation of the observations, and results in better downstream navigation performance.

VII Conclusions

We proposed a framework for training a robot-conditioned policy for vision-based navigation by performing experience augmentation on heterogeneous multi-robot datasets. We propose ExAug, a technique that uses point clouds recovered from monocular images to construct synthetic views and counterfactual action labels to supervise the policy with trajectories that other robots would have taken in the same situation. The resulting policy can be conditioned on robot parameters, such as size and velocity constraints, and deployed on new robots and in new environments without additional training. We demonstrate our method on two new robots and in two new environments.

Our method does have a number of limitations. First, we must manually select the robot parameters to condition on. Second, we still require the robots to be structurally similar – e.g., all robots have forward-facing cameras. An exciting direction for future work would be to utilize the point clouds to also construct synthetic readings for other types of sensors, such as radar, and further extend the range of robots the system can control, potentially with learned latent robot embeddings.

References

APPENDIX

Figure 7 provides an overview of our method. Our challenge is to train a robot conditioned control policy by augmenting experiences from multiple public datasets. Different from , our method does not require new dataset collection or online training on our robot. In our method, there are two steps, (1) view augmentation, and (2) geometric-aware policy learning.

To efficiently leverage multiple datasets which are collected by different robots with different cameras, our method generates the images with the specified camera intrinsic and extrinsic parameters via depth estimation in the first step. Note that our method assumes that we can measure the camera intrinsic and extrinsic parameters from our own robot. In the second step, we train the policy with a novel geometric-aware objective to avoid collisions between the arbitrary sized robot and its environments. In this training, we use the synthetic images from the first step.

Our geometric-aware objective, $J_{\text{geo}}$ can penalize the robot positions that collide with the environment. In $J_{\text{geo}}$ of eq.(2), we give the masked normalization weight $g[i,j]=m^{g}_{k}[i,j]\cdot w^{g}_{k}[i,j]$. In this section, we explain our implementation of $m^{g}_{k}[i,j]$ and $w^{g}_{k}[i,j]$, respectively. $m^{g}_{k}[i,j]$ is the binary value to remove the effect of $(r_{s}-d_{k}[i,j])^{2}$ in the cases where the 3D point $Q_{k}[i,j]$ is outside of the robot’s area.

$w^{g}_{k}[i,j]$ is the weighting variable to balance the geometric cost according to the sparsity of the 3D points.

Assuming the corresponding 3D point is representative point in the area formed by the adjacent four points, we dictate $w^{g}_{k}[i,j]$ by its approximate area. Here $f_{dist}(A,B)$ is the function to calculate the distance between A and B. Without $w^{g}_{k}$, $J_{geo}$ gives larger penalization to obstacles with dense 3D points, and it causes the robot to collide with obstacles with sparse 3D points.

The other parameters $N_{U}$ and $N_{V}$ in eq.(2) are the number of pixels on $U$ and $V$ axis. And $L$ is defined as $L=\sum_{k=1}^{N_{s}}\sum_{j=1}^{N_{V}}\sum_{i=1}^{N_{U}}m^{g}_{k}[i,j]$ to calculate the mean of the effective 3D points inside of the robot’s area.

VII-C Process of view synthesis

Our view synthesis approach generates synthetic images via an estimated point cloud. As shown in Section III-A, we project the point clouds onto the image plane. Then, we interpolate the projected images to fill in the pixels without a projected color value. Here, we explain the detail implementation of both the projection and interpolation process.

By projecting the point cloud $Q_{t}$ on to the image plane using intrinsic parameters measured from the target camera, we can get the corresponding pixel position $[i_{c},j_{c}]$ in target image coordinates as follows:

where $f_{\text{proj}}()$ is the projection function using measured camera intrinsic parameters. Here, $i_{c}$ and $j_{c}$ are scalar values (not integer values). Hence, we can have four candidate pixel positions to project the pixel value of $I[i,j]$. To fill in many pixels, we merge four intermediate images $\{I_{p_{i}}\}_{k=1\ldots 4}$ in the projection process. The four intermediate images can be given as follows:

where $\lceil\cdot\rceil$ and $\lfloor\cdot\rfloor$ indicate ceil and floor functions, respectively. $\{I_{p_{k}}\}_{k=1\ldots 4}$ can be obtained by executing eq.(8) for all pixels, starting from the one with the largest depth to consider occlusion. The projected image $I_{p}$ can be calculated by a weighted sum of $\{I_{p_{k}}\}_{k=1\ldots 4}$ as follows:

where $\{w_{p_{k}}\}_{k=1\ldots 4}$ are weight matrices that give larger weight to the pixels that are closer to $[i_{c},j_{c}]$,

where $\{l_{k}\}_{k=1\ldots 4}$ are the lengths between $[i_{c},j_{c}]$ and the corresponding pixel position.

The last process in our view augmentation is interpolation of $I_{p}$. Although we can fill a lot of pixel positions by merging in eq.(9), there are still a lot of blank pixels in $I_{p}$. Nearest neighbors is one of the simplest methods to fill them. However, it makes the generated images noisy. We fill the blank pixels with a weighted sum of the closest four pixels to generate $I^{\prime}$, similar to eq.(9).

It should be noted that alternative methods are possible in projection and interpolation . We employ the above process because it is fast on GPU.

VII-D Navigation system

To evaluate our proposed method using a real prototype mobile robot in navigation, we construct a navigation system (Algorithm 1) with our trained policy. Our task is to arrive at the position of final goal image $I_{gN_{g}}$ by using current image $I_{c}$ from the robot camera and the subgoal images $\{I_{gi}\}_{i=1\ldots N_{g}}$ from start to the goal position.

Before navigation, we teleoperate the robot from the start to the goal position to construct the topological map with $\{I_{gi}\}_{i=1\ldots N_{g}}$. We sample $I_{gi}$ every 2 seconds as a new node, and connect an edge with the previously sampled node. After making map, we place the robot around the start position to begin navigation.

Following , there are three modules in our navigation system: 1) localization, 2) the control policy, and 3) the safety modules. The localization module decides the current node number $n_{c}$ corresponding to most adjacent node and feeds the subgoal image $I_{g(n_{c}+1)}$ into the control policy module. To decide $n_{c}$, we estimate the distance $\sqrt{(x^{n_{g}})^{2}+(y^{n_{g}})^{2}}$ and the angle $\theta^{n_{g}}$ between the subgoal position of $I_{gn_{g}}$ and the current position. Note that we assume that $N_{s}$-th way point $({x^{n_{g}},y^{n_{g}},\theta^{n_{g}}})$ integrated from velocity commands $\{v^{n_{g}}_{i},\omega^{n_{g}}_{i}\}_{i=1\ldots N_{s}}$ can reach the subgoal position. Here, $x^{n_{g}}$, $y^{n_{g}}$ are xy-position and $\theta^{n_{g}}$ is yaw angle of the robot coordinate. If the estimated subgoal position is close enough to satisfy $\sqrt{(x^{n_{g}})^{2}+(y^{n_{g}})^{2}}<d_{l}$ and $\theta^{n_{g}}<\theta_{l}$, we update the current node as $n_{c}=n_{g}$. We do this process for $N_{t}$ subgoal images to allow our system to skip a few subgoals. Trajectories with larger deviations from the original path to avoid collisions occasionally miss some subgoal positions.

In the control policy module, we calculate the velocity commands $\{v^{i},\omega^{i}\}_{i=1\ldots N_{s}}$ and the traversability probability $\{t^{i}\}_{j=1\ldots N_{s}}$. Similar to receding horizon control (i.e., model predictive control), we only use $v_{1}$ and $\omega_{1}$ after our collision check in the safety module. In safety module, we simply check whether the robot will collide or not by thresholding $p^{1}$. If our predicted trajectory is untraversable ($p^{1}<$ 0.5), we override the linear velocity as 0.0 and only allow the robot to turn at a point. Pivot turning allows the robot to find alternate paths to the subgoal position which are traversable. In our navigation system, we set $N_{t}$, $d_{l}$, and $\theta_{l}$ to 5, 0.4, 0.2, and 0.5, respectively.

VII-E Unseen obstacles in navigation

We have experiments in six indoor environments and six outdoor environments. In half of the indoor and outdoor environments, we place unseen obstacles in Fig. 8 before starting navigation. In each environment, we have three trials where we vary the initial robot position, kind of obstacles, and the position of these obstacles.

VII-F Visualization of data augmentation

Figure. 9 shows synthetic images of our view augmentations and raw images of the target camera to visualize our view augmentations. We mounted the spherical camera and the narrow FoV camera at different positions on same robot platform. We generated synthetic images corresponding to the narrow FoV camera from the spherical camera images. Although the generated images are a bit blurry and noisy when comparing them to the raw images, there are enough details to learn the positional relationships between the images.