Serialization-based Neighborhood Grouping (SNG)

• SNG is a technique that serializes irregular 3D point clouds using space-filling curves to preserve spatial locality and enable efficient processing.
• It forms fixed-size groups or retrieves contiguous windows as approximate neighborhoods for patch-based dynamic adaptation and signed distance field reconstruction.
• Empirical results demonstrate that SNG reduces computational cost and memory usage while achieving competitive accuracy in large-scale point cloud analysis.

Serialization-based Neighborhood Grouping (SNG) denotes a class of point-cloud structuring procedures that impose a locality-preserving one-dimensional order on an irregular 3D point set and then use that order to form local groups or neighborhoods for downstream computation. In the available literature, the term appears in two closely related but operationally distinct settings. In "NoKSR: Kernel-Free Neural Surface Reconstruction via Point Cloud Serialization" (Li et al., 18 Feb 2025), SNG is used to retrieve approximate neighborhoods for signed distance field reconstruction by taking contiguous windows in a serialized point sequence. In "PointTPA: Dynamic Network Parameter Adaptation for 3D Scene Understanding" (Liu et al., 6 Apr 2026), SNG is a parameter-free preprocessing step that serializes points, partitions the serialized stream into fixed-size groups, and produces locally coherent patches for patch-wise dynamic parameter generation. Across both uses, the core idea is that a space-filling curve provides a reversible or locality-preserving linearization of the scene, thereby avoiding explicit voxel grids and avoiding direct reliance on radius queries or $k$-NN at the grouping stage.

1. Conceptual scope and motivation

SNG is motivated by the difficulties of scene-level point cloud processing: point sets are extremely large, spatially irregular and sparse, and exhibit highly varied local geometry and object scale or distribution (Liu et al., 6 Apr 2026). In large-scale signed distance field reconstruction, a related difficulty is that query-time neighborhood aggregation must be accurate enough to preserve geometry while remaining efficient at scale; sparse 3D grids are fast but quantize away fine detail, whereas raw-point $k$-NN or ball queries are accurate but expensive (Li et al., 18 Feb 2025).

Within this setting, SNG replaces direct spatial neighborhood construction with serialization. The point cloud is mapped to a one-dimensional order by a locality-preserving space-filling curve, and that order is then used either to slice the point stream into fixed groups or to retrieve a short contiguous window as an approximate neighborhood. This suggests that SNG is best understood not as a single architecture, but as a data-structuring primitive that turns irregular point sets into sequence-like objects while retaining enough spatial coherence for local computation.

A common misconception is that serialization is equivalent to arbitrary sorting. The formulations described here are more specific: the ordering is chosen so that nearby 3D points tend to remain nearby in the one-dimensional traversal. A second misconception is that SNG is itself a learnable module. In PointTPA, the SNG module is explicitly described as a purely data-structuring, parameter-free preprocessing step; the learnable adaptation occurs downstream in the Dynamic Parameter Projector (DPP) (Liu et al., 6 Apr 2026). In NoKSR, the learnable component lies in the multi-scale feature aggregation and SDF prediction, whereas serialization provides the approximate neighborhood access pattern (Li et al., 18 Feb 2025).

2. Serialization as a locality-preserving linearization

The common substrate of SNG is serialization via a space-filling curve. In PointTPA, the input consists of unordered point features $\mathbf{x}\in\mathbb{R}^{N\times C}$, comprising coordinates and any extra features. The points are first normalized by LayerNorm,

$$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$

and then reordered by a chosen space-filling curve $\varphi$, yielding

$$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$

The paper lists Hilbert, Z-order, or a stage-wise mixed strategy as the choice of $\varphi$, with the mixed strategy as default in PTv3 (Liu et al., 6 Apr 2026).

In NoKSR, serialization is formalized through a quantization map and a hash induced by a 3D Hilbert curve. Given $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$ and a grid size $g>0$,

$$Q(p)=\lfloor p/g\rfloor,\qquad \gamma(p)=\phi(Q(p)),$$

where $k$0 is a bijection from 3D integer coordinates to a single integer index. Sorting the points by $k$1 defines a permutation $k$2 and hence a rank index $k$3 such that

$k$4

The paper states that the 3D Hilbert curve is used in NoKSR, while noting that Morton or Z-order is an alternative (Li et al., 18 Feb 2025).

