LookinGood: Enhancing Performance Capture with Real-time Neural Re-Rendering

Introduction

The rise of augmented reality (AR) and virtual reality (VR) has created a demand for high quality 3D content of humans using performance capture rigs. There is a large body of work on offline multiview performance capture systems [Collet et al., 2015; Prada et al., 2017; Carranza et al., 2003]. However, recently, real-time performance capture systems [Dou et al., 2016; Orts-Escolano et al., 2016; Dou et al., 2017; Zollhöfer et al., 2014; Newcombe et al., 2015] have opened-up new use cases for telepresence [Orts-Escolano et al., 2016], augmented videos [Thies et al., 2016; Suwajanakorn et al., 2017] and live performance broadcasting [Intel, 2016]. Despite all of these efforts, the results of performance capture systems still suffer from some combination of distorted geometry [Orts-Escolano et al., 2016], poor texturing and inaccurate lighting, making it difficult to reach the level of quality required in AR and VR applications. Ultimately, this affects the final user experience (see Fig. 2).

An alternative approach consists of using controlled lighting capture stages. The incredible results these systems produce have often been used in Hollywood productions [Debevec et al., 2000; Fyffe and Debevec, 2015]. However these systems are not suitable for real-time scenarios and often the underlying generated geometry is only a rough proxy, rather than an accurate reconstruction. This makes the methods difficult to apply to AR and VR scenarios where geometry and scale play a crucial role.

In this paper, we explore a hybrid direction that first leverages recent advances in real-time performance capture to obtain approximate geometry and texture in real time – acknowledging that the final 2D rendered output of such systems will be low quality due to geometric artifacts, poor texturing and inaccurate lighting. We then leverage recent advances in deep learning to “enhance” the final rendering to achieve higher quality results in real-time. In particular, we use a deep architecture that takes as input the final 2D rendered image from a single or multiview performance capture system, and learns to enhance such imagery in real-time, producing a final high quality re-rendering (see Fig. 1). We call this approach neural re-rendering, and we demonstrate state of the art results within two real-time performance capture systems – one single RGB-D and one multiview.

In summary the paper makes the following contributions:

A novel approach called neural re-rendering that learns to enhance low-quality output from performance capture systems in real-time, where images contain holes, noise, low resolution textures, and color artifacts. As a byproduct we also predict a binary segmentation mask at test-time that isolates the user from the rest of the background.

A method for reducing the overall bandwidth and computation required of such a deep architecture, by forcing the network to learn the mapping from low-resolution input images to high-resolution output renderings. At test time, however, only the low-resolution images are used from the live performance capture system.

A specialized loss function that uses semantic information to produce high quality results on faces. To reduce the effect of outliers we propose a saliency reweighing scheme that focuses the loss on the most relevant regions.

A specialized design for VR and AR headsets, where the goal is to predict two consistent views of the same object.

Temporally stable re-rendering by enforcing consistency between consecutive reconstructed frames.

Exhaustive experiments using two different real-time capture systems: one involving a full 360 multi-view reconstruction of the full body, and another using a single RGB-D sensor for upper body reconstructions.

Related Work

Generating high quality output from textured 3D models is the ultimate goal of many performance capture systems. Here we briefly review methods as follows: image-based approaches, full 3D reconstruction systems and finally learning based solutions.

IBR techniques [Debevec et al., 1996; Gortler et al., 1996] warp a series of input color images to novel viewpoints of a scene using geometry as a proxy. Zitnick et al. expanded these methods to video inputs, where a performance is captured with multiple RGB cameras and proxy depth maps are estimated for every frame in the sequence. This work is limited to a small $30^{\circ}$ coverage, and its quality strongly degrades when the interpolated view is far from the original cameras.

More recent works [Eisemann et al., 2008; Casas et al., 2014; Volino et al., 2014] introduced optical flow methods to IBR, however their accuracy is usually limited by the optical flow quality. Moreover these algorithms are restricted to off-line applications.

