1 Introduction↩︎

3D surface reconstruction from raw point clouds is a significant and long-standing problem in computer graphics and machine vision. Traditional techniques like Poisson Surface Reconstruction [1] create an implicit indicator function from oriented points and reconstruct the surface by extracting an appropriate isosurface. The advancement of artificial intelligence has led to the emergence of numerous neural network-based methods for 3D reconstruction. Among these, neural implicit representations have gained significant influence, which utilize signed distance fields (SDFs) [2]–[8] and occupancy fields  [9]–[12] to implicitly depict 3D geometries. SDFs and occupancy fields extract isosurfaces by solving regression and classification problems, respectively. However, both techniques require internal and external definitions of the surfaces, limiting their capability to reconstructing only watertight geometries. Therefore, unsigned distance fields [13]–[20] have recently gained increasing attention due to their ability to reconstruct non-watertight surfaces and complex geometries with arbitrary topologies.

Reconstructing 3D geometries from raw point clouds using UDFs presents significant challenges due to the non-differentiability near the surface. This characteristic complicates the development of loss functions and undermines the stability of neural network training. Various unsupervised approaches [14], [17], [19] have been developed to tailor loss functions that leverage the intrinsic characteristics of UDFs, ensuring that the reconstructed geometry aligns closely with the original point clouds. However, these methods suffer from slow convergence, necessitating an extensive network training time to reconstruct a single geometry. As a supervised method, GeoUDF [15] learns local geometric priors through training on datasets such as ShapeNet [21], thus achieving efficient UDF estimation. Nonetheless, the generalizability of this approach is dependent on the training dataset, which also leads to relatively high computational costs.

In this paper, we propose a lightweight and effective supervised learning framework, LoSF-UDF, to address these challenges. Since learning UDFs does not require determining whether a query point is inside or outside the geometry, it is a local quantity independent of the global context. Inspired by the observation that 3D shapes manifest simple patterns within localized areas, we synthesize a training dataset comprising a set of point cloud patches by utilizing local shape functions. Subsequently, we can estimate the unsigned distance values by learning local geometric features through an attention-based network. Our approach distinguishes itself from existing methods by its novel training strategy. Specifically, it is uniquely trained on synthetic surfaces, yet it demonstrates remarkable capability in predicting UDFs for a wide range of common surface types. For smooth surfaces, we generate training patches (quadratic surfaces) by analyzing principal curvatures, meanwhile, we design simple shape functions to imitate sharp features. This strategy has three unique advantages. First, it systematically captures the local geometries of most common surfaces encountered during testing, effectively mitigating the dataset dependence risk that plagues current UDF learning methods. Second, for each training patch, the ground-truth UDF is readily available, streamlining the training process. Third, this approach substantially reduces the costs associated with preparing the training datasets. We evaluate our framework on various datasets and demonstrates its ability to robustly reconstruct high-quality surfaces, even for point clouds with noise and outliers. Notably, our method can serve as a lightweight initialization that can be integrated with existing unsupervised methods to enhance their performance. We summarize our main contributions as follows.

• We present a simple yet effective data-driven approach that learns UDFs directly from a synthetic dataset consisting of point cloud patches, which is independent of the global shape.

• Our method is computationally efficient and requires training only once on our synthetic dataset. Then it can be applied to reconstruct a wide range of surface types.

• Our lightweight framework offers rapid and reliable initialization for other unsupervised iterative approaches, improving both efficiency and accuracy.

2 Related work↩︎

Neural surface representations. Reconstructing 3D surfaces from point clouds is a classic and important topic in computer graphics [23]–[25]. Recently, the domain of deep learning has spurred significant advances in the implicit neural representation of 3D shapes. Some of these works trained a classifier neural network to construct occupancy fields [9]–[12] for representing 3D geometries. Poco [12] achieves superior reconstruction performance by introducing convolution into occupancy fields. Ouasfi  [26] recently proposed a uncertainty measure method based on margin to learn occupancy fields from sparse point clouds. Compared to occupancy fields, SDFs [2], [4]–[8] offer a more precise geometric representation by differentiating between interior and exterior spaces through the assignment of signs to distances.

