OpenCV 图片旋转，缩放

原文：opencv 图像仿射变换 计算仿射变换后对应特征点的新坐标 图像旋转、缩放、平移   

常常需要最图像进行仿射变换，仿射变换后，我们可能需要将原来图像中的特征点坐标进行重新计算，获得原来图像中例如眼睛瞳孔坐标的新的位置，用于在新得到图像中继续利用瞳孔位置坐标。

仿射变换在：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. CvPoint getPointAffinedPos(const CvPoint &src, const CvPoint ¢er, double angle)  
3. {  
4.     CvPoint dst;  
5.     int x = src.x - center.x;  
6.     int y = src.y - center.y;  
7.   
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.     return dst;  
11. }  

要特别注意的是，在对一个原图像中的像素的坐标进行计算仿射变换之后的坐标的时候，一定要按照仿射变换的基本原理，将原来的坐标减去仿射变换的旋转中心的坐标，这样仿射变换之后得到的坐标再加上仿射变换旋转中心坐标才是原坐标在新的仿射变换之后的图像中的正确坐标。

下面给出计算对应瞳孔坐标旋转之后的坐标位置的示例代码：

[cpp]  view plain  copy

1. // AffineTransformation.cpp : Defines the entry point for the console application.  
2. //  
3.   
4. #include "stdafx.h"  
5. #include "stdio.h"  
6. #include "iostream"  
7.   
8. #include "opencv2/opencv.hpp"  
9.   
10. using namespace std;  
11. using namespace cv;  
12.   
13. // 获取指定像素点放射变换后的新的坐标位置  
14. CvPoint getPointAffinedPos(const CvPoint &src, const CvPoint ¢er, double angle);  
15. Mat ImageRotate(Mat & src, const CvPoint &_center, double angle);  
16. Mat ImageRotate2NewSize(Mat& src, const CvPoint &_center, double angle);  
17.   
18. int _tmain(int argc, _TCHAR* argv[])  
19. {  
20.     string image_path = "D:/lena.jpg";  
21.     Mat img = imread(image_path);  
22.     cvtColor(img, img, CV_BGR2GRAY);  
23.   
24.     Mat src;  
25.     img.copyTo(src);  
26.   
27.   
28.     CvPoint Leye;  
29.     Leye.x = 265;  
30.     Leye.y = 265;  
31.     CvPoint Reye;  
32.     Reye.x = 328;  
33.     Reye.y = 265;  
34.   
35.     // draw pupil  
36.     src.at<unsigned char>(Leye.y, Leye.x) = 255;  
37.     src.at<unsigned char>(Reye.y, Reye.x) = 255;  
38.   
39.     imshow("src", src);  
40.   
41.     //  
42.     CvPoint center;  
43.     center.x = img.cols / 2;  
44.     center.y = img.rows / 2;  
45.   
46.     double angle = 15L;  
47.   
48.     Mat dst = ImageRotate(img, center, angle);  
49.   
50.     // 计算原特征点在旋转后图像中的对应的坐标  
51.     CvPoint l2 = getPointAffinedPos(Leye, center, angle * CV_PI / 180);  
52.     CvPoint r2 = getPointAffinedPos(Reye, center, angle * CV_PI / 180);  
53.   
54.     // draw pupil  
55.     dst.at<unsigned char>(l2.y, l2.x) = 255;  
56.     dst.at<unsigned char>(r2.y, r2.x) = 255;  
57.   
58.     //Mat dst = ImageRotate2NewSize(img, center, angle);  
59.     imshow("dst", dst);  
60.   
61.   
62.     waitKey(0);  
63.     return 0;  
64. }  
65.   
66. Mat ImageRotate(Mat & src, const CvPoint &_center, double angle)  
67. {  
68.     CvPoint2D32f center;  
69.     center.x = float(_center.x);  
70.     center.y = float(_center.y);  
71.   
72.     //计算二维旋转的仿射变换矩阵  
73.     Mat M = getRotationMatrix2D(center, angle, 1);  
74.   
75.     // rotate  
76.     Mat dst;  
77.     warpAffine(src, dst, M, cvSize(src.cols, src.rows), CV_INTER_LINEAR);  
78.     return dst;  
79. }  
80.   
81. // 获取指定像素点放射变换后的新的坐标位置  
82. CvPoint getPointAffinedPos(const CvPoint &src, const CvPoint ¢er, double angle)  
83. {  
84.     CvPoint dst;  
85.     int x = src.x - center.x;  
86.     int y = src.y - center.y;  
87.   
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.     return dst;  
91. }  

这里，我们先通过手工找到瞳孔坐标，然后计算在图像旋转之后瞳孔的坐标。

运行结果如图：

原图像

旋转之后的图像：

