Generative adversarial networks for high-fidelity 3D point cloud completion

Abstract

3D point clouds are essential for representing geometric structures in various fields such as autonomous driving and virtual reality. However, real-world data often suffers from incompleteness due to occlusions and noise, and existing completion methods typically rely on paired complete–incomplete training data or are limited to recovering relatively small missing regions, which restricts their effectiveness under high missing-rate scenarios. This paper introduces a GAN-based method for completing 3D point clouds, capable of reconstructing detailed structures from partial inputs. Our end-to-end framework, consisting of an encoder, generator, and discriminator, optimizes topological accuracy and spatial continuity through a multi-term joint loss. Experimental results on the ModelNet40 dataset demonstrate superior performance over traditional and deep learning-based methods, achieving Chamfer Distance (CD = 0.085), Earth Mover’s Distance (EMD = 0.199), and F-Score (0.208). The generated high-quality point clouds support downstream tasks like path planning and robotic grasping. The source code and experimental datasets used in this work are publicly available at: DOI: https://doi.org/10.5281/zenodo.18421141.

Introduction

As an essential data representation for describing the geometric structure of object surfaces, 3D point clouds have been widely applied in autonomous driving, virtual reality, digital twins, industrial inspection, and various other fields^1,2. With the rapid development of 3D sensing devices such as LiDAR and depth cameras, point cloud acquisition has become increasingly efficient and accessible^3,4. However, real-world data collection still suffers from common issues such as occlusion, noise interference, limited resolution, reflective materials, and insufficient viewpoints, leading to sparse or incomplete point clouds. Such deficiencies significantly constrain the performance of subsequent tasks including 3D reconstruction, object recognition, and path planning^5–8.

Current mainstream point cloud completion methods mainly focus on scenarios with local missing regions (missing rate < 30%) or mildly damaged structures⁹. Existing techniques can be broadly categorized into two groups:

1. Traditional optimization and interpolation-based methods: Poisson Surface Reconstruction (PSR) is a representative technique that solves the Poisson equation to construct an implicit surface, from which a closed isosurface is extracted and resampled to form a completed point cloud¹⁰. PSR offers strong advantages in maintaining local geometric continuity.

2. Deep learning–based generative methods: Deep learning approaches can be further divided into supervised encoder–decoder frameworks and adversarial learning–based generative models. Representative supervised methods such as Point Completion Network (PCN) employ a coarse-to-fine cascaded architecture that first generates a low-resolution global shape and subsequently refines local geometric details¹¹. These methods typically require paired datasets of complete and incomplete point clouds, limiting their applicability in real-world scenarios with high missing rates or unpaired data.

GAN-based methods introduce adversarial learning to improve the realism and structural plausibility of completed point clouds. By incorporating a discriminator, the generator captures holistic shape distributions rather than relying solely on point-wise reconstruction losses. Representative GAN-driven methods—including DPG-Net, Point Encoder GAN, PC-GraphNet, and PCC-GAN—still largely depend on paired training data or are designed for small missing regions. Their optimization objectives are often dominated by distance-based metrics (e.g., Chamfer Distance), which do not explicitly enforce global structural consistency. Consequently, maintaining both global structural coherence and fine-grained local detail remains challenging under high missing-rate conditions.

In contrast, the framework proposed in this work can handle unpaired training and large missing regions. It demonstrates improved global structural consistency and local detail fidelity compared with prior approaches, without relying on restrictive template assumptions or handcrafted local priors. While existing methods perform well for repairing regular geometric shapes (e.g., cubes, cylinders) and small-scale missing regions, they struggle with large-area incompleteness (missing rate > 50%), severe structural damage, or missing core object regions^12–15.

To address these challenges, this paper proposes a GAN-based point cloud completion method. By constructing adversarial architecture composed of encoder, generator, and discriminator, the generator is trained to synthesize complete 3D point clouds directly from random noise. The generated complete shape is then fused with the input partial point cloud to fill the missing regions^16–18. Since the generator learns holistic shape priors, the proposed method is particularly effective in large-area missing scenarios and tasks that conventional methods fail to handle.

The main contributions of this paper are as follows:

• We establish a point cloud generation pipeline, where the trained generator can synthesize structurally plausible 3D objects from random noise.

• We propose a completion framework that fuses generated point clouds with partial inputs, effectively addressing structural recovery under large-area missing conditions.

• We further validate the feasibility and advantages of adversarial learning for point cloud completion by comparing the proposed method with existing techniques, demonstrating improved performance and offering methodological insights for future research.

Related work

Traditional methods

