DIG3D: Marrying Gaussian Splatting with Deformable Transformer for Single Image 3D Reconstruction
Jiamin Wu Kenkun Liu Han Gao Xiaoke Jiang Lei Zhang

Phonon dispersion of quantum paraelectric  in electric fields
    Urs Staub
    April 29, 2024
=============================================================




    In this paper, we study the problem of 3D reconstruction from a single-view RGB image and propose a novel approach called DIG3D for 3D object reconstruction and novel view synthesis. Our method utilizes an encoder-decoder framework which generates 3D Gaussians in decoder with the guidance of depth-aware image features from encoder. In particular, we introduce the use of deformable transformer, allowing efficient and effective decoding through 3D reference point and multi-layer refinement adaptations. By harnessing the benefits of 3D Gaussians, our approach offers an efficient and accurate solution for 3D reconstruction from single-view images. We evaluate our method on the ShapeNet SRN dataset, getting PSNR of 24.21 and 24.98 in car and chair dataset, respectively. The result outperforming the recent method by around 2.25%, demonstrating the effectiveness of our method in achieving superior results.
    



§ INTRODUCTION




3D reconstruction from a single-view RGB image is a challenging ill-posed problem in computer vision <cit.>.  Neural Radiance Field (NeRF) based methods <cit.> have made significant progress in this task by regressing volume density and view-dependent RGB color from spatial coordinates and viewing directions. 

Recent advancements have focused on tackling these challenges by employing NeRF-based networks trained solely on RGB data. The training process involves minimizing the image RGB loss between the ground truth image and the image rendered through volume rendering using sampled NeRF points <cit.>. 

However, NeRF's implicit representation introduces challenges in terms of computational inefficiency and reliance on sampling algorithms, which restricted their further applications. 





To address these challenges, 3D Gaussian splatting <cit.> is employed in the 3D reconstruction task as a faster alternative to NeRF. Instead of representing 3D objects implicitly by a neural network, 3D Gaussian splatting utilizes explicit 3D Gaussian ellipsoids to represent objects and extends point-based rendering methods to obtain rendered views <cit.>. With the help of explicit 3D representation and efficient point rendering, it provides a solution to avoiding the heavy sampling in NeRF but remains the advantage that only 2D supervision is required.
By combining diffusion methods with Gaussian splatting rendering, <cit.> achieve comparable 3D reconstruction results to previous state-of-the-art methods such as <cit.>, while significantly improving the generation speed. However, diffusion-based models still require more than one minute to obtain a 3D representation due to multiple denoising steps in the inference process. 













By contrast, non-generation-based models only require a single forward pass during inference, making them extremely fast. For instance, Splatter Image <cit.> simply uses UNet <cit.> on the input image and obtains the parameters of 3D Gaussians for each pixel <cit.>. The approach yields comparable results to previous single image 3D reconstruction baselines on the ShapeNet SRN  benchmark <cit.>, but achieves a significantly high speed of 38 FPS from a image to a 3D object and 588 FPS for rendering. Although <cit.> makes a significant attempt at utilizing 3D Gaussian splatting in the single view 3D reconstruction task, the method still has some limitations. 







As illustrated in Figure <ref>(c), the Splatter Image method achieves good Peak Signal-to-Noise Ratio (PSNR) for views close to the input view, but performs poorly for views that are far from the input view. One possible explanation for this behavior is that the method attempts to align each 3D Gaussian with every pixel of the input view, resulting in a bias towards views far from the input view.
Moreover, this per-pixel regression approach leads to a concentration of a majority of the 3D Gaussians in a single plane, as depicted in Figure <ref>(b). These background points contribute marginally to the 3D object, resulting in incorrect geometry and wasteful rendering time.
The incorrect geometry generated by Splatter Image can be attributed to obtaining 3D Gaussians through UNet with convolution, which introduces unwanted grid structures aligned to each pixel of the input image. 
Examining the three views in Figure <ref>(b), it is evident that the object's geometry is attempting to match the pixels of the input view, resulting in obvious inaccuracies and a significant waste of 3D Gaussians. Moreover, the wrong geometry also limits the feasibility of applications such as converting 3D Gaussian distributions into point cloud representations or surface reconstruction <cit.>.














