Voting for Distortion Points in Geometric Processing

09/28/2019 ∙ by Shuangming Chai, et al. ∙ USTC 0

Low isometric distortion is often required for mesh parameterizations. A configuration of some vertices, where the distortion is concentrated, provides a way to mitigate isometric distortion, but determining the number and placement of these vertices is non-trivial. We call these vertices distortion points. We present a novel and automatic method to detect distortion points using a voting strategy. Our method integrates two components: candidate generation and candidate voting. Given a closed triangular mesh, we generate candidate distortion points by executing a three-step procedure repeatedly: (1) randomly cut an input to a disk topology; (2) compute a low conformal distortion parameterization; and (3) detect the distortion points. Finally, we count the candidate points and generate the final distortion points by voting. We demonstrate that our algorithm succeeds when employed on various closed meshes with a genus of zero or higher. The distortion points generated by our method are utilized in three applications, including planar parameterization, semi-automatic landmark correspondence, and isotropic remeshing. Compared to other state-of-the-art methods, our method demonstrates stronger practical robustness in distortion point detection.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 2

page 3

page 4

page 6

page 7

page 8

page 10

page 11

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Low isometric distortion parameterization plays a fundamental role in many computer graphics and geometric processing tasks, such as atlas generation [1, 2], remeshing [3, 4], and bijective surface correspondence [5]. Fig. 1 shows three applications. Before being parameterized to the plane, a closed mesh needs to be cut to a disk topology. The distortion of a parameterization is highly related to not only the parameterization method, but also the position of the cut. Since a surface is generally not developable, the isometric parameterization distortion is usually high, unless the cut passes through some vertices, where the distortion is usually concentrated. We called these vertices distortion points.

A good distortion point detection algorithm usually satisfies the following properties: (1) the algorithm is automatic and does not require manual intervention; (2) the parameterizations exhibit low isometric distortion if the cut path passes through the detected distortion points; (3) the number of distortion points is small; (4) and the algorithm is efficient, otherwise manual selection is preferable. On the one hand, more distortion points tend to reduce isometric distortion, but too many distortion points are very likely to have a negative impact on subsequent applications. For example, more distortion points usually lead to longer cut, which may worsen the rendering performance [6] and increase the texturing artifacts [1]. On the other hand, fewer distortion points usually produce higher isometric distortion. Therefore, there is a trade-off between properties (2) and (3).

[width=0.90]teaser Planar ParameterizationSurface CorrespondenceIsotropic Remeshing1.05.0

Fig. 1: We employ the detected distortion points (colorized spheres) in three applications (See more details in Section 5).

[width=0.90]highdistbound (a)(b)(c)(d)(e)
Geometry Images [7]
Ours

Fig. 2: An example of a defect of distortion-based methods [7, 8]. If the maximum distortion is on the boundary vertex in one iteration (a), then there is no new cut added, and the iterative process stops. This leads to missing features, i.e. the head of the man (b & c), and high isometric distortion (as shown in the red box in (c)). Our method finds the distortion points correctly (d & e), and the distortion is much lower.

[width=0.95]curdist
Seamster [9]
Ours

Fig. 3: An example of a drawback of the curvature-based method [9]. Since the curvature is related to the mesh triangulation, if the mesh has high resolution, then the curvature-based method finds redundant high-curvature points and misses important features, such as the backrest of the armchair (left). Our method correctly generates the result with lower distortion (right).

From manual picking to automatic generation, there have been many attempts to detect distortion points [8, 7, 10]. Since isometric distortion is the key to our problem, a possible strategy for detecting distortion points is to directly use isometric distortion as a core measure. For instance, some methods iteratively parameterize the mesh to the plane and add the point of greatest isometric distortion into the distortion point set [7, 8]. However, the point of greatest distortion is often located at a boundary, thereby leading to early termination and causing high isometric distortion (see Fig. 2). Instead of using planar parameterizations, Chai  [10] cluster high isometric distortion points using an as-conformal-as-possible (ACAP) spherical parameterization of the input mesh [11]. Although the clustering technique used in this method is very effective for detecting distortion points, it remains a challenge to efficiently compute bijective spherical parameterizations with theoretical guarantees.

