Download presentation

Presentation is loading. Please wait.

1
**Texture-Mapping Progressive Meshes**

SIGGRAPH 2001 Texture-Mapping Progressive Meshes Pedro V. Sander Steven J. Gortler John Snyder Hugues Hoppe Harvard University Microsoft Research

2
**Texture-Mapping Progressive Meshes**

SIGGRAPH 2001 Texture-Mapping Progressive Meshes Pedro V. Sander Steven J. Gortler John Snyder Hugues Hoppe As you can see, this was an international effort. Harvard University Microsoft Research

3
**progressive mesh 69,000 faces 15,000 faces 600 faces**

Given an original high resolution mesh, mesh simplification can produce a progressive mesh that captures a continuous set of approximating meshes.

4
**simplified mesh + normal map Conveys detail of original geometry**

69,000 faces 15,000 faces 600 faces progressive mesh 600 faces The detail that is lost during simplification can be approximated using a normal map, as shown on the 600-face mesh on the lower-right. In order to accomplish this, we must create a texture-map parametrized over the progressive mesh. simplified mesh + normal map Conveys detail of original geometry

5
**Authoring: map a texture image onto a surface**

“Texture mapping” Authoring: map a texture image onto a surface

6
**“Texture mapping” Authoring: map a texture image onto a surface**

Our problem: sample an existing surface signal One common problem in texture-mapping is to apply an existing image onto a surface with minimal distortion, like for instance <C> this mandrill image onto the cat head mesh. There has been a lot of work done on that front, and in fact that is the topic of the next talk. <C>But our intent is not to create parametrizations for authoring. Instead, our goal is to create a parametrization for representing an existing signal already associated with the mesh surface. Rather than optimizing the placement of the texture over the mesh, We want to create a parametrization that best captures the appearance with the fewest texture samples. For instance, consider <C>this 3D checkered pattern on the cat head. After constructing the parametrization, we sample the signal, creating a texture-map, such as this<C>, which can then be used for rendering.

7
Our problem Sample the surface signal into a texture: (e.g. normal, displacement, BRDF, …) Goals: single texture for entire PM sequence quality metrics minimize appearance changes over PM efficiently distribute the texture samples Our problem is to represent a surface signal by use of a texture map. There exist many types of signals, for instance normal maps, or solid textures. Our goals are the following; We would like create a single texture image that can be used to texture all meshes in a progressive mesh sequence. We want to simultaneously satisfy two quality metrics. The texture parametrization should minimize appearance changes over the PM. Also, it should efficiently distribute the texture samples. That is, we want to avoid undersampling the signal, since that would cause blurring. <DEMO>Let me show a demonstration of our result. So, here we have a high resolution mesh, and we simplify it… <DOWN> As you can see the detail is lost during simplification <Dt> Now I can turn on texture-mapping, and as you can see it faithfully captures the detail at all levels of the PM sequence. <UP><DOWN> demo

8
Our problem Sample the surface signal into a texture: (e.g. normal, displacement, BRDF, …) Goals: single texture for entire PM sequence quality metrics minimize appearance changes over PM efficiently distribute the texture samples Let’s first see how can a single texture image be used for all levels of detail.

9
**Simple approach: chart-per-face**

[Soucy 96, Cignoni 98, Sander 00] 500 faces atlas of 500 triangles Define texture for single-LOD mesh. Cannot use texture for any simpler mesh! A simple texture mapping approach is to create an atlas such that each face is its own texture chart. So, for the 500 face mesh shown on the left, we have an atlas of 500 triangles on the right. Note that adjacent faces on the surface are generally not adjacent in the texture, as shown here <C>, Therefore, if we simplify the mesh, we cannot use this texture map anymore.

10
**Our approach: multi-face charts**

Partition mesh into charts. Simplify respecting chart topology. [Cohen 98] Same texture still applicable. So our approach is to partition the mesh into a set of charts, and then simplify the mesh respecting these chart boundaries, as in the work of Cohen et al. With this approach, the same texture is applicable to all levels of detail.