To address the limitations of per-pixel regression, we propose a novel approach, named DIG3D, which marries gaussian splatting with deformable transformer for single image 3D object reconstructing.
In contrast to the local relationships captured by UNet, we leverage a transformer-based model that allows all pixels to contribute to the 3D Gaussian reconstruction. Transformer models, such as DETR (Detection Transformer) <cit.> and its variants <cit.>, have demonstrated remarkable performance in tasks involving position and property extraction from image features, including object detection and point tracing.
Our task involves regressing the position and properties of 3D Gaussian ellipsoids, which shares similarities with DETR and its follow-ups, as they decode the position and size of bounding boxes from image features.
To implement our approach, we initially employ a similar encoder structure as presented in <cit.> to obtain pixel-aligned features. We supervise this encoder with the input view to ensure that the extracted features facilitate accurate rendering of the input view. Additionally, we utilize a pretrained DINOv2 <cit.> model to extract depth-aware features, which helps resolve depth ambiguity in single-view images. We then design a hierarchical feature fusion block to fuse these two types of features.
Next, we adapt the decoder of DETR to our 3D reconstruction task, where our objective is to decode the position and properties of 3D Gaussians. Specifically, we treat the 3D Gaussians as queries and iteratively update them with guidance from the image features.
As demonstrated in Figure <ref>(c), our method outperforms <cit.>, particularly for views that are far from the input view. Notably, our approach achieves a significantly improved 3D geometry reconstruction as shown in Figure <ref>(b), yielding correct geometries in most cases.




While the deformable attention mechanism in DETR offers a simple yet effective approach for decoding 3D Gaussians from input images, there is a challenge that needs to be addressed. In the detection task in DETR, the regression target is a 2D bounding box, which is not directly applicable to efficiently utilize the 3D nature of Gaussians. To overcome this challenge, we make two key adaptations to the DETR framework for handling 3D Gaussians.
Firstly, we project the center of each 3D Gaussian onto the image plane, treating it as a reference point. This projection is crucial for selecting the most relevant features for the corresponding anchors. 
Secondly, we update the parameters in the multi-layer refinement process for 3D Gaussians using specific operations. For the rotation parameter, we employ multiplication to update its value, allowing for more accurate representation of the rotational aspect of the Gaussians. For the other parameters, such as position and size, we use addition to update their values.
By incorporating these adaptations into the DETR framework, we can address the challenges posed by working with 3D Gaussians, allowing for more efficient and accurate reconstruction of the object geometry.  






Our contributions can be summarized as follows:



  * We introduce DIG3D, a straightforward and efficient approach for 3D reconstruction and novel view synthesis from a single RGB image.

  * We present a novel encoder-decoder framework that regards 3D Gaussians as queries with depth-aware image features as guidance. This structure solves the conflict between novel views and input view pixel alignment in <cit.>.

  * We adapt deformable transformer utilized in 2D detection to 3D reconstruction task. We develop a 3D reference point projection technique on the image feature map and apply multilayer refinement on 3D Gaussian parameters.

  * We conduct experiments on ShapeNet SRN benchmark <cit.> to demonstrate the effectiveness of our method.














§ RELATED WORK



  
3D Representations
Implicit functions such as Neural Radiance Field (NeRF) have found wide application in 3D reconstruction tasks <cit.>. By leveraging rendering methods, the implicitly reconstructed objects can be rendered in specified views and the optimization only requires
2D supervision. NeRF represents a scene as a 5D function that outputs the radiance emitted in each direction at each point. The color of each pixel in the image can be rendered by integrating the points along the ray that passes through the pixel. NeRF enables high-fidelity rendering, making 3D tasks feasible with only 2D supervision. However, since all NeRF parameters are implicitly represented, optimizing NeRF can be time-consuming. Despite efforts made to accelerate NeRF <cit.>, the implicit representation remains slow and heavily relies on the quality of sampling algorithms. 


Recently, 3D Gaussian splatting <cit.> has introduced a new approach for representing objects in 3D. Compared to NeRF, it extends the point-based rendering method and can be easily applied as a differentiable rendering method for 3D reconstruction tasks with only 2D supervision. Furthermore, 3D Gaussian splatting explicitly represents 3D objects as 3D Gaussian ellipsoids. This eliminates the need for sampling methods and significantly speeds up the optimization process without performance degradation.







  
3D Reconstruction from Single-view Image
Due to the good accessibility of single-view images, there is also a stream of methods <cit.> exploring reconstructing objects from only a single-view image. <cit.> adapt the original NeRF from a per-scene optimization manner to a feed-forward manner, enabling the learning of object priors with large-scale data for training. As it utilizes the NeRF representation and volume rendering, the whole pipeline is still time-consuming. After 3D Gaussian splatting <cit.> was proposed, <cit.> introduce a fast approach for 3D reconstruction, achieving real-time rendering. However, their per-pixel regression design often leads to wrong object geometry and does harm to the novel view synthesis.



  
Deformable Transformer