Traditional point cloud completion approaches can be broadly categorized into geometry-based reconstruction methods and template retrieval–based methods. Geometry-based approaches, such as Poisson Surface Reconstruction (PSR)¹⁹, reconstruct an implicit surface that approximates the manifold of the point cloud, thereby repairing incomplete meshes or filling holes using neighborhood information around the missing regions. While effective in preserving local geometric continuity, these methods typically overlook topological constraints and perform poorly on large-scale missing areas, limiting their ability to maintain global structural plausibility. Compared with GAN-based generative methods, geometry-based approaches rely heavily on local priors and handcrafted rules, lacking the ability to learn holistic shape distributions.

Interpolation-based methods estimate missing regions by locally fitting surfaces or interpolating neighboring points, with techniques such as moving least squares (MLS) surface fitting and local patch interpolation strategies. These approaches work well for small holes or minor occlusions but degrade significantly for large missing regions or complex structures. In contrast, adversarial methods can capture global patterns and maintain structural coherence even under high missing rates, which local interpolation cannot.

Optimization-based methods formulate completion as an energy minimization problem under geometric regularization constraints such as smoothness, curvature continuity, or structural consistency. Although they enforce certain global priors, they rely on iterative solvers and handcrafted constraints, reducing adaptability to highly irregular shapes. GAN-based frameworks, by contrast, optimize through learned objectives and adversarial feedback, enabling robust reconstruction without strict geometric formulas.