In this paper, we propose a novel method to detect distortion points. Due to recent developments in planar parameterization techniques [12, 13], a flip-free planar parameterization is more computationally efficient and robust than a spherical parameterization. Thus, we hope to use planar parameterizations instead of spherical parameterizations to find distortion points efficiently and robustly. However, it is difficult due to the following two reasons. First, planar parameterizations requires that the input closed mesh is cut to a disk topology. However, since different cuts result in different parameterizations, the cut location has a significant effect on the detection result. Hence how to prepare a cut and handle large distortion near boundaries is very challenging. Second, robustly identifying distortion points based on planar parameterizations is non-trivial.

In order to eliminate the effects of different cuts, we present a simple and effective voting strategy to detect distortion points. To generate candidate distortion points to vote on, we repeatedly perform the following three-step procedure: first cut the input mesh randomly, then compute a low conformal distortion planar parameterization, and finally detect a set of vertices as candidates. To consistently seek candidates with strong practical robustness, we customize an effective clustering strategy, shown in [10], which uses a parameter to control the balance between the number of distortion points and the final parameterization distortion. Note that the generated candidates may include some vertices near boundaries, but they are usually detected only once since the random cut paths have almost no intersections. Therefore, in the voting phase, we only recognize vertices that appear more than once as the final candidates.

Our approach is simple and performs better than current state-of-the-art methods. We conduct various experiments and comparisons that demonstrate the feasibility and effectiveness of our method. Furthermore, we successfully employ the detected distortion points in three applications, including low-distortion parameterizations, semi-automatic corresponding landmark detection for bijective surface mappings, and isotropic remeshing (Fig. 1).

2 Related Work

[width=0.95]pipeline (a1)(a2)(a3)(a4)(b)

Fig. 4: The overview of our algorithm. We cut the mesh randomly, parameterize it to a disk as conformally as possible (a1–a4 bottom), and cluster the candidate feature points (green points in a1–a4 along the top). Judging from the candidate points, we select the final feature points according to a voting strategy (b). The parameterization results are generated by [14].

Distortion point detection.  Since vertices with high curvatures often induce high isometric distortion, some algorithms try to detect distortion points by using the curvature information as a guide [15, 9]. However, as curvature-based methods do not consider distortion directly, some distortion points may be ignored (see Fig. 3). Distortion measures are used to develop an iterative algorithm that alternately flattens the mesh and puts the maximum distortion vertex into the distortion point set [7]. However, as mentioned in the previous section and in Fig. 2, it is difficult to avoid early termination due to the maximum distortion vertex’s location on the boundary. To overcome this issue, spherical parameterizations are used [10]; however, efficiently computing bijective spherical parameterizations for complex objects is a non-trivial task (see the comparison in Fig. 17).

Conformal cone singularities.  In the context of conformal flattening, finding cone singularities is an effective way to mitigate isometric distortion. Kharevych  [16] manually place cone singularities and adjust cone angles to reduce distortion. Similar to [7], an iterative algorithm is used in [8] to compute cone configurations, including the number, placement, and size. Curvatures are also used to find the cone singularities [17, 18, 19]; however, curvatures do not always provide useful information about how cones should be arranged, as observed in [20]. Thus, starting from a different perspective, Soliman  [20] study the problem of finding optimal cones as an approximation problem. However, their optimal cone configurations are affected by a parameter that has no intuitive geometric interpretation. When using default values, some important vertices are missed (see Fig. 15 in [20]). In our method, the trade-off between the number of distortion points and the level of isometric distortion is controlled by a parameter that represents the range of influence of distortion points.

Singularities of fields.  Some recent quadrilateral remeshing methods [4, 21] cut the input mesh to a disk topology by adding the singularities of the designed fields into the cut paths. The field design procedure [22] and parameterization computation step are separate, so the connections between the field singularities and parameterization distortion are not close and indirect. As shown in Fig. 17 in [20], the highly regular fields generated by [23] do not immediately result in a low isometric distortion parameterization. Thus, the isometric distortion of parameterizations may still be large, even if the singularities are from highly smooth fields.

