Epipolar Geometry based Learning of Multi-view Depth and Ego-Motion from Monocular Sequences

TL;DR

This paper introduces a multi-view depth and ego-motion learning method that incorporates epipolar geometry constraints, improving accuracy over single-view approaches by better capturing pixel correspondences and scene structure.

Contribution

It proposes a 2-view depth network with epipolar constraints using the Essential matrix, enhancing geometric learning without relying on explicit labels.

Findings

Improved depth and pose estimation accuracy.

Better scene structure and motion capture.

Effective even with fewer trainable parameters.

Abstract

Deep approaches to predict monocular depth and ego-motion have grown in recent years due to their ability to produce dense depth from monocular images. The main idea behind them is to optimize the photometric consistency over image sequences by warping one view into another, similar to direct visual odometry methods. One major drawback is that these methods infer depth from a single view, which might not effectively capture the relation between pixels. Moreover, simply minimizing the photometric loss does not ensure proper pixel correspondences, which is a key factor for accurate depth and pose estimations. In contrast, we propose a 2-view depth network to infer the scene depth from consecutive frames, thereby learning inter-pixel relationships. To ensure better correspondences, thereby better geometric understanding, we propose incorporating epipolar constraints to make the learning more geometrically sound. We use the Essential matrix obtained using Nist'er's Five Point Algorithm, to enforce meaningful geometric constraints, rather than using it as training labels. This allows us to use lesser no. of trainable parameters compared to state-of-the-art methods. The proposed method results in better depth images and pose estimates, which capture the scene structure and motion in a better way. Such a geometrically constrained learning performs successfully even in cases where simply minimizing the photometric error would fail.

Tables

Table 1. Table 1. Single View Depth results using the split of (Eigen et al . , 2014 ) . (Garg et al . , 2016 ) cap their depth at 50m which we show in the bottom part of the table. Further details about the error and accuracy metrics can be found in (Eigen et al . , 2014 ) . The dashed line separates methods that use some form of supervision from purely monocular methods. Metrics are explained in the appendix in Sec. 5.2 . Baseline numbers taken from (Zhou et al . , 2017 ; Yang et al . , 2018 ; Kuznietsov et al . , 2017 ) .

Method	Supervision	Error Metric (lower is better)				Accuracy Metric (higher is better)
		Abs. Rel.	Sq. Rel.	RMSE	RMSE log
Train set mean	–	0.403	5.53	8.709	0.403	0.593	0.776	0.878
Eigen et. al (Eigen et al., 2014) Coarse	Depth	0.214	1.605	6.563	0.292	0.673	0.884	0.957
Eigen et. al (Eigen et al., 2014) Fine	Depth	0.203	1.548	6.307	0.282	0.702	0.89	0.958
Liu et. al (Liu et al., 2016)	Depth	0.202	1.614	6.523	0.275	0.678	0.895	0.965
Godard et. al(Godard et al., 2017)	Stereo	0.148	1.344	5.927	0.247	0.803	0.922	0.964
\hdashlineKuznietsov et. al(Kuznietsov et al., 2017) (Only Monocular)	Mono	0.308	9.367	8.700	0.367	0.752	0.904	0.952
Yang et. al(Yang et al., 2018)	Mono	0.182	1.481	6.501	0.267	0.725	0.906	0.963
SfMLearner (Zhou et al., 2017) (w/o explainability)	Mono	0.221	2.226	7.527	0.294	0.676	0.885	0.954
SfMLearner (Zhou et al., 2017)	Mono	0.208	1.768	6.856	0.283	0.678	0.885	0.957
SfMLearner (Zhou et al., 2017) (updated from github)	Mono	0.183	1.595	6.709	0.270	0.734	0.902	0.959
Ours	Mono	0.175	1.675	6.378	0.255	0.760	0.916	0.966
Garg et. al (Garg et al., 2016)	Stereo	0.169	1.08	5.104	0.273	0.74	0.904	0.962
\hdashlineSfMLearner (Zhou et al., 2017) (w/o explainability)	Mono	0.208	1.551	5.452	0.273	0.695	0.900	0.964
SfMLearner (Zhou et al., 2017)	Mono	0.201	1.391	5.181	0.264	0.696	0.900	0.966
Ours	Mono	0.166	1.213	4.812	0.239	0.777	0.928	0.972