The Detection Transformer has gained significant popularity in detection tasks <cit.>. This architecture employs a transformer-based encoder-decoder framework, where the encoder captures global contextual information using self-attention mechanisms, and the decoder generates a sequence of object queries. These queries are then utilized to regress the position, width, and height of bounding boxes, similar to our task of regressing the position and properties of 3D Gaussians. Subsequent works, such as Deformable DETR <cit.>, introduced deformable attention mechanisms to handle object deformations, while Cascade DETR employed a cascaded architecture for progressive refinement. Furthermore, <cit.> extended the structure to open-set detection by incorporating text embeddings, and <cit.> applied it to point tracing in video tasks. These follow-up works have expanded the applications of deformable attention beyond detection, showcasing its versatility in various computer vision domains.
















§ METHODS



In this section, we introduce our proposed DIG3D for 3D reconstruction from a single-view image. We begin by providing the necessary preliminaries for 3D Gaussian Splatting, as detailed in Section <ref>. Next, we introduce the formulation of the 3D reconstruction and novel view synthesis tasks using 3D Gaussian splatting in Section <ref>. 


In Section <ref>, we describe how we extract depth-aware image features in the encoder and iteratively update the pixel-free 3D Gaussians within the deformable transformer. Next, in Section <ref>, we show the adaption of our 3D Gaussians to deformable transformer. Finally, we discuss the training objective in Section <ref>.






 §.§ Prelimenaries of 3D Gaussian Splatting
 

We represent a 3D object using 3D Gaussian ellipsoids, characterized by their geometric and appearance parameters. The position and shape of an ellipsoid are determined by the mean vector μ and the covariance matrix Σ of its corresponding 3D Gaussian distribution <cit.>.
Directly optimizing the covariance matrix can result
in a non-positive semi-definite matrix <cit.>. Therefore, the covariance matrix can be optimized through a combination of rotation and scaling for each ellipsoid. This is achieved by expressing the covariance matrix as Σ = 𝐑𝐒𝐒^T𝐑^T, where 𝐑 represents the rotation and 𝐒 contains the scales in three directions. The rotation is typically parameterized using quaternions, providing an efficient and effective way to represent the orientation of the ellipsoid. 




In addition to position and shape, the 3D Gaussian is also parameterized by its opacity σ, which represents the likelihood of a light ray being blocked by the ellipsoid <cit.>. When multiple 3D Gaussians lie along the same light ray, the final color of a pixel is calculated using α-blending <cit.> as shown below.
In the context of 3D Gaussian splatting, which can be viewed as an extension of point-based rendering methods <cit.>, the color of a pixel 𝐩 on the image plane can be rendered using point-based rendering techniques. The color C(𝐩) at pixel 𝐩 can be expressed using the following equation:


    C(𝐩)     = ∑_n ∈ Nc_nα_n∏_j=1^n-1(1-α_j), 
    α_n     = σ_ne^1/2(𝐩-μ_n)^TΣ_n^-1(𝐩-μ_n)


where N denotes the number of 3D Gaussians utilized to represent the 3D object. c_n, σ_n,μ_n, Σ_n denotes the color, opacity, center, and covariance matrix of the n-th Gaussian.

When it comes to color representation in the Gaussian Splatting, using a simple RGB value is insufficient due to the fact that a 3D Gaussian ellipsoid represents more than just a single point. Instead, Spherical Harmonics (SH) <cit.> are employed to represent the view-dependent appearance of each ellipsoid. This approach allows for a more accurate and comprehensive representation of the color information associated with each 3D Gaussian ellipsoid. 




 §.§ Problem Formulation
 


