Fast Robust Monocular Depth Estimation for Obstacle Detection with Fully Convolutional Networks

Fast Robust Monocular Depth Estimation for Obstacle Detection with Fully Convolutional Networks


Obstacle Detection is a central problem for any robotic system, and critical for autonomous systems that travel at high speeds in unpredictable environment. This is often achieved through scene depth estimation, by various means. When fast motion is considered, the detection range must be longer enough to allow for safe avoidance and path planning. Current solutions often make assumption on the motion of the vehicle that limit their applicability, or work at very limited ranges due to intrinsic constraints. We propose a novel appearance-based Object Detection system that is able to detect obstacles at very long range and at a very high speed (), without making assumptions on the type of motion. We achieve these results using a Deep Neural Network approach trained on real and synthetic images and trading some depth accuracy for fast, robust and consistent operation. We show how photo-realistic synthetic images are able to solve the problem of training set dimension and variety typical of machine learning approaches, and how our system is robust to massive blurring of test images.


Obstacle Detection (OD) is a challenging and relevant capability for any autonomous robotic system required to operate in real world scenarios, for safe path planning tasks and reaction to unexpected situations. Obstacle pose estimation must be fast enough to allow robot control system to react and perform required corrections. Since higher robot speeds require longer range detection to timely react, OD in automotive and autonomous aerial vehicle applications is particularly challenging. Obstacle definition changes according to the specific application. In automotive and ground-based robotic applications an obstacle is usually any vertical object raising from the ground, such as cars, pedestrian, traffic lights poles, garbage bins, trees etc. When Micro aerial Vehicles (MAVs) are considered, some other assumptions are required. For example horizontal structures, such as tree branches and overpasses, signs become relevant obstacles, since robot motion is no more constrained to a well defined street environment. In these cases the OD system has to be able to detect any physical object present in the scene.

We propose a fully convolutional network fed with both images and optical flows to obtain fast and robust depth estimation, with a robotic applications-oriented design.
We propose a fully convolutional network fed with both images and optical flows to obtain fast and robust depth estimation, with a robotic applications-oriented design.

The main techniques to address the OD problem are based on visual stereo systems. However, such systems are limited in detection range and accuracy by camera set-up and baselines [1], [2], which in turn pose a limit on maximum speed, and this is a tough constraint both in automotive and MAV applications. To overcome this limitations some systems exploited geometric knowledge about obstacles relationships with ground plane and assuming a limitation in the degrees of freedom of the vehicle’s movement, allowing long range obstacle detection up to 200 meters [3] or a real-time construction of a raw 3D obstacle mapping [4], [5], [6]. Unfortunately, these methods can’t work in application where their geometric assumptions are violated and the robot does not operate at ground level.

Monocular based vision detection systems have been proposed to bypass both stereo vision limitations and geometric assumptions. Since monocular vision does not allow accurate and robust distance geometric measurement, often machine learning based solutions have been proposed [7], [8]. Since learning methods are limited by the training set samples and these methods have been trained using datasets with ground truths collected through stereo vision or laser rigs, these solutions still have limitations on range and accuracy as stereo systems.

To develop an OD system that is capable of detecting obstacles at high speed, allowing fast motion without geometrical assumptions, we propose an hybrid monocular approach that trades some detection accuracy for speed and general applicability. We decided to use monocular images to be able to apply the method on small or micro aerial vehicles that are able to move up to speeds of 10-20 m/s, for which a stereo approach would not be viable. In addition, we address the problem using Deep Neural Networks (DNNs) to learn an algorithm that is accurate and fast enough to allow fast reaction to unexpected obstacles on the vehicle path. To solve the limitations of machine learning approaches, namely the lack of data and generality of the solution, we extend the dataset with artificial sequences created using a state-of-the-art graphic engine capable of producing photo-realistic outdoor environments. This allows us to add an arbitrary number of sequences with perfect ground truth at very long distances (200m), that would not have been possible to collect with a laser or stereo based ground truth system. Through our experiments we show that our algorithm is capable of doing fast estimation of depth with an accuracy that is sufficient for motion planning and that the learning on simulated photo-realistic environments is a viable way to extend datasets on robot vision problems.