Template retrieval–based methods (e.g., Shape Completion using Template Retrieval²⁰ compensate missing parts by retrieving the most similar template from a database and aligning it with the incomplete input. While effective in constrained scenarios, these methods depend heavily on rich prior knowledge and manual intervention. GAN-based models do not require explicit templates and can generalize better to unknown or structurally complex objects.

Deep learning-based methods

The rapid development of deep neural networks has significantly advanced tasks such as point cloud classification, segmentation, and recognition by enabling the effective encoding of geometric information through high-dimensional feature representations. Current deep learning–based point cloud completion methods can be broadly categorized into multi-view projection approaches, voxel-based approaches, and end-to-end point cloud processing approaches.

Early studies such as MVCNN²¹ projected point clouds onto multiple 2D views and extracted features using 2D convolutional networks. However, these methods inevitably lose intrinsic 3D structural information, leading to suboptimal completion quality. To alleviate this limitation, voxel-based methods emerged, employing 3D convolutions on discretized voxel grids. Representative works include 3D-ResGAN²², 3D-EPN²³, and 3D-ED-GAN²⁴. While effective in capturing volumetric structures, voxelization introduces irreversible loss of fine geometric details and texture information, is constrained by resolution bottlenecks, and incurs substantial computational cost. GRNet²⁵ later attempted to recover point-level outputs by mapping voxel-based features back to point clouds; however, the inherent resolution limitations of voxel representations remain a major performance obstacle. These drawbacks have motivated a shift toward methods that process point clouds directly.

PointNet¹⁵, a pioneering work in point cloud learning, addressed the permutation invariance of unordered point sets. Building upon PointNet and its successors, such as PointNet++^26,27, DGCNN²⁸, and PointCNN²⁹—point cloud completion techniques have made significant progress. FoldingNet³⁰ introduced a manifold deformation paradigm that transforms a 2D grid into a 3D point cloud for completion. PCN^11,31, the first dedicated point cloud completion network, adopts an encoder–decoder architecture to generate a coarse global shape and then refines details through a grid-based folding operation. TopNet³² further proposes a tree-structured decoder capable of producing point clouds with arbitrary topology, eliminating the need for predefined point set structures. PF-Net³³ enhances detail recovery by leveraging a multi-scale encoder and a pyramidal decoder to generate hierarchical geometric structures.

Compared with GAN-based approaches, these supervised networks rely on paired complete–incomplete datasets and optimize mostly distance-based metrics (e.g., Chamfer Distance), which may not explicitly enforce global structural consistency.

GAN-driven methods

Generative adversarial networks have recently been applied to 3D point cloud completion to improve reconstruction realism and structural fidelity. Representative works include DPG-Net³⁴, Point Encoder GAN, PC-GraphNet, and PCC-GAN, which leverage adversarial training to generate plausible and detailed point clouds. These methods employ an encoder–generator–discriminator architecture to capture global shape priors while enhancing local detail recovery through adversarial feedback. Existing GAN-based approaches are effective in producing realistic global shapes and preserving local details, and the adversarial loss encourages holistic consistency beyond point-wise reconstruction.

Most of these methods rely on paired complete–incomplete training data, which limits their applicability in unpaired or high missing-rate scenarios. They are also primarily designed for small missing regions, and their optimization objectives are often dominated by distance-based metrics, which do not explicitly enforce global structural consistency. Weakly supervised or unsupervised GAN-based methods, such as Dynamic Sparse GAN and wavelet pooling–enhanced generative completion approaches, partially address the lack of paired data, but their performance under large missing regions or severe structural damage remains limited, and they still face challenges in preserving both global coherence and fine-grained local detail.

In contrast, the framework proposed in this work is capable of handling unpaired training and large missing regions, demonstrating improved structural consistency and local detail fidelity without relying on restrictive template assumptions or handcrafted priors. Compared with prior GAN-based methods such as DPG-Net, our approach is more robust under high missing-rate scenarios and can recover large-scale structural damage or missing core object regions.

Current challenges

Despite notable progress achieved by recent approaches such as MSN³⁵, SoftPoolNet³⁶, and PMP³⁷, completing point clouds with extensive missing regions remains highly challenging. Most existing methods rely on understanding the semantics of local regions, which requires paired complete–incomplete datasets; when missing regions vary significantly, these methods may fail to accurately reconstruct the missing parts. Key issues in point cloud completion include inaccurate structural recovery, insufficient surface smoothness and completeness, loss of fine-grained geometric details, and irregular or uneven point distributions. Adversarial learning for 3D point cloud completion remains a relatively novel and innovative approach, offering a promising solution to these challenges.

Methods

This paper proposes a point cloud completion framework based on Generative Adversarial Networks (GANs), designed to generate complete point clouds with geometric and normal features from random noise, and to utilize the generated shapes to repair large-scale missing regions in partial point clouds. The framework consists of a generator, a discriminator, multiple loss functions, and a completion module.

During training, adversarial learning is employed to progressively enhance the realism and structural fidelity of the generated point clouds. The generator attempts to synthesize plausible point clouds that can “fool” the discriminator, while the discriminator strives to distinguish real samples from generated ones^38,39. Through this adversarial interaction, the model gradually captures the underlying distribution of real point clouds, enabling the generator to produce outputs with realistic shapes and coherent local geometry.

Once trained, the generator produces high-quality, complete point clouds that serve as supplemental geometry for restoring missing regions in partial inputs. By integrating the generated shapes with the incomplete data, the method achieves structurally reasonable and visually coherent completion results. The overall framework is illustrated in Fig. 1.

Fig. 1.

Overview of the proposed GAN-based point cloud completion framework. The generator produces complete point clouds from random noise, which are refined through adversarial training with the discriminator. The trained generator is used to complement partial point clouds, restoring missing regions with realistic geometry and coherent local details.

Generator network

The generator in this study is designed to produce complete 3D point clouds with coherent geometry and structural integrity. During adversarial training, the generator takes a 64-dimensional random noise vector sampled from a standard normal distribution as input. After training, the generator can also accept global feature vectors extracted from incomplete point clouds, assuming they lie in the same latent space as the training noise distribution. The generator adopts a multilayer perceptron (MLP)—based architecture that progressively decodes a compact feature vector into a full point cloud representation through successive nonlinear transformations. The overall structure of the generator is illustrated in Fig. 2.

Fig. 2.

Architecture of the proposed generator network.

Specifically, the generator consists of six fully connected layers with the following neuron counts: 256, 512, 1024, 2048, 4096, and the product of the number of points and the target output dimensionality, which may be either three (representing 3D coordinates only) or six (representing 3D coordinates together with corresponding normal vectors). ReLU activation is applied to the first five layers to introduce nonlinearity, which facilitates learning complex mappings and helps mitigate the vanishing gradient problem—a common and effective choice in hidden layers of MLPs. The Tanh activation is applied to the output layer to constrain the generated 3D coordinates and normal vectors within a normalized range, improving training stability and convergence; this combination of ReLU in hidden layers and Tanh at the output is a widely adopted practice in generative networks for continuous-valued outputs⁴⁰.

The design emphasizes reconstructing fine-grained geometric details from compact latent features. By decoding features layer-by-layer, the generator enhances the expressive capability of the spatial distribution and produces higher-quality samples for adversarial training. This generator effectively establishes a mapping from global feature vectors to 3D point clouds, forming the foundation for reconstructing incomplete point clouds.

Discriminator network

The discriminator is designed to assess the authenticity of input point clouds, distinguishing between real samples and those generated by the generator, thereby guiding the generator to produce more realistic outputs. The discriminator employs an architecture that combines local feature extraction with global discrimination to enhance its perception of both fine-grained geometric details and overall structural distribution. The overall architecture is illustrated in Fig. 3.

Fig. 3.

Architecture of the proposed discriminator network.

The aggregated vector is passed through a discriminator module composed of multiple fully connected layers, mapping the features into higher-level representations. A final Sigmoid activation outputs a scalar in the range [0, 1], representing the estimated authenticity confidence of the input point cloud, with 0 indicating that the input is classified as fake⁴¹. This architecture balances strong discriminative performance with good generalization capability, providing effective feedback for generator optimization.

The network receives a point cloud tensor as input. The first three layers are one-dimensional convolution modules that progressively extract local geometric features while increasing the level of feature abstraction. Nonlinear activation functions follow each convolution layer to enhance the modeling capacity. Global max pooling is then applied to aggregate the point cloud into a fixed-length global feature vector.

Loss function design

To improve the geometric fidelity and structural plausibility of the generated point clouds, we introduce multiple loss functions into the GAN framework for joint optimization of the generator and discriminator⁴². The loss design not only addresses the core objectives of adversarial learning but also incorporates prior knowledge of point cloud spatial continuity and normal consistency.

The discriminator loss is designed to enhance its ability to distinguish real from generated point clouds, providing accurate and effective feedback for the generator. The generator loss integrates adversarial loss, normal consistency loss, geometric alignment loss, and local distance loss, guiding the network to produce 3D point clouds that are geometrically continuous, structurally complete, and rich in local details.

Discriminator loss

The discriminator is trained to accurately distinguish real point clouds from those generated by the generator, thereby encouraging the generator to improve its output quality⁴³. In this work, the discriminator loss is formulated as a log-likelihood–based cross-entropy function, which aims to maximize the confidence of correctly identifying real samples while minimizing the probability of incorrectly classifying generated samples. Formally, the loss is defined as:

1

where represents real point cloud samples, denotes the point clouds generated by the generator, and is the discriminator’s estimated probability that is a real sample. A small constant is typically added inside the logarithm to avoid numerical instability.

This loss guides the discriminator to learn discriminative features reflecting the true distribution of point clouds, providing clear and effective optimization signals for the generator during adversarial training.

Generator loss

To encourage the generator to produce point clouds that are structurally closer to real data, multiple auxiliary loss terms are introduced in addition to the basic adversarial loss⁴⁴. The total generator loss consists of four components: adversarial loss, normal consistency loss, geometric alignment loss, and local distance loss. Through this multi-objective optimization scheme, the network is guided to generate point clouds that maintain locally plausible structures, consistent normal distributions, and globally continuous geometry. The design of each loss component is detailed below.

1. Adversarial Loss.

The adversarial loss serves as the core optimization objective for the generator, encouraging it to produce point clouds capable of “fooling” the discriminator, i.e., achieving higher authenticity scores from the discriminator^45,46. This loss is formulated as:

2

where denotes the generated point cloud, and represents the discriminator’s confidence that is real. This loss drives the generator to optimize its outputs along the distribution of real point clouds.

• (2)Normal consistency loss.

To preserve surface smoothness and geometric coherence in the generated point clouds, a normal consistency loss is introduced. This loss measures the discrepancy between the normals of the generated point cloud and the corresponding real point cloud:

3

where and denote the normals of the real and generated point clouds, respectively. This loss encourages the generator to maintain consistency in surface details with respect to the real samples.

• (3)Geometric alignment loss.

The geometric alignment loss constrains the spatial proximity between the generated point cloud and the corresponding real point cloud, and is defined as:

4

where and represent the coordinates of the real and generated points, respectively. This loss effectively enhances the overall geometric fitting of the generated point cloud.

• (4)Local distance loss.

To further improve the structural plausibility and spatial uniformity of generated point clouds at the local scale, a local distance loss based on axis-aligned sequential neighborhood search is proposed. In this strategy, starting from a generated point, candidate neighbors are filtered sequentially along the -, -, and -axes: for example, the 100 nearest points are first selected along the -axis, then the 10 closest points are refined along the -axis, and finally the single nearest neighbor is determined along the -axis. This process is shown in Fig. 4. The geometric distance is computed only once between the final pair. This strategy avoids the computational burden of brute-force search in full 3D space while ensuring stability and continuity of neighborhood selection, providing a reliable basis for distance-based constraints.

Fig. 4.

Illustration of the axis-aligned sequential search.

This loss penalizes regions in the generated point cloud that are either overly dense or too sparse. By adopting a dimensionality-reduction strategy along coordinate axes, the method simplifies the computation of traditional 3D Euclidean distances, making neighborhood extraction more efficient and stable.

After identifying the nearest neighbor, the distance between the current point and its neighbor is penalized if it falls below a minimum threshold or exceeds a maximum threshold, maintaining structural balance in the local region. The local distance loss is defined as:

5

where the function imposes penalties when distances are outside the predefined bounds. This design enhances the naturalness of spatial distribution and prevents the occurrence of overly dense or isolated points.

Finally, the total generator loss is obtained by combining all components:

6

The weights for each loss term are empirically set in experiments to balance global shape reconstruction and local detail preservation. Specifically, in the experiments reported in this paper, the four loss weights are set as follows: Adversarial Loss = 0.6, Normal Consistency Loss = 0.05, Geometric Alignment Loss = 0.25, and Local Distance Loss = 0.1. These values are used for the experimental evaluation in this study and can be adjusted according to different datasets or training settings.

Point cloud completion pipeline

The proposed point cloud completion pipeline consists of four main stages: feature extraction by the encoder, point cloud generation by the generator, fusion and reconstruction, and KNN filtering combined with farthest point sampling (FPS). The overall workflow is illustrated in Fig. 5.

Fig. 5.

Illustration of the proposed point cloud completion pipeline.

To clearly describe the functionality of each module, the design of each stage is analyzed in detail based on its underlying principles and mechanisms.

Encoder feature extraction

A lightweight encoder network is employed to extract features from the input incomplete point cloud, capturing its overall geometric structure, as illustrated in Fig. 6. The encoder embeds each point using two shared fully connected layers (MLPs) and subsequently applies global average pooling to obtain a holistic feature. Finally, a linear transformation produces a 64-dimensional global feature vector.

Fig. 6.

Architecture of the encoder network.

This global feature vector serves as the core representation for the point cloud completion process, encapsulating the overall geometry and structural information of the input. Unlike general-purpose feature extractors such as PointNet or PointNet++, its primary role is to provide a compact, informative latent representation to the generator, rather than to perform hierarchical or semantic feature extraction.

This design effectively compresses the high-dimensional redundancy of the input point cloud while preserving discriminative shape features, ensuring the stability and expressive capability of the downstream generator module.

Point cloud generation by the generator

The global feature extracted by the encoder is fed into the generator to produce the spatial coordinates and normal vectors for each point:

7

where denotes the number of generated points. This process reconstructs a structurally complete point cloud from the latent space, serving as the basis for subsequent completion.

Fusion and reconstruction of point clouds

Since the incomplete input still contains partially valid geometric information, the generated point cloud is fused with the original input through concatenation:

8

This fusion strategy reconstructs a structurally complete point cloud by integrating the generated points from the generator. By combining the observed partial input with the completed shape, the process effectively fills in missing regions while enhancing global consistency in the final reconstruction. This ensures that the fused point cloud maintains both fidelity to the input and completeness in the overall geometry.

KNN filtering and FPS downsampling

To enhance the spatial uniformity and geometric plausibility of the completed point cloud, a two-stage refinement process consisting of KNN-based outlier filtering and farthest point sampling (FPS) is applied after generation⁴⁷, as shown in Fig. 7.

Fig. 7.

Illustration of the KNN-based filtering and FPS downsampling process.

For the fused point set, the average Euclidean distance between each point and its k nearest neighbors is computed, and the distribution of these averages is analyzed. Points whose neighborhood distance significantly exceeds the global mean are identified as local outliers and removed, preventing isolated artifacts from degrading the global geometry.

To further ensure uniform spatial distribution, FPS is applied to downsample the filtered point cloud. FPS iteratively selects points that maximize pairwise distances, generating a subset with evenly distributed samples that preserves the global structural characteristics.

This two-stage refinement ensures that the final completed point cloud exhibits consistent density and coherent spatial structure, thereby providing high-quality, well-organized data for downstream evaluation and practical applications.

Experiments

Experimental setup

To evaluate the effectiveness of the proposed method, experiments are conducted on the ModelNet40 dataset, which contains 40 categories of 3D point cloud models. In order to construct the completion task, incomplete point clouds are generated by applying random occlusion and cropping to the original complete point clouds. The complete samples in the dataset serve as ground-truth labels for training and evaluation.

All experiments are performed on a workstation equipped with an NVIDIA RTX 3080 GPU. The software environment includes Python 3.9, PyTorch 2.0, and CUDA 11.8. The models are trained using the Adam optimizer with an initial learning rate of 0.0001 and a batch size of 24. The generator and discriminator are jointly optimized for a total of 200 epochs.

To analyze the optimization behavior during training, the loss curves of both the generator and discriminator are recorded and plotted, as shown in Fig. 8.

Fig. 8.

Training loss curves of the generator and discriminator.

As illustrated, the discriminator loss increases rapidly in the early stage, while the generator loss continuously decreases, indicating that the generator gradually learns meaningful geometric distributions. In the mid-to-late training phase, both losses converge to a stable equilibrium, demonstrating that the adversarial learning process reaches a dynamic balance and the generator becomes capable of producing realistic point clouds.

In addition, the proposed generator network is lightweight and computationally efficient. On the RTX 3080 GPU, the trained model can be loaded in approximately 0.79 s, and single-sample inference takes around 0.18 s. On a modern CPU, the model can be loaded in about 0.57 s, with inference completed in roughly 0.02 s. These results demonstrate the model’s suitability for real-time or near real-time point cloud completion, highlighting its potential for practical engineering deployment in applications such as autonomous driving and industrial inspection.

Evaluation of local distance loss and loss ablation

To comprehensively assess the proposed method, three groups of experiments were conducted.

Computational efficiency of LDL vs. full euclidean distance

Point clouds generated by the generator were used as input, and the runtime for representative point selection was measured. The proposed Local Distance Loss (LDL), which selects neighbors sequentially along the x-, y-, and z-axes, was compared with a conventional approach that computes Euclidean distances for all points. As shown in Fig. 9, the LDL strategy significantly reduces computation time while maintaining accurate local geometric representation, demonstrating its efficiency for large-scale point clouds.

Fig. 9.

Computational time comparison between local distance loss and full Euclidean distance calculation.

Parameter sensitivity of axis-aligned sequential selection

To justify the choice of 100, 10, and 1 neighbors along the x-, y-, and z-axes, respectively, experiments were conducted to measure runtime under different parameter settings. The results in Fig. 10 show how varying these parameters affects computational cost. While smaller numbers along the x-axis (e.g., 50) may slightly reduce runtime, they risk missing nearby points, leading to insufficient local feature aggregation. Conversely, increasing the number of neighbors along the y- or z-axes (e.g., 2 or 3 points) would complicate the computation and increase runtime without substantial improvement in completion quality. The chosen configuration provides a practical balance, capturing sufficient local context for accurate point cloud completion while maintaining computational efficiency and stable training convergence.

Fig. 10.

Runtime analysis for different axis-aligned neighbor selection parameters.

Ablation study of generator loss terms

To investigate the contribution of each component in the generator loss, four ablation experiments were performed by removing the adversarial loss, normal consistency loss, geometric alignment loss, or local distance loss. The evolution of the generator loss during training is illustrated in Fig. 11. The curves indicate that all four loss terms are necessary for stable convergence: the adversarial loss is critical for overall convergence, while the other losses refine both local geometry and global structure.

Fig. 11.

Ablation study of generator loss components: adversarial, normal, geometric, and local distance loss.

These experiments collectively demonstrate that the proposed LDL design reduces computational cost, the selected neighbor parameters are reasonable, and the combination of all four loss terms is essential for high-quality, efficient point cloud completion.

In addition, a parameter sensitivity analysis was conducted to evaluate the influence of each loss weight on the final generator performance. Each loss weight—adversarial, normal consistency, geometric alignment, and local distance—was varied individually while keeping the others fixed, and the average generator loss over the last ten training epochs was recorded. The resulting sensitivity curves are shown in Fig. 12, the curves indicate that higher loss values correspond to degraded generator performance, confirming that inappropriate weighting of any component negatively impacts training. Among the four losses, the adversarial loss has the strongest effect on overall convergence, while the normal, geometric, and local distance losses primarily influence local detail recovery and global shape consistency. The weight values selected for the proposed model correspond closely to the observed minima in each sensitivity curve, supporting their effectiveness for stable and high-quality point cloud generation.

Fig. 12.

Parameter sensitivity analysis of generator loss weights: adversarial, normal, geometric, and local distance loss.

Evaluation of point cloud generation

To evaluate the 3D structural modeling capability of the designed generator under unsupervised conditions, we first tested its performance on a pure generation task, i.e., generating complete object point clouds from random noise. The model takes randomly sampled latent vectors as input and outputs 3D point clouds with reasonable structure and normal vector information. Figure 13 shows representative generated results for three object categories alongside the corresponding ground-truth point clouds.

Fig. 13.

Comparison between generated point clouds and ground-truth point clouds.

From the figure, it can be observed that, whether for structurally regular chairs, relatively planar beds, or cars with complex contours, the generated point clouds exhibit good consistency in overall shape, local geometry, and point distribution. For example, key structures such as the chair’s backrest and legs, the bed’s frame and headboard, and the car’s outline and roof are effectively reconstructed. This indicates that the generator has strong geometric modeling ability and can recover complex 3D shapes from noise.

These results demonstrate that the generator can reliably produce structurally consistent 3D shapes from the latent feature space, providing robust support for subsequent generator-based point cloud completion tasks.

Point cloud completion results

The trained generator and completion process were applied to the task of completing incomplete point clouds. Figure 14 presents the completion results for three representative samples, including the input point clouds, the completed outputs, and the corresponding ground-truth data.

Fig. 14.

Visualization of point cloud completion results: incomplete input, our method’s completion, and ground truth.

As shown, the proposed method is able to reconstruct complete 3D structures even when the input point clouds exhibit severe structural omissions, such as missing car bodies, chair legs, or bed headboards. The generated regions maintain high geometric consistency with the original structures, filling in missing areas while preserving the overall shape characteristics. This demonstrates strong structural awareness and local detail restoration capability of the method.

In addition, all completion results are processed with KNN-based outlier filtering and farthest point sampling (FPS) at the final stage, enhancing the spatial uniformity and structural clarity of the completed point clouds.

Comparison with existing methods

To evaluate the overall performance of the proposed method in point cloud completion, Poisson Surface Reconstruction (PSR), Point Completion Network (PCN), Morphing and Sampling Network (MSN), and the GAN-based DPG-Net, a similar method in terms of generative adversarial learning, are selected as baseline methods. Completion experiments are conducted on the chair, bed, and car test sets, comparing both completion quality and geometric errors.

Figure 15 shows the completion results of the three methods on representative samples. The proposed method outperforms the baseline methods in terms of structural completeness, detail recovery, and overall shape consistency.

Fig. 15.

Comparison of point cloud completion results across different methods.

Table 1 presents a comprehensive evaluation of six point cloud completion methods on the Car category, including three core metrics: Chamfer Distance (CD), Earth Mover’s Distance (EMD), and F-Score. The random baseline represents irregularly generated point clouds; effective methods are expected to outperform this baseline in all metrics.

Table 1.

Comparison of point cloud completion metrics across different methods. Bold values indicate the best results.

Method	Chamfer distance↓	EMD↓	F-score↑
PSR	0.284	0.549	0.105
TopNet	0.641	0.584	0.001
GRNet	0.836	0.903	0.001
DPGNet	0.351	0.499	0.002
MSN	0.203	0.364	0.006
PCN	0.251	0.376	0.015
Ours	0.069	0.167	0.353
Random	0.821	0.966	0.002

From the quantitative results shown in Fig. 16, it can be observed that the proposed method (Ours) achieves the best performance across all three metrics: CD, EMD, and F-Score.

Fig. 16.

Comparison of the three metrics for the Car category.

Cross-category comparison results, as shown in Fig. 17, indicate that the proposed method consistently maintains superior performance across different object types.

Fig. 17.

Comparison of different methods across object categories in terms of Chamfer Distance (CD), Earth Mover’s Distance (EMD), and F-Score.

To comprehensively validate the effectiveness of the proposed method, an in-depth comparison was conducted with three representative baseline methods. As shown in Table 2, the proposed method demonstrates significant advantages across multiple dimensions on the ModelNet40 dataset, including completion quality, structural reconstruction capability, and resource efficiency:

Table 2.

Multidimensional performance comparison of different methods. Bold values indicate the results of the proposed method.

Method	Type	Dataset	Avg CD↓	Avg EMD↓	Avg F-score↑
PSR	Geometric reconstruction	0	0.289	0.495	0.057
TopNet	Generative completion	2	0.452	0.545	0.009
GRNet	Volumetric generation	2	0.833	0.946	0.001
DPGNet	GAN-based completion	2	0.404	0.474	0.073
MSN	Morphing and SAMPLING COMPLETION	2	0.267	0.329	0.086
PCN	Encoder–decoder	2	0.156	0.305	0.036
Ours	GAN-based completion	1	0.085	0.199	0.208

During training, the proposed method only requires a single incomplete point cloud dataset for completion learning, without relying on paired samples corresponding to complete point clouds. In contrast, existing mainstream methods such as PCN, TopNet, GRNet, and DPG-Net typically rely on supervised training with paired “incomplete–complete” point cloud data. This dependence on precisely paired data not only increases the cost and difficulty of data preparation but also limits the applicability of these methods in practical scenarios. By comparison, the proposed method significantly reduces data dependency, lowering the deployment threshold and offering stronger generalization and practical applicability.

Analysis of scene point cloud completion and path planning performance

To further evaluate the feasibility and robustness of the proposed system in real-world applications, this section conducts point cloud completion experiments using point cloud data .collected from real station environments, followed by an analysis of the accuracy and completeness of the completion results. Unlike the experiments based on standard datasets, real-world scene point clouds typically suffer from more severe occlusions, noise disturbances, and irregular missing regions, posing greater challenges to the completion task.

In the indoor experiments, an Intel RealSense depth camera was first used to scan typical indoor scenes to acquire raw point clouds with occlusions and insufficient sampling. These point clouds were then fed into the proposed completion method, where the encoder extracts global features and the generator reconstructs the missing regions, resulting in a completed point cloud that is structurally complete and visually realistic.

As shown in Fig. 18, the completed point cloud effectively fills in the occluded areas while preserving the structural characteristics of the original data. The overall geometry becomes more complete, exhibiting improved geometric continuity and spatial coherence.

Fig. 18.

Point cloud completion results on real indoor scene data.

To further demonstrate the method’s generalization and applicability to autonomous driving scenarios, we evaluated the model on simulated driving scenes, where raw point clouds of vehicles are partially observed due to limited LiDAR sampling. As shown in Fig. 19, the proposed completion method reconstructs the missing regions, resulting in a more complete and coherent representation of the scene. This enables the system to infer the spatial structure of previously unseen areas, providing a consistent environmental model that can support downstream tasks such as path planning in complex traffic scenarios.

Fig. 19.

Point cloud completion results in an autonomous driving scenario.

Building on the point cloud completion results, this study further analyzes the impact of the completed point cloud on the predictive capability of the path planning task. Since path planning relies not only on the geometric information of observed regions but also on reasonable inference of unobserved or occluded areas, missing spatial information may lead the planning algorithm to generate unsafe or infeasible paths. By completing the missing regions, the proposed method predicts the spatial structure of previously unseen areas, resulting in a more complete environmental model with coherent spatial topology. Based on the completed point cloud, the path planning algorithm can more accurately predict hidden obstacles and potential traversable regions in the 3D environment, thereby generating smoother and more feasible paths.

As illustrated in Fig. 20, the planning results before and after completion differ significantly. After predicting the invisible regions, the planning algorithm reduces path conflicts and potential collision risks, producing a more continuous and reasonable trajectory. This verifies the effectiveness and engineering value of the proposed point cloud completion method in supporting 3D scene navigation and path planning.

Fig. 20.

Comparison of path planning results before and after point cloud completion.

Conclusion

In this study, we propose an end-to-end reconstruction framework based on a Generative Adversarial Network for 3D point cloud completion under high missing-rate scenarios. By constructing an adversarial architecture that jointly optimizes an encoder–generator–discriminator pipeline, the proposed method establishes a direct mapping from incomplete inputs to complete structures, thus overcoming the strong dependence on paired incomplete–complete samples required by traditional approaches. A novel four-term joint optimization objective is introduced, integrating adversarial loss, normal consistency constraints, geometric alignment loss, and local distance regularization. This design enforces global topological coherence while enhancing the fidelity of local geometric details. Furthermore, an axial dimensionality-reduction search strategy is employed to accelerate nearest-neighbor computation, and a two-stage post-processing scheme—comprising KNN outlier removal and farthest point sampling—is adopted to improve the uniformity and structural clarity of the generated point cloud.

Systematic experiments on the ModelNet40 dataset demonstrate that our method achieves superior performance compared with Poisson Surface Reconstruction (PSR) and state-of-the-art deep learning-based methods (PCN/TopNet/GRNet), with significant improvements in key metrics including Chamfer Distance (CD = 0.085), Earth Mover’s Distance (EMD = 0.199), and F-Score (0.208). Visualization results (Fig. 15) further verify that even when more than 50% of the core object structure is missing, the proposed method can still reconstruct a semantically plausible and geometrically coherent full shape that seamlessly aligns with the observed regions. Real-world scene tests (Fig. 18) confirm the strong generalization capability of the method: under severe occlusion and noise, the completion results exhibit high engineering applicability and can directly support downstream tasks such as robotic grasping, industrial inspection, and virtual simulation. In the path-planning task (Fig. 19), the completed point clouds provide more reliable geometric inference of unobserved areas and significantly improve path continuity, offering robust spatial support for navigation in complex environments.

This work introduces a new paradigm for addressing large-scale point cloud incompleteness. Future research will explore a semantics-guided hierarchical completion strategy and extend the framework to real-time reconstruction in dynamic scenes, and consider integrating alternative generative approaches—such as High Correlated Creator Machine (HCVCM)⁴⁸, Stronger Variable Creator Machine (SVCM), or Dynamic Selecting Machine (DSM)⁴⁹—which could potentially further improve high-fidelity 3D point cloud completion.

Author contributions

D.Z. was responsible for the overall research framework and study design. S.M. designed the algorithms and performed data analysis and processing. J.S. contributed to the optimization of the model modules. H.H. conducted the experimental design and experimental data analysis. All authors reviewed and approved the final manuscript.

Funding

This work was supported by the Major Science and Technology Projects (No. 318J009).

Data availability

The datasets analyzed during the current study are publicly available in the ModelNet40 dataset, provided by the Princeton ModelNet repository (https://modelnet.cs.princeton.edu). The source code and representative experimental data required to reproduce the results reported in this paper are permanently archived and publicly available via Zenodo at DOI: 10.5281/zenodo.18421141.

Declarations

Competing interests

The authors declare no competing interests.