Pith. sign in

REVIEW 3 major objections 4 minor 35 references

Synthetic LiDAR Data Generation and Deterministic Downsampling for Point Cloud Classification on the Edge

T0 review · 3 major / 4 minor · reviewed 2026-08-10 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A frozen critical-point selection layer compresses 1024-point LiDAR clouds to 40-60 points and classifies them at about 50 FPS on a Raspberry Pi 5 with 88.36% accuracy.

desk verdict Useful edge-ML engineering report with a genuinely new synthetic LiDAR dataset and honest baseline work; the headline 50 FPS/88.36% claim is not backed by any single measured configuration. read the letter →

arxiv 2608.07106 v1 pith:D4P7JGU3 submitted 2026-08-07 cs.LG cs.RO

Niclas Meyer , Stefan Reitmann This is my paper · ORCID
classification cs.LGcs.RO
keywords syntheticLiDARpointcloudclassificationCriticalPointsLayerdeterministicdownsamplingedgecomputingNetModelNet40RaspberryPi5
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Point cloud classification on a low-power edge CPU is bottlenecked by the cost and randomness of geometric preprocessing, and by the gap between clean CAD training data and real LiDAR sensor data. This paper tries to remove both bottlenecks at once: it generates a physics-based synthetic LiDAR version of ModelNet40, shows that networks trained on clean CAD data collapse on this sensor-like data, and attaches a pretrained Critical Points Layer (CPL) in front of PointNet as a deterministic downsampler. The central claim is that the frozen CPL compresses a 1024-point cloud to 40-60 unique coordinates in about 1.96 ms, and that the resulting pipeline classifies at roughly 50 FPS on a Raspberry Pi 5 while keeping 88.36% instance accuracy. If true, this would make real-time 3D perception feasible on affordable hardware without retraining a large model.

What carries the argument

The central object is the Critical Points Layer (CPL), a deterministic, feature-driven downsampler. It consists of a small shared MLP that projects each 3D coordinate into a high-dimensional feature space, followed by a column-wise global max-pooling whose argmax rows select the surviving points; sorting the selected indices by how many feature channels they dominate enforces permutation invariance. The layer is trained jointly with PointNet and then frozen, so the MLP weights encode what 'critical' means for the classification task, acting as a learned geometric high-pass filter that keeps structural landmarks and drops redundant geometry. The second piece of machinery is the BLAINDER physics-based raycasting pipeline used to generate the synthetic LiDAR variants of ModelNet40 with Gaussian sensor noise.

What would settle it

Run the complete chained pipeline (frozen CPL frontend plus PointNet classifier) on a Raspberry Pi 5 over the same 5000 test instances with end-to-end timing: if total per-instance time exceeds 20 ms, or if prepending the extracted CPL to a PointNet trained without it drops accuracy materially below 88.36%, the paper's headline operating point is falsified.

Watch

Extended reading notes

Core claim

The paper's central claim is that the Critical Points Layer can be extracted from the architecture it was introduced in and redeployed as a standalone, deterministic frontend filter for PointNet. The CPL is first fused to PointNet and trained end-to-end on ModelNet40, so its shared MLP learns which points are class-defining; after training the frontend is frozen and isolated. At inference it maps every point into a high-dimensional feature space, performs a column-wise max-pooling, and keeps the argmax point indices sorted by feature activation, so the same input always produces the same compressed cloud. The paper reports that this frontend shrinks raw 1024-point clouds to a unique set of 40 to 60 coordinates, runs in 1.96 ms on the Raspberry Pi 5 CPU for a 128-point target, and that the fused CPL-plus-PointNet pipeline reaches 88.36% instance accuracy over 5000 test instances at roughly 50 FPS.

Load-bearing premise

The claim that the pipeline runs at about 50 FPS with 88.36% accuracy rests on the unverified assumption that the separately profiled CPL frontend and jointly trained PointNet classifier perform exactly as well when actually chained together and run end to end on the Raspberry Pi 5.

Editorial extensions

