Eurographics Symposium on Geometry Processing (2004), pp.1-7 R. Scopigno, D. Zorin, (Editors)

Consistent Spherical Parameterization

Abstract Many applications benefit from surface parameterization, including texture mapping, morphing, remeshing, compression, object recognition, and detail transfer, because processing is easier on the domain than on the original irregular mesh. We present a method for simultaneously parameterizing several genus-0 meshes possibly with boundaries onto a common spherical domain, while ensuring that corresponding user-highlighted features on each of the meshes map to the same domain locations. We obtain visually smooth parameterizations without any cuts, and the constraints enable us to directly associate semantically important features such as animal limbs or facial detail. Our method is robust and works well with either sparse or dense sets of constraints.

Figure 1: By spherically embedding a set of models such that corresponding user-provided features map to the same spherical locations, we enable applications such as principal component analysis as shown on the right. Stretch efficiencies (left to right): 0.847, 0.795, 0.879, 0.884, 0.827.

1. Introduction

Several applications in computer graphics, such as texture mapping, compression, surface processing, detail synthesis, and object recognition rely on mesh parameterization. Parameterization refers to computing mappings between surfaces in 3D and simpler domains such as planar regions, simplicial domains, or spheres. To be useful for these varied applications, the mappings must satisfy several properties, such as continuity, bijectivity, smoothness, constraint satisfaction, and acceptable distribution of domain area over the surface. We propose a method for computing maps with these properties for a set of genus-zero objects.

Many parametrization techniques involve partitioning the surface into simpler pieces using cuts. Such discontinuities are problematic for applications involving a large number

of models, since they can lead to fragmentation of the map (i.e. smaller and smaller pieces across which there is a continuous map between all models). Fragmentation can be avoided by producing parameterizations with consistent cuts, but this is difficult for many models with dissimilar geometry, and may require extra user input such as specifying the cut connectivity. Moreover, the resulting map generally lacks smoothness along cuts and at their junctions.

Continuous parameterizations are only possible between topologically equivalent models. For the genus-zero models that we consider, the unit sphere is a natural parameterization domain since it is inherently smooth. While spherically parameterizing geometrically complex models with many extremities incurs some distortion, this distortion is acceptable for most models. And, in addition to being continuous, the mapping is also smooth since derivative discontinuities are only imposed by the model

submitted to Eurographics Symposium on Geometry Processing (2004)

2

discretization itself, not by the domain. We extend the work of Praun and Hoppe [P ] on spherical parameterization to allow simultaneous parameterization of multiple objects.

H03

GH02 H03

HSW03

H04

LPRM02 DMA02 SGH01

VSS00

H03

SGH01

SG03

Simplicial parameterization. To avoid parameterization cuts, the domain must have the same topology as the given surface. One such approach is to use a simplicial domain (a simplified base mesh). Simplicial domains work for arbitrary genus, but are not smooth and typically impose derivative discontinuities in the map at vertices and edges of the base domain. To smooth these discontinuities, Lee et al. [LSS*98] apply relaxation based on Loop subdivision, and Guskov et al. [G ] iterate smoothing a mesh region corresponding to a base domain 1-ring of faces. Khodakovsky et al. [KLS03] eliminate edge discontinuities by setting up a global system that implicitly unfolds adjacent domain faces.

Besides producing continuous maps, allowing the user to specify constraints is another important requirement in many applications, since it provides a way to incorporate higher-level semantic knowledge about the objects. Without constraints it would be difficult for instance to texture map a face and have the eyes appear in the correct place. Constraints can be either “soft” – to be satisfied in least squares sense, or “hard” – to be satisfied exactly. In either case, imposing constraints makes the parameterization problem more challenging, since the algorithms typically lose theoretical guarantees of bijectivity, preservation of metrics, etc.

Spherical parameterization. Discontinuities can be avoided altogether by mapping models to smooth domains of the same topology, such as the unit sphere for genus-zero models. Examples of spherical parameterization methods include [Ale00; GGS03; PH03].

Using consistent spherical parameterizations, one can create consistent geometry images [G ;P ] representing several objects in a database, opening the door to a large array of applications that work on regular grids, including: compression (the stacked geometry images form a volume which can be compressed using voxel techniques), conversion to hardware-supported subdivision surfaces with displacement maps [L ], natural LODs, etc.

