Neural Inverse Rendering of an Indoor Scene from a Single Image

TL;DR

This paper introduces a novel learning-based method for inverse rendering of indoor scenes from a single image, jointly estimating reflectance, geometry, and lighting with a new renderer that captures complex effects.

Contribution

The paper presents the first joint estimation approach for albedo, normals, and lighting from a single image, utilizing a Residual Appearance Renderer for realistic synthesis and self-supervised learning.

Findings

Outperforms existing methods in scene attribute estimation

Uses a large synthetic dataset for training

Effectively models complex appearance effects

Abstract

Inverse rendering aims to estimate physical attributes of a scene, e.g., reflectance, geometry, and lighting, from image(s). Inverse rendering has been studied primarily for single objects or with methods that solve for only one of the scene attributes. We propose the first learning-based approach that jointly estimates albedo, normals, and lighting of an indoor scene from a single image. Our key contribution is the Residual Appearance Renderer (RAR), which can be trained to synthesize complex appearance effects (e.g., inter-reflection, cast shadows, near-field illumination, and realistic shading), which would be neglected otherwise. This enables us to perform self-supervised learning on real data using a reconstruction loss, based on re-synthesizing the input image from the estimated components. We finetune with real data after pretraining with synthetic data. To this end, we use physically-based rendering to create a large-scale synthetic dataset, which is a significant improvement over prior datasets. Experimental results show that our approach outperforms state-of-the-art methods that estimate one or more scene attributes.

Figures

Tables

Table 1. Table 2 : Albedo estimation on synthetic data. (RMSE;MAD)

Algorithm	CG-PBR	CGI [19]
Li et. al. [19]	0.2873; 0.2427	0.2685; 0.2220
Ours	0.1567; 0.1300	0.2126; 0.1875

Table 2. Table 3 : Median angular errors for surface normals. (trained on synthetic and NYUv2)

	NYUv2	7-scenes	Scannet	CG-PBR
PBRS [47]	15.33°	25.65°	30.39°	27.84°
Ours	16.92°	24.54°	21.10°	18.67°

Table 3. Table 4 : Environment map estimation – synth. data. (MAD)

	Gardner  [8]	Ours	GT
Env. map error	0.3162	0.1639	-
Image recon. error	0.1640	0.1158	0.0949

Table 4. Table 5 : Environment map estimation – real data.

	RMSE	MAD
Gardner  [8]	0.3109	0.2554
Ours	0.2105	0.1772

Table 5. Table 6 : Role of RAR. We evaluate albedo and normal estimation error by training IRN with (‘Ours’) and without (‘w/o RAR’) RAR using weak-supervisions over albedo (IIW) and normal (NYUv2).

	Albedo		Normal
	CG-PBR	IIW	NYUv2	Scannet
IIW - Ours	0.130	16.7%	23.2°	28.4°
w/o RAR	0.265	21.6%	60.2°	91.5°
NYUv2 - Ours	0.134	38.5%	16.9°	21.1°
w/o RAR	0.191	40.6%	21.1°	87.1°

Table 6. Table 7 : Role of weak supervision. We train IRN with (’Ours’) and without (‘w/o RAR’) RAR using weak-supervisions over albedo (IIW) and normal respectively (NYUv2).

	Albedo (IIW)	Normal (NYUv2)
Ours	16.7%	16.9°
w/o weak sup.	32.7%	23.3°

Equations

$$\text{mbox}IRN:$$

$$\text{mbox}DirectRenderer:$$

$$\text{mbox}RAR:$$

$$\begin{array}{rl}{L}_s& ={\lambda }_1||\hat{N}-N^{\ast }|{|}_1+{\lambda }_2||\hat{A}-A^{\ast }|{|}_1\\ & +{\lambda }_3||f_d(A^{\ast },N^{\ast },\hat{L})-f_d(A^{\ast },N^{\ast },{\hat{L}}^{\ast })|{|}_1.\end{array}$$

$${\hat{I}}_d=f_d(\hat{A},\hat{N},\hat{L})=\hat{A}\sum _i\max (0,\hat{N}\cdot {\hat{L}}_i),\text{vspace}-1em$$

$$L=0.5\ast L_a+0.5\ast L_n+0.1\ast L_e+L_u+30\ast L_w.$$

$$L=0.2\ast L_a+0.05\ast L_e+L_u+20\ast L_w.$$

Full text

1 Introduction

Inverse rendering aims to estimate physical attributes (e.g., geometry, reflectance, and illumination) of a scene from images. It is one of the core problems in computer vision, with a wide range of applications in gaming, AR/VR, and robotics [12, 14, 40, 43]. In this paper, we propose a holistic, data-driven approach for inverse rendering of an indoor scene from a single image. Inverse rendering has two main challenges. First, it is inherently ill-posed, especially if only a single image is given. Previous approaches [1, 15, 23, 25] that aim to solve this problem from a single image focus only on a single object. Second, inverse rendering of a scene is particularly challenging, compared to single objects, due to complex appearance effects (e.g., inter-reflection, cast shadows, near-field illumination, and realistic shading). Some existing works [8, 21, 47, 19] are limited to estimating only one of the scene attributes. We focus on jointly estimating all scene attributes from a single image, which outperforms previous approaches that estimate a single attribute and generalizes better across datasets (see Figure 1 and more in Section 5).

