图形处理（十二）拉普拉斯网格优化、最小二乘网格模型光顺

看这篇博文前，请先参考我的另外一篇博文《图形处理（三）简单拉普拉斯网格变形-Siggraph 2004》学习拉普拉斯坐标的相关理论知识。这里要分享的paper，是通过拉普拉斯的方法实现三角网格模型的优化。如果你已经非常熟悉三角网格曲面的拉普拉斯相关理论，实现这篇paper也就非常容易了。网格曲面的拉普拉斯坐标不但可以用于变形、光顺，还可以用于优化，总之好处多多，你只要学会了这一招，那么就可以学会这些算法了。

一、优化原理

利用Laplacian 坐标重建的方法进行网格光顺，原理很简单，最简单的就是只要把源网格模型Laplacian 坐标δ的模长缩小，方向不变，就可以然后进行Laplacian 网格重建，就可以实现简单的光顺效果。

然而如果要进行网格优化呢？怎么实现？大牛们告诉我们一个比较规则的网格模型一个特点：当网格曲面上任意顶点的局部片中包含的所有三角面片都为等腰三角形时，该顶点的同一Laplacian 坐标和余切Laplacian 坐标相等。当将上述结论由某一个三角面片扩展到整个模型表面时可以发现：如果所有的三角面片都接近于正三角形，所有顶点的同一Laplacian 坐标和余切Laplacian 坐标接近相等。

ok，上面的原理便是paper的思想，只要你懂得了抓住这个思想，那么算法实现起来就容易了。

在三角网格曲面上，顶点vi的拉普拉斯坐标定义为，vi点与其一邻接顶点加权组合的差：

当然权重wij需要满足归一化

权值的选取很多，但比较常用的权值是均匀权、余切权，其计算公式如下：

二、网格优化算法实现

算法原理主要是：

1、通过先求解网格曲面余切权计算得到的Laplacian 坐标δ

2、构建均匀权下的拉普拉斯矩阵A

3、然后求解AX=δ.

[cpp] view plain copy

