Parametric CAD Reconstruction from Unstructured Point Clouds

20 concepts19 papers1 proposal

When we scan a physical object using 3D sensors, the output is typically a point cloud—an unstructured collection of millions of $(x, y, z)$ coordinates. To a computer, this point cloud is a "dumb" geometry; it has no concept of flat faces, cylindrical holes, or sharp edges. If an engineer wants to alter the radius of a scanned pipe or shift a wall in a scanned building, they cannot simply change a parameter. Instead, they must undergo a tedious, manual process of reverse engineering to convert the discrete points into a structured, editable Computer-Aided Design (CAD) model.

As noted by Cohen-Or et al. in a foundational look at digital geometry processing, bridging this gap between raw acquisition and high-level semantic understanding is a core challenge in the lifecycle of 3D data (Preface). Over the past decade, researchers have shifted from simple geometric fitting to deep learning architectures that infer the underlying mathematical logic, topology, and even the step-by-step construction history of 3D shapes.

From Points to Mathematical Primitives

The first step in making an unstructured point cloud editable is grouping points into geometric primitives like planes, spheres, cylinders, and cones.

Traditional geometric fitting algorithms often fail when faced with sensor noise or missing data. To solve this, Li et al. introduced the Supervised Primitive Fitting Network (SPFN), which demonstrates how deep neural networks can be trained to predict per-point primitive membership and parameters simultaneously (Supervised Fitting of Geometric Primitives to 3D Point Clouds). By optimizing a loss function that accounts for both point segmentation and the mathematical parameters of the surface, the network forces a global consistency that naturally resists local sensor noise.

Unstructured Point Cloud ──> [ Neural Network ] ──> Parametric Patches (Planes, Cylinders, B-Splines)

However, mechanical parts are rarely composed entirely of perfect primitives; they often feature organic, free-form surfaces. To bridge this gap, Sharma et al. developed ParSeNet (ParSeNet: A Parametric Surface Fitting Network for 3D Point Clouds). The key insight of ParSeNet is the integration of a specialized spline-fitting network alongside primitive estimators. By decomposing a shape into a mixture of standard primitives and open B-spline patches, the system can represent arbitrary geometries while retaining the mathematical precision required by CAD software.

Recovering Sharp Edges and Wireframe Graphs

Primitives and splines define the surfaces of an object, but a functional CAD model requires explicit boundaries. Physical 3D scanners naturally smooth out sharp corners, turning crisp mechanical edges into rounded, blurry approximations.

To recover these lost boundaries, Matveev et al. proposed leveraging scalar distance fields (3D Parametric Wireframe Extraction Based on Distance Fields). Instead of detecting edges directly from noisy point distributions, their pipeline computes a distance field where the value at any spatial coordinate represents its proximity to a sharp edge. This continuous field allows the system to mathematically trace the zero-crossings and extract clean, parametric splines along the true boundaries of the object. Similarly, Cherenkova et al. developed SepicNet to infer parametric curves directly from the geometry, explicitly counteracting the smoothing artifacts introduced by hardware scanners (SepicNet: Sharp Edges Recovery by Parametric Inference of Curves in 3D Shapes).

Once these edges are identified, they must be organized into a coherent structure. In architectural modeling, for instance, a "polygon soup" of walls is far less useful than a clean structural skeleton. The authors of PC2WF: 3D Wireframe Reconstruction from Raw Point Clouds addressed this by training an end-to-end network to jointly detect structural vertices and prune candidate connections, transforming raw points directly into a structured wireframe graph. For large-scale environments, Luo et al. demonstrated that processing intermediate "line clouds" via a specialized Transformer architecture allows the system to resolve complex structural junctions far more reliably than point-based methods alone (Learning to Construct 3D Building Wireframes from 3D Line Clouds).

Enforcing Topological Logic via Boundary Representations

While wireframes provide a skeleton, professional CAD engines rely on Boundary Representations (B-Reps). A B-Rep is not just a collection of geometric shapes; it is a highly structured graph where faces, edges, and vertices are logically linked by adjacency relationships.

   [ B-Rep Graph Structure ]
          Face (Plane)
         /            \
   Edge (Line)     Edge (Line)
         \            /
        Vertex (Point)

To reconstruct valid B-Reps, neural networks must understand this underlying topological logic. Cherenkova et al. introduced SpelsNet to enforce these relationships during the learning process (SpelsNet: Surface Primitive Elements Segmentation by B-Rep Graph Structure Supervision). Instead of treating surface segmentation as a purely spatial classification task, SpelsNet uses the adjacency matrix of a target B-Rep graph as a supervisory signal. This forces the network to learn not just where points are in space, but how the underlying surfaces must logically meet to form a watertight, mathematically sound solid.

Inferring the Sequential Language of Design

The ultimate goal of mesh-to-CAD conversion is to recover the actual design history—the sequence of modeling commands a human engineer would use, such as drawing a 2D sketch and extruding it to create a 3D volume.

Early deep learning approaches tackled this by breaking shapes down into single-step operations. Uy et al. introduced Point2Cyl, which uses differentiable solvers to reverse-engineer point clouds into a collection of extrusion cylinders (Point2Cyl: Reverse Engineering 3D Objects from Point Clouds to Extrusion Cylinders). Concurrently, Ren et al. developed ExtrudeNet, demonstrating that a network can learn to parse shapes into 2D Bézier sketches and extrusion parameters in a completely unsupervised manner by minimizing the reconstruction error between the extruded shapes and the target point cloud (ExtrudeNet: Unsupervised Inverse Sketch-and-Extrude for Shape Parsing).

Real-world CAD models, however, are built sequentially over many steps, creating a massive representational gap between unordered spatial points and discrete, grammatical command sequences. To solve this, recent architectures treat CAD modeling as a language inference problem.

Finally, a true CAD model does not just consist of shapes; it embodies geometric intent through constraints like parallelism, perpendicularity, and tangency. Without these, modifying one part of a model causes the rest of the geometry to break. Karadeniz et al. addressed this final frontier with MiCADangelo (MiCADangelo: Fine-Grained Reconstruction of Constrained CAD Models from 3D Scans). By analyzing 2D cross-sections of a scan, the framework automatically infers these geometric constraints alongside the construction sequence.

By combining primitive fitting, topological graph supervision, and sequential language modeling, these frameworks successfully transform "dumb" physical scans into "smart," production-ready parametric models, fully integrating raw physical data into digital engineering workflows.

Key Foundational Work

Structured Indoor Modeling (2015) — contributed 1 concept elements to this direction.
Preface (2009) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_mesh_to_cad_conversion_68d50469,
  title = {mesh-to-CAD conversion},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/mesh-to-cad-conversion/rdr_68d50469361e444daea42c7a95f2fd3e},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_mesh_to_cad_conversion_68d50469_v1,
  title = {mesh-to-CAD conversion},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/mesh-to-cad-conversion/rdr_68d50469361e444daea42c7a95f2fd3e/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake