Simple3D: Minimalist 3D Vision Approaches

• Simple3D is a term that encompasses two distinct methods: one for high-resolution industrial 3D anomaly detection using geometric descriptors and prototype memory, and one for adapting a standard 2D ViT for 3D tasks.
• The anomaly detection approach employs Multi-Scale Neighborhood Descriptors and Local Feature Spatial Aggregation to efficiently score point cloud anomalies without relying on deep neural backbones.
• The Simple3D-Former variant retains a standard 2D Vision Transformer encoder with minimal changes in tokenization and positional encoding, achieving competitive performance in classification, segmentation, and indoor detection.

Simple3D is an overloaded name in recent 3D vision literature. In one usage, it denotes a lightweight framework for high-resolution 3D anomaly detection in industrial point clouds, introduced together with the MiniShift dataset and centered on Multi-scale Neighborhood Descriptors (MSND), Local Feature Spatial Aggregation (LFSA), and nearest-prototype scoring (Cheng et al., 10 Jul 2025). In another usage, appearing as “Simple3D-Former” and also abbreviated as Simple3D, it denotes a minimally adapted 2D Vision Transformer for 3D object classification, point-cloud segmentation, and indoor scene detection, with the transformer encoder kept identical to a standard 2D ViT and only the tokenization, positional encoding, and task heads changed (Wang et al., 2022). The shared label therefore identifies two distinct methodological lines rather than a single unified architecture.

1. Terminological scope and disambiguation

The two systems associated with the name Simple3D differ in task definition, input regime, and computational philosophy.

System	Primary setting	Core mechanism
Simple3D (Cheng et al., 10 Jul 2025)	High-resolution 3D anomaly detection in industrial point clouds	MSND, LFSA, prototype memory, nearest-prototype Euclidean distance
Simple3D-Former (Wang et al., 2022)	3D object classification, point-cloud segmentation, indoor scene detection	Standard 2D ViT backbone with 3D tokenization and 3D positional encoding

The anomaly-detection Simple3D addresses dense industrial inspection data, where point clouds contain hundreds of thousands to over a million points per object and anomalies often occupy less than $1\%$ of surface points. The transformer-based Simple3D-Former addresses a different question: whether a standard 2D ViT architecture can be reused for 3D tasks with only minimal customization. This distinction is essential, because one method is explicitly described as having effectively no learnable parameters, while the other is a full transformer model based on DeiT backbones (Cheng et al., 10 Jul 2025, Wang et al., 2022).

A plausible implication is that the repeated use of the name reflects a common design preference for minimalism, but the technical content of the two systems is otherwise separate.

2. Simple3D for industrial 3D anomaly detection

In the industrial anomaly-detection setting, an anomaly is a local geometric irregularity relative to the nominal shape manifold, such as shallow protrusions or depressions, micro-scratches, or tiny spherical bumps or dents. The motivation is that prevailing benchmarks emphasize low-resolution inputs, whereas practical inspection captures dense point clouds and subtle anomalies may be suppressed by downsampling to sparse groups and interpolating group-wise anomaly scores back to the full cloud (Cheng et al., 10 Jul 2025).

The accompanying MiniShift dataset was built to stress-test this setting. It contains 2,577 point clouds, each with 500,000 points, derived from 12 industrial categories in MulSen-AD. The anomaly synthesis pipeline, Anchor-Guided Geometric Anomaly Synthesis (AG-GAS), injects four defect types—Areal, Striate, Scratch, and Sphere—through four stages: anchor selection, geodesic path computation, region expansion, and geometric distortion. The geodesic path is obtained on an undirected $k$-NN graph $G$ with edge weights $w(e_{ij}) = \|p_i - p_j\|_2$, using Dijkstra’s algorithm to find the shortest path $\pi^*$ between anchors. A tubular region $M_r$ is then expanded around the path point set $\Gamma$, and points are displaced along the averaged normal direction with radial decay (Cheng et al., 10 Jul 2025).

The synthesis protocol stratifies defects into easy, medium, and hard using normalized parameters

$$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$