Table 2. Table 2. Average Trajectory Error (ATE) compared with SfMLearner and Average Translational Direction Error (ATDE) compared with the Five Point Algorithm averaged over 3 frame snippets on the KITTI Visual Odometry Dataset (Geiger et al . , 2012 ) . The ATE is shown in meters and the ATDE, in radians. All values are reported as mean ± plus-or-minus \pm std. dev.

Seq	Average Trajectory Error		Average Translational Direction Error
	SfMLearner(Zhou et al., 2017)	Ours	Five Point Algorithm(Nistér, 2004)	Ours
			using SiftGPU(Wu, 2007)
00	0.5099$\pm$0.2471	0.4967$\pm$0.1787	0.0084$\pm$0.0821	0.0040$\pm$0.0155
01	1.2290$\pm$0.2518	1.1458$\pm$0.2175	0.0061$\pm$0.0807	0.0033$\pm$0.0077
02	0.6330$\pm$0.2328	0.6512$\pm$0.1806	0.0035$\pm$0.0509	0.0021$\pm$0.0026
03	0.3767$\pm$0.1527	0.3583$\pm$0.1254	0.0142$\pm$0.1611	0.0027$\pm$0.0042
04	0.4869$\pm$0.0537	0.6404$\pm$0.0607	0.0182$\pm$0.2131	0.0002$\pm$0.0007
05	0.5013$\pm$0.2564	0.4930$\pm$0.1974	0.0130$\pm$0.0945	0.0044$\pm$0.0044
06	0.5027$\pm$0.2605	0.5384$\pm$0.1627	0.0130$\pm$0.1591	0.0080$\pm$0.0688
07	0.4337$\pm$0.3254	0.4032$\pm$0.2380	0.0508$\pm$0.2453	0.0114$\pm$0.0430
08	0.4824$\pm$0.2396	0.4708$\pm$0.1827	0.0091$\pm$0.0646	0.0037$\pm$0.0058
09	0.6652$\pm$0.2863	0.6280$\pm$0.2028	0.0204$\pm$0.1722	0.0073$\pm$0.0211
10	0.4672$\pm$0.2398	0.4185$\pm$0.1791	0.0200$\pm$0.1241	0.0040$\pm$0.0105

Table 3. Table 3. Ablative study on the effect of different losses in depth estimation. We show our results using the split of (Eigen et al . , 2014 ) while removing the proposed losses. We compare our method with SfMLearner (w/o explainability) which is essentially similar to stripping our method of the proposed losses and using a different smoothness loss.

Method	Error Metric (lower is better)				Accuracy Metric (higher is better)
	Abs. Rel.	Sq. Rel.	RMSE	RMSE log
SfMLearner (w/o explainability)	0.221	2.226	7.527	0.294	0.676	0.885	0.954
Ours (no-epi)	0.199	1.548	6.314	0.274	0.697	0.901	0.964
Ours (single-view)	0.181	1.520	6.080	0.260	0.747	0.914	0.965
Ours ($1^{st}$ order)	0.190	1.440	6.144	0.269	0.714	0.906	0.965
Ours (final)	0.175	1.675	6.378	0.255	0.761	0.916	0.966

Equations

$${\hat{\tilde{p}}}^{T}E\tilde{p}=0$$

$$\hat{p}=K(R_{t\to s}D(p)K^{-1}p+t_{t\to s})$$

$$L_{warp}=\frac{1}{N}\sum _{s=0}^S\sum _{p=0}^N|I_t(p)-{\hat{I}}_s(p)|$$

$$L_{depth}=\frac{1}{N}\sum _{i=0}^S\sum _{j=i+1}^S\sum _p|D_i(p)-D_j(p)|$$

$$L_{smooth}=\frac{1}{N}\sum _{p=0}^N\sum _{i\in \{x,y\}}\sum _{j\in \{x,y\}}|{\partial }_{ij}d(p)|e^{-|{\partial }_{ij}I(p)|}$$

$$L_{warp}=\frac{1}{N}\sum _{s=0}^S\sum _{p=0}^N|I_t(p)-{\hat{I}}_s(p)|e^{|{\hat{\tilde{p}}}^{T}E\tilde{p}|}$$

$$L_{ssim}=\sum _s\frac{1-SSIM(I_t,{\hat{I}}_s)}{2}$$

$$\mathcal{L}=\sum _l(L_{warp}^l+{\lambda }_{smooth}{L}_{smooth}^l+{\lambda }_{ssim}{L}_{ssim}^l+{\lambda }_{depth}{L}_{depth}^l)$$

Full text