Cut construction and atlas generation.  Instead of defining cuts by connecting vertices, some methods directly construct cut paths to generate low isometric distortion parameterizations. Mesh segmentation approaches [24, 25, 26, 27, 28, 29] partition an input mesh into multiple charts, and each chart is parameterized with very low isometric distortion. Generating a quad layout [30] is an another way to segment an input mesh into multiple charts, such as the domain simplicity [31], aligned global parameterizations [32], perfect matching [33, 34], reliable quad meshing [35], and filed tracing [36, 37]. Techniques [38, 1] that simultaneously cut and flatten input meshes have also been developed. Li  [39] propose an algorithm to jointly optimize the parameterization and the cut-preserving bijection of the mapping. In contrast to these methods, our goal is to automatically detect distortion points, and use them in applications beyond parameterization generation. Liu  [40] generate cuts for peeling art.

3 Voting for distortion points

3.1 Overview

We study distortion point detection on 3D surface models. Given a triangular mesh containing vertices and triangles , our goal is to find a set of distortion points . To achieve this goal, we propose a voting-based algorithm. In Section 3.2, we present a three-step method to generate candidate distortion points. After performing the three-step procedure many times, we develop a voting strategy to determine the resulting distortion points, as described in Section 3.3. Some implementation details and discussions are provided in Section 3.4. Fig. 4 illustrates the pipeline of our method using a bear model.

3.2 Candidate distortion points

Instead of spherical parameterizations [10], we use distortion measures on planar parameterizations to detect distortion points. Thus, we first cut as a disk topology mesh (Section 3.2.1), then parameterize onto the plane (Section 3.2.2), and finally find the distortion points (Section 3.2.3).

[width=0.99]highpipeline (a1)(a2)(a3)(b)(c1)(c2)(c3)(d1)(d2)

Fig. 5: Steps of our algorithm for high-genus meshes. We first generate handles and randomly perturb them (a1–a3), then cut along the handles (b) and fill the holes (see the zoom-in). By applying our algorithm for genus-zero meshes, we obtain some candidate distortion points (c1–c3). After the voting process, the final distortion points are detected (d1–d2).

3.2.1 Constructing cuts

Genus-zero surfaces.  We generate cuts for genus-zero surfaces as follows:

  1. Randomly select a vertex ;

  2. Find the farthest vertex from , i.e., satisfies , for all , where refers to the Euclidean norm;

  3. Compute the shortest path between and along the mesh edges as a cut.

High-genus surfaces.  For high-genus surfaces, we first convert them into genus-zero surfaces, and then find the cut using the above procedure for genus-zero surfaces. The conversion from high genus to zero genus is as follows:

  1. Compute the handles of the high-genus surface using [41];

  2. Randomly perturb the generated handles by adding a random offset in terms of the geodesic distance;

  3. Cut the high-genus surface along these perturbed handles to create some holes;

  4. Fill in the holes to generate a genus-zero surface.

Fig. 5 uses an example to show the distortion detection process for high-genus models. In general, vertices that are located on handles are usually identified as distortion points using our detection algorithm. To distinguish them from true distortion points, we randomly perturb the generated handles of [41] so that the vertices on the handles become different. After the voting process, the vertices caused by the handles are filtered out since they only appear once.

3.2.2 Parameterization of

Inspired by methods [7, 8] that iteratively compute a conformal parameterization and place a distortion point at the vertex with the highest isometric distortion, our method also generates a parameterization that is as conformal as possible (ACAP) with no flips for detecting distortion points. Numerous techniques for ACAP parameterizations have been developed (cf. the surveys in [42, 43, 44]). To achieve a flip-free and ACAP conformal parameterization, we initialize the parameterization using Tutte’s embedding method and optimize the AMIPS energy [45] to reduce the conformal distortion.

Formulation.  A parameterization of is constituted by piecewise constant affine maps defined on triangles . After defining a coordinate system on each triangle , each affine map has a linear form , where refers to the Jacobian of . The MIPS energy [46] is defined as follows:

(1)

where and

are singular values of

, and is the Frobenius norm. reaches its minimum when represents a similarity transformation. The AMIPS energy [45] is defined as follows:

(2)

Optimizing penalizes the maximum distortion and generates evenly and smoothly distributed distortion.

[width=0.95]paratype Fixed BoundaryFree Boundary

Fig. 6: Comparison of different types of parameterizations. It takes 1.28 and 0.84 seconds to compute a parameterization while fixing the boundary and relaxing the boundary, respectively. Compared to free boundary parameterizations, fixed boundary parameterizations generate similar distortion distributions (top and middle) and find the same final feature points (bottom), but fixed boundary parameterizations take more time to optimize distortions.