Although the two papers instantiate serialization somewhat differently, their shared principle is that locality is enforced by the curve ordering rather than by explicit geometric search structures. In PointTPA, no explicit radius or $k$5-NN is used; locality is enforced by the curve ordering plus fixed partitioning (Liu et al., 6 Apr 2026). In NoKSR, neighborhood retrieval is reduced to a constant-time window lookup around the serialized position of a query point, followed optionally by Euclidean filtering (Li et al., 18 Feb 2025).

3. Fixed-size grouping in PointTPA

In PointTPA, SNG converts the serialized sequence into locally coherent patches that can be consumed by a dynamic adaptation module. After serialization, the sequence is split into $k$6 contiguous segments: $k$7 where $k$8 is the number of groups and $k$9 is the maximum number of points per group. If a segment has fewer than $\mathbf{x}\in\mathbb{R}^{N\times C}$0 points, it is padded with zeros along the $\mathbf{x}\in\mathbb{R}^{N\times C}$1-axis so that each group is a dense $\mathbf{x}\in\mathbb{R}^{N\times C}$2 tensor (Liu et al., 6 Apr 2026).

The pipeline is entirely index based. The grouping operator $\mathbf{x}\in\mathbb{R}^{N\times C}$3 is described as purely an index slicing operation, and reversibility is preserved through $\mathbf{x}\in\mathbb{R}^{N\times C}$4 and $\mathbf{x}\in\mathbb{R}^{N\times C}$5. The stated goal is to reorder points along a one-dimensional space-filling curve to preserve spatial locality, split the reordered stream into $\mathbf{x}\in\mathbb{R}^{N\times C}$6 equal-length groups, and zero-pad groups that have fewer than $\mathbf{x}\in\mathbb{R}^{N\times C}$7 points so that every group has a constant shape (Liu et al., 6 Apr 2026).

The stage-wise hyper-parameterization is explicit. The default number of groups is 200 in stage 1 and is halved each deeper stage; an example schedule is $\mathbf{x}\in\mathbb{R}^{N\times C}$8 for stages 1 through 5. The implicit group size is $\mathbf{x}\in\mathbb{R}^{N\times C}$9. The paper also states that SNG and DPP live in the last block of each stage, as shown in Figure 1, while Figure 2 depicts the sequence raw cloud $$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$0 LayerNorm $$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$1 serialize along a curve $$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$2 slice into $$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$3 groups $$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$4 hand off to DPP (Liu et al., 6 Apr 2026).

This formulation makes SNG a patch constructor rather than a neighbor oracle. A plausible implication is that the method is designed for modules that require fixed tensor shapes and patch-level descriptors, rather than for exact local geometry estimation.

4. Approximate neighborhood retrieval in NoKSR

In NoKSR, SNG serves a different downstream purpose: approximate neighbor retrieval for query-based reconstruction. Once the point cloud is serialized, retrieving the $$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$5 nearest points to a query $$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$6 is implemented by taking a window centered around the serialized position of $$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$7, using binary search over the sorted codes, and then filtering candidates by true Euclidean distance. The pseudocode in the paper describes a window half-width $$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$8, an optional distance threshold $$\tilde{\mathbf{x}} = \mathrm{LN}\bigl(\mathbf{x}\bigr)\quad\in\mathbb{R}^{N\times C},$$9, and a final selection of the $\varphi$0 closest points if the candidate set is larger than $\varphi$1 (Li et al., 18 Feb 2025).

The method is explicitly approximate. The paper notes that each window lookup can miss a few true neighbors, referred to as false negatives, but reports that multi-scale aggregation compensates for this loss. The reported recall of true $\varphi$2-NN in each serialization slice is approximately $\varphi$3 at one scale and rises to approximately $\varphi$4 when summing three scales, which the paper interprets as confirmation that multi-scale slicing largely recovers neighbors lost by a single window (Li et al., 18 Feb 2025).

NoKSR further embeds SNG in a hierarchical backbone: $\varphi$5 where $\varphi$6 is a subsampled point set and $\varphi$7 is the corresponding learned feature field. For each query $\varphi$8, approximate neighborhoods $\varphi$9 are retrieved at each scale, and a per-level feature is computed as

$$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$0

with $$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$1 and $$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$2. The multi-scale features are fused by summation,

$$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$3

to regress the signed distance value (Li et al., 18 Feb 2025).

This version of SNG should therefore be distinguished from the PointTPA version. In NoKSR, grouping is query-centric and approximate, with the serialized order functioning as an acceleration structure for neighbor retrieval rather than as a fixed patch partition.

5. Interfaces to downstream architectures