In contrast, we propose a 2-view depth network to infer the scene depth from consecutive frames, thereby learning inter-pixel relationships. To ensure better correspondences, thereby better geometric understanding, we propose incorporating epipolar constraints to make the learning more geometrically sound. We use the Essential matrix obtained using Nistér’s Five Point Algorithm, to enforce meaningful geometric constraints, rather than using it as training labels. This allows us to use lesser no. of trainable parameters compared to state-of-the-art methods. The proposed method results in better depth images and pose estimates, which capture the scene structure and motion in a better way. Such a geometrically constrained learning performs successfully even in cases where simply minimizing the photometric error would fail.

Monocular Depth, Visual Odometry, Epipolar Geometry, Computer Vision, Unsupervised Learning

††ccs: Computing methodologies Epipolar geometry††ccs: Computing methodologies Computer vision††ccs: Computing methodologies Vision for robotics††ccs: Computing methodologies 3D imaging††ccs: Computing methodologies Reconstruction††ccs: Computing methodologies Unsupervised learning††ccs: Computing methodologies Neural networks††copyright: acmcopyright††doi: 10.1145/3293353.3293427††isbn: 978-1-4503-6615-1/18/12††conference: 11th Indian Conference on Computer Vision, Graphics and Image Processing; December 18–22 2018; Hyderabad, India††journalyear: 2018††price: 15.00††booktitle: 11th Indian Conference on Computer Vision, Graphics and Image Processing (ICVGIP 2018), December 18–22, 2018, Hyderabad, India

1. Introduction

In recent years, there has been an increasing trend in using deep networks for predicting dense depth and ego-motion from monocular sequences. Such methods, including the one proposed in this paper, make inferences of the scene by observing a lot of samples and inferring their understanding based on consistencies in the scene, similar to the way humans do. Building on top of the same idea of ensuring photometric consistency, some methods add additional supervised constraints in the form of ground-truth depth (Eigen et al., 2014; Hoiem et al., 2005; Duggal et al., 2016; Saxena et al., 2007), calibrated stereo rigs (Garg et al., 2016; Godard et al., 2017) or ground-truth poses(Saxena et al., 2017) or both pose and depth(Ummenhofer et al., 2017). SE3-Nets(Byravan and Fox, 2017) take it a step further and operate directly on pointcloud data to estimate rigid body motions.

SfMLearner(Zhou et al., 2017) was one of the major developments in this field which popularized the ability of deep networks for the task at hand. They were the first method to do it in a purely monocular manner. In order to deal with non-rigid objects (cars, pedestrians etc.), they predict an ”explainability mask” in order to discount regions that violate the static scene assumption. GeoNet(Yin and Shi, 2018) and SfM-Net(Vijayanarasimhan et al., 2017) tackle this issue by explicitly predicting object motions and incorporating optical.

However, one fallacy in these methods is that rather than taking a geometric approach to the problem, they play around with losses to get better performance. We build upon the SfMLearner pipeline and enrich it with the fundamentals of computer vision and multi-view geometry. We tackle the problem in a more geometrically meaningful way by constraining the correspondences to lie on their corresponding epipolar lines. This is done by weighting the losses using epipolar constraints with the Essential Matrix obtained from Nistér’s Five Point Algorithm (Nistér, 2004). This helps us account for violations of the static scene assumption, and also to tackle the problem of improper correspondence generation that arises by minimizing just the photometric loss. We make use of the Five Point Algorithm to help guide the training and improve the predictions. Moreover, rather than inferring depth from a single view, we try to learn inter-pixel relationships by predicting depth from two views in a sequence. Note that we do not use stereo pairs that have a wide baseline, but a sequence of monocular views.

Our main contributions are twofold. The first is incorporating a 2-view depth prediction, rather than from a single view. One thing to note is that, by 2-view we mean two consecutive frames and not a pair of stereo images. Incorporating this helps improve the depth prediction, which is shown in Sec. 5.3. Secondly, we incorporate epipolar constraints to make the learning more geometrically oriented. We do so by using the per-pixel epipolar distance as a weighting factor to help deal with occlusions and non-rigid objects. This not only enforces pixel level correspondences but also allows us to do away with the explainability mask thereby having lesser number of parameters to predict.

2. Background

2.1. Structure-from-Motion (SfM)