Unsigned distance fields learning. Although Occupancy fields and SDFs have undergone significant development recently, they are hard to reconstruct surfaces with boundaries or nonmanifold features. G-Shell [27] developed a differentiable shell-based representation for both watertight and non-watertight surfaces. However, UDFs provide a simpler and more natural way to represent general shapes [13]–[20]. Various methods have been proposed to reconstruct surfaces from point clouds by learning UDFs. CAP-UDF [17] suggested directing 3D query points toward the surface with a consistency constraint to develop UDFs that are aware of consistency. LevelSetUDF [14] learned a smooth zero-level function within UDFs through level set projections. As a supervised approach, GeoUDF [15] estimates UDFs by learning local geometric priors from training on many 3D shapes. DUDF [19] formulated the UDF learning as an Eikonal problem with distinct boundary conditions. UODF [20] proposed unsigned orthogonal distance fields that every point in this field can access the closest surface points along three orthogonal directions. Instead of reconstructing from point clouds, many recent works [28]–[31] learn high-quality UDFs from multi-view images to reconstruct non-watertight surfaces. Furthermore, UiDFF [32] presents a 3D diffusion model for UDFs to generate textured 3D shapes with boundaries.

Local-based reconstruction. Most methods achieve 3D reconstruction by constructing a global function from point clouds. For example, Poisson methods [1], [33] fits surfaces by solving partial differential equations, while neural network-based methods like DeepSDF [34]–[36] represent geometry through network optimization. The limitation of most global methods lies in their need for extensive datasets for training, coupled with inadequate generalization to unseen shape categories. Conversely, 3D surfaces exhibit local similarities and repetitions, which have spurred the development of techniques for reconstructing surfaces locally. Ohtake  [37] introduced a shape representation utilizing a multi-scale partition of unity framework, wherein the local shapes of surfaces are characterized by piecewise quadratic functions. DeepLS [3] and LDIF [38] reconstructed local SDF by training learnable implicit functions or neural networks. PatchNets [39] proposed a mid-level patch-based surface representation, facilitating the development of models with enhanced generalizability. Ying  [40] introduced a local-to-local shape completion framework that utilized adaptive local basis functions. While these methods all focus on SDF, GeoUDF [15] represents a recent advancement in reconstructing UDF from a local perspective.

3 Method↩︎

****Motivation.**** Distinct from SDFs, there is no need for UDFs to determine the sign to distinguish between the inside and outside of a shape. Consequently, the UDF values are solely related to the local geometric characteristics of 3D shapes. Furthermore, within a certain radius for a query point, local geometry can be approximated by general mathematical functions. Stemming from these insights, we propose a novel UDF learning framework that focuses on local geometries. We employ local shape functions to construct a series of point cloud patches as our training dataset, which includes common smooth and sharp geometric features. Given a point cloud to reconstruct, we employ the optimized model to output the corresponding distance values based on the local patch within radius for each query point. 1 illustrates the pipeline of our proposed UDF learning framework.

3.1 Local shape functions↩︎

