# EZ-SP: Fast and Lightweight Superpoint-Based 3D Segmentation

Louis Geist, Loic Landrieu, Damien Robert

<figure><img src="image_1.png" /></figure>

## To cite this version:

Louis Geist, Loic Landrieu, Damien Robert. EZ-SP: Fast and Lightweight Superpoint-Based 3D Segmentation. ICRA, IEEE, 2026, Vienna, France. hal-05466889

HAL Id: hal-05466889

https://hal.science/hal-05466889v1

Submitted on 20 Jan 2026

HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

<figure><img src="image_2.png" /></figure>
arXiv:2512.00385v1 [cs.CV] 29 Nov 2025

# EZ-SP: Fast and Lightweight Superpoint-Based 3D Segmentation

Louis Geist¹ Loic Landrieu¹ Damien Robert²

¹ LIGM, ENPC, IP Paris, Univ Gustave Eiffel, CNRS, Marne-la-Vallée, France

² DM3L, University of Zurich, Zurich, Switzerland

**Abstract**— Superpoint-based pipelines provide an efficient alternative to point- or voxel-based 3D semantic segmentation, but are often bottlenecked by their CPU-bound partition step. We propose a learnable, fully GPU partitioning algorithm that generates geometrically and semantically coherent superpoints 13× faster than prior methods. Our module is compact (under 60k parameters), trains in under 20 minutes with a differentiable surrogate loss, and requires no handcrafted features. Combined with a lightweight superpoint classifier, the full pipeline fits in <2 MB of VRAM, scales to multi-million-point scenes, and supports real-time inference. With 72× faster inference and 120× fewer parameters, EZ-SP matches the accuracy of point-based SOTA models across three domains: indoor scans (S3DIS), autonomous driving (KITTI-360), and aerial LiDAR (DALES). Code and pretrained models are accessible at github.com/drprojects/superpointTransformer.

## I. INTRODUCTION

Accurate 3D semantic segmentation is critical for robotic perception, enabling tasks such as autonomous driving [1], navigation [2], [3], and mapping [4]. However, balancing accuracy with computational efficiency remains a major challenge. Real-world point clouds often contain millions of points and must be processed under strict latency constraints—for instance, rotating automotive LiDAR typically acquires 1.3M points per second. Yet, state-of-the-art (SOTA) models routinely exceed ten million parameters, rely on costly test-time augmentation to reach their performance, and can only process small scenes at a time. This gap limits deployment in real-time robotic systems, as well as in AR/VR [5] and large-scale smart city applications [6].

A common strategy to reduce complexity is to group points into superpoints [7], [8]: spatially contiguous, geometrically homogeneous regions. Reasoning on superpoints rather than individual points dramatically reduces memory and computation, while maintaining SOTA or near-SOTA accuracy [9], [10]. However, the partition stage remains a critical bottleneck: often CPU-bound, slow to tune (each parameter sweep may take hours), and requires complex optimization over handcrafted geometric and radiometric features. This overhead in runtime and engineering effort has hampered the broader adoption of superpoint-based methods.

To overcome these limitations, we introduce EZ-SP (easy-superpoints): a lightweight, learnable, fully GPU pipeline to partition and segment raw point clouds into superpoints on the fly. A 60k-parameter backbone produces low-dimensional embeddings optimized to detect semantic transitions directly from raw point clouds and without handcrafted features. We then use a massively parallel clustering algorithm to

<figure><img src="image_3.png" /><figcaption>**Fig. 1:** Inference Speed v.s. Performance v.s. Model Size. Comparison of end-to-end pipelines (preprocessing to inference) on S3DIS. EZ-SP achieves near-SOTA accuracy with only 400k parameters, while being orders of magnitude faster than point-based networks, and the only method to match the acquisition rate of automotive LiDAR (CAR).</figcaption></figure>

produce semantically homogeneous, geometrically simple superpoints—124× faster than the widely used Parallel Cut Pursuit [11], [12]. These superpoints are then processed by a 330k-parameter superpoint segmentation network, yielding dense labels at a fraction of the cost of point- or voxel-based approaches. As shown in fig. 1, our method matches or surpasses SOTA accuracy while delivering over 72× faster end-to-end inference than PointTransformer-v3 [13].

**Key advantages and contributions.** Our approach is:

* **Fast**: partitioning a raw point cloud is over 13× faster than the fastest graph-based approaches; end-to-end inference is over 72× faster than recent SOTA models.

* **Lightweight**: the entire model fits in <2 MB VRAM and trains from scratch in 3 h on a single A6000.

* **Versatile**: The same configuration generalizes across indoor (S3DIS), mobile (KITTI-360), and aerial mapping (DALES) with minimal hyperparameter tuning. Our model runs in real time on small scans (>1.3M pt/s) and scales to city-scale point clouds in a single pass.

* **Scalable**: GPU-only segmentation of tens of millions of
points in a single pass on a single consumer-grade GPU.

## II. RELATED WORK

This section presents an overview of the field of 3D deep learning with a focus on superpoint-based approaches.

**3D Semantic Segmentation.** Deep networks operating directly on raw points or voxels [14], [15], [16] and, more recently, transformers [17], [13] achieve state-of-the-art accuracy but at high computational cost. Models often contain tens of millions of parameters, and both training and inference are resource-intensive, limiting their applicability to real-world large-scale point clouds.

**Superpoint-Based Semantic Segmentation.** Partitioning a scene into superpoints—spatially contiguous, geometrically homogeneous point clusters—drastically reduces computational load by shifting semantic reasoning from points to regions. The Superpoint Graph (SPG) [7] pioneered this approach, achieving competitive results with far fewer resources. The Superpoint Transformer (SPT) [10] advanced the idea with hierarchical partitions and sparse self-attention, reaching SOTA accuracy with only ~200k parameters. Extensions include instance [18], [19], panoptic [20], weakly supervised [21], and self-supervised [22], [23], [24] segmentation. However, all rely on CPU-based, handcrafted partitions, which limit scalability and accuracy.

**Classical Superpoint Partitioning.** Early 3D over-segmentation methods often used supervoxels, e.g., VCCS [8] via voxel-based k-means. Such methods require predefining the number of clusters and are sensitive to initialization, preventing flexibility to scene size and local complexity. Saliency-guided [25] and density-adaptive [26] variants improved boundaries, while graph-based optimization [27], [28], [18], [29], [30] further improved adaptability. Nevertheless, these methods remain CPU-bound and largely depend on handcrafted features and hyperparameters. Sparsification methods [31], [32], [33] lower the number of points but do not produce valid partitions for segmentation. Image-based methods [34] typically project SLIC [35] or SAM [36] superpixel partitions onto 3D points, but require co-registered 2D images, and rely on 2D textures rather than 3D geometry.

**Learning Superpoint Partitions.** Learning partitions is challenging due to the non-differentiability of standard clustering. GPU-friendly k-means [37], [9], [22], [38] and region-offset [39] approaches enable differentiability but inherit k-means' limitations and often require heavy encoders. GraphCut [40] introduces a graph-based heuristic on learned embeddings for instance segmentation, while SAM-Graph [41] transfers priors from large image models to generate superpoints for detection. Supervised SuperPoints (SSP) [42] directly train embeddings to highlight boundaries but still rely on CPU-based Cut Pursuit [12]. Our method replaces the CPU-based solver with a massively parallel approximate algorithm, uses an edge-based surrogate loss, and employs a small (330k-parameter) encoder. In practice,

