Learning From Design Procedure To Generate CAD Programs for Data Augmentation

This paper proposes a novel data augmentation paradigm that leverages Large Language Models to generate diverse, industry-resembling CAD programs by conditioning them on reference surfaces and modeling procedures, thereby addressing the scarcity of complex, spline-based geometric data in existing training sets.

The Gist

Imagine you are trying to teach a robot how to design complex machine parts, like the brackets that hold up an engine or the spokes of a car wheel. You want the robot to learn from a massive library of blueprints (CAD programs) so it can eventually design its own.

The problem? The library you have is full of simple, blocky Lego bricks. It's missing the smooth, curvy, organic shapes that real engineers use in the real world. If you teach the robot only on Lego bricks, it will only ever build Lego structures. It won't know how to make a sleek, aerodynamic curve.

This paper proposes a clever new way to "fatten up" the robot's library so it can learn to build those complex, curvy shapes. Here is the breakdown using simple analogies:

1. The Problem: The "Lego Only" Diet

Current AI models that generate CAD code are like chefs who have only ever cooked with pre-cut, square vegetables. They are great at making cubes and cylinders, but they struggle to make a smooth, flowing curve (like a B-Spline, which is a fancy math curve used in real car and plane designs).

Why? Because the training data they have is too simple. Most open-source CAD datasets are like a box of basic shapes. They lack the "organic" complexity found in real industrial designs.

2. The Solution: The "Reference Surface" Trick

The authors looked at how human engineers actually work. They noticed that engineers rarely start from scratch. Instead, they often start with a guide.

• The Analogy: Imagine you are a potter. You don't just guess the shape of a vase. You might start with a specific, wavy clay mold (the Reference Surface) and then build your pot around or against that mold to make sure it fits perfectly.
• The Paper's Idea: Instead of just asking the AI, "Make a bracket," the researchers tell the AI: "Here is a specific, wavy, curvy surface (written as a computer script). Now, build a bracket that fits perfectly against this curve."

By forcing the AI to match a complex, pre-defined curve, the AI is forced to learn how to write code for those smooth, organic shapes. It can't just use a simple square block; it has to use the advanced math tools (B-Splines) to match the guide.

3. How It Works: The "Recipe"

The researchers created a new "recipe" for the AI:

1. The Guide: They give the AI a Python script that draws a wavy, organic surface (like a ripple in water or a saddle shape).
2. The Instruction: They tell the AI, "Build a bracket that hugs this wavy surface."
3. The Result: The AI writes a CAD program. Because it had to hug the wavy surface, the program is now full of complex curves, not just straight lines.
4. The Cleanup: Once the bracket is built, the "wavy guide" is removed, leaving behind a beautiful, complex bracket that looks like something a real engineer designed.

4. The Results: From "Blocky" to "Beautiful"

When they tested this method, the results were impressive:

• Old Way: The AI generated designs where 99% were simple blocks.
• New Way: The AI generated designs where 77% had complex curves and 89% had curved edges.

It's like going from a library of only square building blocks to a library full of smooth, sculpted clay. The new data looks much more like the real things you see in factories and car manufacturing.

5. Why This Matters

This isn't just about making pretty pictures. It's about training better robots.

• If we want AI to help design the next generation of cars, planes, or medical devices, it needs to understand curves, not just boxes.
• This method acts as a "data generator." It creates thousands of new, complex training examples automatically, filling the gap between simple computer models and real-world engineering.

The Catch (Limitations)

The paper admits this isn't magic.

• It's harder: Asking the AI to match a complex curve makes the code more complicated, which means the AI makes more mistakes and needs more "tries" to get it right.
• We need the guides: To do this, we first need to have those "wavy guide" scripts ready. If we don't have a script for the curve, we can't use it as a reference.

Summary

Think of this paper as teaching a child to draw.

• Before: You gave the child a coloring book with only squares and triangles. They learned to draw only squares and triangles.
• Now: You put a complex, wavy line on the paper and said, "Draw a house that fits inside this wavy line." Suddenly, the child has to learn how to draw curves, arches, and slopes to make it fit.

By forcing the AI to "fit" its creations to complex reference shapes, the researchers successfully taught it how to generate the complex, organic designs that the real world actually needs.

Technical Summary

Here is a detailed technical summary of the paper "Learning From Design Procedure To Generate CAD Programs for Data Augmentation."

1. Problem Statement

The paper addresses a critical bottleneck in training Large Language Models (LLMs) for Computer-Aided Design (CAD) generation: the lack of geometric complexity and diversity in existing training datasets.

• Current Limitations: Existing open-source CAD datasets (e.g., DeepCAD, GenCAD) are heavily skewed toward simple operations like "sketch-and-extrude." They lack the complex, organic shapes (e.g., free-form B-Splines, NURBS) common in real-world industrial designs.
• Consequences: Models trained on these datasets fail to generate industry-grade CAD models, which often require smooth, continuous surfaces for ergonomic, aesthetic, or structural reasons (e.g., stress distribution in automotive parts).
• Data Scarcity: Unlike software code (available on GitHub), CAD data is often proprietary, siloed across different tools, and lacks a natural, growing ecosystem for data augmentation.

