MeshConv3D: Efficient convolution and pooling operators for triangular 3D meshes

Germain Bregeon; Marius Preda; Radu Ispas; Titus Zaharia

REVIEW 5 major objections 5 minor 21 references

MeshConv3D: Efficient convolution and pooling operators for triangular 3D meshes

T0 review · 5 major / 5 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 MeshConv3D claims a CNN can learn directly on raw triangular meshes, matching prior accuracy at a fraction of the memory.

desk verdict Plausible parallel mesh pooling idea, but the pooling sizes don't work on 500-face meshes and the efficiency numbers are therefore unverifiable as written. read the letter →

arxiv 2501.03830 v1 pith:T74NXKUT submitted 2025-01-07 cs.CV cs.GR

Germain Bregeon , Marius Preda , Radu Ispas , Titus Zaharia This is my paper · ORCID

classification cs.CVcs.GR

keywords 3Dmeshclassificationconvolutionfacecollapsepoolingtriangularmesheslocaldescriptorsorder-invariantGPUmemoryefficiencydeeplearningon

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

The paper introduces MeshConv3D, a pair of neural-network operators—convolution and pooling—designed to run directly on triangular meshes without remeshing. It claims these operators let a VGG-style classifier match the best published mesh-classification accuracy on SHREC11 and the cube dataset, and reach 92.4% on Manifold40, while using about 682 MB of GPU memory at training time versus roughly 2.6 to 7.4 GB for comparable methods. If the claim holds, dense 3D meshes become tractable inputs for deep networks, because the costly remeshing that multiplies face counts is avoided.

What carries the argument

The central mechanism is the parallel face-collapse pooling operator driven by a descriptor-difference significance weight. For each face, the weight is computed as $w_f = \sum_{n=1}^{3} \lVert d_f - d_{f_n} \rVert_2$, and the algorithm greedily selects faces with the lowest weight while marking overlapping candidates as incompatible, then collapses all selected regions in parallel. The second piece is the order-invariant convolution operation, which uses sums and absolute differences of neighboring face descriptors rather than imposing a fixed ordering on irregular neighborhoods, and whose kernel size $K$ controls how many rings of neighbors are included. Together these operators allow a standard convolutional architecture to run on native meshes.

What would settle it

Run the same architecture on Manifold40 with the pooling faces chosen randomly instead of by the lowest L2 distance to neighbors. If random pooling reproduces the reported 92.4% accuracy, the paper's significance criterion is not doing the work; if accuracy drops sharply, the criterion is load-bearing.

Watch

Extended reading notes

Core claim

The central claim is that a mesh CNN can preserve discriminative face information while eliminating about half the faces per pooling step, if the faces to collapse are chosen by a simple local criterion. The pooling algorithm assigns each face a weight equal to the L2 distance between its descriptor and its three neighbors' descriptors, greedily selects non-conflicting faces with the lowest weights, and collapses all selected regions simultaneously, averaging the features of collapsed faces into the surviving faces. On SHREC11 and the cube dataset, the paper reports 100% accuracy in both tested splits; on Manifold40 it reports 92.4%, which is within the range of prior methods. The paper argues that these results are equivalent or superior to prior work while using substantially less GPU memory and computation.

Load-bearing premise

The entire efficiency story depends on the assumption that a face whose local descriptor is close to its three neighbors' descriptors is safe to collapse, and the paper offers no ablation comparing this rule with random or learned pooling.

Editorial extensions

If this is right

Mesh classification can be run on native meshes, so the preprocessing pipeline no longer needs remeshing or conversion, removing a major source of memory overhead and potential distortion.
Because the pooling operator eliminates about half the faces per pass and computes many collapses at once, deeper networks can be trained on meshes that would otherwise exceed GPU memory.
The convolution layer is order-invariant and its receptive-field size is adjustable, so the same operator can be widened without redefining the neighborhood structure.
On the tested 500-face benchmarks, the reported accuracy is equal to or above that of prior methods, indicating that raw triangular face descriptors plus efficient pooling are sufficient for semantic classification.

