Scalable DDPM-Polycube: An Extended Diffusion-Based Method for Hexahedral Mesh and Volumetric Spline Construction

This paper presents Scalable DDPM-Polycube, an enhanced diffusion-based method that improves the automation and robustness of polycube construction for complex CAD geometries by introducing a new blind-hole primitive, expanding to a 3D grid configuration, and implementing a hierarchical genus-guided verification strategy for all-hexahedral mesh and volumetric spline generation.

The Gist

Imagine you have a complex, irregularly shaped piece of clay (a 3D object from a computer design). You want to turn this clay into a perfect, structured grid of tiny cubes (like a 3D Lego structure) so a computer can run a physics simulation on it. This is the goal of Isogeometric Analysis (IGA).

The problem is that turning a weird, organic shape into a neat grid of cubes is incredibly hard. If you force it, the cubes get squashed, stretched, or broken, and the simulation fails.

This paper introduces Scalable DDPM-Polycube, a new "smart assistant" that uses Artificial Intelligence to solve this puzzle. Here is how it works, explained with everyday analogies:

1. The Old Way vs. The New Way

• The Old Way (Templates): Imagine trying to fit a weird-shaped rock into a box. The old AI only had two types of boxes: a plain cube and a cube with a hole going all the way through. If your rock had a "blind hole" (a hole that starts at the surface but stops inside, like a pocket in a shirt), the AI got confused. It couldn't tell the difference between a pocket and a through-hole, so it made a bad guess.
• The New Way (The "Blind-Hole" Tool): This new AI learned a third type of box: a Blind-Hole Cube. Now, it can perfectly match rocks with pockets, through-holes, or plain surfaces. It's like giving the builder a specialized tool for every specific shape they might encounter.

2. The "Diffusion" Magic (The Sculptor)

How does the AI actually build the grid? It uses a process called Denoising Diffusion.

• The Analogy: Imagine you have a perfect, neat Lego castle (the target grid). Now, imagine someone smashes it, shakes it, and covers it in mud until it looks like a messy blob of clay (your input object).
• The AI's Job: The AI is a master sculptor who has seen thousands of these "smashed" blobs. It knows exactly how to chip away the mud and reshape the clay back into the neat Lego castle. It doesn't just guess; it slowly peels away the "noise" (the messy deformations) step-by-step until the perfect grid structure emerges.

3. The "Map" Problem (The Grid)

In the old system, the AI tried to fit complex shapes onto a very small, 1D map (like a single strip of paper). If the shape was complex, the map got stretched and distorted, ruining the result.