removing the CPU bottleneck and avoiding fixed cluster counts enable fast, scalable training and inference.

## III. METHOD

We consider a point cloud P composed of points with F features: spatial coordinates and potential radiometric attributes (color, intensity). Each point p has a semantic label cls(p) ∈ [1, C], with C classes. Our goal is to efficiently predict the semantic labels of all points. We first learn low-dimensional embeddings tailored for detecting semantic transitions (section III-A), then propose an efficient GPU-based superpoint partitioning method (section III-B), and finally show how our approach can be interfaced with a superpoint classification model for fast end-to-end semantic segmentation (section III-C). See fig. 2 for a visual overview.

### A. Detecting Semantic Transition

We train a lightweight network to compute point embeddings optimized for detecting semantic transitions.

**Motivation.** Directly embedding points in a semantic space is typically challenging and requires large networks with extensive receptive fields. Instead, we exploit the simpler insight that semantic boundaries usually correspond to sharp contrasts in geometry or radiometry, such as the geometric discontinuity between a chair and the floor, or the change of color between doors and walls. Detecting these semantic transitions is therefore a much simpler problem than semantic segmentation, does not require global information, and should be achievable with a simpler model.

**Point Embedding.** We define the embedding function $\phi^{point}: \mathbb{R}^{|P|} \times F \mapsto \mathbb{R}^{|P|} \times M$, which associates each point p with an M-dimensional embedding vector. We denote by $\mathbf{X} = \phi^{point}(\mathbf{P})$ the embedding matrix.

**Semantic Transition Prediction.** We aim to learn embeddings that remain homogeneous within objects while being sharply contrasted across semantic boundaries. Following Robert et. al. [20], we formulate transition detection as a binary edge classification task. We first define the pairwise affinity between two points p and q as:

$$a_{p,q} = \exp(-\|\mathbf{X}_p - \mathbf{X}_q\|/\tau), \quad (1)$$

with $\tau > 0$ a temperature parameter. We construct an undirected graph (P, E) connecting points with their k nearest neighbours. We define intra-edges, $E_{intra} = \{(p, q) \in E | \text{cls}(p) = \text{cls}(q)\}$, and inter-edges, $E_{inter} = \{(p, q) \in E | \text{cls}(p) \neq \text{cls}(q)\}$. We encourage $a_{p,q} \approx 1$ for intra-edges and $a_{p,q} \approx 0$ for inter-edges with a contrastive loss:

$$\mathcal{L} = \sum_{(p,q) \in E_{\text{intra}}} -\log(a_{p,q}) + \sum_{(p,q) \in E_{\text{inter}}} -\log(1 - a_{p,q}). \quad (2)$$

To improve diversity in the learned embeddings, we apply adaptive sampling by randomly dropping intra-edges until they constitute at most $\rho_{intra}$ of the sampled edges.
<figure><img src="image_4.png" /><figcaption>Fig. 2: **EZ-SP.** A 60k-parameter backbone embeds every point of the input scene into a low-dimensional space where adjacent points from different semantic classes (inter-edges) are pushed apart. A GPU-accelerated algorithm then clusters neighbouring points with similar embeddings, producing semantically homogeneous superpoints. Finally, a lightweight (330k-parameter) superpoint-level network assigns a label to each superpoint, which is broadcast back to its points for dense segmentation.</figcaption></figure>

## B. Fast Superpoint Partitioning

We now present a GPU-accelerated method to efficiently compute a superpoint partition from the learned embeddings.

**Motivation.** Clustering-based approaches such as K-means require a fixed cluster count, and thus struggle with variable scene size and complexity. We adopt a graph-based partition approach by minimizing the following contour-regularized energy [12]:

$$ \arg\min_{\mathbf{Y} \in \mathbb{R}^{\mathbf{P}|\times\mathcal{M}}} \Omega(\mathbf{Y}; \mathbf{X}, \mathbf{E}) \quad \text{with} \quad (3) $$

$$ \Omega(\mathbf{Y}; \mathbf{X}) = \sum_{p \in \mathbf{P}} \|\mathbf{X}_p - \mathbf{Y}_p\|^2 + \lambda \sum_{(p,q) \in \mathcal{E}} w_{p,q} \|\mathbf{Y}_p - \mathbf{Y}_q\|_0, $$

where $\|x\|_0 = 0$ if $x = 0$ or otherwise 1; $w_{p,q} > 0$ are edge weights; $\lambda > 0$ the regularization strength. Minimizing this energy produces a piecewise-constant approximation $\mathbf{Y}$ of the embeddings $\mathbf{X}$, whose components form our superpoints. As $\mathbf{X}$ is trained to be homogeneous within objects and contrasted at their interface, the superpoints should be semantically coherent. Existing solvers for eq. (3) are typically CPU-bound [11], which can become computational bottlenecks.

**Combinatorial Clustering.** We recast the non-continuous, non-convex optimization problem of eq. (3) as a combinatorial problem which we can efficiently approximate with a parallel greedy bottom-up merging strategy. Let $\mathcal{P}$ denote a partition of $\mathbf{P}$ into superpoints: each superpoint $P \in \mathcal{P}$ defines a connected component of the graph $(\mathbf{P}, \mathbf{E})$ and $\cup_{P \in \mathcal{P}} = \mathbf{P}$. We define the adjacency between superpoints as follows:

$$ \mathcal{E} = \{(P, Q) \in \mathcal{P}^2 \mid \exists (p, q) \in \mathbf{E}, p \in P, q \in Q\}. \quad (4) $$

We associate each superpoint $P$ with its mean embedding:

$$ \mathbf{X}_P = \frac{1}{|P|} \sum_{p \in P} \mathbf{X}_p. \quad (5) $$

We then define the point embedding matrix $\mathbf{X}^\mathcal{P}$ in $\mathbb{R}^{\mathbf{P}|\times\mathcal{M}}$ which associates each point $p$ with the value $\mathbf{X}_p$ of the superpoint $P$ it belongs to:

$$ \mathbf{X}_p^\mathcal{P} = \mathbf{X}_P \quad \text{for } P \text{ such that } p \in P. \quad (6) $$

<figure><img src="image_5.png" /><figcaption>Fig. 3: **Parallel Combinatorial Partition.** Our algorithm greedily approximates a graph signal with piecewise-constant components. Conflicting merges (nodes with multiple outgoing edges) are removed, enabling an efficient parallel implementation on GPUs.</figcaption></figure>

This allows us to restate eq. (3) as a combinatorial problem of minimizing $\Omega(\mathcal{P}) = \Omega(\mathbf{X}^\mathcal{P}; \mathbf{X}, \mathbf{E})$ with respect to $\mathcal{P}$. To do so, we use the following proposition:

**Proposition 1.** *Merging adjacent superpoints $(P, Q) \in \mathcal{E}$ decreases $\Omega(\mathcal{P})$ by the following edge merge gain:*