A major challenge†††The authors contributed to this work when they were at NVIDIA. in solving this problem is the lack of ground-truth labels for real images. Although we have ground-truth labels for geometry, collected by depth sensors, it is extremely difficult to measure reflectance and lighting at the large scale needed for training a neural network. Networks trained on synthetic images often fail to generalize well on real images. In this paper, we propose two key innovations aimed to tackle the domain gap between synthetic and real images. First, we propose the Residual Appearance Renderer (RAR), which learns to predict complex appearance effects on real images. This enables us to learn from unlabeled real images using self-supervised photometric reconstruction loss by re-synthesizing the image from its estimated components. Second, we introduce a new synthetic dataset using physically-based rendering with more photorealistic images than previous indoor scene datasets [47, 37]. More realistic synthetic data is useful for pretraining our network to help bridge the domain gap between real and synthetic images.

Residual Appearance Renderer. Our key idea is to learn from unlabeled real data using self-supervised reconstruction loss, which is enabled by our proposed Residual Appearance Renderer (RAR) module. While using a reconstruction loss for domain transfer from synthetic to real has been explored previously [32, 36, 23], their renderer is limited to direct illumination under distant lighting with a single material. For real images of a scene, however, this simple direct illumination renderer cannot synthesize important, complex appearance effects, such as inter-reflections, cast shadows, near-field lighting, and realistic shading. These effects termed residual appearance in this paper, can only be simulated with the rendering equation via physically-based ray-tracing, which is non-differentiable and cannot be employed in a learning-based framework. To this end, we propose the Residual Appearance Renderer (RAR) module, which along with a direct illumination renderer can reconstruct the original image from the estimated scene attributes, for self-supervised learning on real images.

Rendering dataset. It is especially challenging for inverse rendering tasks to obtain accurate ground truth labels for real images. Hence we create a large-scale synthetic dataset, CG-PBR by applying physically-based rendering to all the 3D indoor scenes from SUNCG [37]. Compared to prior work PBRS [47], CG-PBR significantly improves data quality in the following ways: (1) The rendering of a scene is performed under multiple natural illuminations. (2) We render the same scene twice. Once with all materials set to Lambertian and once with the default material settings to produce image pairs (diffuse, specular). (3) We utilize deep denoising [3], which allows us to render high-quality images from limited samples per pixel. Our dataset consists of 235,893 images with labels for normal, depth, albedo, Phong [16] model parameters and semantic segmentation. Examples are shown in Fig. 3. We plan to release the CG-PBR dataset upon acceptance of this paper.

Similar to prior works [19, 49], we also make use of sparse labels on real data [2, 27], whenever available, to further improve performance on real images.

To our knowledge, our approach is the first data-driven solution to single-image based inverse rendering of an indoor scene. SIRFS [1], which is a classical optimization based method, seems to be the only prior work with similar goals. Compared with SIRFS, as shown in Sec. 5, our method is more robust and accurate. In addition, we also compare with recent DL-based methods that estimate only one of the scene attributes, such as albedo [19, 20, 28, 49], lighting [8], and normals [47]. Both quantitative and qualitative evaluations show that our approach outperforms these single-attribute methods and generalizes better across datasets, which seems to indicate that the self-supervised joint learning of all these scene attributes is helpful.

2 Related Work

Optimization-based approaches.

For inverse rendering from a few images, most traditional optimization-based approaches make strong assumptions about statistical priors on illumination and/or reflectance. A variety of sub-problems have been studied, such as intrinsic image decomposition [39], shape from shading [30, 29], and BRDF estimation [24]. Recently, SIRFS [1] showed it is possible to factorize an image of an object or a scene into surface normals, albedo, and spherical harmonics lighting. In [33] the authors use CNNs to predict the initial depth and then solve inverse rendering with an optimization. From an RGBD video, Zhang et al. [45] proposed an optimization method to obtain reflectance and illumination of an indoor room. These optimization-based methods, although physically grounded, often do not generalize well to real images where those statistical priors are no longer valid.

Learning-based approaches.

With recent advances in deep learning, researchers have proposed to learn data-driven priors to solve some of these inverse problems with CNNs, many of which have achieved promising results. For example, it is shown that depth and normals may be estimated from a single image [6, 7, 50] or multiple images [38]. Parametric BRDF may be estimated either from an RGBD sequence of an object  [25, 15] or for planar surfaces [21]. Lighting may also be estimated from images, either as an environment map [8, 10], or spherical harmonics [48] or point lights [46]. Recent works [36, 32] also performed inverse rendering on faces. Some recent works also jointly learn some of the intrinsic components of an object, like reflectance and illumination [9, 41], reflectance and shape [22], and normal, BRDF, and distant lighting  [34, 23]. Nevertheless, these efforts are mainly limited to objects rather than scenes, and do not model the aforementioned residual appearance effects such as inter-reflection, near-field lighting, and cast shadows present in real images. Concurrently, Yu et. al. [44] proposed an inverse rendering framework for outdoor scenes using multi-view stereo as supervision.

