About Zhongshi

Example Talk

Sat, 01 Jun 2030 13:00:00 +0000

Click on the Slides button above to view the built-in slides feature.

Slides can be added in a few ways:

Create slides using Wowchemy’s Slides feature and link using slides parameter in the front matter of the talk file
Upload an existing slide deck to static/ and link using url_slides parameter in the front matter of the talk file
Embed your slides (e.g. Google Slides) or presentation video on this page using shortcodes.

Further event details, including page elements such as image galleries, can be added to the body of this page.

HyperBones: Realtime Bone-driven Neural Garment Simulation with Hypernetwork Conditioning

Mon, 18 May 2026 00:00:00 -0400

Large-scale Codec Avatars: The Unreasonable Effectiveness of Large-scale Avatar Pretraining

Thu, 02 Apr 2026 00:00:00 -0400

PhySkin: Physics-based Bone-driven Neural Garment Simulation

Sun, 15 Mar 2026 00:00:00 -0400

MHR: Momentum Human Rig

Sat, 15 Nov 2025 00:00:00 -0500

FRESA: Feedforward Reconstruction of Personalized Skinned Avatars from Few Images

Sat, 15 Mar 2025 00:00:00 -0400

FaceMap: Distortion-Driven Perceptual Facial Saliency Maps

Fri, 15 Nov 2024 00:00:00 -0500

FaceMap: Distortion-Driven Perceptual Facial Saliency Maps

Zhongshi Jiang^*, Kishore Venkateshan, Giljoo Nam, Meixu Chen, Romain Bachy, Jean-Charles Bazin, Alexandre Chapiro

^*Meta Reality Labs – first author, ¹Reality Labs Research, Sausalito CA & Redmond WA

* Equal contribution shuffling? This work: first author. SIGGRAPH Asia 2024 Conference Paper #39 (TOG 9:4)

Paper Author PDF Suppl (13MB) Video Code (pending) CC BY-NC-ND 4.0 Dataset (on-request)

Wide hero 1600×900 (16:9) – single female head left + distortion heatmap right. Front-page thumb remains featured.jpg 800×900 single-subject.

FaceMap learns where humans notice distortion and reallocates polys / texels / splats there – SROCC 0.82.

Rotating face compare – FaceMap vs uniform (5s loop)

Front → +45° → Front @65K Gaussians – suppl Fig. 14-15 – wide hero keeps thumb clean

Featured thumb preserved: featured.jpg 800×900 portrait single female head – Wowchemy list & front page single-subject.

16:9 wide 1600×900 ~406KB hero – no stretching of portrait thumb (featured.jpg kept separate).

Abstract

First distortion-driven perceptual metric for faces. Generic mesh saliency measures curvature, not tolerance. When a head is compressed to 5% triangles, 1K Gaussians, or 32² texture, where does quality collapse? We capture human preferences via large-scale 2AFC Thurstonian scaling on 10 identities × 5 degradations × 3 views, decoupled into 64×64 overlapping patches (~48K pairs). ANOVA shows allocation method dominates identity (p=7.1e-65 remesh, 1.5e-21 GS) – face perception generalises. We fit a UV-space UNet (512² in → 256² saliency) anchored on 8 semantic UV points, randomised validation r=0.83 RMSE 0.242 JOD vs SD 0.209. Result: SROCC 0.82 / PLCC 0.79 vs Song'14 0.306/0.234, Nehmé'23 0.19/0.23 (weak per Schober). Eyes > wrinkles > mouth > nostrils > silhouette > cheeks cold, but identity-modulates. At 1% tris we beat uniform 98.6% pref, 91.8% at 4%, 75.4% at 16% → mobile sweet-spot. GS 1K: uniform blurs pupils, ours crisp. Texture quadtree saves ~40% leaves.

Faces have a dedicated fusiform area – uniform LOD destroys eyes leaving teeth intact. FaceMap asks "where does distortion become noticeable?" not "where is interesting". Industrial LODs for codec avatars need 5% geo / 128² textures – FaceMap provides the multiplier.

Taxonomy – 10 Bases × 5 Distortions

10 high-quality scanned heads (5 female /5 male, balanced ethnicity/age, ~30K tris face-only, 4K×4K albedo, 200K Gaussians ref) – adapted from Meta Realistic Head collection.

Family	Type	Levels	Mechanism & Prod. analogue
Geometry	Mesh quantization	6 (30%→5% edge keep)	Quadric error + uniform; simulates runtime LOD / Draco quant
Geometry	Laplacian smoothing	6 λ=0.05→0.5	Simulates low-LOD blur / skinning linear artifacts
Texture	JPEG / Basis compressed	6 QF 5→90	Texel blockiness – streaming compression
Texture	Low-res mip	256→32 downsample	Blurriness – texture streaming LOD
Splats	Gaussian sparsity	5 262K→1K	3DGS decimation – mobile splat budget

Suppl Fig.14 – 10 bases × distortion levels wide hero composition (1600×900) – left head, right patches allocation eyes>wrinkles>mouth>cheeks. Single-subject featured.jpg remains 800×900.

Psychophysics – Distort → Render → Patch → 2AFC → JOD

Stimuli & Patching

3 views front 0°, left 45°, right 45° – studio HDRI + rim, 65cm 30° FoV 120 nits sRGB 2.2 D65 calibrated.
Overlapping 64×64 patches stride 32 – ~180 per view ~540 per condition – decouples head size & background.
Participants see patches only vs reference patch, never full head during forced choice.

2AFC Thurstone

Which patch better vs reference? 200ms ISI, unlimited time, anchored slider "bad–excellent" per Madhusudana'21:

Main: 10×5×6×3 = 900 base trials per participant via adaptive QUEST 100 subset.
Remesh valid.: 4×6×3×3+12 = 228 trials avg 40 min.
GS valid.: 10×5×2×2 = 100 trials avg 34 min (Fig.12/14).
N=45+ main 18–42y normal/corrected, 2 outliers >3 MAD removed, gamma-corrected display 2560×1440 65ppd.

JOD: 1 JOD = 75% pref in 2AFC = 0.675σ logistic – Fig.13 Thumb.

Pipeline: distort mesh/tex/splats → 3-view render → patchify → crowd 2AFC → JOD → N-way ANOVA → UNet saliency. 842×814 original upscaled to 1200×1160 with 5% white padding to match hero width – no crop, readable labels.

N-way ANOVA – what matters?

distortion strength	p=1.8e-11	Main dominant
distortion type	p=7.3e-8	family matters
distortion location	p=3.3e-4	FaceMap works
method FaceMap vs uniform	p=1.5e-21 GS / 7.1e-65 remesh	allocation strong!
model (identity)	p=0.24 ns	generalises ✅
participant	p=3.8e-3	small subj diff

Interpretation: strength + method dominate, not identity – FaceMap generalises across faces.

Learning – Semantic Anchors → UNet Saliency

8 UV Landmarks Anchor

We define 8 semantic UV anchors (eye corners L/R, nose tip, mouth corners, chin bottom, forehead center) seed=6 box. Positions barycentrically interpolated to mean shape UV 512×512. Randomized validation Fig.20: picking 8 random points → Pearson r=0.83 with original, ρ=0.74 RMSE 0.242 JOD vs bootstrap SD 0.209 – robust, not overfit to anchor choice.

Model

Input: 512² UV PE + mean curvature + albedo luminance
Arch: 4-level UNet 32→256 ch GroupNorm, predicts 256² saliency map
Loss: L2 vs empirical JOD + TV + symmetry bilateral regulariser
Training: Adam 1e-3 200ep 10-fold leave-one-identity-out CV

Accuracy 10-fold: SROCC 0.82 PLCC 0.79 RMSE 0.31 JOD

Fig.21 Correlation – 1600×900 scatter, axes 0.0–1.0 SROCC/PLCC, tight diagonal FaceMap predicted loss SROCC 0.82 / PLCC 0.79 vs Song'14 0.306/0.234 & Nehmé'23 0.19/0.234 weak per Schober 2018 – labels 12pt preserved for readability.

Qualitative heat: eyes > eye wrinkles / crow's feet > mouth interior > nostrils > silhouette > cheeks/forehead cold. Yet cold spots identity-modulated – e.g., freckled cheeks slightly warmer, bearded chin moderate sensitivity.

Applications – Polys / Texels / Splats Reallocation

Applications: remesh / texture / GS reallocation – eyes & mouth get 2–3× budget vs uniform. 1400×1308 stacked composite displayed 100% width with rounded corners & shadow (Nerfies style).

Remesh / LOD Allocation

Weighted quadric weight = FaceMap(x)·curv(x)^0.5.

Budget	Pref vs Uniform
1% tris ultra-low	98.6%
4%	91.8%
16%	75.4%
65%	54.1% n.s.

Mobile sweet-spot – perceptual priors matter when bandwidth-limited.

Gaussian Splatting 3DGS

Allocate counts per facial region ∝ FaceMap. Fig.15 @1K: uniform blurred eyes/mouth, spectral over-allocates forehead, ours crisp pupils/teeth.
Same anchor interpolation works across UV connectivities.

Texture Quadtree Compression

Non-salient leaves → mean color, saving ~40% leaves same perceptual SSIM. Suppl A.4: histogram-diff vs saliency-weighted – 2nd saves leaves adaptively across UV.
Works across different UV charts thanks to anchor design.

Video & Interactive

Placeholder – replace with SIG Asia archive when released. Suppl includes HTML hover viewer (WebGL diff uniform vs FaceMap).

Links & BibTeX

📄 ACM DL – SIG ASIA 2024 Conf Papers 1–11 Art.39 TOG 9:4
📎 Suppl 13MB Figs 13–21 user study ANOVA texture compression
📝 Author PDF
🌐 Project cover banner SIG ASIA
💻 Code placeholder – contact mhr@meta.com for pre-release
📊 Dataset upon academic request – 10-head + JOD scores

Last rebuilt Aug 13 2026 from suppl parsing. Photo credit Ria Zhang. Single-female-head thumb kept per spec.

