title: >- [Paper Note] BRepFacetGen: Reverse Engineering B-Reps By Generative Face Segmentation description: >- [ECCV 2026][3D Vision][B-Rep Reverse Engineering] BRepFacetGen models CAD face decomposition as a geometry-conditioned latent variable problem on continuous surfaces, coupling a pretrained 3D geometry prior with flow-matching label generation to reconstruct robust, high-fidelity CAD B-Reps. tags: - ECCV 2026 - 3D Vision - CAD Reconstruction - B-Rep - Flow Matching date: 2026-09-19 content_hash: f89b097c9d22492e

BRepFacetGen: Reverse Engineering B-Reps By Generative Face Segmentation¶

Conference: ECCV 2026
Paper: ECCV Official Page
Area: 3D Vision
Keywords: B-Rep Reverse Engineering, 3D Foundation Models, Generative Face Segmentation, Flow Matching, CAD Reconstruction

TL;DR¶

To overcome topological instability and structural ambiguity in traditional deterministic point-cloud CAD reverse engineering, BRepFacetGen formulates CAD face decomposition as a generative latent variable problem conditioned on continuous geometry, coupling pretrained 3D foundation models with flow-matching label synthesis to deliver superior geometric and topological fidelity in B-Rep reconstruction.

Background & Motivation¶

Boundary representations (B-Reps) serve as the fundamental backbone of computer-aided design (CAD) and industrial manufacturing. Unlike discrete polygonal approximations, B-Reps encapsulate continuous, editable parametric surfaces (such as planes, cylinders, tori, and B-splines) alongside explicit, watertight topological boundary connectivity, which downstream finite element simulation, CNC machining, and interactive modeling workflows strictly depend on. Simultaneously, recent 3D foundation models (e.g., TripoSG and MeshXL) have demonstrated extraordinary capability in synthesizing high-fidelity 3D geometry from disparate inputs like images and text. However, their raw outputs are uniformly confined to unsegmented triangle meshes or implicit fields, resulting in a persistent, profound gap between modern 3D generative synthesis and downstream CAD-native engineering pipelines.

Bridging this gap is traditionally framed as a reverse engineering problem: partitioning a discrete input into smooth patches, fitting analytical or free-form parametric surfaces to each patch, and reconstructing valid B-Rep topology via surface intersection and boundary trimming. Existing learning-based approaches (such as ParSeNet, HP-Net, and SED-Net) fundamentally treat this workflow as a deterministic classification task on discrete, resolution-limited point clouds. This deterministic paradigm breaks down due to two major barriers: first, CAD face decompositions exhibit intrinsic permutation ambiguity and structural non-uniqueness—a single geometry often admits multiple valid, plausible CAD face segmentations, rendering deterministic supervision underdetermined; second, point-cloud predictions suffer from discrete sampling sparsity and boundary aliasing, which induces severe label leakage across sharp edges and directly destabilizes downstream curve intersection and topological trimming.

To resolve these core challenges, this work argues that CAD structure inference must be elevated from deterministic point classification to a generative latent variable problem defined directly over continuous surface geometry. Core idea: decouple CAD representation into a pretrained 3D geometry latent set and a geometry-conditioned label latent space, modeling multiple plausible dense surface segmentations via probabilistic flow matching, and using continuous faceted meshes as the high-resolution interface for downstream parametric fitting and topological reconstruction.

Method¶

Overall Architecture¶

The end-to-end framework of BRepFacetGen comprises four coordinated stages: continuous geometry encoding and mesh extraction, geometry-conditioned label latent space modeling, dense face-instance label decoding over continuous meshes, and classical surface fitting and topological assembly. Given an input point cloud or single-view image, the system first leverages a frozen pretrained 3D foundation model to extract geometry latent vectors and extract a base triangle mesh. A flow-matching conditional generator then samples a mutually compatible label latent set conditioned on geometry. Finally, dense query-based label decoding assigns face instances to mesh facets, providing a high-density, boundary-aligned segmented mesh to guide parametric surface fitting, intersection, and trimming in the Point2CAD kernel.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    In["Input Geometry<br/>Point cloud X or single image"] --> GEnc["Frozen Geometry Encoder<br/>Extract geometry latents Zg & mesh M"]
    GEnc --> FM["Flow-Matching Generator<br/>Sample label latents Zℓ conditioned on Zg"]
    FM --> LDec["Dense Label Decoder<br/>Query instance classes at face centers"]
    LDec --> SegMesh["Segmented Mesh<br/>Continuous geometry with dense labels"]
    SegMesh --> P2C["Surface Fitting & Topology Recovery<br/>Point2CAD fitting, intersecting & trimming"]
    P2C --> Out["Standard CAD B-Rep Solid<br/>Parametric surfaces + exact topology"]