Optimization.  Unfortunately, conformal parameterizations are not unique. For example, a new parameterization , where is an arbitrary Möbius transformation, contains the same conformal distortion as . However, the area distortion of and are likely to be very different. Thus, if the generated ACAP parameterizations are not appropriate, the vertices with high isometric distortion may be located incorrectly. These conditions would affect our technique’s ability to robustly detect distortion points.

In our method, is initialized by Tutte’s embedding method [12]. As observed in our experiments, if we try to minimize the MIPS and AMIPS energy while fixing the boundary vertices, the vertices with high isometric distortion often become our desired distortion points. We also test free boundary cases and observe that the distortion distribution is similar except for the distortion near boundaries. (see the comparison in Fig. 6). However, the running time of free boundary parameterization is faster. Thus, the boundary vertices are always free during the conformal distortion optimization in our experiments, which use the KP-Newton method [47] to optimize .

3.2.3 Detecting distortion points

Isometric distortion.  After achieving an ACAP parameterization , we select the vertices with high isometric distortion as our distortion points. The isometric distortion [45] is defined as follows:

(3)

If is a rotation matrix, reaches its minimum.

Input :  An ACAP parameterization
Output :  A set of distortion triangles
Compute ;
Initialize a queue , and ;
while  do
       ;
        // Pop the front of
       ;
       if  then
             ;
       end if
      ;
        // Find the median of isometric distortions on the triangles of
       ;
       ;
        // Group the connected triangles into several new isolated regions
       for  do
             if  then // is a threshold
                   ;
                    // Push at the back of
                  
             end if
            
       end for
      
end while
Algorithm 1 Distortion Triangle Detection

Clustering method.  Since the clustering method proposed in [10] is practically robust for detecting distortion points , we first review it and then modify it for our ACAP planar parameterizations.

In [10], the distortion triangles each have local maximum distortion over a region. These triangles are first detected, and then one vertex from each distortion triangle is added to . The pseudocode of the detection algorithm for is listed in Alg. 1. The threshold indicates the distortion point scale (see a more detailed discussion in Section 3.4).

In the first iteration, since contains all of the triangles, the algorithm adds the triangle with maximum distortion into and filters out half of the triangles. For some models with ACAP planar parameterizations, some distortion triangles may be filtered out by the median (see Fig. 7 left). To avoid this issue, we modify the clustering method by choosing a different strategy for the first iteration. Since our goal is to detect the triangles at the local maxima, the isometric distortion in our target triangles is at least greater than the small value . In the first iteration, we filter out the triangles with isometric distortions that are smaller than . Then, we group the remaining triangles into new isolated regions to initialize the queue . Finally, we run the “while” loop of Alg. 1 to compute using the median filter. With this simple modification, our method catches obvious distortion triangles, resulting in parameterizations with lower isometric distortion (see Fig. 7 right). In our experiments, we set in all of the models.

[width=0.99]bird3
No first filtering
With first filtering

Fig. 7: Comparison of a modification in the clustering process. If we filter half of the triangles directly in the first iteration, some feature points in the red box are missing (left). If we first filter the triangles whose area distortions are smaller than a threshold , then there will be more feature points detected (right).

3.3 Voting

We present a simple voting strategy to generate final distortion points. This strategy is based on the fact that no matter how cuts change, some vertices are almost always detected as distortion points. The voting strategy contains two steps: (1) perform the candidate distortion point generation procedure many times (ten in our experiments); and (2) vote for the candidates that appear multiple times (more than twice in our experiments) to serve as the resulting distortion points. Fig. 4 (b) shows the voting results from the candidates shown in Fig. 4 (a1–a4).

Post-filtering.  Due to numerical issues, some distortion points are very close to each other. In fact, grouping these close distortion points into one point does not affect the resulting isometric distortion (see the comparison in Fig. 8). If one distortion point is within the -ring neighbors of another distortion point , we keep the one that has more votes and discard the other one. In the experiments, we observe that the very close points always lie in one-ring or two-ring neighborhoods, so we set as 5 to filter out close points effectively.

[width=0.95]postfilter No post-filteringWith post-filtering

Fig. 8: Results of our algorithm with and without the use of post filtering. The post filtering is used to detect redundant distortion points, which are very close to each other and considered part of the same distortion point, marked in the red box (a). We remove all the other points in each small neighborhood, while leaving one point that receives the most votes as the final distortion point (b).