Since we build upon the method of Praun and Hoppe [P ], we briefly summarize it here. To spherically parameterize a mesh, they first convert it to progressive mesh format [Hop96] with a tetrahedral base domain. They map this tetrahedron to a regular one inscribed in the unit sphere, and then run through the progressive mesh sequence from coarse to fine, introducing new vertices and mapping them to the sphere while optimizing their location as well as those of their immediate neighbors. A new vertex can always be mapped inside the kernel of the spherical polygon of its 1-ring neighborhood, which is guaranteed to be non-empty. To optimize a vertex’s spherical location, it is moved inside its one-ring kernel using a sequence of random-direction spherical arc searches. The energy being minimized corresponds to the L2 stretch of the whole map, but since only the configuration inside the 1-ring neighborhood changes, it is only computed locally. The stretch on each triangle equals the trace of the linear map metric tensor, and corresponds to the square of the L2 average of linear distance scaling over all surface directions [S ].

This paper introduces a method for computing consistent parameterizations with point feature constraints between several genus-zero objects, possibly with boundaries. We map the objects to the sphere, while guaranteeing continuity, bijectivity, visual smoothness, and minimizing overall distortion. Specifically, we present the following contributions: • robust construction of consistent spherical

parameterizations for several surfaces, • constrained spherical parameterization where specified

points on a mesh map to given points on the sphere, • methods to avoid swirls (bad homotopy classes of the

map), and to correct them when they arise.

2. Previous Work Parameterization constraints. Several methods address the problem of parameterization under constraints. Lévy [Lev01] texture maps meshes under soft constraints by introducing additional terms in the quality metric. Eckstein et al. [ESG01] propose a method for satisfying hard constraints for planar parameterization.

The earliest parameterization methods established mappings to planar domains. There have been many methods developed to date; for a survey we refer the reader to Floater and Hormann [F ]. Unless applied to topological discs, these methods must cut the mesh into one or several pieces, introducing discontinuities in the parameterization. To measure and minimize the mapping distortion, these methods employ various quality metrics, such as conformality (angle preservation) [e.g. EDD*95;

; ] or stretch minimization [S ]. Stretch minimization avoids excessive scaling of domain distances onto the surface, which is particularly important for applications involving regular sampling of the domain. Since our goal is regular remeshing, we use a stretch metric. However, the method could easily be modified to work with conformal metrics and irregular sampling.

Kraevoy et al. [K ] start with an unconstrained planar parameterization and then move the constrained vertices to their required positions by matching a triangulation of these positions to a triangulation of the planar mesh formed by the paths between constrained vertices. Finally, they relax this parameterization while keeping the constraints. They demonstrate results involving a fairly large number of features. In contrast, our method works well even with few provided feature points. In addition, we use a multiresolution approach to avoid forming an initial parameterization and then optimizing it. In our earlier attempts, such initial parameterizations (necessarily based on conformal metrics) suffered from

submitted to Eurographics Symposium on Geometry Processing (2004)

Consistent Spherical Parameterizations 3

numerical precision problems when applied to large patches (such as mapping 10k vertices on a horse leg to a single planar triangle). Consistent parameterization. Praun et al. [P ] consistently parameterize a set of genus-0 models onto a simplicial complex. Unlike their method, we do not impose a fixed consistent connectivity of the base domain, but only satisfy the given point constraints, thereby providing the map more freedom. Whereas their simplicial domain is abstract (with no inherent geometry), our spherical domain geometry is explicit. This implies that paths must be straight arcs on the sphere, rather than arbitrary meandering mesh paths, which makes the problem more difficult. One advantage of the lack of domain connectivity is the opportunity to improve the map by flipping edges, like in Delaunay refinement.

SS01

CP03CP03