Smooth patches. From the viewpoint of differential geometry [41], the local geometry at a specific point on a regular surface can be approximated by a quadratic surface. Specifically, consider a regular surface \(\mathcal{S}: \mathbf{r}=\mathbf{r}(u, v)\) with a point \(\mathbf{p}\) on it. At point \(\mathbf{p}\), it is possible to identify two principal direction unit vectors, \(\mathbf{e}_1\) and \(\mathbf{e}_2\), with the corresponding normal \(\mathbf{n}=\mathbf{e}_1\times\mathbf{e}_2\). A suitable parameter system \((u,v)\) can be determined such that \(\mathbf{r}_u=\mathbf{e}_1\) and \(\mathbf{r}_v=\mathbf{e}_2\), thus obtaining the corresponding first and second fundamental forms as \[\label{eq:fundmental-12} \setlength{\abovedisplayskip}{7pt} \setlength{\belowdisplayskip}{7pt} [\mathrm{I}]_{\mathbf{p}}=\begin{bmatrix} 1 &0\\ 0 &1 \end{bmatrix},\quad [\mathrm{II}]_{\mathbf{p}}=\begin{bmatrix} \kappa_1 &0\\ 0 &\kappa_2 \end{bmatrix},\tag{1}\] where \(\kappa_1, \kappa_2\) are principal curvatures. Without loss of generality, we assume \(\mathbf{p}\) corresponding to \(u=v=0\) and expand the Taylor form at this point as \[\setlength{\abovedisplayskip}{4pt} \setlength{\belowdisplayskip}{4pt} \label{eq:taylor} \begin{align} &\mathbf{r}(u,v)=\mathbf{r}(0,0)+\mathbf{r}_u(0,0)u+\mathbf{r}_v(0,0)v+\frac{1}{2}[\mathbf{r}_{uu}(0,0)u^2\\ &+ \mathbf{r}_{uv}(0,0)uv+\mathbf{r}_{vv}(0,0)v^2]+o(u^2+v^2). \end{align}\tag{2}\] Decomposing \(\mathbf{r}_{uu}(0,0), \mathbf{r}_{uv}(0,0), \text{and } \mathbf{r}_{vv}(0,0)\) along the tangential and normal directions, we can formulate 2 according to 1 as \[\setlength{\abovedisplayskip}{4pt} \setlength{\belowdisplayskip}{4pt} \begin{align} &\mathbf{r}(u,v)=\mathbf{r}(0,0)+(u+o(\sqrt{u^2+v^2}))\mathbf{e}_1+(v\\ &+o(\sqrt{u^2+v^2}))\mathbf{e}_2+\frac{1}{2}(\kappa_1u^2+\kappa_2v^2+o(u^2+v^2)))\mathbf{n} \end{align}\] where \(o(u^2+v^2)\approx 0\) is negligible in a small local region. Consequently, by adopting \(\{\mathbf{p}, \mathbf{e}_1, \mathbf{e}_2, \mathbf{n}\}\) as the orthogonal coordinate system, we can define the form of the local approximating surface as \[\setlength{\abovedisplayskip}{4pt} \setlength{\belowdisplayskip}{4pt} \label{eq:smooth} x=u,\quad y=v,\quad z=\frac{1}{2}(\kappa_1u^2+\kappa_2v^2),\tag{3}\] which exactly are quadratic surfaces \(z=\frac{1}{2}(\kappa_1x^2+\kappa_2y^2)\). Furthermore, in relation to Gaussian curvatures \(\kappa_1\kappa_2\), quadratic surfaces can be categorized into four types: ellipsoidal, hyperbolic, parabolic, and planar. As shown in 2, for differentiable points on a general geometry, the local shape features can always be described by one of these four types of quadratic surfaces.

Sharp patches. For surfaces with sharp features, they are not differentiable at some points and cannot be approximated in the form of a quadratic surface. We categorize commonly seen sharp geometric features into four types, including creases, cusps, corners, and v-saddles, as illustrated in 2 (b). We construct these four types of sharp features in a consistent form \(z=f(x,y)\) like smooth patches. We define a family of functions as \[\setlength{\abovedisplayskip}{5pt} \setlength{\belowdisplayskip}{5pt} \label{eq:sharp} z=1-h\cdot g(x,y),\tag{4}\] where \(h\) can adjust the sharpness of the shape. Specifically, \(g=\frac{|kx-y|}{\sqrt{1+k^2}}\) for creases (\(k\) can control the direction), \(g=\sqrt{x^2+y^2}\) for cusps, \(g=\max (|x|, |y|)\) for corners, \(g=(|x|+|y|)\cdot(\frac{|x|}{x}\cdot\frac{|y|}{y})\) for v-saddles. 3 illustrates several examples of smooth and sharp patches with distinct parameters.

Synthetic training dataset. We utilize the mathematical functions introduced above to synthesize a series of point cloud patches for training. As shown in 3, we first uniformly sample \(m\) points \(\{(x_i, y_i)\}_{i=1}^m\) within a circle of radius \(r_0\) centered at \((0, 0)\) in the \(xy\)-plane. Then, we substitute the coordinates into 3 4 to obtain the corresponding \(z\)-coordinate values, resulting in a patch \(\mathcal{P}=\{\mathbf{p}_{i=1}^m\}\), where \(\mathbf{p}_i=(x_i, y_i, z(x_i, y_i))\). Subsequently, we randomly collect query points \(\{\mathbf{q_i}\}_{i=1}^n\) distributed along the vertical ray intersecting the \(xy\)-plane at the origin, extending up to a distance of \(r_0\). For each query point \(\mathbf{q}_i\), we determine its UDF value \(\mathcal{U}(\mathbf{q}_i)\), which is either \(|\mathbf{q}_i^{(z)}|\) for smooth patches or \(1-|\mathbf{q}_i^{(z)}|\) for sharp patches. Noting that for patches with excessively high curvature or sharpness, the minimum distance of the query points may not be the distance to \((0, 0, z(0, 0))\), we will exclude these patches from our training dataset. Overall, each sample in our synthetic dataset is specifically in the form of \(\{\mathbf{q}, \mathcal{P}, \mathcal{U}(\mathbf{q})\}\).