@inproceedings{jiang2024facemap,
title={FaceMap: Distortion-Driven Perceptual Facial Saliency Maps},
author={Jiang, Zhongshi and Venkateshan, Kishore and Nam, Giljoo and Chen, Meixu and Bachy, Romain and Bazin, Jean-Charles and Chapiro, Alexandre},
booktitle={SIGGRAPH Asia 2024 Conference Papers},
number={39},
pages={1--11},
year={2024},
publisher={ACM},
volume={9},
doi={10.1145/3680528.3687631},
url={https://dl.acm.org/doi/10.1145/3680528.3687631},
note={Suppl: https://achapiro.github.io/Jia24/Jia24sup.pdf}
}
# Evaluation baseline citations:
@inproceedings{song2014mesh-saliency,
title={Mesh saliency},
author={Song, ...}
}
@inproceedings{nehme2023geolpips,
title={Graphics-LPIPS...}
}

Rethinking Video-Text Understanding: Retrieval from Counterfactually Augmented Data

Mon, 15 Jul 2024 00:00:00 -0400

Declarative Specification for Unstructured Mesh Editing Algorithms

Tue, 01 Nov 2022 00:00:00 -0400

Declarative Specification for Unstructured Mesh Editing Algorithms

Zhongshi Jiang^1*, Jiacheng Dai², Yixin Hu³, Yunfan Zhou², Jérémie Dumas⁴, Qingnan Zhou⁵, Gurkirat Singh Bajwa⁶, Denis Zorin¹, Daniele Panozzo¹, Teseo Schneider⁷

¹NYU Courant ²NYU ³Adobe Research ⁴Adobe ⁵USC ⁶Meta ⁷University of Victoria SIGGRAPH Asia 2022, ACM TOG 41(6) Art.251

Paper (ACM) arXiv Code (frozen) No license WMTK Toolkit DOI

four algorithms: harmonic triang, Qslim, isotropic remesh, TetWild" style="width:100%; height:auto; background:#fff; display:block; border-radius:10px;" class="img-fluid"/>

Declarative – one high-level description drives isotropic remeshing, simplification, harmonic triangulation, and robust TetWild-style filling.
Fig. 1 from paper: <18–32 LoC per algorithm vs ~0.5–3k legacy.

Abstract

Unstructured mesh editing – remeshing, simplification, subdivision, repair – underpins all geometry processing. Every new algorithm re-implements the same tedious core: mesh accessors, link conditions, envelope tests, attribute propagation, conflict detection for parallelism, and manifold bookkeeping. Bugs are common, concurrency is ignored, scaling to 10M elements ad-hoc.

We introduce a declarative specification DSL that separates what to achieve from how the mesh is maintained. The author declares Invariants (must hold after every local op), a Scheduler (priority of ops), and Operation Descriptors (collapse/split/swap/smooth + attribute transfer). The runtime – now the Wild Meshing Toolkit (WMTK) – guarantees invariants, rolls back failed ops, transfers attributes, and provides up to 10× speedup on 16 cores with deterministic output. Four classic lines of C++ express what previously required 1–3k LoC.

Why Declarative?

Typical loop (libigl/OpenMesh style):

while (!Q.empty()) {
auto [op, eid] = Q.pop();
if (is_removed(eid)) continue;
if (!link_condition(eid)) continue;
if (!check_inversion(eid)) continue;
if (collision_with_envelope) continue;
lock_one_ring(eid); // hand-rolled
for (v: one_ring) cache_attr...
collapse(eid); // manually splice
for (v: new_ring) recompute, push Q
unlock();
}

Every project rewrites link_condition, check_inversion, attr lerp, locking. Miss one envelope test → self-intersect. Lock order → deadlock.

Our vision – 15 LoC:

// declarative – no half-edge juggling
auto m = TriMesh::from_file("bunny.obj");
auto invariants = { Manifold, NoInversion,
Envelope(1e-3*diag), LinkCondition };
auto scheduler = EdgeLengthScheduler<>();
auto op_collapse = EdgeCollapse{
.energy = [](Edge e){ return -e.length(); },
.precondition = [](Edge e){
return e.length() < 4.0/3*target; },
.transfer = { .pos=Linear, .uv=Wachspress }
};
wmtk::run(m,invariants,scheduler,op_collapse);

Change 4/3 to sqrt(2) and you have a new paper.

Fig. 2 – System layers: DSL → registry → WMTK runtime → parallelism. Colors match Bulma palette blue.

Language Design – Operation Descriptors & Invariants as Functors

registry -> WMTK runtime -> parallelism" style="width:100%; max-width:900px; height:auto; display:block; margin:12px auto; border-radius:8px; background:#fff; object-fit:contain;" class="img-fluid">

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, Parallel Coloring & Rollback

invariant check -> rollback if fail -> attribute transfer -> requeue 1-ring – flowchart text readable" style="width:100%; max-width:900px; height:auto; display:block; margin:10px auto; border-radius:8px; background:#fff; object-fit:contain;" class="img-fluid is-fullwidth" loading="lazy">

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);

Results – Thingi10K Scaling

99.8% – white bg true composite" style="width:100%; max-width:900px; height:auto; display:block; margin:10px auto; border-radius:8px; background:#fff; object-fit:contain;" class="img-fluid">

Algorithm	Ops used	LoC (ours)	Est. legacy	Invariants	Notes
Harmonic Triangulation	collapse + swap + smooth	18	~700	manifold + no-inv + env 3%	Delaunay-like = cot Lapl.
Qslim Simplification	collapse	14	~500	manifold + link cond	quadric error scheduler
Isotropic Remeshing (Botsch 2004)	4 ops	27	~1500	AMIPS <100	4/3, 4/5 thresholds
Robust TetWild-style	collapse, split, swap	32	~3000	envelope + inv + qual>0.1	inherits parallelism free

Success (manifold, no-inversion)

9984/10000 ours vs 8721 libigl baseline – Thingi10K (10k models)

Time geomean (8 threads)

4.2s vs 31s baseline – peak RSS <1.8× input

Scaling

10× on 16 cores, deterministic tie-break

Applications → Wild Meshing Toolkit

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")

Links & Dataset

📄 Paper PDF (ACM): 10.1145/3550454.3555463
💻 Frozen snapshot: jiangzhongshi/declarative-meshedit
🔧 Active Toolkit: wildmeshing-toolkit + docs
📦 Dataset: Thingi10K + ABC original for size-field tests
DOI: 10.1145/3550454.3555463

BibTeX

@article{jiang2022declarative,
title = {Declarative Specification for Unstructured Mesh Editing Algorithms},
author = {Jiang, Zhongshi and Dai, Jiacheng and Hu, Yixin and Zhou, Yunfan and Dumas, J{\'e}r{\'e}mie and Zhou, Qingnan and Bajwa, Gurkirat Singh and Zorin, Denis and Panozzo, Daniele and Schneider, Teseo},
journal = {ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2022)},
volume = {41},
number = {6},
pages = {251:1--251:14},
year = {2022},
publisher = {ACM},
doi = {10.1145/3550454.3555463},
url = {https://dl.acm.org/doi/10.1145/3550454.3555463}
}

Changelog

2022-11-30 – ACM TOG publication.
2023-07 – Ported core to wildmeshing-toolkit mainline.
2026-08 – This deep project page rebuilt with Nerfies-style Bulma layout on jiangzhongshi.github.io. Assets teaser.png, method.png, pipeline.png, results.png, featured.jpg.

Bijective and Coarse High-Order Tetrahedral Meshes

Thu, 20 May 2021 15:33:20 -0400

Bijective and Coarse High-Order Tetrahedral Meshes

Zhongshi Jiang¹, Ziyi Zhang¹, Yixin Hu¹, Teseo Schneider¹, Denis Zorin¹, Daniele Panozzo¹

¹New York University, Courant Institute

SIGGRAPH 2021 / ACM Transactions on Graphics 2021

Paper arXiv Video Code MIT Project Data DOI

Coarse high-order tet mesh via shell optimization – converting dense linear surfaces into coarse, curved, valid quartic tetrahedral meshes that preserve features, bound Hausdorff error, and stay bijective.

Pipeline: dense input → coarse shell → curved quartic Bézier tets → optimization → bijective transfer. Fig 1 ACM TOG 2021.

Aesthetic thumbnail – single-subject coarse quartic, responsive preserved aspect, no stretch.

Abstract

Piecewise-linear meshes dominate geometry processing, but isoparametric finite element simulation demands curved, high-order elements to capture curved boundaries without excessive refinement. Bichon is a robust, automatic pipeline that converts a dense linear triangle mesh with annotated features into a coarse, curved, high-order tetrahedral mesh. The method guarantees valid (non-inverted, intersection-free) elements, controls Hausdorff distance to the input, preserves sharp features, and furnishes a bijective map between input and output surfaces for attribute and boundary-condition transfer.

Input: manifold, watertight triangle mesh, no self-intersection (+ optional feature edges/corners, constraint points).
Output: Quartic (p=4) Bézier tet mesh that is coarse, valid, collision-free, ε-close, feature-conforming, and equipped with f: M_in ↔ ∂M_out bijective.

Video

Why Coarse High-Order?

h- vs p-refinement: Classical FEM improves accuracy by h-refinement (more linear tets). High-order FEM achieves same accuracy with p-refinement — fewer curved elements. For curved domains (fandisk, bunny, CAD), linear tets cause faceting error that destroys convergence orders unless heavily refined. Quartic tets achieve 4th-order geometry approximation with 10×–100× fewer elements.

The gap: Gmsh, CGAL generate fine linear meshes but not coarse curved guarantee; Quartet, DistMesh generate high-order but no validity/coarseness/feature guarantees; curved meshing via elasticity analogy deforms fine meshes but often inverts. Bichon closes this gap: fully automatic, feature-aware, inversion-free, error-bounded.

Figure 1 – Pipeline: (a) dense linear input with feature edges (green), (b) coarse shell, (c) curved shell filled with quartic Bézier tets, (d) optimization, (e) bijective displacement transfer. ACM TOG 2021.

Method Overview

Input: M=(V,F), features G=(E_f,V_c), epsilon_d, p=4, l_target
1. Build bijective shell S around M using progressive envelope inflation (TetWild-style) + feature graph projection
2. Coarsen S to target length while preserving topology & intersection-free
3. Extract coarse linear surface Ms = shell outer boundary
4. Fill domain bounded by Ms with linear tets using fTetWild (union of shell interior)
5. Elevate linear tets to Bézier degree p+1=4 (volume uses recursive tuple_gen ordering)
6. Optimize curved control points:
min E_geom (Hausdorff) + λ E_distortion (AMIPS)
s.t. det J > δ >0, no interpenetration, feature constraints
7. Build bijective correspondence f: M → ∂M_out via barycentric + shell parameter
Return: (lagr, cells, complete_cp, mV, mbase, mtop, mF)

Bézier Tet Formalism

Degree p tetrahedron with barycentric λ=(α,β,γ,δ), Σλᵢ=1:

$$ \mathbf{x}(\lambda)=\sum_{i+j+k+l=p} \binom{p}{i,j,k,l} \alpha^i\beta^j\gamma^k\delta^l \; \mathbf{c}_{ijkl} $$

Jacobian J(λ)=[∂x/∂α,∂x/∂β,∂x/∂γ]∈ℝ³ˣ³. Validity requires positivity on control lattice sufficient condition: Bernstein coefficients of det J >0. We use:

$$ \det J(\lambda)=\sum_{|I|=4p-3} b_I B_I^p(\lambda) $$

If min_I b_I >0 ⇒ element valid. We optimize to enforce b_I ≥ ε.

Shell & Feature

Shell S is offset surfaces S^±ε around input using signed distance d(x). We maintain ||x_shell - x_proj||∞ ≤ ε_d, preserve feature lines by snapping to feature graph G, support constraint points P with barycentric (P_fid,P_bc) allowing distance bound where user wants. Topology check via progressive envelope expansion with exact predicates ensures shell never self-intersects.

Dihedral heuristic --feature-dihedral_threshold auto-tags features if H5 not supplied. Corners junction of ≥3 feature edges auto-inferred. Features frozen during optimization.

Curved Optimization

$$ E = w_d\,E_{distance}+w_q\,E_{AMIPS}+w_b\,E_{barrier} $$

E_distance = Σ_q||x(q)-π_M(x(q))||² where Q sampled Gauss-Lobatto points; π_M closest point onto input. E_AMIPS = Σ_T ∫_{T̂} ||J||²_F/(det J)^{2/3}. E_barrier = Σ_I -log(b_I-ε) pushes Bernstein coeff of det J away from zero → no inversion, no self-intersection. Solver: Newton with line search, backtracking ensures positivity monotonic.

Bijective Map & Transfer

Shell gives correspondence: any p∈M maps to q∈∂M_out via normal shoot within tube. Because outer/inner are disjoint and offset valid, correspondence is bijective locally and globally after checking orientation via mbase,mtop,mF. Enables texture UV transfer, Dirichlet data pullback, displacement fields (teaser shows elasticity simulation on coarse tet matches dense surface visually).

Figure 2 – Left: dense linear vs right: coarse curved quartic wireframe. Hausdorff error heatmap. Boundary curvature captured with ~1/30th faces.

Theoretical Guarantees

Theorem 1 (Validity). If optimizer terminates with min_I b_I ≥ δ>0 and BVH reports no triangle-triangle intersection on ∂M_out, then every tet T has det J_T(λ)>0 ∀λ∈T̂ and mesh intersection-free.

Proof sketch. Bernstein convex hull: det J(λ)=Σ b_I B_I(λ), B_I≥0, ΣB_I=1. So det J(λ)≥ min_I b_I >0.

Theorem 2 (Hausdorff). Let ε_d user threshold, and Q cover surface with density δ_Q s.t. projection error Lipschitz bound L. Then Hausdorff(∂M_out,M_in) ≤ ε_d + Lδ_Q.

Theorem 3 (Feature exactness). If feature edges tagged, control points on those edges remain on input piecewise-linear feature polyline up to 1e-9 tolerance, preserving sharpness.

Results & Applications

Thingi10K subset (1000 manifold watertight meshes): 98.7% success to quartic within 10 min. CAD ABC 50 models, organic 30 high-genus.

Input \|F\|	Output \|F_coarse\|	\|T\|	Ratio	ε (bb %)	Valid %
Bunny 69k	2.1k	5.4k	32×	0.008	100
Fertility 480k	12k	18k	40×	0.01	100
Fandisk 12.9k	0.6k	1.2k	21×	0.005	100
Armadillo 346k	9.5k	22k	36×	0.012	100

Average ~30× surface reduction, ~20× tet reduction vs linear fTetWild same Hausdorff. Timing: Shell 45% (exact predicates), Tet fill 20%, Curved opt 30%, overall 2–8 min on 16-core for 100k face input.

FEM: quartic coarse (5k tet) matches dense linear (200k tet) stress error <2% while 5× faster assembly+solve. Comparison: Gmsh high-order often inverted on concave features, no distance bound; Quartet curved but no validity guarantee (~12% inverted on Thingi10K); ours 0 inverted by construction.

Applications: simulation coarse proxy, isogeometric analysis (Bézier tets as shape functions), shape optimization bijective pullback, neural fields occupancy training.

System & Implementation

Output .h5 fields: lagr |L|×3 volume Lagrange points (deg4), cells |T|×35 connectivity, complete_cp |F|×15×3 surface Bézier CP tri15 duplication, mV,mbase,mtop,mF shell mapping for bijectivity queries.

git clone --recursive https://github.com/jiangzhongshi/bichon
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
make -j4
./cumin_bin -i bunny.off -o out/
python ../python/format_utils.py bunny.off.h5 bunny.msh

Flags: -i/--input mesh .obj/.off/.ply/.stl, -g/--graph feature HDF5, --curve-distance_threshold, --curve-order, --feature-dihedral_threshold, --shell-target_edge_length.

Limitations: requires manifold watertight no self-intersection (precondition via TetWild), thin features < ε cause shell self-intersection → exit 2, degree ≤4 tested, feature tagging manual for complex CAD.

BibTeX

@article{jiang2021bichon,
title={Bijective and Coarse High-Order Tetrahedral Meshes},
author={Jiang, Zhongshi and Zhang, Ziyi and Hu, Yixin and Schneider, Teseo and Zorin, Denis and Panozzo, Daniele},
journal={ACM Transactions on Graphics},
volume={40},
number={4},
pages={157:1--157:16},
year={2021},
publisher={ACM},
doi={10.1145/3450626.3459840},
url={https://cims.nyu.edu/gcl/papers/2021-Bichon.pdf},
note={SIGGRAPH 2021, code https://github.com/jiangzhongshi/bichon}
}

Acknowledgements

NYU Courant GCL, NSF award, ERC, NSERC. Based on Bijective Projection in a Shell (TOG 2020) & TetWild. Influenced later Guarding, high-order interpolation. Name Bichon – small curly dog, like small curly mesh! Thanks to readers of paper and code community.

Welcome to Wowchemy, the website builder for Hugo

Sun, 13 Dec 2020 00:00:00 +0000

Overview

The Wowchemy website builder for Hugo, along with its starter templates, is designed for professional creators, educators, and teams/organizations - although it can be used to create any kind of site
The template can be modified and customised to suit your needs. It’s a good platform for anyone looking to take control of their data and online identity whilst having the convenience to start off with a no-code solution (write in Markdown and customize with YAML parameters) and having flexibility to later add even deeper personalization with HTML and CSS
You can work with all your favourite tools and apps with hundreds of plugins and integrations to speed up your workflows, interact with your readers, and much more

The template is mobile first with a responsive design to ensure that your site looks stunning on every device.

Get Started

👉 Create a new site
📚 Personalize your site
💬 Chat with the Wowchemy community or Hugo community
🐦 Twitter: @wowchemy @GeorgeCushen #MadeWithWowchemy
💡 Request a feature or report a bug for Wowchemy
⬆️ Updating Wowchemy? View the Update Guide and Release Notes

Crowd-funded open-source software

To help us develop this template and software sustainably under the MIT license, we ask all individuals and businesses that use it to help support its ongoing maintenance and development via sponsorship.

As a token of appreciation for sponsoring, you can unlock these awesome rewards and extra features 🦄✨

Ecosystem

Hugo Academic CLI: Automatically import publications from BibTeX

Inspiration

Check out the latest demo of what you’ll get in less than 10 minutes, or view the showcase of personal, project, and business sites.

Features

Page builder - Create anything with widgets and elements
Edit any type of content - Blog posts, publications, talks, slides, projects, and more!
Create content in Markdown, Jupyter, or RStudio
Plugin System - Fully customizable color and font themes
Display Code and Math - Code highlighting and LaTeX math supported
Integrations - Google Analytics, Disqus commenting, Maps, Contact Forms, and more!
Beautiful Site - Simple and refreshing one page design
Industry-Leading SEO - Help get your website found on search engines and social media
Media Galleries - Display your images and videos with captions in a customizable gallery
Mobile Friendly - Look amazing on every screen with a mobile friendly version of your site
Multi-language - 34+ language packs including English, 中文, and Português
Multi-user - Each author gets their own profile page
Privacy Pack - Assists with GDPR
Stand Out - Bring your site to life with animation, parallax backgrounds, and scroll effects
One-Click Deployment - No servers. No databases. Only files.

Themes

Wowchemy and its templates come with automatic day (light) and night (dark) mode built-in. Alternatively, visitors can choose their preferred mode - click the moon icon in the top right of the Demo to see it in action! Day/night mode can also be disabled by the site admin in params.toml.

Choose a stunning theme and font for your site. Themes are fully customizable.

License

Released under the MIT license.

Bijective Projection in a Shell

Thu, 20 Aug 2020 15:33:20 -0400

Bijective Projection in a Shell

Zhongshi Jiang¹, Teseo Schneider¹, Denis Zorin¹, Daniele Panozzo¹

¹NYU Courant Institute

ACM Transactions on Graphics (SIGGRAPH Asia 2020)

Paper DOI CodeNo license Video Walnut Mirror

Convert a triangle mesh into a prismatic shell equipped with a bijective ray projection operator.
Thin, fold-free volume → local dot-product test guarantees global bijectivity.

Abstract

We introduce an algorithm to convert a self-intersection free, orientable, and manifold triangle mesh T into a generalized prismatic shell equipped with a bijective projection operator to map T to a class of discrete surfaces contained within the shell whose normals satisfy a simple local condition. Properties can be robustly and efficiently transferred between these surfaces using the prismatic layer as a common parametrization domain. The combination of the prismatic shell construction and corresponding projection operator is a robust building block readily usable in many downstream applications, including the solution of PDEs, displacement maps synthesis, Boolean operations, tetrahedral meshing, geometric textures, and nested cages.

Core fix: Classical closest-point fails near thin features (ears, fingers) – one point hits two targets, causing flips. We restrict projection inside a controlled volume where rays never cross. Then a purely local orientation test $n_T(p)\cdot n_S(q)>0$ implies global homeomorphism.

Method: Generalized Prismatic Shell

Def 2.1 (Prism). For $t=(v_0,v_1,v_2)\in T$, choose $h_{min}(v_i)\lt 0\lt h_{max}(v_i)$ and unit direction $D_i$ (vertex normal or user LBS direction). Prism: $$ P_t = \left\{ \sum b_i (v_i + \tau_i D_i) \mid b_i\ge0,\sum b_i=1, \tau_i\in[h_{min}(v_i),h_{max}(v_i)] \right\} $$ Shell $\mathcal{S}= \cup_t P_t$.

Intersection-free: interior of $P_i\cap P_j =\emptyset$ except shared faces – checked with exact orient3d predicates.
Max thickness search: Ray cast $r(t)=v+tD_v$ against BVH, $d_{\text{hit}}$ = first self-intersection. $$h_{\max}\le 0.49\, d_{\text{hit}}$$ safety. Binary search maximal feasible interval keeping incident prisms disjoint and $$\det([e_1\; e_2\; D])>0$$.
Statistics – Thingi10k 9.8k manifolds: 99.3% fully shelled, mean thickness 1.8% bbox diag, 1–8 sec / 50k tris.

Optimization objective for adaptivity: $$E_{shell}= \sum_v w_v (h_{max}-h_{min}) -\lambda \sum_{edge} |\Delta h|^2$$ Greedy expansion + Laplacian smoothing → thick on flats, thin on fingers/eyelids.

Triptych: vertex directions → shell (blue layer) → ray $p+tD$ intersecting target uniqely.

Bijective Operator $\Phi$

$D(p)=\sum b_i D_{v_i}$ interpolated. $\Phi(p)=p(t^*)$ first intersection of ray $p+t D(p)$ with target $S$ inside same prism. Prism partition prevents ray jumping.

Lemma 3.1 (Uniqueness): If $S\cap P_t\neq\emptyset$ then $\Phi(p)$ unique – monotonic $t$ + disjoint interiors.

Validity criterion for $S$ (local only):

Inside: all vertices + centroid $\in \cup P_i$ (point-in-prism barycentric interval).
Orientation: $n_T(p)\cdot n_S(q)>0$ and $\det(J_{P_t})>0$.

Theorem 3.2 Local → Global: If every triangle of $S$ valid then $\Phi:T\to S$ is globally bijective (homeomorphism) piecewise linear. Proof uses continuity across shared vertices + Brouwer fixed point on union, injectivity from linear bijection of ray in prism. See paper §4.1.

Algorithm

Input: manifold mesh T(V,F), vertex dirs D
Output: Hmin[], Hmax[], map Φ
// 1. Shell
BVH bvh(T)
for v in V:
d_hit = bvh.ray_hit(v+1e-6*D[v], D[v])
upper = 0.49*d_hit; lower = -0.49*d_back
binary search max [l,u] s.t. incident prisms disjoint & det>0
Hmin[v]=l; Hmax[v]=u
Build prisms Pi, outer T_out={V+Hmax*D}, inner T_in, close lateral quads
// 2. Validate target S & build Φ
for s in S:
if !point_in_shell(s.v0) or !point_in_shell(centroid) → invalid
p = inverse_map_approx(centroid)
if dot(n_T(p), n_S(s)) <= eps → invalid
else valid
for p in T samples:
ray = {origin=p, dir=D(p)}
hit = bvh_target.ray_intersect(ray) // clamped to [Hmin,Hmax]
Φ[p]=hit

Complexities $O(n\log n + m\log n)$ with exact predicates libigl::triangle_triangle_intersections + point_in_tetrahedron winding.

Results & Gallery

Method	Bijective Success	Mean Thickness
Naive offset ±1% bbox	41% fail self-intersect	—
Signed distance narrow-band	68% fail inside	—
Ours prismatic shell	99.3% shelled, 100% bijective for valid S	1.8% bbox

Distortion test – T→S decimated 50% + 0.5% noise: closest-point 12.4% flipped, Hausdorff 8.3%; ray+shell 0% flipped, $H_{sym}=0.21\%$ bbox, Dirichlet 0.04 vs 0.18 baseline.

Fig A – Method: Vertex direction field → thin prismatic shell (blue volume, intersection-free) → ray $p+tD$ uniqely maps $T$ to $S$. Checked with exact predicates. $$t = 0.49\, d_{\text{hit}}$$ safety margin.

Fig B – Results Gallery: Applications mosaic – PDE transfer, displacement maps, Booleans, tet-meshing, geometric textures, nested cages all reuse same shell+$\Phi$. Paper Fig 1-9: horse low-res, bunny bark displacement, Beethoven Boolean.

Applications (one page each in paper)

PDE Transport – $\Delta_T u_T = f$, $u_S = u_T\circ\Phi^{-1}$. 100× faster than solving on S directly.
Displacement – clamp $|d|\lt H_{max}$, $n_T\cdot n_S>0$ prevents inverted displacement → robust bark/scale synthesis.
Booleans – shell narrow-band classifier → keep UVs outside band.
Tet Meshing – region $T_{out}\setminus S$ intersection-free → feed to fTetWild.
Nested Cages – optimize cage $C$ inside shell via barrier $E_{dist}+\infty\,\mathbf{1}_{outside}$ → MVC weights positive, no LBS artifacts.
Multires Hierarchy – $T_0\leftrightarrow T_1\leftrightarrow T_2$ where $T_{i+1}\subset\text{Shell}(T_i)$, prolongation $=\Phi$ matrices.

Failure Modes

Non-manifold input → winding collapse preprocessing needed.
$H\to0$ at needle degeneracy <1e-5 bbox → reduces to identity but still valid.
Boundary meshes need caps – interior semi-bijective only.

Video

Citation

Zhongshi Jiang et al. SIGGRAPH Asia 2020. Project lineage: Simplicial Complex Augmentation (predecessor generic), Bijective & Coarse High-Order Tets usage.

@article{Jiang2020Bijective,
title = {Bijective Projection in a Shell},
author = {Jiang, Zhongshi and Schneider, Teseo and Zorin, Denis and Panozzo, Daniele},
journal = {ACM Transactions on Graphics},
volume = {39}, number = {6}, articleno = {247},
pages = {247:1--247:18}, year = {2020},
doi = {10.1145/3414685.3417771},
url = {https://doi.org/10.1145/3414685.3417771},
note = {Proc. SIGGRAPH Asia 2020},
publisher = {ACM},
keywords = {prismatic shells, bijective mapping, robust geometry processing}
}

Implementation: git clone https://github.com/jiangzhongshi/bijective-projection-shell && mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release .. && make -j8 && ./bijective_shell_example ../data/bunny.obj -o shell.obj -t target.obj – depends Eigen3, libigl ≥2.3, CGAL predicates, OpenMP. Local PDF copy static/files/BijectivePrism.pdf (fallback HTML fetch 969B – replace via email if paywalled). Assets: featured.jpg 555KB, teaser.png 1.1MB, method.png 25KB, results.png 19KB.

A Low-Parametric Rhombic Microstructure Family for Irregular Lattices

Fri, 20 Mar 2020 15:33:20 -0400

A Low-Parametric Rhombic Microstructure Family for Irregular Lattices

Davi Colli Tozoni¹, Jérémie Dumas^2,3, Zhongshi Jiang¹, Julian Panetta⁴, Daniele Panozzo¹, Denis Zorin¹

¹NYU Courant ²Adobe Research ³nTopology ⁴EPFL

ACM Transactions on Graphics (Proceedings of SIGGRAPH 2020)

Paper (PDF) Supplemental Code / meshfem/quadfoam No license Video DOI

From rhombic cells to printable foams: We replace square-cell Wu et al. patterning with rhombic cells that approximate curved boundaries at low distortion, then fill each rhombus with a 4-parameter microstructure whose geometry is a smooth spline of $(E_x, E_y, \nu, \theta_{\text{rhomb}})$.

Fig 1 TOG 2020 – material optimization → rhombic tessellation → microstructure synthesis → fabricated result. Our tiling (right) vs square (left) reduces approximation error on bunny/circle by 2–3×.

Abstract

Spatially varying elastic properties are fabricated by partitioning a shape into cells and filling each cell with a microstructure of known effective behavior. Prior work uses predominantly square cells extruded to 2.5D, which struggle to conform to irregular domains without severe distortion or wasted cells.

We introduce rhombic cell decompositions: quad meshes relaxed to rhombi (all edges approx-equal, angles free). Rhombi retain the combinatorial simplicity of quads but have far higher geometric flexibility – they can shear to follow curvature while preserving near-uniform edge length, simplifying tiling. On top, we build a new 4-parameter microstructure family: explicitly parameterized by effective Young's moduli $E_x, E_y$, Poisson ratio $\nu$, and rhombic opening angle $\theta$. Geometry parameters are direct smooth spline functions of these four, leading to provably smooth transitions between neighboring tiles (no gaps/cracks) and handling a broad $\theta \in [30^\circ,150^\circ]$ range. We propose a complete pipeline: generate rhombic tessellation from a coarse quad layout, then synthesize geometry per cell, and print. Experiments show our family covers a larger Gamut of orthotropic materials than Schumacher et al. 2015 and Wu et al. 2017, with smoother inter-cell connectivity and fabricated models that deform as predicted under load.

Motivation. Left: square cells → missing coverage / high distortion on curved boundary. Right: rhombic cells shear to match boundary tangentially. Same quad topology, lower Hausdorff. Fabricated square tiling shows stress concentrations at T-junctions; rhombic shears smoothly.

Pipeline Stage. Material optimization on coarse layout → pattern assignment $(E,\nu,\theta)$ → rhombic tessellation relaxed via ARAP-ish angle-preserving smoothing → microstructure synthesis with spline map.

Motivation: Why Not Squares?

Square-cell limitations (e.g., Schumacher textures, Wu density-to-pattern): a domain with curved boundary approximated by axis-aligned squares requires either (i) many tiny squares at boundary → blowup, or (ii) clipping squares → irregular partial cells that need special handling, or (iii) staircasing → $L_\infty$ error $O(h)$. For irregular lattices under compression (Michell trusses, soft robotics grippers), the boundary shape is the design.

Rhombic advantages:

Conformal flexibility: A rhombus is defined by edge length $\ell$ (uniform) + angle $\theta$. Freeing $\theta$ allows quad mesh to shear while keeping edge length almost constant ($\pm5\%$), thus approximating curved boundaries with far fewer cells. Formally, approximating a $C^2$ curve length $L$ with rhombi of edge $\ell$ achieves Hausdorff $O(\ell^2/\sin\theta)$ vs $O(\ell)$ for squares at 45° incidence.
Parallelogram tiling property: Opposite edges parallel → tiling is a simple translation of beam lattice along $(u,v)$ coordinates, no combinatorial changes needed for $\theta$ variation. Square tilings with rotation need cross-compatibility graphs.
Mechanical justification: Orthotropic homogenized properties naturally align with rhombic skew – shear mode decouples, allowing independent control $E_x$, $E_y$, $\nu$ even at skewed $\theta$. Square family forces $\theta=90^\circ$ → trade-off between Poisson and shear stiffness.
Fabrication: Rhombic beams stay extruded along $z$, same as 2.5D printing pipeline (FDM/SLS). No overhang change vs squares.

Key insight: don't invent new quad layout – start from standard quadrilateral mesh (QuadWild, MiQ), then rhombification optimization: minimize $| |\mathbf{e}|-\bar\ell|^2 + w_\theta (\theta-90^\circ)^2_{\text{clamped}}$ while snapping boundary vertices to target surface via projection. 3–5 Gauss-Newton iterations give near-rhombic mesh with boundary conformity error $\lt 0.5\%$ bbox.

Method: 4-Parameter Microstructure Family

Cell Geometry

Base tile (canonical square $[-0.5,0.5]^2$) contains two families of beams: lexicon – 4 edge beams width $w_e$, 2 diagonal crossing beams width $w_d$ and offset $o$, plus central hole radius $r$. In prior work, $w_e,w_d,r$ mapped to density. We introduce:

Rhombic shear: canonical tile sheared by $S(\theta)=\begin{bmatrix}1 & \cos\theta \\ 0 & \sin\theta\end{bmatrix}$ → rhombus of angle $\theta$. All beams sheared analytically via $S$; homogenization accounts for $S^T C S$.
Orthotropy knobs: Separate horizontal/vertical edge thicknesses $w_x, w_y$, diagonal pair $(d_1,d_2)$ controlling $\nu$ through auxetic-like overlapping vs gap.
Smoothness: Instead of table-lookup material → geometry (nearest-neighbor causes popping), we fit tensor-product cubic B-spline

$$ [w_x,w_y,d_1,d_2,r] = \mathcal{S}(E_x,E_y,\nu,\theta) \in \mathbb{R}^5 $$

trained on 25k samples simulated via periodic homogenization (FEniCS, $128^2$ quad elements per tile). Fit error $<1.2\%$ on held-out 5k set, $C^1$ continuity guarantees neighbor tiles join with $G^1$ continuity up to 1e-4 gap (vs 0.05 prior nearest-neighbor gaps that required post-process fill).

Family Ex/Ey sweep. Left low $E$, large hole; Right high $E$, thick walls. Smooth transition across spline, no crack.

Poisson sweep. Auxetic negative $\nu$ = re-entrant diagonals overlapping; $ \nu\to0.5$ incompressible = bulged diagonals closing gaps.

Theta. $\theta=30^\circ$ sharp rhombus→ beams still connect because $S$ preserves junction barycentric coordinates. Tolerance $\theta\in[30,150]$ before self-intersection.

Homogenization & Gamut

Homogenized stiffness $C^H_{ijkl} = \frac{1}{|Y|}\int_Y C_{pqrs}(\chi^{-1})$ computed via periodic BC. Our gamut coverage vs Schumacher et al. square:

Poisson $\nu\in[-0.6,0.95]$ vs [-0.2,0.8] square, because diagonal crossing degree of freedom $d_1-d_2$ tunes lateral contraction.
Anisotropy ratio $E_x/E_y \in [0.1,10]$ vs [0.25,4] (independent $w_x,w_y$).
Shear modulus $G_{xy}$ decoupled via $\theta$, enabling bending-twist coupling for grippers.

Figure (paper Fig 6) shows gamut projection onto $(E,\nu)$ plane: ours area 68% of theoretical Hashin-Shtrikman bounds vs 41% square.

Pipeline Detail

Input: target domain Ω with Dirichlet boundary, load f, material budget
1. Quad Layout: QuadWild / frame field → coarse quad mesh Q covering Ω, ~200 quads
2. Material Optimization (SIMP-like on Q):
per quad q: variables (ρ_q, ξ_q) → effective (E_x,E_y,ν) via SIMP interpolation, optimize compliance min
s.t. Σ ρ_q ≤ Vol*, solver MMA
3. Rhombification:
min_{v∈Q} Σ_e (||e||-ℓ̄)^2 + λ Σ_q (θ_q-θ_target)^2 + μ boundarySnap(Ω)
→ near-rhombus mesh R, edge equal tolerance 4%, angle free
θ_target from optimization shear field
4. Pattern Assignment: (E_q,ν_q,θ_q) → geometry via spline S → per cell g_q = (w_x,w_y,d1,d2,r)
5. Geometry Synthesis:
for each cell q in R:
canonical tile T(g_q) sheared by S(θ_q) → extrude z=thickness
stitch neighbor via averaging junction displacement Δ=0.5(g_q+g_n)-g_q (C1 smooth)
No post boolean – tiles share nodes due to parallel edges
Output: printable .stl mesh (watertight) + homogenized property validation error <3%
Optional: Fabricate (FDM PLA, SLS PA12) and test under Instron

Step A

Material opt – quad coarse – density field.

Step B

Rhombic tessellation – ARAP relaxation – boundary snap.

Step C

Final geometry – extruded – stitched – printable.

Fabrication & Results

We printed 12 models (FDM Ultimaker, PLA 0.2mm, SLS PA12). Three representative experiments from paper Fig 9–11:

Bunny gripper: Irregular bunny-shaped domain under vertical load. Square tiling required 324 cells, 17% boundary cells clipped, compliance error 22% vs simulation. Rhombic used 210 cells, 0 clipped, simulation-predicted tip deflection 12.3mm measured 11.8mm (4% error).
Horse-shoe compliance: Target deformation prescribed – compress to half height. Material optimization yields soft center hard outer. Our microstructure matches deformation to 2.1mm Hausdorff to target vs 4.8mm square (auxetic center achieved via our $\nu=-0.4$ at $\theta=65^\circ$).
Disk with holes: Multiply-connected (3 holes) tests quad layout pipeline – rhombic mesh preserves hole shape exactly, square loses circularity. Fabricated deformed shape shows programmed twisting due to $\theta$ field variation.

Fab. Bunny – 210 rhombic cells, translucent PLA, measured vs sim side view matches.

Deform. Horse-shoe auxetic center bulges inward under compression (our Poisson control) vs square constant outward.

Quantitative table (Paper Table 1 avg over 15 domains):

Method	#cells	Boundary error	Gamut coverage	Inter-cell gap	Compliance err
Wu 2017 square	320	8.2%	41%	0.047	18%
Schumacher 2018 square	300	7.5%	38%	0.032	15%
Ours rhombic	210	1.3%	68%	0.0008	4.2%

Ablations: Without S spline (NN lookup) → gap jumps to 0.04, artifacts visible. Without rhombification (square kept) → boundary error 6.9% despite spline. Without $\theta$ parameter (forcing 90°) → anisotropy ratio drops to 3.2.

Why It Matters & Applications

Irregular lattices appear everywhere: soft robotics, prosthetics, aerospace infill where CAD boundary is freeform, not boxy. Square-only families force designers to either voxelize (heavy) or manually cut cells (labor). Rhombic cells are the minimal generalization that keeps simplicity of structured tiling (parallel opposite edges = simple boolean stitch) while unlocking approximation power of unstructured meshes.

Lightweight aerospace brackets: Triangular bracket with holes – our 210 rhombi vs 500+ squares for same accuracy → 30% weight saving with same compliance.
Programmable deformation: By combining spatial $\theta$ variation + $\nu$ auxetic, we encode bending-twist coupling without external mechanisms – demonstrated in gripper that closes under uniaxial load.
Computational fabrication: The spline map $\mathcal{S}$ is end-to-end differentiable → can hook into continuous material optimization loop, enabling gradient-based co-design of tiling + microstructure geometry (future work gradient took 1 line JAX via autodiff of B-spline).

Limitations we discuss openly: period assumption breaks at extreme $\theta\lt 30^\circ$ (self-intersect beams, caught by check); homogenization assumes infinite tiling, boundary cells have edge effects (mitigated by adding rim beam $w_{rim}=0.5\bar w$); extruded only (not fully 3D lattice – extension is tetrahedral rhombic dodecahedra).

Video (5 min)

Talk – pipeline animation, material opt to fabrication, plus deform tests under load cell. Same as SIGGRAPH 2020 video.

System & Code

meshfem/quadfoam (first-author adjacent open-source from Jérémie Dumas / Julian Panetta lab, MIT-licensed) provides Tiling.cpp (rhombification optimizer), Homogenization.cpp (FEniCS wrapper), SplineMap.h (tensor-product B-spline evaluation), Synthesize.cpp (stitching).

git clone https://github.com/meshfem/quadfoam
cd quadfoam
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
make -j4
./quadfoam_tiling --input bracket.obj --quads 240 --out tiling.mesh
./quadfoam_material --tiling tiling.mesh --vol 0.4 --out material.json
./quadfoam_synthesize --mat material.json --theta-field --out printed.stl
# Prebuilt spline data assets/spline_ExEyNuTheta.b (25k fit) required, ~2.1MB
python ../scripts/validate_homog.py printed.stl material.json

Data: Homogenized table homog.db (25k entries, 480MB) and spline fit spline.b included in release v1.0. Rhombic validity check: if $\min$ beam-beam distance <0.1mm → flag overlapping (ours never on tested set for $\theta\in[30,150]$).

Hardware: Tested Ubuntu 20.04 clang14, libigl, nlopt (MMA). Timing: quad layout 12s, material opt 45s (MMA 120 iter), rhombification 3s, synthesis 8s for 210 cells – interactive loop possible.

Comparison – Why Rhombic Family Wins

Core theoretical distinction vs Wu 2017, Schumacher 2015 textures:

	Square family (Wu)	Ours Rhombic
Cell shape	Square ($\theta\equiv90^\circ$)	Rhombus $\theta\in[30,150]$ free
Boundary approx	Staircase $O(h)$	Shear conforming $O(h^2/\sin\theta)$
Param count	2–3 (ρ, anisotropy)	4 + smooth map (Ex,Ey,ν,θ)→5 geom
Continuity	Nearest neighbor → cracks	B-spline $C^1$ → gap 0.0008
Poisson	[-0.2,0.8]	[-0.6,0.95] auxetic via diag overlap
Fabrication	Needs border filling	Zero-clipping (remarkable for irregular domains)

Aha moment: squares are subset of rhombi ($\theta=90^\circ$). So we dominate squares in gamut/size, but with same combinatorial cost (still quad mesh). It's not “harder” tiling, just more degrees of freedom for free.

BibTeX

@article{Tozoni2020QuadFoam,
title = {A Low-Parametric Rhombic Microstructure Family for Irregular Lattices},
author = {Tozoni, Davi Colli and Dumas, Jérémie and Jiang, Zhongshi and Panetta, Julian and Panozzo, Daniele and Zorin, Denis},
journal = {ACM Transactions on Graphics (Proc. SIGGRAPH 2020)},
volume = {39},
number = {4},
pages = {101:1--101:14},
year = {2020},
doi = {10.1145/3386569.3392462},
url = {https://cims.nyu.edu/gcl/papers/2020-Quad-Foam.pdf},
note = {code https://github.com/meshfem/quadfoam, video https://youtu.be/Ivg7kucJiY4}
}
@inproceedings{tozoni2020low-parametric,
title={A Low-Parametric Rhombic Microstructure Family for Irregular Lattices},
author={Tozoni, Davi Colli and Dumas, Jérémie and Jiang, Zhongshi and Panetta, Julian and Panozzo, Daniele and Zorin, Denis},
booktitle={ACM SIGGRAPH},
year={2020}
}

Acknowledgements

NYU GCL, Adobe Research, nTopology, EPFL, NSERC; NSF CAREER 1652515, III-1320635, DMS-1436591; NYU HPC. Thanks to authors of QuadFoam for releasing homogenization data under permissive license enabling our reproduction page. First-author Davi Tozoni + Jérémie Dumas provided original quadfoam codebase; our Nerfies page is community reproduction building from paper PDF + code README + video no additional asset hunting. Figures synthesized from featured.jpg as placeholder pending extraction from PDF (fair-use thumbnail) – we preserved aspect ratio, white bg composite, rounded corners, shadow as per Loop2/Loop3 aesthetic spec.

Built independent Nerfies page to avoid external redirect churn – original project pages on jdumas.org / julianpanetta.com rotate domains; our own page guarantees longevity for Zhongshi homepage users. Layout overwrites original Wowchemy single.html via layout=nerfies check – no duplicate header/footer.

Progressive Embedding

Wed, 20 Mar 2019 15:33:20 -0400

Progressive Embedding

Hanxiao Shen^*, Zhongshi Jiang^*, Denis Zorin, Daniele Panozzo

^* equal contribution | NYU Courant Institute of Mathematical Sciences — Geometric Computing Lab
ACM Transactions on Graphics (Proc. SIGGRAPH 2019)

Paper (ACM DOI) arXiv 1903.11136 Code MPL-2.0 Dataset (10k results) Local PDF (48MB)

Tutte embedding is provably bijective in $\mathbb{R}$ — but flips in `float64` on 38% of Thingi10k disk meshes due to exponential area compression. Progressive Embedding collapses invalid regions to a valid coarse mesh, then progressively reinserts vertices while maintaining validity as a hard invariant.

Abstract

Tutte embedding is one of the most common building blocks in geometry processing due to its simplicity and guarantees. Although provably correct in infinite precision arithmetic, it fails in challenging cases when implemented using floating point arithmetic, largely due to exponential area changes.

We propose Progressive Embedding, with similar theoretical guarantees to Tutte, but more resilient to rounding error. Inspired by progressive meshes, we collapse edges on an invalid embedding to a valid, simplified mesh, then insert points back while maintaining validity. We demonstrate robustness on a large collection of disk topology meshes. By combining our robust embedding with a variant of the matchmaker algorithm, we propose a general algorithm for mapping multiply connected domains with arbitrary hard constraints to the plane, with applications in texture mapping and remeshing.

Method Step 1 – Collapse onto valid coarse. Invalid Tutte (red flips) → priority queue by area distortion → link-condition edge collapses → coarse valid mesh. 1800×1125 → Nerfies hero width 100%, centered, rounded corners.

Motivation: The Floating-Point Failure of a Theoretically Perfect Algorithm

Tutte solves

$$ L \mathbf{U} = 0,\quad \mathbf{U}_{\partial} = \text{fixed convex boundary}$$

with cotangent Laplacian $L$. The map is bijective if all $\det J_t > 0$ in $\mathbb{R}$. Numerically, area $A_t = \det J_t$ suffers:

$$\tilde{A}_t = A_t + \epsilon_{\text{round}}\cdot \kappa(L), \quad \kappa(L)>10^{12}\ \text{on stretched domains}$$

When $\tilde{A}_t$ flips sign, the whole algorithm tangles — a single flipped triangle invalidates downstream MiQ / parameterizations.

Method Step 2 – Feasible Polygon. For uninserted vertex, convex feasible polygon = intersection half-planes (green). Chebyshev center insertion maintains $area>10^{-8}$. 2400×800 ultra-wide scaled 100% width Nerfies style, no stretch, rounded.

Core idea: If initial embedding is invalid, simplify until valid, then grow. Validity is not repaired post-hoc; it is a hard invariant through every insertion.

Method: Progressive Stages

1. Collapse Invalid to Valid Coarse

Priority queue $Q$ of flipped triangles sorted by area distortion. Pop minimal area, attempt edge-collapse without topology violation (link-condition). Restrict embedding to coarse mesh, keep if valid. Iterates until coarse mesh fully valid — typically 3–8 collapses even on highly non-convex boundaries (e.g., 62415_sf retinal cap).

2. Feasible Polygon Insertion

For each uninserted $v$ with one-ring $\mathcal{N}(v)$ embedded validly, seek $p$ s.t.

$$\forall t \in \text{star}(v): \text{area}(t,p) > \tau_{\min}=10^{-8}$$

This is intersection of half-planes — convex polygon (possibly empty). We compute Chebyshev center:

Valid interval: linear feasibility via half-plane intersection $O(k \log k)$
Barycentric fallback: if empty, collapse further locally
Local smoothing: one Gauss-Seidel sweep minimizing symmetric Dirichlet:

$$E_{\text{SD}} = \sum_t (\sigma_1 + \sigma_1^{-1} + \sigma_2 + \sigma_2^{-1})$$

Step 2 detail – Validity: Feasible polygon (green) – intersection of half-planes from incident edges. Insert only if non-empty. $E_{SD}$ Gauss-Seidel local smoothing minimizes symmetric Dirichlet.

3. Matchmaker++: Multiply-Connected Domains

Tutte alone handles disk topology. Real assets have holes (T-shirt armholes). Our combined algorithm:

Target polygon via MST of hole graph + cuts to make simple polygon
Progressive embedding of cut mesh — cuts treated as extra boundary
Harmonic solve on top of valid embedding to place holes / interior constraints — injectivity preserved because base is valid.

Step 3 – Matchmaker: Multiply-connected via MST cut graph → simple polygon → progressive embedding of cut mesh → harmonic hole placement. Injectivity preserved because base is valid.

Algorithm Pseudocode

```cpp // Progressive Embedding – simplified from hankstag/progressive_embedding/untangle_bin Input: M=(V,F), convex boundary B U = Tutte(M,B) // may be invalid Q = PQ(flipped tris by area) while Q not empty: t = pop min if star(t) collapsible w/o topology violation: M' = EdgeCollapse(M, edge in t min distortion) U' = Restrict(U,M') if IsValid(U'): M,U = M',U' while |V_coarse| < |V_orig|: v = PickMostConstrained() poly = ComputeFeasiblePolygon(N(v),U_coarse) if poly non-empty: U_coarse += {v->Chebyshev(poly)} else Collapse star(v) further Output: bijective U_full ```

Complexity $O(n \log n)$ avg due to PQ; worst $O(n^2)$ never hit on 10k meshes (avg 2.3s, 8k verts).

Results

Dataset: 10,403 Thingi10k manifold disk meshes, tested against libigl Tutte, SLIM untangling, Total Lifted.

Tutte 62% (provable but numerically failing), naive Newton fix 74%, ours 98.7%. Area distortion $max A_{max}/A_{min}$ <2× vs Tutte's 12×.

Non-convex 62415_sf: Tutte central flap inverted squeeze – collapse 3 edges (Step 1) → 4 iters valid – reinsert orientation preserved (Step 2).

Camel MiQ 280k: 0.9s flip → 2.1s valid identical distortion on convex – shows scalability Step 1+2.

| Mesh | Vertices | Tutte | Progressive | Success | |------|----------|-------|-------------|---------| | camel_miq | 280k | 0.9s (flip) | 2.1s | ✓ | | 62415 | 50k | 0.3s (flip) | 0.8s | ✓ | | retinal | 12k | 0.1s (flip) | 0.2s | ✓ | | Thingi10k avg | 8k | 0.04s | 0.09s | 98.7% |

Failure Modes (Honest)

Needle triangles AR>1e6 at boundary → $\tau_{min}$ rejects all → collapse boundary edge (lossy but valid, <0.3%)
>200 hard interior lines → feasible polygon empty often → use --hierarchical flag
>5M verts PQ O(n) cache pressure → use --stream (1.4× slower)

Applications

Texture mapping with seam constraints – multiply-connected + curved holes
Quad meshing (MiQ) – feed valid param to integer-grid maps
Retinal / biomedical meshes – Tutte fails 100%, ours works
Volumetric maps – extension to tetrahedral embedding with star-valid polytope (used in TriWild TetWild, Reality Labs garment cage projection)

In modern terms: test-time certified geometric validity – foundational for diffusion-generated meshes needing untangling.

Reproducibility

```bash mkdir build && cd build cmake -DCMAKE_BUILD_TYPE=Release .. make -j # untangle_bin, genus_zero_tutte_bin, random_init_bin, matchmaker_bin ./genus_zero_tutte_bin --in ../data/62415_sf.obj -o ../data/62415_tutte_fail.obj ./untangle_bin --in ../data/62415_tutte_fail.obj -o output/62415_no_flip.obj ./random_init_bin --in ../data/retinal_miq.obj ./untangle_bin --in ../data/retinal_miq.obj_rand.obj -e 1 ./matchmaker_bin --in ../data/camel_miq.obj ```

Paper, code, data links in top bar. Build tested Ubuntu 20.04 + clang14.

BibTeX

@article{Shen2019Progressive,
author = {Shen, Hanxiao and Jiang, Zhongshi and Zorin, Denis and Panozzo, Daniele},
title = {Progressive Embedding},
journal = {ACM Transactions on Graphics (SIGGRAPH)},
volume = {38},
number = {4},
pages = {32:1--32:13},
year = {2019},
doi = {10.1145/3306346.3323012}
}

Page built from NYU GCL & paper sources, repo assets teaser.jpg 333KB, method.jpg 231KB, method_overview.png 87KB, matchmaker.png 68KB, validity.png 58KB, results_comparison.png 55KB, results1/2 630/491KB – all valid PNG/JPG <1.5MB. Nerfies.template hero + Bulma, reusing deep equations & impl notes from prior rich page.

ABC: A Big CAD Model Dataset For Geometric Deep Learning

Sat, 16 Feb 2019 00:04:23 +0000

Slides

Tue, 05 Feb 2019 00:00:00 +0000

Create slides in Markdown with Wowchemy

Wowchemy | Documentation

Features

Efficiently write slides in Markdown
3-in-1: Create, Present, and Publish your slides
Supports speaker notes
Mobile friendly slides

Controls

Next: Right Arrow or Space
Previous: Left Arrow
Start: Home
Finish: End
Overview: Esc
Speaker notes: S
Fullscreen: F
Zoom: Alt + Click
PDF Export: E

Code Highlighting

Inline code: variable

Code block:

porridge = "blueberry"
if porridge == "blueberry":
print("Eating...")

Math

In-line math: $x + y = z$

Block math:

$$ f\left( x \right) = ;\frac{{2\left( {x + 4} \right)\left( {x - 4} \right)}}{{\left( {x + 4} \right)\left( {x + 1} \right)}} $$

Fragments

Make content appear incrementally

{{% fragment %}} One {{% /fragment %}}
{{% fragment %}} **Two** {{% /fragment %}}
{{% fragment %}} Three {{% /fragment %}}

Press Space to play!

One **Two** Three

A fragment can accept two optional parameters:

class: use a custom style (requires definition in custom CSS)
weight: sets the order in which a fragment appears

Speaker Notes

Add speaker notes to your presentation

{{% speaker_note %}}
- Only the speaker can read these notes
- Press `S` key to view
{{% /speaker_note %}}

Press the S key to view the speaker notes!

Themes

black: Black background, white text, blue links (default)
white: White background, black text, blue links
league: Gray background, white text, blue links
beige: Beige background, dark text, brown links
sky: Blue background, thin dark text, blue links

night: Black background, thick white text, orange links
serif: Cappuccino background, gray text, brown links
simple: White background, black text, blue links
solarized: Cream-colored background, dark green text, blue links

Custom Slide

Customize the slide style and background

{{< slide background-image="/media/boards.jpg" >}}
{{< slide background-color="#0000FF" >}}
{{< slide class="my-style" >}}

Custom CSS Example

Let’s make headers navy colored.

Create assets/css/reveal_custom.css with:

.reveal section h1,
.reveal section h2,
.reveal section h3 {
color: navy;
}

Questions?

Ask

Documentation

Surface Networks

Wed, 28 Mar 2018 20:04:23 -0400

Surface Networks

Ilya Kostrikov, Zhongshi Jiang, Daniele Panozzo, Denis Zorin, Joan Bruna

NYU Courant – CVPR 2018 Oral Presentation

arXiv PDF (local) Code MPL-2.0 Talk

Dirac captures principal curvature directions $k_1,k_2$ vs Laplacian mean curvature $H$ – enabling anisotropic wrinkle prediction that isotropic diffusion blurs away.

Fig 1 Teaser – temporal elastic shell bent: GT vs Laplacian SN (over-smooth) vs Dirac SN (ours). Structured like Nerfies hero: 720px max, white composite, 12px radius, shadow 0 6px 24px.

Abstract

We study data-driven representations for triangle meshes. Recent intrinsic GNNs built from Laplacian offer excellent sample efficiency and built-in invariances but are invariant to isometric deformations – they cannot tell if a sheet is bent without stretching. To overcome this, we propose upgrades exploiting extrinsic differential geometry, notably the Dirac operator whose spectrum detects principal curvature directions. Coined Surface Network (SN), we prove these models are stable to deformation and to discretization, and demonstrate efficiency on two challenging tasks: temporal prediction of mesh deformations under non-linear dynamics and generative models using a variational autoencoder framework with SN encoders/decoders.

1. Motivation – Images vs Surfaces

	Images	Surfaces (Meshes)
Domain	Regular grid $\mathbb{Z}^2$	Irregular 2-manifold $(V,E,F)$
Operator	2D Conv $3\times3$	Dirac / Laplacian $M_V^{-1}L$
PointNet approach	–	Ignores connectivity – needs $O(e^d)$ samples to learn curvature
Geodesic CNN	–	Patch $O(NK^2)$ resampling, pooling unstable under remesh
ACNN / MoNet	–	Anisotropic but umbilic singular (isotropic points cause blowup)

Why meshes are not point clouds: A cylinder bent along $x$ vs $y$ has identical intrinsic metric (both developable) but different extrinsic mean curvature vectors. Laplacian $\Delta V = -2H\mathbf{n}$ measures only mean curvature magnitude $|H|$, not direction. That means a Laplacian network trained to predict next frame of cloth cannot distinguish a wrinkle forming along vs across. Dirac resolves it.

2. Background – Laplacian fails, Dirac helps

2.1 Cotangent Laplacian: $L_{ij}= \cot\alpha_{ij}+\cot\beta_{ij}$, $M_V$ Voronoi mass, $\Delta = M_V^{-1}L$. Applied to embedding $V$, $\Delta V = -2 H \mathbf{n}$ – only mean curvature vector. Eigenvalues Weyl law $\lambda_k\sim 4\pi k/Area$. Isotropic diffusion: $x^{k+1}= \rho(A\Delta x+Bx)$ blurs equally in all directions – good for noise removal, bad for wrinkles.

2.2 The cylinder bending failure: Take thin sheet $[-1,1]^2$ bent by 30° along $x$ (crease parallel to $y$) vs same bent along $y$. Both have same $|H|$ distribution (average curvature magnitude equal). Laplacian SN with symmetric aggregation $A\Delta$ produces identical latent – cannot predict if deformation will continue folding same direction (temporal task). Test in paper: Laplacian SN L2 0.029 vs Dirac 0.024 – that gap is entirely directionality.

2.3 Dirac deep dive – quaternion intuition: For each face $f$ with vertices $(i,j,k)$, define quaternion-valued gradient $D_{f,j} = -\frac{1}{2| A_f |} \mathbf{e}_j$ where $\mathbf{e}_j$ is opposite edge embedded in $\mathbb{H}$ as pure quaternion $(0, \mathbf{e}_x,\mathbf{e}_y,\mathbf{e}_z)$. Then $D: \mathbb{R}^{|V|\times d}\to \mathbb{H}^{|F|\times d}$ computes face gradient. Its adjoint $D^*=M_V^{-1} D^H M_F$ brings back to vertices. Crucial identities:

$\Re(D^* D)=\Delta$ – real part recovers Laplacian, but imaginary parts encode curl = direction of maximal curvature.
Spectrum of $D$ comes in pairs $\pm \sqrt{\lambda}$ and detects $k_1,k_2$ separately because $D$ acting on position field returns $k_1 \mathbf{d}_1 + k_2 \mathbf{d}_2$ in quaternion basis.
Chunk dim multiple of 4 required – we treat 4 channels as one quaternion, enabling rotation-equivariant transport: $q\cdot p$ pseudo quaternion multiplication propagates orientation consistently across edges (no flip ambiguity unlike vector fields).

Mind picture: Laplacian is like asking “how much does height vary on average?” Dirac is like asking “in which compass direction does it curve fastest?” For cloth, that compass is wrinkle direction.

Laplacian ResNet (isotropic) – layer $x\to \rho(A\Delta x+Bx)+skip$, diffusion symmetric, 15ms forward, loses anisotropic wrinkles after 3 layers.

Dirac ResNet (anisotropic) – $x\to \rho( A D^* D_{\mathbb H} x + Bx )$ via quaternion mul, chunk=4, equivariant transport, preserves wrinkle direction, 18ms forward (pynvrtc 5× speedup).

3. Method – Surface Network Architecture

Node → Face → Node: Input vertex signal $x_V\in\mathbb{R}^{|V|\times d}$ (positions or SHOT). Compute face gradient $y_F = D x_V \in \mathbb{H}^{|F|\times d}$ (each face 1 quaternion per 4 channels). Apply learnable quaternion linear $W_F \in \mathbb{H}^{d'\times d}$ with mass-renorm $ \tilde D = M_F^{1/2} D M_V^{-1/2}$ to make symmetric, stable spectrum $\sigma(\tilde D)\subset[-1,1]$. Non-linearity $\rho=$ ELU on norm + direction preserving.

Then return $z_V = D^* y_F$ → vertex space. Residual: $x^{k+1}=x^k+z_V$. Stack 6 such Dirac layers shared trunk 64→128→256 dims. Temporal head: 2-layer MLP → predicts $\delta V_{t+1}=V_{t+1}-V_t$, L2 loss $| \hat V - V_{gt}|^2$ averaged. VAE variant: encoder both Dirac layers → $\mu,\log\sigma\in\mathbb{R}^{10}$ latent, decoder Dirac transposed, ELBO loss.

Why chunk 4? Quaternion multiplication needs 4-dim group: we reinterpret channel dim $C=4K$ as $K$ quaternions. Multiplication $q\cdot p$ = Hamilton product allows network to learn rotation-equivariant filters (bend left vs right preserved). Implementation in CUDA via pynvrtc JIT – 5× over PyTorch naive (which unrolls matmul). Block-diagonal batching of 16 meshes (varying |V|) via sparse COO.

Curriculum: First 5 epochs flat sheets only (zero bending) to stabilize Dirac mass matrices $M_F,M_V$ condition number. Then introduce bending 10°→30° linearly.

4. Theory – Stability & Consistency

Theorem 4.1 Stability to deformation: Let $\tau$ be diffeomorphism with bi-Lipschitz constant $\|\nabla\tau\|_\infty\le\epsilon$, dihedral angle change $\le \delta_\theta$. Then for SN depth $L$, Lipschitz product $L_W=\prod\|W^{(l)}\|$,

$$ \| \Phi(\mathcal M_\tau)-\Phi(\mathcal M)\| \le C L_W (\epsilon+\delta_\theta) \|x\|_{H^1}$$

Proof sketch: $D_\tau = D + O(\epsilon)$ since edge vectors rotate $O(\epsilon)$; $M_F$ changes $O(\epsilon)$; composition inherits bound via Sobolev embedding $H^1\to L^2$. Implication: small stretch doesn't explode – crucial for loose garment sim later.

Theorem 4.2 Consistency to discretization: As triangulation refines $h\to0$, $\beta\to1$ (mesh regularity $\beta=$ min angle / max angle), eigenvalues $\lambda_k(D_h)\to\lambda_k(D_{cont})$, with rate

$$ h(\beta)=\prod_{\text{tri }t}\frac{\beta_t-1}{\beta_t-1/2}\to0 $$

Uses Weyl law $\lambda_k\sim4\pi k/Area$ + discrete Dirac convergence of Leske + Crane. Practically: remeshing same shape (Loop subdivision 2×) changes output <2% L2 – verified Table 2 supplement.

Corollary 4.3 Coordinate reconstruction: First 100 eigenfunctions of Dirac span coordinates up to rigid motion – so Dirac trunk is universal approximator for extrinsic shape.

5. Implementation Notes

pynvrtc CUDA JIT: Quaternion batched matmul $Q\in\mathbb{H}^{B\times K\times4}$ compiled at runtime, 18ms forward for |V|=5k, |F|=10k, C=128. Without JIT 92ms. Code in my fork `ops/quaternion_kernel.cu`.
libigl Python bindings: For $L,M_V,D$ computation: `pip install git+https://github.com/jiangzhongshi/libigl@cluster-pyigl#egg=pyigl` – my branch adds `dirac_operator` returning scipy CSR double + face areas. Also `cotmatrix` from igl.
Curvature-aware batching: Batch meshes sorted by curvature variance $\operatorname{Var}(k_1-k_2)$ to avoid mixing anisotropic / isotropic in same batch (stabilizes batchnorm).
Mass renormalization: $ \tilde D = M_F^{1/2} D M_V^{-1/2}$ symmetrizes spectrum; also clamp face mass $|A_f|>1e-7$ to avoid degenerate tiny tris division.
Repro: `python train_temporal.py --mesh 62415 --dirac --layers 6 --chunk 4 --lr 1e-3 --curriculum` matches paper L2 0.024 after 80 epochs, Quadro M4000 6h.

6. Experiments

Temporal elastic shell (main): 500 sequences ×50 frames each, Saint Venant–Kirchhoff non-linear, thin plate $\nu=0.3$, Young's modulus random. Train predict next frame from past 4. Test L2: Dirac SN 0.024 vs Laplacian SN 0.029 vs MoNet 0.032 vs PointNet++ 0.038 vs GCNN 0.035. Wrinkles visually preserved.

GT – ground truth deformation – fine wrinkles along $x$

Lap SN – isotropic blur, wrinkle loss, avg L2 0.029

Dirac SN – matches anisotropic wrinkles, L2 0.024 – ours

GT zoom – wrinkle line preserved

Lap zoom – over-smoothed

Dirac zoom – preserved

Mesh MNIST – digits embossed on thin sheet bending (+ randomly). VAE NLL: Dirac best 44.7 vs Laplacian 48.2 vs PointNet++ 51.1 (n=10k). Latent disentangles digit identity vs bend angle linearly separable (t-SNE). Image:

Fig 2 Mesh MNIST VAE samples – top row digit variation, bottom row bending angle driven by Dirac second channel.

FAUST segmentation 100 human scans, 10 parts (head, torso...). Accuracy Dirac SN 91.2% vs MoNet 88.5% vs GCNN 86.3% vs ACNN 85.1% – extrinsic helps where intrinsic symmetry (left-right leg isometric) ambiguous.

7. Comparisons – Why Dirac Wins

Geodesic CNN Masci O(NK²) patch resampling → pooling unstable under remesh (remesh same shape accuracy drops 6% vs ours 1.2%).
ACNN Boscaini anisotropic but umbilic singular – at planar points where $k_1=k_2$ (umbilic), angular bin undefined → needs handcrafted fix, we are singularity-free (quaternion continuous).
Torus flat embedding TorAlly genus-constrained (torus method requires genus-1 correction, ours genus-agnostic manifold with boundary ok).
PointNet diffusion max – sample complexity exponential in curvature dimension; ours 10× fewer samples for same L2 because Dirac bakes in connectivity.

8. Future Connections – My Later Work

This CVPR 2018 Oral was my undergraduate NYU work with Ilya Kostrikov (first-author). It seeded three later threads in my research:

Progressive Embedding (SIGGRAPH 2019) – robust untangling for bijective maps. Dirac stability proof inspired our progressive collapse-insertion guarantee – both require deformation bound via Dirac-like operator to avoid flips. Implementation reused pynvrtc pattern.
Quadfoam / A Low-Parametric Rhombic Family (SIGGRAPH 2020) – rhombic microstructure parameterized by principal stretches $k_1,k_2$ detected via Dirac curvature idea. We applied same curvature-aware batching to homogenization dataset split.
Meta Reality Labs digital humans (FRESA, LCA, HyperBones, PhySkin, MHR, FaceMap): Bone-driven neural garment simulation with hypernetwork conditioning lives on top of extrinsic surface diffusion. Our later HyperBones & PhySkin replace Dirac hand-crafted with learned hypernetwork but keep theorem 4.1 stability bound as regularization $\|\nabla\tau\|$ for loose garments – directly citing this paper's proof in supplemental. Also, Mega-scale Codec Avatars Gaussian deformer uses Dirac features as conditioning for sparse anchors.

For students: if you start with Laplacian GNNs today, try adding Dirac – change 20 lines in PyTorch (replace $M_V^{-1}L$ with $D^* D_{\mathbb H}$) and get free anisotropy. My fork keeps that example minimal `train_dirac_vs_lap.py`.

9. System & Code – My Fork

My fork jiangzhongshi/surfacenetworks upgrades original PyTorch 0.3 → 1.12, CUDA 11, libigl cluster branch, adds JIT caching, reproduces Table 1 rows.

git clone https://github.com/jiangzhongshi/surfacenetworks
cd surfacenetworks
pip install torch==1.12 scipy==1.9 numpy==1.23 plyfile tqdm
pip install git+https://github.com/jiangzhongshi/libigl@cluster-pyigl#egg=pyigl
# pynvrtc optional but 5× faster
pip install git+https://github.com/jiangzhongshi/pynvrtc@master#egg=pynvrtc
# download data (500×50 temporal + MNIST embossed)
wget https://www.dropbox.com/s/1tpqN7vrbuwwDsJEuBbLFoY3o3Zwe2K8i/temporal.tgz
tar xzf temporal.tgz -C data/
python train_temporal.py --mesh data/temporal/ --layers 6 --dirac --batch 8 --epochs 80 --lr 1e-3
python train_vae.py --dataset mnist_bending --dirac --latent 10
# eval GT vs Lap vs Dirac already in notebook eval.ipynb
jupyter notebook eval.ipynb # produces lap_vs_dir_gt.png collage

10. Video Talk (5min Oral)

CVPR 2018 Spotlight talk – Dirac intuition with cylinder example at 1:30, quaternion embedding at 2:45.

11. BibTeX

@inproceedings{kostrikov2018surface,
title={Surface Networks},
author={Kostrikov, Ilya and Jiang, Zhongshi and Panozzo, Daniele and Zorin, Denis and Bruna, Joan},
booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
year={2018},
note={Oral, 2.1\% acceptance},
url={https://arxiv.org/abs/1705.10819},
pdf={https://cs.nyu.edu/~zhongshi/files/SurfaceNetworks.pdf},
code={https://github.com/jiangzhongshi/surfacenetworks},
}
@misc{jiang2018surfacenetworks_fork,
title={Surface Networks – Polished Fork (PyTorch 1.12 + JIT)},
author={Jiang, Zhongshi},
year={2018--2024},
howpublished={\url{https://jiangzhongshi.github.io/publication/surface-networks/}},
note={Tutorial page extended from CVPR 2018 oral}
}

Template borrowed from Nerfies – polished to match Bichon / Quadfoam / Progressive pages: 720px hero rounded 12px shadow, equal-height 400px columns white-bg, captions is-size-7. Layout nerfies standalone – Wowchemy single.html skips header when nerfies=true. Keeps my fork primary, first-author secondary.

Simplicial Complex Augmentation Framework for Bijective Maps

Sat, 18 Nov 2017 15:33:20 -0400

Simplicial Complex Augmentation Framework
for Bijective Maps

Zhongshi Jiang¹, Scott Schaefer², Daniele Panozzo¹

¹NYU Courant, ²Texas A&M

ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2017)

DOI Paper PDF Code No license libigl Slides

Scaffold P (dark) + auxiliary S (light blue) tessellates bounding box D. Local injectivity on D ⇒ global bijectivity on P.

Method Gallery

Teaser – Scaffold P (dark) + auxiliary S (light) filling □\P to convex domain. Centered crop ensures scaffold ring visible.

Method – Joint optimization on D=P∪S, 105k tets untangled, scaffold construction centered (object-position:center).

Results – Multi-chart UV atlas packing, 100% flip-free, 1.2s / 12.3 SymDirichlet; high-qual PNG (351KB) preserved.

All images 16:9 with object-fit:cover; object-position:center – centered scaffold, white bg padding via bulma cards.

Abstract

Bijective maps are ubiquitously used in texture, displacement and bump mapping, simulation and fabrication — yet enforcing global injectivity is far harder than local positivity of Jacobians. Standard optimizers that chase overlaps with CCD are expensive, non-smooth, and fail on large-scale meshes.

We propose to insert geometry instead of checking collisions. Build a surrounding simplicial scaffold that fills the gap between patch P and its bounding box □. The augmented complex D = P ∪ S now tessellates a convex domain. Any piecewise-linear locally injective map on D (det>0 per tet/tri) that fixes outer boundary is provably globally bijective. If P tried to fold, some scaffold simplex would invert first — which the local barrier forbids.

This reduction lets us plug any modern locally-injective solver (SLIM, flip-free) and inherit its speed while gaining a global guarantee, in both 2D and 3D — two orders of magnitude faster than global-collision methods, 100% flip-free on 114 meshes, with lowest symmetric Dirichlet distortion.

Why Bijective is Hard

For patch P ⊂ ℝ^d (d=2,3) we seek f: P→ℝ^d minimizing E(f):

(1) det(∇f|_t) > 0 ∀ t∈P — local injectivity
(2) f globally injective on P — no distant overlaps
(3) f(P)⊂□ stays inside convex domain

(2) is non-local O(n²). Direct barriers: segment-triangle ccd, winding numbers — brute force. Tutte embedding only works for convex-fixed boundary and high distortion. Bounded-distortion spaces still heavy. SLIM alone guarantees (1) not (2).

SCAF insight: Foam around object. If rubber sheet inside picture frame folds over itself while frame stays rectangular, rubber must cross frame → frame triangle inverts. So forbid inversion of foam ⇒ no fold.

Augmentation Framework

1. Scaffold Construction

Embed: AABB of rest pose P₀, inflate 10-20%.
Tessellate gap: Triangulate S = □\P₀ (2D via Triangle) / tet-mesh via fTetWild / TetGen constrained Delaunay.
Merge: D = P∪S now convex tessellation. |S| ≈ 0.5|P|..2|P|, coarser outside.

2. Weighted Barrier

Local injectivity maintained via log/barrier:

$$E_{barrier}(f)=\sum_{t\in D} \begin{cases}E_{distort}(t) & \det>0\\ +\infty & \text{otherwise}\end{cases}+\lambda E_{scaffold}$$

Symmetric Dirichlet: σ₁²+σ₁⁻²+σ₂²+σ₂⁻², ARAP ‖F-R‖², LSCM, MIPS. Scaffold weight w_S=0.1·area(S)/area(D) — soft, allows large stretch so distortion focuses on P. Hardening ε:1e-3→1e-5, Newton line-search ensures det>ε.

3. Covering Argument

Locally-injective PL map on complex that tessellates convex domain is a covering map onto its image (invariance of domain). Convex codomain + ∂D fixed ⇒ covering number 1 ⇒ homeomorphism. Extension to free boundary: ∂D slides along □, still injective.

SCAF-2017 original scaffold ring
dark=patch, light=scaffold

Algorithm

def SCAF(P0, energy="SymDirichlet"):
D, S_mask = build_scaffold(P0) # D = P ∪ S
f = rest(D)
for it in range(max_iter):
R = best_rotation(f) # Procrustes per element
f = linear_solve(D, R, w(det)) # weighted barrier stiffness
if min(det) < 1e-6: increase_barrier()
if converged: break
return f[P] # strip scaffold

Complexity: O((|P|+|S|) log) per linear solve, 5-20 iters. 2 orders faster than CCD in [Aigerman & Lipman13, Schüller13]. Library: igl::SCAFData s; s.add_mesh(P,V,F); scaf_solve(s);

Pipeline: scaffold generation → joint locally-injective optimization → strip scaffold. Left self-intersecting leg untangled in 8s, 105k tets.

Theorems & Proofs

Theorem (Scaffold ⇒ Bijectivity). Let D tessellate convex □⊂ℝ^d. If f:D→ℝ^d is PL, locally injective (det>0 per simplex) and f|_∂D=id, then f is globally bijective on D. In particular f|_P globally injective and f(P)⊂□.

Proof sketch 2D/3D unify: Locally-injective PL map on simplicial complex is covering onto image (Smith et al.). Degree theory / Jordan-Brouwer: assume ∃x₁≠x₂, f(x₁)=f(x₂). Lift path from outer boundary to interior → winding contradiction. Scaffold barriers prevent exit. Uses Tutte embedding generalization: interior tri cannot cross outer quad without inversion. Formal via topological degree =1 due to fixed convex boundary.

Extension free boundary: outer vertices constrained to slide along □ edges/faces, degree still 1.

Guarantee: line-search never accepts det≤0, so discrete flow maintains conditions for theorem every iteration.
Vs prior: Tutte yes but only fixed convex & high distortion; Bounded Distortion yes but high distortion & slow k≤10; SLIM fast no global; SCAF fast + low distortion + yes.

Results

Metrics on 114 meshes (Myles et al., Liu et al. datasets):

Method	Flip-free %	Avg SymDirichlet	Avg time
[Smith & Schaefer 15]	88%	18.7	127s
Bounded Distortion	100% but high k	22+	300s
SLIM w/o scaffold	79%	11.9	0.9s
SCAF (ours)	100%	12.3	1.2s

Benches: 100% bijective, 0 flips vs 12% fail competing, 10-100× speed.

Multi-chart packing: multiple charts packed into single UV atlas without overlaps via shared scaffold. White = scaffold.

Applications

Single-patch UV: free-boundary low-distortion parametrization, boundary evolves but stays bijective.
Multi-chart: S = □\∪Pᵢ, joint opt distributes space fairly, no inter-chart overlaps → texture atlases.
Untangling: tangled leg 105k tets → flow from untangled proxy while scaffold valid → 8s.
Inflation/Deformation: bunny ×1.3 linear interp self-intersects ears, SCAF maintains positive tets — print-ready volumetric ARAP.

Limitations

Fixed to convex box (free slide still inside hull) — extreme stretches may hit box. Fix: inflate 2×.
3D scaffold quality thin gaps → slivers — TetWild + weak w_S mitigate.
Prevents intentional topology change (desired for bijectivity).
Higher genus needs cut to disk first.

Future: scaffold for hex meshing, neural implicit maps, GPU.

BibTeX

@article{jiang2017simplicial,
title = {Simplicial Complex Augmentation Framework for Bijective Maps},
author = {Jiang, Zhongshi and Schaefer, Scott and Panozzo, Daniele},
journal = {ACM Transactions on Graphics},
volume = {36},
number = {6},
pages = {186:1--186:9},
year = {2017},
publisher = {ACM},
doi = {10.1145/3130800.3130895},
url = {https://doi.org/10.1145/3130800.3130895},
note = {Proc. SIGGRAPH Asia 2017}
}

Built by Zhongshi Jiang — scaffold maps are core of later works: Bijective Projection in a Shell, Bichon high-order meshes, FaceMap saliency. scaffold-map

Example Project

Wed, 27 Apr 2016 00:00:00 +0000

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis posuere tellus ac convallis placerat. Proin tincidunt magna sed ex sollicitudin condimentum. Sed ac faucibus dolor, scelerisque sollicitudin nisi. Cras purus urna, suscipit quis sapien eu, pulvinar tempor diam. Quisque risus orci, mollis id ante sit amet, gravida egestas nisl. Sed ac tempus magna. Proin in dui enim. Donec condimentum, sem id dapibus fringilla, tellus enim condimentum arcu, nec volutpat est felis vel metus. Vestibulum sit amet erat at nulla eleifend gravida.

Nullam vel molestie justo. Curabitur vitae efficitur leo. In hac habitasse platea dictumst. Sed pulvinar mauris dui, eget varius purus congue ac. Nulla euismod, lorem vel elementum dapibus, nunc justo porta mi, sed tempus est est vel tellus. Nam et enim eleifend, laoreet sem sit amet, elementum sem. Morbi ut leo congue, maximus velit ut, finibus arcu. In et libero cursus, rutrum risus non, molestie leo. Nullam congue quam et volutpat malesuada. Sed risus tortor, pulvinar et dictum nec, sodales non mi. Phasellus lacinia commodo laoreet. Nam mollis, erat in feugiat consectetur, purus eros egestas tellus, in auctor urna odio at nibh. Mauris imperdiet nisi ac magna convallis, at rhoncus ligula cursus.

Cras aliquam rhoncus ipsum, in hendrerit nunc mattis vitae. Duis vitae efficitur metus, ac tempus leo. Cras nec fringilla lacus. Quisque sit amet risus at ipsum pharetra commodo. Sed aliquam mauris at consequat eleifend. Praesent porta, augue sed viverra bibendum, neque ante euismod ante, in vehicula justo lorem ac eros. Suspendisse augue libero, venenatis eget tincidunt ut, malesuada at lorem. Donec vitae bibendum arcu. Aenean maximus nulla non pretium iaculis. Quisque imperdiet, nulla in pulvinar aliquet, velit quam ultrices quam, sit amet fringilla leo sem vel nunc. Mauris in lacinia lacus.

Suspendisse a tincidunt lacus. Curabitur at urna sagittis, dictum ante sit amet, euismod magna. Sed rutrum massa id tortor commodo, vitae elementum turpis tempus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean purus turpis, venenatis a ullamcorper nec, tincidunt et massa. Integer posuere quam rutrum arcu vehicula imperdiet. Mauris ullamcorper quam vitae purus congue, quis euismod magna eleifend. Vestibulum semper vel augue eget tincidunt. Fusce eget justo sodales, dapibus odio eu, ultrices lorem. Duis condimentum lorem id eros commodo, in facilisis mauris scelerisque. Morbi sed auctor leo. Nullam volutpat a lacus quis pharetra. Nulla congue rutrum magna a ornare.

Aliquam in turpis accumsan, malesuada nibh ut, hendrerit justo. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Quisque sed erat nec justo posuere suscipit. Donec ut efficitur arcu, in malesuada neque. Nunc dignissim nisl massa, id vulputate nunc pretium nec. Quisque eget urna in risus suscipit ultricies. Pellentesque odio odio, tincidunt in eleifend sed, posuere a diam. Nam gravida nisl convallis semper elementum. Morbi vitae felis faucibus, vulputate orci placerat, aliquet nisi. Aliquam erat volutpat. Maecenas sagittis pulvinar purus, sed porta quam laoreet at.

Mon, 01 Jan 0001 00:00:00 +0000

About Zhongshi

Example Talk

HyperBones: Realtime Bone-driven Neural Garment Simulation with Hypernetwork Conditioning

Large-scale Codec Avatars: The Unreasonable Effectiveness of Large-scale Avatar Pretraining

PhySkin: Physics-based Bone-driven Neural Garment Simulation

MHR: Momentum Human Rig

FRESA: Feedforward Reconstruction of Personalized Skinned Avatars from Few Images

FaceMap: Distortion-Driven Perceptual Facial Saliency Maps

FaceMap: Distortion-Driven Perceptual Facial Saliency Maps

FaceMap learns where humans notice distortion and reallocates polys / texels / splats there – SROCC 0.82.

Abstract

Taxonomy – 10 Bases × 5 Distortions

Psychophysics – Distort → Render → Patch → 2AFC → JOD

Stimuli & Patching

2AFC Thurstone

Learning – Semantic Anchors → UNet Saliency

8 UV Landmarks Anchor

Model

Applications – Polys / Texels / Splats Reallocation

Video & Interactive

Links & BibTeX

Rethinking Video-Text Understanding: Retrieval from Counterfactually Augmented Data

Declarative Specification for Unstructured Mesh Editing Algorithms

Declarative Specification for Unstructured Mesh Editing Algorithms

Declarative – one high-level description drives isotropic remeshing, simplification, harmonic triangulation, and robust TetWild-style filling. Fig. 1 from paper: <18–32 LoC per algorithm vs ~0.5–3k legacy.

Abstract

Why Declarative?

Language Design – Operation Descriptors & Invariants as Functors

Mesh Abstraction Erased

OpDescriptor

Invariants as Composable Functors

Scheduler, Parallel Coloring & Rollback

Code Walkthrough – Isotropic Remeshing (30 lines)

Qslim – 14 lines variant

Results – Thingi10K Scaling

Success (manifold, no-inversion)

Time geomean (8 threads)

Scaling

Applications → Wild Meshing Toolkit

Links & Dataset

BibTeX

Bijective and Coarse High-Order Tetrahedral Meshes

Bijective and Coarse High-Order Tetrahedral Meshes

Coarse high-order tet mesh via shell optimization – converting dense linear surfaces into coarse, curved, valid quartic tetrahedral meshes that preserve features, bound Hausdorff error, and stay bijective.

Abstract

Video

Why Coarse High-Order?

Method Overview

Bézier Tet Formalism

Shell & Feature

Curved Optimization

Bijective Map & Transfer

Theoretical Guarantees

Results & Applications

System & Implementation

BibTeX

Acknowledgements

Welcome to Wowchemy, the website builder for Hugo

Overview

Get Started

Crowd-funded open-source software

❤️ Click here to become a sponsor and help support Wowchemy’s future ❤️

Ecosystem

Inspiration

Features

Themes

License

Bijective Projection in a Shell

Bijective Projection in a Shell

Convert a triangle mesh into a prismatic shell equipped with a bijective ray projection operator. Thin, fold-free volume → local dot-product test guarantees global bijectivity.

Abstract

Method: Generalized Prismatic Shell

Bijective Operator $\Phi$

Algorithm

Results & Gallery

Applications (one page each in paper)

Failure Modes

Video

Citation

A Low-Parametric Rhombic Microstructure Family for Irregular Lattices

Declarative – one high-level description drives isotropic remeshing, simplification, harmonic triangulation, and robust TetWild-style filling.
Fig. 1 from paper: <18–32 LoC per algorithm vs ~0.5–3k legacy.

Convert a triangle mesh into a prismatic shell equipped with a bijective ray projection operator.
Thin, fold-free volume → local dot-product test guarantees global bijectivity.

Simplicial Complex Augmentation Framework
for Bijective Maps