Another limitation of IBR techniques is their use of all input images in the rendering stage, making them ill-suited for real-time VR or AR applications as they require transferring all camera streams, together with the proxy geometry. However, IBR techniques have been successfully applied to constrained applications like $360^{\circ}$ degree stereo video [Anderson et al., 2016; Richardt et al., 2013], which produce two separate video panoramas — one for each eye — but are constrained to a single viewpoint.

Two recent works from Microsoft [Collet et al., 2015; Prada et al., 2017] use more than 100 cameras to generate high quality offline volumetric performance capture. Collet et al. used a controlled environment with green screen and carefully adjusted lighting conditions to produce high quality renderings. Their method produces rough point clouds via multi-view stereo, that is then converted into a mesh using Poisson Surface Reconstruction [Kazhdan and Hoppe, 2013]. Based on the current topology of the mesh, a keyframe is selected which is tracked over time to mitigate inconsistencies between frames. The overall processing time is $\sim 28$ minutes per frame. Prada et al. extended the previous work to support texture tracking. These frameworks then deliver high quality volumetric captures at the cost of sacrificing real-time capability.

Recent proposed methods deliver performance capture in real-time [Zollhöfer et al., 2014; Newcombe et al., 2015; Dou et al., 2016; Dou et al., 2017; Orts-Escolano et al., 2016; Du et al., 2018]. Several use single RGB-D sensors to either track a template mesh or reference volume [Zollhöfer et al., 2014; Newcombe et al., 2015; Innmann et al., 2016; Yu et al., 2017]. However, these systems require careful motions and none support high quality texture reconstruction. The systems of Dou et al. and Orts-Escolano et al. use fast correspondence tracking [Wang et al., 2016] to extend the single view non-rigid tracking pipeline proposed by Newcombe et al. to handle topology changes robustly. This method however, suffers from both geometric and texture inconsistency, as demonstrated by Dou et al. and Du et al. .

Even in the latest state of the art work of Dou et al. the reconstruction suffers from geometric holes, noise, and low quality textures. Du et al. extend previous work and propose a real-time texturing method that can be applied on top of the volumetric reconstruction to improve quality further. This is based on a simple Poisson blending scheme, as opposed to offline systems that use a Conditional Random Field (CRF) model [Lempitsky and Ivanov, 2007; Zhou et al., 2005]. The final results are still coarse in terms of texture. Moreover these algorithms require streaming all of the raw input images, which means it does not scale with high resolution input images.

Learning-based solutions to generate high quality renderings have shown very promising results since the groundbreaking work of Dosovitskiy et al. . That work, however, models only a few, explicit object classes, and the final results do not necessary resemble high-quality real objects. Followup work [Kulkarni et al., 2015; Yang et al., 2015; Tatarchenko et al., 2016] use end-to-end encoder-decoder networks to generate novel views of an image starting from a single viewpoint. However, due to the large variability, the results are usually low resolution.

More recent work [Ji et al., 2017; Park et al., 2017; Zhou et al., 2016] employ some notion of 3D geometry in the end-to-end process to deal with the 2D-3D object mapping. For instance, Zhou et al. use an explicit flow that maps pixels from the input image to the output novel view. In Deep View Morphing [Ji et al., 2017] two input images and an explicit rectification stage, that roughly aligns the inputs, are used to generate intermediate views. Park et al. split the problem between visible pixels, i.e. those that can be explicitly copied from the input image, and occluded regions, i.e. areas that need to be inpainted. Another trend explicitly employs multiview stereo in an end-to-end fashion to generate intermediate view of city landscapes [Flynn et al., 2016].

3D shape completion methods [Han et al., 2017; Dai et al., 2017; Riegler et al., 2017] use 3D filters to volumetrically complete 3D shapes. But given the cost of such filters both at training and at test time, these have shown low resolution reconstructions and performance far from real-time. PointProNets [Riccardo et al., 2018] show impressive results for denoising point clouds but again are computationally demanding, and do not consider the problem of texture reconstruction.

