常常需要最圖像進行仿射變換，仿射變換後，我們可能需要將原來圖像中的特徵點坐標進行重新計算，獲得原來圖像中例如眼睛瞳孔坐標的新的位置，用於在新得到圖像中繼續利用瞳孔位置坐標。

仿射變換在：http://blog.csdn.net/xiaowei_cqu/article/details/7616044這位大牛的博客中已經介紹的非常清楚。

關於仿射變換的詳細介紹，請見上面鏈接的博客。

我這裡主要介紹如何在已經知道原圖像中若干特徵點的坐標之後，計算這些特徵點進行放射變換之後的坐標，然後做一些補充。

** 在原文中，很多功能函數都是使用的cvXXX，例如cv2DRotationMatrix(center,degree,1,&M); 這些都是老版本的函數，在opencv2以後，應該盡量的使用全新的函數，所以在我的代碼中，都是使用的最新的函數，不再使用 cvMat， 而是全部使用 Mat 類型。 **

1. 特徵點對應的新的坐標計算

假設已經有一個原圖像中的特徵點的坐標 CvPoint point; 那麼計算這個point的對應的仿射變換之後在新的圖像中的坐標位置，使用的方法如下函數：

[cpp] view plain copy
  1. //獲取指定像素點放射變換後的新的坐標位置
  2. CvPointgetPointAffinedPos(constCvPoint&src,constCvPoint￠er,doubleangle)
  3. {
  4. CvPointdst;
  5. intx=src.x-center.x;
  6. inty=src.y-center.y;
  8. dst.x=cvRound(x*cos(angle)+y*sin(angle)+center.x);
  9. dst.y=cvRound(-x*sin(angle)+y*cos(angle)+center.y);
  10. returndst;
  11. }

要特別注意的是，在對一個原圖像中的像素的坐標進行計算仿射變換之後的坐標的時候，一定要按照仿射變換的基本原理，將原來的坐標減去仿射變換的旋轉中心的坐標，這樣仿射變換之後得到的坐標再加上仿射變換旋轉中心坐標纔是原坐標在新的仿射變換之後的圖像中的正確坐標。

下面給出計算對應瞳孔坐標旋轉之後的坐標位置的示例代碼：

[cpp] view plain copy

  1. //AffineTransformation.cpp:Definestheentrypointfortheconsoleapplication.
  2. //
  4. #include"stdafx.h"
  5. #include"stdio.h"
  6. #include"iostream"
  8. #include"opencv2/opencv.hpp"
  10. usingnamespacestd;
  11. usingnamespacecv;
  13. //獲取指定像素點放射變換後的新的坐標位置
  14. CvPointgetPointAffinedPos(constCvPoint&src,constCvPoint￠er,doubleangle);
  15. MatImageRotate(Mat&src,constCvPoint&_center,doubleangle);
  16. MatImageRotate2NewSize(Mat&src,constCvPoint&_center,doubleangle);
  18. int_tmain(intargc,_TCHAR*argv[])
  19. {
  20. stringimage_path="D:/lena.jpg";
  21. Matimg=imread(image_path);
  22. cvtColor(img,img,CV_BGR2GRAY);
  24. Matsrc;
  25. img.copyTo(src);
  28. CvPointLeye;
  29. Leye.x=265;
  30. Leye.y=265;
  31. CvPointReye;
  32. Reye.x=328;
  33. Reye.y=265;
  35. //drawpupil
  36. src.at<unsignedchar>(Leye.y,Leye.x)=255;
  37. src.at<unsignedchar>(Reye.y,Reye.x)=255;
  39. imshow("src",src);
  41. //
  42. CvPointcenter;
  43. center.x=img.cols/2;
  44. center.y=img.rows/2;
  46. doubleangle=15L;
  48. Matdst=ImageRotate(img,center,angle);
  50. //計算原特徵點在旋轉後圖像中的對應的坐標
  51. CvPointl2=getPointAffinedPos(Leye,center,angle*CV_PI/180);
  52. CvPointr2=getPointAffinedPos(Reye,center,angle*CV_PI/180);
  54. //drawpupil
  55. dst.at<unsignedchar>(l2.y,l2.x)=255;
  56. dst.at<unsignedchar>(r2.y,r2.x)=255;
  58. //Matdst=ImageRotate2NewSize(img,center,angle);
  59. imshow("dst",dst);
  62. waitKey(0);
  63. return0;
  64. }
  66. MatImageRotate(Mat&src,constCvPoint&_center,doubleangle)
  67. {
  68. CvPoint2D32fcenter;
  69. center.x=float(_center.x);
  70. center.y=float(_center.y);
  72. //計算二維旋轉的仿射變換矩陣
  73. MatM=getRotationMatrix2D(center,angle,1);
  75. //rotate
  76. Matdst;
  77. warpAffine(src,dst,M,cvSize(src.cols,src.rows),CV_INTER_LINEAR);
  78. returndst;
  79. }
  81. //獲取指定像素點放射變換後的新的坐標位置
  82. CvPointgetPointAffinedPos(constCvPoint&src,constCvPoint￠er,doubleangle)
  83. {
  84. CvPointdst;
  85. intx=src.x-center.x;
  86. inty=src.y-center.y;
  88. dst.x=cvRound(x*cos(angle)+y*sin(angle)+center.x);
  89. dst.y=cvRound(-x*sin(angle)+y*cos(angle)+center.y);
  90. returndst;
  91. }