Reading between the lines

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

A natural next step the paper does not take is to swap the L2-based pooling criterion for a learned significance score or a curvature-aware measure; if accuracy improves on Manifold40, the descriptor-difference heuristic, rather than the descriptors themselves, would be the limiting factor.
The efficiency comparison is measured at training time on 500-face meshes; on denser meshes the parallel face-collapse step should make the memory advantage grow, but the paper does not show such scaling.
Because the convolution and pooling operate on faces rather than vertices or edges, the same building blocks could be dropped into a segmentation or generative autoencoder, where hierarchical collapse is a natural encoder; the paper tests only 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.

Desk Editor's Note

read the letter

Quick take: this paper has a useful idea buried under a reproducibility problem. The MeshConv3D pooling—selecting non-overlapping face-collapse regions greedily by a descriptor-distance heuristic and collapsing them in parallel—is genuinely more parallelizable than the sequential edge-collapse used in MeshCNN, and the variable-size convolution regions are a reasonable way to grow receptive fields without remeshing. The authors also compare against the right baselines and are honest that ExMeshCNN beats them on Manifold40 (92.4 vs 93.6), which the abstract's "equivalent or superior" claim doesn't quite cover.

The soft spots are real. The big one: the architecture says three pooling layers with target sizes T=400, 300, and 200, but all input meshes have 500 faces and each pooling pass removes "about half" of them. If the first pass takes 500 to ~250, the pool stops because 250 is below the 400 target. The second pool (T=300) is then a no-op, and only the third (T=200) does anything, to ~125. So the network is not the VGG-like stack the text describes, and the runtime/memory numbers in Table III were measured on something else. The paper doesn't explain this. It also gives no kernel size K, no channel counts for the conv blocks, no error bars on runtime or memory, and no code. For a paper whose headline is efficiency, that's a serious gap.

The pooling selection heuristic itself (L2 distance to neighbors as salience) is plausible but untested. There's no ablation against random pooling or a learned score, so I can't tell whether the greedy selection is doing any work for accuracy.

Bottom line: the core operators may be sound, but as written the paper is not reproducible enough to verify the central efficiency claim. I'd send it to peer review, because the parallel pooling idea deserves scrutiny and the flaws are fixable, but I'd expect a major revision—clarify the pooling semantics, report actual per-layer sizes, give full hyperparameters, add ablations, and release code. Without that, the efficiency numbers don't stand.

Referee Report

5 major / 5 minor

Summary. The paper presents MeshConv3D, a convolutional and pooling framework that operates directly on triangular meshes. Convolution patches are built by iteratively expanding face neighborhoods to a user-defined kernel size K, and the convolution is an order-invariant sum of central and neighboring face descriptors (Eq. 4). Pooling greedily selects faces with the smallest L2 descriptor-distance to their neighbors (Eq. 5), collapses mutually compatible regions in parallel, and removes roughly half of the faces per pass. Classification experiments are reported on SHREC11, cubes, and Manifold40, together with runtime and GPU-memory comparisons against MeshCNN, MeshNet++, and SubdivNet.

Significance. If the reported behavior is reproducible, MeshConv3D would be a practically useful mesh-CNN building block: it avoids remeshing, supports variable receptive fields, and its pooling is parallel and removes many faces at once, addressing a known bottleneck of edge-collapse pooling. The paper builds on prior descriptors from ExMeshCNN rather than claiming a new descriptor, and the convolution and pooling definitions are simple and clearly specified at a conceptual level. The evidence, however, is underreported: no architecture or kernel-size specification, no ablations for the pooling criterion, and no variance information for the efficiency measurements. The manuscript is therefore a plausible incremental contribution whose empirical claims need substantial strengthening before the efficiency and accuracy conclusions can be accepted.

major comments (5)