11
**Chart constraint 1: Faces cannot span chart boundaries**

We must respect certain chart constraints in order to be able to use the same texture for all LOD’s of the PM. The first constraint is that faces cannot span chart boundaries. At a coarser level we could never introduce the simplified triangle shown in yellow on the left, since the face will not be texture-mapped correctly, as shown on the right.

12
**Chart constraint 2: Texture boundaries must be straight**

fine mesh Note that the chart boundaries meander a bit on the fine mesh, shown on the top left. In texture domain, the boundaries must be straight, because at the coarsest level they will be mapped to single edges of the mesh, as shown on the lower-left. coarse mesh texture map

13
Our problem Sample the surface signal into a texture: (e.g. normal, displacement, BRDF, …) Goals: single texture for entire PM sequence quality metrics minimize appearance changes over PM efficiently distribute the texture samples Now lets go over the quality metrics.

14
**Parametrization quality metrics**

(1) Minimize texture deviation (stricter than geometric error) [Cohen et al 98] demo First we want to minimize texture deviation, or “slippage”, as introduced by Cohen et al. We will use this metric during simplification. Slippage is stricter than geometric error, as it measures the displacement of texture samples in the 3D domain. [DEMO] Let me demonstrate this. Slippage error is any movement of texture samples in 3D. Note the texture detail shifting around. Even though the surface geometry can be highly accurate, there may be significant texture deviation, as shown here.

15
**Parametrization quality metrics**

(2) Minimize texture stretch undersampling Also, we want to minimize stretch, or minimize undersampling of the parametrization. For instance, using the 2D texture on the left, the presence of large stretched dots indicate that a large portion of the surface is being mapped to a small portion of the texture. That’s undesirable. The parametrization on the right shows significantly less stretch on the hands and toes. 2D texture high stretch low stretch

16
**Parametrization quality metrics**

(2) Minimize texture stretch blurring As you can see, if we use the parametrization for normal mapping, those stretched regions result in blurring, as you can see on the fingers. high stretch low stretch

17
**Contributions: Texture mapping PM’s**

470 faces 700 faces 1,200 faces 10,000 faces Chartification algorithm (considers simplification quality) Texture stretch metric (penalizes undersampling) Parametrization algorithm (minimizes stretch) PM optimization The overall contribution of our work is an automatic system to texture-map progressive meshes. In order to achieve that goal, we develop an algorithm to break up the mesh into charts. This algorithm considers simplification quality. We devise a texture-stretch metric to parametrize the mesh penalizing undersampling of the texture. We develop an algorithm to create a parametrization for a single-resolution mesh that minimizes this stretch metric. Finally, we develop an algorithm to optimize this parametrization over the entire PM sequence.