這裡，我們先通過手工找到瞳孔坐標，然後計算在圖像旋轉之後瞳孔的坐標。

運行結果如圖：

原圖像

旋轉之後的圖像：

2. 旋轉中心對於旋轉的影響

然後我們看看仿射變換旋轉點的選擇對於旋轉之後的圖像的影響，一般情況下，我們選擇圖像的中心點作為仿射變換的旋轉中心，獲得的旋轉之後的圖像與原圖像大小一樣。

計算代碼：

[cpp] view plain copy

  1. int_tmain(intargc,_TCHAR*argv[])
  2. {
  3. stringimage_path="D:/lena.jpg";
  4. Matimg=imread(image_path);
  5. cvtColor(img,img,CV_BGR2GRAY);
  7. Matsrc;
  8. img.copyTo(src);
  11. CvPointLeye;
  12. Leye.x=265;
  13. Leye.y=265;
  14. CvPointReye;
  15. Reye.x=328;
  16. Reye.y=265;
  18. //drawpupil
  19. src.at<unsignedchar>(Leye.y,Leye.x)=255;
  20. src.at<unsignedchar>(Reye.y,Reye.x)=255;
  22. imshow("src",src);
  24. //
  25. /*CvPointcenter;
  26. center.x=img.cols/2;
  27. center.y=img.rows/2;*/
  28. CvPointcenter;
  29. center.x=0;
  30. center.y=0;
  32. doubleangle=15L;
  34. Matdst=ImageRotate(img,center,angle);
  36. //計算原特徵點在旋轉後圖像中的對應的坐標
  37. CvPointl2=getPointAffinedPos(Leye,center,angle*CV_PI/180);
  38. CvPointr2=getPointAffinedPos(Reye,center,angle*CV_PI/180);
  40. //drawpupil
  41. dst.at<unsignedchar>(l2.y,l2.x)=255;
  42. dst.at<unsignedchar>(r2.y,r2.x)=255;
  44. //Matdst=ImageRotate2NewSize(img,center,angle);
  45. imshow("dst",dst);
  48. waitKey(0);
  49. return0;
  50. }

這裡繞著（0,0）點進行旋轉，旋轉之後的圖像：

繞著左下角旋轉：

[cpp] view plain copy
  1. CvPointcenter;
  2. center.x=0;
  3. center.y=img.rows;

旋轉之後的圖像：

3. 縮放因子對於旋轉圖像的影響