$$ \Delta(P, Q) = - \frac{|P||Q|}{|P| + |Q|} \|\mathbf{X}_P - \mathbf{X}_Q\|^2 + \lambda \sum_{(p,q) \in (P \times Q) \cap \mathcal{E}} w_{p,q}. \quad (7) $$

**Parallel Implementation.** The combinatorial problem defined above can be approximated with a greedy merging strategy: at each step, adjacent superpoints $(P, Q)$ with the energy gain $\Delta(P, Q)$ are merged. This process is inherently sequential, since each merge alters subsequent gains, making naive approaches ill-suited for GPUs. We therefore propose a bottom-up, GPU-parallel algorithm, illustrated in fig. 3:

0. **Initialization.** Each point is its own superpoint: $\mathcal{P} = \{\{p\} | p \in \mathbf{P}\}$ with adjacency $\mathcal{E} = \mathbf{E}$.
<figure><img src="image_6.png" /><figcaption>Fig. 4: **Partition Examples.** Visualization of point cloud partitions across three datasets and three partitioning algorithms. Section III-B shows the full dataset sizes; we also report, for each configuration, the resulting number of superpoints and the partition purity over the validation dataset (all folds for S3DIS).</figcaption></figure>

1. **Candidate Merges.** We construct $\mathcal{E}_{merge}$ the set of directed edges ($P \to Q$) for ($P, Q \in \mathcal{E}$) satisfying either $\Delta(P, Q) > 0$ or $|P| < \sigma_{min}$, where $\sigma_{min}$ is the minimum superpoint size. If $\mathcal{E}_{merge}$ is empty, return $\mathcal{P}$.

2. **Conflict Removal.** To prevent conflicting merges, each superpoint may appear at most once as a source in $\mathcal{E}_{merge}$. For each $P$, we retain only the outgoing edge ($P \to \cdot$) with the highest merge gain $\Delta$.

3. **Merging.** The remaining edges $\mathcal{E}_{merge}$ define a directed merge graph ($\mathcal{P}, \mathcal{E}_{merge}$). We compute its weakly connected components and update $\mathcal{P}$ with the resulting merged sets. This allows chain merges (e.g. ($P \to R$) and ($Q \to R$)) to be resolved in a single iteration.

4. **Recalibration.** Update the node embeddings and merge gains for the new adjacency graph, then return to Step 1.

Our approach makes heavy use of the highly optimized `scatter` operation [43], enabling efficient GPU parallelization. Detailed pseudo-code and proofs of correctness will be released alongside an open-source GPU implementation.

**Hierarchical Partition.** The proposed algorithm can be applied recursively to produce a *hierarchical* set of partitions, i.e. $\mathcal{P}^{(1)}, \dots, \mathcal{P}^{(L)}$, where $\mathcal{P}^{(1)}$ is a partition of $\mathbf{P}$ and $\mathcal{P}^{(l+1)}$ is a partition of $\mathcal{P}^{(l)}$. This is straightforward to implement by maintaining the adjacency graph between components at each stage. Such multi-scale partitioning is useful for downstream processing, as discussed in the next section.

### C. Semantic Segmentation

Once the initial point cloud $\mathbf{P}$ is partitioned into superpoints $\mathcal{P}$, we can apply a superpoint-based classifier to predict their semantic labels. Labels are then broadcast from superpoints back to their constituent points, allowing the inference stage to operate entirely on the much smaller set $\mathcal{P}$ while still producing dense predictions over $\mathbf{P}$.

**Superpoint Classification.** For classification, we employ the SuperPoint Transformer (SPT) [10] due to its strong balance between accuracy and efficiency. We retain the default configuration with three key modifications:

* **Simplified Hyperparameters:** We remove all CPU-bound preprocessing and their hyperparameters. Partition coarseness is controlled solely by one parameter per partition level: the minimum superpoint size.

* **Efficient GPU Pipeline:** because partitioning is fully GPU-based, vectorized operations run faster, and costly CPU-GPU data transfers are eliminated or optimized.

* **Hierarchical Architecture:** we preserve most of the original SPT design but extend it to three nested partition levels to leverage our hierarchical superpoints.

## IV. EXPERIMENTS

We evaluate EZ-SP on three large-scale 3D segmentation benchmarks. We first outline the experimental setup (section IV-A), then assess partition quality and efficiency
(section IV-B). Next, we report semantic segmentation performance with a downstream superpoint classifier (section IV-C), followed by an ablation study (section IV-D).

## A. Experimental Setting

**Datasets.** We evaluate on three datasets covering various sensing modalities and scales:

* **S3DIS** [44]: Indoor scans of six large building floors, totaling 273M points annotated in 13 classes. Following [15], we use the *merged* version, where each floor is treated as a single point cloud.

* **KITTI-360** [45]: Mobile mapping LiDAR with 919M points and 15 classes, spanning 300 large-scale urban scenes, including 61 validation scans.

* **DALES** [46]: Aerial LiDAR over urban and suburban areas with 492M points across 8 classes, comprising 40 scans, 12 reserved for evaluation.

We subsample all point clouds on a regular grid: 3 cm for S3DIS, 10 cm for KITTI-360 and DALES.

**Implementation Details.** For partitioning, we fix $\tau=1$ in eq. (1), $w_{\rho,q}=1$, and build adjacency from the 8-nearest neighbors. The regularization in eq. (3) is $\lambda=0.02$, and the intra-edge sampling ratio in eq. (2) is $\rho_{\text{intra}}=0.1$ for S3DIS and 0.3 for KITTI-360/DALES.

The backbone $\phi^{\text{point}}$ is a sparse CNN [47] implemented with TorchSparse [48], with three layers of width [32, 32, 32]. Kernels are 3³ except in the first layer for KITTI-360/DALES ($7^3$). The embedding dimension is $M=32$, yielding models of 58k (S3DIS), 89k (KITTI-360), and 67k (DALES) parameters. We compute three-level hierarchical partitions with minimal superpoint sizes of [5, 30, 90] (S3DIS/KITTI-360) and [5, 15, 70] (DALES).

For segmentation, we use a modified SPT-64 on S3DIS and DALES, and an SPT-128 on KITTI-360: we add a third hierarchical stage, reinstate the feed-forward layer in the transformer block (for DALES only), and concatenate color, position, and elevation with the CNN feature map to form the point embeddings. This yields segmentation heads with 330k (S3DIS), 870k (KITTI-360), and 425k (DALES) parameters. To fight class imbalance, we trained with a focal loss [49] ($\gamma = 1$ for S3DIS and $\gamma = 2$ for KITTI-360/DALES). All models are trained with Adam (default hyperparameters) and cosine learning rate scheduling with 50 warm-up epochs.

## B. Oversegmentation Results

We compare the quality of EZ-SP's partitions against classical and learning-based oversegmentation methods.

**Metrics.** We follow the common practice of evaluating oversegmentation, i.e. partitioning a point cloud into compact regions that ideally align with semantic objects. Since the downstream classifier operates on superpoints, partition quality is measured by two criteria: the number of superpoints produced and the oracle mIoU [42], defined as the mIoU obtained by assigning each superpoint its majority ground-truth label. This provides an upper bound on the segmentation accuracy achievable with a given partition. We also report

