💻 computer science

Orientation-Aware Mesh Learning via a Signed Half-Dihedral Scalar for Robust Shape Classification under Structural Perturbations

This paper proposes an orientation-aware mesh learning method that utilizes a novel signed half-dihedral scalar to encode local face orientation, significantly improving robustness and classification accuracy for 3D shapes under structural perturbations like cutting and open boundaries compared to conventional edge-centric approaches.

Original authors: Jong-Hyun Kim

Published 2026-07-28

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Jong-Hyun Kim

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a computer to recognize 3D objects, like a cat, a dinosaur, or a pair of glasses, just by looking at their digital blueprints. These blueprints are called "meshes," and they are built from thousands of tiny triangles stitched together, much like a geodesic dome or a low-poly video game character. For a computer to understand these shapes, it needs to know not just how big the triangles are, but how they are tilted and connected. The tricky part is that computers are often terrible at understanding "direction." If you have a hill and a valley that look exactly the same from the side, a standard computer might think they are identical because it only measures the steepness, not whether the slope is going up or down. This is a huge problem because real-world objects often get damaged, cut, or have missing pieces. If a computer can't tell the difference between a "bump" and a "dip," it might get confused when a part of the object is sliced off, leading to a total failure in recognizing what the object is.

This paper introduces a clever new way to teach computers this missing sense of direction. The researchers, led by Jong-Hyun Kim, propose a simple but powerful trick: instead of just measuring the angle between two triangles, they give that angle a "sign," like a positive or negative number. Think of it like giving a compass a north and a south pole, or telling a story with a clear "left" and "right." By using this "signed" number, the computer can finally tell the difference between a convex bump (like a nose) and a concave dent (like a nostril), even if the object has been chopped up or rotated. The paper shows that this tiny addition makes the computer much tougher and less likely to get confused when the shape is imperfect, without needing to rebuild the entire computer brain from scratch.

The Problem: The Computer's "Blind Spot"

For a long time, the best way to teach computers about 3D shapes was to use a system called MeshCNN. Imagine MeshCNN as a detective who walks along the edges of a 3D object, looking at the triangles connected to each edge. The detective measures things like the length of the edge and the angle between the triangles. However, there was a major blind spot: the detective only measured the size of the angle, not the direction.

If you have a piece of paper folded like a mountain (convex) and another folded like a valley (concave), a standard detector sees the same angle for both. It's like looking at a shadow; a mountain and a valley cast the same shadow if the light is in the right spot. This is fine for perfect, closed objects, but the real world is messy. If you take a 3D scan of a statue and a chunk gets cut off, or if the object is rotated, the computer loses its context. Without knowing which way is "up" or "in," the computer might think a cut-off cat is actually a snake because the remaining edges look similar to a snake's body. The old methods struggled to keep their cool when the shape was broken or incomplete.

The Solution: The "Signed" Compass

To fix this, the authors invented a new tool called a Signed Half-Dihedral Scalar. That's a mouthful, so let's break it down with an analogy.

Imagine you are standing on a hinge (an edge) connecting two doors (triangles).

The Old Way: You just measure how wide the doors are open. You say, "They are open 45 degrees." But you don't know if the left door swung out or the right door swung in.
The New Way: You add a sign. You say, "The left door swung out 22.5 degrees, and the right door swung in 22.5 degrees."

The authors call this a "signed half-dihedral scalar." It's a single number that tells the computer two things at once:

How much the surface is tilted (the magnitude).
Which way it is tilted (the sign: positive for one direction, negative for the other).

This number is special because it doesn't care if you move the object, spin it around, or make it bigger or smaller. It only cares about the local relationship between the two triangles. It's like a GPS that works even if you turn the map upside down.

How They Tested It

The team didn't just guess that this would work; they put it to the test using a standard set of 3D shapes called the SHREC benchmark. They had 600 different objects, ranging from cats and rabbits to dinosaurs and sharks.

First, they tested the computer on perfect, whole objects. The new method got 99.5% of them right. This is just as good as the best existing methods, proving that adding this new "direction sense" doesn't slow the computer down or confuse it when things are perfect.

