GenSP: Consistent Spherical Parameterization via Learning Shape Generative Models¶

Conference: ECCV 2026
arXiv: 2607.00492
Code: None
Area: 3D Vision
Keywords: Spherical Parameterization, Mesh Generative Models, Surface Consistency, Neural Deformation, Geometry Processing

TL;DR¶

GenSP proposes a data-driven method to learn a neural generative model that continuously deforms a unit sphere into arbitrary genus-0 shapes, thereby obtaining cross-shape consistent and low-distortion spherical parameterization via inverse mapping. On ShapeNet, it improves isometric distortion by over 14× and consistency by over 3.6× compared to existing methods.

Background & Motivation¶

Spherical parameterization is one of the fundamental problems in geometry processing: given a closed genus-0 triangular mesh surface, the goal is to compute a bijective mapping from the surface to a unit sphere. Once this mapping is established, downstream tasks such as texture transfer, shape matching, and geometric analysis gain a unified "coordinate system" where all shapes can be aligned on the sphere. Existing solutions roughly fall into two categories: shape-by-shape independent optimization methods (e.g., SMAT, AHSP, ARAP), which can yield low-distortion parameterizations for each individual shape but ignore cross-shape correspondences—for instance, running independent optimization twice on two geometrically similar chairs in different poses yields completely different spherical mappings, causing severe misalignment when applying textures; and geometric flow-based methods (e.g., CMCF), which can achieve a degree of consistency by progressively deforming the shape to a sphere, but the flow process itself introduces massive local distortions in thin structures and high-frequency regions, with isometric factors varying up to thousands of times.

The key challenge of these two categories lies in their fundamental contradiction: consistency requires global coordination, whereas distortion control is locally shape-preserving, which naturally pits them against each other in an independent optimization framework. If all shapes can be optimized in a unified framework—conceptually by learning a mapping from the "shape space" to the "spherical parameterization" rather than solving for each shape independently—it is possible to simultaneously achieve both low distortion and high consistency. However, doing so faces three major challenges: first, the representation of this mapping—mesh generative models suffer from extremely poor triangular face quality due to drastic changes in conformal factors during parameterization; second, the sphere itself usually does not lie within the subspace of input shapes, making it difficult for generative models to smoothly deform a sphere into arbitrary shapes; third, the initialization of correspondences between the sphere and complex shapes—direct deformation from a sphere to a highly distorted shape easily falls into local optima.

The key insight of this paper is that rather than computing parameterization for each shape independently, one can learn a neural generative model from the sphere to each shape, and then define the parameterization as the inverse mapping of this generative model. Core Idea: Train a continuous neural deformation model \(g^\theta(z, p)\) that takes a shape latent code \(z\) and a spherical sample point \(p\) as inputs and outputs the corresponding surface point on the target shape. By introducing "bridging shapes" via data augmentation, the sphere is naturally embedded into the training space. Then, using a minimum spanning tree path in the latent space, the correspondence between the sphere and complex shapes is decomposed into a series of progressive registrations. Finally, consistent cross-shape spherical parameterization is obtained via the inverse mapping.

Method¶

Overall Architecture¶