throughput, obtained either from official model logs or from our own re-runs. All measurements are conducted on comparable Ampere- or Ada-generation GPUs.

**Baselines and Competing Methods.** We compare against:

* **Voxelization:** Uniform voxel grid grouping.

* **VCCS** [8]: A classical voxel-based oversegmentation based on $k$-means.

* **Parallel Cut Pursuit (PCP)** [11]: The updated graph-cut partitioner [12] used in SPT [10].

* **SPNet** [9]: Learns partitions via differentiable $k$-means.

**Results.** Figure 5 reports the purity of the partition obtained by all methods on three benchmarks, along with their throughput. EZ-SP consistently achieves a purity higher or on par with the best oversegmentation methods for the same number of superpoints, while being a full order of magnitude faster. The purity of VCCS's and SPNet's superpoints is limited by their reliance on the rigid $k$-means algorithm. Moreover, VCCS's CPU-based implementation limits its throughput. SPNet, despite being trained for partitioning, underperforms in purity and requires ~6 h of training, against fewer than 20 minutes for EZ-SP. Voxelization naturally remains the fastest partitioning algorithm, but also yields the least semantically pure partitions.

**Qualitative Analysis.** We report qualitative examples of partitions in fig. 4. The $k$-means-based method VCCS fails to adapt to local complexity and produces partitions that resemble uniform tessellations. PCP adapts better to variations in complexity, but still tessellates large, simple surfaces. In contrast, EZ-SP yields the most adaptive partitions: it produces large, semantically pure superpoints on simple structures such as ground, roofs, or walls, while allocating small superpoints to geometrically complex regions.

## C. Semantic Segmentation

Table I reports both accuracy and efficiency for a range of SOTA semantic segmentation models. All methods are trained only on the official training split of each dataset, without using any external data.

**Analysis.** Superpoint-based methods consistently deliver competitive accuracy with 100–200× fewer parameters than typical point- or voxel-based networks. Yet their inference speed is often constrained by the CPU-bound partitioning stage, which can dominate runtime. EZ-SP removes this bottleneck, yielding much faster end-to-end inference while retaining top-tier accuracy. With fewer than 400k parameters (under 2 MB of VRAM), it ranks among the smallest models in this comparison—orders of magnitude lighter than many voxel- or point-based alternatives. In terms of inference speed, EZ-SP is unmatched: faster even than PointNet++, while maintaining strong performance across all datasets. Its accuracy trails SOTA large models by less than 2 mIoU points, comparable to SPT and well within the expected variance of training and macro-averaged evaluation metrics.

In contrast, modern point- and voxel-based architectures such as PointNeXt [50], Stratified Transformer [17], and
<figure><img src="image_7.png" /><figcaption>Fig. 5: **Oversegmentation Performance.** Oracle mIoU as a function of the number of superpoints on S3DIS, KITTI-360, and DALES. We also report the throughput (from raw points to superpoints) on S3DIS, with error bars indicating variance across configurations. EZ-SP achieves partition purity comparable to or better than PCP while being over 13× faster.</figcaption></figure>

<table><caption>TABLE I: **Efficiency and Performance.** End-to-end processing time on the full S3DIS dataset (273M points), broken down by stage. We also compare model size and semantic segmentation performance on S3DIS, KITTI-360, and DALES.</caption><thead><tr><th rowspan="3">Model</th><th rowspan="3"></th><th colspan="4">Inference time (in GPU-s) ↓</th><th rowspan="3">Size ↓<br/>×10<sup>6</sup><br/>params.</th><th colspan="4">Performance (mIoU) ↑</th></tr><tr><th rowspan="2">◇</th><th rowspan="2">X</th><th rowspan="2">◇</th><th rowspan="2">◇</th><th colspan="2">S3DIS</th><th colspan="2">K-360</th></tr><tr><th>6-Fold</th><th>Area 5</th><th>val</th><th>test</th></tr></thead><tbody><tr><td rowspan="6">point/voxel</td><td>PointNet++ [14]</td><td>125</td><td>-</td><td>52</td><td>177</td><td>3.0</td><td>56.7</td><td>-</td><td>-</td><td>68.3</td></tr><tr><td>KPCConv [15]</td><td>1031</td><td>-</td><td>354</td><td>1385</td><td>14.1</td><td>70.6</td><td>67.1</td><td>-</td><td><strong>81.1</strong></td></tr><tr><td>MinkowskiNet [16]</td><td>887</td><td>-</td><td>302</td><td>1189</td><td>37.9</td><td>69.1</td><td>65.4</td><td>58.3</td><td>-</td></tr><tr><td>PointNeXt-XL [50]</td><td>-</td><td>-</td><td>66k</td><td>66k</td><td>41.6</td><td>74.9</td><td>71.1</td><td>-</td><td>-</td></tr><tr><td>Strat. Trans. [17]</td><td>-</td><td>-</td><td>26k</td><td>26k</td><td>8.0</td><td>74.9</td><td>72.0</td><td>-</td><td>74.3</td></tr><tr><td>PTv3 [13]</td><td>-</td><td>-</td><td>11k</td><td>11k</td><td>46.2</td><td><strong>77.7</strong></td><td><strong>73.4</strong></td><td>-</td><td>-</td></tr><tr><td rowspan="5">superpoint</td><td>SPG [7]</td><td>3187</td><td>2616</td><td>56</td><td>5859</td><td>0.28</td><td>62.1</td><td>58.0</td><td>-</td><td>60.6</td></tr><tr><td>SSP [42]</td><td>3220</td><td>2616</td><td>56</td><td>5892</td><td>0.29</td><td>68.4</td><td>61.7</td><td>-</td><td>-</td></tr><tr><td>SPNet [9]</td><td>3187</td><td>445</td><td>56</td><td>3688</td><td>0.33</td><td>68.7</td><td>-</td><td>-</td><td>-</td></tr><tr><td>SPT [10]</td><td>376</td><td>418</td><td><strong>14</strong></td><td>808</td><td><strong>0.21</strong></td><td>76.0</td><td>68.9</td><td><strong>63.5</strong></td><td>79.6</td></tr><tr><td><strong>EZ-SP(ours)</strong></td><td><strong>136</strong></td><td><strong>3</strong></td><td><strong>14</strong></td><td><strong>153</strong></td><td>0.39</td><td>76.1</td><td>69.6</td><td>62.0</td><td>79.4</td></tr></tbody></table>

PointTransformer-v3 [13] can be extremely slow at inference, in part due to heavy test-time augmentation (TTA). Removing TTA reduces accuracy by -1.5 mIoU on S3DIS Area 5 for Stratified Transformer and by -1.6 for PTv3, yet they still remain significantly slower than our approach (e.g., PTv3 requires 988 s on S3DIS without TTA).

**Qualitative Analysis.** Figure 6 shows semantic segmentations produced by EZ-SP across indoor, outdoor, and aerial domains. Predictions remain reliable even in complex environments, with most errors arising from the ambiguous *clutter* class, and cases that are inherently difficult to partition into superpoints due to low geometric and radiometric contrasts at their interface, such as a whiteboard against a white wall. At the same time, EZ-SP accurately captures fine details such as furniture edges, vehicle boundaries, and roof structures. Overall, it achieves high-quality segmentation while delivering orders of magnitude faster inference than existing approaches.