Key Designs¶

1. Pretrained Geometry Latent Reuse: Anchoring Continuous Geometry with 3D Foundation Priors Prior CAD reconstruction pipelines typically train geometry feature extraction from scratch on synthetic CAD datasets, limiting their generalization and robustness. BRepFacetGen leverages the frozen weights of the pretrained TripoSG 3D foundation model as its geometry VAE backbone. From a dense surface point set $X=\{(x_i, n_i)\}_{i=1}^N$ ($N=16,384$), point embeddings are compressed via farthest point sampling (FPS) into $M \ll N$ spatial anchors. Through cross-attention and $L_{\text{enc}}$ self-attention layers, the network constructs a pre-variational geometry latent set $\tilde{Z}_g \in \mathbb{R}^{M \times C}$ and samples latent vectors $Z_g$. Decoded via query-based signed distance function (SDF) evaluation and marching cubes, this backbone provides a high-fidelity continuous geometry mesh $M$ while natively accommodating both point clouds and single-view images as inputs.

2. Geometry-Conditioned Label Latent Space: Resolving Permutation Ambiguity and Non-Uniqueness Because CAD face segmentation admits arbitrary instance label permutations and multiple plausible topological decompositions for the same physical shape, deterministic label assignment frequently struggles at surface boundaries. The authors propose a probabilistic Label VAE that models a conditional distribution $q(Z_\ell \mid \tilde{Z}_g)$ over label latent sets. Training points are supervised with one-hot instance vectors $Y \in \{0, 1\}^{N \times K}$ augmented with random permutation matrices $\Pi$ on active instance IDs ($Y\Pi$). The resulting initial label latent set $\tilde{Z}_\ell$ incorporates geometric conditioning via cross-attention with the frozen geometry latent set: $$ \hat{Z}\ell = \mathrm{Attn}(\tilde{Z}\ell, \tilde{Z}_g, \tilde{Z}_g) $$ before sampling $Z_\ell$. At decoding time, a lightweight classification head predicts instance probabilities at arbitrary continuous 3D surface queries. This probabilistic formulation naturally models the multi-modal distribution of valid face segmentations without brittle Hungarian matching.

3. Latent Flow-Matching Generator: Efficient Anchor-Aligned Conditioning Across Modalities In generative and reconstruction workflows where ground-truth label latents are unavailable, the model must synthesize a compatible label latent set $Z_\ell$ purely from geometry latents $Z_g$. The authors design a conditional velocity network $v_\theta(Z_t, t, Z_g)$ governed by flow matching. Recognizing that both geometry latents $Z_g$ and noisy label latents $Z_t$ are anchored at the exact same $M$ spatial FPS locations, the architecture completely dispenses with costly cross-attention layers. Instead, it performs direct channel-wise concatenation: $$ H_t = \mathrm{MLP}_{\mathrm{in}}([Z_t, Z_g]) \in \mathbb{R}^{M \times C} $$ Following AdaIN-style timestep modulation $e(t)$ and $L_{\text{gen}}$ self-attention blocks, the network predicts the straight-line flow velocity target $v^\star = Z_\ell - Z_0$ under the loss $\mathcal{L}_{\mathrm{FM}} = \mathbb{E}_{t, Z_0, Z_\ell}[\|v_\theta(Z_t, t, Z_g) - (Z_\ell - Z_0)\|^2]$. At inference, a numerical ODE solver integrates from standard Gaussian noise $Z_0 \sim \mathcal{N}(0, I)$ at $t=0$ to $t=1$, yielding a coherent label latent set aligned with the input geometry.

4. Dense Continuous Mesh Fitting: Eliminating Discrete Point Resolution Bottlenecks Directly running parametric surface fitting and edge intersection on sparse, unorganized point clouds invariably leads to distorted trim curves and disjoint topology due to missing geometric support near sharp transitions. BRepFacetGen queries the trained label decoder at the face centroids of the high-resolution triangle mesh $M$ extracted from the geometry SDF. The resulting segmented mesh is then resampled via Poisson-disk sampling to produce a dense point set $X_{\text{dense}}$ of $N_d=100,000$ points with transferred face labels. This dense, surface-bounded point distribution is fed into the Point2CAD kernel to fit B-splines and analytical primitives, compute analytic curve intersections between adjacent patches, trim boundaries, and assemble the final B-Rep solid.