The two uses of SNG differ most clearly in how the grouped or retrieved data are consumed. In PointTPA, SNG outputs $$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$4, after which DPP average-pools each group over the $$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$5 points,

$$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$6

These $$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$7 patch descriptors are passed through a tiny MLP and a softmax with temperature $$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$8: $$\mathbf{x}_{\mathrm{seq}}=\varphi\bigl(\tilde{\mathbf{x}}\bigr), \qquad \varphi^{-1}\bigl(\mathbf{x}_{\mathrm{seq}}\bigr)=\tilde{\mathbf{x}}. \tag{1}$$9 The coefficients linearly combine a learnable base set $\varphi$0 into per-group dynamic weights

$\varphi$1

These weights are applied to each group’s $\varphi$2 features, after which the output is inverse-grouped and inverse-serialized back into the original $\varphi$3 shape for residual addition into the transformer block (Liu et al., 6 Apr 2026).

In NoKSR, the downstream interface is instead an SDF predictor operating on query-conditioned, multi-scale neighborhood features. The backbone is PointTransformerV3. The paper states that raw points are embedded by a small MLP and positional encoding, then serialized and cut into equal-sized chunks, such as 1024 points each, for local self-attention with a learned function of the relative offset as an attention bias. Hierarchical reduction yields multiple scales, and the decoder uses a two-layer MLP with hidden size half of feature dimension followed by $\varphi$4 to regress the final signed distance (Li et al., 18 Feb 2025).

The contrast may be summarized as follows.

Setting	Role of SNG	Immediate downstream consumer
PointTPA	Serialize, chunk into $\varphi$5 fixed groups, zero-pad to $\varphi$6	DPP for patch-wise adaptive weights
NoKSR	Serialize, retrieve contiguous windows as approximate neighborhoods	Multi-scale PointNet-style aggregation for SDF prediction

This suggests that SNG is modular with respect to the computation that follows it. Its invariant component is the serialization-induced locality prior; its variable component is whether locality is used to construct fixed patches or approximate query neighborhoods.

6. Empirical properties, limitations, and interpretation

PointTPA reports that, when integrated into the PTv3 structure, the method introduces two lightweight modules of less than $\varphi$7 of the backbone’s parameters and achieves $\varphi$8 mIoU on ScanNet validation, surpassing existing parameter-efficient fine-tuning methods across multiple benchmarks. The supplementary timing table is described as showing that SNG adds only approximately $\varphi$9 ms overhead to inference (Liu et al., 6 Apr 2026). The paper’s interpretation is that test-time dynamic network parameter adaptation improves scene understanding while maintaining low parameter overhead.

NoKSR reports, on CARLA, that exact $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$0-NN takes $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$1 s with $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$2 and $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$3, SparseCNN (Minkowski) takes $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$4 s with $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$5 and $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$6, and SNG takes $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$7 s with $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$8 and $P=\{p_1,\dots,p_N\}\subset\mathbb{R}^3$9. The paper further states that across SyntheticRoom, ScanNet, and SceneNN, SNG is as accurate or better than the SOTA voxel solvers with half or less the inference latency. In the supplementary results, peak GPU memory is reported to drop from $g>0$0 GB for NeuralKSR to under $g>0$1 GB for SNG during training, and training step time halves as well (Li et al., 18 Feb 2025).

The principal limitations are also explicit. In NoKSR, serialization remains an approximation: under very high non-uniformity, some neighbors may still be missed unless the window width $g>0$2 is enlarged, which increases cost. The paper also notes that Python-side code for $g>0$3 and sorting can lag behind a well-engineered CUDA KNN for small point counts, such as $g>0$4k, and mentions a hybrid strategy that switches to KNN when $g>0$5 is small (Li et al., 18 Feb 2025). In PointTPA, the data provided emphasize the absence of explicit radius or $g>0$6-NN search and the use of fixed partitioning; a plausible implication is that patch coherence depends on the locality quality of the chosen space-filling curve and on the stage-wise grouping schedule (Liu et al., 6 Apr 2026).

Taken together, these results position SNG as an efficient alternative to conventional neighborhood construction for large-scale point cloud processing. The evidence in the cited works supports two conclusions. First, serialization can act as a practical surrogate for direct geometric neighborhood search when exactness is not strictly required. Second, the same serialization primitive can support both query-conditioned reconstruction and patch-conditioned dynamic adaptation, indicating that SNG is better characterized as a reusable locality-inducing representation strategy than as a single fixed algorithm.