当前位置:   article > 正文

图像处理(十三)保刚性图像变形算法-Siggraph 2004_图像编辑对某块区域变形处理算法

图像编辑对某块区域变形处理算法

保刚性图像变形算法

原文地址http://blog.csdn.net/hjimce/article/details/45766321 

作者:hjimce

一、相关理论

图像变形可以说是很多图像、动画领域的一个非常常见的功能,就说ps、天天P图、美图秀秀、可牛等这些每个软件,有好多个功能都要用到图像变形,比如图像方向校正、图像全景、视频防抖等,在我的另外一篇博文全景矩形还原,就要用到图像变形算法。


变形算法实现图像姿态调整


变形算法实现物体方向位置调整

可以说ps中的一些图像扭曲都是通过变形方法实现的,比如这篇paper:《As-Rigid-As-Possible Image Registration for Hand-drawn Cartoon Animations》就有讲到它的变形算法与ps的效果分析,然而我今天要讲的算法无论是在视屏防抖《Content-Preserving Warps for 3D Video Stabilization》《Bundled Camera Paths for Video Stabilization》,还是在图像全景《Rectangling Panoramic Images via Warping》等都用到这个算法,这几篇都是siggraph上的文献,对于搞图形图像的人来说,siggraph上的paper是每年必看的文章。保相似的变形算法就相当于是一个经典又好用的图像变形算法,具有保相似性,避免图像变形过程中,发生严重错切变换。好了到底是哪篇文献这么好用,那就是2005 siggraph上的一篇文献《As-Rigid-As-Possible Shape Manipulation》,这篇文献在三维网格曲面图形变形方面也具有重要的作用。

好了废话不多说,这里开始讲解As-Rigid-As-Possible Shape Manipulation》,因为这篇paper分为两个步骤,

第一步主要是实现尽量保证变形前后,每个三角形都于原来的对应三角形相似,又称之为网格模型的保相似变形。

第二步主要是为了尽量保证每个三角形与原三角形尽量全等。由于第一步中算法只是保相似,这样变形后三角形会有的被放大,有的被缩小,出现图像的局部放大与缩小,所以需要对每个三角形进行适合的缩放调整,这一步又称为拟合步,拟合变形后的每个三角形与原网格三角形全等。

一、理论讲解

(1)相对坐标的概念。开始这个算法之前,我需要先给讲解一个三角形中相对坐标的概念:给定一个三角形v0v1v2,如下图所示:


那么我们定义,v2相对于v0、v1的坐标为(x01,y01),满足:


也就是说,我们可以通过已知的一个三角形,然后建立一个以三角形的一个顶点为原点,以其邻接边、及其对应的垂直旋转90度后的方向分别作为x轴、y轴,求取三角形另外一个顶点的相对于这个坐标系的坐标。OK,如果我给你一个三角形,我要你计算出(x01,y01),你要怎么计算?这个是一个简单的数学问题,同时也是本文算法开始的第一步,具体x01、y01怎么计算,那是高中问题了,不解释

(2)整体保相似。保相似图像变形算法的原理很简单,说白了就是尽量保证变形前后,相对坐标不变,也就是说保证每个三角形的相对坐标(x12,y12)、(x20,y20)、(x01,y01)不变。因为如果两个三角形的这个相对坐标一样,那么这两个三角形就是相似三角形。那么算法具体是怎么实现尽量保证,每个三角形变形前后的这三个相对坐标不变的呢?

假设变形后的三角形顶点坐标为v0',v1',v2'。因为我们是要尽量的保证相对坐标不变,我们可以根据下面的计算公式:


计算出v2desired,然后使得如下误差最小化:



上面的能量公式越小,就代表变形后的三角形与原三角形越相似。而对于有多个三角面片的网格模型,那么总误差能量公式为:


这个问题其实归结为求解一个最小二乘问题,大家还记得吗,最小二乘其实就是使得误差能量最小化,因此到了这里其实我们就可以猜到,这个算法最后归结为求解一个稀疏的线性系统。我们的目的是使得上面的总能量最小化,设相对坐标v'=,那么:


我们的问题是要使得E1{v’}最小化,而最小化说白了就是使得其偏导数为0,因此我们需要对E1{v’}求偏导。开始前先把公式5,换另外一种形式来表达:


其中,q表示控制顶点,u表示自由顶点。对上面的式子求偏导:


把上面的式子简写为:


需要注意的是:对于控制顶点不变的模型,G'、B是一个固定的稀疏矩阵,因此我们可以通过上式求解u,得到自由顶点的坐标。

(3)局部完全保相似,及局部缩放调整。每个三角形分开重新调整,使得其与原三角形更为相似,同时对其做缩放调整。

首先,在经过上面的整体相似变换后,三角形可能进行放大或者缩小,因为我们用了三角形的内在属性相对坐标,这样只能保证所有三角形的尽量相似,并不能保证全等。如果算法直到这里就结束了,那么变形后的图像将会出现局部放大与缩小。就拿上面的瘦脸图片来说,如果只经过上面相似变换步骤,我们只是要移动脸型轮廓的特征点,而最后变形出来的结果可能就会出现眼睛等局部位置的放大,或缩小,因此我们要进行大小调整,瘦脸后,眼睛的大小与原来图像的大小相等。


就像上面图像中,图(a)是原图,图(c)的结果就是只经过相似变换后的结果,可以看到(c)中的右手部变粗了许多,而左手部变细了许多,因此我们接着这一步要做的事就是调整大小,使得(a)变形后,使得图像变形后不会出现局部放大与缩小的情况,得到如(d)结果图。

另一方面,在经过上面的整体相似变换后,因为我们用了整个三角网格模型进行整体调整,使得能量最小化,这个就像最小二乘一样,最后求解出来的结果并不能保证每个三角形与原三角形完全相似,也会发生错切变换,误差还是存在的。就像最小二乘,求解出来的结果并不能保证最后每个方程的残差为0。


在经过(2)中的相似变换后,因为我们是对网格模型的所有三角形一起调整的,保证总三角形错切变形能最小化,这个时候得到的每个三角形也不全是完全相似的一个三角形,且大小也发生了变化,如上图所示。我们得到了v0'v1'v2',这个三角形我们称之为中介三角形,接着我们要把每个三角形分开拟合成跟原三角形v0v1v2完全全等的三角形,我们定义拟合阶段的三角形变形能为:


当然我们还需要保证变形前后的也与原三角形相似:


这样联立公式(9)、(10),同时对其求偏导,使得变形能最小化:


记住,这一步是对每个三角形进行分开调整,这样才能得到与原网格模型的三角形完全相似。同时在满是上面式子后,对整个三角形以重心坐标为缩放原点,对每个三角形进行缩放调整

(4)整体拟合

上面那一部是对每个三角形分开调整,这个时候,每个三角形是完全独立的,我们需要对齐对整体连接调整,否则两个邻接三角形的共用边的两个顶点的位置各不一样,这样根本是不是三角网格模型。




整个三角网格模型的总能量为:


H是一个表示整个网格模型拓扑连接关系的矩阵,对上式换另外一种表达方式,并对其求偏导,求取最小值:

简化为:


然后重新求解,可得到自由顶点u的坐标。

二、算法流程

输入:原三角网格模型,控制顶点

输出:变形后的三角网格模型

Algorithm

1、整体相似变换

(1)计算原网格模型的相对坐标。根据给定的原三角网格模型,遍历每一个三角面片,


并计算每个顶点,相对于另外两个顶点的坐标。以计算v2相对于边v0v1的坐标为例:


(x01,y01)表示的是一个相对坐标,如果三角形的三个顶点的坐标已知v0,v1,v2,其实计算这个相对坐标是非常容易的。

(1)建立局部坐标轴。先求出边向量v0v1,然后利用v0v1求出其单位向量即为局部坐标系的x轴,接着只需要把x轴旋转90度,就可以得到y轴了。

(2)计算相对坐标(x01,y01),这一步首先需要把向量v0v2投影到x轴,y轴。这里需要注意的是我们上面的公式中x轴指的是v0v1,y轴指的是把v0v1旋转90度后的向量,因此我们需要对投影结果做一个缩放处理