If this is right

  • If the central claim is correct, deterministic downsampling by a frozen CPL removes the need for distance-based preprocessing such as farthest point sampling, whose latency at 512 points (23.04 ms) can exceed the neural network inference itself.
  • Because the retained set can be as small as 40 unique points, very sparse point clouds remain classifiable at 88.36%, extending PointNet's known robustness to extreme thinning to a learned selection rule.
  • Sensor-aware training on synthetic LiDAR is necessary for deployment: the cross-dataset matrix shows accuracy falling as low as 2.28% when a clean-CAD-trained network meets rotational LiDAR data, while noise-trained models transfer better to clean data than the reverse.
  • The reported 1.96 ms frontend plus roughly 21 ms PointNet inference implies an interactive-rate classifier on a single Raspberry Pi 5, enabling continuous embedded perception.
  • A network trained on noisy synthetic LiDAR can abstract to clean data, suggesting that injected sensor noise acts as a regularizer.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • An end-to-end timing of the chained CPL frontend plus PointNet on the Raspberry Pi 5 is not reported; the 50 FPS figure is assembled from separate component latencies, so an integrated benchmark is the immediate way to confirm it.
  • The 88.36% accuracy is demonstrated for a PointNet trained jointly with the CPL; prepending the extracted, frozen CPL to an independently trained PointNet without joint fine-tuning is untested and is the natural next experiment.
  • Replacing the hard argmax with a differentiable top-k sampler (e.g., Gumbel-Top-k) would give per-point importance weights and avoid duplicating points to reach the target density, a more information-preserving variant that the paper itself lists as future work.
  • If the learned compression is class-agnostic rather than tied to ModelNet40 categories, it could serve as a fast frontend for segmentation or object detection on edge robots, but the paper only evaluates classification.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper presents a two-part engineering workflow for edge point-cloud classification. First, it uses the BLAINDER add-on to generate synthetic LiDAR-style datasets from ModelNet40, with clean/noisy and static/rotational variants. Second, it trains a Critical Points Layer (CPL) jointly with a PointNet classifier on ModelNet40, then extracts the CPL as a standalone frontend that downsamples 1024-point clouds to 40–60 unique coordinates (with duplication to reach a target size). On a Raspberry Pi 5, the authors measure component latencies (isolated CPL 1.96 ms for a 128-point target; PointNet ~21 ms at 128 points) and a fused-pipeline accuracy of 88.36% on 5000 test instances with CPL downsampled to 64 points. The abstract claims an end-to-end throughput of approximately 50 FPS at this accuracy. Cross-dataset evaluations in Table 2 show large accuracy drops when models trained on clean ModelNet data are applied to the synthetic LiDAR data.

Significance. If the claimed 50 FPS at 88.36% accuracy on a Raspberry Pi 5 were demonstrated end-to-end, the paper would make a useful engineering contribution: a deterministic, real-time, low-power 3D classification pipeline with a published synthetic LiDAR dataset. The cross-dataset result that training on noisy LiDAR-like data improves robustness to clean data is a useful empirical finding. The component-level profiling on actual hardware is a strength, as is the public dataset release. However, the headline performance claim is not currently supported, and the real-time pipeline is never evaluated on the LiDAR-like data that motivates the paper.

major comments (3)
  1. [Abstract; §4.3] The headline claim of 'approximately 50 FPS while maintaining an instance classification accuracy of 88.36%' is not supported by any single measured configuration. The 88.36% accuracy is reported for the fused CPL+PointNet model with CPL downsampled to 64 points (§4.3, final paragraph), while the component latencies used to assemble the FPS figure come from the isolated CPL at a 128-point target (1.96 ms, §4.3) and PointNet at 128 points (~21 ms, §4.1.2). No end-to-end timing of CPL followed by the classifier on the Raspberry Pi 5 is reported. Moreover, the sum of the two components (~23 ms) corresponds to ~44 FPS, not ~50 FPS. Please provide an end-to-end measurement for the exact configuration that achieves 88.36% and report the resulting throughput.
  2. [§3.2.3, §4.1.1, §4.3] The CPL frontend is trained and evaluated on clean ModelNet40 data, while the synthetic LiDAR datasets are used only in the cross-dataset study of §4.1.1. The paper's stated motivation is to bridge the reality gap between CAD models and LiDAR sensor data, but the proposed real-time pipeline (CPL+PointNet) is never tested on any of the synthetic LiDAR datasets. Consequently, the claimed 'real-time 3D perception at the edge' is not demonstrated for the sensor type that motivates the data-generation contribution. Please either evaluate the CPL+PointNet pipeline on the LiDAR-like test sets or explicitly scope the real-time claim to clean CAD-distribution data.
  3. [Abstract; §4.3, §5.1] The abstract and conclusion state that CPL 'deterministically compresses raw 1024-point clouds to a subset of 40 to 60 unique coordinates,' but the implementation described in §4.3 duplicates selected points to reach the desired target size ('our proof-of-concept implementation duplicates the resulting points', and truncates if fewer points are desired). The tensor actually consumed by the classifier therefore contains duplicate coordinates, and the 40–60 unique-coordinate count is not the effective input size. Please clarify whether the reported accuracy and latency correspond to the duplicated tensor or the unique-point subset, and discuss the effect of duplication on the compression and determinism claims.