2. 旋转中心对于旋转的影响

然后我们看看仿射变换旋转点的选择对于旋转之后的图像的影响，一般情况下，我们选择图像的中心点作为仿射变换的旋转中心，获得的旋转之后的图像与原图像大小一样。

计算代码： 

[cpp]  view plain  copy

1. int _tmain(int argc, _TCHAR* argv[])  
2. {  
3.     string image_path = "D:/lena.jpg";  
4.     Mat img = imread(image_path);  
5.     cvtColor(img, img, CV_BGR2GRAY);  
6.   
7.     Mat src;  
8.     img.copyTo(src);  
9.   
10.   
11.     CvPoint Leye;  
12.     Leye.x = 265;  
13.     Leye.y = 265;  
14.     CvPoint Reye;  
15.     Reye.x = 328;  
16.     Reye.y = 265;  
17.   
18.     // draw pupil  
19.     src.at<unsigned char>(Leye.y, Leye.x) = 255;  
20.     src.at<unsigned char>(Reye.y, Reye.x) = 255;  
21.   
22.     imshow("src", src);  
23.   
24.     //  
25.     /*CvPoint center; 
26.     center.x = img.cols / 2; 
27.     center.y = img.rows / 2;*/  
28.     CvPoint center;  
29.     center.x = 0;  
30.     center.y = 0;  
31.   
32.     double angle = 15L;  
33.   
34.     Mat dst = ImageRotate(img, center, angle);  
35.   
36.     // 计算原特征点在旋转后图像中的对应的坐标  
37.     CvPoint l2 = getPointAffinedPos(Leye, center, angle * CV_PI / 180);  
38.     CvPoint r2 = getPointAffinedPos(Reye, center, angle * CV_PI / 180);  
39.   
40.     // draw pupil  
41.     dst.at<unsigned char>(l2.y, l2.x) = 255;  
42.     dst.at<unsigned char>(r2.y, r2.x) = 255;  
43.   
44.     //Mat dst = ImageRotate2NewSize(img, center, angle);  
45.     imshow("dst", dst);  
46.   
47.   
48.     waitKey(0);  
49.     return 0;  
50. }  

这里绕着（0,0）点进行旋转，旋转之后的图像：

绕着左下角旋转：

[cpp]  view plain  copy

1. CvPoint center;  
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"  
4.   
5. #include "opencv2/opencv.hpp"  
6.   
7. using namespace std;  
8. using namespace cv;  
9.   
10. // 获取指定像素点放射变换后的新的坐标位置  
11. CvPoint getPointAffinedPos(const CvPoint &src, const CvPoint ¢er, double angle, double scale);  
12. Mat ImageRotate(Mat & src, const CvPoint &_center, double angle, double scale);  
13. Mat ImageRotate2NewSize(Mat& src, const CvPoint &_center, double angle, double scale);  
14.   
15. int _tmain(int argc, _TCHAR* argv[])  
16. {  
17.     string image_path = "D:/lena.jpg";  
18.     Mat img = imread(image_path);  
19.     cvtColor(img, img, CV_BGR2GRAY);  
20.     double scale = 0.5;  
21.   
22.     Mat src;  
23.     img.copyTo(src);  
24.   
25.   
26.     CvPoint Leye;  
27.     Leye.x = 265;  
28.     Leye.y = 265;  
29.     CvPoint Reye;  
30.     Reye.x = 328;  
31.     Reye.y = 265;  
32.   
33.     // draw pupil  
34.     src.at<unsigned char>(Leye.y, Leye.x) = 255;  
35.     src.at<unsigned char>(Reye.y, Reye.x) = 255;  
36.   
37.     imshow("src", src);  
38.   
39.     //  
40.     CvPoint center;  
41.     center.x = img.cols / 2;  
42.     center.y = img.rows / 2;  
43.   
44.     double angle = 15L;  
45.   
46.     Mat dst = ImageRotate(img, center, angle, scale);  
47.   
48.     // 计算原特征点在旋转后图像中的对应的坐标  
49.     CvPoint l2 = getPointAffinedPos(Leye, center, angle * CV_PI / 180, scale);  
50.     CvPoint r2 = getPointAffinedPos(Reye, center, angle * CV_PI / 180, scale);  
51.   
52.     // draw pupil  
53.     dst.at<unsigned char>(l2.y, l2.x) = 255;  
54.     dst.at<unsigned char>(r2.y, r2.x) = 255;  
55.   
56.     //Mat dst = ImageRotate2NewSize(img, center, angle);  
57.     imshow("dst", dst);  
58.   
59.   
60.     waitKey(0);  
61.     return 0;  
62. }  
63.   
64. Mat ImageRotate(Mat & src, const CvPoint &_center, double angle, double scale)  
65. {  
66.     CvPoint2D32f center;  
67.     center.x = float(_center.x);  
68.     center.y = float(_center.y);  
69.   
70.     //计算二维旋转的仿射变换矩阵  
71.     Mat M = getRotationMatrix2D(center, angle, scale);  
72.   
73.     // rotate  
74.     Mat dst;  
75.     warpAffine(src, dst, M, cvSize(src.cols, src.rows), CV_INTER_LINEAR);  
76.     return dst;  
77. }  
78.   
79. // 获取指定像素点放射变换后的新的坐标位置  
80. CvPoint getPointAffinedPos(const CvPoint &src, const CvPoint ¢er, double angle, double scale)  
81. {  
82.     CvPoint dst;  
83.     int x = src.x - center.x;  
84.     int y = src.y - center.y;  
85.   
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.     return dst;  
89. }  