Structure-from-Motion refers to the task of reconstructing an environment and recovering the camera motion from a sequence of images. Various methods exist that aim to tackle the problem as it is an age-old problem in vision(Wu, 2013; Furukawa et al., 2010; Sturm and Triggs, 1996; Bhowmick et al., 2014) however, they usually require computation of accurate point correspondences for performing the task. A subset of this comes under the area of monocular SLAM, which involves solving the SfM problem in real-time. Visual odometry, is a smaller subset which doesn’t involve structural estimation, but just camera motion estimation. These approaches could either be sparse(Mur-Artal et al., 2015; Klein and Murray, 2007; Forster et al., 2014; Maity et al., 2017; Jose Tarrio and Pedre, 2015), semi-dense(Engel et al., 2014, 2018) or dense(Newcombe et al., 2011; Alismail et al., 2016). The main issue that arises in these methods is that of improper correspondences in texture-less areas, or if there are occlusions or repeating patterns. In monocular approaches, performing it in a sparse manner is a well known topic but estimating dense monocular depth is much more complex.

2.2. Depth Image Based Warping

In order to ensure that a reconstruction is accurate, one way is to ensure that the reprojected image of the predicted scene at a novel view point is consistent with what is observed at that point. This consistency is known as photometric consistency. One common approach for image warping in the context of deep networks using differentiable warping and bi-linear sampling (Jaderberg et al., 2015) which have been in use for a variety of applications like learning optical flow (Jason et al., 2016), video prediction (Patraucean et al., 2015) and image captioning (Johnson et al., 2016). We apply bi-linear sampling to calculate the warped image using scene depth and the relative transformation between two views.

In this approach, given a warped pixel $\hat{p}$, its pixel value $I_{s}(\hat{p})$ is interpolated using 4 nearby pixel values of $\hat{p}$ (upper left and right, lower left and right) i.e. $\hat{I}_{s}(p)=I_{s}(\hat{p})=\sum_{i}\sum_{j}w_{ij}I_{s}(p_{ij})$ where $i\in\{\lfloor\hat{p}_{x}\rfloor,\lceil\hat{p}_{x}\rceil\}$, $j\in\{\lfloor\hat{p}_{y}\rfloor,\lceil\hat{p}_{y}\rceil\}$ and $w_{ij}$ is directly proportional to the proximity between $\hat{p}$ and $p_{ij}$ such that $\sum w_{ij}=1$. Further explanation regarding this can be found in (Jaderberg et al., 2015).

2.3. Epipolar Geometry

We know that a pixel $p$ in an image corresponds to a ray in 3D, which is given by its normalized coordinates $\tilde{p}=K^{-1}p$, where $K$ is the intrinsic calibration matrix of the camera. From a second view, the image of the first camera center is called the epipole and that of a ray is called the epipolar line. Given the corresponding pixel in the second view, it should lie on the corresponding epipolar line. This constraint on the pixels can be expressed using the Essential Matrix $E$ for calibrated cameras. The Essential Matrix contains information about the relative poses between the views. Detailed information regarding normalized coordinates, epipolar geometry, Essential Matrix etc, can be found in (Hartley and Zisserman, 2003). Given a pixel’s normalized coordinates $\tilde{p}$ and that of its corresponding pixel in a second view $\hat{\tilde{p}}$, the relation between $\tilde{p}$, $\hat{\tilde{p}}$ and $E$ can be expressed as:

[TABLE]

Here, $E\tilde{p}$ is the epipolar line in the second view corresponding to a pixel $p$ in the first view. In most cases, there could be errors in capturing the pixel $p$, finding the corresponding pixel $\hat{p}$ or in estimating the Essential Matrix $E$. Therefore in most real world applications, rather than imposing Eq. 1, the value of $\hat{\tilde{p}}^{T}E\tilde{p}$ is minimized in a RANSAC(Fischler and Bolles, 1981) like setting. We refer to this value as the epipolar loss in the rest of the paper.

We refer to a pixel’s homogeneous coordinates as $p$ and the normalized coordinates as $\tilde{p}$ in the rest of the paper. We also refer to a corresponding pixel in a different view as $\hat{p}$ and in normalized coordinates as $\hat{\tilde{p}}$.

2.4. Nistér’s 5 Point Algorithm

Nistér’s 5 Point Algorithm (Nistér, 2004) is currently the state-of-the-art solutions to the ”Five Point Relative Pose” problem for estimating the Essential Matrix between two views. The problem can be stated as follows. Given the projections of five unknown points onto two unknown views, what are the possible configurations of points and cameras? The solution to this gives rise to the relative poses between the cameras and the points. Absolute scale, however, cannot be recovered from just images. Nistér proposes a solution by solving a tenth degree polynomial in order to extract the Essential Matrix $E$ which can then be decomposed into the rotation $R$ and translation $t$ between the two views.