This work is focused on depth estimation for obstacle perception and does not assess planning and control strategies to achieve effective obstacle avoidance. These aspects will be considered in future works.

2Related Work

Most of traditional vision-based obstacle avoidance works rely on stereo vision. The most trivial solutions are based on finding disparities between the two matched images, compute point clouds and apply heuristics to detect obstacles. This methodology suffers from range limitations, produces sparse maps and may be not robust to pixel matching errors [9]. Many of these methods are based on v-disparity computation. Labayrade et al[10], using a planarity assumption on stereo cameras, formulates a more robust analytical ground-plane estimation method based on v-disparity computation. Benenson et al[5] use v-disparity and u-disparity to generate at high rate a fast obstacle representation on 3D space, while Harakeh et al[11] build a probability field based on v-disparity to get a precise ground segmentation and occupancy grid of the scene. Pinggera et al[3] improve range and accuracy detection using stereo vision to compute local ground normal as a statistical hypothesis testing problem, getting detection range up to 200 meters. Pillai et al[6] propose a tunable and scalable stereo reconstruction algorithm which allows scene depth comprehension with very high frame rates, which may be usable for real time obstacle detection purposes. The main issue of these methods is that they make geometric assumptions, requiring planarity between stereo images. Also, methods such as [10], [5], [11] and [3] utilize ground model to position obstacles on 3D space, so obstacles posed over the ground won’t be detected by these methods.
Stereo vision has also been used as a data acquisition method for machine-learnind approaches. Hadsell et al[12] use a stereo rig to assign labels to close-range obstacles, detecting them using geometric techinques cited above. Features are extracted from image patches containing those obstacles through an offline-trained convolutional autoencoder. A classifier is trained using these features and obtained labels as reference. Distant obstacles are then detected by the online trained classifier. Ball et al[13] apply a similar approach optimized for agricultural applications, based on a novelty-based obstacle detector. To overcome stereo methods geometric constraints, monocular vision-based methods have been proposed. Mori et al[14] extract SURF features from monocular images and use template matching to detect frontal obstacles from their change in relative size between consecutive frames. This method makes no geometric assumption on the scene, but it has no capability to detect lateral obstacles and has limited range, which makes it unsuitable for high speed operations. Optical flow based obstacle detection has been explored in [15], but it tends to be noisy in images with far away backgrounds, where optical flow tends to assume values close to zero. Day et al[8] implement a imitation learning based reactive MAV controller based on monocular images, training a non-linear regressor to detect obstacles distances from features extracted from several patches of the image, as optical flow, histogram of oriented gradients, Radon transform, Laws’ Masks and structure tensors. Ground truth for obstacles is obtained through a stereo rig. Being a machine learning based algorithm, it cannot perform better that the hardware used for training, so detection capability are limited by stereo vision weaknesses.

In the set of monocular methods, we also consider depth map estimators. These methods solve a different problem, as they try to find an accurate 3D reconstruction of the scene, but we use them as benchmarks for our methods. Michels [7] implements a reinforcement learning based 3D model generator with real-time capability. It relies on horizontal alignment of the images and does not generalize in less controlled settings. Eigen et al[16] develop a deep learning based architecture for single image 3D reconstruction trained, on different experiments, on NYUDepth dataset [17] and KITTI dataset [18], obtaining state-of-the-art performance in terms of depth estimation accuracy. Although, for robotic application, we’re not interested into obtaining state-of-the-art precision as it would require higher computational costs and it would be even unnecessary for our purposes, we consider these methods as reference for estimation performance.

We share with some of these methods the learning approach based on Deep Neural Networks (DNNs), but we fetch them not only with monocular images, but also with the optical flow of consecutive frames. Our architecture is inspired by recent works in semantic segmentation and optical flow estimation ([19], [20], [21], [22]), where Fully Convolutional Networks (FCNs) have been trained to make pixel-wise estimations, obtaining outputs of the same size of the input image. Differently from standard Convolutional Neural Network approaches, FCNs do not make use of fully connected layers, which account for most of the parameters of the network (e.gon VGG-16 [23] architecture fully connected layers parameters are about 120M, out of the 134M parameters describing the whole network), and for this reason they improve training speed and reduce the amount of data required to train the deep network [21]. In addition, since convolution operations can be strongly optimized on GPU, these networks can generate estimates with very high frame rates.