• The Upgrade: This new system uses a 3D Grid (like a full Rubik's cube with 12 slots). This gives the AI much more room to maneuver. It can arrange the "blocks" in three dimensions, reducing the stretching and making the final grid much more accurate for complex shapes.

4. The "Detective" Strategy (Scalability)

Here is the biggest challenge: If you give the AI too many choices (many types of blocks and a big grid), it gets overwhelmed. It would take forever to try every possible combination to find the right one.

• The Solution: The authors created a "Genus-Guided Detective" system.
  • Step 1 (The Clue): The AI first looks at the "topology" of the object (basically, how many holes it has). This is a big clue.
  • Step 2 (Local Investigation): Instead of trying to solve the whole puzzle at once, the AI breaks the object into small pieces. It solves the puzzle for each small piece individually, using the "hole count" as a rule to narrow down the options.
  • Step 3 (The Double-Check): Once it assembles the local pieces into a full solution, it runs a strict Verification Test.
    • Check 1 (The Occupancy Check): "Did you actually put a block in the slot you said you would?"
    • Check 2 (The Template Match): "Does the shape of the block in that slot actually look like the specific type of block you claimed it was?"
  • If it fails a check, it discards that idea immediately and tries the next one. This saves massive amounts of time.

5. The Result

Once the AI successfully builds this "Polycube" (the neat grid of blocks), the rest is easy. The computer can now:

1. Map the original weird shape onto this neat grid.
2. Create a high-quality mesh of hexagonal cubes.
3. Turn that mesh into smooth mathematical curves (splines).
4. Run accurate physics simulations (like crash tests or heat flow) on the object.

Summary

Think of Scalable DDPM-Polycube as a super-smart, automated architect.

• It has a bigger toolbox (new primitive shapes).
• It works on a larger blueprint (3D grid).
• It uses a smart strategy (breaking the problem down and double-checking its work) so it doesn't get stuck trying to solve impossible puzzles.

This allows engineers to take complex, real-world designs and automatically turn them into simulation-ready models without needing a human to manually fix every single error.

Technical Summary

1. Problem Statement

The paper addresses the challenge of automating Isogeometric Analysis (IGA) pipelines, specifically the conversion of complex CAD boundary representation (B-Rep) surface models into analysis-suitable all-hexahedral (all-hex) control meshes and volumetric splines.

While previous learning-based methods (like DL-Polycube and the original DDPM-Polycube) improved automation, they faced three critical limitations when handling complex geometries:

1. Restricted Primitive Set: Previous models only supported "Cube" (genus-0) and "Through-Hole Cube" (THC, genus-1). They failed to accurately represent blind-hole features (local holes that do not change global genus), leading to ambiguous inference.
2. Limited Grid Configuration: The original method used a 1D $G_{2\times1}$ grid (effectively 2 cells). This forced complex geometries into a low-dimensional space, causing high mapping distortion and poor mesh quality.
3. Scalability of Inference: As the primitive set and grid size grow, the number of valid context candidates (topology-consistent arrangements) explodes. The previous strategy of traversing all candidates becomes computationally prohibitive.

2. Methodology: Scalable DDPM-Polycube (SDDPM)

The authors propose SDDPM, an extended Denoising Diffusion Probabilistic Model (DDPM) framework that generates topology-consistent polycube structures. The pipeline consists of the following key components:

A. Expanded Primitive Set and Grid Configuration

• New Primitive: Introduced the Blind-Hole Cube (BHC) primitive. Along with the existing Cube and THC, and their axis-oriented variants (e.g., THC+Z, BHC+X), the primitive set $\mathcal{K}$ now contains 10 categories. This allows the model to distinguish between global genus changes (THC) and local hole-like features (BHC) without altering the global genus.
• 3D Grid: Extended the grid from $G_{2\times1}$ (1D, 2 cells) to $G_{3\times2\times2}$ (3D, 12 cells). This increases representational capacity, allowing for more complex assemblies and reducing geometric distortion during parametric mapping.

B. Data Representation and Feature Extraction

• Input: The input triangular mesh is normalized and converted into a point cloud.
• Tensor Reshaping: The point cloud is reshaped into a fixed $64 \times 96 \times 3$ tensor (representing 12 cells of $16 \times 32$ points each, with 3 channels for $X, Y, Z$ coordinates). This "image-like" format allows the use of a U-Net architecture.
• Context Encoding: A 132-dimensional one-hot vector ($12 \text{ cells} \times 11 \text{ states}$) encodes the target assembly (primitive type or null state) for each grid cell.

C. Genus-Guided Context Generation

To solve the scalability issue of candidate traversal, the authors introduce a hierarchical inference strategy supporting two modes:

1. User-Guided Mode: Users provide partial constraints (e.g., counts of primitives) or full context vectors.
2. Automated Mode:
   • The input geometry is temporarily tetrahedralized and partitioned into subregions.
   • Local Inference: For each subregion, the genus is computed to restrict feasible primitive categories. A local reverse diffusion process generates a candidate label for that subregion.
   • Global Assembly: Verified local labels are assembled into a global 132-dimensional context vector.
   • This approach avoids traversing the full global candidate space ($11^{12}$) by constructing the context from verified local inferences.

D. Hierarchical Verification Module

To ensure the generated polycube is valid, a two-stage verification process is applied before accepting a result:

1. Grid Occupancy Consistency Check (GOCC): A coarse filter that verifies if the generated point distribution matches the context's occupancy labels (e.g., checking point counts and spatial extent for active vs. null cells).
2. Template Competition Verification (TCV): A fine-grained check using Penalty Chamfer Distance (PCD). It verifies that the geometry in each active cell matches the intended primitive category and orientation by ensuring the target template is the nearest neighbor among all competitors.

3. Key Contributions

1. Primitive Expansion: The introduction of the Blind-Hole Cube (BHC) primitive resolves the ambiguity of representing local hole-like features that do not affect global genus, significantly improving geometric fidelity.
2. 3D Grid Extension: Moving to a $G_{3\times2\times2}$ (12-cell) grid configuration enhances the model's ability to handle complex engineering geometries with reduced mapping distortion compared to the previous 1D setting.
3. Scalable Inference Strategy: The development of a genus-guided context generation algorithm combined with hierarchical verification (GOCC + TCV) enables automated inference on complex grids without exhaustive candidate traversal, making the method practical for higher-genus models.
4. End-to-End IGA Pipeline: The method successfully bridges the gap from CAD surfaces to TH-spline3D volumetric splines suitable for IGA, including all-hex mesh generation and quality optimization.

4. Experimental Results

• Training: The model was trained on a dataset of 120 single-cell, 4,083 multi-cell, and full-grid assemblies. Training converged stably over 500 epochs.
• Inference Performance:
  • User-Guided: Efficiently generates valid structures when constraints are provided.
  • Automated: Successfully generates polycubes for models with varying genus (0 to 3+). For complex models (7+ occupied cells), the method reduced the effective search space significantly, identifying valid solutions in ~900 seconds on average.
  • Ablation Study: Removing the BHC primitive resulted in a 9x increase in average Chamfer distance (0.2785 vs. 0.0292) for blind-hole features, proving the necessity of the new primitive.
• Mesh Quality: The generated polycubes were used to create all-hex control meshes. After optimization (smoothing, pillowing, Jacobian optimization), the meshes exhibited high quality (minimum scaled Jacobian > 0.01 for most cases, up to 0.66), with few inverted elements.
• Generalization: The model successfully generated polycubes for geometries not present in the training set, demonstrating strong generalization capabilities based on learned deformation priors.

5. Significance

This paper represents a significant step forward in automating CAD-to-IGA workflows. By overcoming the limitations of primitive diversity and grid dimensionality, SDDPM enables the generation of high-quality all-hex meshes for complex industrial geometries that were previously difficult to automate. The integration of diffusion models with topological constraints and hierarchical verification offers a robust framework that balances automation with geometric accuracy, paving the way for more reliable isogeometric analysis in engineering applications.

Limitations & Future Work:

• The method still relies on a fixed grid ($G_{3\times2\times2}$); future work aims for adaptive/hierarchical grids.
• Automated context generation depends on temporary tetrahedralization quality.
• Inference is currently slower than direct prediction methods due to iterative diffusion; integrating verification constraints directly into the diffusion process is a potential optimization.