3. Proposed Approach

We use 2 CNNs, one for inverse depth (which we refer to as depth network) and one for pose (pose network). Our Depth network takes a pair of consecutive images as input, rather than a single image, and calculates the depth of the scene as seen in the first image. The reason behind this is to leverage the relationship between pixels over multiple views to calculate the depth, rather than relying on learnt semantics of the scene in a single view. The Pose network takes an image sequence as input. The first image is the target view with respect to which the poses of the other images are calculated. Both networks are independent of each other and are trained jointly to effectively capture the coupling between scene depth and camera motion in learning based paradigm.

The main idea behind the training, similar to that of previous works, is to ensure proper scene reconstruction between the source and target views based on the predicted depth and poses. We warp the source view into the target frame and minimize the photometric error between the synthesized image and the target image to ensure that the predicted depth and pose can recreate the scene effectively. Details about this warping process is given in Sec. 3.1 and 3.2. Additionally, since we predict the depth using each source image as the second input image, we need to ensure consistency between the predicted depth images. This is explained in Sec. 3.3.

For now, we consider mostly static scenes, i.e. where objects in the scene are rigid. SfMLearner predicts an ”explainability mask” along with the pose, which denotes the contribution of a pixel to the loss such that pixels of non-rigid objects have a low weight. Instead, we use the epipolar loss to weight the pixels. This process is explained in Sec. 3.5.

3.1. Image Warping

Given a pixel $p$ in normalized coordinates, and its depth $D(p)$, we transform it into the source frame using the relative pose and project it onto the source image’s plane.

[TABLE]

where $K$ is the camera calibration matrix, $D(p)$ is the depth of pixel $p$, $R_{t\rightarrow s}$ and $t_{t\rightarrow s}$ are the rotation and translation respectively from the target frame to the source frame. The homogeneous coordinates of $\hat{p}$ are continuous while we require integer values. Thus, we interpolate the values from nearby pixels, using bi-linear sampling, proposed by (Jaderberg et al., 2015), as explained in sec 2.2.

3.2. Novel View Synthesis

We use novel view synthesis using depth image based warping as the main supervisory signal. Given the per-pixel depth and the relative pose between images, we synthesize the image of the scene from a novel viewpoint. We minimize the photometric error between the warped image and the image at the given viewpoint.

Given a target view $I_{t}$ and $S$ source views $I_{s}$, we minimize the photometric error between the target view and the source view warped into the target’s frame, denoted by $\hat{I}_{s}$. Mathematically, this can be described by Eq. 3

[TABLE]

where $N$ is the total number of pixels.

3.3. Depth Consistency

Our depth network takes 2 views as input and outputs the depth w.r.t. the first image. In an iteration, we predict depths with each of the $S$ source views as the second input and use the respective outputs to warp a given source frame into the target frame. Since all the predicted depths are for the target image itself, they would need to be consistent with one another. Therefore we minimize the depth error between the predicted depth images obtained using all source images.

[TABLE]

where $N$ is the total number of pixels.

3.4. Spatial Smoothing

In order to tackle the issues of learning wrong depth values for texture-less regions, we try to ensure that the depth prediction is derived from spatially similar areas. One more thing to note is that depth discontinuities usually occur at object boundaries. We minimize $L1$ norm of the $2^{nd}$ order spatial gradients of the inverse depth of a pixel $\partial^{2}d(p)$, weighted by the image laplacian at that pixel $\partial^{2}I(p)$. This is to account for sudden changes in depth due to crossing of object boundaries and ensure a smooth change in the depth values. This is similar to what is done in (Godard et al., 2017; Wang et al., 2018).

[TABLE]

where $N$ is the total number of pixels.

3.5. Epipolar Constraints

The problem with simply minimizing such photometric errors is that it doesn’t take ambiguous pixels into consideration, such as those belonging to non-rigid objects, those which are occluded etc. Thus, we need to weight pixels appropriately based on whether they’re properly projected or not. One way of ensuring correct projection is by checking if the corresponding pixel $\hat{p}$ satisfies epipolar constraints or not, according to Eq. 1.

