Function
5.1 Introduction
The skeleton of a 3D model is an 1D structure that represents the topological characteristics of the model. As a global shape descriptor of 3D models, the skeleton is useful for shape analysis, object retrieval, segmentation, and animation. In general, extracting skeleton from a 3D model is a costly process that usually requires the information about the internal volume of the model.
According to the short-cut [79], a good cut should be the shortest cut and cross an axis of local symmetry. Hence, the skeleton can be computed based on the union of the local symmetries of all short cuts on the surface. Based on the MSP function introduced in Chap. 3, we propose a new mesh skeletonization that derives the curved skeleton di-rectly from the 3D model. The original model is shrunk didi-rectly to a skeleton-like shape while preserving the connectivity of the model by using the information associated with the minimum perimeter slices. A greedy framework is then invoked to iteratively alter the connectivity of the shrunk mesh and adjust its local geometry until an 1D curved skeleton is obtained. Although similar to the greedy framework commonly used in mesh simplifi-cation, our framework aims to degenerate the topology and to move transformed vertices towards the centerline. The mesh manipulation operator and the error metric are
there-40
5.1 Introduction 41
fore completely different. The edge swap operator only alters the edge connectivity and is commonly used in mesh simplification to obtain a better mesh connectivity. Since the edge swap operator can be iteratively applied to reduce a 3D mesh to a 1D structure, it is used as a single edge operator in our greedy framework. To degenerate the shrunk mesh to a 1D curve skeleton, an error metric guides the edge swap sequence such that the edges with higher deviation from the centerline would be swapped first. Moreover, we apply a smoothing operation after each edge swap operation so as to move the vertices towards the centerline. To do so, a slice-deviation error derived from the minimum perimeter slice measures the deviation between a shrunk vertex and the centerline. The resulting skeleton of the greedy framework may contain small skeleton branches induced by the local surface features or noises. These small skeleton branches can be removed by testing the salience of their corresponding surface regions.
Our approach would attempt to retain vertices and to delete a small portion of the ver-tices associated with short branches during branch removal. The resulting skeleton pos-sesses a dense node distribution at the core parts and around the junction nodes, and a skeleton-surface mapping. Previous skeleton extraction methods such as the ones using Reeb graph [27, 8, 83] or mesh contraction [6] usually generate skeletons with sparse node distribution, especially at the core parts of the model or around the junctions. Although the sparse node distribution may lead to zigzag skeleton structure in some cases, sparse nodes at the core parts are usually sufficient for some applications such as segmentation and skin-ning. Nevertheless, when we consider to embed the surface information to the skeleton, the denser node distribution is, the more information could be embedded. Some applica-tions may be benefited greatly by the presence of dense node distribution together with the skeleton-surface mapping. For example, we are investigating how to find a surface-to-surface correspondence between two meshes by utilizing the skeleton-surface-to-surface mapping and a mapping between dense nodes of two skeletons established with the aid of a well devel-oped skeleton correspondence algorithm such as [7]. In this case, the density of skeleton nodes affects the accuracy of the surface correspondence.
Our contributions of this work are stated as follows. We propose a novel greedy frame-work for degenerating the 2-manifold connectivity of polygonal mesh to a 1D skeletal structure. The resulting skeleton possesses a dense node distribution at the core parts and around the junctions. A single salience parameter is required for controlling branch
re-5.2 Mesh Skeletonization 42
(a) Original mesh (b) Shrunk mesh (c) Intermediate skeleton (d) Final skeleton
Figure 5.1: The skeletonization process.
moval so as to compute skeletons with varying details. Finally, the proposed method is able to generate consistent skeletons for models in different resolutions.
5.2 Mesh Skeletonization
To compute the skeleton, we first shrink the 3D mesh to a skeleton-like shape by trans-forming each vertex to the local symmetry axis approximated by the geometric center of the minimum perimeter slice associated with the vertex. A greedy edge-swap process based on the edge swap operator is invoked to iteratively degenerate the shrunk mesh to an 1D skeleton structure. A specially designed metric is proposed to guide the edge-swap se-quence such that the edges deviate farther from the centerline would be swapped first.
Furthermore, after each edge swap the vertices of the swapped edge are refined towards positions that represent the skeleton as the centerline by using a smoothing operator. The resulting skeleton may contain undesired small branches induced by detailed geometric features, noise, or the improper orientation minimum perimeter slices. After a branch is formed in the edge-swap process, we compute the saliency of the surface region corre-sponding to the branch and remove the branch if its associated salience value is smaller than a user-specified threshold. So that the threshold can be intuitively tuned and skeletons with varying resolutions can be effectively generated.
Fig. 5.1 depicts the proposed skeletonization process. First, the original mesh is shrunk to a skeleton-like shape, as shown in Fig. 5.1(b). Second, a sequence of edge-swap opera-tors is performed to transform the shrunk mesh to a 1D skeleton structure. An intermediate result is shown in Fig. 5.1(c) and the resulting 1D skeleton is shown in Fig. 5.1(d).
5.2 Mesh Skeletonization 43
5.2.1 Mesh Shrinking
The minimum perimeter slice associated with a surface point p approximates the short-cut passing through p. The skeleton point that corresponds to the surface point p therefore can be approximated by the geometric center of the simple polygon forming the minimum perimeter slice. Accordingly, the mesh is shrunk to a skeleton-like shape by transforming each surface point to its corresponding geometric center. Note that MSP slices, rather than the refined MSP slices, are used in the proposed skeletonization method since the metric that guides the edge-swapping and the smoothing operator to be described later is able to effectively handle the outlier cases of the shrunk mesh.
The shrunk mesh is, therefore, similar to the resulting skeleton in shape and preserves the connectivity of the original mesh. Some of the transformed vertices may deviate from the skeleton path and form protrusions on the shrunk mesh, especially around the skeleton junctions as shown in Fig. 5.1(b). However, most of the transformed vertices are distributed along the skeleton path, providing a good hint on how to locate the skeleton and how to adjust the outliers towards the skeleton path.
5.2.2 Mesh Degeneration
To extract an 1D skeleton from a manifold mesh is a degeneration process. An edge-swap operator flips the common edge of two adjacent triangles to the edge connecting two opposite vertices. Traditionally, the edge-swap operator is used in level-of-detail modeling to adjust the triangle connectivity in order to refine the mesh connectivity, while geometry simplification operators such as edge collapse are used to simplify the mesh. When the edge-swap operator is iteratively applied to a 3D mesh, the mesh can be degenerated to a 1D structure while all vertex positions are retained; as shown in Fig. 5.2 in which a tetrahedral is degenerated to a 1D structure. Our skeleton extraction algorithm is a greedy framework based on an edge-swap operator which is used for degenerating the shrunk mesh into a 1D skeleton structure. In this subsection, the error metric, smoothing operator, and branch removal scheme will be described.
5.2 Mesh Skeletonization 44
Figure 5.2: A tetrahedral is degenerated to a 1D structure using edge swap.
(a) Slice-deviation error (b) Vertex sparseness (c) Vertex protrusion
Figure 5.3: Metric associated with the transformed vertices on the horse model. The color ranging from blue to red represents the increasing value.
5.2.3 Error Metric
In traditional mesh simplification algorithms, the error metric measures the error incurs be-fore and after the simplification [20]. The primitives with smaller error have higher priority to be simplified. In our case, the primitives are edges formed by transformed vertices. We need an error metric to measure how much an edge deviates from the skeleton path and the amount of changes in shape before and after an edge swap operation is performed.
To measure how much a transformed edge deviates from the skeleton path, we first measure how much its end vertices deviate from the skeleton path. For a surface vertex, its slice-deviation error defined by Eq. 3.2 measures how well its minimum perimeter slice approximates the short cut, which offers a good measure on how much its corresponding transformed vertex deviates from the skeleton path. For a transformed vertex v, we denote cdev(v) as the slice-deviation error of its original surface vertex. Fig. 5.3(a) shows the slice-deviation error of the transformed vertices of the horse model. Notice that minimum perimeter slices of some vertices near the ends of skeleton or junctions usually have higher slice-deviation errors.
Adopting the slice-deviation error alone does not guarantee that the shape of the skele-ton would be preserved. This is because the slice-deviation error describes only the devia-tion of the minimum perimeter slice from the short cut. To preserve the shape and produce
5.2 Mesh Skeletonization 45
Figure 5.4: Measurement of the vertex sparseness.
a smooth curved skeleton, the change of the shape on the shrunk mesh should be taken into account. We observe that the transformed vertices usually distribute around the skeleton path and the vertices with higher slice-deviation error deviate farther from the skeleton path, are less dense and form protrusions on the shrunk mesh. In addition to slice-deviation error, we define the vertex density and the vertex protrusion for a vertex as the shape preserving metric. Measuring the vertex density in Euclidean space is a difficult task as an additional acceleration structure is required. Instead, we compute the sparseness of the transformed vertex v as the averaged distance between v and all the opposite edges of the one-ring faces of v, as shown in Fig. 5.4. The corresponding equation is given as follows:
cs(v) = 1
The vertex protrusion cp(v) measures the protrusion of the transformed vertex v relative to its one-ring neighborhood as shown in Eq. 5.2 as follows
cp(v) = v −
∑
vi∈V
vi, (5.2)
where V denotes the one-ring vertices of the vertex v. Fig. 5.3(b) and Fig. 5.3(c) illustrate the sparseness and the protrusion of the transformed vertices.
The skeleton is an 1D edge structure. Hence, we need one more metric for measuring the area difference of the shrunk mesh before and after swapping an edge e. This metric is called area-difference error cA(e). To increase the convergence rate of the skeletonization process, we would give the transformed edge with higher area-difference error to have higher priority to be swapped.
Finally, the metric used to guide the edge swapping process is a combination of slice-deviation error, vertex sparseness metric, vertex protrusion metric, and the area-difference
5.2 Mesh Skeletonization 46
error. It is given in Eq. 5.3 as follows
C(e) =cdev(e)
π +cs(e) + cp(e) + cA(e)
3kemaxk , (5.3)
where kemaxk denotes the length of the longest edge in the shrunk mesh and is used for normalization, and cdev(e), cs(e) and cp(e) are computed as the averaged slice-deviation error, averaged sparseness and averaged protrusion of the two end vertices, respectively. At each iteration step of the edge-swapping process, the edge with the highest C(e) is swapped first; that is, conceptually the edge that deviates most from the centerline would be swapped first.
5.2.4 Skeleton path smoothing
The proposed edge-swapping process ensures that the manifold topology of the shrunk mesh is degenerated to a 1D skeleton structure while all the vertices are preserved. How-ever, vertices with high slice-deviation error cannot represent the skeleton well, leading to a zigzag skeleton path. To smooth the skeleton path, we perform a smoothing operation on the vertices after each edge swap operation. Consider the edge e with end points vs1 and vs2, as shown in Fig. 5.5. After e is swapped, the vertices vt1 and vt2 are refined to v0t1 and
Figure 5.5: Bi-linear interpolation after the edge swapping.
vt0
2, respectively. v0t1 and v0t2 are computed by a bilinear interpolation that first derives the interpolated position of vs1 and vs2, denoted as v0, and then interpolates v0with vt1 and vt2, respectively. The slice-deviation errors are used to offer the weights such that vertices are moved towards the centerline. Eq. 5.4 and Eq. 5.5 list the equations.
v0t1 = v
5.2 Mesh Skeletonization 47
(a) Without path smoothing (b) With path smoothing
Figure 5.6: Effect of skeleton path smoothing.
where
v0= vs1cdev(vs2) + vs2cdev(vs1)
cdev(vs1) + cdev(vs2) , (5.5) and cdev(v0) is the interpolated value of the slice-deviation errors of vs1 and vs2.
The number of times for refining a vertex depends on the number of its outgoing edges being swapped. Fig. 5.6 depicts the resultant skeleton of a horse model without and with path smoothing enabled. In both cases, branch removal is enabled.
5.2.5 Skeleton branch removal
The skeleton resulted from the iterative edge swapping process may contain many small branches induced by detailed geometric features, noise, or the improper orientation mini-mum perimeter slices, as shown in Fig. 5.7(a). Such small branches may not be useful for describing the anatomical structure of the model. A skeleton branch represents a protrusion from the core part. So during our skeletonization process, a skeleton branch is removed if its corresponding surface region is insignificant in terms of the salience measurement.
According to the saliency geometric features proposed by Gal and Cohen-Or [19], the salience of a model’s part is judged by the combination of the surface curvature and the area. The maximum curvature of the surface point on the protrude part can be described as the reciprocal of the radius of the maximum inscribed ball, which can be approximated by the distance between the surface point and the corresponding skeleton node. Moreover, the area of the protrusion can be described as the integral of the MSP function along the skeleton branch. Thus, we define the salience of the skeleton branch b as the integral of the
5.2 Mesh Skeletonization 48
(a) Without branch removal (b) With branch removal
Figure 5.7: Effect of branch removal.
MSP function multiplied by the curvature along the skeleton branch, as given in Eq. 5.6,
S (b) = Z
x∈b
MSP (t (x))
r(x)3(cdev(t (x)) + 1)dx, (5.6) where t (x) denotes the transformation from the skeleton to the surface and
r(x) = MSP (t (x))2
8π2kx − t (x) k+kx − t (x) k 2
is the approximate radius of the maximum inscribed ball for the surface point t (x). The division by slice-deviation error in Eq. 5.6 is used to reduce the contribution from poor representative MSP slices. Note that all the lengths in Eq. 5.6 are divided by the half length of the mesh diagonal for normalization.
During skeletonization, once a part of the shrunk mesh is degenerated to a 1D branch, the salience of the branch is computed. The branch is removed if its salience value is smaller than a user-specified threshold. Fig. 5.7 illustrates the resultant skeleton of a horse model without and with branch removal. In both cases, path smoothing is performed.
Since all the vertices are retained by the edge-swap operator with the smoothing oper-ator and only a small portion of the vertices are deleted in the process of branch removal, the resulting skeleton possesses a dense node distribution.
5.2.6 Discussions
Our skeletonization scheme and contraction-based skeleton extraction [6] share similar ideas; but they are very different in terms of algorithms. Since connectivity is maintained
5.3 Results 49
in the skeletonization, both methods generate skeletons that are homotopic to the original model. Both methods are rotation invariant and pose insensitive since they work directly on the original geometry.
We found in practice that the skeletons generated by [6] and ours are quite similar in shape; but have some different characteristics due to their algorithmic differences. For example, the skeletons generated by [6] have sparse nodes at the core parts of a model while the skeletons derived by the proposed method have a dense node distribution at the core parts and around the junctions. Moreover, the mapping vertices of a skeleton node in [6] form a cylinder-like or a sphere-like shape, which are much larger than the ones derived by our proposed method. Compared to [6], our skeleton-surface mapping together with the dense node distribution embed more accurate and detailed surface property or information on the skeleton, which are useful to applications such as surface-to-surface correspondence. Due to the fact that only vertices associated with insignificant branches are deleted in our skeletonization, the skeletons of models with extremely low polygon count can also be extracted. However, the method [6] may not be able to handle such kind of models. The saliency threshold in our approach is more intuitive to be specified than the initial weights for balancing the contraction and attraction constraints used in [6]. The initial weights do not have intuitive relation to the skeleton branching and higher weights do not guarantee to have branches for more detail features.
5.3 Results
We implemented our approach and applied it to 3D models with various topological types.
Fig. 5.8 lists the resulting skeletons of some 3D models. Note that MSP, rather than the refined MSP, is used for all skeleton examples derived by the proposed method. The results show that the proposed skeletonization is homotopic not only for simple models but also for models with higher order genus, such as heptoroid, dancing children, or fertility. The small red spheres in Fig. 5.8 represent the nodes of the skeleton paths, indicating that the skeletons have a high node resolution at the core parts and junctions. Table 5.1 shows the percentages of surface vertices that are retained on the skeletons for some models.
Although MSP slicing is sensitive to noise, for applications such as segmentation and skeletonization such noises are harmless to the judgment of intermediate level features on the objects. The proposed skeletonization scheme is insensitive to the noisy surface models,
5.3 Results 50
Figure 5.8: The skeletons of different models. The numbers indicate salience thresholds used and small red spheres represent the skeleton nodes.
Table 5.1: Number of surface vertices retained on the skeleton.
Model Number of Number of
as shown in our experiment. Fig. 5.9 shows the skeleton extracted from the noisy horse model, on which the resulting skeleton preserves the main structure of the horse model and is similar to the skeleton of the smooth horse model, as shown in Fig. 5.8. MSP function is pose invariant and so is the proposed skeletonization method. Fig. 5.10 shows the skeletons of the cat models of different poses in Fig. 3.4.
5.3.1 Comparisons
We compare our skeletonization method with the mesh contraction algorithm [6] which also derives the skeleton directly from the surface. The results, derived using the parameter setting as suggested in [6], are shown in Fig. 5.11. Our method and the mesh contraction
5.3 Results 51
Figure 5.9: Skeleton extracted from a horse model with high noise.
Figure 5.10: Skeletons for the cat model in different poses.
algorithm generate skeletons that are homotopic to the original models and are similar in shape. However, skeletons produced by our skeletonization have a denser node distribution than the ones produced by [6], especially at the core parts of the model and around the
algorithm generate skeletons that are homotopic to the original models and are similar in shape. However, skeletons produced by our skeletonization have a denser node distribution than the ones produced by [6], especially at the core parts of the model and around the