3.2 UDF learning↩︎

We perform supervised training on the synthesized dataset which is independent of specific shapes. The network learns the features of local geometries and utilizes an attention-based module to output the corresponding UDF values from the learned features. After training, given any 3D point clouds and a query point in space, we extract the local point cloud patch near the query, which has the same form as the data in the training dataset. Consequently, our network can predict the UDF value at that query point based on this local point cloud patch.

3.2.1 Network architecture↩︎

For a sample \(\{\mathbf{q}, \mathcal{P}=\{\mathbf{p}_i\}_{i=1}^m, \mathcal{U}(\mathbf{q})\}\), we first obtain a latent code \(\mathbf{f}_p\in\mathbb{R}^{l_p}\) related to the local point cloud patch \(\mathcal{P}\) through a Point-Net [42] \(\mathcal{F}_p\). To derive features related to distance, we use relative vectors from the patch points to the query point, \(\mathcal{V}=\{\mathbf{p}_i-\mathbf{q}\}_{i=1}^m\), as input to a Vectors-Net \(\mathcal{F}_v\), which is similar to the Point-Net \(\mathcal{F}_p\). This process results in an additional latent code \(\mathbf{f}_v\in\mathbb{R}^{l_v}\). Subsequently, we apply a cross-attention module [43] to obtain the feature codes for the local geometry, \[\mathbf{f}_G=\text{CrossAttn}(\mathbf{f}_p, \mathbf{f}_v)\in\mathbb{R}^{l_G},\] where we take \(\mathbf{f}_p\) as the Key-Value (KV) pair and \(\mathbf{f}_v\) as the Query (Q). In our experiments, we set \(l_p=l_v=64\), and \(l_G=128\). Based on the learned geometric features, we aim to fit the UDF values from the distance within the local point cloud. Therefore, we concatenate the distances \(\mathbf{d}\in\mathbb{R}^m\) induced from \(\mathcal{V}\) with the latent code \(\mathbf{f}_G\), followed by a series of fully connected layers to output the predicted UDF values \(\mathcal{U}_\Theta(\mathbf{q})\). 4 illustrates the overall network architecture and data flow. The two PointNets used in our network to extract features from point cloud patches \(\mathcal{P}\) and vectors \(\mathcal{V}\) consist of four ResNet blocks. In addition, the two fully connected layer modules in our framework consist of three layers each. To ensure non-negativity of the UDF values output by the network, we employ the softplus activation function.

Denoising module. In our network, even if point cloud patches are subjected to a certain degree of noise or outliers, their representations in the feature space should remain similar. However, distances induced directly from noisy vectors \(\mathcal{V}\) will inevitably contain errors, which can affect the accurate prediction of UDF values. To mitigate this impact, we introduce a denoising module that predicts displacements \(\Delta\mathbf{d}\) from local point cloud patches, as shown in 4. We then add the displacements \(\Delta\mathbf{d}\) to the distances \(\mathbf{d}\) to improve the accuracy of the UDF estimation.

3.2.2 Training and evaluation↩︎

Data augmentation. During the training process, we scale all pairs of local patches \(\mathcal{P}\) and query points \(\mathbf{q}\) to conform to the bounding box constraints of \([-0.5, 0.5]\), and the corresponding GT UDF values \(\mathcal{U}(\mathbf{q})\) are scaled by equivalent magnitudes. Given the uncertain orientation of local patches extracted from a specified global point cloud, we have applied data augmentation via random rotations to the training dataset. Furthermore, to enhance generalization to open surfaces with boundaries, we randomly truncate \(20\%\) of the smooth patches to simulate boundary cases. To address the issue of noise handling, we introduce Gaussian noise \(\mathcal{N}(0, 0.1)\) to \(30\%\) of the data in each batch during every training epoch.