Loss & Training¶

The training pipeline is executed in two decoupled stages: 1. Label VAE Training: With frozen TripoSG geometry weights, the label encoder and decoder are trained for 200k iterations with a batch size of 64 and a learning rate of $1\times 10^{-4}$, employing a cross-entropy loss against permuted one-hot face labels alongside a KL divergence regularization loss weighted by $1\times 10^{-3}$. 2. Conditional Flow-Matching Generator Training: Using paired latent sets $(Z_g, Z_\ell)$ cached from the dataset, the velocity network is trained on the flow-matching regression objective $\mathcal{L}_{\mathrm{FM}}$ for 700k iterations with a batch size of 128, a learning rate of $5\times 10^{-5}$, and an exponential moving average (EMA) decay of 0.9999. Training was conducted across 32 NVIDIA H100 GPUs, taking approximately 3 days and 7 days for the two stages, respectively.

Key Experimental Results¶

Main Results¶

Evaluation was conducted on the intersection of the filtered ABC-1M test split with the ParSeNet benchmark (around 700 CAD models containing complex B-spline patches and 10 to 100 faces).

Table 1: Instance-Level Point Segmentation Results on ParSeNet Benchmark (All metrics: higher is better)

Method	mIoU ↑	Accuracy (Acc.) ↑	Precision (Prec.) ↑	Recall (Rec.) ↑	F1 Score ↑
ParSeNet [ECCV 2020]	0.7671	0.5232	0.5472	0.6021	0.5582
HP-Net [ICCV 2021]	0.7486	0.5542	0.5928	0.6263	0.5896
SED-Net [SIGGRAPH 2023]	0.8010	0.5130	0.5262	0.5857	0.5420
PrimitiveNet [ICCV 2021]	0.7189	0.3069	0.3527	0.3479	0.3376
BRepFacetGen (Ours)	0.8046	0.7040	0.7606	0.7575	0.7470

Table 2: Point-Cloud to B-Rep Geometric Error, Topology Correctness, and Detection Performance (CD: lower is better; Topology FE/EV and Detection F1: higher is better; V: Vertices, C: Curves, S: Surfaces)

Method	V CD ↓	C CD ↓	S CD ↓	Topology FE ↑	Topology EV ↑	V F1 ↑	C F1 ↑	S F1 ↑
ComplexGen [TOG 2022]	0.205	0.173	0.106	0.186	0.298	0.236	0.205	0.273
Split-and-Fit [SIGGRAPH 2024]	0.416	0.154	0.051	0.167	0.182	0.216	0.211	0.347
ParSeNet + Point2CAD	0.399	0.144	0.086	0.236	0.213	0.203	0.208	0.293
HP-Net + Point2CAD	0.357	0.108	0.076	0.245	0.231	0.232	0.240	0.328
BRepFacetGen + Point2CAD (Ours)	0.233	0.085	0.057	0.315	0.304	0.558	0.579	0.770

Ablation Study¶

The authors thoroughly evaluated the core algorithmic choices: generative label latents versus capacity-matched deterministic segmentation heads, and dense continuous mesh fitting versus direct sparse point fitting.

Table 3: Ablation on Segmentation Formulation and Fitting Resolution

Configuration	Seg mIoU ↑	Seg F1 ↑	Vertex F1 ↑	Curve F1 ↑	Surface F1 ↑	Topology FE ↑
Deterministic Head [small capacity]	0.7360	0.6633	0.292	0.344	0.470	0.308
Deterministic Head [large capacity]	0.7167	0.6372	0.255	0.318	0.448	0.285
Fitting directly from input points (Points)	0.8046	0.7470	0.264	0.295	0.417	0.286
HP-Net directly on 100k dense points	-	-	0.122	0.119	0.222	0.160
Full Model (Ours, Dense Mesh Fitting)	0.8046	0.7470	0.558	0.579	0.770	0.315
Full Model (Best of 10 Generations Oracle)	0.8368	0.8397	-	-	-	-

Key Findings¶