GenSP's four-stage pipeline breaks down the difficult problem of "computing correspondences from a single sphere to all shapes" into highly manageable sub-tasks. Stage I utilizes an off-the-shelf geometric flow method (CMCF) to deform each input shape onto a sphere and samples intermediate shapes along the deformation trajectories to augment the training set, ensuring that the sphere \(S_0\) indeed resides in the shape space fittable by the generative model. Stage II learns an implicit shape generator \(f^\phi\) and a point cloud encoder \(e^\gamma\) on this augmented dataset: \(f^\phi\) is a neural network with SDF decoding that outputs a signed distance field for each shape, while the encoder maps shapes into a 256-dimensional latent space and encourages latent codes of similar shapes to be close via regularization. Stage III constructs a minimum spanning tree in the latent space rooted at the sphere \(S_0\), generates intermediate interpolated shapes using \(f^\phi\) along each edge of the tree, and propagates correspondences step-by-step from \(S_0\) to each target shape via non-rigid registration, thus decomposing a large deformation into a chain of multiple small deformations. Stage IV uses these initial correspondences to initialize an explicit mesh generator \(g^\theta\) (which takes latent codes and spherical point coordinates as input and outputs surface point positions) and performs joint fine-tuning with isometric/conformal regularization loss at the Jacobian level, eventually yielding high-quality, low-distortion, and consistent spherical parameterizations.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Input Shape Set<br/>{S1, ..., SN}"] --> B["Stage I: Data Augmentation<br/>CMCF deformation → Sample bridging shapes<br/>Augment to 24N shapes"]
    B --> C["Stage II: Implicit Generative Model<br/>Learn encoder e^γ + implicit decoder f^ϕ<br/>SDF reconstruction + latent regularization + deformation regularization"]
    C --> D["Stage III: Correspondence Propagation<br/>Latent space minimum spanning tree (rooted at S0)<br/>Cascade registration along tree edges"]
    D --> E["Stage IV: Joint Fine-tuning of Mesh Generator<br/>g^θ(z, ·): Sphere → Surface<br/>SDF reconstruction loss + Jacobian conformal/isometric regularization"]
    E --> F["Output: Consistent Spherical Parameterization<br/>Inverse mapping m_i = (g^θ(z_i, ·))^{-1}"]

Key Designs¶

1. Data Augmentation: Bridging the Gap between Sphere and Input Shapes with Bridging Shapes

The fundamental reason why learning the inverse mapping of spherical parameterization is challenging is that the sphere \(S_0\) usually does not lie within the data subspace of input shapes—for instance, a shape space of cats or chairs does not contain a perfect spherical manifold. If the sphere is abruptly placed outside this subspace, the generative model will either fail to converge or generate unrealistic interpolations. GenSP's solution is straightforward: it runs the CMCF geometric flow on each input shape \(S_i\) to progressively deform it into a sphere, sampling intermediate shapes along the deformation trajectory to be added to the training set. Specifically, CMCF has a key hyperparameter—the step size \(m\), whose optimal value varies across shapes. GenSP defines a scoring function \(s(m, S_i)\) to evaluate the parameterization quality for each \(m\) (combining Hausdorff distance and cumulative physical deformation), and only accepts intermediate shapes from the trajectory when the score is lower than a threshold \(2\delta\), eventually augmenting the dataset to \(24N\) shapes. This step might seem simple, but it is the foundation of the entire pipeline: only with bridging shapes can the subsequent implicit generator learn a smooth path from the sphere to any shape, otherwise the model will collapse (variants without data augmentation in the ablation study show massive performance drops across all metrics).

2. Implicit Generative Model + Reduced Deformation Regularization: Geometrically Rational Latent Space Interpolation

Stage II requires concurrently training an encoder \(e^\gamma\) and an implicit shape decoder \(f^\phi\). The encoder uses PointNet++ to map shapes into 256-dimensional latent codes, and applies an \(\ell_1\) sparse regularization to force latent codes of similar shapes to be close; the decoder is a 10-layer MLP (with residual connections) that outputs SDF values. If only SDF reconstruction is performed, the intermediate shapes generated by \(f^\phi\) when interpolating between two close shape latent codes are often geometrically unreasonable—a classic issue of linear interpolation in the latent spaces of implicit models. GenSP improves upon the regularization concept of GenCorres with two key changes: first, it introduces a reduced deformation model (compressing 2,000 mesh vertices to 200 deformation nodes via Farthest Point Sampling), dramatically lowering the computational overhead of regularizations; second, instead of directly minimizing the absolute deformation energy \(d^\top L d\), it minimizes the relative deformation ratio \(d^\top L d / \|d\|^2\), because when the latent space distribution is irregular, absolute displacement cannot accurately reflect the true deformation quality. The integration of this relative ratio makes the regularization term scale-insensitive, enforcing plausible deformation of intermediate shapes regardless of whether the latent codes are sparsely or densely distributed.

3. Minimum Spanning Tree Paths: Decomposing Large Deformations into Registrable Small Steps