[III-C and IV-A] The pooling target sizes T=400, 300, and 200 are unreachable on the benchmark meshes, all of which have 500 faces, as they are described. Section III-C states that each pooling pass eliminates 'about a half' of the faces, and steps 5-6 stop as soon as the mesh size is no longer superior to T. Starting from 500 faces, the first pass would leave roughly 250 faces, already below T=400, so the second and third pooling layers could not operate on meshes of 400 and 300 faces as the VGG-like architecture in Section IV-A requires. If instead the network actually produces 400 faces after the first pooling, then only about 100 faces are removed, contradicting the stated half-face removal and the claimed parallel efficiency. The architecture and the pooling operator are thus not consistently specified, and the runtime and memory values in Table III are not reproducible from the paper alone.
[III-B and IV-A] The manuscript never specifies the convolution kernel size K or the remaining network hyperparameters, such as the number of channels per block, the number of convolutional layers per block, activation, optimizer, learning rate, epochs, and training batch size. Because the convolution definition in Eq. (4) depends on K, and the VGG-like architecture is central to the accuracy results, the reported 100% scores on SHREC11 and cubes and 92.4% on Manifold40 cannot be reproduced or compared fairly from the text.
[III-C and Eq. (5)] The pooling significance criterion is asserted rather than validated. The only evaluation of the L2-distance heuristic is end-to-end accuracy on datasets where several methods saturate at 100% in Table I, which cannot discriminate among pooling strategies. An ablation comparing the proposed significance score with random pooling or with alternative criteria, such as learned significance scores, is necessary to support the claim that the pooling mechanism preserves discriminative information while removing half the faces per pass.
[IV-E and Table III] The efficiency comparison is underreported. The table gives a runtime ratio and peak memory for each competing method but no standard deviation, no description of the competing implementations' configurations, and no per-method breakdown of the pooling and convolution contributions. Since SubdivNet's runtime ratio is 0.87, the claim of superior efficiency is sensitive to implementation details; without more detail and error bars, the superiority conclusion is not established.
[IV-D and Table II] The characterization of the Manifold40 results is imprecise: Table II reports 92.4% for MeshConv3D versus 93.6% for ExMeshCNN, which is a lower accuracy, and the surrounding text acknowledges this only indirectly. The abstract's phrase 'equivalent or superior classification results' is defensible for SHREC11 and cubes, but on Manifold40 the result is inferior to the closest competitor; the claim should be qualified accordingly.

minor comments (5)

[IV-D, Table I] The table formatting is inconsistent: for example, the MeshNet++ row shows '98,5' without a percent sign, and decimal commas should be unified throughout the tables.
[References] Reference [20] appears to point to Wu et al., 3D ShapeNets, but the cubes dataset is described as built from the MPEG-7 binary shape dataset; the citation should be verified and corrected if necessary.
[IV-E] The text uses 'efficacity' where 'efficacy' is intended; this and similar wording issues should be corrected.
[Figures 2 and 3] The color-based explanations in the captions are difficult to follow in a black-and-white rendering; adding explicit labels or a short textual description of which faces disappear would improve clarity.
[V] The final paragraph contains a typo, 'more advances convolutional kernels', which should read 'more advanced convolutional kernels'.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: MeshConv3D is an empirical architecture paper whose benchmark results are measured against external datasets, not derived from its own definitions.

full rationale

MeshConv3D is an empirical architecture paper. Its convolution operator (Eq. 4) and pooling operator (Eq. 5) are newly proposed mechanisms with learnable weights, and the reported classification accuracies are measured on external benchmarks (SHREC11, cubes, Manifold40) using standard train/test splits. The only imported component is the face descriptor d_f = (K_f, G_f), which is explicitly attributed to ExMeshCNN [1], a prior work by different authors; this is legitimate external support, not a self-citation chain. No equation defines its output in terms of the accuracies later reported, no fitted parameter is renamed as a prediction, and no uniqueness theorem is invoked to force a choice. The noted inconsistency between pooling target sizes T=400/300/200 and the 500-face benchmark meshes is a potential reproducibility or correctness defect, not a circular derivation, so it does not affect the circularity score.

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

The paper introduces no new physical entities. Its claims rest on the borrowed descriptors, the manifold assumption, an unspecified kernel size, and an unvalidated pooling heuristic.

free parameters (3)

Pooling target sizes T = 400, 300, 200
Hand-chosen for each pooling layer in the VGG-like architecture; no justification or sensitivity study is given.
Convolution kernel size K = not reported
The paper says kernel size is variable but never states the value used in the experiments, so the receptive field size is unknown.
Network architecture hyperparameters = not reported
Number of channels, convolutional layer depths, learning rate, and training epochs are not specified, making the efficiency claims hard to interpret.

assumptions (4)

domain assumption Meshes are consistently oriented manifold meshes
Section III's first paragraph asserts this assumption, though the abstract claims 'arbitrary topology'; border faces are zero-padded.
domain assumption ExMeshCNN descriptors K_f and G_f capture sufficient local geometry
The method adopts these descriptors without independent validation, making the central accuracy claim depend on their quality.
domain assumption Iterative neighbor expansion yields representative receptive fields
Section III-B expands regions by adding neighbors until K faces are reached, but no analysis shows this produces meaningful local patches for arbitrary connectivity.
ad hoc to paper L2-distance face significance is a valid pooling criterion
Section III-C Eq. (5) defines pooling priority as L2 distance to neighbor descriptors; this heuristic is not justified or compared with alternatives.

how reviews work

0 comments

Cite this review

Pith. "Pith review of MeshConv3D: Efficient convolution and pooling operators for triangular 3D meshes." pith.science (2026). https://pith.science/paper/T74NXKUT

@misc{pith2026250103830,
  author       = {Pith},
  title        = {Pith review of: MeshConv3D: Efficient convolution and pooling operators for triangular 3D meshes},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/T74NXKUT}},
  note         = {Machine review of arXiv:2501.03830}
}

read the original abstract

Convolutional neural networks (CNNs) have been pivotal in various 2D image analysis tasks, including computer vision, image indexing and retrieval or semantic classification. Extending CNNs to 3D data such as point clouds and 3D meshes raises significant challenges since the very basic convolution and pooling operators need to be completely re-visited and re-defined in an appropriate manner to tackle irregular connectivity issues. In this paper, we introduce MeshConv3D, a 3D mesh-dedicated methodology integrating specialized convolution and face collapse-based pooling operators. MeshConv3D operates directly on meshes of arbitrary topology, without any need of prior re-meshing/conversion techniques. In order to validate our approach, we have considered a semantic classification task. The experimental results obtained on three distinct benchmark datasets show that the proposed approach makes it possible to achieve equivalent or superior classification results, while minimizing the related memory footprint and computational load.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

21 extracted references · 11 canonical work pages

[1]

ExMeshCNN: An Explainable Convolutional Neural Network Architecture for 3D Shape Analysis,

S. Kim and D.-K. Chae, “ExMeshCNN: An Explainable Convolutional Neural Network Architecture for 3D Shape Analysis,” in Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, Washington DC USA: ACM, Aug. 2022, pp. 795–803. doi: 10.1145/3534678.3539463

arXiv 2022
[3]

MeshCNN: A Network with an Edge,

R. Hanocka, A. Hertz, N. Fish, R. Giryes, S. Fleishman, and D. Cohen-Or, “MeshCNN: A Network with an Edge,” ACM Trans. Graph., vol. 38, no. 4, pp. 1–12, Aug. 2019, doi: 10.1145/3306346.3322959

arXiv 2019
[4]