But the real magic happened when they broke the objects. They simulated "structural perturbations," which is a fancy way of saying they chopped off parts of the shapes, rotated them weirdly, or moved them around.

When they cut the shapes, the old methods (like MeshCNN) started to fail, dropping in accuracy significantly.
The new method, however, stayed incredibly strong, keeping 93.33% accuracy even when the objects were damaged.

The authors ran a specific experiment to prove that their new tool was actually doing the heavy lifting. They tested three versions:

Shape only: The computer looked at the size of the triangles but ignored direction. It got 96.8% right.
Direction only: The computer looked at the direction but ignored the size. It got 94.5% right.
Both together: The computer used both the size and the signed direction. It got 99.5% right.

This showed that the new "signed" number wasn't just a duplicate of what the computer already knew; it was a crucial piece of the puzzle that worked with the shape information to make the system smarter.

Why This Matters

The most important finding here isn't that the computer got slightly better at recognizing cats. It's that the computer became robust. In the real world, 3D scans are rarely perfect. They have holes, missing pieces, and weird angles. The old methods relied on the object being a perfect, closed shell. If you cut a hole in it, the computer got lost.

By using this signed scalar, the computer can now look at a broken piece of a shape and still say, "Ah, this is a cat, even though its ear is missing, because I can still feel the direction of the remaining fur." The paper suggests that this approach is a "representation-level extension," meaning it's a way to upgrade the data the computer sees without needing to replace the entire computer brain. It's like giving your existing glasses a new lens that helps you see in the dark, rather than buying a whole new pair of eyes.

The Bottom Line

The paper concludes that this simple, signed number is a powerful tool for making 3D shape recognition more reliable. It suggests that the main benefit lies in preserving "explicit local orientation cues," which means the computer never loses track of which way is up or down, even when the object is incomplete. While the authors note that this method is designed to work with existing systems rather than replace them entirely, the results show that adding this "direction sense" is a game-changer for handling the messy, imperfect 3D objects we encounter in the real world. The computer is no longer just counting triangles; it's finally understanding the story they tell.

Technical Summary: Orientation-Aware Mesh Learning via a Signed Half-Dihedral Scalar

Problem Statement

Learning on triangular meshes offers significant potential for 3D shape classification and segmentation due to the preservation of intrinsic surface geometry and connectivity. However, existing mesh-based neural networks, such as MeshCNN, predominantly rely on edge-centric features and unsigned geometric descriptors (e.g., unsigned dihedral angles). This reliance creates a fundamental ambiguity: geometrically distinct configurations, such as convex and concave folds with identical edge lengths and areas, are mapped to similar feature representations. Consequently, these models struggle to generalize under structural perturbations, such as cutting, open boundaries, or positional variations, where orientation consistency is critical for preserving geometric meaning. The core challenge addressed is the lack of an explicit, sign-aware notion of face orientation in current mesh learning pipelines.

Methodology

The paper proposes an orientation-aware mesh learning representation that encodes local face orientation as a single signed scalar, integrated into a standard MeshCNN-style pipeline without replacing the network backbone.

1. Signed Half-Dihedral Scalar

The core innovation is a signed half-dihedral scalar ( $\phi_f$ ) defined at the edge–face level. Unlike traditional unsigned dihedral angles, this scalar captures both the direction (sign) and magnitude of a face's orientation relative to a shared edge.

Definition: For an edge $e$ shared by two faces with unit normals $n_1$ and $n_2$ , the method projects these normals onto a plane orthogonal to the edge direction ( $\Pi^\perp_{\hat{e}}$ ). A bisector axis $b$ and a tangential axis $t$ are constructed in this plane. The orientation scalar for a face $f$ is computed as:
$\phi_f(e) = \text{atan2}(p_f \cdot t, p_f \cdot b)$
where $p_f$ is the projected normal.
Properties:
- Invariance: The scalar is invariant to translation, rotation, and scaling.
- Sign-Awareness: It explicitly distinguishes between convex and concave configurations (e.g., $\phi_f$ and $-\phi_f$ ).
- Recoverability: The full signed dihedral angle $\theta_e$ can be exactly recovered from the two per-face scalars ( $\theta_e = \phi_2 - \phi_1$ ).
Stabilization: To handle numerical instability near sharp folds ( $|\theta_e| \approx \pi$ ) or boundary edges (single adjacent face), the method employs fallback strategies, such as projecting a global axis onto the orthogonal plane or using local average normals.