上面我們的代碼都沒有添加縮放信息，現在對上面的代碼進行稍加修改，添加縮放參數，然後看一下如何計算對應的新的坐標。

[cpp] view plain copy
  1. #include"stdafx.h"
  2. #include"stdio.h"
  3. #include"iostream"
  5. #include"opencv2/opencv.hpp"
  7. usingnamespacestd;
  8. usingnamespacecv;
  10. //獲取指定像素點放射變換後的新的坐標位置
  11. CvPointgetPointAffinedPos(constCvPoint&src,constCvPoint￠er,doubleangle,doublescale);
  12. MatImageRotate(Mat&src,constCvPoint&_center,doubleangle,doublescale);
  13. MatImageRotate2NewSize(Mat&src,constCvPoint&_center,doubleangle,doublescale);
  15. int_tmain(intargc,_TCHAR*argv[])
  16. {
  17. stringimage_path="D:/lena.jpg";
  18. Matimg=imread(image_path);
  19. cvtColor(img,img,CV_BGR2GRAY);
  20. doublescale=0.5;
  22. Matsrc;
  23. img.copyTo(src);
  26. CvPointLeye;
  27. Leye.x=265;
  28. Leye.y=265;
  29. CvPointReye;
  30. Reye.x=328;
  31. Reye.y=265;
  33. //drawpupil
  34. src.at<unsignedchar>(Leye.y,Leye.x)=255;
  35. src.at<unsignedchar>(Reye.y,Reye.x)=255;
  37. imshow("src",src);
  39. //
  40. CvPointcenter;
  41. center.x=img.cols/2;
  42. center.y=img.rows/2;
  44. doubleangle=15L;
  46. Matdst=ImageRotate(img,center,angle,scale);
  48. //計算原特徵點在旋轉後圖像中的對應的坐標
  49. CvPointl2=getPointAffinedPos(Leye,center,angle*CV_PI/180,scale);
  50. CvPointr2=getPointAffinedPos(Reye,center,angle*CV_PI/180,scale);
  52. //drawpupil
  53. dst.at<unsignedchar>(l2.y,l2.x)=255;
  54. dst.at<unsignedchar>(r2.y,r2.x)=255;
  56. //Matdst=ImageRotate2NewSize(img,center,angle);
  57. imshow("dst",dst);
  60. waitKey(0);
  61. return0;
  62. }
  64. MatImageRotate(Mat&src,constCvPoint&_center,doubleangle,doublescale)
  65. {
  66. CvPoint2D32fcenter;
  67. center.x=float(_center.x);
  68. center.y=float(_center.y);
  70. //計算二維旋轉的仿射變換矩陣
  71. MatM=getRotationMatrix2D(center,angle,scale);
  73. //rotate
  74. Matdst;
  75. warpAffine(src,dst,M,cvSize(src.cols,src.rows),CV_INTER_LINEAR);
  76. returndst;
  77. }
  79. //獲取指定像素點放射變換後的新的坐標位置
  80. CvPointgetPointAffinedPos(constCvPoint&src,constCvPoint￠er,doubleangle,doublescale)
  81. {
  82. CvPointdst;
  83. intx=src.x-center.x;
  84. inty=src.y-center.y;
  86. dst.x=cvRound(x*cos(angle)*scale+y*sin(angle)*scale+center.x);
  87. dst.y=cvRound(-x*sin(angle)*scale+y*cos(angle)*scale+center.y);
  88. returndst;
  89. }

當縮放尺度為0.5的時候，程序的運行結果如圖：

4. 根據旋轉與縮放尺度獲得與原始圖像大小不同的圖像大小（新的合適的大小）

上面的計算中，一直都是放射變換之後計算得到的圖像和原始圖像一樣大，但是因為旋轉、縮放之後圖像可能會變大或者變小，我們再次對上面的代碼進行修改，這樣在獲得仿射變換之後的圖像前，需要重新計算生成的圖像的大小。