当缩放尺度为0.5的时候，程序的运行结果如图：

4.  根据旋转与缩放尺度获得与原始图像大小不同的图像大小（新的合适的大小）

上面的计算中，一直都是放射变换之后计算得到的图像和原始图像一样大，但是因为旋转、缩放之后图像可能会变大或者变小，我们再次对上面的代码进行修改，这样在获得仿射变换之后的图像前，需要重新计算生成的图像的大小。

计算方法：

[cpp]  view plain  copy

1. double angle2 = angle * CV_PI / 180;  
2. int width = src.cols;  
3. int height = src.rows;  
4.   
5. double alpha = cos(angle2) * scale;   
6. double beta = sin(angle2) * scale;  
7.   
8. int new_width = (int)(width * fabs(alpha) + height * fabs(beta));  
9. int new_height = (int)(width * fabs(beta) + height * fabs(alpha));  

另外，因为我们的图像旋转是按照原图像的中心，所以当获取到图像的仿射变换矩阵之后，我们需要根据新生成的图像的大小，给仿射变换矩阵添加平移信息。

或者可以这么说，我们新计算得到的图像的大小，让原始图像绕着新的图像大小的中心进行旋转。

[cpp]  view plain  copy

1. //计算二维旋转的仿射变换矩阵  
2. Mat M = getRotationMatrix2D(center, angle, scale);  
3.   
4. // 给计算得到的旋转矩阵添加平移  
5.   
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. CvPoint getPointAffinedPos(Mat & src, Mat & dst, const CvPoint &src_p, const CvPoint ¢er, double angle, double scale)  
3. {  
4.     double alpha = cos(angle) * scale;   
5.     double beta = sin(angle) * scale;  
6.   
7.     int width = src.cols;  
8.     int height = src.rows;  
9.   
10.     CvPoint dst_p;  
11.     int x = src_p.x - center.x;  
12.     int y = src_p.y - center.y;  
13.   
14.     dst_p.x = cvRound(x * alpha  + y * beta + center.x);  
15.     dst_p.y = cvRound(-x * beta + y * alpha + center.y);  
16.   
17.     int new_width = dst.cols;  
18.     int new_height = dst.rows;  
19.   
20.     int movx = (int)((new_width - width)/2);  
21.     int movy = (int)((new_height - height)/2);  
22.   
23.     dst_p.x += movx;  
24.     dst_p.y += movy;  
25.   
26.     return dst_p;  
27. }  

我们仿射变换函数代码：

[cpp]  view plain  copy

1. Mat ImageRotate2NewSize(Mat& src, const CvPoint &_center, double angle, double scale)  
2. {  
3.     double angle2 = angle * CV_PI / 180;  
4.     int width = src.cols;  
5.     int height = src.rows;  
6.   
7.     double alpha = cos(angle2) * scale;   
8.     double beta = sin(angle2) * scale;  
9.   
10.     int new_width = (int)(width * fabs(alpha) + height * fabs(beta));  
11.     int new_height = (int)(width * fabs(beta) + height * fabs(alpha));  
12.   
13.     CvPoint2D32f center;  
14.     center.x = float(width / 2);  
15.     center.y = float(height / 2);  
16.     //计算二维旋转的仿射变换矩阵  
17.     Mat M = getRotationMatrix2D(center, angle, scale);  
18.   
19.     // 给计算得到的旋转矩阵添加平移  
20.   
21.     M.at<double>(0, 2) += (int)((new_width - width )/2);  
22.     M.at<double>(1, 2) += (int)((new_height - height )/2);  
23.   
24.     // rotate  
25.     Mat dst;  
26.     warpAffine(src, dst, M, cvSize(new_width, new_height), CV_INTER_LINEAR);  
27.     return dst;  
28. }  

主函数：

[cpp]  view plain  copy