where $l$ is the geodesic length between anchors, $r$ is the expansion radius, $k$0 is the distortion amplitude, and $k$1 is the bounding-box diagonal of the point cloud. Labels include per-point defect masks and object-wise labels. The paper states that anomalies occupy $k$2 of points on average, which makes the dataset explicitly high-resolution and low-occupancy (Cheng et al., 10 Jul 2025).

For inference, Simple3D produces point-wise anomaly scores for selected points and an object-wise score

$k$3

This makes the method suitable for both localization and object-level decision-making.

3. Architectural formulation of the anomaly-detection Simple3D

Simple3D is a training-light prototype-based detector composed of three components: Multi-Scale Neighborhood Descriptors, Local Feature Spatial Aggregation, and prototype memory with nearest-prototype scoring (Cheng et al., 10 Jul 2025).

MSND computes hand-crafted geometric descriptors at multiple neighborhood scales around each point. Given point cloud $k$4 with $k$5 points and neighborhood sizes $k$6, defaulting to $k$7, the feature at point $k$8 is

$k$9

The default descriptor operator is FPFH, a 33-D histogram descriptor per neighborhood encoding angular relationships between normals of pairs $G$0. With three scales, MSND yields a 99-D feature per point. The framework is described as descriptor-agnostic, with SHOT and USC identified as possible alternatives, and local covariance eigen-analysis also noted as a route to curvature, linearity, planarity, and scattering measures (Cheng et al., 10 Jul 2025).

LFSA expands spatial support while preserving efficiency. A set of $G$1 detection points $G$2 is sampled uniformly at random, or by farthest-point sampling, and the aggregated feature for each sampled point is

$G$3

where $G$4 is the $G$5-nearest-neighbor set in the original point set and the default aggregation breadth is $G$6. The aggregation is simple mean pooling with no attention, chosen for speed and stability at large $G$7 (Cheng et al., 10 Jul 2025).

The anomaly score is nonparametric. Enhanced features from normal training clouds define a prototype memory

$G$8

and each test feature is scored by nearest-prototype Euclidean distance,

$G$9

The method is trained in a normal-only setting; no reconstruction, one-class classification, or density modeling is required, and no losses are optimized. The paper explicitly states that no deep neural backbone is used and that there are effectively no learnable parameters (Cheng et al., 10 Jul 2025).

This design makes the anomaly-detection Simple3D unusual within 3D AD: it relies on classical geometric descriptors and efficient spatial aggregation rather than a learned backbone, yet still targets dense high-resolution inputs.

4. Efficiency, benchmarks, and failure modes of the anomaly-detection Simple3D

The runtime profile is dominated by normal estimation, $w(e_{ij}) = \|p_i - p_j\|_2$0-NN queries, FPFH computation, and LFSA averaging. The paper reports CUDA-supported Open3D implementations for FPFH and neighbor search, and describes the memory footprint as being dominated by transient $w(e_{ij}) = \|p_i - p_j\|_2$1 MSND buffers and a compact prototype set $w(e_{ij}) = \|p_i - p_j\|_2$2, with $w(e_{ij}) = \|p_i - p_j\|_2$3 (Cheng et al., 10 Jul 2025).

On NVIDIA A100 GPUs, the method is reported to achieve real-time inference exceeding 20 fps at a detection resolution of about 4k points on Anomaly-ShapeNet. As $w(e_{ij}) = \|p_i - p_j\|_2$4 increases from $w(e_{ij}) = \|p_i - p_j\|_2$5 to $w(e_{ij}) = \|p_i - p_j\|_2$6, accuracy improves and fps decreases; beyond $w(e_{ij}) = \|p_i - p_j\|_2$7, the method surpasses prior state-of-the-art accuracy while preserving practical speed (Cheng et al., 10 Jul 2025).

Dataset	Simple3D O-ROC / P-ROC	Comparative note
MiniShift	68.6 / 66.2	Better than PatchCore-FP 65.1 / 53.7 and GLFM 55.8 / 58.7
Real3D-AD	80.4 / 92.3	Baseline averages cited are 78.2 O-ROC and 83.6 P-ROC
Anomaly-ShapeNet	86.0 / 92.9	Better than MC3D-AD 84.2 / 74.8
MulSen-AD	88.2 / 80.3	Better than PatchCore-FP 86.0 O-ROC and GLFM 66.5 P-ROC