Loss functions. We employ \(L_1\) loss \(\mathcal{L}_{\text{u}}\) to measure the discrepancy between the predicted UDF values and the GT UDF values. Moreover, for the displacements \(\Delta\mathbf{d}\) output by the denoising module, we employ \(L_1\) regularization to encourage sparsity. Consequently, we train the network driven by the loss function \(\mathcal{L}=\mathcal{L}_u+\lambda_d\mathcal{L}_r\), where \(\mathcal{L}_u=|\mathcal{U}(\mathbf{q})-\mathcal{U}_\Theta(\mathbf{q})|,\,\,\mathcal{L}_r=|\Delta\mathbf{d}|\), we set \(\lambda_d=0.01\) in our experiments.

Evaluation. Given a 3D point cloud \(\mathbf{P}\) for reconstruction, we first normalize it to fit within a bounding box with dimensions ranging from \([-0.5, 0.5]\). Subsequently, within the bounding box space, we uniformly sample grid points at a specified resolution to serve as query points. Finally, we extract the local geometry \(\mathcal{P}_\mathbf{p}\) for each query point by collecting points from the point cloud that lie within a sphere of a specified radius centered on the query point. We can obtain the predicted UDF values by the trained network \(\mathcal{U}_{\Theta^*}(\mathbf{q}, \mathcal{P}_\mathbf{q})\), where \(\Theta^*\) represents the optimized network parameters. Note that for patches \(\mathcal{P}_\mathbf{p}\) with fewer than 5 points, we set the UDF values as a large constant. Finally, we extract meshes from the UDFs using the DCUDF model [22].

3.3 Integration with unsupervised methods↩︎

Unsupervised methods, such as CAP-UDF [17] and LevelSetUDF [14], require time-consuming iterative reconstruction of a single point cloud. In contrast, our LoSF-UDF method is a highly lightweight framework. Once trained on a synthetic, shape-independent local patch dataset, it efficiently reconstructs plausible 3D shapes from diverse point clouds, even in the presence of noise and outliers. Although unsupervised methods are time-consuming, they can reconstruct shapes with richer details due to the combined effects of various loss functions. Therefore, we integrate our method with unsupervised approaches to provide better initialization, thereby accelerating convergence ([tbl:tab:time]) and achieving improved reconstruction results. Generally, assuming the network of the unsupervised method is \(\mathcal{B}_\Xi\), we define the loss function of our integrated framework as \[\label{eq:integration-loss} \min\limits_\Xi\,\mathcal{L}=\alpha_t\frac{1}{N}\sum_{i=1}^N|\mathcal{B}_\Xi(\mathbf{q}_i)-\mathcal{U}_{\Theta^*}(\mathbf{q}_i)|+(1-\alpha_t)\mathcal{L}_{\text{unsupv}},\tag{5}\] where \(\mathcal{B}_\Xi\) can be selected as a MLP network like CAP-UDF [17] and LevelSetUDF [14], or a SIREN network [44] like DEUDF [45]. \(\mathcal{L}_{\text{unsupv}}\) is the loss functions employed in these unsupervised methods. \(\mathcal{U}_{\Theta^*}\) is our trained LoSF network with optimized parameters \(\Theta^*\). \(\alpha_t\in[0, 1]\) is a time-dependent weight. In our experiments (refer to 4.5), the whole training process requires around 20000 iterations. The value of \(\alpha_t\) decreases from 1 to 0 gradually during the first 10000 iterations.

4 Experimental results↩︎

4.1 Setup↩︎

Datasets. To compare our method with other state-of-the-art UDF learning approaches, we tested it on various datasets that include general artificial objects from the field of computer graphic. Following previous works [14], [17], [31], we select the "Car" category from ShapeNet [21], which has a rich collection of multi-layered and non-closed shapes. Furthermore, we select the real-world dataset DeepFashion3D [46] for open surfaces, and ScanNet [47] for large outdoor scenes. To assess our model’s performance on actual noisy inputs, we conducted tests on real range scan dataset [48] following the previous works [14], [17].