3.4 Implementation details

Mesh resolution.  Since we compute ACAP parametrizations many times, this process is very time-consuming for large-scale models. In fact, if a low-resolution mesh approximates the high-resolution model well and and are cut to disk topologies by similar cut paths, the distortion distributions of their planar parameterizations are similar as well. As a result, the positions of the distortion points detected by are similar to the positions detected by . Fig. 9 shows an example. In our experiments, if , our detection algorithm contains three steps:

  1. Simplify using QEM [48] to contain vertices;

  2. Detect the distortion points of the simplified mesh;

  3. For each detected distortion point, find the nearest vertex on , which becomes the resulting distortion point for .

We set in all examples. If the threshold is too small, some features may be missed. Fig. 11-left shows an example of . Note that the top of the octopus is missing, leading to high distortion.

We consider the simplification as an optional operation that aims to accelerate the computation. In our experiments, the simplification is not applied everywhere. Specifically, if the mesh has a small number of vertices, there is no need to simplify the mesh. Besides, if we do not simplify large-scale meshes, our method is still able to detect distortion points but takes more time. Our experiments show that the simplification does not affect the robustness in practice.

[width=0.99]simplification
No Simplification
With Simplification

Fig. 9: In this Armadillo model, the original mesh has 83,699 vertices and 167,394 faces. Left: If we do not use a simplification, then it takes 45.39s to compute the distortion points. Center: The simplified mesh has 13,000 vertices and 25,996 faces. The distortion points are computed on this simplified mesh. Right: The distortion points are mapped back onto the original mesh. The final distortion is similar, and this process takes only 20.37s.

[width=0.99]diffn

Fig. 10: Different values for generate different results. When is larger, there are fewer distortion points detected, and the distortion is larger.

Choice of .  The parameter controls the balance between the number of distortion points and the isometric distortion. A large value indicates that a distortion point has a large range of influence, so the number of distortion points is often small, resulting in high isometric distortion. A small value usually leads to a large number of distortion points and small isometric distortion. By default, we set if ; otherwise, . Fig. 10 shows a comparison between different values for .

[width=0.95]parameters
Simplified to 5,000, 10 candidates
Simplified to 13,000, 5 candidates
Simplified to 13,000, 10 candidates

Fig. 11: Results from different choices with other parameters. Left: If the simplified mesh has too few vertices, then the distortion point at the top of the octopus is not detected (in the red rectangle). Middle: If there are five candidate distortion detection processes, the distortion point at the top is not detected either. Right: Our default choice, simplified to 13,000 vertices and ten candidates, finds the top distortion points successfully.

Parameter selection.  There are some parameters in the voting strategy. We run ten candidate generation processes to generate candidates and select the candidate points that get at least three votes as distortion points. The reasons for these settings are based on three cases of candidate points. First, the candidate distortion points that are near the random cut have at most two votes (e.g. the points near a cut in Fig. 4 (a2) top). These points are caused by the cut and should not be involved in the final distortion points. Second, when some candidate distortion points are located very close together (as shown in the red box in Fig. 8), they are not detected at the same time in one candidate generation process. We observe that there are usually two or three candidate distortion points that are closely located in our experiments. This case should be distinguished from the first case. Third, the isolated candidate distortion points get almost all of the votes. Therefore, in ten candidate generation processes, the candidate distortion points typically get one or two votes for the first case, four or five votes for the second case, and 8 to ten votes for the third case. On one hand, if there are fewer candidate generation processes, the points in the first and second situations cannot be distinguished. On the other hand, it is feasible to conduct more candidate generation processes, but the entire algorithm requires more time to yield the final result. We show a result with five candidates in the middle of Fig. 11. In this example, the algorithm does not find the point at the top of the model, and thus producing a high-distortion result.

[width=0.90]persistence
Persistence-based method [49]
Ours

Fig. 12: Comparison with the persistence-based clustering method [49]. This method detects too many points on the camel’s head and fails to find the distortion point on its hump, which results in higher distortion.

[width=0.95]tessellation
Original
Isotropic
Anisotropic
Noisy
Sparse
Dense