3Network Structure

Network architecture. Blue boxes: Encoder feature maps. Green boxes: Decoder feature maps. Convolutional filters are reported in red, deconvolutional filters in yellow.
Network architecture. Blue boxes: Encoder feature maps. Green boxes: Decoder feature maps. Convolutional filters are reported in red, deconvolutional filters in yellow.

For the network structure we propose an encoder-decoder architecture, similar to [22], [21] and [20]. Since the problem we tackle is depth estimation for Obstacle Detection and not for 3D reconstruction, we design network structure and complexity to be a good compromise between accuracy and execution speed.

3.1Depth pixel-wise estimation as an encoder-decoder network

Our proposed architecture is reminiscent of fully convolutional architectures as [22], [21] and [20]. The encoder section is composed by a stack of convolutional layers, which apply learned filters on their input and extract relevant synthetic features. We do not apply naive pooling with an a-priori chosen strategy, such as max or average pooling. We choose instead to conveniently stride convolutions in order to obtain a downsampled version of its input. Convolution output’s dimensions and , are determined, given an input of size , defining as the convolution kernel size, as convolution pad and as applied stride, by the following equations:

From these equations we can infer how, choosing appropriate stride and padding, we are able to downsample information directly from convolutions, allowing the network to learn the optimal scaling strategy according to the task at hand. The decoder section is composed by a stack of deconvolutional layers, which learns to upsample from the features computed in the encoder section to obtain a final output of the same resolution of the input, containing pixel-wise predictions. Other works as [21] or [20] place unpooling layers between each deconvolutional layer to reverse pooling operations done in the encoder section; since downsampling is performed by convolution layers, we model our deconvolutional layers and learn the most effective upsampling strategy, as an inverse operation.
Detailed network implementation is shown on Image ?. Encoder section is composed by five convolutional layers. Strided convolutions are applied at the first, second, third and fifth layer of the encoder section to downsample feature maps. Padding is added accordingly to maintain desired feature maps size. ReLU non-linearity is applied after each convolution output. At the end of the encoder section, we obtain feature maps downscaled by a factor of 16 compared to network input.
Decoder section is composed by three deconvolutional layer. Each deconvolutional layer learn to upsample encoder feature maps by, respectively, a factor of 2 for the first two layers and a factor of 4 for the final layer, in order to obtain a final upsampling factor of 16. In [22] and [19] feature maps computed in intermediate convolutional layers in the encoder section are concatenated to each intermediate deconvolutional layer output to improve upsampling quality and edges definitions. We experimented this strategy in preliminary experiments; although we came upon a slight improvement on upsampling quality, we also experimented a performance degradation in terms of inference time, so we did not apply this strategy in successive experiments.

3.2Image and optical flow as network input

In order to choose appropriate network input, we compare in our experiments two possible strategies: feeding the network with a single image, currently captured by the camera, or concatenate current image with optical flow information between current frame and the previous one. Optical flow has been used previously as raw feature for obstacle detectors [8] [15]. It is known how relative motion information between each pixel in two consecutive frames contains some implicit information about object dimensions and locations in 3D space. As previous works stated, optical flow alone is not sufficient to obtain a complete and long-range depth estimation. Our intuition is to use it as additional information and let convolutional filters learn optimal strategy to extract useful information from it. Mixing together optical flow and raw image as network input, we expect them to overcome each other’s limitations and improve performances and generalization capability in real world scenarios. Optical flow during our experiments has been computed off-line using widely-used and robust Brox algorithm [24], but faster and effective algorithms as [22] may be used as well to improve whole software pipeline real-time performance.

3.3Virtual Dataset