1. int _tmain(int argc, _TCHAR* argv[])  
2. {  
3.     string image_path = "D:/lena.jpg";  
4.     Mat img = imread(image_path);  
5.     cvtColor(img, img, CV_BGR2GRAY);  
6.     double scale = 0.5;  
7.   
8.     Mat src;  
9.     img.copyTo(src);  
10.   
11.     CvPoint Leye;  
12.     Leye.x = 265;  
13.     Leye.y = 265;  
14.     CvPoint Reye;  
15.     Reye.x = 328;  
16.     Reye.y = 265;  
17.   
18.     // draw pupil  
19.     src.at<unsigned char>(Leye.y, Leye.x) = 255;  
20.     src.at<unsigned char>(Reye.y, Reye.x) = 255;  
21.   
22.     imshow("src", src);  
23.   
24.     //  
25.     CvPoint center;  
26.     center.x = img.cols / 2;  
27.     center.y = img.rows / 2;  
28.   
29.     double angle = 15L;  
30.   
31.     //Mat dst = ImageRotate(img, center, angle, scale);  
32.     Mat dst = ImageRotate2NewSize(img, center, angle, scale);  
33.   
34.     // 计算原特征点在旋转后图像中的对应的坐标  
35.     CvPoint l2 = getPointAffinedPos(src, dst, Leye, center, angle * CV_PI / 180, scale);  
36.     CvPoint r2 = getPointAffinedPos(src, dst, Reye, center, angle * CV_PI / 180, scale);  
37.   
38.     // draw pupil  
39.     dst.at<unsigned char>(l2.y, l2.x) = 255;  
40.     dst.at<unsigned char>(r2.y, r2.x) = 255;  
41.   
42.   
43.     imshow("dst", dst);  
44.   
45.   
46.     waitKey(0);  
47.     return 0;  
48. }  

仿射变换结果以及瞳孔重新坐标计算结果：

5. 根据三个点进行仿射变换

根据给点的三个点，由这三个点之前的坐标以及变换之后的坐标，对原图像进行仿射变换，不过需要事先知道三个点仿射变换的坐标位置。

[cpp]  view plain  copy

1. int _tmain(int argc, _TCHAR* argv[])  
2. {  
3.     string image_path = "D:/lena.jpg";  
4.     Mat img = imread(image_path);  
5.   
6.     Point2f src_points[3];  
7.     src_points[0] = Point2f(100, 100);  
8.     src_points[1] = Point2f(400, 100);  
9.     src_points[2] = Point2f(250, 300);  
10.   
11.     Point2f dst_points[3];  
12.     dst_points[0] = Point2f(100, 100);  
13.     dst_points[1] = Point2f(400, 300);  
14.     dst_points[2] = Point2f(100, 300);  
15.   
16.     Mat M1 = getAffineTransform(src_points, dst_points);  
17.   
18.     Mat dst;  
19.     warpAffine(img, dst, M1, cvSize(img.cols, img.rows), INTER_LINEAR);  
20.   
21.     imshow("dst", dst);  
22.   
23.     //cvtColor(img, img, CV_BGR2GRAY);  
24.     //double scale = 1.5;  
25.   
26.     //Mat src;  
27.     //img.copyTo(src);  
28.   
29.     //CvPoint Leye;  
30.     //Leye.x = 265;  
31.     //Leye.y = 265;  
32.     //CvPoint Reye;  
33.     //Reye.x = 328;  
34.     //Reye.y = 265;  
35.   
36.     //// draw pupil  
37.     //src.at<unsigned char>(Leye.y, Leye.x) = 255;  
38.     //src.at<unsigned char>(Reye.y, Reye.x) = 255;  
39.   
40.     //imshow("src", src);  
41.   
42.     ////  
43.     //CvPoint center;  
44.     //center.x = img.cols / 2;  
45.     //center.y = img.rows / 2;  
46.   
47.     //double angle = 15L;  
48.   
49.     ////Mat dst = ImageRotate(img, center, angle, scale);  
50.     //Mat dst = ImageRotate2NewSize(img, center, angle, scale);  
51.   
52.     //// 计算原特征点在旋转后图像中的对应的坐标  
53.     //CvPoint l2 = getPointAffinedPos(src, dst, Leye, center, angle * CV_PI / 180, scale);  
54.     //CvPoint r2 = getPointAffinedPos(src, dst, Reye, center, angle * CV_PI / 180, scale);  
55.   
56.     //// draw pupil  
57.     //dst.at<unsigned char>(l2.y, l2.x) = 255;  
58.     //dst.at<unsigned char>(r2.y, r2.x) = 255;  
59.     //imshow("dst", dst);  
60.   
61.   
62.     waitKey(0);  
63.     return 0;  
64. }  

结果：