We impose epipolar constraints using the Essential Matrix obtained from Nistér’s Five Point Algorithm (Nistér, 2004) using matches between features extracted using SiftGPU (Wu, 2007). This helps ensure that the warped pixels to lie on their corresponding epipolar line. This epipolar loss $\hat{\tilde{p}}^{T}E\tilde{p}$ is used to weight the above losses, where $E$ is the Essential Matrix obtained using the Five Point Algorithm. After weighting, the new photometric loss now becomes

[TABLE]

The reason behind this is that for a non-rigid object, even if the pixel is properly projected, the photometric error would be high. In order to ensure that such pixels are given a low weight, we weight them with their epipolar distance, which would be low if a pixel is properly projected. If the epipolar loss is high, it means that the projection is wrong, giving a high weight to the photometric loss, thereby increasing its overall penalty. This also helps in mitigating the problem of a pixel getting projected to a region of similar intensity by constraining it to lie along the epipolar line.

3.6. Structural Similarity

Another well known and robust metric for measuring perceptual differences between two images is the Structural Similarity Index (SSIM) (Wang et al., 2004). It is widely applied in tasks that require comparing 2 images of the same scene, like comparing transmission quality. The photometric loss assumes brightness constancy which need not hold in all cases. Instead, SSIM considers three main factors, namely lunimance, constrast and structure, which provide a more robust measure for image similarity. Since SSIM needs to be maximized (with 1 as the maximum value), we minimize the below loss

[TABLE]

3.7. Final Loss

Our final loss function is a weighted combination of the above loss functions summed over multiple image scales.

[TABLE]

where $l$ iterates over the different scale values and $\lambda_{smooth}$ $\lambda_{ssim}$ and $\lambda_{depth}$ are the the relative weights for the smoothness loss, SSIM loss and the depth consistency loss respectively.

Note that we don’t minimize the epipolar loss but use it for weighting the other losses. This way the network tries to implicitly minimize it as it would lead to a reduction in the overall loss.

4. Implementation Details

4.1. Neural Network Design

We use networks similar to that of SfMLearner, except we remove their ”explainability mask” from the pose network. The network architectures that we use are shown in the appendix in Fig. A1.

4.2. Depth Network

The design of the Depth CNN is similar to the one in (Zhou et al., 2017), which is inspired from DispNet(Mayer et al., 2016). It consists of an encoder-decoder network with skip connections from previous layers. The input is a pair of RGB images concatenated along the colour channel ($H\times W\times 6$) and the output is the inverse depth of the first image. The idea behind this is that rather than just learning semantic artifacts in the scene from a single view, the network can learn inter-pixel relationships and correspondences, similar to how optical flow networks are modelled. Even in Visual SLAM/Odometry methods, multiple images are used to predict depth, instead of a single image.

Along with this, we also normalize the predicted inverse depth to have unit mean, to remove any scale ambiguity in the predicted depths. This is inspired from what is applied to the inverse depth of keyframes in LSD-SLAM(Engel et al., 2014). As mentioned in (Godard et al., 2018), and as we observed in our experiments as well, performing a simple multi-scale estimation causes ”holes” to develop in textureless regions. They argue that minimizing photometric error would allow the network to predict incorrect depth at a lower scale, which would still end up with a low photometric error at that scale due to the textureless property of the region but lead to a larger photometric error at a higher resolution. Thus they propose to overcome this by upsampling the depth images to the input’s resolution and then calculating the errors.

4.3. Pose Network

For the pose network, the target view and the source views are concatenated along the colour channel giving rise to an input layer of size $H\times W\times 3N$ where $N$ is the number of input views. The network predicts 6 DoF poses for each of the $N-1$ source views relative to the target image. We modify the pose network proposed by (Zhou et al., 2017) by removing their ”explainability mask” thereby having to learn lesser parameters yet giving better performance.

4.4. Training

We use Tensorflow (Abadi et al., 2016) for implementing the system. We use batch normalization(Ioffe and Szegedy, 2015) for the non-output layers and make use of the Adam Optimizer (Kingma and Ba, 2015) with $\beta 1=0.9$, $\beta 2=0.999$ and a learning rate of 0.0002 and a mini-batch of size 4 for training our networks. We set the weights as $\lambda_{smooth}=0.2$, $\lambda_{ssim}=0.7$ and $\lambda_{depth}=0.5$. The learning typically converges after 26 epochs. We use raw images from the KITTI dataset(Geiger et al., 2013), with the split given by (Eigen et al., 2014), having about 40K images totally. We exclude static scenes and test image sequences from our training set leaving us with 33K images. We use 3 views as the input to the pose network with the middle image as our target image and the previous and next images as the source images. We use 2 views as input to the depth network with the middle image as the target view and predict it’s depth with both the source images as the second input, one by one.