On MiniShift, performance is also stratified by difficulty tier: Easy $w(e_{ij}) = \|p_i - p_j\|_2$8, Medium $w(e_{ij}) = \|p_i - p_j\|_2$9, and Hard $\pi^*$0. Per-category gains are highlighted for Capsule $\pi^*$1, Button cell $\pi^*$2, Plastic cylinder $\pi^*$3, and Nut $\pi^*$4. On Real3D-AD, highlighted categories include Diamond $\pi^*$5, Car $\pi^*$6, Fish $\pi^*$7, Seahorse $\pi^*$8, and Toffees $\pi^*$9 (Cheng et al., 10 Jul 2025).

Ablation studies indicate that removing MSND or LFSA consistently reduces performance. With both disabled, Real3D-AD falls from $M_r$0 to $M_r$1; Anomaly-ShapeNet from $M_r$2 to $M_r$3; MulSen-AD from $M_r$4 to $M_r$5; and MiniShift from $M_r$6 to $M_r$7. Increasing $M_r$8 from 8 to 128 improves both O-ROC and P-ROC, and increasing detection resolution $M_r$9 from 256 to 8192 monotonically improves accuracy across datasets (Cheng et al., 10 Jul 2025).

The reported limitations are correspondingly specific. Extremely subtle defects within very noisy or sparsely sampled localities remain challenging, and on MiniShift-hard all methods, including Simple3D, experience degradation, with point-wise AUROC in the mid-50s. The paper identifies this as evidence of remaining sensitivity to measurement noise and strong curvature or texture confounders (Cheng et al., 10 Jul 2025).

5. Simple3D-Former: a minimally adapted 2D ViT for 3D tasks

Simple3D-Former addresses a different problem: whether one can solve 3D vision tasks using a standard 2D Vision Transformer architecture with only minimal customization at input and output levels. Its central claim is architectural continuity with 2D ViTs. The method preserves an “authentic” ViT encoder—multi-head self-attention, MLP, LayerNorm, and residual connections—and changes only tokenization and patch or voxel embedding, positional encoding matching 3D geometry, and task heads. No changes are made to the self-attention block (Wang et al., 2022).

The method supports two 3D input modalities. For voxels, an input tensor $\Gamma$0 is partitioned into cubes of size $\Gamma$1, and tokenization is realized by a single 3D convolution with kernel size $\Gamma$2 and stride $\Gamma$3. Three voxel tokenizers are defined: naive inflation, 2D projection, and group embedding. The generic linear tokenization form is

$\Gamma$4

and for naive inflation the token count is

$\Gamma$5

The group embedding variant applies a lightweight 1D Transformer Encoder to the depth sequence at each fixed $\Gamma$6 location and then yields $\Gamma$7 tokens (Wang et al., 2022).

For point clouds, the input is $\Gamma$8, with coordinates $\Gamma$9 and per-point features $$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$0. The tokenizer uses Transition Down layers from Point Transformer or PointNet++ to lift feature dimension and reduce token count. Positional and feature information are fused before the encoder: $$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$1 For point inputs, geometry therefore enters through pre-encoder coordinate fusion rather than explicit relative positional encoding inside attention (Wang et al., 2022).

A major consequence of keeping the backbone unchanged is direct reuse of 2D ImageNet-pretrained weights for the transformer encoder. The paper further introduces a teacher–student learning-without-forgetting objective,

$$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$2

with $$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$3 in experiments. The purpose is to retain 2D knowledge while fine-tuning on 3D tasks (Wang et al., 2022).

6. Tasks, empirical behavior, and limitations of Simple3D-Former

Simple3D-Former is evaluated on 3D object classification, point-cloud segmentation, and indoor scene detection. For classification, the class token is fed to a linear MLP head; for segmentation, Transition Up layers mirror Transition Down layers and interpolate features back to the original point set with U-Net style skip connections; for indoor detection, the encoder in 3DETR is replaced with Simple3D while keeping the decoder and detection head unchanged (Wang et al., 2022).