We formulate the problem of single view 3D reconstruction as learning a mapping from single view images to 3D Gaussian parameters. Specifically, given a set of multi-view RGB images denoted as 𝒟 = {I_oj, π_oj| o=1, ..., O; j=1, ..., J}, where I_oj∈ℝ^H× W × 3 represents the j-th image of the object o with dimensions H and W, and π_oj represents the camera pose for image I_oj, we aim to learn a mapping 𝒢_Φ that maps a given input image I_oj to a 3D object represented by N 3D Gaussians {G_n | n=1, ... N}. In other words, we want to obtain θ_o = 𝒢_Φ(I_oj), where θ_o = (μ_n, σ_n, S_n, R_n, SH_n), n = 1, ..., N. Each 3D Gaussian consists of parameters including the center μ, opacity σ, covariance matrix Σ and spherical harmonic coefficients SH. Notably, instead of directly regressing the 3D coordinates of the center μ, we regress the depth d and offset values (Δ_x, Δ_y, Δ_z). This choice simplifies the regression process and aids convergence (refer to Section <ref> for more details). The Gaussian shape parameter Σ can be regressed using the scale S and rotation R. Subsequently, given the camera parameters π_oj', we can render the j'-th novel view I_oj'_pred = ℛ(𝒢_2^l(I_oj), π_oj') and supervise it with the ground-truth I_oj'. For simplicity, we focus on outlining the training and inference procedure for a single image, omitting the subscript for subsequent sections. 










 §.§ DIG3D Framework
 


  
Deformable 3D Gaussian Encoder
Reconstructing 3D objects from a single view is a highly ill-posed problem due to the depth ambiguity. Therefore, to relief this issue, we design a depth-aware image encoder to extract both pixel-aligned features and depth-aware features from the input image, as shown in Figure <ref>(a).


We employ a UNet <cit.> architecture for extracting pixel-aligned features, following a similar approach to <cit.>. UNet offers a simple yet effective method for pixel-wise feature extraction. To effectively leverage the per-pixel correspondence provided by UNet in the input view and avoid conflicts in the position of novel view pixels, we introduce a loss on the reconstructed input view.


While we have obtained pixel-aligned image features, it is essential that these features also incorporate depth information to guide the 3D reconstruction process effectively. To address this, we utilize DINOv2, a model pretrained on the depth prediction task. DINOv2 inherently contains depth information due to its training on depth-related tasks. Hence, we leverage DINOv2 to acquire depth-aware image features. By incorporating depth information into the image features, we enhance the accuracy and reliability of our 3D reconstruction framework. 


In order to harness the advantages offered by both the pretrained DINOv2 feature, which excels in 2D tasks and depth estimation, and the high-resolution UNet image feature, we introduce a feature fusion block as shown in Figure <ref>(b).
Since the DINOv2 feature has a lower resolution compared to the UNetfeature, we employ the concept of Feature Pyramid Networks (FPN) <cit.> to upsample the DINOv2 feature. After upsampling, we add the DINOv2 feature to the UNet feature followed with a convolution layer. This aggregated feature is then further processed using another convolution layer. 




To reduce computational costs, the resulting feature with the original resolution is downsampled using a 2D convolution network with a large stride and kernel size. This downscaled feature serves as the feature map for deformable attention in the transformer decoder layers. This approach allows for efficient utilization of both the high-resolution UNet features and the informative pretrained DINOv2 features within the DIG3D method.






  
Deformable 3D Gaussian Decoder 
In the decoder phase, we initiate by randomizing N 3D Gaussians as queries and strive to learn their parameters by leveraging the image features obtained from the encoder. Drawing inspiration from works such as <cit.>, we integrate multiplayer refinement into our approach, computing the loss at the end of each layer. Additionally, we introduce a 3D reference point design, which enables us to adapt the 3D queries to the 2D deformable attention mechanism. By incorporating these techniques, we enhance the refinement process and improve the accuracy of our 3D reconstruction framework. 


As depicted in Figure <ref>, we initialize N Gaussians and update them layer by layer in the transformer decoder. Within each layer, the 3D Gaussians undergo a self-attention operation to facilitate information exchange among all ellipsoids. Subsequently, they are utilized as queries to compute cross-attention with the image features via the Deformable Attention (DFA) mechanism <cit.>. Ultimately, the queries are processed through a splatter head to obtain the N × K parameters for all the 3D Gaussians, where K denotes the number of Gaussian parameters for each Gaussian. 