The problem we consider is also closely related to the image-to-image translation task [Isola et al., 2016; Chen and Koltun, 2017; Zhu et al., 2017], where the goal is to start from input images from a certain domain and “translate” them into another domain, e.g. from semantic segmentation labels to realistic images. Our scenario is similar, as we transform low quality 3D renderings into higher quality images.

Despite the huge amount of work on the topic, it is still challenging to generate high quality renderings of people in real-time for performance capture. Contrary to previous work, we leverage recent advances in real-time volumetric capture and use these systems as input for our learning based framework to generate high quality, real-time renderings of people performing arbitrary actions.

LookinGood with Neural Re-Rendering

Existing real-time single and multiview performance capture pipelines [Dou et al., 2017; Dou et al., 2016; Orts-Escolano et al., 2016; Newcombe et al., 2015], estimate the geometry and texture map of the scene being captured; this is sufficient to render that textured scene into any arbitrary (virtual) camera. Although extremely compelling, these rendering usually suffer from final artifacts, coarse geometric details, missing data, and relatively coarse textures. Examples of such problems are depicted in Fig. 2. We propose to circumvent all of these limitations using a machine learning framework called neural re-rendering. The instantiation of this machine learning based approach is a new system called LookinGood that demonstrates unprecedented performance capture renderings in real-time.

We focus exclusively on human performance capture and apply the proposed technique to two scenarios: a) a single RGB-D image of a person’s upper body and b) another one where a person’s complete body is captured by a $360^{\circ}$ capture setup. In the following we describe the main components of our approach.

In order to train our system, we placed, into the capture setup, additional ground-truth cameras that can optionally be higher resolution than the ones already in the capture rig. The proposed framework learns to map the low-quality renderings of the 3D model, captured with the rig, to a high-quality rendering at test time.

The idea of casting image denoising, restoration or super-resolution to a regression task has been extensively explored in the past [Schulter et al., 2015; Riegler et al., 2015; Dai et al., 2015; Fanello et al., 2014; Jancsary et al., 2012]. Compared with previous work, the problem at hand is significantly more challenging than the tasks tackled by prior art since it consists of jointly denoising, superresolving, and inpainting. Indeed, the rendered input images can be geometrically imprecise, be noisy, contain holes and be of lower resolution than the targeted output.

Ultimately, our goal is to output a high quality image in real-time given low quality input. A key insight of our approach is the use of extra cameras providing ground truth, that allow for evaluation and training of our proposed neural re-rendering task. To this end, we mount additional “witness” color cameras to the existing capture rigs, that capture higher quality images from different viewpoints. Note that the images captured by the witness cameras are not used in the real-time system, and only used for training.

2. Image Enhancement

Given an image $I$ rendered from a volumetric reconstruction, we want to compute an enhanced version of $I$, that we denote by $I_{e}$.

When defining the transformation function between $I$ and $I_{e}$ we specifically target VR and AR applications. We therefore define the following principles: a) the user typically focuses more on salient features, like faces, and artifacts in those areas should be highly penalized, b) when viewed in stereo, the outputs of the network have to be consistent between left and right pairs to prevent user discomfort, and c) in VR applications, the renderings are composited into the virtual world, requiring accurate segmentation masks. Finally, like in any image synthesis system, we will require our outputs to be temporally consistent.

We define the synthesizing function $F(I)$ to generate a color image $I_{pred}$ and a segmentation mask $M_{pred}$ that indicates foreground pixels such that $I_{e}=I_{pred}\odot M_{pred}$ where $\odot$ is the element-wise product, such that background pixels in $I_{e}$ are set zero. In the rest of this section, we define the training of a neural network that computes $F(I)$.

At training time, we use a state of the art body part semantic segmentation algorithm [Chen et al., 2018] to generate $I_{seg}$, the semantic segmentation of the ground-truth image $I_{gt}$ captured by the witness camera, as illustrated in the right of Fig. 3. To obtain improved segmentation boundaries for the subject, we refine the predictions of this algorithm using the pairwise CRF proposed by Krähenbühl and Koltun .

