1 Introduction↩︎

Computing spherical parameterizations of genus-0 surfaces is a fundamental problem in geometry processing and visual computing [2]–[5]. Given a genus-0 surface, spherical parameterization computes a bijective mapping between the surface and the unit sphere, providing a canonical domain for applications such as texture transfer, shape correspondence, and geometric analysis. Compared with planar parameterization methods that map surfaces to the UV plane, spherical parameterization does not require cutting the surface. Such cuts introduce discrete optimization decisions that are difficult to solve and often lead to additional distortion in the parameterization. Most existing approaches [6], [7] compute spherical parameterizations for each surface independently. However, a fundamental challenge is that there exist infinitely many spherical parameterizations for a genus-0 surface. Even when the mapping is restricted to be conformal, the space of valid parameterizations forms a Möbius group [8]. As a result, two geometrically similar shapes may obtain very different parameterizations when using existing methods, as shown in Figure 1.

In this paper, we introduce a data-driven approach for computing consistent spherical parameterizations across a collection of genus-0 shapes. Our approach learns a generative model that continuously deforms the unit sphere to each shape in the dataset. Under this formulation, spherical parameterizations arise naturally as the inverse mappings of the learned generator. To ensure consistent parameterizations across shapes, we formulate common objectives of spherical parameterization as regularization losses on the generative model. These losses encourage the generator to produce smooth deformations, which lead to similar spherical parameterizations among neighboring shapes in the dataset. We further introduce a deformation regularization term that effectively minimizes geometric distortion in the resulting parameterizations.

Although the conceptual idea of this approach is straightforward, there are three fundamental challenges. The first challenge is the representation of the generative model. The straightforward approach of learning a mesh generative model is not ideal due to large variations in conformal factors of the underlying parameterization, leading to unevenly large and tiny triangles during parameterization. To address this issue, we introduce a continuous neural deformation model that maps points on a sphere to corresponding surface points on the target shape.

The second challenge is that, to date, most shape generative models with fixed topology have only been applied to relatively limited shape spaces, e.g., humans/animals [12], [13]. In many cases, the underlying sub-space does not contain the sphere, making it difficult to produce smooth latent space trajectories from a sphere to the shapes in a dataset. To address this issue, we propose augmenting the shape space with additional shapes that bridge the sphere and the input shapes. This is achieved by running existing flow-based models [11] to deform a shape into a sphere and adding suitable intermediate shapes as training shapes to learn the generative model. The training dataset, augmented with intermediate shape samples, samples the distribution of a larger genus-0 shape space that contains both the sphere and the input shapes in a more natural manner.

The final challenge is to compute the correspondences between the sphere and each input shape to initialize our neural deformation model, since learning this generator from scratch is prone to getting trapped in local minima. We find that doing so directly is quite difficult, particularly when the deformation between the sphere and an input shape is large. We address this by finding a path of training (input and augmented) shapes that gradually deforms the sphere into each input shape. To this end, we learn a point cloud encoder and an implicit decoder using an auto-encoder loss with additional regularization losses. The first loss controls the distribution of latent codes, wherein the latent code of the sphere is forced to lie at the origin of the latent space, and the latent codes of two shapes are close if and only if they are similar. The second loss regularizes the shape space defined by the shape decoder, so that intermediate shapes between two adjacent input shapes are deformation preserving, prioritizing high-quality inter-shape correspondences. We then construct a spanning tree among the latent codes of the training shapes, with the latent code of the sphere at the root. Then, obtaining correspondences between a complex training shape and the sphere is done by composing correspondences between shapes associated with each edge along the shortest path between the given shape and the sphere. These point-to-point correspondences are consistent between similar training shapes and are used to initialize the neural-deformation based mesh generative model. Finally, we regularize the model to minimize the isometric distortion in the generated mappings.

We tested our approach on the Genus-0 subset of the ShapeNet [1] dataset. The experimental results show that our approach yields parameterizations with significantly improved inter-shape consistency compared to state-of-the-art spherical parameterizations while simultaneously having low geometric distortions.

2 Related Work↩︎

2.1 Spherical Mesh Parameterization↩︎

Existing spherical parameterizations have evolved through four generations. The first generation reduces the problem to the planar case. [14] first cut out one triangle to serve as a boundary, then parameterize the resulting open mesh over the unit triangle using any planar parameterization method, and finally use the inverse stereographic projection to map the plane to the sphere. [15] is a modern variant of this approach. The main problem with these methods is the severe distortion of large regions. The key idea of the second generation [7], [9], [10], [16], [17] is to perform mesh simplification into a tetrahedron, map the tetrahedron to the sphere, and revert the procedure to compute the spherical parameterization of each intermediate mesh in the simplification process. Although this method is efficient, it is difficult to optimize the parameterization due to its greedy nature. Additionally, the bottom-to-top approach makes it challenging to preserve the consistency between parameterizations of two similar shapes. The third generation consists of various global optimization methods. The seminal work of [6] connects discrete spherical parameterizations to spectral graph theory and computes spherical parameterization via a generalized Laplacian. However, this formulation is non-convex and has many local minima. Several other papers [18]–[20] solve various global optimization relaxations, but all have issues of local minima. The fourth generation models spherical parameterizations as geometric flows [11], [21], [22], which gradually deform a given shape into the sphere. These approaches enjoy theoretical guarantees and improved consistency between parameterizations. However, these methods often yield extremely poor isometry factors (see Figure 1). Our approach can be considered a variant of the flow-based approaches, in which the flow from each shape to the sphere is not determined by a PDE but by data, i.e., a path of intermediate shapes. This approach greatly enhances the stability of spherical parameterization.

2.2 Shape Correspondences↩︎

Spherical parameterization can be formulated as a shape matching problem, which computes dense correspondences between vertices of a triangular mesh and the sphere. However, existing shape-matching approaches do not apply to the problem of matching a sphere with an arbitrary genus-0 shape. A breakthrough result in this domain is the functional map representation [23], [24]. Due to their simple algebraic representation, functional maps have been widely adopted in the deep learning era [25]–[30]. Several other approaches [31]–[34] also introduced deep neural networks for shape matching. Compared to non-deep-learning-based approaches, learning-based methods relax the constraint that the input shapes should be similar to each other. However, they are still not applicable to matching a sphere shape with an arbitrary genus-0 shape due to a lack of identifiable keypoints on the sphere.

One promising approach to extend the range of input shapes is to perform joint shape matching [35]–[37], where the map between two shapes is the composition of pairwise maps along a path of similar shape pairs. Joint shape matching typically enforces the cycle-consistency constraint, which is effective for pruning incorrect maps computed between pairs of shapes. Several papers have studied how to enforce this constraint using convex [38], non-convex [39], and spectral techniques [40], [41]. The most relevant to our approach is GenCorres [42], which learns mesh generative models to establish consistent correspondences. However, learning a mesh generative model requires high-quality initial correspondences, which are difficult to obtain. Moreover, a mesh generative model is not applicable in our setting due to large variations of conformal factors between the underlying shapes. This paper addresses these two issues by studying the problems of learning a shape generative model from a heterogeneous shape collection of diverse genus-0 shapes and encoding the shape generative model as neural fields.

2.3 Shape Generative Models↩︎

GenSP is based on recent advances in generative models of deformable shapes. Early work on this topic employs explicit shape representations, such as distance matrices [43] between all pairs of points and triangular meshes [44]–[47]. These approaches require consistently meshed training shapes as input for learning the generative model. The idea of alternating between computing consistent correspondences and learning an explicit generative model requires good initializations, which this paper addresses.

Several other papers studied learning an implicit shape generative model that bypasses the requirement of correspondences among the input data. Motivated by DeepSDF [48], SALD [49] learns an MLP to encode an implicit shape generative model for deformable shapes, e.g., humans and animals. This approach does not apply to training shapes with large pose variations. Several papers introduced regularization losses for implicit generative models. Among them, the killing vector field approach [50], which provides weak regularizations, has been adopted in several papers [51]–[54]. GenCorres [42] and GenAnalysis [55] introduce a stronger regularization, which is based on discretizing an implicit surface generator into a mesh generator locally by computing dense correspondences of mesh vertices on adjacent implicit surfaces. This allows us to employ prior work that enforces deformation losses on meshes [56], [57] to regularize the implicit generator. This approach is flexible because it allows us to employ a reduced deformation model that enables stronger and more efficient regularizations, which we will explore in this paper.

2.4 Neural Deformation Models↩︎

Our approach uses classical shape deformation models such as as-rigid-as-possible [58] and as-conformal-as-possible [59]. Unlike the standard formulations that do not admit a closed-form expression, we employ the linear approximation [60], which applies to shapes that are close to each other and admits a closed-form expression.

The application of this deformation model to regularize generative models has been studied in the literature, e.g., ARAPReg [56], GeoLatent [57] and GenCorres [42]. These methods introduce regularization losses to minimize the deformation between adjacent synthetic shapes. Although our approach also follows this paradigm, the key difference is that we normalize the deformation using the absolute shape displacements, addressing the issue of irregular distributions of shape latent codes.

Several other papers have studied neural deformation models, e.g., NJField [61], LLDPD [62], and TutteNet [63]. A common scheme among these models is to employ neural networks to predict the deformation field, e.g., displacements of deformation nodes and deformation gradients. The focus is on shapes that undergo large deformations. However, neural shape deformation models have generalization issues. In contrast, our deformation model is between adjacent shapes, and deformations between different shapes are computed using a generative model that implicitly composes deformations between adjacent shapes.

3 Problem Statement and Approach Overview↩︎

3.1 Problem Statement↩︎

The input consists of a collection of triangular meshes \(\mathcal{S} = \{S_0,\cdots S_N\}\). Each mesh is closed and has genus-\(0\). Here \(S_0\) is a mesh of the unit sphere with \(n\) vertices. \(S_1,\cdots, S_N\) are actual training meshes. As a starting point, we assume that these meshes are roughly normalized in some shared ambient shape. However, we do not assume that they are consistently meshed.

Our goal is to find, for each shape \(S_i\), a mapping \(m_i: S_i\rightarrow S_0\) to the unit sphere \(S_0\). \(m_i\) has the following properties: 1) \(m_i\) is bijective, i.e., the image \(m_i(S_i)\) covers \(S_0\) and does not have self-intersections. 2) \(m_i\) has minimal isometric deformations. 3) For similar shapes \(S_i\) and \(S_j\), the mappings \(m_i\) and \(m_j\) are also similar.

3.2 Approach Overview↩︎

Our approach learns a neural shape generative model of the inverse mapping from the unit sphere to each shape in the genus-\(0\) shape space. Denote \(\mathcal{Z} \cong \mathbb{R}^d\) as the latent space of genus-0 shapes. The generative model is denoted as \(\boldsymbol{g}^{\theta}(\boldsymbol{z},\cdot): \mathbb{R}^3\rightarrow \mathbb{R}^3\), where \(\boldsymbol{g}^{\theta}(\boldsymbol{z},\boldsymbol{p})\) is the corresponding surface point of a point on a sphere \(\boldsymbol{p}\in \mathbb{S}^2\). We consider four objectives:

1. The latent code of \(S_0\) is at the origin, i.e., \(\boldsymbol{g}^{\theta}(\boldsymbol{0},\boldsymbol{p}) \in S_0, \forall \boldsymbol{p}\in \mathbb{S}^2\).

2. \(\boldsymbol{g}^{\theta}(\boldsymbol{z}_i,\boldsymbol{p})\in S_i, \forall \boldsymbol{p}\in \mathbb{S}^2\), where \(\boldsymbol{z}_i\) is the latent code of shape \(S_i\).

3. The Jacobian \(\frac{\partial \boldsymbol{g}^{\theta}(\boldsymbol{z},\boldsymbol{p})}{\partial \boldsymbol{z}}, \forall \boldsymbol{p}\in \mathbb{S}^2\) follows a regularized as-conformal-as possible deformation prior.

4. The geometric distance between two shapes \(S_i\) and \(S_j\) correlates with the Euclidean distance between \(\boldsymbol{z}_i\) and \(\boldsymbol{z}_j\).

There are two fundamental challenges to learning the generative model described above. First, the sphere \(S_0\) is usually not in the underlying shape space of \(\mathcal{S}=\{S_1,\cdots, S_N\}\), making it very difficult to learn a shape generative model that fits \(\mathcal{S}\) and provides meaningful interpolations between \(S_0\) and each \(S_i\). To address this challenge, our key idea is to augment the input shapes with additional shapes \(S_{N+1},\cdots, S_{\overline{N}}\) by deforming each input shape \(S_i\) into the sphere \(S_0\) using an off-the-shelf method to obtain the augmented dataset \(\overline{\mathcal{S}}\). Second, we need consistent correspondences between the sphere and the training shapes to define a meaningful data term to learn the shape generative model. Without correspondences, minimizing the Chamfer distance or Earth-Mover distance between the synthetic mesh and each training shape can easily result in getting trapped in local minima. To address this challenge, we propose to introduce an implicit generative model \(f^{\phi}:\mathbb{R}^3\times \mathbb{R}^d \rightarrow \mathbb{R}\) to facilitate the computation of initial correspondences for learning this shape generative model.

As shown in Figure 2, GenSP proceeds in four stages. The first stage applies an off-the-shelf flow method [11] to deform each shape \(S_i\) into the sphere. These intermediate shapes are used to augment the training shapes.

The second stage learns an implicit shape generator \(f^{\phi}:\mathbb{R}^d\times \mathbb{R}^3\rightarrow \mathbb{R}\) together with a point cloud encoder \(e^{\gamma}:\overline{\mathcal{S}}\rightarrow \mathcal{Z}\) that maps a shape into the latent space using an auto-encoder loss. We add an additional regularization loss on \(e^{\gamma}\) to enforce that similar shapes have close-by latent codes. The decoder \(f^{\phi}\) will be used to generate intermediate shapes between pairs of adjacent training shapes to propagate inter-shape correspondences. Therefore, we introduce a deformation regularization loss in \(f^{\phi}\) to improve the quality of these intermediate shapes.

Based on the learned implicit shape generator, the third stage constructs a spanning tree among the training shapes where \(S_0\) is the root. Starting from the root, we apply template-based shape registration using intermediate shapes generated by the implicit generator \(f^{\phi}\) to compute dense correspondences between \(S_0\) and each training shape. The resulting correspondences are used to initialize the shape generator \(\boldsymbol{g}^{\theta}\), which is trained using an auto-encoder loss.

The last stage fine-tunes the shape generator \(\boldsymbol{g}^{\theta}\) and the encoder together \(e^{\gamma}\) together, where we introduce a deformation regularization term on the shape generator \(\boldsymbol{g}^{\theta}\) to optimize the final spherical mesh parameterizations.

4 Approach↩︎

4.1 Stage I: Data Augmentation↩︎

The first stage augments the training data \(S_0,\cdots, S_N\) with suitable genus-0 shapes \(S_{N+1},\cdots, S_{\overline{N}}\) that bridge \(S_0\) and \(S_1,\cdots, S_N\), as shown in Figure 2. We achieve this goal by using an off-the-shelf flow-based method to deform each input shape \(S_i\) into the sphere shape \(S_0\) and sample intermediate shapes. We chose CMCF [11], which has a stable open-source implementation. CMCF has the step-size as a critical hyper-parameter, and no fixed value is optimal among all input shapes. Therefore, we need to define a scoring function for intermediate shapes to decide which intermediate shapes to use for augmentation.

For a given hyper-parameter \(m\) and one shape \(S_i\), denote by \(S_i^m(t), 0\leq t \leq 1\) the result of \(m\) such that \(S_i^m(0) = S_i\), and \(S_i^m(1)\) converges to the sphere or becomes degenerate. We define the scoring function as \[s(m,S_i) = d^2(S_0, S_i^m(1)) + \eta \int_{0}^{1}e_{\mathrm{deform}}(S_i^m(t), S_i) dt \label{Eq:Data:Loss:Stage:I}\tag{1}\] where the first term measures the squared Hausdorff distance between \(S_0\) and \(S_i^m(1)\), and the second term integrates the deformation between \(S_i^m(t)\) and \(S_i\). For two meshes \(\boldsymbol{p}\in \mathbb{R}^{3n}\) and \(\boldsymbol{q}\in \mathbb{R}^{3n}\) each with \(n\) vertices that share the same topology, their deformation is defined as \[e_{\mathrm{deform}}(\boldsymbol{p}, \boldsymbol{q}) = \sum\limits_{i=1}^{n}\min\limits_{R_i\in \mathrm{SO}(3)}\sum\limits_{j\in \mathcal{N}_i}\|R_i(\boldsymbol{p}_i-\boldsymbol{p}_j)-(\boldsymbol{q}_i-\boldsymbol{q}_j)\|^2\] where \(\mathcal{N}_i\) is the 1-ring neighborhood of the vertex \(i\).

For each \(S_i\), we pick the hyper-parameter \(m_i^{\star}\) that has the smallest \(s(m_i^{\star},S_i)\). When \(s(m_i^{\star},S_i) < 2\delta\), where \(\delta\) is the median of \(s(m_i^{\star},S_i)\) among all input shapes, we add \(S_i^{m_i^{\star}}(t)\) to the training shapes, where \(t\) is randomly sampled in \((0,1)\). The total number of training shapes \(\overline{N} = 24N\), i.e., we place 23 samples in \(t\).

4.2 Stage II: Autoencoder for Learning the Shape Space↩︎

The second stage learns a point cloud encoder \(e^{\gamma}\) and an implicit generator \(f^{\phi}\) by combining an auto-encoder data loss and two regularization losses on \(e^{\gamma}\) and \(f^{\phi}\), respectively. The data loss fits \(f^{\phi}\) to the training shapes: \[l_{\mathrm{data}}(\phi, \gamma) := \sum\limits_{i=0}^{\overline{N}} \sum\limits_{(\boldsymbol{p},d)\in \mathcal{D}(S_i)} \big(f^{\phi}(\boldsymbol{p},e^{\gamma}(S_i))-d\big)^2 \label{Eq:Data:Loss:Stage:II}\tag{2}\] where \(\mathcal{D}(S_i)\) collects signed-distance function (SDF) samples (cf. [49]) on-and-off the surface of \(S_i\) to learn the implicit decoder.

