u/ElectricalRate3050

To put it simply for those who find the math a bit dense:

For years, the 3D industry has had incredible magnifying glasses (algorithms like Functional Maps and ZoomOut). They have insane resolution and can match tiny skin pores between two models.

The problem? If you point a magnifying glass at the wrong spot on a table, you see nothing. These methods were "blind" at the start—they often got lost, flipped left for right, or got stuck in "local minima" because they didn't have a map of the whole object.

HST is the "Map and Compass":

• HST doesn't care about the tiny pores yet. It looks at the internal volume to understand the global structure.
• It creates a stable intermediate state—a perfect "bridge" between two shapes.
• It then hands this "bridge" over to the magnifying glasses (FM/ZoomOut).

The Result: Before, you had to manually guide the "glass" or pray the random start would work. Now, HST solves the global orientation automatically, and the other methods just do the fine-tuning.

By putting the whole pipeline on the GPU, we turned a 2.5-hour "guessing game" into a 13-minute automated certainty. I’ve finally completed the puzzle by adding the stabilization layer that was missing for decades.

https://orcid.org/0009-0003-9680-3333

https://zenodo.org/records/20074328

https://github.com/sel8888/harmonic-shape-transform-2026-koncept

¨Hi everyone,

I've been working on a project that tackles the "bad initialization" problem in spectral shape matching (Functional Maps, ZoomOut). Most existing implementations are surface-only and CPU-based, which often leads to local minima or symmetry-breaking.

I developed HST Dual, a framework that uses a volumetric Laplace-Beltrami operator to stabilize global initialization.

Key technical bits:

• The Pipeline: Volumetric LB Eigenfunctions → HST Global Init → GPU Functional Maps → GPU ZoomOut.
• Performance: I managed to cut down the full FAUST benchmark (99 pairs) from 142 minutes to 13 minutes on an NVIDIA GPU using a Python/CUDA backend.
• Accuracy: Achieved 99/99 accuracy on standard datasets where surface-only methods often flip or fail.
• Implementation: It's all in Python (using CuPy/Numba for kernels) and designed to be accessible for Blender integration.

I'm quite happy with the 11x speedup, especially keeping the whole pipeline in GPU memory to avoid bus overhead.

The code is open-source (GPLv3). I’d love to hear your thoughts on the volumetric approach or any ideas on further GPU optimizations!

https://orcid.org/0009-0003-9680-3333

https://zenodo.org/records/20074328

https://github.com/sel8888/harmonic-shape-transform-2026-koncept

https://preview.redd.it/v84ijw6b5jzg1.jpg?width=2044&format=pjpg&auto=webp&s=f3ebb59472bfaeb7949c3a8597d1f6757c0bad44

I formalized a shape mapping framework based on the observation

that every Riemannian manifold has a natural scalar fingerprint

through its first Laplace-Beltrami eigenfunction —

what I call its harmonic note.

The mapping: for shapes Ω_A, Ω_B with normalized eigenfunctions

φ̃_A, φ̃_B, map x ∈ Ω_A to argmin_{y ∈ Ω_B} |φ̃_B(y) − φ̃_A(x)|.

Empirical results on FAUST (99 pairs, 6890 vertices):

- Mean normalized geodesic error: 0.129

- Stable for connected manifolds genus 0→2

- Robust under noise σ ≤ 0.2 of shape radius

Relationship to Functional Maps and ZoomOut discussed

in the preprint. Feedback from Prof. Solomon (MIT)

helped position the work correctly.

GitHub: github.com/sel8888/harmonic-shape-transform-2026-koncept

arXiv preprint pending.

https://preview.redd.it/wko0v4gp4jzg1.png?width=2683&format=png&auto=webp&s=7ad46d84ce9f25e54b7b9df80605b86f3624ac66

Built a Blender addon that maps any two 3D shapes to each other

without manual landmarks, rigging, or shared topology.

The idea: every shape has a harmonic note — its first

Laplace-Beltrami eigenfunction normalized to [0,1].

Map points with the same note value. That's it.

Results on FAUST (scanned human bodies, 99 pairs):

- Mean geodesic error: 0.129

- Time per pair: 0.805s

- Wins vs ZoomOut: 67/99

Works on sphere → torus, male → female body,

double torus (genus 2) — all without pre-alignment.

Blender addon + Python library + raw benchmark CSV:

github.com/sel8888/harmonic-shape-transform-2026-koncept

I'm an independent researcher. Over the past 5 days I built

Harmonic Shape Transform (HST) — a shape correspondence method

based on a single normalized Laplace-Beltrami eigenfunction

(harmonic note).

Full FAUST benchmark (99 pairs, fully deterministic):

| Method | Mean geo error | Time | Wins |

|-----------------|---------------|---------|-------|

| HST Note | 0.129 | 0.805s | 67/99 |

| HST → ZoomOut | 0.193 | 43.6s | 32/99 |

| Random → ZoomOut| 0.352 | 42.8s | 0/99 |

Key finding: Random → ZoomOut never wins on any pair.

HST as ZoomOut initialization improves it by 42.3% on average.

No training. No GPU. No pre-alignment. One eigenfunction.

GitHub + raw CSV: github.com/sel8888/harmonic-shape-transform-2026-koncept

arXiv preprint pending endorsement.

Feedback from Prof. Justin Solomon (MIT) pointed me to

ZoomOut and One Point Isometric Matching — both included

in related work.