DATASET. E. Performance review The criteria retained for evaluating the performances are the runtime ratio and peak memory usage. The runtime ratio, quantified as the ratio between the execution time of alternative methods and the one of our approach, alongside peak memory usage—representing the maximum GPU memory required during training in megabytes (MB...

work page
[5]

Subdivision-Based Mesh Convolution Networks,

S.-M. Hu et al., “Subdivision-Based Mesh Convolution Networks,” ACM Trans. Graph., vol. 41, no. 3, pp. 1–16, Jun. 2022, doi: 10.1145/3506694

work page doi:10.1145/3506694 2022
[6]

Multi-view Convolutional Neural Networks for 3D Shape Recognition,

H. Su, S. Maji, E. Kalogerakis, and E. Learned-Miller, “Multi-view Convolutional Neural Networks for 3D Shape Recognition,” in 2015 IEEE International Conference on Computer Vision (ICCV), Santiago, Chile: IEEE, Dec. 2015, pp. 945–953. doi: 10.1109/ICCV.2015.114

doi:10.1109/iccv.2015.114 2015
[7]

DeepPano: Deep Panoramic Representation for 3-D Shape Recognition,

B. Shi, S. Bai, Z. Zhou, and X. Bai, “DeepPano: Deep Panoramic Representation for 3-D Shape Recognition,” IEEE Signal Processing Letters, vol. 22, no. 12, pp. 2339–2343, Dec. 2015, doi: 10.1109/LSP.2015.2480802

work page arXiv 2015
[10]

Mesh Convolutional Autoencoder for Semi-Regular Meshes of Different Sizes,

S. Hahner and J. Garcke, “Mesh Convolutional Autoencoder for Semi-Regular Meshes of Different Sizes,” in 2022 IEEE/CVF Winter Conference on Applications of Computer Vision (WACV), Waikoloa, HI, USA: IEEE, Jan. 2022, pp. 2344–2353. doi: 10.1109/WACV51458.2022.00240

arXiv 2022
[12]

Geodesic Convolutional Neural Networks on Riemannian Manifolds,

J. Masci, D. Boscaini, M. M. Bronstein, and P. Vandergheynst, “Geodesic Convolutional Neural Networks on Riemannian Manifolds,” in 2015 IEEE International Conference on Computer Vision Workshop (ICCVW), Santiago, Chile: IEEE, Dec. 2015, pp. 832–840. doi: 10.1109/ICCVW.2015.112

work page doi:10.1109/iccvw.2015.112 2015

Show all 21 references

[13]

doi: 10.48550/arXiv.2012.00888

2012 doi arXiv
[15]

doi: 10.48550/arXiv.2010.12455

2010 doi arXiv
[16]

Face-Based CNN on Triangular Mesh with Arbitrary Connectivity,

H. Wang, Y. Guo, and Z. Wang, “Face-Based CNN on Triangular Mesh with Arbitrary Connectivity,” Electronics, vol. 11, no. 15, Art. no. 15, Jan. 2022, doi: 10.3390/electronics11152466

2022 doi
[18]

MAPS: multiresolution adaptive parameterization of surfaces,

A. W. F. Lee, W. Sweldens, P. Schröder, L. Cowsar, and D. Dobkin, “MAPS: multiresolution adaptive parameterization of surfaces,” in Proceedings of the 25th annual conference on Computer graphics and interactive techniques - SIGGRAPH ’98, Not Known: ACM Press, 1998, pp. 95–104....

1998
[19]

Available: https://dl.acm.org/doi/abs/10.1145/3386569.3392418

[Online]. Available: https://dl.acm.org/doi/abs/10.1145/3386569.3392418
[20]

3D ShapeNets: A deep representation for volumetric shapes,

Zhirong Wu et al., “3D ShapeNets: A deep representation for volumetric shapes,” in 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Boston, MA, USA: IEEE, Jun. 2015, pp. 1912–1920. doi: 10.1109/CVPR.2015.7298801

2015
[21]

doi: 10.48550/arXiv.1811.11424

doi arXiv
[2017]

doi: 10.48550/arXiv.1612.00593

doi arXiv
[2018]

doi: 10.48550/arXiv.1803.02108

doi arXiv
[2020]

doi: 10.48550/arXiv.2006.05353

2006 doi arXiv
[2022]

doi: 10.36227/techrxiv.19137518.v2

doi
[2023]

Available: http://arxiv.org/abs/1904.07601

[Online]. Available: http://arxiv.org/abs/1904.07601

1904 arXiv
[2024]

Available: https://dl.acm.org/doi/abs/10.1145/3474085.3475468

[Online]. Available: https://dl.acm.org/doi/abs/10.1145/3474085.3475468

Pith tools

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

[1] [1]

ExMeshCNN: An Explainable Convolutional Neural Network Architecture for 3D Shape Analysis,

S. Kim and D.-K. Chae, “ExMeshCNN: An Explainable Convolutional Neural Network Architecture for 3D Shape Analysis,” in Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, Washington DC USA: ACM, Aug. 2022, pp. 795–803. doi: 10.1145/3534678.3539463

arXiv 2022

[2] [3]

MeshCNN: A Network with an Edge,

R. Hanocka, A. Hertz, N. Fish, R. Giryes, S. Fleishman, and D. Cohen-Or, “MeshCNN: A Network with an Edge,” ACM Trans. Graph., vol. 38, no. 4, pp. 1–12, Aug. 2019, doi: 10.1145/3306346.3322959

arXiv 2019

[3] [4]

DATASET. E. Performance review The criteria retained for evaluating the performances are the runtime ratio and peak memory usage. The runtime ratio, quantified as the ratio between the execution time of alternative methods and the one of our approach, alongside peak memory usage—representing the maximum GPU memory required during training in megabytes (MB...

work page

[4] [5]

Subdivision-Based Mesh Convolution Networks,

S.-M. Hu et al., “Subdivision-Based Mesh Convolution Networks,” ACM Trans. Graph., vol. 41, no. 3, pp. 1–16, Jun. 2022, doi: 10.1145/3506694

work page doi:10.1145/3506694 2022

[5] [6]

Multi-view Convolutional Neural Networks for 3D Shape Recognition,

H. Su, S. Maji, E. Kalogerakis, and E. Learned-Miller, “Multi-view Convolutional Neural Networks for 3D Shape Recognition,” in 2015 IEEE International Conference on Computer Vision (ICCV), Santiago, Chile: IEEE, Dec. 2015, pp. 945–953. doi: 10.1109/ICCV.2015.114

doi:10.1109/iccv.2015.114 2015

[6] [7]

DeepPano: Deep Panoramic Representation for 3-D Shape Recognition,

B. Shi, S. Bai, Z. Zhou, and X. Bai, “DeepPano: Deep Panoramic Representation for 3-D Shape Recognition,” IEEE Signal Processing Letters, vol. 22, no. 12, pp. 2339–2343, Dec. 2015, doi: 10.1109/LSP.2015.2480802

work page arXiv 2015

[7] [10]

Mesh Convolutional Autoencoder for Semi-Regular Meshes of Different Sizes,

S. Hahner and J. Garcke, “Mesh Convolutional Autoencoder for Semi-Regular Meshes of Different Sizes,” in 2022 IEEE/CVF Winter Conference on Applications of Computer Vision (WACV), Waikoloa, HI, USA: IEEE, Jan. 2022, pp. 2344–2353. doi: 10.1109/WACV51458.2022.00240

arXiv 2022

[8] [12]

Geodesic Convolutional Neural Networks on Riemannian Manifolds,

J. Masci, D. Boscaini, M. M. Bronstein, and P. Vandergheynst, “Geodesic Convolutional Neural Networks on Riemannian Manifolds,” in 2015 IEEE International Conference on Computer Vision Workshop (ICCVW), Santiago, Chile: IEEE, Dec. 2015, pp. 832–840. doi: 10.1109/ICCVW.2015.112

work page doi:10.1109/iccvw.2015.112 2015