The first regularization loss is enforced on \(e^{\gamma}\) to ensure that similar training shapes remain close to each other in the latent space. This is important when using latent codes to construct a spanning tree to initialize the correspondences between \(S_0\) and each training shape \(S_i\). Here, we directly regularize the magnitude of \(\gamma\): \[l_{\mathrm{reg,I}} (\gamma) = \rho(\|\gamma\|) \label{Eq:Regu:Loss:I:Stage:I}\tag{3}\] where \(\rho\) is chosen as the \(L^1\) norm.

The second regularization loss is enforced on the implicit shape generator so that the intermediate shapes that interpolate adjacent synthetic shapes are deformation-preserving. As we will linearly interpolate latent codes of adjacent synthetic shapes to generate intermediate shapes to propagate correspondences, we collect these interpolated latent codes into an empirical distribution \(p_{\mathrm{sync}}\) and define the regularization loss as \[l_{\mathrm{reg, II}}(\phi) = \underset{\boldsymbol{z}\sim p_{\mathrm{sync}}}{\mathbb{E}} r(f^{\phi}(\cdot, \boldsymbol{z})). \label{Eq:Regu:Loss:II:Stage:I}\tag{4}\] We adopt the approach in GenCorres [42] to define \(r(f^{\phi}(\cdot, \boldsymbol{z}))\) but make two significant modifications. First, we define \(r(f^{\phi}(\cdot, \boldsymbol{z}))\) using a reduced deformation model, which greatly increases the efficiency of training while making the effectiveness of regularization more prominent. Specifically, consider a mesh discretization of \(f^{\phi}(\cdot, \boldsymbol{z})\) with \(m\) vertices \(\boldsymbol{p}^{\phi}(\boldsymbol{z})\in \mathbb{R}^{3m}\). Consider \(l \ll m\) deformation nodes obtained by farthest point sampling (\(m = 2000\) and \(l = 200\) in our experiments). With \(\mathcal{N}_i\) we collect adjacent vertices of node \(i\), where adjacent \(\mathcal{N}_i\) overlap and \(\{\mathcal{N}_i\}\) cover all mesh vertices. With this setup, we parameterize \(\boldsymbol{p}^{\phi}(\boldsymbol{z}+\epsilon\boldsymbol{v}) \approx \boldsymbol{p}^{\phi}(\boldsymbol{z}) + \epsilon \boldsymbol{d}(\boldsymbol{z},\boldsymbol{v})\) in the neighborhood of \(\boldsymbol{z}\) where \(\boldsymbol{d}(\boldsymbol{z},\boldsymbol{v}):=\) \[\begin{align} \underset{\boldsymbol{d}}{\mathrm{argmin}} & \min_{s_i,\boldsymbol{c}_i}\sum\limits_{i=1}^{l}\big(\sum\limits_{j\in \mathcal{N}_i} \|A_i(\boldsymbol{p}_i^{\phi}(\boldsymbol{z})-\boldsymbol{p}_j^{\phi}(\boldsymbol{z})) - (\boldsymbol{d}_i-\boldsymbol{d}_j)\|^2 + \eta s_i^2\big)\nonumber \\ s.t. & \quad \frac{\partial f^{\phi}}{\partial \boldsymbol{x}}(\boldsymbol{p}_j^{\phi}(\boldsymbol{z}),\boldsymbol{z})\boldsymbol{d}_j + \frac{\partial f^{\phi}}{\partial \boldsymbol{z}}(\boldsymbol{p}_j^{\phi}(\boldsymbol{z}),\boldsymbol{z})\boldsymbol{v} = 0, \quad 1\leq j \leq m \label{Eq:Cons:Opt} \end{align}\tag{5}\] where \[A_i = s_i I_3 + \boldsymbol{c}_i\times I_3.\] Through some derivations (see the supp. material), we can rewrite Eq. (5 ) as \[\boldsymbol{d}^{\boldsymbol{v}}:= \underset{\boldsymbol{d}}{\mathrm{argmin}} \;\;\boldsymbol{d}^T L^{\phi}(\boldsymbol{z}) \boldsymbol{d} \quad s.t. \quad C^{\phi}(\boldsymbol{z}) \boldsymbol{d}+ F^{\phi}(\boldsymbol{z}) \boldsymbol{v} = 0. \label{Eq:Cons:Opt2}\tag{6}\] This leads to an explicit expression of \[d^{\boldsymbol{v}} = G^{\phi}(\boldsymbol{z}) \boldsymbol{v},\quad G^{\phi}(\boldsymbol{z}) = -(I,0)\left( \begin{array}{cc} L^{\phi}(\boldsymbol{z}) & {C^{\phi}(\boldsymbol{z})}^T \\ C^{\phi}(\boldsymbol{z}) & 0 \end{array} \right)^{\dagger}\left( \begin{array}{c} 0 \\ F^{\phi}(\boldsymbol{z}) \end{array} \right)\boldsymbol{v}.\] Second, unlike merely minimizing \({\boldsymbol{d}^{\boldsymbol{v}}}^TL^{\phi}(\boldsymbol{z})\boldsymbol{d}^{\boldsymbol{v}}\), we define the regularization loss at \(\boldsymbol{z}\) by integrating the ratio \(\frac{{\boldsymbol{d}^{\boldsymbol{v}}}^TL^{\phi}(\boldsymbol{z})\boldsymbol{d}^{\boldsymbol{v}}}{{\boldsymbol{d}^{\boldsymbol{v}}}^T\boldsymbol{d}^{\boldsymbol{v}}}\), which measures the relative deformation with respect to the absolute displacement. This becomes important as the distribution of shapes in the AE latent space becomes irregular. Specifically, we have \[r(f^{\phi}(\cdot, \boldsymbol{z}) = \int_{\boldsymbol{v}\in \mathcal{S}^d}\frac{{\boldsymbol{d}^{\boldsymbol{v}}}^TL^{\phi}(\boldsymbol{z})\boldsymbol{d}^{\boldsymbol{v}}}{\|\boldsymbol{d}^{\boldsymbol{v}}\|^2}d\boldsymbol{v}. \label{Eq:Def:Regu}\tag{7}\] Combing Eqs.(2 ), (3 ), and (4 ), the total training loss for stage II is \[\min\limits_{\gamma, \phi} l_{\mathrm{data}}(\phi, \gamma) + \lambda l_{\mathrm{reg}, I}(\gamma) + \mu l_{\mathrm{reg}, II}(\phi). \label{Eq:Stage:I:Total:Loss}\tag{8}\]

To ensure that the latent code of \(S_0\) is at the origin of the latent space, we sample \(S_0\) once every batch and penalize the \(L^2\)-norm of its predicted latent.

4.3 Stage III: Shape Generator Initialization↩︎

The goal of the third stage is to compute the initial dense correspondences between \(S_0\) and each training shape \(S_i\), which will be used to initialize the shape generator \(\boldsymbol{g}^{\theta}\). A naive approach is to use \(f^{\phi}(\cdot,\boldsymbol{z})\) to generate intermediate shapes between \(S_0\) and \(S_i\) and to align \(S_0\) with these intermediate shapes sequentially to obtain the correspondences with \(S_i\). However, this approach does not work when \(S_i\) and \(S_0\) are very different from each other, as many intermediate shapes present large deformations (see Figure 3 (Top)).

Our idea is to introduce a more meaningful interpolation path from \(S_0\) to \(S_i\) using the training data. Specifically, we build a minimum spanning tree among \(\mathcal{S}\) where the root is \(S_0\). The weight of each edge \((S_i, S_j)\) is given by the distance \(\|e^{\gamma}(S_i)-e^{\gamma}(S_j)\|\) between \(S_i\) and \(S_j\) in the latent space. We also use \(f^{\phi}(\cdot, \boldsymbol{z})\) to generate intermediate shapes between \(S_i\) and \(S_j\) to propagate the correspondences between \(S_0\) and \(S_i\) to \(S_j\). Correspondence propagation employs the standard non-rigid registration approach with an as-rigid-as possible deformation prior [64]. As shown in Figure 3 (Bottom), this approach yields accurate correspondences for shapes \(S_i\) that present large variations from \(S_0\).

Let \(\boldsymbol{p}^i\in \mathbb{R}^{3n}\) be the correspondences of the mesh vertices \(\boldsymbol{c}\in \mathbb{R}^{3n}\) of \(S_0\) on \(S_i\). We initialize the mesh generator \(\boldsymbol{g}^{\theta}(\boldsymbol{z},\cdot)\) using the standard \(L^2\) loss: \[\min\limits_{\theta} \sum\limits_{i=1}^{N}\sum\limits_{j=1}^{n}\|\boldsymbol{g}^{\theta}(e^{\gamma}(S_i),\boldsymbol{c}_j)-\boldsymbol{p}_j^i\|^2. \label{Eq:StageII:Loss}\tag{9}\]

4.4 Stage IV: Shape Generator Fine-tuning↩︎

The fourth stage jointly refines the shape generator \(\boldsymbol{g}^{\theta}\) and the encoder \(e^{\gamma}\). The training loss consists of a modified data loss and a deformation regularization loss on \(\boldsymbol{g}^{\theta}\). Its effect on improving the quality is shown in Figure 4.

The modified data loss is given by \[l_{\mathrm{data}}(\gamma, \theta) := \sum\limits_{i=0}^{N} \int_{\boldsymbol{p}\in \mathcal{S}^2} d^2\big(\boldsymbol{g}^{\theta}(e^{\gamma}(S_i),\boldsymbol{p}), S_i\big) \label{Eq:Data:Loss:Stage:IV}\tag{10}\] where \(d^2\big(\boldsymbol{q}, S_i)\) is the squared distance between \(\boldsymbol{q}\) and the triangular mesh \(S_i\).

The deformation regularization loss models deformation priors on \(\boldsymbol{g}^{\theta}(\boldsymbol{z},\boldsymbol{p})\). As \(\boldsymbol{g}^{\theta}(\boldsymbol{z},\boldsymbol{p})\) is continuous in \(\boldsymbol{p}\), we model the deformation regularization loss based on the Jacobian \(J_{\boldsymbol{p}}^{\theta}(\boldsymbol{z},\boldsymbol{p})= \frac{\partial \boldsymbol{g}^{\theta}(\boldsymbol{z},\boldsymbol{p})}{\partial \boldsymbol{p}} \in \mathbb{R}^{3\times 2}\) which is computed in a local tangent frame at each sphere point \(p\), formed by two orthonormal vectors obtained by Gram-Schmidt against the radial direction at \(p\). The Jacobian itself is computed via PyTorch autograd. It is easy to see that the desired properties for \(\boldsymbol{p}^{\theta}(\boldsymbol{z},\boldsymbol{p})\) to be an isometric and conformal mapping are that \({J_{\boldsymbol{p}}^{\theta}(\boldsymbol{z},\boldsymbol{p})}^T J_{\boldsymbol{p}}^{\theta}(\boldsymbol{z},\boldsymbol{p})\) is the identity matrix \(I_2\) and the scaled identity matrix, respectively. Therefore, we define the following regularization loss \[l_{\mathrm{def}}(\theta) = \underset{\boldsymbol{z}\sim p_{\mathrm{sync}},\boldsymbol{p}\in \mathcal{S}^2}{\mathbb{E}} r({J_{\boldsymbol{p}}^{\theta}(\boldsymbol{z},\boldsymbol{p})}^T J_{\boldsymbol{p}}^{\theta}(\boldsymbol{z},\boldsymbol{p})) \label{}\tag{11}\] where \[r(A) = \beta \|A-I_2\|^2 + \|A-\frac{\langle A, I_2\rangle}{2} I_2\|^2.\] We set \(\beta = 0.01\) in all of our experiments.

The training loss at this stage is then given by \[\min\limits_{\theta} l_{\mathrm{data}}(\gamma, \theta)+ \overline{\mu}l_{\mathrm{def}}(\theta).\]

5 Experimental Results↩︎

5.1 Experimental Setup↩︎

We collected a dataset of genus-0 shapes from the ShapeNet [1] dataset, totaling 1K shapes. These shapes cover diverse objects. We use 900 shapes for training and 100 shapes for testing. For baseline comparisons, we choose five state-of-the-art single-shape spherical parameterization approaches, i.e., CMCF [11] and SMAT  [9], AHSP [10], ARAP [20], VC25 [15]. Here, CMCF is flow-based, while the other four baselines are optimization-based.

We consider four metrics for experimental evaluation. Similar to VC25, the first three metrics evaluate the quality of each spherical parameterization via its geometric distortion. Three of these metrics consider the distortions of each triangle \(t\) and each method. Specifically, we compute the Jacobian \(J_t\) between the image of \(t\) on the sphere and itself. We report two distortions based on \(J_t\): \[\sigma_t = \max\big(\sigma_{\max}(J_t), \frac{1}{\sigma_{\min}(J_t)}\big), \;\;\sigma_t^{\mathrm{con}} = \max\big(\frac{\sigma_{\max}(J_t)}{\sigma_{\mathrm{mean}}(J_t)}, \frac{\sigma_{\mathrm{mean}}(J_t)}{\sigma_{\min}(J_t)}\big).\] where \(\sigma_{\max}(J_t)\), \(\sigma_{\min}(J_t)\), and \(\sigma_{\mathrm{mean}}(J_t)\) are the maximum, minimum, and mean singular values of \(J_t\). We report the mean and maximum of \(\sigma_t\) and the maximum of \(\sigma_t^{\mathrm{con}}\) among all triangles. The fourth metric evaluates the consistency of the spherical parameterizations. First we compute a graph \(\mathcal{G} = (\{S_1,\cdots, S_N\},\mathcal{E})\) that connects similar input shapes. \(\mathcal{E}\) connects each shape \(S_i\) to its \(6\) nearest neighbors according to the Hausdorff distance. Let \(m_{ij}: S_i\rightarrow S_j\) be the ground-truth mapping between two similar shapes \((S_i,S_j)\in \mathcal{E}\). We use ground truth mappings \(m_{ij}\) provided by KeypointNet[65]. We compute the differences \(\|m_{ij}\circ m_i^{-1}(S_0), m_j^{-1}(S_0)\|\) between images of the same sample points of \(S_0\) on \(S_i\) and \(S_j\). We report the average of \(c(m_i,m_j) = d(m_{ij}\circ m_i^{-1}(S_0), m_j^{-1}(S_0))/d_{\mathrm{Haus}}(S_i, S_j)\). The lower the value of \(c(m_i,m_j)\) the more consistent \(m_i\) and \(m_j\). Note that for all baseline approaches, we employ Möbius registration to factor out the underlying Möbius group  [22] before calculating \(c(m_i, m_j)\).

5.2 Sphere Parameterization Quality↩︎

Table 1 presents quantitative comparisons between GenSP and the baseline approaches. We can see that GenSP outperforms all baseline approaches considerably across all metrics. Compared to CMCF, GenSP reduces \(\mathrm{mean}(\sigma_t)\) and \(\max(\sigma_t)\) by \(14.3\times\) and \(146\times\) respectively. Even for \(\mathrm{mean}(\sigma_t^{\mathrm{con}})\) which favors CMCF, GenSP only increases by \(1.17\times\). GenSP’s \(\mathrm{mean}(\sigma_t)\), \(\max(\sigma_t)\), and \(\mathrm{mean}(\sigma_t^{\mathrm{con}})\) also remain on par with per-shape optimization based methods.

With respect to the consistency metric, \(\mathrm{mean}(c(m_i,m_j))\), GenSP leads to significant performance gains compared to per-shape optimization methods, i.e., \(3.6\times\) better than the top-performing optimization-based baseline SMAT. It also outperforms flow based approaches to a lesser extent. This is expected as GenSP explicitly models the consistency of spherical parameterizations as an optimization objective.

Figure 5 shows qualitative comparisons between GenSP and baseline approaches. Qualitative results are consistent with quantitative results. The individual spherical parameterizations of GenSP exhibit fewer distortions, which is expected. Moreover, GenSP is the only approach that offers consistent parameterizations across the shape collection, in which semantic feature keypoints are in correspondence.

Bijectivity Guarantees: GenSP does not provide formal bijectivity guarantees, but it is empirically near-bijective. On our 100-shape ShapeNet test-set, 91 shapes produce fully bijective parameterizations and the mean per-shape rate of self-intersecting or degenerate faces is 0.099% as shown in Table  [tab:bijectivity]. This is comparable to optimization-based methods that explicitly target bijectivity per shape and is substantially better than other flow-based or stereographic methods.

5.3 Ablation Study↩︎

5.3.1 No data augmentation↩︎

The first ablation study removes the data augmentation step and uses only input shapes to learn the generative models. As shown in Table  1, all metrics of this variant drop significantly. This is because extrinsic generative models fail to recover the underlying complex deformations between the sphere and these shapes without training on shapes that bridge them.

5.3.2 No intermediate training shapes↩︎

The second ablation study replaces correspondence propagation along a path of adjacent training shapes in stage III with intermediate shapes defined by the implicit shape generator via straight-line interpolation in the latent space. Table 1 shows that this variant leads to notable performance drops in all metrics, except the consistency metric, which is similar to CMCF. This is because the mesh generator depends on the quality of the initial correspondences and cannot recover from severe errors in initial correspondences, which leads to poor isometry errors. On the other hand, as the latent space is still organized according to the intermediate CMCF shapes, the consistency metric remains similar to that of CMCF.

5.3.3 No geometric regularizations↩︎

The third ablation study drops the geometric regularizations used in training the implicit and mesh generators. Table 1 shows that this variant leads to noticeable performance drops. This is expected as geometric regularizations are critical for determining how to interpolate shapes between sparse shape samples, e.g., between complex shapes. Figure 4 depicts the improvement in the quality of parameterizations when this regularization is used, which also contributes to the improvement in metrics.

5.4 Applications↩︎

In Figure 6, we compare GenSP against three recent correspondence methods (Diff3F [66], Diffumatch [67], and ULRSSM [68]). GenSP produces more coherent inter-class and intra-class surface correspondences while running at least \(100\times\) faster. ULRSSM fails on axially symmetric shapes due to rotationally non-unique features. We show a further application in shape morphing and comparison with classical methods in Sec. 10.

6 Conclusions and Future Work↩︎

In this paper, we have presented a data-driven approach that computes a consistent spherical parameterization among a collection of genus-0 shapes. We have shown how to formulate this problem as learning a neural deformation-based mesh generative model. We present a technique to compute consistent correspondences between training shapes and the sphere to initialize the mesh generative model. The experimental results reveal that GenSP retains the high-quality isometric factors yielded by per-shape optimization based spherical parameterization approaches while simultaneously providing consistent parameterizations like flow based methods.

There are ample opportunities for future research. First is how to extend this framework to higher genera shapes. CMCF could be replaced with a curvature flow admitting non-constant final mean curvature (e.g., Willmore flow variants [69]) and the sphere with high-genera templates. Second, the shape generative models are extrinsic, while spherical parameterization is an intrinsic problem. Developing an intrinsic shape generative model for spherical parameterization is another interesting problem.

7 Acknowledgments↩︎

This project was supported by NSF-2047677, 2413161, 2504906, and 2515626; GIFTs from Adobe, Google, and Ericsson; and computing support on the Vista GPU Cluster through the Center for Generative AI (CGAI) and the Texas Advanced Computing Center (TACC) at UT Austin.

8 Derivation of Eq. 5↩︎

This section presents a matrix reformulation of Eq. 5 , which is \[\boldsymbol{d}^T L^{\phi}(\boldsymbol{z})\boldsymbol{d} = \min_{s_i,\boldsymbol{c}_i}\sum\limits_{i=1}^{l}\big(\sum\limits_{j\in \mathcal{N}_i} \|A_i(\boldsymbol{p}_i^{\phi}(\boldsymbol{z})-\boldsymbol{p}_j^{\phi}(\boldsymbol{z})) - (\boldsymbol{d}_i-\boldsymbol{d}_j)\|^2 + \eta s_i^2\big) \label{piumxqvw}\tag{12}\] where \[A_i = s_i I_3 + \boldsymbol{c}_i\times I_3.\] Denote \(\boldsymbol{x}\in \mathbb{R}^{4l}\) where \(\boldsymbol{x}_i = (s_i;\boldsymbol{c}_i)\). Introduce \(L\in \mathbb{R}^{m\times m}\), \(B^{\phi}(\boldsymbol{z})\in \mathbb{R}^{3m\times 4l}\), and \(H^{\phi}(\boldsymbol{z})\in \mathbb{R}^{4l\times 4l}\) where \[\begin{align} L_{ii} &= \left\{ \begin{array}{cc} |\mathcal{N}_i|& i= j, \quad 1\leq i \leq l \\ |\{i'|i\in \mathcal{N}_{i'}\}| & \quad i=j, \quad l+1\leq i\leq m\\ -1 & j\in \mathcal{N}_i, \quad \mathrm{or} i\in \mathcal{N}_j \\ 0 & \mathrm{otherwise} \end{array} \right.\,\\ B_{ji}^{\phi}(\boldsymbol{z}) & = \left\{ \begin{array}{cc} \big(\boldsymbol{q}_{ij}^{\phi}(\boldsymbol{z}),-\boldsymbol{q}_{ij}^{\phi}(\boldsymbol{z})\times \big)& i = i\nonumber \\ -\big(\boldsymbol{q}_{ij}^{\phi}(\boldsymbol{z}),-\boldsymbol{q}_{ij}^{\phi}(\boldsymbol{z})\times \big)& j\in \mathcal{N}_i\nonumber \\ 0 & \mathrm{otherwise} \end{array} \right.\,\\ H_{ij}^{\phi}(\boldsymbol{z}) & = \left\{ \begin{array}{cc} \sum\limits_{j'\in \mathcal{N}_i}\left( \begin{array}{cc} \|\boldsymbol{q}_{ij'}^{\phi}(\boldsymbol{z})\|^2 + \eta &0\\ 0 & \|\boldsymbol{q}_{ij'}^{\phi}(\boldsymbol{z})\|^2I_3- \boldsymbol{q}_{ij'}^{\phi}(\boldsymbol{z}){\boldsymbol{q}_{ij'}^{\phi}(\boldsymbol{z})}^T \end{array} \right) & i = j \\ & \mathrm{otherwise} \end{array} \right.\,\\ \end{align}\] where \[\boldsymbol{q}_{ij}^{\phi}(\boldsymbol{z}) = \boldsymbol{p}_i^{\phi}(\boldsymbol{z})-\boldsymbol{p}_j^{\phi}(\boldsymbol{z}).\] Then \[\begin{align} & \quad \boldsymbol{d}^T L^{\phi}(\boldsymbol{z})\boldsymbol{d} \nonumber \\ =& \quad\min\limits_{\boldsymbol{x}}\quad\Big(\boldsymbol{d}^T(L\otimes I_3))\boldsymbol{d} -2\boldsymbol{d}^T B^{\phi}(\boldsymbol{z}) \boldsymbol{x} + \boldsymbol{x}^T H^{\phi}(\boldsymbol{z})\boldsymbol{x}\Big) \nonumber \\ =&\quad \boldsymbol{d}^T\Big(L\otimes I_3-B^{\phi}(\boldsymbol{z})H^{\phi}(\boldsymbol{z}){B^{\phi}(\boldsymbol{z})}^{-1}\Big)\boldsymbol{d}, \quad \Big(\boldsymbol{x} = {H^{\phi}(\boldsymbol{z})}^{-1}(B^{\phi}(\boldsymbol{z})^T\boldsymbol{d})\Big) \quad \end{align}\] meaning \[L^{\phi}(\boldsymbol{z}) = L\otimes I_3-B^{\phi}(\boldsymbol{z})H^{\phi}(\boldsymbol{z}){B^{\phi}(\boldsymbol{z})}^{-1}.\]

9 Implementation Details↩︎

9.1 Latent Space Regularization↩︎

A desirable property of the latent space is that similar shapes are reconstructed similarly and therefore assigned nearby latent codes. We find that the L1 penalty together with reconstruction loss encourages this desired behavior. We verified that latent distances strongly correlate with 3D Hausdorff distances (Pearson’s \(r = 0.723\)).

9.2 Registration↩︎

As mentioned in Sect. 4.3, we construct paths from a template shape \(S_0\) (the sphere) to the target shape \(S_i\) via various intermediate shapes. Our goal is to build correspondences between the end points, and to do this we build correspondences between adjacent nodes in the path. Given two meshes in the path, \(S_i\) and \(S_j\), we first take their latents and interpolate them to get \(n\) interpolated latents. We then decode them to get \(n\) intermediate meshes between the two nodes in the path, say \((S_{i\rightarrow j})_1,\dots, (S_{i\rightarrow j})_n\). In our implementation, \(n=5\). We then iteratively register \((S_{i\rightarrow j})_{n-1}\) to \((S_{i\rightarrow j})_{n}\) via standard non-rigid registration with an as-rigid-as possible deformation prior. This gives a remeshed verion of \(S_j\) with the same connectivity as \(S_i\).

9.3 Stitching↩︎

Our next task is to “stitch” these independently registered segments together such that we can project the connectivity of a target shape \(S\) onto the surface of the sphere. Consider two registered segments \(S_{i\rightarrow j}\) which has shape \(S_j\) remeshed to connectivity of \(S_i\), and \(S_{j\rightarrow k}\) which has \(S_k\) remeshed to connectivity of \(S_j\). Then essentially, as we have two differently remeshed versions of \(S_j\), we can create a bijective map between them using barycentric interpolation of one vertex layout onto the surface of the other. This map can be extended to \(S_i\), which now has the same connectivity to \(S_k\). Iterating this process through all segments till the sphere, we can project the connectivity of \(S\) to the sphere, creating the initializations that are used for training the mesh generative model.

9.4 Dealing with Faulty Correspondences↩︎

While our two-step registration and stitching process ensures that correspondences are propagated from the sphere to training shapes without severe self intersections, there are often \(\sim5\%\) triangles that show self intersections on the sphere. To ensure these faulty correspondences do not adverse affect the training of the mesh decoder, we simple omit samples from such regions from our mesh initiaization dataset. Our mesh initialization training is robust enough to learn reasonable interpolations in these missing regions. The final joint-training stage relies on the ground truth shapes for minimizing the squared distance between the predicted shape and the original. This final stage fixes the reconstruction in the under-sampled regions.

9.5 Network Architecture↩︎

Encoder: We use the PointNet++ architecture for the shape encoder module, which produces latents with 256 dimensions for any given shape.
Decoder: Both our point decoder and mesh decoder follow the architecture of DeepSDF, and consist of 10 fully connected layers with 1024 hidden units in each of them. We have residual connections from the input to the third and sixth layer. In the case of the mesh decoder, we output a single SDF value, whereas for the mesh decoder produces a 3D location. We use
We train the implicit model for 600 epochs, the first 500 of which are without geometric regularization and the next 100 are including it. We train the mesh decoder for 2500 epochs, out of which the first 2000 are done without geometric regularization and the subsequent 500 include it. For Stage II, \(\lambda=0.1\) and \(\mu=0.01\). For Stage IV, \(\bar{\mu} = 0.1\) and \(\beta=0.01\).

9.6 Training Details↩︎

We train the implicit model on 8 \(\times\) GH200 GPUS for 8 hours with a cumulative batch size of 96. Meanwhile, the mesh decoder training was done on a single H100 GPU with a batch size of 8. This takes a total of 14 hours wall-clock time. Learning rate for the implicit model training and mesh initialization is set at 1e-3, while the joint training stage uses a learning rate of 1e-4. All stages use cosine annealing scheduler and the Adam optimizer.

10 More Results and Ablations↩︎

We also trained and evaluated our method on the challenging human dataset D-FAUST (trained on 1180 shapes and tested on 120 held-out shapes). As shown in Table 2, GenSP achieves the best consistency and mean conformal distortion by a high margin. Mean isometric distortion is on par with the optimization-based baselines, consistent with the ShapeNet results.

In Fig. 1, Fig. 5, and Fig. 8, the geometries of shapes are reconstructed from their spherical parameterizations obtained from different methods, in addition to mapping the texture defined on the sphere.

For the baseline methods which give a spherical parameterization of a shape that have the same connectivity as it, we first find the barycentric coordinates of all \(40,962\) vertices of the icosphere (\(\text{level}=6\)) on the triangles of the given shape’s spherical parameterization. Then using these coordinates, we interpolate the vertex coordinates of the original shape while maintaining the same connectivity as that of the icosphere.

For GenSP, we first encode the ground truth shape using the shape encoder. We then use the encoded latent to deform the vertices of an icosphere with \(40,962\) vertices to obtain a reconstruction of a target shape. While reconstructions yielded by GenSP’s mesh decoder are very accurate, the generated points do not lie perfectly on the original shape. As the ground truth shape is available during the process of creating spherical parameterizations, we can simply project vertices generated by GenSP to the ground truth mesh. Finally this yields a bijective map between the ico-sphere and the original shape.

We choose this reconstruction based approach for visualizing various methods of spherical parameterizations for two reasons. Firstly, this remains consistent with the inverse spherical parameterization formulation proposed by GenSP, and secondly, it also helps to visualize the isometry and conformality of the parameterizations through the accuracy of the reconstructions. Due to this manner of reconstruction, we see severely under-reconstructed sections of shapes when using CMCF due to its extremely poor isometric factors.

In Fig. 9, we show qualitative results for removing different components of our method, as discussed in Sec. 5.3. In the No-DA case, we observe bad geometry and major self-intersections. No-GP is perhaps the best, but struggles with thin structures and major concavities. No-GR especially struggles from bad triangulations, evident near the ridges.

We also demonstrate the applicability of GenSP for shape morphing and shape matching in Fig. 10 and Fig. 7 respectively. In Fig. 7 we compare against more classical methods like Möbius Registration [70], BIM [71], and EFM [72].

11 Limitations↩︎

All methods of spherical parameterization, including ours and the baselines shown in this paper, fail for shapes with thin structures like the one shown in Fig. 11. Developing algorithms that address this limitation is an interesting direction for future research.

References↩︎

---

1. Equal contribution.↩︎