Baselines & metrics. For our validation datasets, we compared our method against the state-of-the-art UDF learning models, which include unsupervised methods like CAP-UDF [17], LevelSetUDF [14], and DUDF [19], as well as the supervised learning method, GeoUDF [15]. We trained GeoUDF independently on different datasets to achieve optimal performance. 1 shows the qualitative comparison between our methods and baselines. To evaluate performance, we compare our approach with other baseline models in terms of \(L_1\)-Chamfer Distance (CD), F1-Score (setting thresholds of 0.005 and 0.01), and normal consistence (NC) metrics between the ground truth meshes and the meshes extracted from learned UDFs. For a fair comparison, we adopt the same DCUDF [22] method for mesh extraction. All experiments are conducted on NVIDIA RTX 4090 GPU.

4.2 Experimental results↩︎

Synthetic data. For general 3D graphic models, ShapeNetCars, and DeepFashion3D, we obtain dense point clouds by randomly sampling on meshes. Considering that GeoUDF [15] is a supervised method, we retrain it on ShapeNetCars, and DeepFashion3D, which are randomly partitioned into training (70%), testing (20%), and validation subsets (10%). All models are evaluated in the validation sets, which remain unseen by any of the UDF learning models prior to evaluation. 5 illustrates the visual comparison of reconstruction results, and ¿tbl:tab:quantitative? presents the quantitative comparison in terms of evaluation metrics. We test each method using their own mesh extraction technique, as shown in 6, which display obvious visual artifacts such as small holes and non-smoothness. We thus apply DCUDF [22] , the state-of-art method, to each baseline model , extracting the surfaces as significantly higher quality meshes. Since our method utilizes DCUDF for surface extraction, we adopt it as the default technique to ensure consistency and fairness in comparisons with the baselines. Our method achieves stable results in reconstructing various types of surfaces, including both open and closed surfaces, and exhibits performance comparable to that of the SOTA methods. Noting that DUDF [19] requires normals during training, and GeoUDF utilizes the KNN approach to determine the nearest neighbors of the query points. As a result, DUDF and GeoUDF are less stable when dealing with point clouds with noise and outliers, as shown in 5.

Noise & outliers. To evaluate our model with noisy inputs, we added Gaussian noise \(\mathcal{N}(0, 0.25\%)\) to the clean data across all datasets for testing. The middle three columns in 5 display the reconstructed surface results from noisy point clouds, and ¿tbl:tab:quantitative? also presents the quantitative comparisons. It can be observed that our method can robustly reconstruct smooth surfaces from noisy point clouds. Additionally, we tested our method’s performance with outliers by converting 10% of the clean point cloud into outliers, as shown in the last three columns of 5. Experimental results demonstrate that our method can handle up to 50% outliers while still achieving reasonable results. Even in the presence of both noise and outliers, our method maintains a high level of robustness. The corresponding results are provided in the supplementary materials.

Real scanned data. Dataset [48] provide several real scanned point clouds, as illustrated in 7, we evaluate our model on the dataset to demonstrate the effectiveness. Our approach can reconstruct smooth surfaces from scanned data containing noise and outliers. However, our model cannot address the issue of missing parts. This limitation is due to the local geometric training strategy, which is independent of the global shape.

4.3 Analysis↩︎

Efficiency. We compare the time complexity of our method with other methods, as shown in [tbl:tab:time]. All tests were conducted on an Intel i9-13900K CPU and an NVIDIA RTX 4090 GPU. Computational results show that supervised, local feature-based methods like our approach and GeoUDF [15] significantly outperform unsupervised methods in terms of computational efficiency. Additionally, our method has a significant improvement in training efficiency compared to GeoUDF. Utilizing ShapeNet as the training dataset, GeoUDF requires 120GB of storage space. In contrast, our method employs a shape-category-independent dataset, occupying merely 0.50GB of storage. Our network is very lightweight, with only 653KB of trainable parameters and a total parameter size of just 2MB. Compared to GeoUDF, which requires 36 hours for training, our method only requires 14.5 hours.