5. Results

5.1. Depth Estimation Results

We evaluate our performance on the 697 images provided by (Eigen et al., 2014). We show our results in Table 1. Our method’s performance exceeds that of SfMLearner(Zhou et al., 2017), Yang et. al(Yang et al., 2018), Kuznietsov et. al(Kuznietsov et al., 2017) (only monocular) which are purely monocular. We also perform better than methods which use depth supervision (Eigen et al., 2014; Liu et al., 2016) and (Garg et al., 2016) who use calibrated stereo supervision. We fall short of (Godard et al., 2017), who use calibrated stereo supervision along with left-right consistency, which makes their approach more robust.

The images after the red line in Fig. 2 are cases where our method performs better in places where SfMLearner fails, such as texture-less scenes and open regions. This shows the effectiveness of having 2-view depth prediction and using epipolar geometry to handle occlusions and non-rigidity. We provide sharper outputs as compared to SfMLearner, which can be seen in the which is the result of using an edge-aware smoothness that helps capture the shape of objects in a better manner. We scale our depth predictions such that it matches the median of the ground truth. Further explanation about the metrics can be found is (Eigen et al., 2014), which are given below in Sec. 5.2

5.2. Depth Evaluation Metrics

Given the predicted depth $\hat{y}_{i}$ and the corresponding ground truth depth $y_{i}^{*}$ for the $i^{th}$ image, we use the following error metrics and accuracy metrics.

5.2.1. Error Metrics

• •

Absolute Relative Difference (Abs. Rel.): $\frac{1}{N}\sum_{i=1}^{N}|\hat{y}_{i}-y_{i}^{*}|/y_{i}^{*}$

• •

Squared Relative Difference (Sq. Rel.): $\frac{1}{N}\sum_{i=1}^{N}||\hat{y}_{i}-y_{i}^{*}||^{2}/y_{i}^{*}$

• •

Root Mean Squared Error (RMSE): $\sqrt{\frac{1}{N}\sum_{i=1}^{N}||\hat{y}_{i}-y_{i}^{*}||^{2}}$

• •

Logarithmic RMSE (RMSE log): $\sqrt{\frac{1}{N}\sum_{i=1}^{N}||\log\hat{y}_{i}-\log y_{i}^{*}||^{2}}$

5.2.2. Accuracy Metrics

We calculate the accuracy metric as the percentage of images for which the value of $\delta$, defined as $\delta=\max(\frac{\hat{y}_{i}}{y_{i}^{*}},\frac{y_{i}^{*}}{\hat{y}_{i}})$, is lesser than a threshold $th$. In our case, we choose three values for the threshold $th$ which are $1.25$, $1.25^{2}$ and $1.25^{3}$.

5.3. Pose Estimation Results

For our pose estimation experiments, we use the KITTI Visual Odometry Benchmark dataset (Geiger et al., 2012). Only 11 sequences (00-10) have the associated ground truth data, on which we show our results. We use a sequence of 3 views as the input to the pose network with the middle view as the target view. Each image is of size $1271\times 376$ which we scale down to a size of $416\times 128$ for both pose estimation and depth estimation experiments.

We show the Average Trajectory Error (ATE) and Average Translational Direction Error (ATDE) averaged over 3 frame intervals. Before comparison, the scale is first corrected to best align it with the ground truth after which the ATE is computed. Since the ATDE is only comparing the angle between the directions of translations, we do not correct the scale of the poses.

Table 2 shows the results of our pose estimation. We perform better than SfMLearner111using the model provided at github.com/tinghuiz/SfMLearner on an average in terms of the ATE showing that adding meaningful geometric constraints helps get better estimates as compared to minimzing just the reprojection error. We perform better on all runs compared to the relative poses obtained from the Five Point Algorithm in terms of the ATDE.

This rises from the fact that, we have additional constraints of depth and image warping that help give a better estimation of the direction of motion, whereas the Five point Algorithm uses only sparse point correspondences between the images. Moreover, the Five point Algorithm itself is slightly erroneous due to inaccuracies arising in the feature matching or in the RANSAC based estimation of the essential matrix. Despite being given slightly erroneous estimates of the essential matrix, incorporating image reconstruction as the main goal helps in overcoming erroneous predictions.

