Mesh Convolution Block

• Mesh convolution blocks are locality-preserving operators that aggregate features over irregular geometric domains such as faces, edges, or vertices.
• They utilize specialized neighborhood construction and aggregation schemes, including self-terms and symmetric neighbor summations, to ensure permutation invariance.
• Integrated with normalization, non-linearities, and adaptive pooling, these blocks form deep mesh networks for tasks like segmentation, classification, and correspondence.

A mesh convolution block is a fundamental locality-preserving operator that enables the propagation and aggregation of feature information on irregular geometric domains, such as triangular meshes. Unlike 2D image convolutions that rely on regular, grid-based neighborhoods, mesh convolution blocks operate over the complex adjacency structure of mesh faces, edges, or vertices. To address mesh irregularity, various mesh convolution blocks have been developed which carefully define local connectivity, orderings, and aggregation schemes. These operators are typically stacked, often interleaved with normalization, nonlinearities, and mesh-adaptive pooling operations, to form deep mesh networks for shape analysis, segmentation, and classification.

1. Signal Domains and Feature Representation

Mesh convolution blocks differ in their choice of domain (vertex, edge, or face), which determines the structure of input and output features. In MeshConv3D, for a mesh $M = (V, E, F)$ with vertices $V = \{v_i \in \mathbb{R}^3\}$ and triangular faces $F$, the operator acts on per-face signals $d_f \in \mathbb{R}^{C_\mathrm{in}}$ for each $f \in F$. The input descriptor $d_f$ typically concatenates geometric encodings (e.g., geodesic and shape descriptors), while the output is an updated per-face feature $d_f^{\mathrm{out}} \in \mathbb{R}^{C_\mathrm{out}}$. This face-centric design contrasts with vertex-based methods (as in semi-regular mesh CNNs) and edge-based approaches (e.g., MeshCNN), underlining the flexibility of mesh convolution blocks to different mesh signalizations (Bregeon et al., 7 Jan 2025, Hanocka et al., 2018, Liu et al., 2019).

2. Mathematical Formulation of Mesh Convolution

Mesh convolution fundamentally generalizes the local aggregation principle to mesh connectivity by defining neighborhoods and summarization rules. In MeshConv3D, for each face $f$, a local patch $R_f$ with $K$ neighbors $\{f_n : n=1,\ldots,K\}$ is built, and the convolution is defined as

$$\mathrm{Conv}(d_f) = W_0\, d_f + W_1 \sum_{n=1}^{K} d_{f_n} + W_2 \sum_{n=1}^{K} |d_f - d_{f_n}|$$

where $$W_0, W_1, W_2 \in \mathbb{R}^{C_\mathrm{out} \times C_\mathrm{in}}$$ are learnable parameters, and $|\cdot|$ denotes elementwise absolute value (Bregeon et al., 7 Jan 2025). This formula comprises a self-term, a symmetric neighbor sum, and a feature-difference term, resulting in permutation invariance with respect to neighbor ordering. Other works propose alternative aggregations using ring-ordered neighborhoods or attention-based message passing, but the principle remains: constructing an aggregation operator that respects mesh topology and invariances (Hu et al., 2021, Milano et al., 2020).

3. Neighborhood Construction and Ordering

The choice and construction of local patches are central to mesh convolution blocks. MeshConv3D implements a region-growing algorithm: for each face, neighbors are first selected from the 1-ring (faces sharing an edge), sorted by shared-edge length. If fewer than $K$ neighbors are available, the patch is expanded iteratively by union of 1-ring neighbors until saturation. The final patch includes the center and exactly $K$ peripheral faces, with any excess faces discarded. Since the aggregation is via summation, the output is invariant to residual ordering, mitigating ambiguity from mesh irregularity (Bregeon et al., 7 Jan 2025). Other operators, such as SpiralNet++ and SubdivNet, impose explicit local orderings such as spirals or consistent counter-clockwise traversals to enable weight sharing and efficient batching (Gong et al., 2019, Hu et al., 2021).

4. Learnable Parameters and Architectural Integration