**Breaking the Partition Bottleneck.** Figure 7 details the breakdown of end-to-end inference time across different pipeline stages for Superpoint Transformer [10] and our

proposed EZ-SP—excluding I/O, which largely depends on dataset format, e.g. plain `.txt` vs. binary `.ply` files. For SPT, the CPU-bound partition stage dominates computation time; in EZ-SP, this cost is virtually eliminated due to our GPU-based implementation and the removal of handcrafted point features. Additional minor optimizations further reduce runtime in other stages. Beyond speed, EZ-SP is also easier to deploy and tune, as it avoids the complex feature engineering and hyperparameters optimization required by traditional superpoint partitioning methods.

**Memory Efficiency.** As shown in table II, EZ-SP processes full scans *in a single pass, without tiling*, across scenarios ranging from real-time inference on a single Velodyne64 sweep to city-scale aerial surveys. A single LiDAR rotation runs on an embedded Jetson device (< $200), while an entire S3DIS floor (68 rooms) fits on a consumer GPU (< $1000). Even 1.3 km² of aerial LiDAR from DALES can be handled at once on an NVIDIA A40 (~ $3000).
<figure><img src="image_8.png" /><figcaption>Fig. 6: **Semantic Segmentation.** Qualitative results on three benchmarks: section IV-B S3DIS, section IV-B KITTI-360, and section IV-B DALES. For each dataset, we show the input point cloud (RGB for S3DIS and KITTI-360, LiDAR intensity for DALES), the ground-truth labels, and the predictions of EZ-SP.</figcaption></figure>

<figure><img src="image_9.png" /><figcaption>Fig. 7: **Computation Breakdown.** Breakdown of runtime comparison between SPT and EZ-SP for S3DIS 6-Fold.</figcaption></figure>

<table><caption>TABLE II: **Scalability of EZ-SP.** From a single LiDAR scan to a city-scale aerial survey, entire scenes can be processed in one pass on embedded or commercial-grade GPU memory.</caption><thead><tr><th>Scenario</th><th>Points</th><th>VRAM</th><th>Compatible Hardware</th></tr></thead><tbody><tr><td><strong>Autonomous driving</strong><br>single LiDAR scan</td><td>105k pts</td><td>EZ-SP: 0.25 GB<br>MinkowskiNet: 0.52 GB</td><td>Jetson-Nano</td></tr><tr><td><strong>Digital twin</strong><br>building-scale</td><td>79M pts</td><td>EZ-SP: 29 GB<br>MinkowskiNet: 30 GB</td><td>2x Radeon RX<br>7900: 40GB</td></tr><tr><td><strong>Aerial survey</strong><br>city-scale, 1.3 km²</td><td>16M pts</td><td>EZ-SP: 45 GB<br>MinkowskiNet: OoM</td><td>A40<br>48GB</td></tr></tbody></table>

## D. Ablation Study

We assess the contribution of each component of our approach through the ablations summarized in table III. For ablations A, B, and D, we retrain our SPT model from scratch.

* **A: Learning to Partition.** Replacing our lightweight CNN (section IV-B) with handcrafted geometric features [51], [28] yields comparable performance. This demonstrates that our approach eliminates the need for handcrafted inputs, as the CNN learns features of similar expressivity, while reducing manual engineering.

* **B: Hierarchical Levels.** Adding a third hierarchical level
<table><caption>TABLE III: Ablation. Performance of variants of EZ-SP.</caption><thead><tr><th>Configuration</th><th>S3DIS Fold5<br>mIoU</th><th>Throughput<br>×10<sup>6</sup> pt/s</th></tr></thead><tbody><tr><td><strong>Best</strong></td><td>69.6</td><td>1.7</td></tr><tr><td>A Handcrafted features</td><td>69.5</td><td>1.7</td></tr><tr><td>B 2 hierarchical levels</td><td>67.2</td><td>1.7</td></tr><tr><td>C No optimization</td><td>-</td><td>0.8</td></tr><tr><td>D PCP</td><td>67.8</td><td>0.3</td></tr></tbody></table>

to our SPT improves accuracy with negligible impact on throughput.

* **C: Optimizations.** The various implementation optimizations over the original SPT codebase (CPU-GPU transfer, GPU-bound feature computation) do not impact the performance but double our throughput.

* **D: Partition Algorithm.** Replacing our GPU partition algorithm with the original CPU-based PCP [11] based on handcrafted features (as in SPT) reduces throughput substantially, while delivering slightly lower accuracy. As in Robert et al. [10], we find that the 3-level PCP partition does not improve performance, unlike ablation B, suggesting that despite comparable oracle mIoU, our superpoint partition's hierarchical structure is more informative than PCP's.

## V. CONCLUSION

We presented EZ-SP, a fast and lightweight superpoint partitioning model that removes the long-standing partitioning bottleneck in superpoint-based 3D semantic segmentation. Our end-to-end pipeline can process 1.7M points/s on a single consumer grade GPU and achieves near-state-of-the-art accuracy in indoor, terrestrial, and aerial LiDAR benchmarks. By drastically lowering runtime costs, EZ-SP opens the door to efficient analysis of massive 3D scans and real-time perception on resource-constrained and embedded platforms.

**Acknowledgements.** This work was supported by ANR project ANR-23-PEIA-0008, and was granted access to the HPC resources of IDRIS under the allocation AD011015519R1 and AD011015196R1 made by GENCI. We thank Davide Allegro for inspiring discussions and valuable feedback.

## REFERENCES

[1] R. Loiseau, M. Aubry, and L. Landrieu, "Online segmentation of LiDAR sequences: Dataset and algorithm," *ECCV*, 2022.

[2] S. Xu, D. Honegger, M. Pollefeys, and L. Heng, "Real-time 3D navigation for autonomous vision-guided MAVs," in *IROS*, 2015.

[3] F. L. Busch, T. Homberger, J. Ortega-Peimbert, Q. Yang, and O. Andersson, "One map to find them all: Real-time open-vocabulary mapping for zero-shot multi-object navigation," in *ICRA*, 2025.

[4] P. Pfaff, R. Triebel, C. Stachniss, P. Lamon, W. Burgard, and R. Siegwart, "Towards mapping of cities," in *ICRA*, 2007.

[5] Z. Makhataeva and H. A. Varol, "Augmented reality for robotics: A review," *Robotics*, 2020.

[6] N. K. Beigi, B. Partov, and S. Farokhi, "Real-time cloud robotics in practical smart city applications," in *PIMRC*, 2017.

[7] L. Landrieu and M. Simonovsky, "Large-scale point cloud semantic segmentation with superpoint graphs," *CVPR*, 2018.

[8] J. Papon, A. Abramov, M. Schoeler, and F. Worgotter, "Voxel cloud connectivity segmentation-supervoxels for point clouds," *CVPR*, 2013.

[9] L. Hui, J. Yuan, M. Cheng, J. Xie, X. Zhang, and J. Yang, "Superpoint network for point cloud oversegmentation," *ICCV*, 2021.

