Depth prediction using a single image
Diksha Meghwal Imran
dm4511@nyu.edu ii398@nyu.edu
Courant Institute of Mathematics
New York University
Abstract
This paper addresses the problem of estimat-
ing the depth map of a scene given a single
RGB image. We propose a simpler fully con-
volutional architecture, encompassing resid-
ual learning, to model the ambiguous mapping
between monocular images and depth maps.
In order to improve the output resolution, we
present a novel way to efficiently learn fea-
ture map up-sampling within the network. The
architecture consists of a contracting path to
capture context and a symmetric expanding
path that enables precise localization. For opti-
mization, we use the scale invariant loss that is
particularly suited for the task at hand and han-
dles the ambiguity caused by scale of the depth
in the image. Our model is composed of a sin-
gle architecture that is trained end-to-end and
does not rely on post-processing techniques,
such as CRFs or other additional refinement
steps. The model contains significantly fewer
parameters than the current SOTA.
1 Introduction
Scene depth inference from a single image is cur-
rently an important issue in machine learning [1]
[2], [3] [4] [5]. The underlying rationale of this
problem is the possibility of human depth percep-
tion from single images. The task here is to as-
sign a depth value to every single pixel in the im-
age, which can be considered as a dense regres-
sion problem. Depth information can benefit many
challenging computer vision problems, such as se-
mantic segmentation [6], [7], pose estimation [8],
and object detection [9].
During the past decade, significant effort has been
made in the research community to improve the
performance of monocular depth learning, and sig-
nificant accuracy has been achieved thanks to the
rapid development and advances of deep neural
networks. However, most networks tend to be
pretty heavy and contain large no of parameters
Rob Fergus
fergus@nyu.edu
to be trained. This requires huge amount of image
data to train. We adopted the novel approach used
by U-Net architecture to create a simpler archi-
tecture that consists of a contracting path to cap-
ture context and a symmetric expanding path that
enables precise localization. U-Net architectures
have already provided good resulst on the prob-
lem of segmentation. We implement the coarse
and fine model proposed by Eigen [10] to compare
results acheived by using u-net on same image set.
2 Related Work
Depth estimation from image data has originally
relied on stereo vision [11] [12], using image pairs
of the same scene to reconstruct 3D shapes. Such
approaches relied on motion (Structure-from-
Motion [13]) or different shooting conditions
(Shape-from-Shading [14], Shape-from-Defocus
[15]). Despite the ambiguities that arise in lack
of such information, but inspired by the analogy
to human depth perception from monocular cues,
depth map prediction from a single RGB image
has also been investigated. Below, we focus on
the related work for single RGB input, similar to
our method.
Classic methods on monocular depth estimation
have mainly relied on hand-crafted features and
used probabilistic graphical models to tackle
the problem [16] [17] [18] [19], usually making
strong assumptions about scene geometry. One
of the first works, by Saxena et al.[20], uses a
MRF to infer depth from local and global features
extracted from the image, while superpixels [21]
are introduced in the MRF formulation in order to
enforce neighboring constraints. Their work has
been later extended to 3D scene reconstruction
[22]. Inspired by this work, Liu et al. [23] com-
bine the task of semantic segmentation with depth
estimation, where predicted labels are used as
additional constraints to facilitate the optimization
task. Ladicky et al.[24] instead jointly predict
labels and depths in a classification approach.
More recently, remarkable advances in the field
of deep learning drove research towards the use
of CNNs for depth estimation. Since the task is
closely related to semantic labeling, most works
have built upon the most successful architectures
of the ImageNet Large Scale Visual Recognition
Challenge (ILSVRC) [25], often initializing their
networks with AlexNet [26] or the deeper VGG
[27]. Eigen et al.[10] have been the first to use
CNNs for regressing dense depth maps from a
single image in a two-scale architecture, where
the first stage based on AlexNet produces a
coarse output and the second stage refines the
original prediction. Their work is later extended
to additionally predict normals and labels with a
deeper and more discriminative model based on
VGG and a three-scale architecture for further
refinement[3].
3 U-Net Model
The original network architecture of u-net is
illustrated in Figure 1. It consists of a con-
tracting path (left side) and an expansive path
(right side). The contracting path follows the
typical architecture of a convolutional network.
It consists of the repeated application of two
3x3 convolutions (unpadded convolutions), each
followed by a rectified linear unit (ReLU) and
a 2x2 max pooling operation with stride 2 for
downsampling. At each downsampling step we
double the number of feature channels. Every step
in the expansive path consists of an upsampling
of the feature map followed by a 2x2 convolution
(up-convolution) that halves the number of feature
channels, a concatenation with the corresponding
feature map from the contracting path, and two
3x3 convolutions, each followed by a ReLU. At
the final layer a 1x1 convolution is used to map
each 64-component feature vector to the desired
number of classes.
We have slightly modified the original architec-
ture of u-net to further reduce the no of parameters
to train. The size of the input image is reduced and
also we dropped 1 layer in the both contracting and
expanding path of the architecture. In total the net-
work has 18 convolutional layers as opposed to 23
present in the original architecture. The original
architecture also crops the image while downsam-
pling the image so we end up losing boundary val-
ues. We prevent this loss of boundary by applying
appropriate padding. Also since the original archi-
tecture is designed for classification problem, we
have modified the last layer to produce an output
which is the same size as the target depth image.
Figure 1: Architecture of the proposed network.
U-net architecture (example for 8x8 pixels in the
lowest resolution). Each blue box corresponds to
a multi-channel feature map. The number of chan-
nels is denoted on top of the box. The x-y-size is
provided at the lower left edge of the box. White
boxes represent copied feature maps. The arrows
denote the different operations.
4 Fine and Coarse Model
4.1 Coarse network
The coarse-scale network contains five feature ex-
traction layers of convolution and max-pooling,
followed by two fully connected layers. The in-
put, feature map and output sizes are also given in
Fig. 2. The final output is at 1/4-resolution com-
pared to the input and corresponds to a center crop
containing most of the input (as we describe later,
we lose a small border area due to the first layer
of the fine-scale network and image transforma-
tions). Since the top layers of the coarse model are
fully connected layers, they encompass the entire
image giving a global feature map of the image.
The middle and lower layers focus on small part
of the image to enable localization.
4.2 Fine network
The task of fine scale model is to make local re-
finements in the depth using the combined input
of the image as well as the depth map produced by
the coarse scale network. The fine scale network
consists of convolution layers that have a small
viewing area of 45*45 pixels that focus on the lo-
cal nuances of the image. It consists of a single
max pool operation that is applied with a convolu-
tion layer on the input image. The size of this out-
put matches the size of the depth map produced by
coarse network and this combined input is then ap-
plied on subsequent convolution layers that main-
tain the same size using appropriate padding. This
way the model achieves local refinement by learn-
ing the local features like wall edges, corners. All
hidden convolution layers are followed by recti-
fied linear activations. The final layers predicts the
depth map and hence is a fully connected layer.
Figure 2: Coarse-fine model with details of each
convolution layer.
5 Loss function
The standard loss functions for optimization in re-
gression problems are the L1, L2 loss function,
minimizing the absolute distance or squared eu-
clidean norm between predictions y’ and ground
truth
The equation is:
1X
smooth L1(y 0 , y) = zi (3)
n
i
where z i is as define below:
(
0 · 5 |y 0 i − yi|2 , |y 0 i − yi| < 1
zi = (4)
|y 0 i − yi | − 0 · 5, otherwise
It also popularly known as the Huber loss. How-
ever, the best results were observed from using the
scale invariant error as proposed by Eigen et al.
[10]. For a predicted depth map y’ and ground
truth y, each with n pixels indexed by i the method
is defined as below:
!2
1 X λ X
L(y 0 , y) = di2 − 2 di (5)
n n
i
where d i is the difference between the absolute
truth and the global truth defined as below:
d i = log y 0 − log y (6)
where λ = 0.5. This method mitigates the ambi-
guity caused by the scale of the image since all
the operations are happening at log scale. The
first part of the equation is very similar to l2 Loss.
However, since the operation is in log scale, each
pair of pixels in the prediction must differ in depth
by an amount similar to that of the correspond-
ing pair in the ground truth. Also the second term
of the equation is basically a product of the two
vectors d i and d j and is actually smaller if two
predictions are off from the ground truth by a simi-
lar margin as compared to the other prediction and
larger when they are in opposite directions. In ev-
ery gradient descent step, when we compute this
scale invariant loss by taking the cumulative loss
for an entire batch and then dividing by the batch
size to get the final loss value per pixel. The value
X
y 0 − y  of λ is chosen as an average between 0 which re-

L1 = (1)
X
2
L2 = y0 − y (2)
Although this produces good results in our test
cases, we found that there were still ambiguities
in the results obtained.
We then tried smooth L1 loss function which
is a combination of L1-loss and L2-loss. It be-
haves as L1-loss when the absolute value of the
argument is high, and it behaves like L2-loss when
the absolute value of the argument is close to zero.
duces the equation to a simple L2 and 1 which is
the actual scale invariant loss and seems to provide
the best results on the observed dataset
In addition to the scale-invariant error, we also
measure the performance of our method according
to several error metrics have been proposed in
prior works, as described in Section 6.4
6 Experimental setup
In this section, we first describe the training cor-
pus, explain our training and inference setups and
give implementation details about our model.
6.1 Dataset
We train our model on the labeled version of NYU
Depth v2[28] which comprises of 1449 densely
labeled pairs of aligned RGB and depth images.
The raw distributions contain many additional im-
ages collected from the same scenes as in the more
commonly used small distributions, but with no
preprocessing; in particular, points for which there
is no depth value are left unfilled. However, given
the scope of this project we restrict ourselves to
the labeled data set where the data has been pre-
processed to fill in missing depth labels. We split
the database into a group of 1024 images for train-
ing, 224 for validation and 201 images for evalua-
tion.
Number of pairs (Train) 1024
Number of pairs (Validation) 224
Number of pairs (Test) 201
Table 1: Distribution of data in train, test and
validation sets in the entire NYU depth labeled
dataset.
6.2 Image Preprocessing
Since we are using the NYU depth dataset, we ex-
tract the data from matlab file provided on their
official website[28]. It consists of both the rgb
images and their corresponding depth map as the
numpy arrays. For rgb images, we subtract the per
channel mean of the value of a pixel for a consid-
erable subset of the data. This basic normaliza-
tion for images is done for training, validation as
well as test to make the network more robust and
less susceptible to differing background and light-
ening conditions. Also, we resize the rgb images
according to the network input requirement. For
the coarse and fine model the rgb input image is
transformed to a size of 304 x 228 while the depth
target is resized to 74 x 55 as the model produces
an output 1/4 of the input image. For U-Net since
the input and output size remain same as we con-
cat across down-sampling and up-sampling paths,
we transform the input to a 64 * 64 image to make
the computations less heavy. Finally we normalize
the rgb image by calculating the mean per pixel
per channel for 500 odd images and subtracting it
from each rgb image and adding the standard de-
viation for a batch
For depth we use bilinear interpolation to resize
depth array. Also the depth is transformed into log
space to handle the ambiguity caused by scale.
6.3 Training and inference
The input images and their corresponding depth
maps are used to train the network in pytorch.
For coarse and fine model, training is done in two
steps. First step involves tuning the coarse model
with respect to the ground truth. This network
takes as input an image of size 304 x 228 and pro-
duces a depth map that generates a fuzzy depth
map for the whole image. Once coarse network
is trained we freeze that model and train the fine
model using the input from this trained coarse net-
work and the input rgb image. We use the stan-
dard SGD optimizer with momentum 0.9 and our
log invariant loss function for gradient computa-
tion for both the networks.
We use separate learning rate for each layer.
coarse layer lr fine layer lr
conv1 0.001 conv1 0.001
conv2 0.001 conv2 0.01
conv3 0.001 conv3 0.001
conv4 0.001
conv5 0.001
fc1 0.1
fc2 0.1
Table 2: Learning rate for each convolutional layer
in the coarse and fine architecture
For the u-net architecture we train with an
input of size 64 * 64, use the SGD optimizer with
momentum of 0.9, learning rate 0.01 and the scale
invariant loss function to train the network with
a batch size of 32. We run the model for approx
200 epochs and it converges in 20 mins to provide
substantial results.
The loss values are defined for each pixel
for which we are predicting a depth value. The
weights of the network are randomly initialized.
Ideally the initial weights should be adapted
such that each feature map in the network has
approximately unit variance. For a network with
our architecture (alternating convolution and
ReLU layers) this can be achieved by drawing the
initial weights from a Gaussian distribution with
a standard deviation of 2/N, where N denotes the our loss values were less compared to the ones
number of incoming nodes of one neuron [5]. observed in the benchmark models. To validate
that our model was not erratic, we tried a bunch
of other loss functions like L1(absolute relative
6.4 Experiments difference between pixels in a batch of images),
We implemented our model using standard py- L2, smooth L1 loss (Huber loss), changing the
torch libraries. We used prince clusters provided lambda value in the scale invariant loss function
by NYU Computer Science departments and ran and observing the results on the absolute as well
sbatch jobs to run our models. We plugged in ten- as logarithmic scale. The original scale invariant
sorboard to monitor the progress of the model and function seemed to perform the best among all
get a good feel of the gradient descent. To visual- despite its unexplainably small values.
ize the depth map and to get a good sense of the re-
sults we generate plots of the output images along
with input and target while evaluating.
Model Architecture Since the original architec-
ture of the u-net model was pretty big to train,
we started with a smaller network with 3 convolu-
tional layers comprising of just conv nets followed
by Relu (no pooling) for downsampling and 3 con-
vTranspose2D for upsampling with no concatena-
tion of weights at the same level. This model had
just 94011 parameters and was first made to over-
fit a small trainset of 1 image. We then slowly
added more layers, one at a time, adding padding
to conv nets to ensure no loss of boundary and
added maxpool for downsampling. The model
had now 433771 parameters and seemed to im-
prove a little with the increase in the no of parame-
Figure 4: Output of our implementation of the
ters in the network but showed most improvement
coarse and fine model on the NYU labeled dataset
with the concatenation of feature maps across the
downsample-upsample bridge. We also tried to
change the activation function to tanH but didn’t 6.5 Evaluation metrics
observe any improvement. Coarse Fine UNet Coarse [10] Fine [10]
Scale Inv. 0.094 0.095 0.077 0.221 0.219
Optimizers We experimented with several delta1 0.502 0.498 0.573 0.618 0.611
optimizers like Adagrad, Adamax, Adadelta, delta2 0.816 0.812 0.860 0.891 0.887
delta3 0.948 0.947 0.959 0.969 0.971
Adam (with and without amsgrad) and found SGD rmse(lin) 0.889 0.898 0.806 0.871 0.907
to perform equal or slightly better than Adam. rmse(log) 0.116 0.118 0.096 0.283 0.285
We started with a standard learning rate of 10−3 abs rel
abs sqr rel
0.276
0.307
0.267
0.297
0.263
0.272
0.228
0.223
0.215
0.212
and observed that the rate of convergence for the
model was pretty slow. It took 3 hours and 3000 Table 3: Error Table. delta1 is no of pixels for
epochs for the model to converge. We slowly which output/input threshold < 1.25, delta2 with
increased the learning rate with a factor of 10 threshold < 1.252 , delta3 with 1.253
and observed that model now converged in just
200 epochs in 20 mins. To further improve the
results we tried to implement a decaying rate with We use several metrics apart from the scale in-
a step size of 30 epochs but we didn’t see any variant function to evaluate the depth predictions
improvement in the results. of our model with the ground truth while validat-
ing. These include the threshold loss functions
that evaluate the maximum of the ratio between
Loss Functions We trained our model using the predicted output and actual output. We also use
scale invariant loss function but we observed that RMSE linear which is nothing but the standard
 (a) Plot of loss functions as described in the legend (b) Plot of accuracies as described in the legend

Figure 3: Error and accuracies on the u-net model

root mean squared error. Since out dataset is in log observed in the model when we combine the input
space, we convert into the exponent of the base to in the expanding part of the model with the corre-
get the linear value. Similarly, we add other loss sponding output in the contracting path as shown
functions like relative difference, squared relative in figure 5.
difference for both log space and absolute. We plot
these values during the validation stage and ob-
served that post 200 epochs the network stabilizes
and doesn’t progress much. The values observed
are evaluated on the evaluation dataset of the la-
beled NYU Depth dataset which had 201 images.

Table 4: Notable Results in area of Depth Map Pre-

diction

Wang[29] Eigen[3] ResNet[4] AlexNet[4] VGG[4]

delta1 0.605 0.769 0.811 0.586 0.626
delta2 0.890 0.950 0.953 0.869 0.894
delta3 0.970 0.988 0.988 0.967 0.974
rmse(lin) 0.745 0.641 0.573 0.845 0.746
rmse(log) 0.262 0.214 0.195 0.283 0.285
abs rel 0.220 0.158 0.127 0.209 0.194

7 Results and Analysis

The fine and coarse model that we implemented
didn’t perform comparable to the benchmark
results as shown in Tables 3 and 4. This may be
because of the lack of larger images in the training
dataset as we restricted ourselves to the labeled
dataset given the constraint of resources.
The initial encoder-decoder model that we im-
plemented which consisted of just 94000 parame-
ters performed terribly and produced no meaning-
ful output. This was because the model didn’t have
sufficient parameters to be trained for the task at
hand. As we increased the no of layers and hence
the no of parameters in the model, we observe im-
provements in the model. A major improvement is
Figure 5: Output of the network before and af-
ter concatenating the feature map from the corre-
sponding converging path
As shown in Table 3 shows the summary of
results across the two models, using various
evaluation metrics. We see that our u-net based
model falls short of all the benchmark values by
a small value. However as observed in the plots
in the Fig5, our results for u-net are better across
all the given metrics as compared to our own
implementation of the coarse-fine model. This
leads us to believe that if we were able to fix the
anomaly in our loss function, our model would
 have given much better results that could have
been comparable to the benchmark values. The
scale invariant loss function does handle scale
based ambiguity
8 Conclusion
We propose a end to end trainable model for es-
timating the depth map from a single rgb image
using NYU Depth labeled dataset. We show how
to train this model by using the coarse fine model
for comparison. We see that our model with u-net
based architecture converged in mere 200 epochs
and trains quickly as there are no heavy fully con-
nected layers used in the model. Also we use
no processing of images like CRFs or other ad-
ditional refinement steps. The output generated by
our model is comparable to the fine-coarse model
implemented by us and can do even better with in-
creased dataset size.
For future work, we would like to investigate
our findings further and try to explore other loss
functions with better gradient optimization strate-
gies to better account for the loss in the output im-
ages. We would also like to investigate the effects
of using the original u-net architecture which ex-
pects input of size 572 * 572 and see the impact
of these increased parameters on the model’s per-
formance. Also make our model more robust by
applying it on non labeled dataset as well.
9 Contributions
− Diksha Meghwal - Worked on implement-
ing variations of u-net model, built log parser
to plot the graphs for gradient descent, and
worked on setting up the framework for run-
ning the program parallely on GPUs
− Imran - Worked on implementation of the
fine and coarse model, extracting and trans-
forming images from NYU Depth Dataset
and developing framework to calculate nu-
merous loss values for comparison
References
[1] Ashutosh Saxena, Min Sun, and Andrew Y Ng.
Make3d: Learning 3d scene structure from a single
still image. IEEE transactions on pattern analysis
and machine intelligence, 31(5):824–840, 2009.
[2] Kevin Karsch, Ce Liu, and Sing Bing Kang. Depth
transfer: Depth extraction from video using non-
parametric sampling. IEEE transactions on pattern
analysis and machine intelligence, 36(11):2144–
2158, 2014.
[3] David Eigen and Rob Fergus. Predicting depth, sur-
face normals and semantic labels with a common
multi-scale convolutional architecture. In Proceed-
ings of the IEEE International Conference on Com-
puter Vision, pages 2650–2658, 2015.
[4] Iro Laina, Christian Rupprecht, Vasileios Belagian-
nis, Federico Tombari, and Nassir Navab. Deeper
depth prediction with fully convolutional residual
networks. In 3D Vision (3DV), 2016 Fourth Interna-
tional Conference on, pages 239–248. IEEE, 2016.
[5] Dan Xu, Elisa Ricci, Wanli Ouyang, Xiaogang
Wang, and Nicu Sebe. Multi-scale continuous crfs
as sequential deep networks for monocular depth es-
timation. In Proceedings of CVPR, volume 1, 2017.
[6] Caner Hazirbas, Lingni Ma, Csaba Domokos, and
Daniel Cremers. Fusenet: Incorporating depth into
semantic segmentation via fusion-based cnn archi-
tecture. In Asian Conference on Computer Vision,
pages 213–228. Springer, 2016.
[7] Yuanzhouhan Cao, Chunhua Shen, and Heng Tao
Shen. Exploiting depth from single monocular
images for object detection and semantic segmen-
tation. IEEE Transactions on Image Processing,
26(2):836–846, 2017.
[8] Jamie Shotton, Ross Girshick, Andrew Fitzgibbon,
Toby Sharp, Mat Cook, Mark Finocchio, Richard
Moore, Pushmeet Kohli, Antonio Criminisi, Alex
Kipman, et al. Efficient human pose estimation from
single depth images. IEEE Transactions on Pattern
Analysis and Machine Intelligence, 35(12):2821–
2840, 2013.
[9] Shuran Song Jianxiong Xiao. Deep sliding shapes
for amodal 3d object detection in rgb-d images.
[10] David Eigen, Christian Puhrsch, and Rob Fergus.
Depth map prediction from a single image using a
multi-scale deep network. In Advances in neural
information processing systems, pages 2366–2374,
2014.
[11] Nathan Silberman, Derek Hoiem, Pushmeet Kohli,
and Rob Fergus. Indoor segmentation and support
inference from rgbd images. In European Confer-
ence on Computer Vision, pages 746–760. Springer,
2012.
[12] Andreas Geiger, Philip Lenz, Christoph Stiller, and
Raquel Urtasun. Vision meets robotics: The kitti
dataset. The International Journal of Robotics Re-
search, 32(11):1231–1237, 2013.
[13] Vijay Badrinarayanan, Alex Kendall, and Roberto
Cipolla. Segnet: A deep convolutional encoder-
decoder architecture for image segmentation. arXiv
preprint arXiv:1511.00561, 2015.
[14] Hyeonwoo Noh, Seunghoon Hong, and Bohyung [26] Guanghui Wang, Hung-Tat Tsui, and QM Jonathan
Han. Learning deconvolution network for semantic Wu. What can we learn about the scene structure
segmentation. In Proceedings of the IEEE interna- from three orthogonal vanishing points in images.
tional conference on computer vision, pages 1520– Pattern Recognition Letters, 30(3):192–202, 2009.
1528, 2015.
[27] Miaomiao Liu, Mathieu Salzmann, and Xuming
[15] Jonathan Long, Evan Shelhamer, and Trevor Dar- He. Discrete-continuous depth estimation from a
rell. Fully convolutional networks for semantic seg- single image. In Proceedings of the IEEE Confer-
mentation. In Proceedings of the IEEE conference ence on Computer Vision and Pattern Recognition,
on computer vision and pattern recognition, pages pages 716–723, 2014.
3431–3440, 2015.
[28] Pushmeet Kohli Nathan Silberman, Derek Hoiem
[16] Bharath Hariharan, Pablo Arbeláez, Ross Girshick, and Rob Fergus. Indoor segmentation and support
and Jitendra Malik. Hypercolumns for object seg- inference from rgbd images. In ECCV, 2012.
mentation and fine-grained localization. In Proceed-
ings of the IEEE conference on computer vision and [29] Peng Wang, Xiaohui Shen, Zhe Lin, Scott Cohen,
pattern recognition, pages 447–456, 2015. Brian Price, and Alan L Yuille. Towards unified
depth and semantic prediction from a single image.
[17] Olaf Ronneberger, Philipp Fischer, and Thomas In Proceedings of the IEEE Conference on Com-
Brox. U-net: Convolutional networks for biomed- puter Vision and Pattern Recognition, pages 2800–
ical image segmentation. In International Confer- 2809, 2015.
ence on Medical image computing and computer-
assisted intervention, pages 234–241. Springer,
2015.
[18] Guosheng Lin, Anton Milan, Chunhua Shen, and
Ian D Reid. Refinenet: Multi-path refinement net-
works for high-resolution semantic segmentation. In
Cvpr, volume 1, page 5, 2017.
[19] Yun Liu, Ming-Ming Cheng, Xiaowei Hu, Kai
Wang, and Xiang Bai. Richer convolutional features
for edge detection. In Computer Vision and Pat-
tern Recognition (CVPR), 2017 IEEE Conference
on, pages 5872–5881. IEEE, 2017.
[20] Saining Xie and Zhuowen Tu. Holistically-nested
edge detection. In Proceedings of the IEEE interna-
tional conference on computer vision, pages 1395–
1403, 2015.
[21] Derek Hoiem, Alexei A Efros, and Martial Hebert.
Automatic photo pop-up. In ACM transactions on
graphics (TOG), volume 24, pages 577–584. ACM,
2005.
[22] Alexander G Schwing and Raquel Urtasun. Effi-
cient exact inference for 3d indoor scene understand-
ing. In European Conference on Computer Vision,
pages 299–313. Springer, 2012.
[23] Varsha Hedau, Derek Hoiem, and David Forsyth.
Thinking inside the box: Using appearance mod-
els and context based on room geometry. In Euro-
pean Conference on Computer Vision, pages 224–
237. Springer, 2010.
[24] Ashutosh Saxena, Sung H Chung, and Andrew Y
Ng. Learning depth from single monocular images.
In Advances in neural information processing sys-
tems, pages 1161–1168, 2006.
[25] Ashutosh Saxena, Sung H Chung, and Andrew Y
Ng. 3-d depth reconstruction from a single still
image. International journal of computer vision,
76(1):53–69, 2008.