The most straightforward way to obtain initial correspondences is to perform linear interpolation in the latent space between the sphere and \(S_i\) using \(f^\phi\), followed by step-by-step registration. However, experiments show that when the difference between \(S_0\) and \(S_i\) is too large, the linear-interpolated intermediate shapes are of extremely poor quality (with highly unrealistic cross-sectional distortions), causing registration to fail. GenSP's insight is: instead of generating unreliable artificial intermediate shapes, it is better to leverage real-existing training shapes as stepping stones for registration. Concretely, a minimum spanning tree is constructed in the latent space of the augmented dataset, rooted at \(S_0\) (sphere) with Euclidean distances of latent codes as edge weights. The path from the root to each target shape passes through a series of real shapes (or their neighborhoods) that already exist in the training set. When propagating correspondences along tree edges, \(f^\phi\) is used to interpolate \(n=5\) intermediate shapes between the latent codes of two real shapes, followed by non-rigid registration to propagate the mesh connectivity step-by-step. Finally, a "stitching" operation (remeshing using overlapping shapes from adjacent mesh segments) bridges and concatenates all path segments into a complete correspondence from \(S_0\) to the target shape.

4. Mesh Generator's Jacobian Regularization: Co-constraining Isometry and Conformity in the Continuous Domain

The core of the fourth stage is the fine-tuning of the mesh generator \(g^\theta(z, p)\). \(g^\theta\) is a continuous function (taking \(\mathbb{R}^3\) positions and latent codes as inputs and outputting \(\mathbb{R}^3\) surface points). Its Jacobian \(J_p^\theta(z, p) = \partial g^\theta / \partial p \in \mathbb{R}^{3 \times 2}\) describes how differential changes on the sphere's tangent plane map to changes on the surface. If the mapping is isometric, \(J_p^\top J_p = I_2\); if it is conformal, \(J_p^\top J_p\) is a scalar matrix. GenSP encodes these two constraints into a single regularization loss: \(r(A) = \beta\|A - I\|^2 + \|A - \frac{\langle A,I\rangle}{2} I\|^2\), where the first term penalizes non-isometry and the second term penalizes non-conformality (with \(\beta=0.01\) indicating a lower weight for isometry, as the primary objective is a low-distortion conformal mapping). This Jacobian is computed automatically via PyTorch autograd to regularize directly in the continuous domain, fundamentally preventing triangular face quality degradation caused by mesh discretization. Compared to solely using the \(\ell_2\) loss during initialization, the Jacobian regularization significantly improves the smoothness and shape-preservation of the parameterizations across shapes.

Loss & Training¶

The training pipeline is split into two major phases (Stage II and Stage IV), each with its own loss functions:

Stage II (Implicit Model): \(\min_{\gamma,\phi} l_{\text{data}}(\phi,\gamma) + \lambda l_{\text{reg,I}}(\gamma) + \mu l_{\text{reg,II}}(\phi)\), where the data term is the SDF reconstruction \(\ell_2\) loss, \(l_{\text{reg,I}}\) is the encoder's \(\ell_1\) sparse regularization, and \(l_{\text{reg,II}}\) is the deformation regularization for the implicit model (Eq. 5-8), with \((\lambda=0.1, \mu=0.01)\).

Stage IV (Mesh Generator Joint Fine-tuning): \(\min_{\theta} l_{\text{data}}(\gamma,\theta) + \bar{\mu} l_{\text{def}}(\theta)\), where the data term is the squared distance from the predicted surface points to the ground truth mesh, and \(l_{\text{def}}\) is the Jacobian regularization loss (Eq. 12), with \((\bar{\mu}=0.1, \beta=0.01)\).

Training details: The implicit model is trained for 8 hours on 8× GH200 GPUs (batch size 96) for 500 epochs without regularization followed by 100 epochs with regularization. The mesh generator is trained for 14 hours on a single H100 GPU (batch size 8) for 2000 epochs without regularization, followed by 500 epochs of joint fine-tuning. All phases employ the Adam optimizer with cosine annealing learning rate scheduler, with an initial learning rate of \(10^{-3}\) (\(10^{-4}\) during the joint fine-tuning phase).

Key Experimental Results¶

Main Results¶