To be more precise, we represent the queries as 𝐪∈ℝ^N × C, where N denotes the number of 3D Gaussians used to represent an object, and C signifies the hidden dimension. The corresponding increments of 3D Gaussians Δ G ∈ℝ^N × K, are computed by applying the splat head 𝒮 to the queries, as shown in Equation <ref>. The splat head is a convolution network that transforms the hidden dimension C into the output dimension K.


    Δ G = 𝒮(𝐪)


In each layer, given a set of initialized queries 𝐪, they undergo a self-attention operation to obtain updated queries. These updated queries are then utilized to compute the deformable cross-attention in conjunction with reference points and the fused image feature 𝐅. Finally, the queries pass through a feed-forward network to complete one layer.
Let l ∈1, 2, ..., L denote the l-th layer of the decoder. The process of query updating in each layer can be described by Equation <ref>. Here, SelfAttn, DFA, and FFN represent the self-attention, deformable cross-attention, and feed-forward network, respectively.


    𝐪^l+1 = FFN(DFA(SelfAttn(𝐪^l), P^l, 𝐅))


Here, P^l denotes the reference points at layer l and is obtained as follows. In each deformable cross-attention layer, we treat each 3D Gaussian ellipsoid as a 3D anchor and project its center onto the image feature plane, as depicted in Figure <ref>(b). By utilizing the pinhole camera model, the projection of the 3D points in camera coordinates can be described as P^l = C_intrinμ^l / d, where C_intrin represents the camera's intrinsic parameters. 






 §.§ Marrying 3D Gaussian to Deformable Decoder
 






  
Multi-Layer Refinement 
Taking inspiration from <cit.>, we employ a multi-layer refinement strategy to enhance the decoding process and facilitate iterative improvement. This strategy involves updating the 3D Gaussians layer by layer. Initially, we obtain the initialized 3D Gaussians and proceed to train a parameter increment for each layer. We then update the 3D Gaussian parameters in a sequential manner, rendering and supervising them at each layer. 
This refinement process is denoted as Δ G = 𝒮_l(𝐪^l), where 𝒮_l represents the splat head of the l-th layer. To update the 3D Gaussian parameters from Gaussians G in the previous layer, we apply the following change: G = G ⊕Δ G. Here, ⊕ denotes the update operation of G by Δ G, involving multiplication for rotation and addition for other parameters. 


Moreover, we compute the refined version of the reference points and utilize these updated reference points for deformable attention in the subsequent layer. By incorporating this strategy, we ensure that each layer contributes positively to refining the Gaussian representations. 




Empirically, we find that directly regressing the center of 3D Gaussians can lead to convergence difficulties during training. To address this issue, our approach locates the 3D Gaussians within a visual cone, as illustrated in Figure <ref>(a). The center coordinates of the Gaussians. The center coordinates x, y, z are parameterized by the depth d and offset values (Δ_x, Δ_y, Δ_z). The depth d represents the length of a ray originating from the camera center. Then, the center coordinates μ of a 3D Gaussian can be acquired with the below equation,




    μ = 
        [ x; y; z;   ]
        =
        [ u_1d + Δ_x; u_2d + Δ_y;    d + Δ_z ]


Here d denotes the distance between Gaussian center and the normalized plane. The center of Gaussians can be derived by Equation <ref>. This design simplifies the process of center regression in comparison to directly regressing the 3D Gaussian center coordinates.
Similar to <cit.>, we utilizes 24 parameters to represent each 3D Gaussian ellipsoid. These parameters are distributed as follows: 4 parameters for μ (1 for depth and 3 for position offset), 7 parameters for Σ (3 for scale 𝐒 and 4 for rotation 𝐑), 1 parameter for opacity σ, and 12 parameters for appearance SH.



  
3D Reference Point








Although we have developed a fairly comprehensive framework for 3D reconstruction from a single RGB image, there remains a challenge regarding deformable attention. Deformable attention employs reference points and trains sampling offsets on image features to select sampling points for calculating cross-attention. This method efficiently performs cross-attention by selecting specific features in the image. In detection problems, the reference point is typically the center of the bounding box, and all operations are performed in the 2D image domain. 

However, our situation differs in that we lack the bounding box center, and our queries are in 3D. To address this issue, we have devised a 3D reference point strategy. This strategy involves projecting the center of a 3D Gaussian onto the image features and considering it as the reference point, as depicted in Figure <ref>(b). Subsequently, we train sampling offsets Δ S^l = MLP^S(𝐪^l) to determine the sampling points on the image features. These sampling points are crucial for calculating attention in conjunction with the queries.

