Declarative Specification for Unstructured Mesh Editing Algorithms

Mesh Abstraction Erased

We expose simplex tuples (vertex, edge, face, volume) – not half-edges. User code never sees pointers. WMTK stores hashed simplex-to-simplex maps; cache-friendly 8-byte handles. No more splicing hell.

OpDescriptor

struct OpDescriptor {
  std::function<double(Simplex)> energy;
  std::function<bool(Simplex)> can_apply;
  std::function<void(Simplex, AttributeTransfer&)> execute;
  std::vector<Invariant> invariants_before, invariants_after;
};

We pre-instantiate 6 topology ops: EdgeCollapse, EdgeSplit, EdgeSwap, VertexSmooth, FaceSplit, TetSplit. User provides lambda for can_apply and attribute lerp.

• pos, uv, color, mip-map level are wmtk::Attribute<T> – split/collapse requires linear/harmonic extension, auto-generated.
• Physics-aware length metric synthesizes Jacobian via Eigen::AutoDiff – never hand-derivate again.

Invariants as Composable Functors

struct Invariant {
  virtual bool before(const Simplex&) const = 0;
  virtual bool after(const Simplex&) const { return true; }
  virtual bool strictly_after(const Primitive&) const;
};

Library ships:

• ManifoldInvariant – link condition via Euler char of link
• NoInversionInvariant – signed tet/area >0 filtered by exact predicates (orient2d/3d via Shewchuk)
• EnvelopeInvariant – AABB tree of input surface, ε-envelope test
• UVNoFoldInvariant – flip-free UV under operation
• QualityInvariantBound – AMIPS < threshold, scaled Jacobian

auto safe = make_invariant_collection(
  ManifoldEdge(), NoInversionTet(), EnvelopeSurface{input, 1e-6}
);

• Scheduler = Active Set Learning. Two-level priority: geometric energy first, reuse score second for cache locality. update_after_success(op) only re-queues 1-ring (<2% visited/iter).
• Partitioned locking. Vertices painted by greedy distance-1 coloring of dual graph; each color processes in parallel, no two neighboring ops co-run.
• Speculative rollback. If invariant fails after op, mesh rewound via copy-on-write log (~12 bytes per simplex change).
• Determinism. Sorted tie-break by simplex id; same seed → bitwise-identical mesh on same thread count.
• Envelope safety. TetWild path wraps input surface AABB tree and tests moved vertices against ε-envelope using exact orient predicates.

Code Walkthrough – Isotropic Remeshing (30 lines)

#include <wmtk/TriMesh.h>
using namespace wmtk;

int main(int argc, char** argv) {
  TriMesh mesh(argv[1]);
  double target = std::stod(argv[2]);

  auto long_edges = [&](Edge e){ return e.length() > 4*target/3; };
  auto short_edges = [&](Edge e){ return e.length() < 4*target/5; };

  auto invs = std::make_shared<InvariantCollection>(mesh);
  invs->add(std::make_shared<ManifoldInvariant>(mesh));
  invs->add(std::make_shared<InversionInvariant>(mesh));

  Scheduler scheduler(mesh);
  scheduler.run_operation<EdgeSplit>(mesh, invs, long_edges, [](auto){return true;});
  scheduler.run_operation<EdgeCollapse>(mesh, invs, short_edges, [](auto e){return e.length();});

  auto quality_improve = [&](Edge e){
    double before = min_quality(one_ring(e));
    double after = min_quality_if_swapped(e);
    return after > before;
  };
  scheduler.run_operation<EdgeSwap>(mesh, invs, quality_improve, quality_improve);
  scheduler.run_operation<VertexSmooth>(mesh, invs, [](auto){return true;},
    [](Vertex v){ return laplacian_smooth(v); });

  mesh.save("out.obj");
}

Qslim – 14 lines variant

Attribute<Matrix4d> quadric = compute_quadric(mesh);
auto qslim_err = [&](Edge e){ return quadric[e.v0()] + quadric[e.v1()]; };
auto collapse = EdgeCollapseOp{ .pos = [&](Edge e){ return optimal_qslim_pos(e); } };
wmtk::run(mesh, {Manifold(), LinkCondition()}, EdgeQuadricScheduler{qslim_err}, collapse, /*stop*/ target_faces=5000);

This paper is the seed of Wild Meshing Toolkit (WMTK), now a community C++17 library with Python bindings pip install wildmeshing. The DSL ideas persist as wmtk::operations::Operation + wmtk::invariants.

• Surface repair – removing self-intersections for 3D printing
• Volume adaptivity – adaptive tetrahedral meshing with sizing field from SDF
• Non-manifold, open-boundary, mixed tri/tet – generality from simplex erasure

git clone https://github.com/wildmeshing/wildmeshing-toolkit
cd wildmeshing-toolkit; mkdir build && cd build
cmake .. -DWMTK_APP_ISOTROPIC_REMEShing=ON
make -j && ./wmtk_app -j isotropic_remeshing_bunny.json

import wildmeshing as wm
m = wm.TriMesh("bunny.obj")
wm.isotropic_remeshing(m, target_edge=0.02, envelope=1e-3)
m.save("out.obj")