相关代码实现如下:

  1. // 遍历网格模型的每个三角面片
  2. for ( unsigned int i = 0; i < nTris; ++i ) {
  3. Triangle & t = m_vTriangles[i];//第i个三角面片
  4. //计算当前三角形每个顶点相对于另外两个顶点的坐标
  5. for ( int j = 0; j < 3; ++j ) {
  6. unsigned int n0 = j;
  7. unsigned int n1 = (j+1)%3;
  8. unsigned int n2 = (j+2)%3;//三角面片三个顶点的索引
  9. Eigen::Vector2d v0 = GetInitialVert( t.nVerts[n0] );
  10. Eigen::Vector2d v1 = GetInitialVert( t.nVerts[n1] );
  11. Eigen::Vector2d v2 = GetInitialVert( t.nVerts[n2] );//三角面片三个顶点的坐标
  12. //建立局部坐标系的 x轴 与y 轴
  13. Eigen::Vector2d v01( v1 - v0 );
  14. Eigen::Vector2d v01N( v01 );
  15. v01N.normalize();//边向量v0v1的方向向量 x轴
  16. Eigen::Vector2d v01Rot90( v01(1), -v01(0) );
  17. Eigen::Vector2d v01Rot90N( v01Rot90 ); v01Rot90N.normalize();//垂直于边v0v1的方向向量 y轴
  18. //计算局部相对坐标
  19. Eigen::Vector2d vLocal(v2 - v0);
  20. float fX = vLocal.dot(v01) /SquaredLength(v01);//计算局部相对坐标x01
  21. float fY = vLocal.dot(v01Rot90) /SquaredLength(v01Rot90);//计算局部相对坐标y01
  22. Eigen::Vector2d v2test(v0 + fX * v01 + fY * v01Rot90);
  23. float fLength = Length(v2test - v2);
  24. t.vTriCoords[j] = Eigen::Vector2d(fX,fY);//局部相对坐标(x01,y01)
  25. }
  26. }

(2)构造公式(7)的相关矩阵。

  1. void RigidMeshDeformer2D::PrecomputeOrientationMatrix()
  2. {
  3. std::vector<Constraint,Eigen::aligned_allocator<Constraint> > vConstraintsVec;
  4. std::set<Constraint>::iterator cur(m_vConstraints.begin()), end(m_vConstraints.end());
  5. while ( cur != end )
  6. vConstraintsVec.push_back( *cur++ );
  7. unsigned int nVerts = (unsigned int)m_vDeformedVerts.size();
  8. m_mFirstMatrix.resize( 2*nVerts, 2*nVerts);
  9. for ( unsigned int i = 0; i < 2*nVerts; ++i )
  10. for ( unsigned int j = 0; j < 2*nVerts; ++j )
  11. m_mFirstMatrix(i,j) = 0.0;
  12. size_t nConstraints = vConstraintsVec.size();
  13. unsigned int nFreeVerts = nVerts - nConstraints;
  14. unsigned int nRow = 0;
  15. m_vVertexMap.resize(nVerts);
  16. for ( unsigned int i = 0; i < nVerts; ++i ) {
  17. Constraint c(i, vec2(0,0));
  18. if ( m_vConstraints.find(c) != m_vConstraints.end() )
  19. continue;
  20. m_vVertexMap[i] = nRow++;
  21. }
  22. for ( unsigned int i = 0 ; i < nConstraints; ++i )
  23. m_vVertexMap[vConstraintsVec[i].nVertex ] = nRow++;
  24. size_t nTriangles = m_vTriangles.size();
  25. for ( unsigned int i = 0; i < nTriangles; ++i ) {
  26. Triangle & t = m_vTriangles[i];
  27. double fTriSumErr = 0;
  28. for ( int j = 0; j < 3; ++j ) {
  29. double fTriErr = 0;
  30. int n0x = 2 * m_vVertexMap[ t.nVerts[j] ];
  31. int n0y = n0x + 1;
  32. int n1x = 2 * m_vVertexMap[ t.nVerts[(j+1)%3] ];
  33. int n1y = n1x + 1;
  34. int n2x = 2 * m_vVertexMap[ t.nVerts[(j+2)%3] ];
  35. int n2y = n2x + 1;
  36. float x = t.vTriCoords[j](0);
  37. float y = t.vTriCoords[j](1);
  38. m_mFirstMatrix(n0x,n0x)+= 1 - 2*x + x*x + y*y;
  39. m_mFirstMatrix(n0x,n1x)+= 2*x - 2*x*x - 2*y*y;
  40. m_mFirstMatrix(n0x,n1y)+= 2*y;
  41. m_mFirstMatrix(n0x,n2x)+= -2 + 2*x;
  42. m_mFirstMatrix(n0x,n2y)+= -2 * y;
  43. m_mFirstMatrix(n0y,n0y)+= 1 - 2*x + x*x + y*y;
  44. m_mFirstMatrix(n0y,n1x)+= -2*y;
  45. m_mFirstMatrix(n0y,n1y)+= 2*x - 2*x*x - 2*y*y;
  46. m_mFirstMatrix(n0y,n2x)+= 2*y;
  47. m_mFirstMatrix(n0y,n2y)+= -2 + 2*x;
  48. m_mFirstMatrix(n1x,n1x)+= x*x + y*y;
  49. m_mFirstMatrix(n1x,n2x)+= -2*x;
  50. m_mFirstMatrix(n1x,n2y)+= 2*y;
  51. m_mFirstMatrix(n1y,n1y)+= x*x + y*y;
  52. m_mFirstMatrix(n1y,n2x)+= -2*y;
  53. m_mFirstMatrix(n1y,n2y)+= -2*x;
  54. m_mFirstMatrix(n2x,n2x)+= 1;
  55. m_mFirstMatrix(n2y,n2y)+= 1;
  56. }
  57. }
  58. Eigen::MatrixXd mG00( 2*nFreeVerts, 2*nFreeVerts );
  59. ExtractSubMatrix( m_mFirstMatrix, 0, 0, mG00 );
  60. Eigen::MatrixXd mG01( 2 * (int)nFreeVerts, 2 * (int)nConstraints );
  61. ExtractSubMatrix( m_mFirstMatrix, 0, 2*nFreeVerts, mG01 );
  62. Eigen::MatrixXd mG10( 2 * (int)nConstraints, 2 * (int)nFreeVerts );
  63. ExtractSubMatrix( m_mFirstMatrix, 2*nFreeVerts, 0, mG10 );
  64. //
  65. Eigen::MatrixXd mGPrime = mG00 + mG00.transpose();
  66. Eigen::MatrixXd mB = mG01 + mG10.transpose();
  67. Eigen::MatrixXd mGPrimeInverse=mGPrime.inverse();
  68. Eigen::MatrixXd mFinal = mGPrimeInverse * mB;
  69. mFinal *= -1;
  70. m_mFirstMatrix = mFinal;
  71. }