minor comments (4)
  1. [§4.3] The sentence reporting 88.36% accuracy over 5000 test instances does not name the test dataset. Given that §4.1.1 evaluates five distinct data configurations, please state explicitly that this is the ModelNet40 test split (or whatever set was used).
  2. [Table 2] In the 'Rotation Clean' row, the instance accuracy of 2.28% for the model trained on the original ModelNet data is below the random-guess rate of 2.5% for 40 classes. Please clarify whether this is due to the minimum-point-count threshold, label mismatches, or the evaluation protocol, since a value below chance suggests a systematic misalignment rather than a mere domain gap.
  3. [§4.2] The FPS and RS latency profiling is performed on a single test instance; the text asserts that runtime depends only on point densities, but reporting the latency distribution or a small set of shapes would strengthen the claim that the timings are shape-independent.
  4. [Abstract and captions] There are several typographical issues: 'accuracy of88.36%' in the abstract, '0.016657ms' without a space in the Figure 7 caption, and 'PoinNet' in the Figure 9 caption. A careful proofreading pass is needed.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: results are direct empirical evaluations; the abstract's ~50 FPS figure is an unmeasured composition gap, not a circular derivation.

full rationale

This paper makes no formal derivation claim, so the main circularity patterns do not apply. The central results are empirical: the CPL+PointNet pipeline was trained on an 80/20 split of ModelNet40 and the 88.36% instance accuracy is reported for held-out test instances in Section 4.3; the latency figures for PointNet and the isolated CPL are direct Raspberry Pi 5 benchmarks in Sections 4.1.2 and 4.3; and the 40-to-60 unique-coordinate compression is an observed property of the trained CPL's max-pooling argmax behavior. The BLAINDER dataset generator is cited to Reitmann et al. [7], which is a self-citation by one of the present authors, but BLAINDER is an independently published, open-source Blender add-on whose behavior is externally reproducible, so it constitutes independent tool support rather than a load-bearing self-referential premise. The only notable weakness is that the abstract's approximate 50 FPS figure is not an end-to-end measurement: the 128-point PointNet timing (~47 FPS) and the isolated 128-point CPL timing (1.96 ms) are measured separately, and the 88.36% accuracy is reported for a 64-point CPL target; this is an evidence/composition gap, not circularity. No equation is defined in terms of a target result, and no fitted parameter is renamed as a prediction.

Assumptions & free parameters 6 free parameters · 4 assumptions · 0 invented entities

The paper has no derivations; its main quantities come from trained models and measured latencies. The key free parameters are the CPL and PointNet weights, the hand-chosen noise level, the target point count, and an unreported exclusion threshold. The main domain assumptions are that BLAINDER with Gaussian noise approximates LiDAR and that ModelNet40 is a valid benchmark. No invented physical entities are introduced.

free parameters (6)
  • CPL frontend MLP weights = learned on ModelNet40; not published
    The deterministic selection of 40 to 60 critical points depends entirely on these trained weights, and they are not released.
  • PointNet classifier weights = trained jointly with CPL on ModelNet40; not published
    The 88.36% accuracy is produced by this backend, so the reported accuracy cannot be reproduced without these weights.
  • Gaussian noise standard deviation = 0.01
    Hand-chosen to simulate LiDAR jitter; it defines the 'noisy' synthetic datasets and directly affects the domain-gap measurements.
  • CPL output target size = 64 points for accuracy, 128 points for latency profiling
    The accuracy and latency claims are tied to the chosen output density, and the paper uses different target sizes in different experiments.
  • Minimum point-count exclusion threshold = not reported
    Instances below this threshold are filtered from the synthetic datasets, but the threshold value and the number of excluded instances are never stated.
  • Training hyperparameters = learning rate 0.001, 200 epochs, batch size 24
    Taken from the baseline PointNet repository; they determine the trained weights and the resulting accuracy.