Fig. 13: Our method is robust to different mesh tessellations such as noise (right top), isotropy (left middle) or anisotropy (right middle), as well as low (left bottom) and high resolution (right bottom). The anisotropic mesh is generated by the LCT method [50].

[width=0.90]gallary

Fig. 14: Gallery displaying our distortion point detection results.

4 Experiments and evaluations

We apply our distortion point detection method to various models. In Section 4.1, we first evaluate the results and components of our algorithm and then demonstrate the practical robustness of our algorithm on different tessellations and complex models. We select the Seamster [9], Geometry Images method [7], and a sphere-based clustering method [10] as the competitors (Section 4.2). The experiments were performed on a desktop PC with an Intel Core i7-4790 processor and 8GB memory.

Qualitative and quantitative evaluation methods.  Since the main purpose of finding distortion points is to decrease the distortion in parameterizations, a simple quantitative evaluation method is to conduct parameterizations and then compute the resulting distortion distribution. Specifically, we adopt the isometric distortion metric defined in [45]

to evaluate the quality of the parameterizations. Then we report the distortion distribution by offering the maximum (worst case), average, and standard deviations for all triangles, denoted as

, , and , respectively. Meanwhile, we visualize the distortion distribution by shading the triangles according to the isometric distortion, with white being optimal (See Fig. 4 (b) top). In addition, another popular visualization method we adopt is rendering mappings using a checkerboard texture with letters (See Fig. 4 (b) bottom).

4.1 Evaluations

Other clustering methods.  There are other existing clustering methods that detect points according to the distortion of a parameterization. We select one typical persistence-based method [49] to compare with the effectiveness of our method. As shown in Fig. 12, the distortion points detected by the persistence-based clustering method are inappropriate, i.e., some points are superfluous, but some important regions are not detected. In fact, the persistence-based method is regarded as a top-down approach, which finds the most significant features according to the topology persistence of the distortion. However, our clustering method is a bottom-up approach, which filters out low distortion areas hierarchically. As seen in the comparison, our bottom-up approach is more suitable for finding points that cause high distortion.

Tessellations.  In Fig. 13, distortion point detection is performed for six types of tessellations that represent the same shape. The distortion points detected by our method are in very similar places, and the isometric distortions of the parameterizations are all at a low level. Since the final distortion points are obtained by voting from several parameterizations, our method exhibits reliable results when using different tessellations as inputs.

Practical robustness.  Our method successfully detects the desired distortion points, resulting in parameterizations with low isometric distortion in all of the models. We show eleven complex models in Fig. 18, including five genus-zero models and six high-genus models. The C++ implementation for detecting distortion points for genus-zero surfaces is provided in the supplementary material.

Timings.  The running time for distortion point detection on an ant model with 10k vertices is 8.64 seconds. For a dragon model with 50k vertices, the mesh simplification and the distortion point detection take 3.44 seconds and 14.06 seconds, respectively. Thanks to the use of mesh simplification, our method takes about 15 seconds on average. The more structurally complex the input model is, the longer our method will take, since more iterations are required to compute ACAP parameterizations.

[width=0.90]seamster
Seamster [9]
Ours

Fig. 15: Comparison to the Seamster method [9] using a Beethoven model. Left: The Seamster method always finds high-curvature points, but in this example, some low curvature points also cause high distortion. Right: Our method directly detects distortion points from planar parameterizations, and therefore generates a result with lower distortion.

[width=0.90]geoimg
Geometry Images [7]
Ours

Fig. 16: Comparison with the Geometry Images [7] method using a gorilla model. Left: The result generated by the Geometry Images method has higher distortion, since some important points are not detected. Right: Our result has lower distortion.

[width=0.99]hcc
Sphere-based [10]
Ours

Fig. 17: Comparison with the sphere-based method [10] using a Ramses model. The input model contains 50,002 vertices and 100,000 triangles. The running times for the sphere-based method and our method are 42.75 seconds and 17.92 seconds, respectively. The simplification is enabled in our method.

4.2 Comparisons

4.2.1 Comparison to Seamster [9]

The Seamster method uses curvatures as guides for detecting distortion points, so the vertices with low curvatures are not recogized. However, some low curvature vertices are important for reducing isometric distortion. In Fig. 3 and Fig. 15, we compare our method to the Seamster method. Due to some missing distortion points with low curvatures, the parameterizations generated by the Seamster method often have greater distortion than ours.