To be more precise, the attention scores are computed using a Multilayer Perceptron (MLP) applied to the queries, while the values are obtained by bilinearly projecting the image feature at the sampling points. The update of queries from 𝐪^l to 𝐪'^l through deformable cross-attention can be described by Equation <ref>.


    𝐪'^l = ∑_p=1^N_PA_pBilinear(𝐅_l, P^l + Δ S^l), 
    
        A_p = MLP^A(𝐪^l)


In this equation, N_P represents the number of sampling points P, and MLP^A corresponds to the learnable MLP responsible for generating the attention weights. 




 §.§ Training objective
 
Given a RGB image I as input and the viewpoint change π between the source and target cameras, we compute the discrepancy between the ground truth image I_gt and the rendered views from encoder, as well as at each output layer of decoder. The overall loss function can be defined as Equation <ref>. 


    ℒ = 1/|𝒟|∑_(I, I_gt, π) ∈𝒟(I - ℛ(𝒢_E(I), π)^2 + ∑_l=1^LI_gt - ℛ(𝒢_D^l(I), π)^2)


Here, ℛ represents the Gaussian splatting rendering operation using 𝒢_E and 𝒢_D, which are the encoder and decoder networks of DIG3D, respectively.
Furthermore, to improve the local similarities between patches in the reconstructed image and the ground truth image, the LIPIS (Learned Perceptual Image Patch Similarity) loss <cit.>, a perceptual similarity metric, is utilized after certain training steps. The LIPIS loss aims to optimize the perceptual quality and similarity between the reconstructed image and the ground truth image.




















§ EXPERIMENTS



 §.§ overview

We assess the effectiveness of our method in tackling the demanding task of 3D reconstruction and novel view synthesis using a single-view RGB image. We first present the dataset and evaluation metrics employed in our study, followed by an explanation of our experimental setup.
In Section <ref>, we showcase the qualitative and quantitative outcomes of novel view synthesis achieved by DIG3D, comparing it against the baseline approaches. In Section <ref>, we demonstrate the indispensability of our two-stage design and the benefits of incorporating deformable attention. 



  
Dataset
In our work, we utilize the widely-used ShapeNet-SRN dataset <cit.> for the evaluation of single-view 3D reconstruction, as introduced by <cit.>. This benchmark dataset comprises two object classes: "Cars" and "Chairs".  The training set includes 2458 car objects and 4612 chair objects, while the validation set has 352 car objects and 662 chair objects. The testing set comprises 704 car objects and 1317 chair objects.
ShapeNet-SRN provides multiple-view RGB images with corresponding camera intrinsics and poses. The dataset also includes a predefined training and testing split. For the validation and testing sets, there are 250 views per object, while the training set has 50 views per object. Each image in the dataset has a resolution of 128×128. 







  
Evaluation metrics
We train our methods using single-view RGB images and camera parameters, supervised by multiple views. During inference, we generate 3D object representations with 3D Gaussians and render novel views when provided with camera parameters. We evaluate our results using standard metrics: the Peak Signal-to-Noise Ratio (PSNR), Structural Similarity (SSIM), and perceptual quality measured using the Learned Perceptual Image Patch Similarity (LPIPS). 



  
Experiment Settings
Our model was trained on a single 80G A100 GPU over a period of 2 weeks, amounting to 1 million training steps. The training process followed a similar approach as presented in <cit.>. During the initial 800k steps, we trained the model using only the RGB loss. Subsequently, we introduced the LPIPS loss to further enhance the training process.
For the decoder architecture, we utilized 2 layers to strike a balance between performance and computational efficiency. Regarding the representation of a 3D object, we employed 10,000 Gaussians to capture its shape and properties. 





 §.§ Comparison with other methods
 
We compare our method with other methods on Shapenet SRN chair and car datasets in this section and analize the performances.




  
Quantitative comparison


















We assess the quality of our 3D reconstruction by generating novel views of the reconstructed 3D object using the camera intrinsics and poses provided in the dataset. For each object, we calculate the average metrics for the rendered images, and the results on ShapeNet SRN are presented in Table <ref>. Our method surpass all the methods shown in the table for both chairs and cars.

























  
Visualized comparison on ShapeNet SRN