2、局部完全相似,及大小缩放调整。

计算公式(11)的F、C矩阵:

  1. //计算公式11 F、C矩阵
  2. void RigidMeshDeformer2D::PrecomputeScalingMatrices( unsigned int nTriangle )
  3. {
  4. //遍历每个三角形
  5. Triangle & t = m_vTriangles[nTriangle];
  6. t.mF =Eigen::MatrixXd(4,4);
  7. t.mC = Eigen::MatrixXd(4,6);
  8. double x01 = t.vTriCoords[0](0);
  9. double y01 = t.vTriCoords[0](1);
  10. double x12 = t.vTriCoords[1](0);
  11. double y12 = t.vTriCoords[1](1);
  12. double x20 = t.vTriCoords[2](0);
  13. double y20 = t.vTriCoords[2](1);
  14. double k1 = x12*y01 + (-1 + x01)*y12;
  15. double k2 = -x12 + x01*x12 - y01*y12;
  16. double k3 = -y01 + x20*y01 + x01*y20;
  17. double k4 = -y01 + x01*y01 + x01*y20;
  18. double k5 = -x01 + x01*x20 - y01*y20 ;
  19. double a = -1 + x01;
  20. double a1 = pow(-1 + x01,2) + pow(y01,2);
  21. double a2 = pow(x01,2) + pow(y01,2);
  22. double b = -1 + x20;
  23. double b1 = pow(-1 + x20,2) + pow(y20,2);
  24. double c2 = pow(x12,2) + pow(y12,2);
  25. double r1 = 1 + 2*a*x12 + a1*pow(x12,2) - 2*y01*y12 + a1*pow(y12,2);
  26. double r2 = -(b*x01) - b1*pow(x01,2) + y01*(-(b1*y01) + y20);
  27. double r3 = -(a*x12) - a1*pow(x12,2) + y12*(y01 - a1*y12);
  28. double r5 = a*x01 + pow(y01,2);
  29. double r6 = -(b*y01) - x01*y20;
  30. double r7 = 1 + 2*b*x01 + b1*pow(x01,2) + b1*pow(y01,2) - 2*y01*y20;
  31. //计算F矩阵
  32. // F矩阵的第一行
  33. t.mF(0,0)= 2*a1 + 2*a1*c2 + 2*r7;
  34. t.mF(0,1)= 0;
  35. t.mF(0,2)= 2*r2 + 2*r3 - 2*r5;
  36. t.mF(0,3)= 2*k1 + 2*r6 + 2*y01;
  37. // F矩阵的第二行
  38. t.mF(1,0)= 0;
  39. t.mF(1,1)= 2*a1 + 2*a1*c2 + 2*r7;
  40. t.mF(1,2)= -2*k1 + 2*k3 - 2*y01;
  41. t.mF(1,3)= 2*r2 + 2*r3 - 2*r5;
  42. // F矩阵的第三行
  43. t.mF(2,0)= 2*r2 + 2*r3 - 2*r5;
  44. t.mF(2,1)= -2*k1 + 2*k3 - 2*y01;
  45. t.mF(2,2)= 2*a2 + 2*a2*b1 + 2*r1;
  46. t.mF(2,3)= 0;
  47. //F矩阵的第四行
  48. t.mF(3,0)= 2*k1 - 2*k3 + 2*y01;
  49. t.mF(3,1)= 2*r2 + 2*r3 - 2*r5;
  50. t.mF(3,2)= 0;
  51. t.mF(3,3)= 2*a2 + 2*a2*b1 + 2*r1;
  52. // 求逆
  53. Eigen::MatrixXd mFInverse=t.mF.inverse();
  54. mFInverse *= -1.0;
  55. t.mF = mFInverse;
  56. //计算C矩阵
  57. // C矩阵的第一行
  58. t.mC(0,0)= 2*k2;
  59. t.mC(0,1)= -2*k1;
  60. t.mC(0,2)= 2*(-1-k5);
  61. t.mC(0,3)= 2*k3;
  62. t.mC(0,4)= 2*a;
  63. t.mC(0,5)= -2*y01;
  64. // C矩阵的第二行
  65. t.mC(1,0)= 2*k1;
  66. t.mC(1,1)= 2*k2;
  67. t.mC(1,2) = -2*k3;
  68. t.mC(1,3)= 2*(-1-k5);
  69. t.mC(1,4)= 2*y01;
  70. t.mC(1,5)= 2*a;
  71. // C矩阵的第三行
  72. t.mC(2,0)= 2*(-1-k2);
  73. t.mC(2,1)= 2*k1;
  74. t.mC(2,2)= 2*k5;
  75. t.mC(2,3)= 2*r6;
  76. t.mC(2,4)= -2*x01;
  77. t.mC(2,5)= 2*y01;
  78. //C矩阵的第四行
  79. t.mC(3,0)= 2*k1;
  80. t.mC(3,1)= 2*(-1-k2);
  81. t.mC(3,2)= -2*k3;
  82. t.mC(3,3)= 2*k5;
  83. t.mC(3,4)= -2*y01;
  84. t.mC(3,5)= -2*x01;
  85. }