4.2.2 Comparison to Geometry Images [7]

In Fig. 2 and Fig. 16, comparisons between our method and the Geometry Images method are conducted. Due to early termination issues, some important points are missed, e.g., the points at the top of the human head (Fig. 2) and the gorilla head (Fig. 16). Thus, the parameterization distortion caused by the Geometry Images method is usually higher than ours.

4.2.3 Comparison to the sphere-based method [10]

In Fig. 17, we compare our method with the sphere-based method [10]. Note that since we use a different method to compute the final parameterizations, the distortion values are different from those in [10]. The AQP method [51] and the SA method [52] are used in [10], while the progressive parameterization method [14] is used in this paper. Thus, we recompute a parameterization using the same method and measure the distortion for fair comparison. The detected distortion points are similar, so the parameterization distortion is also similar. However, as the bijective spherical parameterization takes 42.09 seconds, the sphere-based method takes more time than our method.

[width=0.90]randommodels \put(5.0,9.0){\scriptsize\parbox{0.0pt}{ }}

Fig. 18: Detected distortion points in five models from the constructed data set.

[width=0.99]histogram 1.812.441.351.31Geometry Images [7]Seamster [9]Sphere-based [10]Ours#model

Fig. 19: The histogram showing the average distortion in the results from four algorithms running on 20,000 models. The red lines with numbers show the average values.

4.2.4 Extensive comparisons

Data set construction.  To verify the robustness of our method and compare it with other methods, we construct a data set containing 20,000 random genus-zero meshes. The meshes in the data set are constructed from a primitive shape, such as a sphere, a cube, a pyramid, a dodecahedron, etc. Then, we conduct random shape manipulations, including rotation, scaling, random affine transformation, stretching, bending, twisting, random vertex perturbation, fractal displacement [53], CSG manipulations (merge, intersect, and subtract with other models), remeshing, smoothing, and simplification [54]. After each manipulation, if the mesh is not a genus zero manifold, we discard this manipulation and roll back to the previous shape. Each mesh is finally simplified or subdivided to 13,000 vertices. We show five examples in Fig. 18.

Results.  We have run the Geometry Images method [7], the Seamster method [9], the sphere-based method [10], and our method on the constructed data set. The Seamster method, the Geometry Images method, and our method succeed in all models, while the sphere-based method fails in 508 models. The sphere-based method depends on a spherical parameterization. If the input model has a long and thin neck, the sphere-based method [10] usually fails due to its spherical parameterization method [11]. Specifically, such a long and thin neck provides no enough space to insert vertices, so the spherical parameterization gets stuck in the vertex insertion phase. Since the possible vertex positions are enumerated discretely by sampling points in a triangle, if flips occur for all vertex positions, the algorithm terminates and does not generate a flip-free spherical parameterization. Fig. 18 shows its five failed examples.

The histograms in Fig. 19 show the distributions of . The average over all successful examples of [10] is higher than our method. Since some important points are not detected by the Seamster method [9] and Geometry Images method [7], their average are much higher than ours.

5 Applications

We employ our detected distortion points in three applications.

[width=0.99]autocut
Autocuts
Ours

Fig. 20: Comparison with Autocuts [1]. Left: The Autocuts method generates cuts and parameterizations simultaneously. Right: We generate a cut using a spanning tree connecting the distortion points. The ratio between the cut lengths and total edge lengths in the Autocuts method and ours are and .

[width=0.99]optcuts
OptCuts
Ours

Fig. 21: Comparison with OptCuts [39]. Left: The result is generated by the Optcuts method. Right: We generate a cut using a spanning tree connecting the distortion points. The ratio between the cut lengths and total edge lengths in the OptCuts method and ours are and .

5.1 Parameterizations

Computing parameterizations is a straightforward application of our method. Given a closed mesh, we generate a cut by simply constructing a minimal spanning tree along the mesh edges that passes through all the distortion points detected by our method. After cutting the mesh into a disk topology, any of the recent parameterization methods are able to generate a low-distortion UV map, which is used for texture mapping. In our experiments, we use the progressive parameterizations method [14] to generate UV maps and color the triangles according to the isometric distortion with red indicating high distortion. In addition, we also use a checkerboard texture with letters to show the levels of distortion.