To show the quality of our method, we visualize it both for the reconstructed 3D and rendered 2D image. 
When it comes to rendering quality, our method surpasses Splatter Image. Our approach produces smoother and more meaningful results. For instance, in cases where one chair leg obstructs another, Splatter Image still renders the leg behind, as illustrated in Figure <ref>. In contrast, our method accurately captures the occlusion and generates a more realistic rendering. 











To demonstrate that our method captures a meaningful 3D structure instead of merely relying on a shortcut to the supervised views, we have visualized the point cloud with the centers of Gaussians in Figure <ref>. In Splatter Image, each pixel in the input view is associated with a predicted depth and offset. Consequently, the network only obtains a shortcut representation of the rendered images. When we filter out the 50% lowest opacity points, most of the background points in the input view are removed, resulting in a waste of Gaussian points.
In contrast, our method ensures that all Gaussians contribute to the 3D object. The geometry of our objects is nearly accurate, and removing low opacity points does not compromise the overall 3D structure. This highlights the meaningfulness and coherence of our approach in capturing the true 3D representation of objects.



  
Speed comparison
We conducted speed tests for inference on the ShapeNet SRN dataset using a single A100 GPU, and the results are summarized in Table <ref>.

r0.58
  Inference time comparison on ShapeNet SRN Chair dataset on A100 GPU. 3D: 3d Reconstruction speed; R: rendering speed. Inference: the speed from image to all 250 novel views for each object in the test dataset. Unit in second.
  
  
    Method     3D ↓     R ↓     Inference ↓     

    PixelNeRF      0.005     1.2200     304.530  

    Splatter Image      0.022     0.0022     0.572  

    DIG3D     0.140     0.0022     0.690   

    


Our method utilizing 3D Gaussian Splatting rendering technique demonstrates exceptionally fast rendering speed. Although the encoder-decoder process may take longer for the forward pass, our inference process is still fast thanks to the high rendering speed. During inference, our model performs a single forward pass to acquire the 3D Gaussian parameters and multiple passes to generate various novel views. We have the same rendering speed comparing to Splatter Image and the overall inference time remains much faster compared to PixelNeRF. The total inference time is less than 1 second. 




As mentioned earlier, Splatter Image takes a shortcut by focusing on views instead of accurately representing the 3D structure. This approach may yield satisfactory results for views close to the input view but perform poorly for other views <cit.>. To support our claim, we calculate the average PSNR, SSIM, and LPIPS for each view of the ShapeNet SRN Chair dataset. As shown in Figure <ref>, the views within the red circle represent those that are very close to the input view. Splatter Image performance similiar to our method inside the red circle but the difference is significant for the views far away. Our method demonstrates superior performance compared to Splatter Image, particularly for views that are farther away from the input view. 




  
Quantitative comparsion view-wisely

In general, the views close to the input view will be easier to be generated because they have more information. To show the ability of generating hard situations (views far away from the input view), we present a quantitative comparison of each view in the ShapeNet SRN chair dataset, highlighting the performance of our method compared to Splatter Image. We give SSIM and LPIPS in Figure <ref> in addition to PSNR in Figure <ref>. Our method demonstrates superior results, especially for views that are distant from the input view (index 64). These distant views pose greater challenges for novel view synthesis compared to nearby views, showcasing the robustness and generalizability of our model across various perspectives.


  
Quantitative comparison after excluding neighbouring views
r0.58
  Novel Views for removing the 8 nearest views to input view for ShapeNet SRN dataset
  
  
    1cMethod     3cChairs                

    
          PSNR ↑         SSIM ↑     LPIPS ↓  

    Splatter Image      23.99     0.925     0.080  

    DIG3D     24.77     0.935     0.068   

    

To prove that our method is not a shortcut for the input view, we conducted an experiment where we removed the views that were very close to the input view. Specifically, we excluded the nearest 8 views located within the red circle (index 60 to 68), as compared to Splatter Image. The results of this experiment, presented in Table <ref>, clearly indicate the superiority of our method over Splatter Image. 


Our method exhibits a substantial improvement in performance compared to Splatter Image .When comparing Table <ref> and Table <ref>, our model shows minimal decrease in metrics when removing the values of the 8 views near the input view. However, the Splatter Image dataset exhibits a notable decrement in performance. This comparison provides evidence that our method is not simply a shortcut around the input view.
 By removing the values of the 8 views near the input view, our method decrease not much, which highlight the effectiveness of our method in enhancing the quality of the generated views when compared to Splatter Image. These results validate that our approach performs better, particularly when it comes to generating novel views that far from input views.





 §.§ Ablation study
 