計算方法：

[cpp] view plain copy
  1. doubleangle2=angle*CV_PI/180;
  2. intwidth_=src.cols;
  3. intheight=src.rows;
  5. doublealpha=cos(angle2)*scale;
  6. doublebeta=sin(angle2)*scale;
  8. intnew_width_=(int)(width*fabs(alpha)+height*fabs(beta));
  9. intnew_height=(int)(width*fabs(beta)+height*fabs(alpha));

另外，因為我們的圖像旋轉是按照原圖像的中心，所以當獲取到圖像的仿射變換矩陣之後，我們需要根據新生成的圖像的大小，給仿射變換矩陣添加平移信息。

或者可以這麼說，我們新計算得到的圖像的大小，讓原始圖像繞著新的圖像大小的中心進行旋轉。

[cpp] view plain copy

  1. //計算二維旋轉的仿射變換矩陣
  2. MatM=getRotationMatrix2D(center,angle,scale);
  4. //給計算得到的旋轉矩陣添加平移
  6. M.at<double>(0,2)+=(int)((new_width-width)/2);
  7. M.at<double>(1,2)+=(int)((new_height-height)/2);

然後另外需要注意的是，如果你在原始圖像中有一些特徵點的坐標，這些特徵點的坐標映射到新的圖像上的時候，需要在以前的方法的基礎上增加平移信息。[cpp] view plain copy

  1. //獲取指定像素點放射變換後的新的坐標位置
  2. CvPointgetPointAffinedPos(Mat&src,Mat&dst,constCvPoint&src_p,constCvPoint￠er,doubleangle,doublescale)
  3. {
  4. doublealpha=cos(angle)*scale;
  5. doublebeta=sin(angle)*scale;
  7. intwidth_=src.cols;
  8. intheight=src.rows;
  10. CvPointdst_p;
  11. intx=src_p.x-center.x;
  12. inty=src_p.y-center.y;
  14. dst_p.x=cvRound(x*alpha+y*beta+center.x);
  15. dst_p.y=cvRound(-x*beta+y*alpha+center.y);
  17. intnew_width_=dst.cols;
  18. intnew_height=dst.rows;
  20. intmovx=(int)((new_width-width)/2);
  21. intmovy=(int)((new_height-height)/2);
  23. dst_p.x+=movx;
  24. dst_p.y+=movy;
  26. returndst_p;
  27. }

我們仿射變換函數代碼：

[cpp] view plain copy
  1. MatImageRotate2NewSize(Mat&src,constCvPoint&_center,doubleangle,doublescale)
  2. {
  3. doubleangle2=angle*CV_PI/180;
  4. intwidth_=src.cols;
  5. intheight=src.rows;
  7. doublealpha=cos(angle2)*scale;
  8. doublebeta=sin(angle2)*scale;
  10. intnew_width_=(int)(width*fabs(alpha)+height*fabs(beta));
  11. intnew_height=(int)(width*fabs(beta)+height*fabs(alpha));
  13. CvPoint2D32fcenter;
  14. center.x=float(width/2);
  15. center.y=float(height/2);
  16. //計算二維旋轉的仿射變換矩陣
  17. MatM=getRotationMatrix2D(center,angle,scale);
  19. //給計算得到的旋轉矩陣添加平移
  21. M.at<double>(0,2)+=(int)((new_width-width)/2);
  22. M.at<double>(1,2)+=(int)((new_height-height)/2);
  24. //rotate
  25. Matdst;
  26. warpAffine(src,dst,M,cvSize(new_width,new_height),CV_INTER_LINEAR);
  27. returndst;
  28. }