Differentiable Renderer.

A few recent works from the graphics community proposed differentiable Monte Carlo renderers [18, 4] for optimizing rendering parameters (e.g., camera poses, scattering parameters) for synthetic 3D scenes. Neural mesh renderer [13] addressed the problem of differentiable visibility and rasterization. Our proposed RAR is in the same spirit, but its goal is to synthesize the complex appearance effects for inverse rendering on real images, which is significantly more challenging.

Datasets for inverse rendering.

High-quality synthetic data is essential for learning-based inverse rendering. SUNCG [37] created a large-scale 3D indoor scene dataset. The images of the SUNCG dataset are not photo-realistic as they are rendered with OpenGL using diffuse materials and point source lighting. An extension of this dataset, PBRS [47], uses physically based rendering to generate photo-realistic images. However, due to the computational bottleneck in ray-tracing, the rendered images are quite noisy and limited to one lighting condition. There also exist a few real-world datasets with partial labels on geometry, reflectance, or lighting. NYUv2 [27] provides surface normals from indoor scenes. Relative reflectance judgments from humans are provided in the IIW dataset [2] which are used in many intrinsic image decomposition methods. In contrast to these works, we created a large-scale synthetic dataset with significant image quality improvement.

Intrinsic image decomposition.

Intrinsic image decomposition is a sub-problem of inverse rendering, where a single image is decomposed into albedo and shading. Recent methods learn intrinsic image decomposition from labeled synthetic data [17, 26, 34] and from unlabeled [20] or partially labeled real data [49, 19, 28, 2]. Intrinsic image decomposition methods do not explicitly recover geometry or illumination but rather combine them together as shading. In contrast, our goal is to perform a complete inverse rendering which has a wider range of applications in AR/VR.

3 Our Approach

We present a deep learning-based approach for inverse rendering from a single image, which is shown in Fig. 2. Given an input image $I$, our proposed neural Inverse Rendering Network (IRN), denoted as $h_{d}(\cdot;\Theta_{d})$, estimates surface normal $N$, albedo $A$, and environment map $L$:

[TABLE]