Collection of a sufficient amount of training data is a typical problem for every deep learning work. Considering how we formulate our problem of finding obstacles, we explore existing datasets containing depth ground truth. NYUDepth v2 indoor dataset [17], Make3D [25] and KITTI outdoor datasets [18] are typical choices for depth estimation-related problems. Make3D and NYUDepth datasets contain still images of a scene with no sequentiality between them, since they are thought for 3D image reconstruction, and this makes our optical flow-based approach not applicable. KITTI sequences are grabbed by a camera mounted on a moving car, making it more appropriate for robotic applications. KITTI depth ground truth, collected through a LiDAR unit, is sparse and does not cover the whole image scene. Moreover, images are generally aligned with ground plane, which may be a limitation according to the desired operating scenarios.
Motivated by these reasons, we explored the possibility to collect data from virtual scenarios, utilizing development tools generally used in gaming industry, exploiting capabilities of the newest graphic engines. We utilize Unreal Engine 4 with Urban City pack developed by PolyPixel to build an urban scenario sized about km. No car, person, or dynamic object is present due to development package limitations; their inclusion will be considered as future work. We move a camera, collecting images and dense scene depth ground truth. Camera moves around the virtual world with six degrees of freedom, simulating non-trivial movements that rarely are present in real-world datasets, such as huge roll or pitch angles with respect to the ground plane. Depth is stored as a grayscale image: it is converted into metric depth by scaling each pixel value by a factor obtained through placing objects in a toy scenario at known metric distance from the camera. For preliminary experiments, depth is collected firstly with a maximum range of 40 meters; in a second phase, we collected depth measures up to 200 meters. Depth measures are spherical with respect of the camera.
More that 265k images have been collected and stored in PNG format, with a resolution of pixels. Light conditions are changed from time to time to achieve brightness robustness. Haze is added in some sequences as well, and motion blur is simulated through graphic engine’s tools, in order to better simulate real scenarios. Images are collected as sequences of consecutive frames captured as the camera moves around the world, at a rate of 10 Hz. We move the camera both on-road and off-road environments, for example between trees or light poles, to better simulate possible realistic application scenarios.


To validate our work, we perform experiments on our Virtual Dataset, as described on Section 3.3, as well as on KITTI dataset [18]. We also test our network’s estimation robustness adding artificial blurring and darkening on KITTI images, to evaluate network’s performance in presence of noise. For all of our experiments, we train the proposed networks on our Virtual Dataset, divided into a training set composed by about 200k images and a test set of 65k images. In order to evaluate the generalization capabilities of our approach, we do not perform any fine-tuning on the KITTI sequences. Training and testing are performed on a NVIDIA K40 GPU-mounted workstation.

We update weights during training by using Stochastic Gradient Descent (SGD) algorithm with a learning rate , gradually scaled down during training. Convergence is reached after about 50 epochs on training data. We train our final proposed architecture on Log RMSE (Equation 1), in order to penalize more errors on close obstacles than ones committed on long range estimations:

Exploratory experiments are also performed with a linear RMSE loss, as specified later in Section 4.1.
Network inference time, without taking into account optical flow computation, is about 34 ms () on K40 for each frame, which allows optimal scalability into complete embedded robotic software pipelines. Brox’s optical flow algorithm used for our experiments runs at about , but much faster algorithms, as [22], could be used as well.

The benchmark metrics for our comparisons are:

  • Threshold error: % of s.t.

  • Linear RMSE:

  • Scale-invariant Log MSE (as introduced by [16]): , with

4.1Virtual Dataset

Table 1: Experiments results on virtual dataset for ground truth collected up to 40m.
Single Image Opt. Flow+Img.
thr. 0.726 0.774 Higher
thr. 0.924 0.938 is better
RMSE 3.819 3.478 Lower
Log RMSE 0.246 0.221 is
Scale Inv. MSE 0.065 0.055 better

We initially perform exploratory experiments on Virtual Dataset test set to compare the performance of the two proposed architectures (as described in Section 3.2). Networks are trained by using sequences with ground truth depth collected up to 40 meters, using Linear RMSE as training loss. Quantitative results are shown in Table 1: the network that processes optical flow inputs outperforms single image network with respect to all the metrics, showing the effectiveness of the proposed optical flow+image network.

Afterwards, we compute metric depth up to 200 meters and re-train the optical flow-based architecture on log RMSE and linear RMSE (see Table 2). The results show that the network based on the log RMSE loss achieve better performance with respect to the linear one.