[10] D. Robert, H. Raguet, and L. Landrieu, "Efficient 3D semantic segmentation with superpoint transformer," in *ICCV*, 2023.

[11] H. Raguet and L. Landrieu, "Parallel cut pursuit for minimization of the graph total variation," *ICML Workshop on Graph Reasoning*, 2019.

[12] L. Landrieu and G. Obozinski, "Cut pursuit: Fast algorithms to learn piecewise constant functions on general weighted graphs," in *SIAM Journal on Imaging Sciences*, 2017.

[13] X. Wu, L. Jiang, P.-S. Wang, Z. Liu, X. Liu, Y. Qiao, W. Ouyang, T. He, and H. Zhao, "Point transformer v3: Simpler faster stronger," in *CVPR*, 2024.

[14] C. R. Qi, L. Yi, H. Su, and L. J. Guibas, "PointNet++: Deep hierarchical feature learning on point sets in a metric space," *NeurIPS*, 2017.

[15] H. Thomas, C. R. Qi, J.-E. Deschaud, B. Marcotegui, F. Goulette, and L. J. Guibas, "KPConv: Flexible and deformable convolution for point clouds," *ICCV*, 2019.

[16] C. Choy, J. Gwak, and S. Savarese, "4D spatio-temporal ConvNets: Minkowski convolutional neural networks," *CVPR*, 2019.

[17] X. Lai, J. Liu, L. Jiang, L. Wang, H. Zhao, S. Liu, X. Qi, and J. Jia, "Stratified transformer for 3D point cloud segmentation," *CVPR*, 2022.

[18] Z. Liang, Z. Li, S. Xu, M. Tan, and K. Jia, "Instance segmentation in 3D scenes using semantic superpoint tree networks," *CVPR*, 2021.

[19] J. Sun, C. Qing, J. Tan, and X. Xu, "Superpoint transformer for 3D scene instance segmentation," in *AAAI*, 2023.

[20] D. Robert, H. Raguet, and L. Landrieu, "Scalable 3D panoptic segmentation as superpoint graph clustering," in *3DV*, 2024.

[21] Z. Liu, X. Qi, and C.-W. Fu, "One thing one click: A self-training approach for weakly supervised 3D semantic segmentation," in *CVPR*, 2021.

[22] Z. Zhang, B. Yang, B. Wang, and B. Li, "GrowSP: Unsupervised semantic segmentation of 3D point clouds," *CVPR*, 2023.

[23] L. Nunes, R. Marcuzzi, X. Chen, J. Behley, and C. Stachniss, "Segment-Contrast: 3D point cloud feature representation learning through self-supervised segment discrimination," *IEEE Robotics and Automation Letters*, 2022.

[24] J. Liu, Z. Yu, T. P. Breckon, and H. P. H. Shum, "U3DS3: Unsupervised 3D semantic scene segmentation," *WACV*, 2023.

[25] G. Gao, M. Lauri, J. Zhang, and S. Frintrop, "Saliency-guided adaptive seeding for supervoxel segmentation," in *IROS*, 2017.

[26] Y. Lin, C. Wang, D. Zhai, W. Li, and J. Li, "Toward better boundary preserved supervoxel segmentation for 3D point clouds," *ISPRS journal of photogrammetry and remote sensing*, 2018.

[27] Y. Ben-Shabat, T. Avraham, M. Lindenbaum, and A. Fischer, "Graph based over-segmentation methods for 3D point clouds," *Computer Vision and Image Understanding*, 2017.

[28] S. Guinard and L. Landrieu, "Weakly supervised segmentation-aided classification of urban scenes from 3D LiDAR point clouds," *ISPRS Workshop*, 2017.

[29] L. Han, T. Zheng, L. Xu, and L. Fang, "Occuseg: Occupancy-aware 3D instance segmentation," *CVPR*, 2020.

[30] A. Thyagharajan, B. Ummenhofer, P. Laddha, O. J. Omer, and S. Subramoney, "Segment-fusion: Hierarchical context fusion for robust 3D semantic segmentation," *CVPR*, 2022.

[31] S. Jin, I. Armeni, M. Pollefeys, and D. Barath, "Multiway point cloud mosaicking with diffusion and global optimization," in *CVPR*, 2024.

[32] Z. J. Yew and G. H. Lee, "Regtr: End-to-end point cloud correspondences with transformers," in *CVPR*, 2022.

[33] Y. Zhu, L. Hui, Y. Shen, and J. Xie, "SPGroup3D: Superpoint grouping network for indoor 3D object detection," in *AAAI*, 2024.

[34] Y. Yang, X. Wu, T. He, H. Zhao, and X. Liu, "SAM3D: Segment anything in 3D scenes," *arXiv:2306.03908*, 2023.

[35] R. Achanta, A. Shaji, K. Smith, A. Lucchi, P. Fua, and S. Susstrunk, "SLIC superpixels compared to state-of-the-art superpixel methods," *TPAMI*, 2012.

[36] A. Kirillov, E. Mintun, N. Ravi, H. Mao, C. Rolland, L. Gustafson, T. Xiao, S. Whitehead, A. C. Berg, W.-Y. Lo et al., "Segment anything," in *ICCV*, 2023.

[37] M. Cheng, L. Hui, J. Xie, J. Yang, and H. Kong, "Cascaded non-local neural network for point cloud semantic segmentation," in *ROS*, 2020.

[38] D. Lu, L. Xu, J. Zhou, K. Y. Gao, and J. Li, "3DLST: 3D learnable supertoken transformer for LiDAR point cloud scene segmentation," *International Journal of Applied Earth Observation and Geoinformation*, 2025.

[39] X. Kang, C. Wang, and X. Chen, "Region-enhanced feature learning for scene semantic segmentation," *arXiv:2304.07486*, 2023.
[40] L. Hui, L. Tang, Y. Shen, J. Xie, and J. Yang, "Learning superpoint graph cut for 3D instance segmentation," *NeurIPS*, 2022.

[41] H. Guo, H. Zhu, S. Peng, Y. Wang, Y. Shen, R. Hu, and X. Zhou, "SAM-guided graph cut for 3D instance segmentation," in *ECCV*, 2024.

[42] L. Landrieu and M. Boussaha, "Point cloud oversegmentation with graph-structured deep metric learning," *CVPR*, 2019.

[43] M. Fey and J. E. Lenssen, "Fast graph representation learning with PyTorch Geometric," in *ICLR Workshop*, 2019.

[44] I. Armeni, O. Sener, A. R. Zamir, H. Jiang, I. Brilakis, M. Fischer, and S. Savarese, "3D semantic parsing of large-scale indoor spaces," *CVPR*, 2016.

[45] Y. Liao, J. Xie, and A. Geiger, "KITTI-360: A novel dataset and benchmarks for urban scene understanding in 2D and 3D," *TPAMI*, 2022.

[46] N. Varney, V. K. Asari, and Q. Graehling, "DALES: A large-scale aerial LiDAR data set for semantic segmentation," *CVPR Workshops*, 2020.

[47] B. Graham, M. Engelcke, and L. Van Der Maaten, "3D semantic segmentation with submanifold sparse convolutional networks," *CVPR*, 2018.