并求解公式11,得每个三角面片新顶点的位置

3、全局连接拟合。

构造公式(16)的相关矩阵:

  1. void RigidMeshDeformer2D::PrecomputeFittingMatrices()
  2. {
  3. std::vector<Constraint,Eigen::aligned_allocator<Constraint> > vConstraintsVec;
  4. std::set<Constraint>::iterator cur(m_vConstraints.begin()), end(m_vConstraints.end());
  5. while ( cur != end )
  6. vConstraintsVec.push_back( *cur++ );
  7. unsigned int nVerts = (unsigned int)m_vDeformedVerts.size();
  8. size_t nConstraints = vConstraintsVec.size();
  9. unsigned int nFreeVerts = nVerts - nConstraints;
  10. unsigned int nRow = 0;
  11. m_vVertexMap.resize(nVerts);
  12. for ( unsigned int i = 0; i < nVerts; ++i )
  13. {
  14. Constraint c(i,vec2(0,0));
  15. if ( m_vConstraints.find(c) != m_vConstraints.end() )
  16. continue;
  17. m_vVertexMap[i] = nRow++;
  18. }
  19. for ( unsigned int i = 0 ; i < nConstraints; ++i )
  20. m_vVertexMap[vConstraintsVec[i].nVertex ] = nRow++;
  21. Eigen::VectorXd gUTestX( nVerts ), gUTestY(nVerts);
  22. for ( unsigned int i = 0; i < nVerts; ++i )
  23. {
  24. Constraint c(i,vec2(0,0));
  25. if ( m_vConstraints.find(c) != m_vConstraints.end() )
  26. continue;
  27. int nRow = m_vVertexMap[i];
  28. gUTestX[nRow] = m_vInitialVerts[i].vPosition(0);
  29. gUTestY[nRow] = m_vInitialVerts[i].vPosition(1);
  30. }
  31. for ( unsigned int i = 0; i < nConstraints; ++i ) {
  32. int nRow = m_vVertexMap[ vConstraintsVec[i].nVertex ];
  33. gUTestX[nRow] = vConstraintsVec[i].vConstrainedPos[0];
  34. gUTestY[nRow] = vConstraintsVec[i].vConstrainedPos[1];
  35. }
  36. Eigen::MatrixXd mHX( nVerts, nVerts );
  37. Eigen::MatrixXd mHY( nVerts, nVerts );
  38. for ( unsigned int i = 0; i < nVerts; ++i )
  39. for ( unsigned int j = 0; j < nVerts; ++j )
  40. mHX(i,j) = mHY(i,j) = 0.0;
  41. size_t nTriangles = m_vTriangles.size();
  42. for ( unsigned int i = 0; i < nTriangles; ++i ) {
  43. Triangle & t = m_vTriangles[i];
  44. double fTriSumErr = 0;
  45. for ( int j = 0; j < 3; ++j ) {
  46. double fTriErr = 0;
  47. int nA = m_vVertexMap[ t.nVerts[j] ];
  48. int nB = m_vVertexMap[ t.nVerts[(j+1)%3] ];
  49. mHX(nA,nA)+= 2;
  50. mHX(nA,nB)+= -2;
  51. mHX(nB,nA)+= -2;
  52. mHX(nB,nB)+= 2;
  53. mHY(nA,nA)+= 2;
  54. mHY(nA,nB)+= -2;
  55. mHY(nB,nA)+= -2;
  56. mHY(nB,nB)+= 2;
  57. }
  58. }
  59. Eigen::MatrixXd mHX00( (int)nFreeVerts, (int)nFreeVerts );
  60. Eigen::MatrixXd mHY00( (int)nFreeVerts, (int)nFreeVerts );
  61. ExtractSubMatrix( mHX, 0, 0, mHX00 );
  62. ExtractSubMatrix( mHY, 0, 0, mHY00 );
  63. Eigen::MatrixXd mHX01( (int)nFreeVerts, (int)nConstraints );
  64. Eigen::MatrixXd mHX10( (int)nConstraints, (int)nFreeVerts );
  65. ExtractSubMatrix( mHX, 0, nFreeVerts, mHX01 );
  66. ExtractSubMatrix( mHX, nFreeVerts, 0, mHX10 );
  67. Eigen::MatrixXd mHY01( (int)nFreeVerts, (int)nConstraints );
  68. Eigen::MatrixXd mHY10( (int)nConstraints, (int)nFreeVerts );
  69. ExtractSubMatrix( mHY, 0, nFreeVerts, mHY01 );
  70. ExtractSubMatrix( mHY, nFreeVerts, 0, mHY10 );
  71. m_mHXPrime = mHX00;
  72. m_mHYPrime = mHY00;
  73. m_mDX = mHX01;
  74. m_mDY = mHY01;
  75. m_mLUDecompX=Eigen::FullPivLU<Eigen::MatrixXd>(m_mHXPrime);
  76. m_mLUDecompY=Eigen::FullPivLU<Eigen::MatrixXd>(m_mHYPrime);
  77. }

这篇paper的总思路就是分成三步,因为如果控制顶点、和自由顶点的没有发生变化,相关的矩阵只要经过第一次求解就可以了,因此可以实现实时拖拽更新,这个我在三维图形学网格曲面变形的时候,用到的拉普拉斯网格变形的方法思路大体相同,需要对原网格模型做预处理操作,然后才能实现实时变形。具体这个算法要和图像结合起来,就要对图像进行三角剖分,然后计算每个三角形的放射变换矩阵,根据仿射变换矩阵计算每个像素点值的变化,才能对图像进行变形,具体就不贴代码了,因为这一些代码都是比较简单的,没有什么技术含量在里面。

参考文献

1、http://www-ui.is.s.u-tokyo.ac.jp/~takeo/research/rigid/

2、《As-Rigid-As-Possible Shape Manipulation》

************* 作者:hjimce     联系qq:1393852684   更多资源请关注我的博客:http://blog.csdn.net/hjimce                  原创文章,转载请保留本行信息*****************

声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:【wpsshop博客】
推荐阅读
相关标签
  

闽ICP备14008679号