Using our synthetic data CG-PBR, we can simply train IRN ($h_{d}(\cdot;\Theta_{d})$ with supervised learning – with only one caveat, i.e. we need to approximate the “ground truth” environment maps (using a separate network $h_{e}(\cdot;\Theta_{e})\rightarrow\hat{L}^{*}$; see Sec. 3.1 for details). To generalize on real images, we use a self-supervised reconstruction loss. Specifically, as shown in Fig. 2, we use two renderers to re-synthesize the input image from the estimations. The direct renderer $f_{d}(\cdot)$ is a simple closed-form shading function with no learnable parameters, which synthesizes the direct illumination part $\hat{I}_{d}$ of the the raytraced image. The Residual Appearance Renderer (RAR), denoted by $f_{r}(\cdot;\Theta_{r})$, is a trainable network module, which learns to synthesize the complex appearance effects $\hat{I_{r}}$:

[TABLE]

The self-supervised reconstruction loss is thus defined as $||I-(\hat{I_{d}}+\hat{I_{r}})||_{1}$. We explain the details of the direct renderer and the RAR in Sec. 3.2.

3.1 Training on Synthetic Data

We first train IRN on our synthetic dataset CG-PBR with supervised learning. As shown in Fig. 2, IRN has a structure similar to [32], which consists of a convolutional encoder, followed by nine residual blocks and a convolutional decoder for estimating albedo and normals. We condition the lighting estimation block on the image, normals and albedo features (see Appendix for details). We use ground truth albedos $A^{*}$ and normals $N^{*}$ from CG-PBR for supervised learning.

The ground truth environmental lighting $L^{*}$ is challenging to obtain, as it is the approximation of the actual surface light field. We use environment maps as the exterior lighting for rendering CG-PBR, but these environment maps cannot be directly set as $L^{*}$, because the virtual cameras are placed inside each of the indoor scenes. Due to occlusions, only a small fraction of the exterior lighting (e.g., through windows and open doors) is directly visible. The surface light field of each scene is mainly due to global illumination (i.e., inter-reflection) and some interior lighting. One could approximate $L^{*}$ by minimizing the difference between the raytraced image $I$ and the output $I_{d}$ of the direct renderer $f_{d}(\cdot)$ with ground truth albedo $A^{*}$ and normal $N^{*}$. However, we found this approximation to be inaccurate, since $f_{d}(\cdot)$ cannot model the residual appearance present in the raytraced image $I$.

We thus resort to a learning-based method to approximate the ground truth lighting $L^{*}$. Specifically, we train a residual block based network, $h_{e}(\cdot;\Theta_{e})$, to predict $\hat{L}^{*}$ from the input image $I$, normals $N^{*}$ and albedo $A^{*}$. We first train $h_{e}(\cdot;\Theta_{e}^{\prime})$ with the images synthesized by the direct renderer $f_{d}(\cdot)$ with ground truth normals, albedo and indoor lighting, $I_{d}=f_{d}(A^{*},N^{*},L)$, where $L$ is randomly sampled from a set of real indoor environment maps. Here the network learns a prior over the distribution of indoor lighting, i.e., $h(I_{d};\Theta_{e}^{\prime})\rightarrow L$. Next, we fine-tune this network $h_{e}(\cdot;\Theta_{e}^{\prime})$ on the raytraced images $I$, by minimizing the reconstruction loss: $\|I-f_{d}(A^{*},N^{*},\hat{L}^{*})\|$. Thus we obtain the approximated ground truth of the environmental lighting $\hat{L}^{*}=h_{e}(I;\Theta_{e})$ which can best reconstruct the raytraced image $I$ modelled by the direct render.

Finally, with all the ground truth components ready, the supervised loss for training IRN is

[TABLE]

where $\lambda_{1}=1$, $\lambda_{2}=1$, and $\lambda_{3}=0.5$.

3.2 RAR: Self-supervised Training on Real Images

Learning from synthetic data alone is not sufficient to perform well on real images. Although CG-PBR was created with physically-based rendering, the variation of objects, materials, and illumination is still limited compared to those in real images. Since obtaining ground truth labels for inverse rendering is almost impossible for real images (especially for reflectance and illumination), we use two key ideas for domain transfer from synthetic to real: (1) self-supervised reconstruction loss and (2) weak supervision from sparse labels.

Previous works on faces [32, 36] and objects [23] have shown success in using a self-supervised reconstruction loss for learning from unlabeled real images. As mentioned earlier, the reconstruction in these prior works is limited to the direct renderer $f_{d}(\cdot)$, which is a simple closed-form shading function (under distant lighting) with no learnable parameters. In this paper, we implement $f_{d}(\cdot)$ simply as

[TABLE]

where $\hat{L}_{i}$ corresponds to the pixels on the environment map $\hat{L}$. While using $f_{d}(\cdot)$ to compute the reconstruction loss may work well for faces [32] or small objects with homogeneous material [23], we found that it fails for inverse rendering of a scene. In order to synthesize the aforementioned residual appearances (e.g., inter-reflection, cast shadows, near-field lighting), we propose to use the differentiable Residual Appearance Renderer (RAR), $f_{r}(\cdot;\Theta_{r})$, which learns to predict a residual image $\hat{I}_{r}$. The self-supervised reconstruction loss is thus defined as $L_{u}=||I-(\hat{I}_{d}+\hat{I}_{r})||_{1}$.

Our goal is to train RAR to capture only the residual appearances but not to correct the artifacts of the direct rendered image due to faulty normals, albedo, and lighting estimation of the IRN. To achieve this goal, we train RAR only on synthetic data with ground-truth normals and albedo, and fix it for training on real data, so that it only learns to correctly predict the residual appearances when the direct renderer reconstruction is accurate. We need realistic synthetic images, which capture complex appearance effects, e.g., cast shadows, inter-reflections etc. for training RAR. Our CG-PBR provides the necessary photo-realism that previous indoor scene datasets [47, 37] lack.

As shown in Fig. 2, RAR consists of a U-Net [31], with normals and albedo as its input, and latent image features ($D=300$ dimension) learned by a convolutional encoder (‘Enc’). We combine the image features at the end of the U-Net encoder and process them with the U-Net decoder to produce the residual image. RAR, along with the direct renderer $f_{d}(\cdot)$, acts like an auto-encoder in principle. RAR learns to encode complex appearance features from the original image into a latent subspace ($D=300$ dimension). The bottleneck of the auto-encoder architecture present in RAR forces it to focus only on the complex appearance features and not in the whole image. So RAR learns to encode the non-direct part of the image to avoid paying a penalty in the reconstruction loss and in principle is simpler than a differentiable renderer. Details of the RAR architecture are presented in the Appendix (Section 8).

As shown in Fig. 4, RAR indeed learns to synthesize complex residual appearance effects present in the original input image. In Sec. 6, we provide quantitative and qualitative ablation studies to show why RAR is crucial in improving albedo and normal estimation. The goal of RAR in this project is to reconstruct an image from its components along with the direct renderer to facilitate self-supervised learning on real images. This helps to significantly improve albedo and normal estimation over state-of-the-art approaches. Our goal is not to develop a differentiable renderer for realistic illumination during object insertion.

Similar to prior work [49, 19], we use sparse labels over reflectance as weak supervision during training on real images. Specifically, we use pair-wise relative reflectance judgments from the Intrinsic Image in the Wild (IIW) dataset [2] as a form of supervision over albedo. We also use supervision over surface normals from NYUv2 dataset [27]. More details are provided in the Appendix (Section 8). As shown in Sec. 6, using such weak supervision can substantially improve performance on real images.

3.3 Training Procedure

We summarize the different stages of training from synthetic to real data. More details are in the Appendix (Section 8).

Estimate GT indoor lighting: (a) First train $h_{e}(\cdot;\Theta_{e}^{\prime})$ on images rendered by the direct renderer $f_{d}(\cdot)$. (b) Fine-tune $h_{e}(\cdot;\Theta_{e})$ on raytraced synthetic images to estimate GT indoor environment map $\hat{L}^{*}$.

Train on synthetic images: (a) Train IRN with supervised L1 loss on albedo, normal and lighting. (b) Train RAR on synthetic data with L1 image reconstruction loss.

Train on real images: Fine-tune IRN on real data with (1) the pseudo-supervision over albedo, normal and lighting (to handle ambiguity of decomposition as proposed in [32]), (2) the self-supervised reconstruction loss $L_{u}$ with RAR, and (3) the weak supervision over the albedo (i.e., pair-wise relative reflectance judgment) or normals.

4 The CG-PBR Dataset

High-quality synthetic datasets are essential for learning-based inverse rendering. The SUNCG dataset [37] contains 45,622 indoor scenes with 2,644 unique objects, but their images are rendered with OpenGL under fixed point light sources. The PBRS dataset [47] extends the SUNCG dataset by using physically based rendering with Mitsuba [11]. Yet, due to a limited computational budget, many rendered images in PBRS are quite noisy. Moreover, the images in PBRS are rendered with only diffuse materials and a single outdoor environment map, which also significantly limits the photo-realism of the rendered images. High-quality photo-realistic images are necessary for training RAR to capture residual appearances.

In this paper, we introduce a new dataset named CG-PBR, which improves data quality in the following ways: (1) The rendering is performed under multiple outdoor environment maps. (2) We render the same scene twice, once with all materials set to Lambertian and once with the default material settings. This offers (diffuse, specular) image pairs which can be useful to the community for learning to remove highlights and many other potential applications. (3) We utilize deep denoising [3], which allows us to raytrace high-quality images from limited samples per pixel. Our dataset consists of 235,893 images with labels related to normal, depth, albedo, Phong [16] model parameters, semantic and glossiness segmentation. Examples are shown in Fig. 3. A comparison with the SUNCG and PBRS datasets is shown in Fig. 5.

5 Experimental Results

Comparison with SIRFS.

SIRFS [1] is an optimization-based method for inverse rendering, which estimates surface normals, albedo and spherical harmonics lighting from a single image. We compare with SIRFS on the test data from the IIW dataset [2]. As shown in Fig. 6, our method produces more accurate normals and better disambiguation of reflectance from shading. This is expected, as we are using deep CNNs, which are known to better learn and utilize statistical priors present in the data than traditional optimization techniques.

Comparison with intrinsic image decomposition algorithms.

Intrinsic image decomposition aims to decompose an image into albedo and shading, which is a sub-problem in inverse rendering. Several recent works [2, 49, 28, 19] showed promising results with deep learning. While our goal is to solve the complete inverse rendering problem, we still compare albedo prediction with these latest intrinsic image decomposition methods. We evaluate the WHDR (Weighted Human Disagreement Rate) metric [2] on the test set of the IIW dataset [2] and report the result in Table 1. As shown, we outperform these algorithms that train on the original IIW dataset [2]. Since our goal is not intrinsic image decomposition, we do not train on additional intrinsic image specific datasets and avoid any post-processing as done in Li et al. [19].

We also present a qualitative comparison of the inferred albedo with Li et al. [19] in Figure 7 (more in Appendix, Sec. 8.4). As shown, our method preserves more detailed texture and has fewer artifacts in the predicted albedo, compared to Li et al. [19]. To further illustrate the effectiveness of our method over Li et al. [19], we also evaluate albedo estimation error (RMSE and MAD) on the synthetic CG-PBR and CGI datasets [19] in Table 2 and qualitatively in Appendix, Sec. 8.4.While our method uses CG-PBR as synthetic data for training, Li et al. [19] uses CGI. Yet we outperform Li et al. [19] on both datasets. Thus our method significantly outperforms all prior intrinsic image decomposition algorithms for albedo estimation.

Evaluation of normal estimation.

We also compare with PBRS [47] which predicts only surface normals from an image. Both PBRS and ‘Ours’ are trained on synthetic data and NYUv2 [27] (real data), and then tested on NYUv2, 7-scenes [35], Scannet [5] and synthetic CG-PBR datasets. In Table 3 we evaluate median angular error over the estimated albedo obtained by PBRS and our approach. Our method significantly outperforms PBRS on Scannet and CG-PBR, while slightly improving on 7-Scenes and doing slightly worse on NYUv2. This suggest that while PBRS overfits on NYUv2, our method shows significantly better generalization across datasets. This is because we are jointly reasoning about all components of the scene. Qualitative comparisons of normals predicted by our method and that of PBRS on Scannet dataset are shown in Fig. 8).