6. Ablation Study

In order to see what is the contribution of our proposed loss to the learning process, we perform an ablation study on the depth estimation by considering variants of our proposed approach and training the networks using the Eigen(Eigen et al., 2014) split. We show the results of studying the effects of epipolar constraints, 2-view depth prediction and the second order edge-based smoothness.

In order to see the effectiveness of our method, we first replace the second order edge-aware smoothness with a first order edge-based smoothness. We call this as ”Ours ($1^{st}$ order)”. Then we remove the epipolar loss which is similar to having an SfMLearner pipeline with 2 views as input to the depth network. We denote this as ”Ours (no-epi)”. Then in order to see the contribution of our proposed idea of using 2 views as input to the depth network, we train a variant with a single view depth having epipolar constraints and a first order edge-based smoothness. This is denoted as ”Ours (single-view)”.

Any further removal would just result in having SfMLearner without the explainability mask, which we consider as our baseline. This is essentially equivalent to removing our proposed improvements and replacing the edge-aware depth with a simpler second order smoothness loss. Finally, we further investigate the possibility of using 3 views as the input to the depth network as well.

The results of the study are shown in Table 3. All our variants perform significantly better than the standard SfMLearner without the explainability mask showing that our method has a positive effect on the learning. Just adding 2-view depth prediction without epipolar constraints (Ours no-epi) gives a significant improvement showing that using multiple views provide better depth estimates, compared to a single view. Incorporating just the epipolar loss (Ours single-view) improves the output drastically, showing that geometrically meaningful constraints provide better depth outputs.

.

When we combine the two, it doesn’t lead to a drastic improvement over the individual methods, however providing a second order smoothness improves the results as compared to a first order smoothness. A first order smoothness implies having a constant depth change, which isn’t necessarily true. For parts of the image that are closer to the camera, the depth varies slowly, whereas for those which are further away, the depth variations are larger. Therefore, having a second order smoothness captures this change in depth variation rather than just the change in depth.

6.1. Three-view Depth Prediction

One more variant which we tried out was using 3 views for the depth prediction as well. Though it was giving visually understandable results, our 2-view variant was giving better depth estimates. One observation is that during turning, the depth outputs would deteriorate at a much larger scale. A possible explanation for this could be that compared to the motion between 2 views, while using 3 views, there is a larger amount of motion, and thereby lesser amount of overlap between images. Though the motion is not too large, it is large enough to escape the field of view of the convolutional filter in an input, since the views are stacked together and given to the network. Some sample outputs of using a 3 view depth prediction are shown in Fig. 3.

In order to test our hypothesis regarding the filter sizes, we tried increasing the filter sizes and performing the depth prediction. More specifically, we increase each of the filter sizes by a value of 4. By doing so, we effectively increase the perceptive field of view of a filter thus allowing it to accumulate information from a larger area of pixels. This way, it would be able to properly ”see” a pixel across multiple views, which would otherwise fall outside the field of view of a filter. We observed that this leads to smoother depth images as compared to using smaller filter sizes. However, it still didn’t perform as well as the 2-view variant, and it ended up developing a few unwanted holes as well. These results are shown in Fig. 4.

7. Conclusion and Future Work

We build upon a previous unsupervised method for learning deep monocular visual odometry and depth by leveraging the fact that depth estimation could be made more robust by using multiple views rather than a single view. Along with this, we incorporate epipolar constraints to help make the learning more geometrically meaningful while using lesser number of trainable parameters. Our method is able to predict depth with higher accuracy along with giving sharper depth estimates and better pose estimates. Although increasing the number of inputs for depth prediction gave a good output in 2 views, it’s 3-view counterpart wasn’t able to perform as well. This would be an interesting problem to look into for improving it, either by architectural changes in the depth network or by incorporating a post-processing optimization on top of the networks.

The current method however only performs pixel level inferences. A higher scene level understanding can be obtained by integrating semantics of the scene to get better correlation between objects in the scene and the depth and ego-motion estimates. This is similar to using semantic motion segmentation (Haque et al., 2017a, b). Architectural changes could also be leveraged to get a stronger coupling between depth and pose by having a single network predicting both pose and depth in order to allow the network to be able to learn representations that capture the complex relation between both camera motion and scene depth.

Chapter \thechapter

Appendix for ”Epipolar Geometry based Learning of Multi-view Depth

                       

and Ego-Motion from Monocular Sequences”