Table 2: Comparison between the optical flow+image network trained on Log RMSE and the linear RMSE
Log RMSE Linear RMSE
thr. 0.643 0.482 Higher
thr. 0.887 0.764 is better
RMSE 6.065 7.004 Lower
Log RMSE 0.292 0.416 is
Scale Inv. MSE 0.085 0.154 better

4.2KITTI dataset

We perform experiment on KITTI dataset [18]. The sequences are gathered with a Pointgrey Flea2 firewire stereo camera mounted on a car traveling in the streets of the Karlsruhe city. Images are undistorted and collected with a resolution of and a frame rate of 10Hz. As the provided depth ground truth is sparse, we compute dense ground truth by using the colourization routine proposed in [17]. Furthermore, since LiDAR provides ground truth measures only for the bottom half of the scene, experiments are performed with respect to that portion of data. Performance are evaluated on a test set composed by 697 images, corresponding to the published results of [16]. We first run exploratory experiments to evaluate the optical flow based architecture, re-using network weights trained on a maximum detection range up to 40 meters, as described in Section 4.1. Results are provided in Table 3.

Table 3: Results on KITTI Dataset on our architectures trained with a detection range meters
Single Img. Optical Flow+Img.
thr. 0.311 0.421 Higher
thr. 0.572 0.679 is
thr. 0.764 0.813 better
RMSE 7.542 6.863 Lower
Log RMSE 0.574 0.504 is
Scale Inv. MSE 0.206 0.205 better
Table 4: Results on KITTI Dataset
Our network Eigen et. al Saxena et al.
thr. 0.318 0.692 0.601 Higher
thr. 0.617 0.899 0.820 is
thr. 0.813 0.967 0.926 better
RMSE 7.508 7.156 8.734 Lower
Log RMSE 0.524 0.270 0.361 is
Scale Inv. MSE 0.196 0.246 0.327 better

Finally, we perform experiments on our optical flow-based network trained for detection up to 200 meters, and we compare its performance with respect to state of the art depth predictors. In particular, we compare our performances with Eigen et. al [16] and Saxena et al. [25]. It is important to notice that these approaches are both trained and tested with respect to the KITTI sequences. Conversely, in order to prove the generalization capabilities of our approach, we train our network with respect to the Virtual Dataset sequence and test on the KITTI sequences without any fine-tuning procedure.

We report results in Table 4. For Saxena et al. work, we refer to the results provided in [16]. Although we do not perform any fine-tuning with respect to the real sequences, we obtain similar performance with respect to state-of-the-art approaches that are trained and tested on the same scenario. Furthermore, our network outperforms the other methods with respect to the scale invariant Log MSE metric that penalizes relative scale errors without considering absolute scale imperfections. Hence, we infer that our approach provides a accurate estimates with respect to relative depths.

The performance that we achieved with respect to linear RMSE and log RMSE metrics, suggest that our network weaknesses lie on close-range estimations, as log RMSE penalizes more mistakes on small values. We acknowledge that, for obstacle detection tasks, there are more robust methods than can detect close obstacles, such as laser sensors or stereo cameras. Thus, we believe that our approach could definitely improve depth estimation performance if combined with approaches tuned for short range detections.

Table 5: Results obtained on KITTI dataset applying Gaussian blur to images and changing lighting conditions.
Plain Blur rad:3 Blur rad:10 Darkened


0.318 0.244 0.142 0.176 Higher


0.617 0.525 0.350 0.348 is


0.813 0.741 0.573 0.509 better


7.508 8.126 9.483 9.645 Lower


0.524 0.606 0.792 0.923 is

Scale Inv.MSE

0.196 0.209 0.240 0.346 better

4.3Testing network robustness