GenSP is compared against five state-of-the-art methods on 1,000 genus-0 shapes from ShapeNet (900 train / 100 test), covering three distortion metrics and one consistency metric.

Method	mean(\(\sigma_t\)) \(\downarrow\)	max(\(\sigma_t\)) \(\downarrow\)	max(\(\sigma_t^{\text{con}}\)) \(\downarrow\)	mean(\(c(m_i,m_j)\)) \(\downarrow\)	Inference Time
CMCF	24.22	\(1.13\times10^3\)	1.029	1.626	~5 min
ARAP	177.19	\(1.22\times10^6\)	1.029	1.608	~6 min
AHSP	1.578	2.349	1.232	6.006	~32 sec
SMAT	1.503	3.392	1.049	5.122	~2 min
VC25	12.52	216.70	6.892	6.573	~5 min
GenSP	1.681	7.719	1.212	1.425	<1 sec

GenSP's consistency metric improves by 3.6× compared to the best optimization-based method SMAT, and also shows an improvement of about 14% compared to the best flow-based method CMCF. The mean isometric distortion is on par with the best optimization-based method (1.68 vs 1.50 of SMAT), while the maximum distortion is orders of magnitude smaller than CMCF's scale of \(10^3\). The inference time is under 1 second (compared to 2 to 6 minutes for baselines), as inference only requires a single forward pass of the mesh generator.

Ablation Study¶

Configuration	mean(\(\sigma_t\))	max(\(\sigma_t\))	mean(\(c\))	Description
Full GenSP	1.681	7.719	1.425	Full Method
No-DA	2.326	614.14	3.164	Without Data Augmentation, distortion surges (max increases by 80×)
No-GP	1.866	23.228	1.613	Without tree path (using linear interpolation), max distortion increases by 3×
No-GR	2.296	271.26	1.740	Without geometric regularization, max distortion increases by 35×

The impact of the three components is ordered as: Data Augmentation > Geometric Regularization > Tree Path. Removing data augmentation causes the maximum distortion to surge by 80 times, demonstrating that bridging shapes are the most critical component of the pipeline. Geometric regularization (particularly the Jacobian loss) is vital for suppressing local distortion. While consistency metrics remain close to CMCF even without the tree path planning (since the latent space organization itself originates from CMCF intermediate shapes), the maximum distortion degrades significantly.

Key Findings¶

Data augmentation is the performance backbone: removing bridging shapes makes the model directly incapable of handling large deformations from a sphere to complex shapes, with the max distortion increasing from 7.7 to 614. This demonstrates that "embedding the sphere within the subspace of training shapes" is a prerequisite for data-driven spherical parameterization.
Relative deformation regularization outperforms absolute deformation energy: compared to the absolute deformation loss in GenCorres, GenSP's normalized version is more robust to irregularities in latent space distributions, as validated by the 35× max distortion gap in the ablation study (No-GR vs. Full).
Excellent shape-preserving performance on both sides: GenSP demonstrates superior performance on both ShapeNet and the D-FAUST human body dataset. On D-FAUST, the mean consistency metric \(c\) reaches 1.68, which is about 2× better than CMCF (3.47) and ARAP (3.43).
Inference speed is three orders of magnitude faster: once trained, inference only requires a single forward pass to compute the inverse mapping, whereas optimization methods must run non-linear optimization from scratch for every inference—a natural advantage of the data-driven paradigm.

Highlights & Insights¶

Reverse Thinking: Instead of directly solving the forward parameterization mapping from "shape to sphere", the method learns an inverse mapping generative model from "sphere to shape", converting single-shape optimization into a cross-shape generative learning problem. This perspective shift naturally promotes cross-shape consistency.
Continuous Representation Avoids the Discretization Trap: Compared to mesh generative models like GenCorres, GenSP's \(g^\theta\) is defined as a continuous function, allowing Jacobian regularization to be computed directly in the continuous domain. This avoids triangular face quality degradation caused by drastic changes in conformal factors, which is key to the method's generalization across heterogeneous shape sets.
Minimum Spanning Tree Paths vs. Linear Interpolation: Utilizing latent-space tree paths instead of linear interpolation to propagate correspondences leverages real training data as registration anchors, avoiding the unreliability of synthesized intermediate shapes during large deformations. This idea can be migrated to any scenario requiring dense correspondence estimation between highly deformed shape pairs.
Generality of Relative Deformation Regularization: Converting the deformation regularization from an absolute formulation \(d^\top L d\) to the integral of a relative ratio \(d^\top L d / \|d\|^2\) addresses the scale-sensitivity issue when the latent space distribution is non-uniform. This provides a valuable practical insight—similar techniques can be applied to the geometric regularization design of other implicit generative models.