1. void CMeshOptimize::OptimizeMesh(TriMesh*Tmesh)  
2. {  
3.     Tmesh->need_neighbors();  
4.     int vn=Tmesh->vertices.size();  
5.     //拉普拉斯矩阵设置  
6.     int count0=0;  
7.     vector<int>begin_N(vn);  
8.     for (int i=0;i<vn;i++)  
9.     {     
10.         begin_N[i]=count0;  
11.         count0+=Tmesh->neighbors[i].size()+1;  
12.     }  
13.     typedef Eigen::Triplet<double> T;  
14.     std::vector<T> tripletList(count0+vn);  
15.     for(int i=0;i<vn;i++)  
16.     {  
17.         int nei_n=Tmesh->neighbors[i].size();  
18.         tripletList[begin_N[i]]=T(i,i,-1.0*nei_n);  
19.         for (int k = 0;k<nei_n;++k)   
20.         {  
21.             tripletList[begin_N[i]+k+1]=T(i,Tmesh->neighbors[i][k],1);  
22.         }  
23.     }  
24.     //约束矩阵设置  
25.     m_boundary_wieght=100*m_contrain_weight;  
26.     for (int i=0;i<vn;i++)  
27.     {  
28.         if(Tmesh->is_bdy(i))tripletList[count0+i]=T(vn+i,i,m_boundary_wieght);  
29.         else tripletList[count0+i]=T(vn+i,i,m_contrain_weight);  
30.     }  
31.   
32.     SparseMatrixType Ls(2*vn,vn);   
33.     Ls.setFromTriplets(tripletList.begin(), tripletList.end());  
34.   
35.     //最小二乘解超静定方程组  
36.     SparseMatrixType ls_transpose=Ls.transpose();  
37.     SparseMatrixType LsLs =ls_transpose* Ls;  
38.     vector<Eigen::VectorXd> RHSPos;//超静定方程组右边  
39.     Compute_RHS(RHSPos);  
40.     Eigen::SimplicialCholesky<SparseMatrixType>MatricesCholesky(LsLs);  
41.     #pragma omp parallel for  
42.     for (int i=0;i<3;i++)  
43.     {  
44.         Eigen::VectorXd xyzRHS=ls_transpose*RHSPos[i];  
45.         Eigen::VectorXd xyz=MatricesCholesky.solve(xyzRHS);  
46.         for(int j=0;j<vn;j++)  
47.         {  
48.             Tmesh->vertices[j][i]=xyz[j];  
49.         }  
50.     }  
51.       
52. }  
53. //设置方程组右边项  
54. void CMeshOptimize::Compute_RHS(vector<Eigen::VectorXd> &RHSPos)  
55. {  
56.     int vn=m_OptimizeMesh->vertices.size();  
57.     m_OptimizeMesh->need_neighbors();  
58.     m_OptimizeMesh->need_adjacentfaces();  
59.     RHSPos.clear();  
60.     RHSPos.resize(3);  
61.     for (int i=0;i<3;i++)  
62.     {  
63.         RHSPos[i].resize(2*vn);  
64.         RHSPos[i].setZero();  
65.     }  
66.   
67.     int fn=m_OptimizeMesh->faces.size();  
68.     m_OptimizeMesh->need_adjacentedges();  
69.     #pragma omp parallel for  
70.     for (int i=0;i<vn;i++)  
71.     {     
72.         vector<float>CotWeight;  
73.         float SumWeight;  
74.         CotangentWeights(m_OptimizeMesh,i,CotWeight,SumWeight);  
75.         int nei_n=m_OptimizeMesh->neighbors[i].size();  
76.         //归一化  
77.         vector<int>&a=m_OptimizeMesh->neighbors[i];  
78.         vec ls;  
79.         for (int j=0;j<nei_n;j++)  
80.         {     
81.             ls=ls+CotWeight[j]*m_OptimizeMesh->vertices[a[j]];  
82.         }  
83.         ls=ls-SumWeight*m_OptimizeMesh->vertices[i];  
84.         for (int j=0;j<3;j++)  
85.         {  
86.             RHSPos[j][i]=ls[j];  
87.         }  
88.     }  
89.     for (int i=vn;i<2*vn;i++)  
90.     {  
91.         for (int j=0;j<3;j++)  
92.         {     
93.             if(m_OptimizeMesh->is_bdy(i-vn))RHSPos[j][i]=m_OptimizeMesh->vertices[i-vn][j]*m_boundary_wieght;  
94.             else RHSPos[j][i]=m_OptimizeMesh->vertices[i-vn][j]*m_contrain_weight;  
95.         }  
96.     }  
97.   
98.   
99. }  
100. //计算一阶邻近点的各自cottan权重  
101. void CMeshOptimize::CotangentWeights(TriMesh*TMesh,int vIndex,vector<float>&vweight,float &WeightSum)  
102. {     
103.     int NeighborNumber=TMesh->neighbors[vIndex].size();  
104.     vweight.resize(NeighborNumber);  
105.     WeightSum=0;  
106.     vector<int>&NeiV=TMesh->neighbors[vIndex];  
107.     for (int i=0;i<NeighborNumber;i++)  
108.     {  
109.         int j_nei=NeiV[i];  
110.         vector<int>tempnei;  
111.         Co_neighbor(TMesh,vIndex,j_nei,tempnei);  
112.         float cotsum=0.0;  
113.         for (int j=0;j<tempnei.size();j++)  
114.         {  
115.             vec vivo=TMesh->vertices[vIndex]-TMesh->vertices[tempnei[j]];  
116.             vec vjvo=TMesh->vertices[j_nei]-TMesh->vertices[tempnei[j]];  
117.             float dotvector=vivo DOT vjvo;  
118.             dotvector=dotvector/sqrt(len2(vivo)*len2(vjvo)-dotvector*dotvector);  
119.             cotsum+=dotvector;  
120.         }  
121.         vweight[i]=cotsum/2.0;  
122.         WeightSum+=vweight[i];  
123.     }  
124.     for (int k=0;k<NeighborNumber;++k)  
125.     {  
126.         vweight[k]=NeighborNumber*vweight[k]/WeightSum;  
127.     }  
128.     WeightSum=NeighborNumber;  
129.   
130. }  
131. void CMeshOptimize::Co_neighbor(TriMesh *Tmesh,int u_id,int v_id,vector<int>&co_neiv)  
132. {  
133.     Tmesh->need_adjacentedges();  
134.     vector<int>&u_id_ae=Tmesh->adjancetedge[u_id];   
135.     int en=u_id_ae.size();  
136.     Tedge Co_Edge;  
137.     for (int i=0;i<en;i++)  
138.     {  
139.         Tedge &ae=Tmesh->m_edges[u_id_ae[i]];  
140.         int opsi=ae.opposite_vertex(u_id);  
141.         if (opsi==v_id)  
142.         {  
143.             Co_Edge=ae;  
144.             break;  
145.         }  
146.     }  
147.     for (int i=0;i<Co_Edge.m_adjacent_faces.size();i++)  
148.     {  
149.         TriMesh::Face af=Tmesh->faces[Co_Edge.m_adjacent_faces[i]];  
150.         for (int j=0;j<3;j++)  
151.         {  
152.             if((af[j]!=u_id)&&(af[j]!=v_id))  
153.             {  
154.                 co_neiv.push_back(af[j]);  
155.             }  
156.         }  
157.     }  
158. }  

至此三角网格的优化可以说算法讲完了。因为算法比较简答，本篇文章篇幅比较小，所以在这篇博文中顺便讲一下最小二乘网格的相关概念。

参考文献：Laplacian Mesh Optimization

三、最小二乘网格相关理论

这边顺便讲一下最小二乘网格，最小二乘网格最初的概念来源于paper《Least-squares Meshes》，我最初看到最小二乘网格这个概念是在paper《基于最小二乘网格的模型变形算法》中看到的，因为之前学习微分域的网格变形算法的时候，基本上对每种变形算法都有看过相关的paper，用最小二乘网格的方法实现网格变形，其实跟基于多分辨率的网格变形算法是一样的，都是对低频空间中的网格模型进行变形操作。

最小二乘网格模型又称为全局的拉普拉斯光顺网格，就是通过把网格模型的拉普拉斯坐标设置为0，然后求解拉普拉斯方程：

即：

其中权重wij为：

这样重建求解的网格即为最小二乘网格，也是一个光顺后的网格模型，因为该模型的拉普拉斯坐标全部为0。

当然求解上面的方程还需要控制顶点，控制顶点的个数对效果的影响还是蛮大的，可以看一下下面这个图：

总之就是控制顶点的个数越少，越是光顺。

在paper《Least-squares Meshes》中还演示了通过给定的拓扑链接关系，进行网格补洞，与原网格模型的区别。

本文地址：http://blog.csdn.net/hjimce/article/details/46505863     作者：hjimce     联系qq：1393852684   更多资源请关注我的博客：http://blog.csdn.net/hjimce                原创文章，版权所有，转载请保留本行信息。

参考文献：

1、《Least-squares Meshes》

2、《Laplacian Mesh Optimization》

3、《基于最小二乘网格的模型变形算法》