2. Integration with MeshCNN

The proposed scalar is integrated as an additional feature alongside existing shape descriptors (specifically the height-to-edge ratio $r = 2A/\|e\|^2$ ).

Feature Pair: The local geometry is represented by the pair $\{r, \phi_f\}$ , where $r$ captures triangle slenderness (shape) and $\phi_f$ captures signed orientation.
Pipeline: The method follows the standard MeshCNN workflow: edge-based feature extraction $\rightarrow$ mesh convolution (using symmetric neighbor aggregation) $\rightarrow$ mesh pooling (edge collapse) $\rightarrow$ global aggregation $\rightarrow$ classification via MLP. The signed scalar serves as an input feature, allowing the existing edge-centric architecture to access sign-aware face information.

3. Training and Loss

To address the periodic discontinuity of angular values at $\pm\pi$ , the authors utilize periodic-invariant loss functions (e.g., $L_{ang} = 1 - \cos(\hat{\phi} - \phi)$ ) during the learning of orientation features. This ensures smooth gradients and stable convergence, particularly when orientation is directly supervised or compared.

Key Contributions

Sign-Aware Descriptor: Introduction of a single-scalar, sign-aware orientation descriptor (signed half-dihedral) that explicitly encodes face orientation in a transformation-invariant manner.
Representation-Level Extension: Integration of this scalar into existing MeshCNN-style pipelines as an additional edge–face feature, enabling edge-centric architectures to incorporate explicit face-level orientation without architectural overhaul.
Robustness Demonstration: Empirical evidence showing that the proposed representation maintains high accuracy under structural perturbations (cutting, rotation, positional variation) where conventional unsigned or edge-centric representations degrade.

Experimental Results

The method was evaluated on the SHREC benchmark (600 meshes, 30 classes) with a 480/120 train/test split.

Closed-Mesh Classification: The proposed method achieved 99.5% accuracy, demonstrating competitive performance against state-of-the-art methods like DiffusionNet (99.7%) and SubdivNet (99.5%).
Ablation Study:
- Shape-only ( $r$ ): 96.8% accuracy.
- Orientation-only ( $\phi$ ): 94.5% accuracy.
- Combined ( $r + \phi$ ): 99.5% accuracy.
  This confirms that shape and orientation provide complementary, non-redundant information.
Robustness Under Perturbation: Under structural transformations (cutting, rotation, positional shifts), the proposed method retained 93.33% accuracy. In contrast, other methods showed significant drops (e.g., SubdivNet dropped 17.8 percentage points, DiffusionNet dropped 13.5 percentage points).
Qualitative Analysis: Visualizations of orientation profiles across cut boundaries showed that the proposed signed scalar varies smoothly and maintains directional consistency, whereas diffusion-based or gradient-based representations exhibited noisy and inconsistent variations near boundaries.

Significance and Claims

The paper positions its contribution not as a new network architecture designed solely to maximize closed-mesh classification accuracy, but as a compact geometric representation that addresses a fundamental limitation of existing edge-centric learning: the inability to distinguish direction-sensitive configurations.

Robustness over Capacity: The primary advantage is the preservation of explicit local orientation cues under incomplete or perturbed mesh conditions (e.g., cuts, open boundaries). This makes the method particularly suitable for real-world scenarios where mesh connectivity is disrupted.
Interpretability: The signed scalar provides a physically interpretable representation that disentangles shape from orientation, offering clearer supervisory signals for the network.
Efficiency: The computation of the scalar is $O(1)$ per edge-face pair, resulting in linear overall complexity $O(|E|)$ , which is fully parallelizable on GPUs and comparable in efficiency to existing methods.

The authors conclude that the proposed signed scalar serves as a robust, representation-level extension that enhances the reliability of mesh learning in the presence of structural perturbations, rather than competing with high-capacity backbones on standard closed-mesh benchmarks alone.