/mesh-processing

title: Mesh Processing
description: Mesh data structures, mesh operations, mesh analysis, mesh repair, UV mapping and unfolding, quad meshing, mesh-to-NURBS conversion, and mesh quality assessment for AEC computational design
version: 1.0.0
tags: [mesh, subdivision, remeshing, repair, UV-mapping, unfolding, quad-mesh, mesh-analysis, half-edge, topology]
auto_activate: true
user_invocable: true
invocation: /mesh-processing

Mesh Processing

This skill provides comprehensive guidance on mesh processing for architecture, engineering, and construction. Meshes are the workhorse representation for simulation (FEA, CFD, acoustics), fabrication (3D printing, CNC), visualization (rendering, VR/AR), and increasingly for design geometry itself. This reference covers data structures, operations, analysis, repair, UV mapping, quad meshing, and reverse engineering.

---

1. Mesh Processing in AEC

1.1 Why Meshes Matter

Meshes represent 3D geometry as collections of vertices, edges, and faces. In AEC:

• **Simulation**: Finite Element Analysis (structural), Computational Fluid Dynamics (wind/airflow), thermal simulation, acoustic simulation, and daylight simulation all require mesh discretization of geometry. The mesh quality directly determines simulation accuracy.
• **Visualization**: Real-time rendering (game engines, VR/AR) operates on triangulated meshes. Level-of-detail mesh decimation controls rendering performance.
• **Fabrication**: 3D printing requires watertight triangulated meshes (STL/3MF). CNC milling requires surface meshes for toolpath generation. Robotic fabrication uses mesh representations for collision checking and path planning.
• **Scanning**: LiDAR, photogrammetry, and structured light scanning produce point clouds that are reconstructed into meshes. Scan-to-BIM workflows begin with mesh processing.
• **Design**: Freeform architectural surfaces (shells, facades, roofs) are often designed as meshes, particularly when the target is a panelized or discrete structure.

1.2 Mesh vs. NURBS Trade-offs

| Dimension | Mesh | NURBS | |---|---|---| | Representation | Discrete vertices + faces | Continuous parametric surface | | Precision | Approximate (chord tolerance) | Mathematically exact | | Topology | Arbitrary (any connectivity) | Rectangular patch structure | | Boolean operations | Robust (with good libraries) | Fragile (trimmed surface issues) | | Simulation compatibility | Direct (FEA/CFD mesh = geometry mesh) | Requires meshing step | | File size (complex forms) | Smaller (for tessellated freeform) | Larger (many control points) | | Editing | Vertex-level sculpting, subdivision | Control point manipulation, continuity | | Rendering | Direct (GPU operates on triangles) | Requires tessellation | | Fabrication (3D print) | Direct (STL is triangulated mesh) | Requires tessellation | | Industry standard | Visualization, gaming, scanning | CAD, BIM, manufacturing |

**When to use meshes in AEC**:

• Freeform geometry that resists NURBS patch layout (organic shapes, scanned surfaces)
• Direct-to-simulation workflows (structural shells, CFD domains)
• Fabrication output (3D printing, panelization)
• Processing scan data (point cloud to mesh to BIM)
• Real-time visualization and VR/AR content

**When to use NURBS**:

• Precise geometric control with continuity constraints (G0/G1/G2)
• Standard architectural elements (planar walls, cylindrical columns, ruled surfaces)
• BIM integration (Revit, ArchiCAD expect NURBS/solid geometry)
• Manufacturing with CNC that expects parametric surfaces

1.3 The Mesh Processing Pipeline

[Input Geometry]
    |
    v
[Mesh Generation] -- from NURBS, from point cloud, from implicit, from scratch
    |
    v
[Mesh Repair] -- fix non-manifold, fill holes, remove degenerates, orient normals
    |
    v
[Mesh Operations] -- subdivide, remesh, decimate, smooth, boolean, offset
    |
    v
[Mesh Analysis] -- curvature, thickness, quality metrics, topology check
    |
    v
[Mesh Optimization] -- improve quality for target application (FEA, printing, rendering)
    |
    v
[Output]
    |-- Simulation mesh (FEA/CFD solver format)
    |-- Fabrication mesh (STL/3MF for 3D printing, unfolded for sheet fabrication)
    |-- Visualization mesh (glTF/FBX for rendering, LOD variants)
    |-- Reverse-engineered NURBS (mesh-to-NURBS conversion for CAD)

---

2. Mesh Data Structures

2.1 Vertex-Face List (Simple Mesh)

The simplest representation. Two arrays:

• **Vertices**: List of 3D coordinates. V = [(x0,y0,z0), (x1,y1,z1), ..., (xn,yn,zn)]
• **Faces**: List of vertex index tuples. F = [(v0,v1,v2), (v0,v2,v3), ...] for triangles, or [(v0,v1,v2,v3), ...] for quads.

**Memory**: 3 floats per vertex (12 bytes as float32, 24 bytes as float64) + 3 or 4 ints per face (12 or 16 bytes as int32).

**Advantages**: Simple, compact, easy to serialize (STL, OBJ, PLY formats use this structure). Direct GPU upload.

**Limitations**: No explicit edge representation. Adjacency queries are O(F) where F = number of faces. Finding neighboring faces of a face requires scanning all faces. Finding all faces incident on a vertex requires scanning all faces.

**Use**: File I/O, GPU rendering, simple geometry storage. Not suitable for topological operations.

2.2 Half-Edge Data Structure

The standard data structure for mesh processing algorithms. Each undirected edge is represented as two directed half-edges pointing in opposite directions.

**Components**:

• **Vertex**: Stores position (x,y,z) and pointer to one outgoing half-edge.
• **Face**: Stores pointer to one bounding half-edge.
• **Half-edge**: Stores pointers to:
• `next`: Next half-edge around the same face (counter-clockwise).
• `prev`: Previous half-edge around the same face (or computed from next).
• `twin` (or `opposite`): The half-edge on the adjacent face sharing the same edge but pointing in the opposite direction.
• `vertex`: The vertex this half-edge points to (its target vertex)