Compact Polygonal Reconstruction and Surface Simplification

105 concepts90 papers1 proposal

When algorithms or sensors reconstruct the 3D world, they typically produce an explosion of triangles. Standard isosurface extraction techniques, such as Marching Cubes, treat space as a uniform grid, evaluating continuous fields at discrete voxel corners and stitching together thousands of tiny, redundant faces to represent even the flattest surfaces.

This over-tessellation creates a massive mesh complexity overhead. Whether a model is destined for a real-time game engine, a mobile web browser, or a physical simulation solver, millions of redundant vertices inflate storage costs, bottleneck rendering pipelines, and stall computational mechanics.

To solve this, a major research direction focuses on compact polygonal reconstruction and structural simplification. Instead of treating 3D generation as a black-box density extraction problem, recent work embeds geometric and structural awareness directly into the reconstruction and decimation pipelines. The goal is simple: generate or reduce meshes into clean, "low-poly" representations that capture human design intent and sharp features using a fraction of the geometric primitives.


The Root of Redundancy: Isosurface Extraction vs. Structural Awareness

Why do standard 3D pipelines generate so much geometric waste? The issue lies in a lack of structural awareness. When a neural network or a depth scanner represents a shape implicitly (e.g., via signed distance fields), converting that continuous field into a discrete triangle mesh usually relies on black-box algorithms. These algorithms do not understand that a wall is flat or a corner is sharp; they merely evaluate local thresholds.

To bypass this limitation, researchers have proposed architectures that build shapes out of global geometric primitives from the ground up. In BSP-Net: Generating Compact Meshes via Binary Space Partitioning, Zhiqin Chen et al. design a neural network that learns to carve out 3D space using a set of implicit planes. By intersecting these half-spaces, the network outputs compact, watertight polygonal meshes directly. Because a large flat surface is represented by a single plane equation rather than thousands of micro-triangles, the resulting mesh is inherently optimized for standard graphics pipelines without requiring post-processing decimation.

Traditional Voxel/Marching Cubes:
[Dense Grid] ---> [Tiny Triangles Tiling Flat Surface] ---> High Overhead

Space Partitioning (BSP-Net):
[Learned Planes] ---> [Direct Half-Space Intersection] ---> Clean Low-Poly

This philosophy of leveraging structural regularity is particularly powerful in man-made environments. For instance, Yang Liu demonstrates in GSPlane: Concise and Accurate Planar Reconstruction via Structured Representation that replacing dense, irregular triangle clouds with structured regular grids derived from learned plane equations can reduce vertex counts by nearly half. Similarly, for raw point clouds, Raphael Sulzer introduces a highly scalable method in Concise Plane Arrangements for Low-Poly Surface and Volume Modelling that processes tens of thousands of planes by merging coplanar facets based on a volume threshold, balancing geometric fidelity with element counts.


Rethinking Topology: Dual Grids and Learned Vocabularies

When smooth or organic shapes prevent the use of simple plane arrangements, how can we avoid over-tessellation? The answer lies in changing the underlying topological framework used for extraction or generation.

Neural Dual Contouring

While Marching Cubes places vertices strictly along the edges of a voxel grid, Dual Contouring analyzes the grid's cells, placing a single vertex inside each cell that exhibits an intersection. This structural shift allows the mesh to naturally conform to sharp features and corners.

In Neural Dual Contouring, Zhiqin Chen introduces a data-driven approach that trains networks to predict these vertex positions and edge crossings. By leveraging this dual-grid topology, the method generates up to 23 times fewer triangles than neural marching cubes while maintaining high feature fidelity.

Autoregressive Geometric Vocabularies

Another frontier bypasses implicit fields entirely, training autoregressive transformers to generate meshes face-by-face, mimicking the clean topology designed by human artists.

  • PolyGen: Charlie Nash shows in PolyGen: An Autoregressive Generative Model of 3D Meshes that predicting $n$-gons rather than triangles allows large planar surfaces to be represented by a single face, capturing design intent and lowering face counts.
  • MeshGPT: To scale this to complex assets, Yawar Siddiqui et al. propose MeshGPT: Generating Triangle Meshes with Decoder-Only Transformers. By training a transformer on a learned vocabulary of geometric "words" (quantized face embeddings), the model generates sharp, efficient structures directly, avoiding the messy over-tessellation characteristic of volumetric extraction.

Feature-Preserving and Intrinsic Simplification Metrics

When a high-resolution mesh already exists—whether from a dense multi-view stereo pipeline or an electron microscopy stack—we must simplify it. Traditional decimation algorithms rely heavily on the Quadric Error Metric (QEM), which minimizes the extrinsic 3D distance between the original and simplified surfaces. However, purely geometric distance metrics often fail to preserve the underlying properties needed for downstream tasks.

Intrinsic vs. Extrinsic Simplification

For physical simulations (like fluid dynamics or structural stress analysis), preserving how a surface looks is less important than preserving its intrinsic geometry—such as distances and angles measured along the surface itself.

To address this, Hsueh-Ti Derek Liu et al. introduce Surface Simplification using Intrinsic Error Metrics. They propose an "Intrinsic Curvature Error" (ICE) metric based on optimal transport. By decoupling the coarse mesh's visual appearance from its underlying geometric properties, their method allows for extreme reductions in triangle counts while guaranteeing that the mesh remains computationally valid for physics solvers.

Extrinsic Simplification (QEM):
Minimizes 3D spatial distance ---> Preserves visual silhouette

Intrinsic Simplification (ICE):
Minimizes surface distance/angles ---> Preserves physics/solver validity

Differentiable and Learned Decimation

Traditional edge-collapse algorithms are greedy, iterative, and non-differentiable, making them impossible to integrate into end-to-end deep learning frameworks.

Rolandos Alexandros Potamias addresses this bottleneck in Neural Mesh Simplification by introducing a learnable, fully differentiable framework. Instead of slowly collapsing edges one by one, a modular neural network predicts vertex removal in a single pass, achieving real-time performance up to 10x faster than standard methods while preserving geometric fidelity.


Why It Works: The Intuition of Structural Priors

The core insight unifying this research direction is that geometric redundancy is a symptom of a lack of priors. When an algorithm assumes every region of 3D space is equally complex, it wastes computational resources tiling flat floors, uniform walls, and smooth curves with thousands of identical triangles.

By forcing pipelines to reason about shapes through structured lenses—whether via learned plane equations (BSP-Net), dual-grid topologies (Neural Dual Contouring), learned geometric vocabularies (MeshGPT), or intrinsic metrics (Surface Simplification using Intrinsic Error Metrics)—the complexity is compressed at the source. The algorithms exploit the underlying regularity of the data, ensuring that every vertex and face in the final mesh serves a distinct geometric or functional purpose.

Key Foundational Work

A unified approach for simplifying polygonal and spline models (1998) — contributed 2 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_complexity_overhead_7bfd69ed,
  title = {mesh complexity overhead},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/mesh-complexity-overhead/rdr_7bfd69edfc054882af33da1d0beb248f},
  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_complexity_overhead_7bfd69ed_v1,
  title = {mesh complexity overhead},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/mesh-complexity-overhead/rdr_7bfd69edfc054882af33da1d0beb248f/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