Generative Modeling Outperforms Deterministic Matching Decisively: Increasing deterministic model capacity actually degraded segmentation performance (F1 fell from 0.6633 to 0.6372), falling far behind the generative latent approach (0.7470). This proves that structural ambiguity in CAD decomposition is an intrinsic distributional problem that cannot be resolved merely by expanding network parameters under deterministic Hungarian matching.
High Sample Consistency with Constructive Multi-Modality: Evaluating 10 independent stochastic generations per shape yielded an average pairwise adjusted Rand index (ARI) of 0.934, demonstrating that the learned space reliably preserves core topological structure while supporting plausible local variations. Oracle selection among 10 samples raised segmentation mIoU from 0.8046 to 0.8368 and F1 from 0.7470 to 0.8397.
Continuous Mesh Density is Essential for Robust Topology: Feeding the exact same segmentation labels to Point2CAD via sparse input points produced a surface F1 of only 0.417. In contrast, querying on the reconstructed continuous mesh and sampling 100k points boosted surface F1 to 0.770. Running HP-Net directly on 100k points collapsed surface F1 to 0.222, proving that high-density continuous geometry combined with resolution-independent probabilistic label querying is indispensable.

Highlights & Insights¶

Reframing Reverse Engineering as Conditional Latent Generation: Rather than forcing a neural network to make deterministic, brittle point classifications, treating face segmentation as a geometry-conditioned continuous latent variable effectively bypasses permutation ambiguities and multi-modal decomposition conflicts.
Anchor-Aligned Cross-Attention-Free Conditioning: By enforcing geometry and label latents to share identical spatial FPS anchor positions, the flow-matching generator achieves rich spatial conditioning via direct channel concatenation and self-attention, eliminating expensive cross-attention operations.
Bridging General 3D Foundation Priors with CAD B-Reps: BRepFacetGen successfully repurposes general-purpose 3D foundation model latents (TripoSG) to drive precision engineering CAD outputs, providing a practical blueprint for CAD-native synthesis from multi-modal inputs.

Limitations & Future Work¶

Reliance on General-Domain Geometry Priors: The frozen TripoSG backbone is pretrained on generic 3D assets and can occasionally produce smoothed features or miss internal mechanical cavities in complex CAD solids. Fine-tuning foundation priors specifically on CAD geometry distributions represents an essential next step.
Inference Latency in Flow-Matching ODE Integration: Generating label latents requires multi-step numerical integration of the flow-matching ODE, introducing noticeable inference latency compared to feed-forward networks. Exploring few-step distillation or consistency models could substantially speed up sampling.
Downstream Heuristic Kernel Vulnerabilities: The final conversion step relies on Point2CAD's heuristic intersection and trimming rules, which can still fail on highly complex free-form junctions or tiny fillets. Deep integration with industrial solid modeling kernels (e.g., OpenCASCADE or Parasolid) will be required for seamless manufacturing deployment.

vs ParSeNet / HP-Net: Traditional methods perform deterministic classification on discrete point sets, leading to severe aliasing and boundary leakage near edges; BRepFacetGen models continuous label latent distributions and extracts dense mesh queries, elevating surface detection F1 from 0.328 to 0.770.
vs ComplexGen / Split-and-Fit: Direct B-Rep generators either restrict themselves to simple planar/cylindrical primitives or suffer from noisy, spurious curve complexes on free-form geometry; BRepFacetGen decouples geometry synthesis from face partitioning, achieving superior topological correctness (FE: 0.315 vs 0.186).
vs CADDreamer: CADDreamer infers neural SDFs from single-view images via multi-view normal rendering, which is vulnerable to heavy geometric drift; BRepFacetGen harnesses foundation geometry priors and flow-matching labels, reducing single-image Chamfer Distance by more than half (0.1185 vs 0.2606).

Rating¶

Novelty: ⭐⭐⭐⭐⭐ Formulating CAD face segmentation as a continuous geometry-conditioned generative latent modeling problem is a brilliant paradigm shift.
Experimental Thoroughness: ⭐⭐⭐⭐⭐ Rigorous evaluation across point segmentation, point-to-B-Rep, image-to-B-Rep, and deep ablations on sample diversity and fitting resolutions.
Writing Quality: ⭐⭐⭐⭐⭐ Exceptionally structured, mathematically concise, and compellingly motivated.
Value: ⭐⭐⭐⭐⭐ Establishes a viable, robust bridge connecting modern 3D foundation models with industrial CAD/B-Rep engineering workflows.