{'fraction_non_alphanumeric': 0.03596253534401508, 'fraction_numerical': 0.015256833176248822, 'mean_word_length': 4.706386554621849, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
SeedFormer: Patch Seeds based Point Cloud Completion with Upsample Transformer

Point cloud completion has become increasingly popular among generation tasks of 3D point clouds, as it is a challenging yet indispensable problem to recover the complete shape of a 3D object from its partial observation. In this paper, we propose a novel SeedFormer to improve the ability of detail preservation and recovery in point cloud completion. Unlike previous methods based on a global feature vector, we introduce a new shape representation, namely Patch Seeds, which not only captures general structures from partial inputs but also preserves regional information of local patterns. Then, by integrating seed features into the generation process, we can recover faithful details for complete point clouds in a coarse-to-fine manner. Moreover, we devise an Upsample Transformer by extending the transformer structure into basic operations of point generators, which effectively incorporates spatial and semantic relationships between neighboring points. Qualitative and quantitative evaluations demonstrate that our method outperforms state-of-the-art completion networks on several benchmark datasets. Our code is available at https://github.com/hrzhou2/seedformer.


Introduction
As a commonly-used and easily-acquired data format for describing 3D objects, point clouds have boosted wider research in computer vision for understanding 3D scenes and objects. However, raw point clouds, routinely captured by Li-DAR scanners or RGB-D cameras, are inevitably sparse and incomplete due to the limited sensor resolution and self-occlusion. It is an indispensable step to recover complete point clouds from partial/incomplete data in real-world scenes for various downstream applications [24, 16,20].
Recent years have witnessed an increasing number of approaches applying deep neural networks on point cloud completion. The dominant architecture [43,1,38] employs a general encoder-decoder structure where a global feature (or called shape code) is extracted from partial inputs and is used to generate a complete point cloud in the decoding phase. However, this global feature  [40] and SnowflakeNet [38], SeedFormer is better at preserving existing structures (grey bounding box) and recovering missing details (green bounding box).
structure possesses two intrinsic drawbacks in its representation ability: (i) finegrained details are easily lost in the pooling operations in the encoding phase and can hardly be recovered from a diluted global feature in the generation, and (ii) such a global feature is captured from a partial point cloud, thus representing only the "incomplete" information of the seen part, and is contrary to the objective of generating the complete shape. Besides the overall network architecture, another problem is derived from the designs of point cloud generators. Unlike image inpainting which predicts RGB colors of the missing pixels, the 3D point generation is designed differently to predict (x, y, z) coordinates which are unstructured yet continuously distributed in the 3D space. This suggests that the desired points, which can describe the missing parts of the target object, have close spatial and semantic relationships with surrounding points in their local neighborhoods. However, existing methods, either using folding-based generators [41,43,34,39,42] or following a hierarchical structure with MLP/deconvolution implementations [27,11,38], attempt to process each point independently by splitting one target point into more. These designs neglect the distribution of existing points which results in poor recovery quality of geometric details (see in Fig. 1(b) and Fig. 1(c)).
To resolve the aforementioned problems, we propose a novel point cloud completion network, namely SeedFormer, with better detail preservation and recovery ability as shown in Fig. 1. Based on the designed Patch Seeds and Upsample Transformer, the decoding phase of our method consists of two main steps of: (i) first generating the complete shape from incomplete features in the seed generator, and (ii) then recovering fine-grained details in a coarse-to-fine manner. In the first stage, unlike previous methods using global features, we introduce Patch Seeds as a latent representation in the point cloud completion architecture. The Patch Seeds characterize the complete shape structure with learned features stored in local seeds. This helps generate more faithful details as it preserves regional information which is highly sparse in a global feature. Secondly, a new point generator is designed for both seed generator and the subsequent layers. Following the idea discussed before, we propose to integrate useful local information into the generation operations by aggregating neighboring points in the proposed Upsample Transformer. In particular, we formulate the generation of new points as a transformer-style self-attention weighted average of point features in the local field. This leads to a better understanding of local geometric features captured by semantic relationships. Qualitative and quantitative evaluations demonstrate the clear superiority of SeedFormer over the state-of-the-art methods on several widely-used public datasets. Our main contributions can be summarized as follows: -We propose a novel SeedFormer for point cloud completion, greatly improving the performance of generating complete point clouds in terms of both semantic understanding and detail preservation. -We introduce Patch Seeds as a new representation in the completion architecture to preserve regional information for recovering fine details. -We design a new point generator, i.e. Upsample Transformer, by extending the transformer structure into basic operations of generating points.

Related Work
Voxelization-based shape completion. The early attempts on 3D shape completion [3,10, [43] is the first learning-based method for point cloud completion, which adopts a similar encoder-decoder design with a global feature representing the input shape. It generates a complete point cloud from the global feature using MLPs and folding operations [41]. Focusing on the decoding phase of generating point clouds with more faithful details, several works [27, 34,11] extend the generation process into multiple steps in a hierarchical structure. This coarse-to-fine strategy helps produce dense point clouds with details recovered gradually on the missing parts. Furthermore, Wang et al.
[31] propose a cascaded refinement module to refine predicted points by computing a displacement offset. Similar ideas are also explored in [44,37,39,35]. In order to utilize supervision not only from 3D points but also in the 2D image domain, some other works [45,39] use rendered single-view images to guide the completion task. Among the aforementioned methods, the global feature design is widely used due to its efficiency and simplicity, while it still represents intrinsic drawbacks as we discussed before. PoinTr [42] proposes a set-to-set translation strategy which shares similar ideas with SeedFormer. However, PoinTr designs local proxies which are used for feature translation in transformer blocks. SeedFormer introduces Patch Seeds that can be propagated to the following upsample layers, focusing on the decoding process of recovering fine details from partial inputs. Point cloud generators. Generating 3D points is a fundamental step for point cloud processing and can be generalized to wider research areas. Following PointNet, early generative models [1] use fully-connected layers to produce point coordinates directly from a latent representation in auto-encoders [23,14] or GANs [8]. Then, FoldingNet [41] presents a new type of generators by adding variations from a canonical 2D grid in the point deformation. It requires lower computational cost while assuming that 3D object lies on 2D-manifold. Following this design, [39] proposes a style-based folding operator by injecting shape information into point generation using a StyleGAN [12] design. Moreover, Snowflak-eNet [38] proposes to generate new points by splitting parent point features through deconvolution. More recently, with the success of transformers in natural language processing [29, 36,5,4], an increasing number of research have developed such architecture for encoding 3D point clouds. In this work, we further extend the application of transformer-based structure into the basic operations of point cloud generation in the decoding phase, which also represents a new pattern of point generators with local aggregation.

Architecture Overview
The overall architecture of SeedFormer is shown in Fig. 2. We will introduce our method in detail as follows.
Encoder. Denote the input point cloud as P = {p i |i = 1, 2, ..., N } ∈ R N ×3 where N is the total number of points and p i possesses the (x, y, z) coordinates. The encoder applies point transformer [46] and set abstraction layers [22] to extract features from the incomplete shape. The number of points is reduced progressively in each layer and then we obtain patch features F p ∈ R Np×Cp and the corresponding patch center coordinates P p ∈ R Np×3 , which represent the local structures of the partial point cloud. Seed generator. Seed generator aims to predict the overall structure of the complete shape. It is designed to produce a coarse yet complete point cloud (seed points) as well as seed feature of each point which can capture regional information of local patterns. Given the extracted patch features F p and center coordinates P p , we use Upsample Transformer (Sec. 3.3) to generate a new set of seed features: Then, we obtain the corresponding seed points S = {x i } Ns i=1 ∈ R Ns×3 by applying MLPs on the generated seed features F = {f i } Ns i=1 ∈ R Ns×Cs . Grouping seed points and features together yields our Patch Seeds representation (more details are discussed in Sec. 3.2).  Coarse-to-fine generation. Afterwards, we follow the coarse-to-fine generation [41,11,38] to progressively recover faithful details in a hierarchical structure. This process consists of several upsample layers, each of which takes the previous point cloud and produces a dense output P l (l = 1, 2, ...) with an upsampling rate of r l where our Patch Seeds are closely involved. Specifically, each point in the input point cloud is upsampled into r l points using the Upsample Transformer. The coarse point cloud P 0 which is fed to the first layer is produced by fusing seeds S and the input point cloud P using Farthest Point Sampling (FPS) [22] to preserve partial structure of the original input [31].

Point Cloud Completion with Patch Seeds
Patch Seeds. Patch Seeds serve as a new shape representation in point cloud completion. It consists of both seed coordinates S and features F where each seed covers a small region around this point with seed feature containing semantic clues about this area. With rich information provided in seed features, SeedFormer can recover ambiguous missing details as shown in Fig. 1(d). Thus, compared with a global feature, the Patch Seeds representation possesses two advantages: (i) it can preserve regional information of local patterns, thus tiny details can be recovered in the complete point cloud; (ii) it represents the complete shape structure which is recovered from the partial input with explicit supervision (Sec. 3.4). Usage. Throughout the following steps, Patch Seeds are incorporated into each of the upsample layers to provide regional information. Given an input point cloud P l , we propagate seed features to each point p i ∈ P l by interpolating feature values in its neighborhood N s (i) (k nearest seeds of p i ). We use weighted average based on inverse distances [22] to compute the interpolated features: Here, d ij denotes the distance between p i and seed point x j , and f j is the corresponding seed feature. The interpolated features in this layer are {s l i } N l i=1 .

Upsample Transformer
Point generator via local aggregation. The generation process in point cloud completion aims to produce a set of new points, either maintaining data fidelity by preserving geometric details or well inferring missing parts based on the existing shape structure. The commonly-used folding operations [41,43,34,39] are designed to upsample each point independently with fixed 2D variants which leads to poor detail recovery. Differently, our Upsample Transformer is designed to incorporate closely-related local information into the generation by aggregating features from neighboring points. To this end, based on the point transformer [46] structure, we propose to formulate the generation process of new points as a self-attention weighted average of point features in the local field ( Fig. 3(a)). Moreover, following the idea of local aggregation, we can extend other successful encoder designs, e.g., Upsample layer. We first explain how to apply the designed Upsample Transformer in an upsample layer ( Fig. 2(b)). Given the input points P l ∈ R N l ×3 and the corresponding interpolated seed features {s l i } N l i=1 , we concatenate them and apply a shared MLP to form the point-wise queries {q l i } N l i=1 . Following [38], we use the output features from the previous layer as keys {k l i } N l i=1 in the transformer. It is used to preserve learned features of the existing points in the input. Then, the values {v l i } N l i=1 are obtained by applying a MLP on the concatenated keys and queries. Upsample Transformer applies a channel-wise attention using the subtraction relation in a local neighborhood N (i) (k nearest neighbors) of each point:â Here, α m , β and γ are feature mapping functions (i.e., MLPs) to produce attention vectors. δ is a positional encoding vector to learn spatial relations. For each upsampled point relating to the centered point p i , a specific kernel α m is defined where m = 1, 2, ..., r l indicates one of the r l generation processes in this layer (r l N l = N l+1 ). Each kernel learns a certain geometric pattern of local characteristics which outputs a separate group of self-attention weights to form a new point. In addition, to normalize the computed weights into a balanced scale,â ijm is applied by a softmax function: Then, we compute the generated point features by combining weights with the duplicated values: where ψ is also a feature mapping function and * denotes the elemental-wise product. Grouping all h im from each kernel yields our produced upsampled point features H l = {h im |i = 1, 2, ...N l ; m = 1, 2, ..., r l } ∈ R r l N l ×C . H l also serves as the keys {k l+1 i=1 of next layer in the skip connection. Finally, we apply shared MLPs on point features to obtain a set of point displacement offsets ∆P l . The output point cloud is defined as P l+1 =P l + ∆P l , whereP l is the duplicated point cloud, for both refining existing points and generating new points. Positional encoding with seed features. The basic positional encoding in the self-attention computations is designed to capture spatial relations between 3D points [46]. Besides, since the introduced seeds contain regional features with regard to the seed positions, we encode the interpolated features into regional encoding as follows: Here, δ encodes both positional relation and seed feature relation between p i and p j . ρ and θ are encoding functions using a two-layer MLP. Transformer without softmax. Similarly, Upsample Transformer is also used in the seed generator but is implemented without skip connection and seed features ( Fig. 2(a)). Generating seeds involves a different objective of producing seed points which can predict missing regions and cover the complete shape structure. As shown in Fig. 3(c), when the input point cloud represents an incomplete shape, it is essential for the seed generator to produce seed points outside the local neighborhood. However, the standard transformer structure represents an intrinsic limitation that the softmax normalization explicitly produces attention weights within a specific range of (0, 1). This may limit the learning ability especially in the seed generator. To solve this, we simply remove the softmax function in the transformer; that is, a ijm =â ijm is applied without normalization. The experiments in Sec. 4.5 show that it is easier to generate better seed points by disabling the softmax function or using other alternatives.

Loss Function
We use Chamfer Distance (CD) as our loss function to measure the distance between two unordered point sets [6]. To ensure that the generated seeds S can cover the complete shape, we down-sample the ground-truth point cloud to the same point number as S and compute the corresponding CD loss between them. The same loss function is also applied to each output P l separately in the upsample layers. Then, we define the sum of all CDs as the completion loss L comp . Besides, following [33], we compute the partial matching loss L part on the final predicted result to preserve the shape structure of the input point cloud.
The total training loss is defined as: 4 Evaluation

Implementation Details
The SeedFormer encoder applies two layers of set abstraction [22] and obtain N p = 128 patches of the incomplete point cloud. Then, in the seed generator, we produce a set of seed features F ∈ R Ns×Cs where N s = 256 and C s = 128. The coarse point cloud P 0 contains N 0 = 512 points which is obtained by merging S and P using FPS. Three upsample layers are used in the following coarse-tofine generation procedure which output dense point clouds {P 1 , P 2 , P 3 } and P 3 corresponds to the final predicted result. Channel number of generated features is set to C = 128 for all upsample layers. We train our network end-to-end using pytorch [19] implementation. We use Adam [13] optimizer with β 1 = 0.9 and β 2 = 0.999. All the models are trained with a batch size of 48 on two NVIDIA TITAN Xp GPUs. The initial learning rate is set to 0.001 with continuous decay of 0.1 for every 100 epochs.

Experiments on PCN Dataset
Data. The PCN dataset [43] is one of the most widely used benchmark datasets for point cloud completion. It is a subset of ShapeNet [2] with shapes from 8  categories. The incomplete point clouds are generated by back-projecting 2.5D depth images from 8 viewpoints in order to simulate real-world sensor data. For each shape, 16,384 points are uniformly sampled from the mesh surfaces as complete ground-truth, and 2,048 points are sampled as partial input. We follow the same experimental setting with PCN for a fair comparison. Results. Following previous methods, we report the Chamfer Distances with L1 norm (×1000) in Tab. 1. Detailed results of each category are also provided. SeedFormer achieves the best scores on all categories of this dataset, outperforming previous state-of-the-art methods by a large amount. Moreover, in Fig. 4, we show visual results of shapes from three categories (Lamp, Chair and Couch), compared with PCN [43], GRNet [40] and SnowflakeNet [38]. It shows that Seed-Former can produce clearly better results with more faithful details. As shown Table 2: Completion results on ShapeNet-55 dataset evaluated as L2 Chamfer Distance ×1000 (lower is better) and F-Score@1% (higher is better).  in the 2-nd and 3-rd rows, our network can preserve complicated details in the regions of chair arms and backs, without introducing undesired components.

Experiments on ShapeNet-55/34
Data. We further evaluate our model on ShapeNet-55 and ShapeNet-34 datasets from [42]. These two datasets are also generated from the synthetic ShapeNet [2] dataset while they contain more object categories and incomplete patterns.   Results. The ShapeNet-55 dataset tests the ability of dealing with more diverse objects and incompleteness levels. Tab. 2 reports the average L2 Chamfer Distances (×1000) on three difficulty levels and the overall CDs. Additionally, we show results from 5 categories (Table, Chair, Plane, Car and Sofa) with more than 2,500 samples in the training set. Complete results for all 55 categories are available in the supplemental material. We also provide results under the F-Score@1% metric [26]. Compared with previous methods, SeedFormer achieves the best scores on all categories and evaluation metrics. In particular, our method outperforms the SOTA model PoinTr [42] by 15.6% in terms of overall CD and 16.8% in terms of average CD on hard difficulty.
On ShapeNet-34, the networks should handle novel objects from unseen categories which do not appear in the training phase. We show results on two test sets in Tab. 3. Our method again achieves the best scores. Especially, when dealing with unseen objects, SeedFormer shows better generalization ability achieving an average CD of 1.34 which is 34.6% lower than PoinTr.

Experiments on KITTI
Data. In order to evaluate the proposed model on real-scanned data, we further conduct experiments on the KITTI [7] dataset for completing sparse point clouds of cars in real-world environments. This dataset consists of a sequence of LiDAR scans from outdoor scenes where car objects are extracted in each frame according to the 3D bounding boxes, resulting in a total of 2,401 partial point clouds. Unlike other datasets which are built from synthetic models, the scanned data in KITTI can be highly sparse and does not have complete point cloud as ground-truth. Thus, we follow the experimental settings of GRNet [40] and evaluate our method using two metrics: (i) Fidelity Distance, which is the Table 5: Ablation study on shape representations. We also evaluate the density of Patch Seeds.

Methods
CD-Avg global feature 6.97 seed number = 128 7.00 seed number = 256 6.74 seed number = 512 6.75   Methods CD-Avg none 6.88 positional 6.80 positional + regional 6.74 combined 6.78 average distance from each point in the input to its nearest neighbour in the output. This measures how well the input is preserved; (ii) Minimal Matching Distance (MMD), which is the Chamfer Distance between the output and the car point cloud from ShapeNet that is closest to the output point cloud in terms of CD. This measures how much the output resembles a typical car.
Results. Following GRNet, we fine-tune our model (pretrained on PCN dataset) on ShapeNetCars (the cars from ShapeNet) for a fair comparison. Quantitative evaluation results are shown in Tab. 4 compared with previous methods. We also show some visual comparisons of the predicted point clouds in Fig. 5. Each of the car objects is visualized in two different views for a clearer comparison. We can see that our method performs clearly better on real-scanned data. Even with a very sparse input (see the 2-nd row in Fig. 5), SeedFormer can produce general structures of the desired object.

Ablation Studies
In this section, we demonstrate the effectiveness of several architecture designs in SeedFormer and provide some optional choices that can be applied in the network. All the networks are trained on PCN dataset with identical settings. Patch Seeds. The Patch Seeds representation attempts to preserve geometric features locally, which shows clear superiority of detail recovery over previous global feature designs. We first ablate these two network architectures by replacing Patch Seeds with a global feature in the SeedFormer network. Specifically, in the seed generator, the global feature is obtained through max-pooling from input patch features, and is used to produce a coarse point cloud by a deconvolution layer [38]. Then, in the subsequent upsample layers, this global feature is concatenated with each input point which is fed to the Upsample Transformer similarly. All other architectures are identical. Results in Tab. 5 show clear improvement of our Patch Seeds design (6.74 vs 6.97). In addition, we ablate the number of seeds in the network and show that 256 seed points are suitable for covering an input 3D object with proper density. Upsample Transformer and other generator designs. We compare Upsample Transformer with other point cloud generators. Among previous methods for point cloud completion, folding-based operation [41] and deconvolution [38] are commonly-used. Unlike our generator which considers semantic relationships between points, these two designs are applied to process each point independently without using contextual information of point clouds.
The information from local areas is vital for point cloud completion, and we provide two optional choices for point generation operators. As discussed in Sec. 3.3, we adopt graph convolution [32] and vanilla Transformer (point-wise attention) to further demonstrate the effectiveness of local aggregation. In this experiment, we replace the Upsample Transformers in both seed generator and upsample layers, and keep other architectures the same. All the generators are designed to produce new features with upsampled points. Tab. 6 shows point generation by local aggregation performs better than previous methods, and the performance of Upsample Transformer stands out in similar designs. Alternatives to softmax function. The softmax function can provide balanced weights in the self-attention mechanism. However, in the case of seed generators, it also presents intrinsic limitations on generating new points. In Tab. 7, we show that the standard transformer structure (w/ softmax) is not the best choice (6.83) in the seed generator. Our improvement (w/o softmax) by applying self-attention without softmax function aims to release the points from limited weights within a specific range of (0, 1). Similar results can be achieved by using a log-softmax or scaled-softmax (multiplied by a scale parameter λ) function, which are also alternatives to the original softmax function. Positional encoding. Upsample Transformer applies both positional encoding from spatial relations and regional encoding from seed feature relations. This extends the original positional encoding in transformers by utilizing information from interpolated seed features. Tab. 8 shows that this design performs better which also demonstrates the effectiveness of incorporating information from Patch Seeds into the generation process of Upsample Transformer. Moreover, we design another ablation which combines both features in one encoding (6.78). We concatenate the two inputs and obtain a joint version through MLPs.

Visualization of Patch Seeds
In this section, we give some insights to achieve a deeper understanding of the generation process of Patch Seeds. The seed generator takes N p = 128 patches ( Fig. 6(b)) extracted from the input point cloud and produces a new set of N s = 256 seed points (Fig. 6(c)). Instead of using a global feature, adopting a patch-to-patch translation allows us to track the paths in the seed generation process. Specifically, the generated seeds can be divided into two groups, denoted as seed0 and seed1, since each patch center is split into two seeds according to different groups of self-attention weights in Upsample Transformer (see in Eq. 3). Thus, we visualize the obtained Patch Seeds in Fig. 6(c) with specific colors (red: seed0, blue: seed1). We can see that the red points (seed0) are close to the partial patches where the network tries to preserve the input structures. As for another group (blue points), if the input point cloud is symmetric to the ground-truth (the 1-st row in Fig. 6(a)), SeedFormer learns to duplicate the existing points as well as features, thus it can recover the missiles which are inferred from the seen parts. If the input is asymmetric (in the 2-nd row), our network can also predict missing parts according to the similar observations in the seen point cloud. For a clearer illustration, we also visualize the predicted complete point clouds in Fig. 6(d) where each point is colored according to its nearest seed.

Conclusion
In this paper, we propose a novel point cloud completion network, termed Seed-Former. As opposed to previous methods, SeedFormer introduce a new shape representation, namely Patch Seeds, in point cloud completion. The idea of Patch Seeds is to capture both global shape structure and fine-grained local details by learning regional features which are stored in several local seeds. This leads to a better performance of shape recovery and detail preservation in the generated point clouds. Furthermore, by extending the transformer structure into point generation, we propose a novel Upsample Transformer to capture useful neighborhood information. Comprehensive experiments show that our method achieves clear improvements on several challenging benchmark dataset compared to state-of-the-art competitors. Acknowledgements. This work is supported by the National Natural Science Foundation of China (No. 61832008). In this supplementary material, we provide additional information to complement the manuscript. First, we present additional implementation details and experimental settings of SeedFormer (Sec. A). Second, we provide more details about the ablation studies (variants of SeedFormer) in Sec. B. Third, we show complexity analysis of our method compared with previous state-of-the-art methods (Sec. C). At last, we present more qualitative results compared with other methods (Sec. D).

A Implementation Details
In this section, we provide additional implementation details of the proposed SeedFormer.
Encoder. We use point transformer [46] (SA) and set abstraction [22] (P T ) layers to extract features from an input point cloud. The point cloud (with 2,048 points) is downsampled using FPS in each layer of set abstraction. Detailed network architecture is as follows: SA(C = 128, N = 512) → P T (C = 128) → SA(C = 256, N = N p ) → P T (C = C p ). The outputs are N p = 128 patch centers P p as well as the corresponding patch features F p with C p = 256 channels.
Seed Generator. The inputs to seed generator are the obtained patch centers P p and correponding patch features F p . The implementation of Upsample Transformer (Eq. 1 in the main paper) is slightly different from that in an upsample layer. Since there are no skipped features, we use F p , applied by linear projections, for both keys and queries in the transformer. Also, the positional encoding of each point is calculated without incorporating seed features. Then, after we obtain seed features F, we concatenate them with a pooled feature from F p which is used for encoding global contexts, and apply shared MLPs to produce the seed coordinates S.
Experimental settings. For PCN dataset (with 16,384 points in groundtruth), we set the upsampling rate as r 1 = 1, r 2 = 4, r 3 = 8 where the first upsample layer is used to refine the input coarse point cloud P 0 . For ShapeNet-34/55 (8,192 points), we set r 1 = 1, r 2 = 4, r 3 = 4. Each input point cloud from all datasets contains 2,048 points. For those point clouds with less than 2,048 points, we randomly duplicate input points; for those with more than 2,048 points, we pick a subset as input.

B Ablation Studies
We give more details about ablation networks used in Sec. 4.5 in the main paper. Following the same idea of point generation by local aggregation, we propose two optional generator designs which are both more effective than previous methods. Compared with the default Upsample Transformer, these options can also achieve decent results (Tab. 6 in the main paper) while being more efficient.
Here, α m is a feature mapping function (MLPs) and m = 1, 2, ..., r l corresponds to each of the r l generation processes in this layer. The output features are H l = {h im |i = 1, 2, ..., N l ; m = 1, 2, ..., r l } ∈ R r l N l ×C with a upsampling rate of r l . Then, we obtain the new point cloud by learning displacement offsets from the produced features using shared MLPs. Another option applies transformer structures in point generation. Different from an Upsample Transformer, we adopt point-wise attention which is more efficient in the computations. Similar to Eq. 3 in the main paper, we compute self-attention weights by: The difference is that α m : R C → R outputs one-dimensional weights which are assigned to different points in the neighborhood. Then, we obtain the generated point features by combining weights with duplicated values (Eq. 5 in the main paper). To sum up, the point-wise attention is faster (Sec. C) while it can still outperform state-of-the-art methods.

C Complexity Analysis
We provide a detailed complexity analysis of our method. Tab. 9 reports the theoretical computational cost (FLOPs) and number of parameters for different models. The scores are measured on PCN dataset (16,384 points) with a batch size of 1. We also provide the overall Chamfer Distances as references. We can see that the model size of SeedFormer is very favorable compared to previous methods. This is owing to our designs of seed generator and upsample layers which process each point with a shared generator. On the other hand, since Upsample Transformer is required to aggregate local points in each generation, the computational cost of SeedFormer is relatively high but it is comparable with GRNet [40] and FoldingNet [41]. We also provide a more efficient version of SeedFormer using a faster transformer structure (point-wise attention) as discussed in Sec. 4.5 of the main manuscript. This model achieves a decent result (6.85) with lower computational cost. In all, our model can offer a pleasant trade-off between cost and performance.

D Additional Experimental Results
Qualitative results on PCN dataset. In Fig. 7, we provide more visual results compared with PCN [43], GRNet [40] and SnowflakeNet [38]. All the results are obtained from their released pretrained models. We can see that SeedFormer performs clearly better than previous methods.
More results on ShapeNet-55/34. We report complete results of our method on ShapeNet-55 in Tab