Note that at test time, this semantic segmentation is not required. However, our network does predict a binary segmentation mask as a biproduct, which can be useful for AR/VR rendering.

To optimize for $F(I)$, we train a neural network to optimize the loss function

where the weights $w_{i}$ are empirically chosen such that all the losses provide a similar contribution.

The mask loss $\mathcal{L}_{mask}$ encourages the model to predict an accurate foreground mask $M_{pred}$. This can be seen as a binary classification task. For foreground pixels we assign the value $y^{+}=1$, whereas for background pixels we use $y^{-}=0$. The final loss is defined as

The head loss focuses the network on the head to improve the overall sharpness of the face. Similar to the body loss, we use VGG16 to compute the loss in the feature space. In particular, we define the crop $I^{C}$ for an image $I$ as a patch cropped around the head pixels as given by the segmentation labels of $I_{seg}$ and resized to $512\times 512$ pixels. We then compute the loss as

For an illustration of the head loss, please see Fig. 4, third row.

To minimize the amount of flickering between two consecutive frames, we design a temporal loss between a frame $I^{t}$ and $I^{t-1}$. A simple loss minimizing the difference between $I^{t}$ and $I^{t-1}$ would produce temporally blurred results, and thus we use a loss that tries to match the temporal gradient of the predicted sequence, i.e. $I_{pred}^{t}-I_{pred}^{t-1}$, with the temporal gradient of the ground truth sequence, i.e. $I_{gt}^{t}-I_{gt}^{t-1}$. In particular, the loss is computed as

Although recurrent architectures [Jain and Medsker, 1999] have been proposed in the past to capture long range dependencies in temporal sequences, we found our non-recurrent architecture coupled with the temporal loss was able to produce temporally consistent outputs, with the added advantage of reduced inference time. Another viable alternative consists of using optical flow methods to track correspondences between consecutive frames in the predicted images as well as in the groundtruth ones. The norm between these two motion fields can be used as a temporal loss. However this is bound to the quality of the flow method, and requires additional computation during the training. The proposed approach, instead, does not depend on perfect correspondences and works well for the purpose, i.e. to minimize the temporal flicker between frames. Please see Fig. 4, fifth row, for an example that illustrates the computed temporal loss.

The stereo loss is specifically designed for VR and AR applications, when the network is applied on the left and right eye views. In this case, inconsistencies between both eyes might limit depth perception and result in discomfort for the user. One possible solution is to employ a second stereo “witness” camera placed at interpupillary distance with respect to the first one.

However, this might be unpractical due to bandwidth constraints. Therefore we propose an approach for those scenarios where such a stereo ground-truth is not available by proposing a loss that ensures self-supervised consistency in the output stereo images.

In particular, we render a stereo pair of the volumetric reconstruction and set each eye’s image as input to the network, where the left image $I^{L}$ matches ground-truth camera viewpoint and the right image $I^{R}$ is rendered at $65$ mm along the x-coordinate. The right prediction $I_{pred}^{R}$ is then warped to the left viewpoint using the (known) geometry of the mesh and compared to the left prediction $I_{pred}^{R}$. We define a warp operator $I_{warp}$ using the Spatial Transformer Network (STN) [Jaderberg et al., 2015], which uses a bi-linear interpolation of $4$ pixels and fixed warp coordinates. We finally compute the loss as

Please see the fourth row of Fig 4 for examples that illustrate the stereo loss.

Saliency Re-weighing for Outlier Rejection.

where $\Gamma(i,\mathbf{y})$ extracts the $i$’th percentile across the set of values in $\mathbf{y}$ and $p_{min}$, $p_{max}$, $\alpha_{i}$ are empirically chosen and depend on the task at hand (see Section 3.4). We apply this saliency as a weight on each pixel of the residual $\mathbf{y}$ computed for $\mathcal{L}_{rec}$ and $\mathcal{L}_{head}$ as:

where $\odot$ is the elementwise product.

