All summaries · 2026-09-11

Learn the Solid, Not the File: Canonical Inputs for Neural Networks on CAD Boundary Representations

Heinrich Jiang, Hager Yasser Mohamed, Alexander Hitt, et al.

arXiv:2609.11573 · abstract · pdf · summarized by meta/muse-spark-1.3-contributor on 2026-09-11

The one-paragraph version

This paper argues that neural networks for computer-aided design are learning the wrong thing: the file, not the shape. In CAD, the standard format called boundary representation, or B-rep, describes a solid object by dividing its outer skin into trimmed surface pieces called faces, joined along curves called edges. The catch is that the same solid can be divided up in many different valid ways — different engineers, export settings, or geometry kernels can split faces, rotate the coordinate system, or rewrite a simple shape like a cylinder in a generic freeform language, without changing the geometry at all. The authors show that popular B-rep encoders called UV-Net, BRepNet, and AAGNet collapse under such changes, then propose a new input called the canonical region graph that is built from the solid itself. It merges face fragments that belong to the same underlying surface into whole regions, puts everything in a coordinate frame computed from the shape's own center and principal directions, and describes regions with frame-relative features. That input is provably unchanged by re-splitting and rigid motion, matches the best baseline on clean benchmarks, and stays essentially flat under synthetic splits, rotations, rewrites, real Rhino import-export round-trips, and differently authored human models.

The problem they're solving, and why it matters

Boundary representation, meaning a description of a 3D solid by its bounding surfaces plus how they connect, is what modern CAD systems actually store and exchange. A growing research field trains neural networks directly on B-reps for tasks like recognizing machined features such as holes or pockets, labeling each face by what it is, retrieving similar parts, predicting how parts assemble, or generating new CAD.

The problem is representation fragility. A B-rep is not unique. As the authors explain, the exact same geometric boundary admits arbitrarily many valid topological decompositions into faces and edges. Concrete causes include: drawing a circular sketch profile as one full circle versus two half-arcs, extruding in one step versus two half-extrusions, mirroring half a part and leaving a seam, splitting faces with section planes, moving the part in space, and translating between kernels that rewrite analytic surfaces — meaning simple shapes defined by equations like plane, cylinder, sphere, cone, torus — as NURBS, meaning Non-Uniform Rational B-Splines, CAD's generic freeform format defined by a grid of control points.

If a model is meant to reason about the solid, it should give about the same answer for any valid B-rep of that solid. The paper shows it does not. The baselines inherit file accidents: UV-Net and AAGNet sample small image grids in each face's own surface parameterization, so re-cutting or re-expressing the surface changes the features; BRepNet walks the face-edge adjacency structure, so splitting a face rewrites the walks; all use the file's coordinate frame, so rotation moves every coordinate. In practice this is not academic, because files routinely pass through cleanup, translation, and different authoring habits before a model ever sees them.

The key idea, in plain words

Learn the solid, not the file. Instead of trusting the faces and coordinates as stored, recompute a coarser, more stable description from the geometry itself.

Think of a soup can: the file might store its cylindrical side as one face, two half-faces, or four quarter-faces, plus separate top and bottom discs. The canonical approach says: recognize those side pieces are all parts of one same cylinder, merge them into one whole surface region, and make that region a node in a graph. Two nodes get an edge when their regions actually touch on the solid.

Then, stop using the designer's arbitrary placement. Instead of saying "the hole center is at x equals 10 in file coordinates," compute a shape-centered frame: origin at the boundary's center of mass, meaning its area-weighted average position, and axes along its principal directions, meaning the natural long, middle, and short axes from its inertia, like in mechanics. Express all positions and directions in that frame, rescale so total area equals one to remove size units, and compute only features that add up correctly when a region is split. The result is a region graph whose structure, frame, and features move with the solid but do not change when you merely redraw its seams.

How it actually works, step by step

First, assign a surface identity key to every stored face. For analytic faces, the key is the surface type plus its defining numbers written in a standard form, for example a cylinder's axis and radius or a plane's normal and offset. For faces stored as NURBS or procedural forms like a line revolved around an axis, the method first tries to fit them back to the five analytic types, simplest first, accepting only very tight fits; genuinely freeform surfaces are keyed by their underlying untrimmed control data, not just the trimmed visible patch. Because splitting only redraws trim bounds on the same underlying surface, the key survives cutting.

Second, merge into canonical regions. Two faces join the same region when they share the same key and share an edge, applied transitively. The shared-edge requirement matters: two separate identical holes that happen to lie on the same plane should stay separate. Each maximal merged patch becomes one graph node. Two nodes are connected when their regions share a boundary curve.