Several researchers have addressed the problem of creating databases of human faces or bodies. These methods use specific knowledge of the objects being represented to create a carefully tuned template that can be geometrically fitted to the raw data. Blanz and Vetter [BV99] use optical flow to find dense correspondences between a set of faces represented as meshes with disc topology. Their algorithm benefits from the implicit 2D parameterization of the input data given by its cylindrical coordinates. Marschner et al. [MGR00] fit a template subdivision surface to laser scans of faces using 25-30 user-selected features as soft constraints, and then obtain surface correspondences using normal-piercing. Allen et al. [A ] use 74 physical markers on whole-body human scans to obtain the soft constraints, and optimize the smoothness and the fit of the transforms that need to be applied to the template subdivision mesh vertices to approximate each scan.

ic knowledge of the objects being represented to create a carefully tuned template that can be geometrically fitted to the raw data. Blanz and Vetter [BV99] use optical flow to find dense correspondences between a set of faces represented as meshes with disc topology. Their algorithm benefits from the implicit 2D parameterization of the input data given by its cylindrical coordinates. Marschner et al. [MGR00] fit a template subdivision surface to laser scans of faces using 25-30 user-selected features as soft constraints, and then obtain surface correspondences using normal-piercing. Allen et al. [A ] use 74 physical markers on whole-body human scans to obtain the soft constraints, and optimize the smoothness and the fit of the transforms that need to be applied to the template subdivision mesh vertices to approximate each scan.

3. Approach 3. Approach

Given a set of meshes and corresponding feature points, we form a consistent parameterization of all the meshes. That is, we produce for each surface an embedding onto the unit sphere such that corresponding feature points across the different meshes map to the same location on the sphere.

Given a set of meshes and corresponding feature points, we form a consistent parameterization of all the meshes. That is, we produce for each surface an embedding onto the unit sphere such that corresponding feature points across the different meshes map to the same location on the sphere.

Our approach has two major parts. First, we find good spherical feature locations, such that the final maps have low distortion and distribute the sphere area adequately to the various parts of the input meshes. Second, we create a constrained spherical parameterization for each surface, forcing the feature points to map to the computed locations. Here is the algorithm in more detail (see also ). Let Mi (i=1..n) be the initial meshes, P be a parameterization, and F a set of spherical feature locations.

Our approach has two major parts. First, we find good spherical feature locations, such that the final maps have low distortion and distribute the sphere area adequately to the various parts of the input meshes. Second, we create a constrained spherical parameterization for each surface, forcing the feature points to map to the computed locations. Here is the algorithm in more detail (see also ). Let Mi (i=1..n) be the initial meshes, P be a parameterization, and F a set of spherical feature locations.

Figure 2Figure 2

Step 1

⊕

Step 2 Steps 3,4 Step 5 Step 6

Figure 2: Steps of the algorithm. For clarity, steps 3-5 show a coarser version of the remesh grid than the one actually used. The features in step 5 are vertices of the finer grid. Stretch efficiencies: gargoyle 0.632, bunny 0.697.