assumptions (4)
  • domain assumption PointNet and CPL behave as described in their source papers, including permutation-invariant max-pooling.
    Sections 2.5.3 and 3.2 adopt the architectures from refs [8] and [9] without re-deriving them.
  • domain assumption BLAINDER raycasting with injected Gaussian noise approximates real LiDAR sensor behavior.
    Section 3.1 uses this to construct the synthetic datasets; no real LiDAR validation is provided.
  • domain assumption ModelNet40 labels and the 80/20 train-test split are a valid benchmark for the claims.
    Section 4.1 uses the standard repository and split for training and evaluation.
  • standard math The argmax row selection and feature sorting in CPL are deterministic and permutation-invariant.
    Section 3.2 relies on the symmetry of max-pooling and the sorting step for the determinism claim.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Synthetic LiDAR Data Generation and Deterministic Downsampling for Point Cloud Classification on the Edge." pith.science (2026). https://pith.science/paper/D4P7JGU3

@misc{pith2026260807106,
  author       = {Pith},
  title        = {Pith review of: Synthetic LiDAR Data Generation and Deterministic Downsampling for Point Cloud Classification on the Edge},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/D4P7JGU3}},
  note         = {Machine review of arXiv:2608.07106}
}
read the original abstract

Deploying three-dimensional deep learning frameworks to low-power embedded processors is bottlenecked by the unstructured nature of spatial data and the resource-intensive distance sorting algorithms often used before neural network inference. To address this gap, this paper presents a hardware-constrained workflow optimized for native execution on the Raspberry Pi 5. To account for the reality gap between noiseless, clean computer-aided design (CAD) datasets and real-world sensor data, we use physics-based simulation to construct a synthetic LiDAR dataset. Cross-dataset evaluations demonstrate a substantial drop in classification accuracy when networks trained on clean CAD data are evaluated on synthetic LiDAR sensor data, highlighting the critical need for sensor-aware training. To address the latency bottleneck of traditional geometric preprocessing on edge CPUs, we integrate an isolated, feature-driven Critical Points Layer (CPL) as a frontend filter. Our results show that the pretrained CPL deterministically compresses raw 1024-point clouds to a subset of 40 to 60 unique coordinates. When profiled on the ARM Cortex-A76 processor, the complete pipeline achieves an inference throughput of approximately 50 FPS while maintaining an instance classification accuracy of 88.36%, demonstrating the viability of deterministic real-time 3D perception at the edge.

Figures

Figures reproduced from arXiv: 2608.07106 by the authors.

Figure 1
Figure 1. Contrast between an instance of (a) SemanticKITTI and (b) ModelNet instance. In (b), a point cloud is dis￾played below the actual CAD model. The SemanticKITTI image was taken from https: // semantic-kitti. org/ images/ mobile_ hero2. jpg . 1b). Rather than capturing real-world instances of objects, ModelNet consists of clean and geometric flawless 3D CAD models, representing a wide vari￾ety of categories. Two subset… view at source ↗
Figure 3
Figure 3. Synthetic rotational LiDAR scans of instance airplane_0655 recorded by BLAINDER. The records in the top row do not inherit noise, whereas those in the lower rows do. From left to right, the columns depict a right-side lateral view, a top-down view, and a frontal view of the aircraft [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figure 4
Figure 4. Synthetic LiDAR scans by a generic static scanner. The upper row displays chair_0006, flower_pot_0029, and person_0027 without any induced noise; the lower row shows the instances with induced noise. 3.1 Bridging the Sensor Reality Gap While the aforementioned existing implementations demonstrated the viability of deploying PointNet on edge hardware, their evaluation relied exclusively on uniformly sampled instances… view at source ↗
Figures from the paper (5 more)
Figure 5
Figure 5. Figure 5: CPL pipeline for point cloud downsampling. give an intuitive understanding of which points are more important than others for the classification it￾self, they cannot be used for downsampling meth￾ods. They present a fundamental chicken-and-egg problem: a surrogate expl…
Figure 6
Figure 6. Figure 6: PointNet performance profile across different downsampling granularities. The plot illustrates a linear computational complexity relative to point density; note that the curve exhibits a visually exponential trajectory solely due to the logarithmic scaling of the horiz…
Figure 7
Figure 7. Figure 7: Inference preprocessing runtime scaling on the Raspberry Pi 5 architecture. The actual timings for RS are between 0.016657ms for 16 points and 0.031077ms for 512 points, whereas FPS is between 0.693ms 23.042ms, respectively [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]
Figure 8
Figure 8. Figure 8: Different airplane and person instances are displayed. The instances in gray are sampled down to 1024 points and taken as input for LIME-3D and CPL. Next to it in green are all positive attributed points, identified via LIME-3D. On the right are the compressed point cl…
Figure 9
Figure 9. Figure 9: Confusion Matrix displaying the results of PoinNet evaluated on ModelNet. It can be seen that the network has difficulty differentiating between several classes, such as ’flower pot’ and ’plant’. 16 [PITH_FULL_IMAGE:figures/full_fig_p016_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

35 extracted references · 16 canonical work pages

  1. [1]

    Lidar for Autonomous Driving: The Principles, Chal- lenges, and Trends for Automotive Lidar and Perception Systems

    You Li and Javier Ibanez-Guzman. “Lidar for Autonomous Driving: The Principles, Chal- lenges, and Trends for Automotive Lidar and Perception Systems”. In:IEEE Signal Process- ing Magazine37.4 (July 2020), pp. 50–61.issn: 1053-5888, 1558-0792.doi: 10.1109/MSP.2020. 2973615.url: https : / / ieeexplore . ieee . org/document/9127855/. 13 Synthetic LiDAR Data ...

    work page arXiv 2020

  2. [2]

    AI-Powered LiDAR Point Cloud Understanding and Processing: An Up- dated Survey

    Shanghui Jia et al. “AI-Powered LiDAR Point Cloud Understanding and Processing: An Up- dated Survey”. In:IEEE Transactions on Intel- ligent Transportation Systems26.8 (Aug. 2025), pp. 11249–11275.issn: 1558-0016.doi: 10 . 1109 / TITS . 2025 . 3568500.url: https : / / ieeexplore.ieee.org/document/11021542/ figures

    work page arXiv 2025

  3. [3]

    Are we ready for autonomous driv- ing? The KITTI vision benchmark suite

    Andreas Geiger, Philip Lenz, and Raquel Ur- tasun. “Are we ready for autonomous driv- ing? The KITTI vision benchmark suite”. In: 2012 IEEE Conference on Computer Vision and Pattern Recognition. ISSN: 1063-6919. June 2012, pp. 3354–3361.doi: 10 . 1109 / CVPR . 2012 . 6248074.url: https : / / ieeexplore . ieee . org/document/6248074

    arXiv 2012

  4. [4]

    Vision meets robotics: The KITTI dataset

    A Geiger et al. “Vision meets robotics: The KITTI dataset”. In:Int. J. Rob. Res.32.11 (Sept. 2013), pp. 1231–1237.issn: 0278-3649.doi: 10. 1177/0278364913491297 .url: https://doi. org/10.1177/0278364913491297

    doi:10.1177/0278364913491297 2013

  5. [5]

    arXiv:1406.5670 [cs]

    Zhirong Wu et al.3D ShapeNets: A Deep Repre- sentation for Volumetric Shapes. arXiv:1406.5670 [cs]. Apr. 2015.doi: 10 . 48550 / arXiv . 1406 . 5670.url: http : / / arxiv . org / abs / 1406 . 5670

    arXiv doi:10.48550/arxiv.1406.5670 2015

  6. [6]

    Point Transformer V3: Sim- pler, Faster, Stronger

    Xiaoyang Wu et al. “Point Transformer V3: Sim- pler, Faster, Stronger”. In:2024 IEEE/CVF Con- ference on Computer Vision and Pattern Recog- nition (CVPR). ISSN: 2575-7075. June 2024, pp. 4840–4851.doi: 10.1109/CVPR52733.2024. 00463.url: https://ieeexplore.ieee.org/ document/10658198/

    arXiv 2024

  7. [7]

    BLAINDER—A Blender AI Add- On for Generation of Semantically Labeled Depth-Sensing Data

    Stefan Reitmann, Lorenzo Neumann, and Bern- hard Jung. “BLAINDER—A Blender AI Add- On for Generation of Semantically Labeled Depth-Sensing Data”. en. In:Sensors21.6 (Jan. 2021), p. 2144.issn: 1424-8220.doi: 10.3390/ s21062144.url: https : / / www . mdpi . com / 1424-8220/21/6/2144

    work page 2021

  8. [8]

    Adaptive Hierarchical Down-Sampling for Point Cloud Classification

    Ehsan Nezhadarya et al.Adaptive Hierarchi- cal Down-Sampling for Point Cloud Classifica- tion. arXiv:1904.08506 [cs.CV]. May 2020.doi: 10.48550/arXiv.1904.08506 .url: http:// arxiv.org/abs/1904.08506

    work page Pith review arXiv doi:10.48550/arxiv.1904.08506 1904

Show all 35 references
  1. [9]

    Qi et al.PointNet: Deep Learning on Point Sets for 3D Classification and Segmen- tation

    Charles R. Qi et al.PointNet: Deep Learning on Point Sets for 3D Classification and Segmen- tation. arXiv:1612.00593 [cs]. Apr. 2017.doi: 10.48550/arXiv.1612.00593 .url: http:// arxiv.org/abs/1612.00593

    2017 doi arXiv

  2. [10]

    Visualizing Global Explanations of Point Cloud DNNs

    Hanxiao Tan. “Visualizing Global Explanations of Point Cloud DNNs”. In:2023 IEEE/CVF Winter Conference on Applications of Computer Vision (WACV). ISSN: 2642-9381. Jan. 2023, pp. 4730–4739.doi: 10.1109/WACV56688.2023. 00472.url: https://ieeexplore.ieee.org/ document/10030393

    2023

  3. [11]

    arXiv:1007.0085 [cs.CV]

    Nitin Bhatia and Vandana.Survey of Nearest Neighbor Techniques. arXiv:1007.0085 [cs.CV]. July 2010.doi: 10.48550/arXiv.1007.0085 . url:http://arxiv.org/abs/1007.0085

    2010 doi arXiv

  4. [12]

    arXiv:1904.01416 [cs]

    Jens Behley et al.SemanticKITTI: A Dataset for Semantic Scene Understanding of LiDAR Se- quences. arXiv:1904.01416 [cs]. Aug. 2019.doi: 10.48550/arXiv.1904.01416 .url: http:// arxiv.org/abs/1904.01416

    1904 doi arXiv

  5. [13]

    Point Cloud Classification with ModelNet40: What is left?

    Jarne Van den Herrewegen, Tom Tourwé, and Francis Wyffels. “Point Cloud Classification with ModelNet40: What is left?” en. In: (2023)

    2023

  6. [14]

    arXiv:2509.05198 [cs]

    Mohammad Saeid, Amir Salarpour, and Pe- dram MohajerAnsari.Enhancing 3D Point Cloud Classification with ModelNet-R and Point-SkipNet. arXiv:2509.05198 [cs]. Sept. 2025.doi: 10 . 48550 / arXiv . 2509 . 05198 .url: http : / / arxiv.org/abs/2509.05198

    2025 doi arXiv

  7. [15]

    Ad- vancements in Point Cloud Data Augmenta- tion for Deep Learning: A Survey

    Qinfeng Zhu, Lei Fan, and Ningxin Weng. “Ad- vancements in Point Cloud Data Augmenta- tion for Deep Learning: A Survey”. In:Pattern Recognition153 (Sept. 2024). arXiv:2308.12113 [cs], p. 110532.issn: 00313203.doi: 10.1016/ j.patcog.2024.110532 .url: http://arxiv. org/abs/2308.12113

    2024 arXiv

  8. [16]

    arXiv:2101.01461 [cs.CV]

    Jinlai Zhang et al.PointCutMix: Regulariza- tion Strategy for Point Cloud Classification. arXiv:2101.01461 [cs.CV]. Feb. 2021.doi: 10 . 48550 / arXiv . 2101 . 01461 .url: http : / / arxiv.org/abs/2101.01461

    2021 doi arXiv

  9. [17]

    arXiv:2201.12296 [cs]

    Jiachen Sun et al.Benchmarking Robustness of 3D Point Cloud Recognition Against Common Cor- ruptions. arXiv:2201.12296 [cs]. Jan. 2022.doi: 10.48550/arXiv.2201.12296 .url: http:// arxiv.org/abs/2201.12296

    2022 doi arXiv

  10. [18]

    arXiv:2303.02314 [cs]

    Hai Wu et al.Virtual Sparse Convolution for Mul- timodal 3D Object Detection. arXiv:2303.02314 [cs]. Mar. 2023.doi: 10 . 48550 / arXiv . 2303 . 02314.url: http : / / arxiv . org / abs / 2303 . 02314

    2023 doi arXiv

  11. [19]

    Deep Learning on 3D Semantic Segmentation: A Detailed Re- view

    Thodoris Betsas et al. “Deep Learning on 3D Semantic Segmentation: A Detailed Re- view”. In:Remote Sensing17.2 (Jan. 2025). arXiv:2411.02104 [cs], p. 298.issn: 2072-4292. doi: 10.3390/rs17020298.url: http://arxiv. org/abs/2411.02104. 14 Synthetic LiDAR Data and Downsampling on...

    2025 arXiv

  12. [20]

    arXiv:2503.12595 [cs]

    Dan Halperin and Niklas Eisl.Point Cloud Based Scene Segmentation: A Survey. arXiv:2503.12595 [cs]. Mar. 2025.doi: 10 . 48550 / arXiv . 2503 . 12595.url: http : / / arxiv . org / abs / 2503 . 12595

    2025 doi arXiv

  13. [21]

    arXiv:1710.07368 [cs.CV]

    Bichen Wu et al.SqueezeSeg: Convolutional Neu- ral Nets with Recurrent CRF for Real-Time Road- Object Segmentation from 3D LiDAR Point Cloud. arXiv:1710.07368 [cs.CV]. Oct. 2017.doi: 10 . 48550 / arXiv . 1710 . 07368 .url: http : / / arxiv.org/abs/1710.07368

    2017 doi arXiv

  14. [22]

    arXiv:1809.08495 [cs]

    Bichen Wu et al.SqueezeSegV2: Improved Model Structure and Unsupervised Domain Adaptation for Road-Object Segmentation from a LiDAR Point Cloud. arXiv:1809.08495 [cs]. Sept. 2018.doi: 10.48550/arXiv.1809.08495 .url: http:// arxiv.org/abs/1809.08495

    2018 doi arXiv

  15. [23]

    arXiv:2002.10893 [cs]

    Iñigo Alonso et al.3D-MiniNet: Learning a 2D Representation from Point Clouds for Fast and Efficient 3D LIDAR Semantic Segmenta- tion. arXiv:2002.10893 [cs]. Apr. 2021.doi: 10. 48550 / arXiv . 2002 . 10893 .url: http : / / arxiv.org/abs/2002.10893

    2002 doi arXiv

  16. [24]

    Learning Semantic Seg- mentation of Large-Scale Point Clouds With Random Sampling

    Qingyong Hu et al. “Learning Semantic Seg- mentation of Large-Scale Point Clouds With Random Sampling”. In:IEEE Transactions on Pattern Analysis and Machine Intelligence44.11 (Nov. 2022), pp. 8338–8354.issn: 1939-3539.doi: 10.1109/TPAMI.2021.3083288.url: https:// ieeexplore.ie...

    2022

  17. [25]

    Deep Learning-based 3D Point Cloud Classification: A Systematic Survey and Outlook

    Huang Zhang et al. “Deep Learning-based 3D Point Cloud Classification: A Systematic Survey and Outlook”. In:Displays79 (Sept. 2023). arXiv:2311.02608 [cs.CV], p. 102456.issn: 01419382.doi: 10 . 1016 / j . displa . 2023 . 102456.url: http : / / arxiv . org / abs / 2311 . 02608

    2023 arXiv

  18. [26]

    Searching Efficient 3D Architectures with Sparse Point-Voxel Convo- lution

    Haotian Tang et al. “Searching Efficient 3D Architectures with Sparse Point-Voxel Convo- lution”. en. In:Computer Vision – ECCV 2020. Ed. by Andrea Vedaldi et al. Cham: Springer In- ternational Publishing, 2020, pp. 685–702.isbn: 978-3-030-58604-1.doi: 10.1007/978- 3- 030- 58604-1_41

    2020 doi

  19. [27]

    Qi et al.PointNet++: Deep Hierar- chical Feature Learning on Point Sets in a Met- ric Space

    Charles R. Qi et al.PointNet++: Deep Hierar- chical Feature Learning on Point Sets in a Met- ric Space. arXiv:1706.02413 [cs]. June 2017.doi: 10.48550/arXiv.1706.02413 .url: http:// arxiv.org/abs/1706.02413

    2017 doi arXiv

  20. [28]

    arXiv:1801.07829 [cs.CV]

    Yue Wang et al.Dynamic Graph CNN for Learn- ing on Point Clouds. arXiv:1801.07829 [cs.CV]. June 2019.doi: 10.48550/arXiv.1801.07829 . url:http://arxiv.org/abs/1801.07829

    2019 doi arXiv

  21. [29]

    arXiv:2303.16570 [cs.CV]

    Karim Knaebel et al.Point2Vec for Self- Supervised Representation Learning on Point Clouds. arXiv:2303.16570 [cs.CV]. Oct. 2023.doi: 10.48550/arXiv.2303.16570 .url: http:// arxiv.org/abs/2303.16570

    2023 doi

  22. [30]

    Point-GN: A Non-Parametric Network Using Gaus- sian Positional Encoding for Point Cloud Classi- fication

    Marzieh Mohammadi and Amir Salarpour. Point-GN: A Non-Parametric Network Using Gaus- sian Positional Encoding for Point Cloud Classi- fication. arXiv:2412.03056 [cs]. Dec. 2024.doi: 10.48550/arXiv.2412.03056 .url: http:// arxiv.org/abs/2412.03056

    2024 doi arXiv

  23. [31]

    arXiv:1812.01687 [cs]

    Tianhang Zheng et al.PointCloud Saliency Maps. arXiv:1812.01687 [cs]. Sept. 2019.doi: 10 . 48550 / arXiv . 1812 . 01687 .url: http : / / arxiv.org/abs/1812.01687

    2019 doi arXiv

  24. [32]

    arXiv:2403.07706 [cs]

    Meir Yossef Levi and Guy Gilboa.Fast and Simple Explainability for Point Cloud Networks. arXiv:2403.07706 [cs]. Mar. 2024.doi: 10 . 48550 / arXiv . 2403 . 07706 .url: http : / / arxiv.org/abs/2403.07706

    2024 doi arXiv

  25. [33]

    arXiv:2107.13459 [cs]

    Hanxiao Tan and Helena Kotthaus.Surrogate Model-Based Explainability Methods for Point Cloud NNs. arXiv:2107.13459 [cs]. Aug. 2021. doi: 10.48550/arXiv.2107.13459.url: http: //arxiv.org/abs/2107.13459

    2021 doi arXiv

  26. [34]

    Characterizing Deep Neural Networks on Edge Computing Systems for Object Classification in 3D Point Clouds

    Cristian Wisultschew et al. “Characterizing Deep Neural Networks on Edge Computing Systems for Object Classification in 3D Point Clouds”. In:IEEE Sensors Journal22.17 (Sept. 2022), pp. 17075–17089.issn: 1558-1748.doi: 10.1109/JSEN.2022.3193060 .url: https:// ieeexplore.ieee.or...

    2022

  27. [35]

    Meyer and S

    N. Meyer and S. Reitmann.Synthetic LiDAR Data Generation and Deterministic Downsam- pling for Point Cloud Classification on the Edge. Aug. 2026.doi: 10 . 5281 / zenodo . 21835460. url: https : / / doi . org / 10 . 5281 / zenodo . 21835460. 15 Synthetic LiDAR Data and Downsampl...

    2026

Pith tools

Reviewed August 10, 2026 · model on record in the stance chip above.