Evaluation of lighting estimation.

We estimate an environment map of low spatial resolution from an image. We compare our estimated environment map with Gardner et al. [8], the only existing method which also estimates a HDR environment map from a single indoor image using CNNs. We present a quantitative evaluation of the estimated environment map on synthetic data in Table 4 (see Section 8.4 for qualitative comparisons). For ‘Env. map error’ we present the Mean Absolute Deviation (MAD) error w.r.t. ‘GT’ (obtained by using $h_{e}(\cdot;\Theta_{e})$, see Sec. 3.1) weighted by solid angle, following  [42]. We also compute MAD ‘Image recon. error’ by using direct renderer $f_{d}(\cdot)$ (‘GT’ has a non-zero image reconstruction error, as it only captures distant-direct illumination.). For evaluating on real data, we collect 20 images of 4 scenes with varying illumination conditions with (also without) a diffuse ball inside the image, which serves as GT, as shown in Fig. 9. We estimate the environment map from the image taken without the diffuse ball using our method and that of Gardner et al. [8]. Then we render the diffuse ball with the estimated environment map and evaluate RMSE and MAD reconstruction error with the GT ball in Table 5. Our method significantly outperforms Gardner et al. [8] in estimating an environment map from a single image.

6 Ablation Study

Role of RAR in self-supervised training.