2. Methodology

The authors propose a novel data augmentation paradigm inspired by industrial design workflows. Instead of relying on image prompts or simple text descriptions, they introduce a Design Procedure Prompting strategy that conditions LLMs using two specific inputs:

A. Reference Surface Program

Instead of using images or point clouds, the method uses a Python script (specifically using the CadQuery library) to define a reference surface.

• Why Scripts? LLMs are already highly proficient in Python code generation. Using a script provides an accurate, parametric, and expressive definition of 3D geometry (specifically B-Spline surfaces) that avoids the cross-modality correlation errors common when prompting LLMs with visual data.
• Variety: The authors generate diverse reference surfaces (Gaussian, saddle, wave, ripple) by varying parameters in the Python scripts.

B. Design Procedure Prompting

The LLM is prompted with a structured text template containing:

1. Design Description: A natural language description of the target object (e.g., "a rectangular bracket with two holes").
2. Design Context: Instructions to match the curvature of the provided reference surface and to remove the surface after the object is created.
3. System Prompts: Constraints ensuring the output is a watertight solid and specifying the output format (STEP file).

C. Validation Loop

The generated CAD programs undergo a two-stage agentic validation:

1. Program Validation: Checks if the code executes and converts to a Boundary Representation (B-rep) STEP file.
2. Structure Validation: Verifies if the resulting B-rep is watertight and structurally feasible (using checks from DTGBrepGen).

• Self-Correction: If validation fails, the error message is fed back to the LLM for iterative correction.

3. Key Contributions

1. Novel Prompting Paradigm: The paper introduces a method to guide LLMs using reference surface programs rather than just text or images. This bridges the gap between human design intent (matching a surface) and machine generation.
2. Synthesis of Organic Geometry: The method successfully forces the generation of B-Spline faces and curves, which are typically absent in existing open-source datasets.
3. Modularized Design Procedure: The approach mimics industrial workflows where a base surface dictates the geometry of attached parts, allowing for the synthesis of complex, interconnected primitives.
4. Open Data Augmentation: It provides a scalable framework to generate high-quality, diverse CAD training data without relying on proprietary industrial datasets.

4. Experimental Results

The authors evaluated their method against baselines (DeepCAD-b, GenCAD, CAD-MLLM) and a commercial industry dataset ("Industry").

• Geometric Complexity:

  • B-Spline Ratio: The proposed method achieved a B-Spline Ratio of 0.2217, significantly outperforming baselines (which were near 0.0004–0.0009).
  • B-Spline Presence: 77% of generated objects contained B-Spline faces and 89% contained B-Spline curves. In contrast, baselines had 0% B-Spline faces and ~1% B-Spline curves.
  • Complexity Metrics: The generated STEP files had higher average line counts (4,494 vs. ~1,000–2,400 in baselines) and more faces/curves, indicating greater structural complexity.

• Distribution Diversity:

  • Unlike baselines which clustered heavily at 0% B-Spline ratio, the proposed method produced a more even distribution across B-Spline ratios, covering a wider range of shape complexity similar to the "Industry" dataset.

• Ablation Study:

  • Removing the reference surface prompt (relying only on text guidance like "make it smooth") resulted in a drastic drop in B-Spline generation (Ratio dropped from 0.22 to 0.04).
  • This confirms that the scripted reference surface is the critical factor driving the generation of organic shapes, not just natural language descriptions.

• Generalizability:

  • The method was successfully extended to generate car wheels with different spoke patterns (double-spoke, Y-spoke), demonstrating applicability beyond simple brackets.

5. Significance and Impact

• Bridging the Industry Gap: The work demonstrates that machine-generated CAD can closely resemble industrial-grade designs in terms of geometric complexity, specifically by introducing B-Spline geometries.
• Training Data Solution: It offers a sustainable, automated solution to the scarcity of high-quality CAD training data, enabling the fine-tuning of LLMs for more advanced engineering tasks.
• Paradigm Shift: It moves the field away from simple "text-to-shape" generation toward "procedure-to-shape" generation, leveraging the LLM's coding capabilities to interpret parametric constraints.

6. Limitations

• Validation Overhead: The complex procedures lead to more execution errors, requiring more iterative generations (21% of samples required >5 iterations) compared to simpler baselines.
• Reference Surface Dependency: The method requires pre-existing Python scripts for reference surfaces. While these can be synthesized, obtaining precise reference surfaces for specific custom parts currently requires manual logging or reverse engineering.
• Precision Control: The system cannot yet precisely control where on the reference surface the new object attaches (e.g., base vs. feet) without further human intervention or specialized fine-tuning.