Task / dataset	Reported result	Context
ModelNet40 voxel classification	mAcc 84.0, OA 88.0	Voxel Simple3D
ModelNet40 point classification	mAcc 89.3, OA 92.0	Point Simple3D
ScanObjectNN PB_T50_RS	OA 83.1	Matches Point-BERT
ShapeNetPart	cat. mIoU 83.3, ins. mIoU 86.0	Competitive with Point Transformer
S3DIS Area-5	mAcc 72.5, ins. mIoU 67.0	Robust despite no 3D-aware attention changes
SUN RGB-D	AP25 57.6, AP50 32.0	Comparable to 3DETR

The ablations clarify where the performance comes from. On ShapeNetV2 and ModelNet40, the 2D projection variant improves from $$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$4 without 2D knowledge to $$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$5 with pretraining plus teacher ViT. In low-quantity 3D data regimes on ShapeNetPart, teacher guidance provides consistent gains across $$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$6, $$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$7, and $$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$8 data fractions. Backbone scaling also behaves predictably: DeiT-tiny gives $$\alpha = l/D,\qquad \beta = r/D,\qquad \gamma = d/D,$$9 OA on ModelNet40 with $l$0M parameters and $l$1G FLOPs, DeiT-small gives $l$2 OA with $l$3M and $l$4G, and DeiT-base gives $l$5 OA with $l$6M and $l$7G (Wang et al., 2022).

Among voxel tokenizers, group embedding is reported as best on ShapeNetV2. With $l$8, naive, 2D projection, and group embedding yield $l$9, $r$0, and $r$1, respectively, for with/without 2D pretraining; with $r$2, the corresponding values are $r$3, $r$4, and $r$5. The projection axis is dataset-dependent: for 2D projection, XYZ, YZX, and ZXY produce different OA values on ShapeNetV2 and ModelNet40, and the paper notes that group embedding reduces this sensitivity (Wang et al., 2022).

The limitations are primarily tied to full self-attention. Attention complexity is $r$6 time and $r$7 memory per block, so very large scenes or extremely high-resolution voxels lead to long token sequences and may require windowed or sparse attention. The method is also described as sensitive to voxel or patch size $r$8, potentially affected by non-uniform point densities due to TD and TU interpolation heuristics, not evaluated on outdoor LiDAR, and limited by the absence of stronger 3D-aware attention priors (Wang et al., 2022).

7. Conceptual relation and recurring misconceptions

The most immediate misconception is terminological: “Simple3D” does not designate a single canonical method in the literature considered here. It refers to at least two distinct systems with different objectives, representations, and computational substrates (Cheng et al., 10 Jul 2025, Wang et al., 2022).

A second misconception is architectural. In the anomaly-detection literature, Simple3D is not a deep transformer or CNN backbone; the paper states that no deep neural backbone is used and that there are effectively no learnable parameters. Its discriminative mechanism is MSND plus LFSA plus nearest-prototype Euclidean distance on normal-only data (Cheng et al., 10 Jul 2025). By contrast, Simple3D-Former is explicitly a transformer model built from standard DeiT-style encoder blocks and trained for supervised 3D tasks (Wang et al., 2022).

A third misconception concerns how “simple” is realized. In Simple3D-Former, simplicity means keeping the 2D ViT encoder unchanged and modifying only tokenization, positional encoding, and heads; in the anomaly-detection Simple3D, simplicity means eliminating heavy backbones and relying on geometric descriptors, local averaging, and prototype memory. This suggests that the two methods share a minimalist engineering stance while occupying different points in the design space of 3D vision.

Taken together, the two Simple3D lines delineate a broader methodological contrast in 3D research. One line argues that carefully engineered local descriptors and efficient spatial aggregation can achieve state-of-the-art accuracy and real-time throughput in high-resolution industrial anomaly detection. The other argues that a standard 2D ViT backbone, with minimal adaptations at the interface layers, can remain competitive across 3D classification, segmentation, and detection. Their coexistence under the same name is therefore best understood as a coincidence of nomenclature coupled with a shared preference for architectural economy rather than as evidence of a single unified framework.