Note that the we do not compute gradients with respect to the re-weighing function, and thus it does not need to be continuous for SGD to work. We experimented with a more complex, continuous formulation of $\Upsilon_{p}(\mathbf{y})$ defined by the product of a sigmoid and an inverted sigmoid, and obtained similar results.

The effect of saliency reweighing is shown in the bottom row of Fig. 4. Notice how the reconstruction error is along the boundary of the subject when no the saliency re-weighing is used. Conversely, the application of the proposed outlier removal technique forces the network to focus on reconstructing the actual subject. Finally, as byproduct of the saliency re-weighing we also predict a cleaner foreground mask, compared to the one obtained with the semantic segmentation algorithm used. Note that the saliency re-weighing scheme is only applied to the reconstruction, mask and head losses.

3. Deep Architecture

Our choice of the architecture is guided by two specific requirements: 1) the ability to perform inference in real-time 2) and effectiveness in the described scenario. Based on these requirements we resort to a U-NET like architecture [Ronneberger et al., 2015]. This model has shown impressive results in challenging novel viewpoint synthesis from 2D images problems [Park et al., 2017] and, moreover, can be run in real-time on high-end GPUs architectures.

As opposed to the original system, we resort to a fully convolutional model (i.e. no max pooling operators). Additionally, since it has been recently showed that deconvolutions can result in checkerboard artifacts [Odena et al., 2016], we employed bilinear upsampling and convolutions instead. The overall framework is shown in Fig. 5.

In more detail, our U-NET variation has a total of $18$ layers ($9$ encoding and $9$ decoding), with skip connections between the encoder and decoder blocks. The encoder begins with an initial $3\times 3$ convolution with $N_{init}$ filters followed by a sequence of four “downsampling blocks”. Each such block $i\in\{1,2,3,4\}$ consists of two convolutional layers each with $N_{i}$ filters. The first of these layers has a filter size $4\times 4$, stride $2$ and padding $1$, whereas the second has a filter size of $3\times 3$ and stride $1$. Thus, each of the four block reduces the size of the input by a factor of $2$ due to the strided convolution. Finally, two dimensionality preserving convolutions are performed (see far-right of Fig. 5). In all cases, the outputs of the convolutions are implicitly assumed to immediately pass through a ReLU activation function. Unless noted otherwise, we set $N_{init}=32$ and $N_{i}=G^{i}\cdot N_{init}$, where $G$ is the filter size growth factor after each downsampling block.

The decoder consists first of four “upsampling blocks” that mirror the “downsampling blocks” but in reverse. Each such block $i\in\{4,3,2,1\}$ consists of two convolutional layers. The first layer bilinearly upsamples its input, performs a convolution with $N_{i}$ filters, and leverages a skip connection to concatenate the output with that of its mirrored encoding layer. The second layer simply performs a convolution using $2N_{i}$ filters of size $3\times 3$. Optionally, we add more upsampling blocks to produce images at a higher resolution than the input.

The final network output is produced by a final convolution with $4$ filters, whose output is, as per usual, passed through a ReLU activation function to produce the reconstructed image and a single channel binary mask of the foreground subject.

When our goal is to produce stereo images for VR and AR headsets, we simply run both left and right viewpoints using the same network (with shared weights). The final output is an improved stereo output pair.

4. Training Details

We train the network using Adam [Kingma and Ba, 2014] and weight decay [Golub et al., 1999] until convergence (i.e. until the point where we no longer consistently observe drops in our losses). This was typically around 3 millions iterations for us. Training with Tensorflow on $16$ NVIDIA V100 GPUs with a batch size of 1 per GPU takes 55 hours.

The percentile ranges for the saliency re-weighing are empirically set to remove the contribution of the imperfect mask boundary and other outliers without affecting the result otherwise. We set $p_{max}=98$, and found that setting $p_{min}$ to values in $$was acceptable, ultimately choosing$p_{min}=50$for the reconstruction loss and$p_{min}=25$for the head loss. We finally set both$\alpha_{1}=\alpha_{2}=1.1$.

Evaluation