The parametric design of mesh convolution blocks governs expressive capacity and efficiency. In MeshConv3D, each block contains three weight matrices of size $C_\mathrm{out} \times C_\mathrm{in}$, with an optional bias vector. The total parameter count is $3 C_\mathrm{out} C_\mathrm{in} + C_\mathrm{out}$. The operator is typically embedded in a VGG-like or U-Net-style network, where blocks are stacked and separated by nonlinearities (ReLU or LeakyReLU), optional normalization (e.g., BatchNorm), and mesh-adaptive pooling layers. For classification, features are aggregated (e.g., global average pooling) and mapped to class scores through a final linear projection (Bregeon et al., 7 Jan 2025, Hu et al., 2021, Yang et al., 2022).

MeshConv Variant	Domain	Param Count (per block)
MeshConv3D	Face	$3C_\mathrm{out} C_\mathrm{in} + C_\mathrm{out}$
MeshCNN	Edge	$5C_\mathrm{in}C_\mathrm{out} + C_\mathrm{out}$
SpiralNet++	Vertex	$$C_\mathrm{out} (\ell C_{\mathrm{in}}) + C_\mathrm{out}$$

While MeshConv3D and MeshCNN aggregate over center-plus-neighborhood, SpiralNet++ unfolds neighbor features into fixed-length spirals, for direct application of dense fully connected transformations (Bregeon et al., 7 Jan 2025, Hanocka et al., 2018, Gong et al., 2019).

5. Normalization, Weighting, and Pooling

Most mesh convolution blocks apply normalization and weighting schemes to stabilize training. MeshConv3D does not employ explicit area- or degree-based normalization; all neighbor contributions are summed unweighted, and normalization is deferred to pooling stages. Pooling is implemented via parallel face collapse, where features of surviving faces are recomputed as ring-averages, effectively re-averaging and normalizing signal propagation. The pooling operation removes approximately half of the faces per pass, enabling efficient pyramidal representation (Bregeon et al., 7 Jan 2025). Other works utilize similar mesh-aware pooling strategies (edge or vertex collapse) and may apply standard normalization layers (e.g., GroupNorm in MeshCNN) post-convolution (Hanocka et al., 2018).

6. Network Design and Applications

Stacking mesh convolution blocks—interleaved with nonlinearities and mesh downsampling—enables deep mesh neural networks for a wide spectrum of geometric learning tasks. In MeshConv3D, the network ingests per-face descriptors, applies three sequential mesh convolution + pooling blocks, aggregates features globally, and emits class scores for semantic classification (Bregeon et al., 7 Jan 2025). The method operates on arbitrary mesh topologies without the need for prior remeshing, and has demonstrated competitive performance on benchmark shape classification datasets, with reduced memory and computational demands.

Mesh convolution blocks also underpin architectures for segmentation, correspondence, and generative modeling in 3D domains, offering direct support for irregular surfaces and topologies beyond what is achievable with 2D or voxel-based CNNs. The underlying design principles—locality, permutation invariance, and topological adaptivity—are common across variants, but the instantiations differ according to signal domain, neighborhood construction, and aggregation semantics.

7. Comparison with Alternative Mesh Convolution Paradigms

Several alternative mesh convolution blocks have been proposed in the literature. MeshCNN operates on edges with a five-term aggregation (center and four symmetric neighbor combinations), applying GroupNorm and ReLU, and pooling via task-driven edge collapse (Hanocka et al., 2018). SpiralNet++ unfolds a fixed-length spiral of vertex neighbors, concatenates their features, and applies a global affine transformation; no explicit normalization or coordinate weighting is used, and fixed spirals promote training stability (Gong et al., 2019). Subdivision-based mesh convolution (SubdivNet) exploits the regular face adjacency of Loop-subdivided meshes to mimic 2D convolution concepts (kernel size, stride, dilation), thus facilitating analogs of 2D architectures on mesh data (Hu et al., 2021). Attention-based mesh convolution blocks, as in Primal–Dual MeshCNN and attention mesh convolution, enhance adaptivity via learned attention weights and channel gating, targeting geometric regions or feature channels most relevant to the task (Milano et al., 2020, Yang et al., 2022).

A plausible implication is that mesh convolution blocks represent a spectrum between rigid locality-preserving aggregation and flexible attention-driven message passing, with the unifying principle of respecting mesh geometry and topology during feature propagation. MeshConv3D exemplifies the former, prioritizing efficiency and parameter sharing on arbitrary mesh topology, while attention blocks provide increased expressivity and interpretability at additional computational cost.