Third, build the canonical frame. Compute the boundary centroid and its inertia tensor, meaning a summary of how area is spread around the center, from exact surface integrals so subdivision does not change the total. Take its eigenvectors as axes. Resolve the remaining ambiguities: each axis sign is chosen by which side has more area, measured by third-order asymmetry or skew, with smooth blending when the part is too symmetric to decide; when two inertia values are nearly equal and axes are interchangeable, features are blended toward their exact average over the ambiguous rotation; the frame is forced to be right-handed so mirror images are not accidentally identified.

Fourth, compute invariant features. Each region gets 115 numbers and each adjacency gets 10 numbers: surface type and parameters, area, centroid, average normal, spreads, curvature totals, loop counts and lengths, how much border is sharp or concave versus convex, bend-angle histograms along borders, and a coarse map of where area sits. Crucially there are no UV parameterization grids. Everything positional is expressed in the canonical frame.

Finally, learn on that graph with an ordinary graph transformer — the paper uses 8 layers of edge-conditioned attention, width 512, about 17.5M parameters — to predict per-region labels. For evaluation on face-label tasks, each stored face simply inherits its region's prediction, so split pieces agree by construction.

Theory backs this up. The paper proves that valid analytic partitions of the same solid yield the same region decomposition, that integrals add correctly over subdivisions so features and frame are partition-independent, that features in the equivariant frame are rotation- and translation-invariant, and that mesh-sampled histograms drift only proportionally to mesh error. It also proves a limit: a truly partition-invariant predictor can only use geometry, so it cannot recover history labels like which modeling operation created a face when different histories give the same shape.

What they showed — results, honestly, with limitations

On representation-level checks on 3000 test solids, re-splitting, rewriting analytics as NURBS, and random rigid motion gave 99.9 to 100% identical region graphs, with feature differences at numerical noise levels.

On segmentation, meaning labeling each face, measured by macro mIoU, meaning per-class overlap between predicted and true labels averaged over classes with 1.0 perfect: on MFInstSeg, MFCAD++, and CADSynth, the authors' method stays around 0.986 to 0.992 on clean data and essentially unchanged under axis splits, diagonal splits, rotation, NURBS re-expression, and all combined. Baselines collapse — for example on MFInstSeg, AAGNet falls from 0.9851 clean to 0.0055 combined, UV-Net from 0.9725 to 0.0026, BRepNet from 0.9828 to 0.4428. A point-cloud baseline is naturally stable to splits but far less accurate and rotation-sensitive. More splitting monotonically hurts baselines while the new method stays flat.

Similar patterns hold for retrieval without training, where the query is a perturbed version of a database part: the new method gets 96.1%, 96.3%, 88.3%, 80.5%, 76.1% rank-1 under the five perturbations, while baselines often drop to single digits. For predictive churn, meaning fraction of face predictions that flip under perturbation: the new method flips 0.00 to 0.02% of faces and affects 0.00 to 0.33% of solids, versus up to 98% of faces and 100% of solids for baselines. A real Rhino import-export round-trip of the whole test split drops AAGNet to 0.2838 and UV-Net to 0.0433, leaves BRepNet at 0.9674, and leaves the new method at 0.9870. A human study of 25 parts modeled differently in FreeCAD by two experts shows 0.2 to 0.5% churn for the new method versus 11 to 30% for baselines. Ablations confirm merging is essential, and training baselines with augmentations helps the seen perturbation but transfers poorly — architecture-level invariance wins.

Limitation, stated honestly: invariance has a cost. On Fusion 360 Gallery segmentation, where the label is the modeling operation that created each face, history traces in the partition are informative. There the new method scores 0.6148 clean versus 0.7412, 0.6977, and 0.7162 for baselines, though it wins once perturbations are applied. The human study is also small, and some details like exact handling of highly symmetric frames and freeform keys rely on tolerances and appendices that are hard to fully audit from the main text.

Why this might matter to me

For spatial reasoning in LLMs and VLMs and for world models, this is a cautionary template: if your 3D input bakes in authoring accidents like mesh triangulation, face splits, or arbitrary world coordinates, a language-grounded reasoner may appear to understand shape while actually keying on file artifacts. A canonicalized, shape-centered frame plus part-level grouping is a closer analog to object-centered representations that support stable reference, rotation reasoning, and cross-view correspondence.

For text-to-CAD and parametric geometry, the equivalence-class idea reframes evaluation. Counting two valid B-reps of the same solid as distinct or novel, or penalizing a generator for using a different but geometrically correct face decomposition than a single reference, mismeasures success. Future text-to-CAD metrics and retrievers will likely need geometry-first matching like region graphs, with history-aware heads added only where operation labels are truly needed.

For 3D generation and scene representation, canonical regions suggest a useful intermediate: mergeable analytic patches plus symmetry-aware canonical frames as stable tokens for diffusion or autoregressive models, complemented by freeform residuals. That could give generators and world models inputs that are compact, interpretable, and robust to kernel translation — learning solids and scenes, not files.

Terms worth knowing