In this section we evaluate our system on two different datasets: one for single camera (upper body reconstruction) and one for multi view, full body capture.

The single camera dataset comprises 42 participant of which 32 are used for training. For each participant, we captured four 10 second sequences, where they a) dictate a short text, with and without eyeglasses, b) look in all directions, and c) gesticulate extremely.

For the full body capture data, we recorded a diverse set of $20$ participants. Each performer was free to perform any arbitrary movement in the capture space (e.g. walking, jogging, dancing, etc.) while simultaneously performing facial movements and expressions. For each subject we recorded $10$ sequences of $500$ frames.

We left $5$ subjects out from the training datasets to assess the performances of the algorithm on unseen people. Moreover, for some participants in the training set we left $1$ sequence (i.e. $500$ or $600$ frames) out for testing purposes.

A core component of our framework is a volumetric capture system that can generate approximate textured geometry and render the result from any arbitrary viewpoint in real-time. For upper bodies, we leverage a high quality implementation of a standard rigid-fusion pipeline. For full bodies, we use a non-rigid fusion setup similar to Dou et al. , where multiple cameras provide a full $360^{\circ}$ coverage of the performer.

The upper body capture setting uses a single $1500\times 1100$ active stereo camera paired with a $1600\times 1200$ RGB view. To generate high quality geometry, we use a newly proposed method [Nover et al., 2018] that extends PatchMatch Stereo [Bleyer et al., 2011] to spacetime matching, and produces depth images at 60Hz. We compute meshes by applying volumetric fusion [Curless and Levoy, 1996] and texture map the mesh with the color image as shown in Fig. 1 (top row).

In the upper body capture scenario, we mount a single camera at a $25^{\circ}$ degree angle to the side from where the subject is looking at at, of the same resolution as the capture camera. See Fig. 3, top row, for an example of input/output pair.

Full Body Capture (Multi View).

For full body volumetric capture we implemented a system like the Motion2Fusion framework [Dou et al., 2017]. Following the original paper, we placed $16$ IR cameras and $8$ ‘low’ resolution ($1280\times 1024$) RGB cameras as to surround the user to be captured. The 16 IR cameras are built as 8 stereo pairs together with an active illuminator as to simplify the stereo matching problem (see Fig. 6 top right image for a breakdown of the hardware). We leverage fast, state of art disparity estimation algorithms [Fanello et al., 2016, 2017a, 2017b; Kowdle et al., 2018; Tankovich et al., 2018] to estimate accurate depth. The non-rigid tracking pipeline follows the method of Dou et al. . All the stages of the pipeline are performed in real-time. The output of the system consists of temporally consistent meshes and per-frame texture maps. In Fig. 6, we show the overall capture system and some results obtained.

In the full body capture rig, we mounted $8$ ‘high’ resolution ($4096\times 2048$) witness camerasAlthough our witness cameras resolution is $4096\times 2048$ this does not fit in memory during the training, therefore we downsample the images to $2048\times 1024$. (see Fig. 6, top left image). Examples of training examples are shown in Fig. 3, bottom.

Note that both studied capture setups span a large number of use cases. The single-view capture rig does not allow for large viewpoint changes, but might be more practical, as it requires less processing and only needs to transmit a single RGBD stream, while the multi-view capture rig is limited to studio-type captures, but allows for complete free viewpoint video experiences.

Experiments and Metrics.