Limitations & Future Work¶

Limitation 1: Restricted to genus-0 shapes. The core of the method heavily relies on the assumption of a "spherical template" and cannot directly handle genus-1+ shapes with holes. The authors suggest that substituting CMCF with high-genus templates (such as those from Willmore flow) could be a direction for extension.
Limitation 2: Parameterization of thin structures remains difficult. The authors explicitly acknowledge in the appendix that all existing methods (including GenSP) fail when dealing with extremely thin shapes—this remains an open challenge in surface parameterization.
Limitation 3: Lack of theoretical guarantees for formal injectivity. Although GenSP achieves 91% complete injectivity in practice with only 0.099% self-intersecting faces, it lacks the formal theoretical guarantees of injectivity found in optimization-based methods, necessitating additional validation in applications that strictly require injectivity.
Potential Improvements: Currently, data augmentation relies on CMCF as a fixed flow method for bridging shapes. If CMCF performs poorly on a certain class of shapes, it cascade-affects the entire pipeline. Exploring dynamic selection across multiple flow methods or adoptable/learnable data augmentation strategies could further boost robustness.

vs. CMCF (Geometric Flow Methods): Flow-based methods like CMCF solve PDEs to independently deform each shape to a sphere; their consistency stems from flow endpoints being naturally close, but they introduce extreme distortion. GenSP uses intermediate shapes along the flow paths as training data, leveraging generative models to learn deformation paths that are smoother and more consistent than PDEs.
vs. SMAT / AHSP (Shape-by-Shape Optimization Methods): These methods obtain low-distortion parameterization via mesh simplification and inversion strategies, but optimize each shape independently, leading to poor consistency. GenSP's consistency metric is 3.6× better than the best-performing SMAT while achieving comparable levels of distortion.
vs. GenCorres: GenCorres learns mesh generative models for shape matching, but requires high-quality initial correspondences, and its mesh representation is sensitive to variations in conformal factors for heterogeneous shapes. GenSP addresses both issues using continuous neural deformations and reduced deformation models, alongside introducing two key engineering innovations: data augmentation and tree-based paths.
vs. Shape Registration Methods (Diff3F / Diffumatch / ULRSSM): GenSP operates over 100× faster at inference and can handle symmetric shapes (where ULRSSM fails due to rotational ambiguity on axisymmetric shapes), demonstrating the advantage of unifying parameterization and registration within a generative framework.

Rating¶

Novelty: ⭐⭐⭐⭐ Introducing a data-driven generative model to the classic geometry processing problem of spherical parameterization is innovative, especially the inverse mapping perspective and the decoupling of large deformations. However, several components borrow heavily from existing work (e.g., deformation regularization from GenCorres, flow data from CMCF).
Experimental Thoroughness: ⭐⭐⭐⭐⭐ Extensively compared against 5 baseline methods on ShapeNet and D-FAUST datasets. Three ablation studies precisely validate the contribution of each design choice, with additional injectivity analysis and registration applications provided.
Writing Quality: ⭐⭐⭐⭐ The four-stage pipeline is clearly described, method motivation and technical challenges are well presented, and formulas and diagrams are nicely coordinated. However, explanations of the ablation study and analyses of the D-FAUST results are somewhat brief.
Value: ⭐⭐⭐⭐ Demonstrates for the first time the great potential of data-driven methods on the classic problem of spherical parameterization (3.6× consistency improvement + three orders of magnitude inference acceleration), showing high utility for CC BY 4.0 open-sourced geometry processing toolchains.