1. (1. ( 1P1P′ , F ′ ) := UnconstrainedSphericalParam( 1M ) //Initial feature locations F ′ on sphere using one model.

2. For i=2..n, iP′ := ConstrainedSphericalParam( iM , F ′ ) //Parameterize all models using those initial locations.

3. For i=1..n, RiM := Remesh( iM , ) iP′

//Remesh to n geometry images w/ identical connectivities.

4. *RM := { 1

RM , 2RM , … , R

nM } //Concatenate to single mesh w/ vertex coordinates in R3n.

5. (PR,F) := UnconstrainedSphericalParam( *RM )

//Find good feature locations considering all models.

6. For i=1..n, Pi := ConstrainedSphericalParam( iM , F) //Compute final parameterizations using these locations.

The main new procedure is the constrained spherical parameterization used in steps 2 and 6. It is described in

submitted to Eurographics Symposium on Geometry Processing (2004)

4

detail in Section 4. The remaining steps are adapted from earlier work [P ]. In step 3 we need to exactly represent the feature points, so we snap the closest grid samples to the spherical locations . Step 5 involves the construction of a progressive mesh for the special mesh

H03

F ′*RM with

geometry in R3n. We modify the quadric error metric of Garland and Heckbert [GH97] to sum each of the n errors in R3. We also modify the spherical parameterization [P ] to sum the n stretch energies from the sphere to the n mesh geometries in R

H03

SGH01

SG03

SS01

SG03

VSS00

3.

The candidate pool is populated initially by shortest paths between all the feature pairs, computed using a Dijkstra search on mesh vertices. When we select the best candidate path we check to see if it intersects any paths already inserted in the network and if it does we re-compute it using a restricted search. These restricted searches can also use edge midpoints in addition to mesh vertices (though with a cost penalty), corresponding to inserting “Steiner” vertices in the original mesh [K ].

Consistent neighbor ordering and the initial construction of a spanning tree of the feature vertices ensure that the path layout algorithm will always terminate in a topologically valid triangulation [PSS01]. To improve the geometric quality of the triangulation we employ a set of heuristics to avoid and fix swirls (Section 4.1) and we flip edges by replacing them with the other diagonal of the quad formed by the two adjacent patches. We perform this operation only when the new path is shorter and the new configuration is valid on the sphere.

4. Constrained Spherical Parameterization

As the algorithm presented above shows, the key challenge in our approach is to spherically parameterize a surface while ensuring that a given set of feature points map exactly to specified locations on the sphere. Additionally, we want to preserve the robustness and low distortion properties of the unconstrained spherical parameterization of [PH03]. We adapt their method to work with constraints as follows. 4.1. Dealing with swirls

During coarse-to-fine refinement, we can simply fix the spherical location of feature vertices. The difficulty is to bootstrap the algorithm by creating a valid starting state that satisfies all constraints. Specifically, we must create a progressive mesh representation of the surface where the base domain contains only feature vertices and is triangulated the same way as the spherical features (see

).

Homotopy defines a set of equivalence classes for maps between two surfaces in the presence of constraints. Two maps belong to the same class if there exists a continuous deformation between them that maintains the constraints. Any optimization algorithm that continuously deforms the parametrization such as [PH03] always remains within a homotopy class. It is therefore important to initialize the parametrization in a good configuration. Some homotopy classes appear bad to a human observer because paths take unnecessarily long routes around other feature vertices. We call a swirl the local configuration of these long paths (Figure 4).

Figure 3

Figure 3: "Triangulations" of features on the sphere (left)and mesh (middle); base mesh after simplification (right).

To satisfy this, we need only find a spherical triangulation and a corresponding embedding of its arcs onto the mesh, given by a set of non-intersecting paths. Once we have such a path network, we simplify the mesh to produce a progressive mesh, but we keep the feature vertices, and only allow vertices on the feature paths to be collapsed into other path or feature vertices [S ].

Praun et al. [PSS01] note that swirls cannot be repaired using 1-ring relaxations of patches around a vertex [G ], and propose several heuristics to prevent them. Unfortunately we do not benefit from a user-provided base domain, so some of their heuristics do not work in our case. Furthermore, our setting is harder since the spherical locations of the feature points obtained in steps 1 and 5 of the algorithm (Section 3) may be quite different from preferred spherical locations considering the geometry of the current mesh, and neighbor ordering constraints based on these spherical locations may prevent the insertion of many paths that look good on the mesh. To address this problem, we develop a more robust set of swirl-avoiding heuristics, as well as a method to identify and remove swirls after they have appeared.

To produce the path network on the 3D surface, we use a method similar to those of Praun et al. [PSS01] and Kraevoy et al. [K ]. We link together pairs of feature points, with great circle arcs on the sphere, and paths on the mesh, until we complete a full “triangulation”. The paths (and arcs) cannot intersect each other except at feature vertices (and their spherical locations). The algorithm proceeds in greedy fashion, selecting the best pair from a pool of candidates. To guarantee both termination and topological equivalence of the two “triangulations”, we maintain consistent ordering of neighbors around each vertex in the partially completed graph, and we avoid adding any arcs/paths closing cycles before we have linked all the vertices in a spanning tree [P ].

Figure 4: Swirl on the horse leg: the white patch (right) has to connect to B, but it does so around A. It cannot be straightened since it would have to move over A and AB.

submitted to Eurographics Symposium on Geometry Processing (2004)

Consistent Spherical Parameterizations 5

Swirl-avoiding heuristics. The main tool we use in selecting new paths to insert in the network is their ranking in the priority queue. Paths are normally ranked according to their surface length (shorter is better), but they are occasionally penalized (placed at the end of the queue) when certain conditions occur. Such conditions include: • The current path links non-extreme vertices, and there

are still some extremities left unconnected. Extremities are features with large average distance to their nearest neighbors (such as legs, arms, etc.). We start the spanning tree construction by linking such features. If left unconnected they might cause swirls since paths linking other vertices go around the base of the extremity, equally likely on the “correct” as on the “wrong” side. • The spherical image of the path would create spherical

triangles with very small angles (<10° in our examples). In these cases the winding order of the 3 feature locations on the sphere is not reliable. Furthermore, skinny triangles make the spherical optimization less robust. • Failed sidedness tests for neighboring features. We

check whether the projection of a feature vertex onto the path (computed using unrestricted Dijkstra from the neighbor to the path) is on the same side as the projection of the corresponding feature point onto the arc on the sphere. If some of the vertices are on different sides on the mesh and the sphere, we try to force the path to lie on the correct side of nearby feature vertices. To do this we add temporary constraint paths from the path endpoints to the neighboring feature. We now trace the shortest path on the mesh. The path so traced will be on the correct side of all the features in the connected component of the neighbor. However, this might not always be possible as the addition of the temporary constraint paths might form a cycle enclosing either the source or the destination vertex on different sides on the mesh and the sphere. In such cases, we add the path to the end of the queue.

Unswirl operator. In addition to using heuristics that avoid swirls (as Praun et al. did [P ]), we have also developed a method to identify and remove them in the rare cases that they do occur. Paths between two features incident to many other “long” paths (with high ratios between actual length and geodesic distance between endpoints) are likely to be the center of swirls. To fix them, we remove all paths incident to the two vertices, and then replace them in a new order, introducing first paths that were previously bad (so they have a chance to use a more direct route now that some of the old nearby constraints are absent).

SS01

4.2. Mesh boundaries

Meshes with boundaries pose a challenge for the algorithm since each hole must be in correspondence in the different models. To deal with boundaries we need to impose feature path constraints in addition to points. We cannot directly apply the solution for boundaries from spherical parameterization [PH03], since in that work the holes

typically keep their perimeter on the sphere relatively constant but shrink to a region with almost zero area and jagged outline. A few point constraints would not keep these regions in correspondence across different models.

We treat holes by placing a number of feature vertices (the same number for all the input meshes) around each hole and marking the paths between them as path constraints. During the spherical parameterization (steps 1, 2, 5, and 6 of the algorithm) vertices along a constrained path are only allowed to move on the spherical arc between the two neighbors that are also on the path, rather than in the full kernel of their 1-ring polygon. Step 3 (and the possible remesh after step 6) has to be modified such that the remesh exactly samples the feature paths. This can be done by splitting some of the remesh triangles using the spherical arc corresponding to the path, if the remesh does not need regular connectivity (such as the intermediate remesh used in steps 3-5), or by snapping nearby remesh vertices if ones desires a purely regular connectivity (such as when constructing geometry images based on the spherical parameterization).

The feature vertices at the ends of the boundary paths can move on the sphere during the coarse-to-fine optimization only when the adjacent paths are single edges (i.e. there are no intermediate vertices along the path). Otherwise, the constraint that the intermediate vertices lie on the arc between the endpoints would be broken. To maximize the coarse-to-fine window during which these vertices can be optimized, when we create the progressive mesh we first remove vertices on boundary paths.

5. Results and applications

Figure 1 illustrates the basic approach for applications making use of large model databases. To create the database, a few representative models are selected and consistently parameterized using our algorithm, in order to obtain good spherical locations for the 22 feature points. Note that the hole at the necks was mapped to a spherical triangle with very small area, and yet did not collapse to a point (due to tangential stretch along the boundary). In our example we used the 5 heads shown out of a set of 8. The remaining models can be subsequently added to the database by running constrained spherical parameterization (step 6 of our algorithm). Note that not all feature vertices need to be specified for the new models, but the initial models to be parameterized should contain the largest set of features that the database may need in correspondence. Once the database is created, the consistent parameterization can be used for tasks such as classification and retrieval based on principal component analysis. On the right side of Figure 1 we show the average of our set of heads, and the first three principal components (visualized added to the average head). Real-world instances of such applications may include databases of scanned heads or bodies, or brain surfaces from MRI.

Figure 5 demonstrates the role of steps 3-6 of the algorithm. Performing constrained parameterization with

submitted to Eurographics Symposium on Geometry Processing (2004)

6

the feature locations determined by just one of the models leads to poor maps with large distortion for the other models. Optimizing the locations using all the models results in much better maps. Even though step 1 makes the process biased towards one model of the set, the common optimization in step 5 removes this asymmetry.

Consistent parameterizations can also be used to transfer mesh properties, such as geometric detail (the high-frequency components of a multiresolution mesh representation), normals, colors, or texture coordinates. Figure 6 demonstrates examples of color and normals transfer between two heads.

Figure 7

SG03

gives an additional example of consistently parameterized models. This example is challenging due to the great variation in geometry between the models, and their many long extremities that test the robustness of the base domain construction algorithm and of the spherical parameterization. To illustrate the quality of the parameterization and the correspondence between the features, we show morphs between pairs of models as well as various points in the linear interpolation space between the four models.

Our path layout procedure introduces between 0.5% and 2.8% new “Steiner” vertices in our examples. These numbers are similar to those reported by Kraevoy et al. [K ]. For applications involving remeshing, inserting new vertices in the original meshes is not an issue.

Table 1

Figure 5: Parameterization quality improves after optimizing the map taking into account all models. Toprow: spherical images showing location of feature points.Bottom: regular remesh using spherical parameterization.Left column: feature locations are computed using onlycow model. Right: feature locations computed using allmodels in Figure 7.

Steps Models 1 2 5 6 Total time

Fig. 1 19 81 8 95 203 Fig. 2 10 5 5 17 37 Fig. 7 2 23 7 24 56

Table 1: Timing results (in minutes) for the heads example(Figure 1), bunny and gargoyle example (Figure 2), and 4 animals (Figure 7). The timings for steps 2 and 6 arecumulative for the different models in the set.

shows timing results for our method. It takes about 10min to run one 100k face model through our pipeline. For small meshes, step 5 is the most expensive

since it involves several geometries simultaneously. However, when the original meshes are very dense (for example, some of the heads in have 300k faces), the remeshes used in steps 3-5 can have lower complexity, and in that case step 6 becomes the most expensive one.

Figure 1

Figure 6: The texture and normals of the head on the left are combined with the geometry of the head in the middle to produce the one on the right.

Figure 7: Top: original models with 20 feature points. Row 2: consistent geometry images. Row 3: consecutive 50% pair-wise morphs. Bottom: 4-way morphs (ratios 1/2 – 1/6 – 1/6 – 1/6 resp.). Similar maps in [PSS01] used 54 features. Stretch efficiencies: 0.322, 0.316, 0.341, 0.286.

submitted to Eurographics Symposium on Geometry Processing (2004)

Consistent Spherical Parameterizations

submitted to Eurographics Symposium on Geometry Processing (2004)

7

6. Summary and future work

We have presented a robust algorithm for parameterizing genus-zero models onto a sphere in the presence of feature constraints. The central part of the algorithm, constrained spherical parameterization is guaranteed to produce topologically equivalent spherical triangulations and mesh patch partitions, and avoids awkward swirl configurations through a collection of novel heuristics. The heuristics described in Section 4.1 suffice to produce good results in all the examples we tried. For simpler cases (not shown here) involving a small number of geometrically similar models a subset of the heuristics suffice.

The regularly sampled consistent geometry images that can be obtained using our parameterizations allow digital geometry processing applicable to many real-world applications.

As future work, we envision a multiresolution version of our path tracing algorithm that speeds up the Dijkstra searches. We could apply our treatment of mesh boundaries to internal feature path constraints. However, mapping these feature paths to straight arcs on the sphere might be limiting in some applications. For remeshing, it would be useful to give the user some control over the discretization of these feature paths. We are also working on extending our matching algorithm to higher genus.

Acknowledgements

References

[Ale00] ALEXA, M. 2000. Merging polyhedral shapes with scattered features. The Visual Computer, 16(1), pp. 26-37.

[ACP03] ALLEN, B., CURLESS, B., AND POPOVIĆ, Z. 2003. The space of human body shapes: reconstruction and parameterization from range scans. SIGGRAPH 2003, pp. 587-594.

[BV99] BLANZ, V. AND VETTER, T. 1999. A morphable model for the synthesis of 3D faces. ACM SIGGRAPH 99, pp. 187-194.

[DMA02] DESBRUN, M., MEYER, M., AND ALLIEZ, P. 2002. Intrinsic parameterizations of surface meshes. Computer Graphics Forum, 21 (2002), pp. 209-218.

[EDD*95] ECK, M., DEROSE, T., DUCHAMP, T., HOPPE, H., LOUNSBERY, M., AND STUETZLE, W. 1995. Multiresolution analysis of arbitrary meshes. ACM SIGGRAPH 95, pp. 173-182.

[ESG01] ECKSTEIN, I., SURAZHSKY, V. AND GOTSMAN, C. 2001. Texture mapping with hard constraints. Eurographics 2001, pp. 95-104.

[FH04] FLOATER, M. AND HORMANN K. 2004. Recent advances in surface parameterization. Multiresolution in geometric modeling 2004.

[GH97] GARLAND, M. AND HECKBERT, P. 1997. Surface simplification using quadric error metrics. ACM SIGGRAPH 97, pp. 209-216.

[GGS03] GOTSMAN, C., GU, X. AND SHEFFER, A. 2003. Fundamentals of spherical parameterization for 3D meshes. SIGGRAPH 2003, pp. 358-364.

[GGH02] GU, X., GORTLER, S., AND HOPPE, H. 2002. Geometry images. ACM SIGGRAPH 2002, pp. 356-361.

[GVSS00] GUSKOV, I., VIDIMČE, K., SWELDENS, W., AND SCHRÖDER, P. 2000. Normal meshes. ACM SIGGRAPH 2000, pp. 95-102.

[Hop96] HOPPE, H. 1996. Progressive meshes. ACM SIGGRAPH 96, pp. 99-108.

[KLS03] KHODAKOVSKY, A., LITKE, N., AND SCHRÖDER, P. 2003. Globally smooth parameterizations with low distortion. ACM SIGGRAPH 2003, pp. 350-357.

[KSG03] KRAEVOY, V., SHEFFER, A. AND GOTSMAN, C. 2003. Matchmaker: constructing constrained texture maps. SIGGRAPH 2003, pp. 326-333.

[LSS*98] LEE, A., SWELDENS, W., SCHRÖDER, P., COWSAR, L., AND DOBKIN, D. 1998. MAPS: Multiresolution adaptive parameterization of surfaces. ACM SIGGRAPH 98, pp. 85-94.

[Lev01] LÉVY, B. 2001. Constrained texture mapping for polygonal meshes. ACM SIGGRAPH 2001, pp. 417-424.

[LPRM02] LÉVY, B., PETITJEAN, S., RAY, N., AND MAILLOT, J. 2002. Least squares conformal maps for automatic texture atlas generation. ACM SIGGRAPH 2002, pp. 362-371.

[LHSW03] LOSASSO, F., HOPPE, H., SCHAEFER, S. , WARREN, J. 2003. Smooth geometry images. Eurographics Symposium on Geometry Processing 2003, pp. 138-145.

[MGR00] MARSCHNER, S.R., GUENTER, B., AND RAGHUPATHY, S. 2000. Modeling and rendering for realistic facial animation. Eurographics Workshop on Rendering, pp. 231-242.

[PH03] PRAUN, E. AND HOPPE, H. 2003. Spherical parameterization and remeshing. ACM SIGGRAPH 2003, pp. 340-350.

[PSS01] PRAUN, E., SWELDENS, W. AND SCHRÖDER, P. 2001. Consistent mesh parameterizations. ACM SIGGRAPH 2001, pp. 179-184.

[SSGH01] SANDER, P., SNYDER, J., GORTLER, S., AND HOPPE, H. 2001. Texture mapping progressive meshes. ACM SIGGRAPH 2001, pp. 409-416.