Many more results, comparisons and evaluations can be seen in the supplementary video (http://youtu.be/Md3tdAKoLGU). Note that all results shown in the paper and in the supplementary video are on test sequences that are not part of the training set.

2. Qualitative Results

Here we show qualitative results on different test sequences and under different conditions.

In the single camera case, the network has to learn mostly to in-paint missing areas and fix missing fine geometry details such as eyeglasses frames. We show some results in Fig. 7, top two rows. Notice how the method preserves the high quality details that are already in the input image and is able to in-paint plausible texture for those unseen regions. Further, thin structures such as the eyeglass frames get reconstructed in the network output. Note, that no super-resolution effects are observed, as the witness camera in the single view setup is of similar effective resolution than of the capture camera.

Full Body Results (Multi View).

The multi view case carries the additional complexity of blending together different images that may have different lighting conditions or have small calibration imprecisions. This affects the final rendering results as shown in Fig. 7, bottom two rows. Notice how the input images have not only distorted geometry, but also color artifacts. Our system learns how to generate high quality renderings with reduced artifacts, while at the same time adjusting the color balance to the one of the witness cameras.

Viewpoint Robustness.

Although our groundtruth viewpoints are limited to a sparse set of cameras, in this section we demonstrate that the system is also robust to unseen camera poses. We implemented this by simulating a camera trajectory around the subject and show the results in Fig. 8. More examples can be seen in the supplementary video.

Super-resolution.

Our model is able to produce more details compared to the input images. Results can be appreciated in Fig. 9, where the predicted output at the same input resolution contains more subtle details like facial hair. Increasing the output resolution by a factor of $2$ leads to slightly sharper results and better up-sampling especially around the edges.

Generalization: People, Clothing.

Generalization across different subjects are shown in Fig. 10. For the single view case, we did not observe any substantial degradation in the results. For the full body case, although there is still a substantial improvement from the input image, the final results look less sharp. We believe that more diverse training data is needed to achieve better generalization performance on unseen participants.

We also assessed the behavior of the system with different clothes or accessories. We show in Fig. 11 examples of such situations: a subject wearing different clothes, and another with and without eyeglasses. The system correctly recovers most of the eyeglasses frame structure even though they are barely reconstructed by the traditional geometrical approach due to their fine structures.

3. Ablation Study

We now show the importance of the different components of the method. The main quantitative results are summarized in Table 1, where we computed multiple statistics for the proposed model and all its variants. In the following we comment on the findings.

The segmentation mask plays an important role in in-painting missing parts, discarding the background and preserving input regions. As shown in Fig. 12, the model without the foreground mask hallucinates parts of the background and does not correctly follow the silhouette of the subject. This behavior is also confirmed in the quantitative results in Table 1, where the model without the $\mathcal{L}_{mask}$ performs worse compared to the proposed model.

Head Loss.

The loss on the cropped head regions encourages sharper results on faces. Previous studies [Orts-Escolano et al., 2016] found that artifacts in the face region are more likely to disturb the viewer. We found the proposed loss to greatly improve this region. Although the numbers in Table 1 are comparable, there is a huge visual gap between the two losses, as shown in Fig. 13. Notice how without head loss the results are oversmoothed and facial details are lost. Whereas the proposed loss not only upgrades the quality of the input, but it also recovers unseen features.

Temporal and Stereo Consistency.

Stable results across multiple viewpoints have already been shown in Fig. 8. The metrics in Table 1 show that removing temporal and stereo consistency from the optimization sometimes may outperform the model trained with the full loss function. However, this is somehow expected since the metrics used do not take into account important factors such as temporal and spatial flickering. The effects of the temporal and stereo loss are visualized in Fig. 14.

Saliency Reweighing.

The saliency reweighing reduces the effect of outliers as shown in Fig. 4. This can also be appreciated in all the metrics in Table 1: indeed the models trained without the saliency reweighing perform consistently worse. Figure 15 shows how the model trained with the saliency reweighing is more robust to outliers in the groundtruth mask.

Model Size.

We also assess the importance of the model size. We trained three different networks, starting with $N_{init}=16,32,64$ filters respectively. In Fig. 16 we show qualitative examples of the three different model. As expected, the biggest network achieves the better and sharper results on this task, showing that the capacity of the other two architectures is limited for this problem.

Real-time Free Viewpoint Neural Re-Rendering

We implemented a real-time demonstration of the system, as shown in Fig. 17. The scenario consists of a user wearing a VR headset watching volumetric reconstructions. We render left and right views with the head pose given by the headset and feed them as input to the network. The network generates the enhanced re-renderings that are then shown in the headset display.

Latency is an important factor when dealing with real-time experiences. Instead of running the neural re-rendering sequentially with the actual display update, we implemented a late stage reprojection phase [Van Waveren, 2016; Evangelakos and Mara, 2016]. In particular, we keep the computational stream of the network decoupled from the actual rendering, and use the current head pose to warp the final images accordingly.

We assessed the run-time of the system using a single NVIDIA Titan V. We considered the model with $N_{init}=32$ filters where input and output are generated at the same resolution ($512\times 1024$). Using the standard TensorFlow graph export tool, the average running time to produce a stereo pair with our neural re-rendering is around $92$ms, which is not sufficient for real-time applications. Therefore we leveraged NVIDIA TensorRT, which performs inference optimization for a given deep architecture. Thanks to this tool, a standard export with $32$bits floating point weight brings the computational time down to $47$ms. Finally, we exploited the optimizations implemented on the NVIDIA Titan V, and quantize the network weights using 16-bit floating point. This allows us reaching the final run-time of $29$ms per stereo pair, with no loss in accuracy, hitting the real-time requirements.

We also profiled each block of the network to find potential bottlenecks. We report the analysis in Fig. 18. The encoder phase needs less than $40\%$ of the total computational resources. As expected, most of the time is spent in the decoder layers, where the skip connections (i.e. the concatenation of encoder features with the matched decoder), leads to large convolution kernels. Possible future work consists of replacing the concatenation of the skip connections with sum, which would reduce the features size.

2. User Study

We performed a small qualitative user study on the results of the output system, following an approach similar to [Shan et al., 2013]. We recruited $10$ subjects and prepared $12$ short video sequences showing the renderings of the capture system, the predicted results and the target witness views (masked with the semantic segmentation as described in Section 3.2). The order of the videos was randomized and we selected sequences containing both seen subjects and unseen subjects.

We asked the participants whether they preferred the renders of the performance capture system (i.e. the input to our algorithm), the re-rendered versions using neural re-rendering, or the masked ground truth image, i.e. $M_{gt}\odot I_{gt}$. Not surprisingly, $100\%$ of the users agreed that the output of the neural re-rendering was better compared to the renderings from the volumetric capture systems. Also, the users did not seem to notice substantial differences between seen and unseen subjects. Unexpectedly, $65\%$ of the subjects preferred the output of our system even compared to the groundtruth: indeed the participants found the predicted masks using our network to be more stable than the groundtruth masks used for training, which suffers from more inconsistent predictions between consecutive frames. However all the subjects agreed that groundtruth is still sharper, therefore higher resolution than the neural re-rendering output, and more must be done in this direction to improve the overall quality.

Discussion, Limitations and Future Work

We presented “LookinGood”, the first system that uses machine learning to enhance volumetric videos in real-time. We carefully combined geometric non-rigid reconstruction pipelines, such as [Dou et al., 2017], with recent advances in deep learning, to produce higher quality outputs. We designed our system to focus on people’s faces, discarding non-relevant information such as the background. We proposed a simple and effective solution to produce temporally stable renderings and devoted particular attention to VR and AR applications, where left and right views must be consistent for an optimal user experience.

We found the main limitation of the system to be the lack of training data. Indeed, whereas unseen sequences of known subjects still produce very high quality results, we noticed a graceful degradation of the quality when the participant was not in the dataset (see Fig. 10). When the input is very partially corrupted, the model hallucinates blurry results, as shown in Fig. 19, top row. In addition, missing parts are sometimes oversmoothed. Although a viable solution consists of acquiring more training examples, we prefer to focus our future efforts on more intelligent deep architectures. We will, for instance, reduce the capture infrastructure by leveraging recent deep architectures for accurate geometry estimation [Khamis et al., 2018; Zhang et al., 2018]; furthermore, we will introduce a calibration phase where a new user will be able to quickly personalize the system for better run-time performance and accuracy. Finally, by leveraging semantic information, such as pose estimation and tracking [Joo et al., 2018], we will make the problem even more tractable when multi-view rigs are not available.

References