Advancing Front Mapping

TL;DR

Advancing Front Mapping (AFM) introduces a constructive, provably injective method for surface-to-domain mappings by advancing two fronts from the boundaries of a disk-like input mesh $M_1$ into a fixed convex or star-shaped domain $\Omega$. It relies on two simple topological moves, triangle splits and edge flips, together with local refinements to ensure validity and injectivity without solving a numerical optimization problem. AFM enlarges the class of reachable target domains to include star-shaped polygons and uses selective refinement to open the solution space when a fixed-connectivity mapping would be impossible, all while maintaining a constructive, easily debuggable pipeline. The authors provide extensive large-scale validation (over $10^9$ advancing moves across 36K tasks) and comparisons with Tutte and Progressive Embedding, showing strong robustness and practical viability despite higher runtimes relative to the baselines. The work lays groundwork for extensions to parallelization, warm starts, indirect predicates, and even volume mappings, positioning AFM as a reliable initial-map tool for downstream geometry processing.

Abstract

We present Advancing Front Mapping (AFM), a provably robust algorithm for the computation of surface mappings to simple base domains. Given an input mesh and a convex or star-shaped target domain, AFM installs a (possibly refined) version of the input connectivity into the target shape, generating a piece-wise linear mapping between them. The algorithm is inspired by the advancing front meshing paradigm, which is revisited to operate on two embeddings at once, thus becoming a tool for compatible mesh generation. AFM extends the capabilities of existing robust approaches, such as Tutte or Progressive Embedding, by providing the same theoretical guarantees of injectivity and at the same time introducing two key advantages: support for a broader set of target domains (star-shaped polygons) and local mesh refinement, which is used to automatically open the space of solutions in case a valid mapping to the target domain does not exist. AFM relies solely on two topological operators (split and flip), and on the computation of segment intersections, thus permitting to compute provably injective mappings without solving any numerical problem. This makes the algorithm predictable, easy to implement, debug and deploy. We validated the capabilities of AFM extensively, executing more than one billion advancing front moves on 36K mapping tasks, proving that our theoretical guarantees nicely transition to a robust and practical implementation.

Figures (12)

• Figure 1: Top: two identical stars up to a shift of the boundary vertices cannot be mapped to one another without introducing additional vertices, because the convexities of the left one map to the concavities of the right one. Bottom: by automatically refining the input mesh our method successfully opens the space of solutions, producing an injective map. Note: due to the presence of tiny triangles in the original output, the inner nodes in the bottom right star have been slightly relocated to make the figure easier to parse.
• Figure 2: Pipeline of AFM: we start from a source triangle mesh and a target convex or star-shaped domain (left). In the initialization step (second column) boundary edges are marked as front (thick blue lines) and a starting embedding is created by forming a triangle between each front edge and the front origin ($O$), selected as an inner mesh vertex. Due to convexity, all triangles share a globally coherent orientation. Then, AFM iteratively reproduces the connectivity of the source mesh in the target domain, advancing both fronts while maintaining a one-to-one correspondence between them. Source triangles having only one edge on the front ($t_0$ and $t_1$) are inserted by splitting the triangle formed by the image of such edge and $O$ (iterations #1 and #2). Source triangles having two edges on the front ($t_2$) are inserted by flipping the edge connecting $O$ with the front vertex shared by the images of such edges (iteration #3). The algorithm stops when all source triangles have been inserted in the target domain, yielding a one-to-one mapping $\Phi$ between the two meshes.
• Figure 3: Advancing the front to reproduce a triangle $t$ having a single front edge $e$ amounts to: (i) locating the triangle formed by the image of $e$, $\Phi(e)$, and the front origin $O$; (ii) splitting it into three sub-triangles. The triangle formed by the split point and by $\Phi(e)$ is $\Phi(t)$.
• Figure 4: Advancing the front to reproduce a triangle $t$ having two front edges meeting at a shared vertex $v$ amounts to: (i) locating the edge $e$ connecting the image of $v$, $\Phi(v)$, with the front origin $O$; (ii) flipping $e$. This operation can be performed only if the quad surrounding $e$ (i.e., its link) is strictly convex.
• Figure 5: Naively applying triangle splits and edge flips to advance the front does not always lead to convergence. In the typical case, the front conquers all the mesh vertices, leaving a network of triangle strips (closeup) that cannot be inserted in the target domain because their associated edge flip operations are concave, hence they would introduce flipped elements. The local strategies described in \ref{['sec:corner_cases']} ensure that any edge flip can be performed without breaking the injectivity of the map, thus always ensuring both validity and convergence.