[48] H. Tang, S. Yang, Z. Liu, K. Hong, Z. Yu, X. Li, G. Dai, Y. Wang, and S. Han, "Torchsparse++: Efficient training and inference framework for sparse convolution on gpus," in *MICRO*, 2023.

[49] T.-Y. Lin, P. Goyal, R. Girshick, K. He, and P. Dollár, "Focal loss for dense object detection," in *ICCV*, 2017.

[50] G. Qian, Y. Li, H. Peng, J. Mai, H. Hammoud, M. Elhoseiny, and B. Ghanem, "PointNeXt: Revisiting PoinNet++ with improved training and scaling strategies," *NeurIPS*, 2022.

[51] J. Demantké, C. Mallet, N. David, and B. Vallet, "Dimensionality based scale selection in 3D LiDAR point clouds," in *Laserscanning*, 2011.

[52] T. Chaton, N. Chaulet, S. Horache, and L. Landrieu, "Torch-Points3D: A modular multi-task framework for reproducible deep learning on 3D point clouds," *3DV*, 2020.

[53] "Pytorch implementation of PointNet and PointNet++," https://github.com/yanx27/Pointnet_Pointnet2_pytorch, accessed: 2025-09-01.

[54] "PointNet++ torch points3d logs," https://wandb.ai/nicolas/s3dis/runs/svp512w7/logs, accessed: 2025-09-01.

[55] "KPCConv torch points3d logs," https://wandb.ai/nicolas/s3dis/runs/lr1dr257/logs, accessed: 2025-09-01.

[56] "MinkowskiNet torch points3d logs," https://wandb.ai/nicolas/s3dis/runs/17se1ykh/logs, accessed: 2025-09-01.

[57] "PointNeXt model zoo and logs," https://guochengqian.github.io/PointNeXt/modelzoo, accessed: 2025-09-01.

[58] "Official Stratified Transformer GitHub repository," https://github.com/dvlab-research/Stratified-Transformer, accessed: 2025-09-01.

[59] "Pointcept GitHub repository," https://github.com/Pointcept/Pointcept, accessed: 2025-09-01.

[60] "Point Transformer v3 Hugging Face repository," https://huggingface.co/Pointcept/PointTransformerV3, accessed: 2025-09-01.

[61] "Superpoint Graph GitHub repository," https://github.com/loicland/superpoint_graph, accessed: 2025-09-01.

[62] "SPNet GitHub repository," https://github.com/fpthink/SPNet, accessed: 2025-09-01.

[63] "Superpoint Transformer GitHub repository," https://github.com/drprojects/superpointTransformer, accessed: 2025-09-01.
**Algorithm 1:** Weakly Connected Components by Max Propagation

**Input** : Number of nodes N, undirected edges E
**Output** Component assignment vector
: $I \in \{0, ..., C-1\}^N$

**Function** wcc_max_prop (N, E):

```python
// random index per node
I ← randperm(N)
// max-pool on neighbors
I_max ← maxPropagation(I, E)
if I_max = I then
    return I
I_consec ← to_consecutive_ids(I_max)
// merge nodes with same I_consec
E_comp ← component_graph(I_consec, E)
N_comp ← max(I_consec) + 1
// recursive call
I_rec ← wcc_maxProp(N_comp, E_comp)
// distribute component labels
I_comp ← I_rec[I_consec]
return I_comp
```

# APPENDIX

In this document, we prove Proposition 1 (A-1), provide the pseudo for our partition algorithm (A-2), detail how we measure the computation breakdown across all methods (A-3), and provide further implementation details (A-4).

## A-1. PROOF OF PROPOSITION 1

**Proposition 1.** Merging adjacent superpoints $(P, Q) \in \mathcal{E}$ decreases $\Omega(\mathcal{P})$ by the following edge merge gain:

$$ \Delta(P, Q) = - \frac{|P||Q|}{|P| + |Q|} \|\mathbf{X}_P - \mathbf{X}_Q\|^2 + \lambda \sum_{(p,q) \in (P \times Q) \cap \mathcal{E}} w_{P,q}. \quad (A-8) $$

*Proof.* We can write the energy of the partition $\mathcal{P}$ as:

$$ \Omega(\mathcal{P}) = \sum_{U \in \mathcal{P}} \sum_{p \in U} \|\mathbf{X}_p - \mathbf{X}_U\|^2 + \lambda \sum_{(p,q) \in \mathcal{E}} w_{p,q} \|\mathbf{X}_p - \mathbf{X}_q\|_0 \quad (A-9) $$

$$ = \sum_{U \in \mathcal{P}} \left( \sum_{p \in U} \|\mathbf{X}_p\|^2 - |U| \|\mathbf{X}_U\|^2 \right) + \lambda \sum_{(U,V) \in \mathcal{E}} w_{U,V}, \quad (A-10) $$

$$ \text{where } w_{U,V} = \sum_{(p,q) \in (U \times V) \cap \mathcal{E}} w_{p,q}. $$

We define $\mathcal{P}'$ the modified partition in which P and Q are merged:

$$ \Omega(\mathcal{P}') = \sum_{U \in \mathcal{P}'} \left( \sum_{p \in U} \|\mathbf{X}_p\|^2 - |U| \|\mathbf{X}_U\|^2 \right) + \lambda \left( \sum_{(U,V) \in \mathcal{E}} w_{U,V} - w_{P,Q} \right). \quad (A-11) $$

We denote the new superpoint $R$ obtained by the merge of $P$ and $Q$:

$$ \begin{aligned} \mathbf{X}_R &= \frac{1}{|P| + |Q|} \sum_{p \in P \cup Q} \mathbf{X}_p \\ &= \frac{|P|\mathbf{X}_P + |Q|\mathbf{X}_Q}{|P| + |Q|}. \end{aligned} \quad (A-12) $$

We compute $\Delta(P, Q)$ the gain in energy of this merge:

$$ \begin{aligned} \Delta(P, Q) &= \Omega(\mathcal{P}) - \Omega(\mathcal{P}') \\ &= |R|\|\mathbf{X}_R\|^2 - \sum_{p \in P \cup Q} \|\mathbf{X}_p\|^2 \\ &\quad - |P|\|\mathbf{X}_P\|^2 - |Q|\|\mathbf{X}_Q\|^2 + \sum_{p \in P \cup Q} \|\mathbf{X}_p\|^2 \\ &\quad + \lambda w_{P,Q} \\ &= |R|\|\mathbf{X}_R\|^2 - |P|\|\mathbf{X}_P\|^2 - |Q|\|\mathbf{X}_Q\|^2 + \lambda w_{P,Q} \end{aligned} \quad (A-13) $$

$$ = - \frac{|P||Q|}{|P| + |Q|} \|\mathbf{X}_P - \mathbf{X}_Q\|^2 + \lambda w_{P,Q}. \quad (A-14) $$

□

## A-2. GPU-BASED PARTITION IMPLEMENTATION

We provide here the pseudocode of our parallelized greedy partition algorithm introduced in Section III-A. Our approach relies on two recursive algorithms: Algorithm 1 computing the weakly connected components of a graph and Algorithm 2 merging nodes of a graph based on their energy.

We implemented both algorithms relying solely on CUDA-accelerated PyTorch operations. Note that both algorithms are recursive, which significantly reduces complexity.

## A-3. BENCHMARKING PROCESSING SPEEDS

We detail here how the S3DIS preprocessing, partition, and segmentation speeds communicated in fig. 5 and table I were obtained. Whenever the gathered preprocessing times also included the times for reading raw dataset files from disk, we subtracted the time for our own file reading, to focus on the actual inference speed of each method. Whenever we measured throughput using official public code, and unless specified otherwise, we used a machine with an NVIDIA V100 GPU with 32G VRAM, a 10-core CPU, and 94G RAM.

**PointNet++, KPCConv, and MinkowskiNet.** We used the Torch-Points3D [52] implementation and public logs [53], [54], [55], [56] for estimating the preprocessing and inference times on S3DIS 6-fold for PointNet++ [14], KPCConv [15], and MinkowskiNet [16].

**PointNeXt.** We used the official logs [57] to recover the preprocessing and inference times for PointNeXt-XL [50] on S3DIS 6-fold. Based on the logs and the official codebase, the voxelization is done on the fly during training and inference, which explains why PointNeXt has essentially no preprocessing time in table I.
**Stratified Transformer.** We used the training logs provided in the official GitHub repository [58] to gather the inference time for Stratified Transformer [17]. The Stratified Transformer codebase points to the PointNet++ implementation [53] for preprocessing S3DIS, which explains why these models share the same preprocessing times in table I. Regarding inference times, the training and inference logs [58] illustrate that this method uses about ×60 test-time augmentations to produce the results communicated in the official publication. While Stratified Transformer might achieve acceptable performance

and higher throughput without these multiple predictions, the fact that the communicated performance was assessed using test-time augmentations does not allow disentangling this step from the whole pipeline.

**Point Transformer v3.** We ran the S3DIS preprocessing script from the official Point Transformer v3 [13] implementation [59] to measure preprocessing times. For measuring inference times, we referred to the official logs [60]. Similar to Stratified Transformer, it is worth noting that the Point Transformer v3 implementation uses about ×200 ensembled predictions with test-time augmentations, running on 4 GPUs in its final paper, which explains the very low throughput of this approach.

**Superpoint Graph and SSP.** We ran the code from the official repository [61] to measure preprocessing, partition, and inference times of Superpoint Graph [7] and SSP [42].

**SPNet.** We used the official implementation [62] of SP-Net [9] to compute preprocessing, partition, and inference times. Since the codebase largely relies on the SPG [61] implementation, some preprocessing steps are identical. Note that the current state of the codebase only allowed us to run the partition on GPU architectures that tolerated the project CUDA and PyTorch dependencies. This prevented experimentation on hardware with larger VRAM. For this reason, our results in fig. 5 were limited by GPU memory. Still, these allow seeing the trend of the SPNet oracle mIoU against EZ-SPAs the number for superpoint grows.

**Superpoint Transformer.** We used the official implementation [63] for Superpoint Transformer [10] to measure preprocessing, partition, and inference times.

### A-4. FURTHER IMPLEMENTATION DETAILS

We provide further details of the implementation for detecting the semantic transition III-A and training the semantic segmentation III-C.

**Detecting the semantic transition.** We employ a focal loss [49] with $\gamma = 1$ to learn the semantic boundaries in all datasets. The learning rate is set to $10^{-4}$ for S3DIS and $5.10^{-4}$ for KITTI-360 and DALES without any scheduler. We set the weight decay to $10^{-4}$.

**Semantic segmentation.** Since the point embeddings produced by our CNN have a higher dimensionality than the handcrafted features in the official SPT [10] implementation, we modify the first layer of the PointNet-like MLP of SPT from [32, 64, 128] to [48, 64, 128] channels.

<caption>**Algorithm 2:** Component Merging with Low Contour Prior</caption>

**Input**: Node features $\mathbf{X}$, sizes $\mathbf{S}$, positions $\mathbf{O}$, undirected graph edges $\mathcal{E}$ and weights $\mathbf{W}$

**Parameters**: Regularization $\lambda$, min size $\sigma_{\min}$, nearest neighbor $k$

**Output**: Component assignment $\mathbf{I} \in \{0, \dots, C-1\}^N$

**Function** merge $(\mathbf{X}, \mathbf{S}, \mathbf{O}, \mathcal{E}, \mathbf{W}, \lambda, \sigma_{\min}, k)$:

$N \leftarrow |\mathbf{X}|$
// remove self-loops, duplicates, and connect isolated nodes
$\mathcal{E}, \mathbf{W} \leftarrow \text{prepare\_graph}(\mathcal{E}, \mathbf{W}, \mathbf{O}, k)$
if $|\mathcal{E}| = 0$ then
  $\leftarrow \text{return } \mathbf{I} \leftarrow [0, 1, \dots, N-1]$ // merging energy, see eq. (A-8)
  $\Delta \leftarrow \text{edge\_merge\_energy}(\mathbf{X}, \mathbf{S}, \mathcal{E}, \mathbf{W}, \lambda)$ // select directed $(P \to Q)$ edges
  if $|P| < \sigma_{\min}$, or $\Delta(P \to Q) > 0$, only the best $(P \to \bullet)$ with highest $\Delta$ is kept
  $\mathcal{E}_{\text{merge}} \leftarrow \text{keep\_valid\_merges}(\mathcal{E}, \Delta, \sigma_{\min})$ // no valid merge
  if $|\mathcal{E}_{\text{merge}}| = 0$ then
    $\leftarrow \text{return } \mathbf{I} \leftarrow [0, 1, \dots, N-1]$ // identify connected components in the merge graph, e.g., $\{(P \to R), (Q \to R)\} \in \mathcal{E}_{\text{merge}}$
    $\mathbf{I}_{\text{comp}} \leftarrow \text{wcc\_max\_prop}(N, \mathcal{E}_{\text{merge}})$ // only one component left
    if $\max(\mathbf{I}_{\text{comp}}) = 0$ then
      $\leftarrow \text{return } \mathbf{I}_{\text{comp}}$ // node and edge attributes of the new components
      $\mathbf{X}_{\text{comp}}, \mathbf{S}_{\text{comp}}, \mathbf{O}_{\text{comp}} \leftarrow$
        $\text{component\_attributes}(\mathbf{I}_{\text{comp}}, \mathbf{X}, \mathbf{S}, \mathbf{O})$
      $\mathcal{E}_{\text{comp}}, \mathbf{W}_{\text{comp}} \leftarrow$
        $\text{component\_graph}(\mathbf{I}_{\text{comp}}, \mathcal{E}, \mathbf{W})$
      // recursive call
      $\mathbf{I}_{\text{rec}} \leftarrow \text{merge}(
        \mathbf{X}_{\text{comp}}, \mathbf{S}_{\text{comp}}, \mathbf{O}_{\text{comp}}, \mathcal{E}_{\text{comp}}, \mathbf{W}_{\text{comp}}, \lambda, \sigma_{\min}, k)$
      $\leftarrow \text{return } \mathbf{I}_{\text{rec}}[\mathbf{I}_{\text{comp}}]$