The goal of RAR is to enable self-supervision on real images by capturing complex appearance effects that cannot be modeled by a direct renderer. RAR, along with the direct renderer, can reconstruct the image from its components, so that it can be used to train with a reconstruction loss. To show the effectiveness of RAR, we train IRN with (a) pseudo-supervision over albedo, normal and lighting (to handle ambiguity of decomposition as proposed in [32]), and (b) weak supervision over normals or albedo, whenever available. Specifically, we train IRN: (i) on IIW with weak-supervision over albedo, with and without RAR; (ii) on NYUv2 with weak-supervision over normals, with and without RAR. Models trained on IIW with supervision over albedo are expected to produce better albedo estimates; models trained on NYUv2 with supervision over normals are expected to produce better normal estimates. We test these models on the CG-PBR and IIW to evaluate albedo and on NYUv2 and Scannet to evaluate normals. We report MAD error for the CG-PBR, the WHDR measure for the real IIW dataset and median angular error for the NYUv2 and Scannet in Table 6. Overall, RAR significantly improves the albedo and normal estimates across different datasets.

We further illustrate the importance of RAR with qualitative evaluations in Figure 10. We train IRN with (‘Ours’) and without RAR (‘w/o RAR’), with weak supervision over either albedo (WHDR loss on IIW for predicting albedo) or normal (L1 loss over normals in NYUv2 for predicting normals). Networks trained with supervision over one component, e.g. normals, are always expected to produce better estimates of that component (normals) than the other (albedo). The normals are significantly improved when we use RAR. As for the albedo, using relative reflectance judgments without RAR produces very low contrast albedo. In the absence of RAR, the reconstruction loss used for self-supervised training cannot capture complex appearance effects, and thus it produces worse estimates of scene attributes.

Role of weak supervision.

To evaluate the influence of weak supervision on inverse rendering, we train IRN with and without weak supervision over albedo (on IIW) and normals (NYUv2), respectively, as shown in Table 7. Weak supervision significantly reduces median angular error on the NYUv2 dataset and the WHDR metric on the IIW dataset. It also makes albedo prediction more consistent across large objects like walls, floors, and ceilings as shown in Fig. 11.

7 Conclusion

We present a learning-based approach for inverse rendering of an indoor scene from a single RGB image. Experimental results show our method outperforms prior works for estimating albedo, normal and lighting, which shows the effectiveness of joint learning. We propose a novel Residual Appearance Renderer (RAR) that can synthesize complex appearance effects such as inter-reflection, cast shadows, near-field illumination, and realistic shading. We show that this renderer is important for employing the self-supervised reconstruction loss to learn inverse rendering on real images. Although the goal of RAR in this paper is to enable self-supervision and improve inverse rendering estimations, we believe it is a good starting point for developing neural renderers that can handle object insertion. We also create a large-scale high-quality synthetic dataset CG-PBR with physically-based rendering, which we believe will be useful to the research community.

Acknowledgment Soumyadip Sengupta and David W. Jacobs are supported by the National Science Foundation under grant no. IIS-1526234.

8 Appendix

In this appendix, we provide more details of our network architecture and the loss functions along with additional qualitative evaluations. Specifically, in Section 8.1 we discuss the details of the IRN and RAR network architectures for reproducibility. Details of our training loss functions on real data are provided in Section 8.2. In Section LABEL:sec:res we present additional qualitative evaluations.

8.1 Network Architectures

8.1.1 IRN

Our proposed Inverse Rendering Network (IRN), shown again in Figure 2 for reference, is trained on real data using the Residual Appearance Renderer (RAR), which learns to capture the complex appearance effects (e.g. inter-reflection, cast shadows, near-field illumination, and realistic shading). In the following, we describe the implementation details of IRN and RAR.