To test the robustness of our approach on different scene conditions, we performed additional experiments on the KITTI sequences, by producing transformed versions of each test sequence. To do so we changed contrast and gamma to simulate different light conditions, and applied Gaussian blur of different radius to simulate defocus or motion blur. In particular, we add a gaussian blur with a radius of 3 (we refer to this experiment as Blurred Image rad:3, Figure ? ) and 10 pixels (Blurred Image rad:10, Figure ? ) and change image lighting by setting max contrast to 0.4 and gamma to 1.5 (Darkened Image, Figure ? ). The results of the evaluation with respect to these sequences are shown in Table 5. It was not possible to test Eigen et al. method on blurred images since they did not publicly release their network’s weights trained on KITTI dataset, so we compare our results with their performance on non-blurred images. On Blurred Image rad:3 experiment our performance is still better than Eigen et al. in terms of scale invariant log MSE error even after noise addition. and experience just a slight performance deterioration on other metric. On the Blurred Image rad:10 and Darkened Image experiments, the estimations are less accurate, but results remains acceptable and comparable with other techniques on scale invariant log MSE metric. These experiments, thus, demonstrate our network capability to perform acceptable estimations even with very noisy images.

5Conclusion and Future Work

In this paper, we explore the architecture and performances of a depth estimation algorithm based on a Encoder-Decoder Convolutional Neural Networks architecture. The proposed algorithm is intended to be the foundation of an Obstacle Detection system, meant to be run by fast vehicles. We address the limitations of stereo systems using a learning approach trained on synthetic images with long range ground truth. We test two kind of inputs, monocular images and monocular images with optical flow. Both networks trained on synthetic data have shown, compared to state-of-the-art methods, good performances on real data, suggesting that this training strategy is able to overcome some weaknesses of learning approaches, such as generalization and training data availability. In addition, we showed how the proposed algorithm is capable of estimating depth even when the starting images have been corrupted with blur, darkened or lightened. In future work we plan to increase network’s robustness augmenting virtual training data, also adding dynamical objects to the scene. In future works we will consider finetuning on real images to improve performance. In addition we plan to integrate our depth estimator together with semantic segmentation algorithms and object detectors to obtain a semantic knowledge of the scene, useful to infer information about estimation uncertainty and model more robust interpretations of the scene.


  1. E. R. Davies, Machine vision: theory, algorithms, practicalities. 1em plus 0.5em minus 0.4emElsevier, 2004.
  2. P. Pinggera, D. Pfeiffer, U. Franke, and R. Mester, “Know your limits: Accuracy of long range stereoscopic object measurements in practice,” in Computer Vision–ECCV 2014.1em plus 0.5em minus 0.4em Springer, 2014, pp. 96–111.
  3. P. Pinggera, U. Franke, and R. Mester, “High-performance long range obstacle detection using stereo vision,” in Intelligent Robots and Systems (IROS), 2015 IEEE/RSJ International Conference on.1em plus 0.5em minus 0.4emIEEE, 2015, pp. 1308–1313.
  4. M. Cordts, L. Schneider, M. Enzweiler, U. Franke, and S. Roth, “Object-level priors for stixel generation,” in Pattern Recognition.1em plus 0.5em minus 0.4emSpringer, 2014, pp. 172–183.
  5. R. Benenson, R. Timofte, and L. Van Gool, “Stixels estimation without depth map computation,” in Computer Vision Workshops (ICCV Workshops), 2011 IEEE International Conference on.1em plus 0.5em minus 0.4em IEEE, 2011, pp. 2010–2017.
  6. S. Pillai, S. Ramalingam, and J. J. Leonard, “High-performance and tunable stereo reconstruction,” arXiv preprint arXiv:1511.00758, 2015.
  7. J. Michels, A. Saxena, and A. Y. Ng, “High speed obstacle avoidance using monocular vision and reinforcement learning,” in Proceedings of the 22nd international conference on Machine learning.1em plus 0.5em minus 0.4emACM, 2005, pp. 593–600.
  8. D. Dey, K. S. Shankar, S. Zeng, R. Mehta, M. T. Agcayazi, C. Eriksen, S. Daftry, M. Hebert, and J. A. Bagnell, “Vision and learning for deliberative monocular cluttered flight,” arXiv preprint arXiv:1411.6326, 2014.
  9. S. B. Goldberg, M. W. Maimone, and L. Matthies, “Stereo vision and rover navigation software for planetary exploration,” in Aerospace Conference Proceedings, 2002. IEEE, vol. 5.1em plus 0.5em minus 0.4emIEEE, 2002, pp. 5–2025.
  10. R. Labayrade, D. Aubert, and J.-P. Tarel, “Real time obstacle detection in stereovision on non flat road geometry through“ v-disparity” representation,” in Intelligent Vehicle Symposium, 2002. IEEE, vol. 2.1em plus 0.5em minus 0.4emIEEE, 2002, pp. 646–651.
  11. A. Harakeh, D. Asmar, and E. Shammas, “Ground segmentation and occupancy grid generation using probability fields,” in Intelligent Robots and Systems (IROS), 2015 IEEE/RSJ International Conference on.1em plus 0.5em minus 0.4emIEEE, 2015, pp. 695–702.
  12. R. Hadsell, P. Sermanet, J. Ben, A. Erkan, M. Scoffier, K. Kavukcuoglu, U. Muller, and Y. LeCun, “Learning long-range vision for autonomous off-road driving,” Journal of Field Robotics, vol. 26, no. 2, pp. 120–144, 2009.
  13. D. Ball, B. Upcroft, G. Wyeth, P. Corke, A. English, P. Ross, T. Patten, R. Fitch, S. Sukkarieh, and A. Bate, “Vision-based obstacle detection and navigation for an agricultural robot,” Journal of Field Robotics, 2016.
  14. T. Mori and S. Scherer, “First results in detecting and avoiding frontal obstacles from a monocular camera for micro unmanned aerial vehicles,” in Robotics and Automation (ICRA), 2013 IEEE International Conference on.1em plus 0.5em minus 0.4emIEEE, 2013, pp. 1750–1757.
  15. A. Beyeler, J.-C. Zufferey, and D. Floreano, “Vision-based control of near-obstacle flight,” Autonomous robots, vol. 27, no. 3, pp. 201–219, 2009.
  16. D. Eigen, C. Puhrsch, and R. Fergus, “Depth map prediction from a single image using a multi-scale deep network,” in Advances in neural information processing systems, 2014, pp. 2366–2374.
  17. N. Silberman, D. Hoiem, P. Kohli, and R. Fergus, “Indoor segmentation and support inference from rgbd images,” in Computer Vision–ECCV 2012.1em plus 0.5em minus 0.4emSpringer, 2012, pp. 746–760.
  18. A. Geiger, P. Lenz, and R. Urtasun, “Are we ready for autonomous driving? the kitti vision benchmark suite,” in Computer Vision and Pattern Recognition (CVPR), June 2012.
  19. J. Long, E. Shelhamer, and T. Darrell, “Fully convolutional networks for semantic segmentation,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2015, pp. 3431–3440.
  20. H. Noh, S. Hong, and B. Han, “Learning deconvolution network for semantic segmentation,” in Proceedings of the IEEE International Conference on Computer Vision, 2015, pp. 1520–1528.
  21. V. Badrinarayanan, A. Handa, and R. Cipolla, “Segnet: A deep convolutional encoder-decoder architecture for robust semantic pixel-wise labelling,” arXiv preprint arXiv:1505.07293, 2015.
  22. P. Fischer, A. Dosovitskiy, E. Ilg, P. Häusser, C. Hazirbaş, V. Golkov, P. van der Smagt, D. Cremers, and T. Brox, “Flownet: Learning optical flow with convolutional networks,” arXiv preprint arXiv:1504.06852, 2015.
  23. K. Simonyan and A. Zisserman, “Very deep convolutional networks for large-scale image recognition,” CoRR, vol. abs/1409.1556, 2014.
  24. T. Brox, A. Bruhn, N. Papenberg, and J. Weickert, “High accuracy optical flow estimation based on a theory for warping,” in European Conference on Computer Vision (ECCV), May 2004.
  25. A. Saxena, M. Sun, and A. Y. Ng, “Make3d: Learning 3d scene structure from a single still image,” Pattern Analysis and Machine Intelligence, IEEE Transactions on, vol. 31, no. 5, pp. 824–840, 2009.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minumum 40 characters
Add comment
Loading ...
This is a comment super asjknd jkasnjk adsnkj
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test description