In Fig. 20 and Fig. 21, we give a brief comparison with the recent Autocuts method [1] and OptCuts method [39]. We only adjust the parameters and in the Autocuts method to obtain results with similar distortion levels to ours. For the OptCuts method, we turn off the bijective option and also adjust the parameters to obtain similar distortion results. Then, we compare the cut lengths with these two methods. The cut lengths of our result are shorter than theirs. Moreover, our method is fully automatic and does not require any user intervention.

5.2 Semi-automatic landmark correspondence

Given two meshes, we first generate the distortion points for each mesh and use these points as corresponding landmarks, where the correspondence is manually specified. Then, we find cuts that pass through these landmarks and use the lifted bijection method [5] to compute a bijective surface mapping. We give an example of this application in Fig. 1 center, and a comparison in Fig. 22. From the comparison, we find that the locations of distortion points (center) and manually selected landmarks (top) are similar, and the distortions of the resulting inter-surface mappings are also very similar. However, if some of the distortion points are missing (bottom), the distortion becomes dramatically larger. Therefore, our method has the ability to automatically detect the most important features in models and reduce user interactions when generating inter-surface mappings.

[width=0.95]correspondence
Manually Picking
With Distortion Points
Missing Two Points

Fig. 22: The inter-surface mapping between two fish models using landmark correspondences as inputs. Here, the distortions shown in the figure are the isometric distortions of the inter-surface mappings. Top: The locations and corresponding landmarks are selected by hand. Center: The landmarks are the distortion points generated by our method and their correspondence is specified manually. Bottom: If there are some missed landmarks, the distortion is large. The manually selected landmarks are provided by [55].

[width=0.99]remesh InputIncremental remeshing[3]Parameterization2D remeshingOur result

Fig. 23: Isotropic remeshing of a dog model. Left top: The original mesh has some thin parts (e.g. the legs and the tail) and some narrow ditches (e.g. the mouth and the ears). Right top: The incremental remeshing method [3] smooths out the thin features (shown in the red box). Left bottom: Our method parameterizes the model to the plane isometrically and does isotropic remeshing on the planar mesh. Right bottom: After mapping the 2D isotropic mesh back to the original model, the thin features are correctly preserved.

5.3 Isotropic remeshing

The incremental remeshing method [3] is an efficient and effective algorithm for generating isotropic triangle meshes. Given a target edge length, this method repeatedly carries out four steps: (1) splitting long edges, (2) collapsing short edges, (3) equalizing valences using edge flipping, and (4) relocating vertices. However, certain features, such as thin parts and narrow ditches, are often collapsed (see Fig. 23-center). When a cut passes through the distortion points, we usually get a parameterization with very low isometric distortion. Since the mapping from the original surface to the parameterization domain is able to preserve isotropy, we do an isotropic remeshing on the parameterization mesh. First, we split and collapse edges on the cut before the parameterization, and fix the boundary when remeshing the 2D parameterization mesh. Then, the four aforementioned steps in the incremental remeshing method are carried out to create a 2D isotropic mesh, which is mapped back onto the original mesh. Fig. 23 shows a comparison of three dog models. The thin features collapse in the incremental remeshing method [3], while our method preserves these features successfully. The reason is that the edge lengths in [3] are computed using the 3D Euclidean distance, which yields short lengths at the thin parts; thus, the collapsing operations destroy these thin features. However, the edge lengths in our method are computed using 2D Euclidean distances that approximate the geodesic distances of an input mesh, which is able to preserves thin features. This characteristic is very useful in the error-bounded remeshing [56].

6 Conclusion

In this paper, we present a novel approach for detecting distortion points on 3D triangle meshes. This method can be further applied to planar parameterization, semi-automatic landmark correspondence, and isotropic remeshing.

Our method has some limitations. First, there is no theoretical analysis regarding the relationships between the detected distortion points and the resulting parameterization distortion. Actually, our method is empirical, based on the observation that the isometric distortion will be low if the cuts pass through the distortion points. Although cutting through the distortion points tends to generate low-distortion parameterizations, this condition is not always guaranteed. For example, as shown in Fig. 13, the noisy model has higher distortion than the others, even if the cut passes through the distortion points. The second limitation is that for a sphere-shaped mesh, our method cannot find any distortion points. The reason is that the vertices are almost all symmetrically equivalent, and the random cuts generate random candidate distortion points, each of which has only one vote.

References