In Figure 12 we present the network architecture of IRN. The input to IRN is an image of spatial resolution $240\times 320$, and the output is an albedo and normal map of same spatial resolution along with a $18\times 36$ resolution environment map. Here we provide the details of the each block in IRN.

‘Enc’: C64(k7) - C128(k3) - C256(k3)

‘CN(kS)’ denotes convolution layers with N $S\times S$ filters with stride 1, followed by Batch Normalization and ReLU. ‘C*N(kS)’ denotes convolution layers with N $S\times S$ filters with stride 2, followed by Batch Normalization and ReLU. The output of ‘Enc’ layer produces a blob of spatial resolution $256\times 60\times 80$.

‘Normal ResBLKs’: 9 ResBLK

This consists of 9 Residual Blocks, ‘ResBLK’s, which operate at a spatial resolution of $256\times 60\times 80$. Each ‘ResBLK’ consists of Conv256(k3) - BN -ReLU - Conv256(k3) - BN, where ‘ConvN(kS)’ and ‘BN’ denote convolution layers with N $S\times S$ filters of stride 1 and Batch Normalization.

‘Albedo ResBLKs’: Same as ‘Normal Residual Blocks’ (weights are not shared).

‘Dec.’: CD128(k3)-CD64(k3)-Co3(k7)

‘CD*N(kS)’ denotes Transposed Convolution layers with N $S\times S$ filters with stride 2, followed by Batch Normalization and ReLU. ‘CN(kS)’ denotes convolution layers with N $S\times S$ filters with stride 1, followed by Batch Normalization and ReLU. The last layer Co3k(7) consists of only convolution layers of 3 $7\times 7$ filters, followed by Tanh layer.

‘Light Est.’: It first concatenates the responses of ‘Enc’, ‘Normal ResBLKs’ and ‘Albedo ResBLKs’ to produce a blob of spatial resolution $768\times 60\times 80$. It is further processed by the following module:

C256(k1) - C256(k3) - C128(k3) - C*3(k3) - BU(18,36)

‘CN(kS)’ denotes convolution layers with N $S\times S$ filters with stride 1, followed by Batch Normalization and ReLU. ‘C*N(kS)’ denotes convolution layers with N $S\times S$ filters with stride 2, followed by Batch Normalization and ReLU. BU(18,36) upsamples the response to produce $18\times 36\times 3$ resolution environment map.

8.1.2 RAR

As shown in Figure 2, Residual Appearance Renderer (RAR) consists of a U-Net architecture and a convolution encoder. The U-Net consists of the following architecture, with normals and albedo as its input:

‘Encoder’: C64(k3) - C64(k3) - C128(k3) - C256(k3) - C512(k3)

‘Decoder’: CU512(k3) - CU256(k3) - CU128(k3) - CU64(k3) - Co3(k1)

‘CN(kS)’ denotes convolution layers with N $S\times S$ filters with stride 1, followed by Batch Normalization and ReLU. ‘CN(kS)’ denotes convolution layers with N $S\times S$ filters with stride 2, followed by Batch Normalization and ReLU. ‘CUN(kS)’ represents a bilinear up-sampling layer , followed by convolution layers with N $S\times S$ filters with stride 1, followed by Batch Normalization and ReLU. ‘Co3(k1)’ consists of 3 $1\times 1$ convolution filters to produce Normal or Albedo. Skip-connections exists between ‘CN(k3)’ layers of encoder and ‘CUN(k3)’ layers of decoder. The encoder ‘Enc’ that encodes image features to a latent $D=300$ dimensional subspace is given by: ‘Enc’: C64(k7) - C128(k3) - C256(k3) - C128(k1) - C64(k3) - C32(k3) - C16(k3) - MLP(300)

‘CN(kS)’ denotes convolution layers with N $S\times S$ filters with stride 1, followed by Batch Normalization and ReLU. ‘C*N(kS)’ denotes convolution layers with N $S\times S$ filters with stride 2, followed by Batch Normalization and ReLU. MLP(300) takes the response of the previous layer and outputs a 300 dimensional feature, which is concatenated with the last layer of the U-Net ‘Encoder’.

8.1.3 Environment Map Estimator

As discussed in Section 3.1 of the main paper, the ground-truth environment map is estimated from the image, ground-truth albedo and normal using a deep network $h_{e}(\cdot,\Theta_{e})$. The detailed architecture of this network is presented below:

C64(k7) - C128(k3) - C256(k3) - 4 ResBLKS - C256(k1) - C256(k3) - C128(k3) - C*3(k3) - BU(18,36),

where, ‘CN(kS)’ denotes convolution layers with N $S\times S$ filters with stride 1, followed by Batch Normalization and ReLU. ‘C*N(kS)’ denotes convolution layers with N $S\times S$ filters with stride 2, followed by Batch Normalization and ReLU. BU(18,36) upsamples the response to produce $18\times 36\times 3$ resolution environment map. Each ‘ResBLK’ contains Conv256(k3) - BN -ReLU - Conv256(k3) - BN, where ‘ConvN(kS)’ denotes convolution layers with N $S\times S$ filters of stride 1, ‘BN’ denoted Batch Normalization.