主函數：[cpp] view plain copy

  1. int_tmain(intargc,_TCHAR*argv[])
  2. {
  3. stringimage_path="D:/lena.jpg";
  4. Matimg=imread(image_path);
  5. cvtColor(img,img,CV_BGR2GRAY);
  6. doublescale=0.5;
  8. Matsrc;
  9. img.copyTo(src);
  11. CvPointLeye;
  12. Leye.x=265;
  13. Leye.y=265;
  14. CvPointReye;
  15. Reye.x=328;
  16. Reye.y=265;
  18. //drawpupil
  19. src.at<unsignedchar>(Leye.y,Leye.x)=255;
  20. src.at<unsignedchar>(Reye.y,Reye.x)=255;
  22. imshow("src",src);
  24. //
  25. CvPointcenter;
  26. center.x=img.cols/2;
  27. center.y=img.rows/2;
  29. doubleangle=15L;
  31. //Matdst=ImageRotate(img,center,angle,scale);
  32. Matdst=ImageRotate2NewSize(img,center,angle,scale);
  34. //計算原特徵點在旋轉後圖像中的對應的坐標
  35. CvPointl2=getPointAffinedPos(src,dst,Leye,center,angle*CV_PI/180,scale);
  36. CvPointr2=getPointAffinedPos(src,dst,Reye,center,angle*CV_PI/180,scale);
  38. //drawpupil
  39. dst.at<unsignedchar>(l2.y,l2.x)=255;
  40. dst.at<unsignedchar>(r2.y,r2.x)=255;
  43. imshow("dst",dst);
  46. waitKey(0);
  47. return0;
  48. }

仿射變換結果以及瞳孔重新坐標計算結果：

5. 根據三個點進行仿射變換根據給點的三個點，由這三個點之前的坐標以及變換之後的坐標，對原圖像進行仿射變換，不過需要事先知道三個點仿射變換的坐標位置。[cpp] view plain copy

  1. int_tmain(intargc,_TCHAR*argv[])
  2. {
  3. stringimage_path="D:/lena.jpg";
  4. Matimg=imread(image_path);
  6. Point2fsrc_points[3];
  7. src_points[0]=Point2f(100,100);
  8. src_points[1]=Point2f(400,100);
  9. src_points[2]=Point2f(250,300);
  11. Point2fdst_points[3];
  12. dst_points[0]=Point2f(100,100);
  13. dst_points[1]=Point2f(400,300);
  14. dst_points[2]=Point2f(100,300);
  16. MatM1=getAffineTransform(src_points,dst_points);
  18. Matdst;
  19. warpAffine(img,dst,M1,cvSize(img.cols,img.rows),INTER_LINEAR);
  21. imshow("dst",dst);
  23. //cvtColor(img,img,CV_BGR2GRAY);
  24. //doublescale=1.5;
  26. //Matsrc;
  27. //img.copyTo(src);
  29. //CvPointLeye;
  30. //Leye.x=265;
  31. //Leye.y=265;
  32. //CvPointReye;
  33. //Reye.x=328;
  34. //Reye.y=265;
  36. ////drawpupil
  37. //src.at<unsignedchar>(Leye.y,Leye.x)=255;
  38. //src.at<unsignedchar>(Reye.y,Reye.x)=255;
  40. //imshow("src",src);
  42. ////
  43. //CvPointcenter;
  44. //center.x=img.cols/2;
  45. //center.y=img.rows/2;
  47. //doubleangle=15L;
  49. ////Matdst=ImageRotate(img,center,angle,scale);
  50. //Matdst=ImageRotate2NewSize(img,center,angle,scale);
  52. ////計算原特徵點在旋轉後圖像中的對應的坐標
  53. //CvPointl2=getPointAffinedPos(src,dst,Leye,center,angle*CV_PI/180,scale);
  54. //CvPointr2=getPointAffinedPos(src,dst,Reye,center,angle*CV_PI/180,scale);
  56. ////drawpupil
  57. //dst.at<unsignedchar>(l2.y,l2.x)=255;
  58. //dst.at<unsignedchar>(r2.y,r2.x)=255;
  59. //imshow("dst",dst);
  62. waitKey(0);
  63. return0;
  64. }

結果：


推薦閱讀：

查看原文 >>
相關文章