Patch radius and point density. During the evaluation phase, the radius \(r\) used to find the nearest points for each query point determines the size of the extracted patch and the range of effective query points in the space. The choice of radius directly influences the complexity of the geometric features captured. When normalizing point clouds to a unit bounding box, we set the radius, \(r=0.018\). This setting achieves satisfactory reconstruction for our testing datasets. In the supplementary materials, we present a bias analysis experiment comparing the synthesized local patches and the local geometries extracted from the test point cloud data. The experimental results confirm that setting \(r\) to 0.018 maintains a relatively low bias, suggesting its effectiveness. Users can conduct a preliminary bias analysis based on our well-trained model to adjust the size of the radius according to the complexity of the input point cloud. This process is not time-consuming. Through experimental testing (refer to the supplementary materials), our algorithm ensures reasonable reconstruction, provided that there are at least 30 points within a unit area. A possible way for mitigating issues arising from low sampling rates is to apply an upsampling module [15] during the pre-processing step.

4.4 Ablation studies↩︎

Cross-Attn module. Our main goal is to derive the UDF value for a query point by learning the local geometry within a radius \(r\). To achieve this, we utilize Points-Net to capture the point cloud features \(\mathbf{f}_p\) of local patches. This process enables the local geometry extracted from test data to align with the synthetic data through feature matching, even in the presence of noise or outliers. Vectors-Net is tasked with learning the features \(\mathbf{f}_v\) of the set of vectors pointing towards the query point, which includes not only the position of the query point but also its distance information. The Cross-Attn module then processes these local patch features \(\mathbf{f}_p\) as keys and values to query the vector features \(\mathbf{f}_v\), which contain distance information, returning the most relevant feature \(\mathbf{f}_G\) that determines the UDF value. See 8 for two ablation studies on noisy point clouds.

Denoising module. Our framework incorporates a denoising module to handle noisy point clouds. We conducted ablation experiments to verify the significance of this module. Specifically, we set \(\lambda_d=0\) in the loss function to disable the denoising module, and then retrained the network. As illustrated in 9, we present the reconstructed surfaces for the same set of noisy point clouds with and without the denosing module, respectively.

4.5 Results of unsupervised integration↩︎

Our LoSF-UDF approach offers better initialization for unsupervised methods, including CAP-UDF [17], LevelSetUDF [14], and DEUDF [28]. We evaluated 12 models on the Threescan dataset [49], each containing rich details. Using the integration framework based on our lightweight LoSF-UDF, we achieve comparable or even superior reconstruction results, as illustrated in 10 and 2. More importantly, we improve the efficiency of original unsupervised methods as shown in [tbl:tab:time]. Considering the DEUDF is not open-source, we employ their proposed loss functions to train a SIREN network [44] on our own. For the loss function terms that require normal information, we used the method of PCA [50] to estimate the normals during the optimization process. Thanks to the robustness of LoSF, the accuracy of its estimation has been enhanced.

5 Conclusion↩︎

In this paper, we introduce a novel and lightweight neural framework for surface reconstruction from 3D point clouds by learning UDFs from local shape functions. Our key insight is that 3D shapes exhibit simple patterns within localized regions, which can be exploited to create a training dataset of point cloud patches represented by mathematical functions. As a result, our method enables efficient and robust surfaces reconstruction without the need for shape-specific training, even in the presence of noise and outliers. Extensive experiments on various datasets have demonstrated the efficacy of our method. Moreover, our lightweight framework can be integrated with unsupervised methods to provide rapid and reliable initialization, enhancing both efficiency and accuracy.

Acknowledgement↩︎

The NTU authors were supported in part by the Ministry of Education, Singapore, under its Academic Research Fund Grants (MOE-T2EP20220-0005 & RT19/22) and the RIE2020 Industry Alignment Fund–Industry Collaboration Projects (IAF-ICP) Funding Initiative, as well as cash and in-kind contribution from the industry partner(s). The DLUT authors were supported by the National Natural Science Foundation of China under Grants 62402083 and T2225012, the National Key R&D Program of China under Grants 2021YFA1003003. F. Hou was supported by the Basic Research Project of ISCAS (ISCAS-JCMS-202303) and the Major Research Project of ISCAS (ISCAS-ZD-202401). J. Hou was supported by the Hong Kong RGC under Grants 11219422 and 11219324.

References↩︎