To our best knowledge, DIG3D is the first one to use deformable detection transformer to 3D Gaussians. To show the significance of each component and selection of parameters of our method, we provide ablation study for each component in this section. To manage the computational cost, we trained the ablation models using a shorter training schedule of 100k iterations, following the approach of Splatter Image <cit.>. We discuss the trade-off of performance and efficiency for different hyperparameter selection.




  
Model design


In the previous sections, we emphasized the significance of both the multi-layer refinement and 3D reference point design. Additionally, as the image extractor comprises both UNet and DinoV2, we conducted an ablation study to evaluate the impact of removing UNet.

As shown in Table <ref>, when the multi-layer refinement is removed, the model only receives the loss at the end of the last layer, which does not guarantee positive contributions from each layer. Without the 3D reference point, randomly selected points on the image feature may not provide sufficient accuracy in feature selection compared to the 3D Gaussian positions. Removing the UNet feature results in the image feature being solely derived from the pre-trained model, which may not be suitable for our specific task.



  
Hyper-parameter selection


We give abalation study for some extremely important hyperparameters, including the number of decoder layers and the number of Gaussians utilized to represent an object in the section. 



To analyze the impact of the number of Gaussians used for object representation, we conducted an ablation study. Intuitively, a higher number of Gaussians tends to enhance performance but at the cost of slower speed. Thus, we aimed to find a trade-off between model complexity and performance. The results of this study are presented in Table <ref>, indicating that increasing the number of Gaussians leads to improved performance. However, it is crucial to note that using an excessively large number of Gaussians significantly increases the training cost.
To provide a more explicit comparison between inference time and PSNR for different numbers of Gaussians, we present Figure <ref> (a). When the number of Gaussians smaller 10,000, the PSNR increases significantly. However, when the number of Gaussians exceeds 10,000, the additional benefits diminish while incurring substantial time consumption. Consequently, to strike a balance between speed and quality, we ultimately opted for 10,000 Gaussians to represent an object. This choice allows us to achieve satisfactory results while maintaining reasonable training efficiency.





























To enhance the refinement process in updating the 3D Gaussians, we employ multi-layer refinement in the decoder. In order to evaluate the influence of the number of layers in the decoder, we conducted an ablation study. The results, depicted in Table <ref> (b), reveal that utilizing 2 layers yields significantly superior performance compared to using only 1 layer. Upon increasing the number of layers to 4 and 6, the observed improvement in performance is not as substantial as the transition from 1 layer to 2 layers. However, it is worth noting that the computational speed decreases significantly with the addition of more layers. Therefore, in most of our experiments, we opted to use 2 layers.
Selecting 2 layers strikes a balance between performance and computational efficiency. It provides a satisfactory level of accuracy while maintaining a reasonable speed for practical applications. However, in scenarios where higher accuracy is deemed necessary, the option to utilize more layers is available. This flexibility allows us to adapt the model's depth to specific requirements and trade-offs between accuracy and computational resources. This finding demonstrates the importance of incorporating multiple layers in the refinement process, highlighting the effectiveness of our approach in improving the quality of the reconstructed 3D structures. 



§ CONCLUSION


In conclusion, our work presents a comprehensive framework for 3D reconstruction from a single RGB image in category level. We address several limitations of previous approaches, such as incorrect geometry and shortcuts, while minimizing any negative impact on processing speed. To overcome the misalignment between input view pixels and novel view pixels, we employ separate loss functions in the encoder and decoder. Additionally, we tackle the challenge of using 2D deformable attention by introducing 3D reference points and training sampling offsets on image features, which enables efficient cross-attention calculations. We extend this approach to handle 3D queries by employing a 3D reference point strategy. This involves projecting the centers of 3D Gaussians onto image features and utilizing a multi-layer refinement strategy.
Our method achieves impressive rendering speed, surpassing Splatter Image while requiring fewer Gaussians. Furthermore, we provide compelling evidence of the superiority of our method in terms of rendering quality. Our approach generates smoother and more meaningful results, accurately capturing occlusions and producing realistic renderings. We demonstrate that our method captures a meaningful 3D structure, going beyond supervised views alone. The conducted ablation studies highlight the significance of multi-layer refinement, 3D reference points, and the inclusion of UNet and pretrained DINOv2 in the image extractor.












  