18
Approach Now lets briefly outline the steps in our approach. We will then revisit each in more detail. First, we partition the mesh into charts. <C> (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

19
Approach Then we parametrize each chart by creating a 1-to-1 mapping from the surface region to a 2D polygon as shown on the right. <CC> This process is repeated for each chart. <CC> Then we resize the texture charts according to their stretch. So charts that have more stretch get more texture area. <CC> Next we simplify the mesh <C><C><C> <CC> Then we optimize the parametrization over the entire PM minimizing stretch and deviation at all LOD’s <CC> We then pack the charts in a square texture. <CC> Finally we sample the texture images. <CC> Now we have a texture-mapped PM. <C><C><C> (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

20
Approach (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

21
Approach (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

22
Approach (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

23
Approach (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

24
Approach (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

25
Approach (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

26
Approach (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

27
Approach: Details Now we will cover some of these steps in more detail. First the chartification step.<c> (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

28
**Partition: chart merging**

Assign each face to its own region. Merge regions in greedy fashion based on planarity distance2 to best-fitting plane compactness perimeter length2 Preserves mesh connectivity. [Maillot 93], [Eck 95], [Lee 98], [Garland 01] There are several previous methods for chartification. The one that most closely relates to ours is the independent work of Garland et al. We start by assigning each face to its own region. Then we merge regions in a greedy fashion based on a weighted combination of two criteria: -planarity, which we measured as the squared distance to the best-fitting plane. -and compactness, which we measured as the squared perimeter length. And that’s because we desire our charts to be convex and have straight boundaries. Our resulting chartification preserves mesh connectivity. So no faces are split and the mesh remains identical to the input mesh.

29
**Partition: boundary straightening**

Then as a post-process, we straighten the chart boundaries of the resulting charts. This improves the parametrization because the boundaries must be straight in the texture domain. Improves parametrization (boundary will be straight in texture domain)

30
Approach: Details One of our main contributions is a new approach to parametrize individual charts. (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

31
**Parametrization linear map singular values: γ , Γ g G**

2D texture domain surface in 3D In a parametrization, <C>each triangle in the texture domain is linearly mapped to its respective triangle on the mesh surface. <C>If we draw a unit circle on the triangle on the texture domain, it will map to an ellipse on the surface. The lengths of the principal axes of this ellipse are the singular values of the linear map, little gamma, and big gamma. <C>These singular values measure how much distances in texture space get stretched onto the surface. We wish to avoid large singular values, as the resulting stretch leads to signal undersampling. g G

32
**Parametrization linear map T singular values: γ , Γ**

2D texture domain surface in 3D An ideal parametrization would be isometric. That is, it would preserve lengths, and therefore angles too. It corresponds to having both singular values equal to 1 everywhere. Unfortunately, this is rarely achievable for arbitrary surfaces. A conformal parametrization is one that preserves angles. The two singular values are equal. Still, those values can be arbitrarily large, causing a surface triangle to be mapped to a small triangle in the texture domain. This leads to undersampling. In an area-preserving parametrization, the product of the singular values is 1. Still, one of those values can be significantly larger than the other. So an equilateral triangle can map to a skinny long triangle of the same area. This anisotropic stretch leads to undersampling in certain directions. length-preserving (isometric) γ = Γ = 1 angle-preserving (conformal) γ = Γ area-preserving γ Γ = 1

33
**Stretch-minimizing parametrization**

linear map T singular values: γ , Γ 2D texture domain surface in 3D To minimize undersampling, we introduce metrics that directly penalize stretch. Our L^infinity metric is simply the larger singular value. It is a conservative bound on stretch over all directions. Our L^2 metric averages stretch over all directions. This too can be represented as a simple function of the singular values. <C>These two metrics can be minimized over the entire mesh surface. For the L^infinity norm, we just take the max stretch over all the faces. The L^2 metric is averaged over all the faces of the mesh weighted by face area. We have found the L^infinity norm to be an overly conservative measure of stretch, so we use the L^2 metric. L∞(T) = Γ L2(T) = √(γ2 + Γ2)/2 L∞(M) = maxT L∞(T) L2(M) = √ T (L2(T))2 A(T)

34
**Stretch-minimization algorithm**

demo Stretch-minimization algorithm Start with uniform parametrization. Perform several optimization iterations: for each vertex, try random line searches. We minimize our stretch norm using the following algorithm. For each chart we compute an initial parametrization using uniform edge springs, as shown on the middle figure. We then perform several optimization iterations tweaking the vertices randomly. We optimize one vertex at a time, using random line search. We constrain the vertex to remain within the ring of neighbors, to prevent any flipping. The result obtained is shown on the right. Here is a quick demo. [DEMO] Let me do it once more [DEMO] It usually takes 500 to 1000 or so iterations to converge.

35
**Parametrization example**

Let’s see how the method works in sampling a given signal. Here, we parametrize the mesh chart shown on the right, resulting in the parametrization shown on the left. <C>Our goal is to represent this 3D checkered signal. <C>Using the parametrization, we sample the signal and store it on the texture map, as shown now on the left. Then we texture-map the mesh using the sampled texture, and <C>this is what we get. <C>Note that some regions of the surface got mapped to small regions of the texture, resulting in blurring.

36
**Comparison Conformal parametrization L2 stretch minimization**

(≈ MIPS, Floater) L2 = L = 10.07 The example we just saw was generated using a traditional conformal parametrization scheme, specifically the harmonic map. Other schemes, such as MIPS and Floater, give very similar results. Below is a comparison with our parametrization obtained by stretch minimization. Note that it creates a much more balanced distribution of samples on the surface, resulting in less undersampling. Quantitatively, the stretch measure is also greatly reduced, both in the L2 and Linifnity norms. L2 stretch minimization L2 = L = 2.13

37
**Comparison Uniform parametrization L2 stretch minimization**

L2 = L = 12.52 Here we compare our results with the uniform-edge-spring parametrization, which yields slightly worst results than the harmonic map for this model. L2 stretch minimization L2 = L = 2.13

38
**Comparison Area-preserving parametrization L2 stretch minimization**

L2 = L = 4.19 Our parametrization algorithm can also minimize an area-preservation metric. Although each triangle gets its fair share of texture area, there may be significant stretch in certain directions, resulting in texturing artifacts. L2 stretch minimization L2 = L = 2.13

39
**Example of stretch minimization**

demo Now lets see how stretch minimization improves results on a complete model. [DEMO] These highly stretched red dots on the fingers and toes of the parasaur will result in lost detail. Also note here on the back of the head, there are also some stretched out dots. ignoring stretch minimizing stretch

40
**Approach: Details Half-edge collapses ordered by deviation**

Having constructed a surface parametrization, we then simplify the mesh. We perform half edge collapses, ordered by their resulting texture deviation errors. We devised a simple memoryless heuristic to measure texture-deviation. For details on this heuristic, please refer to the paper. We constrain simplification in order to prevent discontinuities and parametric degeneracies. <C><C><C> (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images Half-edge collapses ordered by deviation Constrained simplification

41
Approach: Details Finally, we optimize the parametrization over the entire PM sequence (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

42
**Parametrization optimization**

Min ∑M in PM stretch(M) + deviation(M) Improves deviation over entire range. Improves stretch at coarser LOD’s (stretch was ignored during simplification). We do that by minimizing the weighted sum of stretch and deviation over all LOD’s. This improves deviation over the entire range and it improves stretch at coarser LOD’s since stretch was ignored during simplification.

43
Approach: Details Next we will go over our packing algorithm (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images

44
**Pack chart polygons NP-Hard problem. We designed a heuristic.**

Packing is NP-hard even for rectangles. So we designed a heuristic to solve it.

45
**Packing Heuristic Calculate the minimum bounding rectangle.**

Rotate chart to make rectangle vertical. First we calculate the minimum bounding rectangle of the chart. Then we rotate the chart to make the rectangle vertical.

46
**Chart placement Sort chart rectangles by height.**

Sequentially place left-to-right and right-to-left. Then we sort the rectangles by height, and sequentially place them left-to-right and right-to-left. This is a similar approach to the independent work of Igarashi. ~[Igarashi 01]

47
**Approach: Details mipmap artifacts!**

Finally, we sample the texture images. <C> Note that mipmapping hardware will take averages over large texture regions. If we leave the inter-chart regions unfilled, mipmap artifacts become apparent. To mitigate this, we apply a pull-push algorithm to fill the empty regions with more reasonable values. (1) partition original mesh into charts (2) parametrize charts (3) resize chart polygons (4) simplify mesh (5) optimize parametrization (6) pack chart polygons (7) sample texture images mipmap artifacts!

48
**Results (Measurements)**

Scale charts to meet low-stretch requirement. Stretch efficiency 3D surface area / 2D chart area Packing efficiency 2D chart area / texture domain area Texture efficiency stretch efficiency * packing efficiency 3D area / texture domain area / / To measure the efficiency of our texture sampling, we introduce some quantitative definitions. We define stretch efficiency to be the 3D surface area over the scaled 2D chart area. Since the charts are scaled to have a worst case stretch of 1, the stretch efficiency is always less than or equal to 1. Packing efficiency is measured as the occupied area of the chart over the entire texture domain area. Finally, we define the overall texture efficiency to be the product of the stretch efficiency and the packing efficiency. Note that all these efficiencies have an upper bound of 1. /

49
**Results Efficiencies on fine meshes: Models bunny parasaur horse hand**

# faces in Mn 69,630 43,866 96,956 60,856 # charts 75 120 60 uniform param. stretch efficiency 0.63 0.003 0.61 0.11 our stretch efficiency 0.84 0.80 0.68 packing efficiency 0.67 0.70 0.62 texture efficiency 0.56 0.40 0.42 Here are some efficiency results. These results are corrections to those presented in the paper. As you can see, stretch efficiency is improved significantly from uniform parametrization to our stretch-minimizing parametrization. The most significant improvement was in the parasaur, that went from a .003 stretch efficiency to .63. That’s mainly due to the stretch on the fingers and toes.

50
**Results across PM deviation stretch uniform min-stretch**

These graphs show deviation and stretch over the meshes in a progressive mesh sequence of a horse model. The blue curve shows a traditional uniform parametrization approach from previous work. The green curve shows our stretch minimization approach. And, the red curve shows the result of our PM optimization. Note the significant improvement in deviation when using min-stretch. For this particular model, the stretch was not improved significantly over the uniform parametrization. As you can see, the final PM optimization yielded a slight improvement in deviation over the entire PM range. It also improved stretch at a given range of the PM. That’s because stretch was ignored during simplification, so it could get arbitrarily bad. <DEMO> Now I will show a quick demo of the deviation error. This bunny mesh is texture-mapped with a marble solid texture. The one on the left uses a uniform parametrization while the one on the right uses our min-stretch parametrization. Note that on the left, you can notice some deviation error over this range of the PM, while on the right, using our parametrization scheme, there is much less slipping. uniform min-stretch min-stretch+optim demo

51
**Demos demo demo <DEMO1>Now I will show a couple of demos.**

<DOWN> Here we simplify this parasaur mesh with texture-mapping on. <Dt> Note the loss of detail when we toggle texture-mapping off. <Dt> <DEMO2> <DOWN> Now lets look at this gargoyle model. We can go to a pretty coarse resolution and the normal mapped model still looks accurate. Here are the faces being rendered.

52
**Summary Automatic PM parametrization scheme.**

Optimizes both deviation and stretch. Novel stretch metric prevents undersampling at all locations and in all directions. Robust parametrization algorithm. In summary, we introduced an automatic method to parametrize a progressive mesh. It allows a single texture image to be used for all levels of detail. Our method seeks to minimize both texture deviation and texture stretch on all meshes in the progressive mesh sequence. We introduced a novel stretch metric. This new metric penalizes undersampling at all locations and in all directions. We presented a robust algorithm for minimizing this nonlinear stretch norm.

53
**Future work Use hierarchical parametrization. Constrain anisotropy.**

Consider content of texture signal. Address mip-mapping problems. Now I will outline a few directions for future work. The parametrization algorithm can be very slow for high resolution meshes. We are currently working on a hierarchical parametrization algorithm that should yield significant speed improvement. Another interesting area of future work would be to constrain anisotropy of the parametrization. Although current graphics hardware can handle some factor of anisotropy, our current parametrizations sometimes exceed this factor. We are also looking into creating parametrizations that consider the frequency content of an input texture, in order to create a parametrization that is optimized for that specific texture. Another area of future work is to look into ways of addressing the mipmap artifacts caused when texture-mapping meshes using multiple charts.

Similar presentations

OK

Iso-charts: Stretch-driven Mesh Parameterization using Spectral Analysis Kun Zhou, John Snyder*, Baining Guo, Heung-Yeung Shum Microsoft Research Asia.

Iso-charts: Stretch-driven Mesh Parameterization using Spectral Analysis Kun Zhou, John Snyder*, Baining Guo, Heung-Yeung Shum Microsoft Research Asia.

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google