8.2 Training Details

8.2.1 Training with weak supervision over albedo

IIW dataset presents relative reflectance judgments from humans. For any two points $R_{1}$ and $R_{2}$ on an image, a weighted confidence score classifies $R_{1}$ to be same, brighter or darker than $R_{2}$. We use these labels to construct a hinge loss for sparse supervision based on WHRD metric presented in [2]. Specifically, if users predict $R_{1}$ to be darker than $R_{2}$ with confidence $w_{t}$, we use a loss $w_{t}\max(1+\delta-R_{2}/R_{1},0)$. If $R_{1}$ and $R_{2}$ are predicted to have similar reflectance, we use $w_{t}[\max(R_{1}/R_{2}-1-\delta,0)+\max(R_{2}/R_{1}-1-\delta,0)]$. We observed empirically that this loss function performs better than WHRD metric, which is an L0 version of our loss. We train on real data with the following losses: (i) Psuedo-supervision loss over albedo ($L_{a}$), normal ($L_{n}$) and lighting ($L_{e}$) based on [32], (ii) Photometric Reconstruction loss with RAR ($L_{u}$) (iii) Pair-wise weak supervision ($L_{w}$). Thus the net loss function is defined as:

[TABLE]

8.2.2 Training with weak supervision over normals

We also train on NYUv2 dataset with weak supervision over normals, obtained from Kinect depth data of the scene. We train with the following losses: (i) Psuedo-supervision loss over albedo ($L_{a}$) and lighting ($L_{e}$) based on [32], (ii) Photometric Reconstruction loss with RAR ($L_{u}$) (iii) Supervision ($L_{w}$) over kinect normals. Thus the net loss function is defined as:

[TABLE]

8.3 Our CG-PBR Dataset

We present more example images of our CG-PBRS dataset in Figure 13. We also compare the renderings of our CG-PBR Dataset with that of PBRS [47], under the same illumination condition in Figure 14 and 15. CG-PBR provides more photo-realistic and less noisy images with specular highlights. Both CG-PBR and PBRS is rendered with Mitsuba [11]. We will release the dataset upon publication.

8.4 More Experimental Results

Comparison with SIRFS.

We present more detailed qualitative evaluations in this appendix. In Figure 16 we compare the results of our algorithm with that of SIRFS [1]. SIRFS is an optimization-based method for inverse rendering, which estimates surface normals, albedo and spherical harmonics lighting from a single image. Compared to SIRFS we obtain more accurate normals and better disambiguation of reflectance from shading.

Comparison with Li et al. [19].

In Figure 17 and 18 we compare the albedo predicted by our method with that of Li et al. [19], which performs intrinsic image decomposition of an image, on the real IIW and the synthetic CG-PBR dataset respectively. Intrinsic image decomposition methods do not explicitly recover geometry, illumination or glossiness of the material, but rather combine them together as shading. In contrast, our goal is to perform a complete inverse rendering which has a wider range of applications in AR/VR.

Evaluation of lighting estimation.

In Figure 19 we present a qualitative evaluation of lighting estimation by inserting a diffuse hemisphere into the scene and rendering it with the inferred light from the image. We compare this with the method proposed by Gardner et al. [8], which also estimates an environment map from a single indoor image. $h_{e}(\cdot,\Theta_{e})$ is a deep network that predicts the environment map given the image, normals, and albedo. ‘GT+$h_{e}(\cdot)$’ estimates the environment map given the image, ground-truth normals and albedo, and thus serves as an achievable upper-bound in the quality of the estimated lighting. ‘Ours’ estimates environment map from an image with IRN. ‘Ours+$h_{e}(\cdot)$’ predicts environment map by combining the inferred albedo and normals from IRN to predict lighting with $h_{e}(\cdot)$. Both ‘Ours’ and ‘Ours+$h_{e}(\cdot)$’ outperform Gardner et al. [8] as they seem to produce more realistic environment maps. ‘Ours+$h_{e}(\cdot)$’ improves lighting estimation over ‘Ours’ by utilizing the predicted albedo and normals to a greater degree.

Our Results and Ablation study.

Figure 20 shows examples of our results, with the albedo, normal and lighting predicted by the network, as well as the reconstructed image with the direct renderer and the proposed Residual Appearance Renderer (RAR). In Figure 21 and 22, we perform a detailed ablation study of different components of our method. We show that it is important to train on real data, as networks trained on synthetic data fail to generalize well on real data. We also show that training our method without RAR (‘w/o RAR’) produces piece-wise smooth, low contrast albedo due to over-reliance on the weak supervision of pair-wise relative reflectance judgments. Training our network with only RAR, without any weak supervision (‘w/o weak’), often fails to produce consistent albedo across large objects like walls, floor, ceilings etc. Finally, training without RAR and weak supervision (‘w/o weak + RAR’) produces albedo which contains the complex appearance effects like cast shadows, inter-reflections, highlights etc., as the reconstruction loss with direct renderer alone cannot model these effects.