图像旋转的原理与实现
 
图像旋转的原理与实现
 
一般图像的旋转是以图像的中心为原点，旋转一定的角度，也就是将图像上的所有像素都旋转一个相同的角度。旋转后图像的的大小一般会改变，即可以把转出显示区域的图像截去，或者扩大图像范围来显示所有的图像。图像的旋转变换也可以用矩阵变换来表示。设点逆时针旋转角后的对应点为。那么，旋转前后点、的坐标分别是：
 
                          (3-6)
 
  (3-7)
 
 
 
 
 
写成矩阵表达式为
 
            (3-8)
 
 
 
 
 
 
 
 
 
其逆运算为
 
            (3-9)
 
 
 
 
 
利用上述方法进行图像旋转时需要注意如下两点：
 
（1）图像旋转之前，为了避免信息的丢失，一定要有坐标平移。
 
（2）图像旋转之后，会出现许多空洞点。对这些空洞点必须进行填充处理，否则画面效果不好，一般也称这种操作为插值处理。
 
以上所讨论的旋转是绕坐标轴原点(0,0)进行的。如果图像旋转是绕一个指定点(a,b)旋转，则先要将坐标系平移到该点，再进行旋转，然后将旋转后的图象平移回原来的坐标原点，这实际上是图像的复合变换。如将一幅图像绕点(a,b)逆时针旋转度，首先将原点平移到(a,b)，即
 
                        (3-10)
 
然后旋转
 
                 (3-11)
 
然后再平移回来
 
                        (3-12)
 
 
 
综上所述，变换矩阵为。
 
代码：
 
B=imread('image1.bmp');
%读取原图像
[m,n]=size(B); %获取原图尺寸w
%参数设置
theta = pi/4;  %旋转角度
a = sin(theta);
b = cos(theta);
T = [cos(theta),sin(theta),;    %旋转矩阵
    -sin(theta),cos(theta)];
  
%建立存储空间
row=m+round((m)/2);
col=n+round((n)/2);
rotateima = zeros(row, col);  %存储旋转后图像的矩阵
  
%图像旋转        
for i=1:m                                      
    for j=1:n
        x=ceil(abs((i-round(m/2))*b-(j-round(n/2))*a+round(row/2)));  %坐标平移至中心
        y=ceil(abs((i-round(m/2))*a+(j-round(n/2))*b+round(col/2)));  %坐标平移至中心
        rotateima(x,y)=B(i,j);                   %未插值的图像
    end
end
nrotateima = uint8(rotateima);
imshow(nrotateima);
title('未插值的图像')
  
%图像插值（近邻插值法）
for i=1:row   
    for j=2:col-1      
               
            if(rotateima(i,j) == 0 && rotateima(i,j-1) ~= 0 && rotateima(i,j+1) ~= 0 )      
                rotateima(i,j) =rotateima(i,j-1) ;     
            
            end
    end
end
  
%图像显示
figure(1);
imshow(B)
title('原始图像');
% figure(2);
% imshow(nrotateima);
% title('未插值的图像');
figure(3);
imshow(rotateima/256);
imwrite(rotateima/256, '旋转后图像.jpg', 'jpg');
title('旋转图');
 
原文链接：https://www.cnblogs.com/hustlx/p/5245226.html

 
 
本文主要讲解图像处理中使用比较广泛的图像旋转算法原理，如下：
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 原文地址：http://blog.163.com/yuyang_tech/blog/static/21605008320138455714221/?suggestedreading&wumii
 

 


 
文章目录
 
图像旋转的原理
图像旋转的实现
最近邻插值
双线性插值
双线性的优化
 

 
 
图像旋转的原理
 
图像旋转的原理其实很简单，为了简化公式的推导，这里我们假设绕原点$(0,0)$旋转。
 
 
本文规定逆时针旋转为正，当然你也可以规定顺时针为正（此时，正角度就表示顺时针旋转）
 很容易得到三个方程：
 $$tan(\theta +\alpha )=\frac{y^{\prime }}{x^{\prime }}(1)$$
 $$tan\alpha =\frac{y}{x}(2)$$
 $$x^2+y^2={x^{\prime }}^2+{y^{\prime }}^2(3)$$
 由和角公式可知
 $$tan(\theta +\alpha )=\frac{tan\theta +tan\alpha }{1-tan\theta tan\alpha }$$
 代入（1）和（2）可得
 $$y^{\prime }=\frac{x^{\prime }(y+xtan\theta )}{x-ytan\theta }(4)$$
 (4)代入(3)得到：
 $$x^{\prime 2}=(xcos\theta -ysin\theta {)}^2(5)$$
 （5）代入（3）
 $$y^{\prime 2}=(xsin\theta +ycos\theta {)}^2$$
 所以
 $$\{\begin{array}{l}{x}^{\prime }=xcos\theta +y(-sin\theta )\\ y^{\prime }=xsin\theta +ycos\theta \end{array}(6)$$
 我们知道仿射变换矩阵可以表示为：
 $$A=\left[\begin{array}{cc}cos\theta & -sin\theta \\ sin\theta & cos\theta \end{array}\right]\text{\hspace{1em}(7)}$$
 公式7与公式6在形式上是一致的(这里没有加入平移和缩放)
 注意公式6中$x,y,x^{\prime },y^{\prime }$实际表示$x-0,y-0,x^{\prime }-0,y^{\prime }-0$即与旋转中心横坐标以及纵坐标之间的距离，现在我们将旋转中心变为更具有一般性的$(x_0,y_0)$,得旋转公式为：
 $$\{\begin{array}{l}{x}^{\prime }=(x-x_0)cos\theta +(y-y_0)(-sin\theta )+x_0\\ y^{\prime }=(x-x_0)sin\theta +(y-y_0)cos\theta +y_0\end{array}(8)$$
 对于图像来说，规定顺时针旋转角度为正，则旋转公式与上述公式一致，由于任意角度的旋转后会出现像素坐标为负的情况，如果不将旋转后的图像坐标平移，会缺失部分图像，所以，对于旋转后的图像，我们通常会加入一个平移
 $$\{\begin{array}{l}{x}^{\prime }=(x-x_0)cos\theta +(y-y_0)(-sin\theta )+x_0+\Delta x\\ y^{\prime }=(x-x_0)sin\theta +(y-y_0)cos\theta +y_0+\Delta y\end{array}(9)$$
 
图像中使用后向映射，使用$x^{\prime },y^{\prime }$表示$x,y$,则上述公式变为
 $$\{\begin{array}{l}x=((x^{\prime }-x_0-\Delta x)cos\theta +(y^{\prime }-y_0-\Delta y)sin\theta )/scale+x_0\\ y=((x^{\prime }-x_0-\Delta x)(-sin\theta )+(y^{\prime }-y_0-\Delta y)cos\theta )/scale+y_0\end{array}(10)$$
 这里加入了缩放，其中：scale>1表示原图放大 <1表示原图缩小
 有了上面的公式，下面就可以写出相应的代码了
 
注：为什么公式推导的时候选用右手系？因为右手系与图像坐标系推导出来的公式在形式上是统一的，而右手系又是我们熟悉的坐标系。
 
 
图像旋转的实现
 
最近邻插值
 
先给出一个结构最简洁的版本，采用最近邻插值
 
// 宏定义
#define DEGREE2RADIAN(x) (x*CV_PI/180)//角度转弧度
#define RADIAN2DEGREE(x) (x*180/CV_PI)//弧度转角度
#define  SHIFT  10
#define  DESCALE(x,n)  (((x)+(1 << ((n)-1))) >> (n))
/*	center:原图像的旋转中心
	dstSize:旋转后图像的大小
	theta:旋转角度，单位弧度，顺时针为正
	scale:缩放，scale>1表示放大  <1表示缩小
*/ 
void Rotate_Nearest(const Mat &srcImage, Mat &dstImage, Point center, Size dstSize, double theta, double scale)
{
	CV_Assert(srcImage.depth() == CV_8U);
	dstImage.create(dstSize, srcImage.type());

	int x0 = center.x;
	int y0 = center.y;
	theta = DEGREE2RADIAN(theta);

	// dx,dy就是dst与src图像中心的距离 
	int dx = dstImage.cols/2 - srcImage.cols/2;
	int dy = dstImage.rows/2 - srcImage.rows/2;
	int numberOfChannels = srcImage.channels();

	int widthOfDst = dstImage.cols;
	int heightOfDst = dstImage.rows;
	
	for (int y = 0; y <= heightOfDst - 1; ++y)
	{
		for (int x = 0; x <= widthOfDst - 1; ++x)
		{
			float srcX = ((x - x0 - dx)*cos(theta) + (y - y0 - dy)*sin(theta))/scale + x0;
			float srcY = ((x0 + dx - x)*sin(theta) + (y - y0 - dy)*cos(theta))/scale + y0;

			// get the nearest coordinate of src
			int x1 = (int)srcX;
			int y1 = (int)srcY;
			if (numberOfChannels == 1)
			{
				if ((x1 >= 0 && x1 <= srcImage.cols - 1) && (y1 >= 0 && y1 <= srcImage.rows - 1))
				{
					dstImage.at<uchar>(y, x) = srcImage.at<uchar>(y1, x1);
				}
				else
				{
					// 越界赋值0
					dstImage.at<uchar>(y, x) = 0;
				}
			}
			else
			{
				if ((x1 >= 0 && x1 <= srcImage.cols - 1) && (y1 >= 0 && y1 <= srcImage.rows - 1))
				{
					dstImage.at<cv::Vec3b>(y, x) = srcImage.at<cv::Vec3b>(y1, x1);
				}
				else
				{
					dstImage.at<cv::Vec3b>(y, x) = cv::Vec3b(0,0,0);
				}

			}
		}
	}

}
 
测试使用的原始图像大小为1000 x 580 (三通道彩色图)
 测试代码：
 Rotate_Nearest(srcImage, dstImage, Point(srcImage.cols / 2, srcImage.rows / 2), Size(2500, 2500), 30.0, 2);
 效果：
 原图：
 
 结果：
 
 无缩放测试：
 Rotate_Nearest(srcImage, dstImage, Point(srcImage.cols / 2, srcImage.rows / 2), Size(2500, 2500), 30.0, 1);
 结果：
 
 
双线性插值
 
下面我们对他进行优化，首先我们将最近邻插值改用更为通用的双线性插值，代码如下
 
void Rotate_Bilinear(const Mat &srcImage, Mat &dstImage, Point center, Size dstSize, double theta, double scale)
{
	CV_Assert(srcImage.depth() == CV_8U);
	dstImage.create(dstSize, srcImage.type());
	dstImage.setTo(Scalar(0, 0, 0));

	int x0 = center.x;
	int y0 = center.y;
	theta = DEGREE2RADIAN(theta);

	// 
	Mat extendedImage;
	copyMakeBorder(srcImage, extendedImage, 1, 1, 1, 1, BORDER_CONSTANT,Scalar(0,0,0)); // 使用0填充边界

	// dx,dy就是dst与src图像中心的距离 
	int dx = dstImage.cols / 2 - srcImage.cols / 2;
	int dy = dstImage.rows / 2 - srcImage.rows / 2;
	int numberOfChannels = srcImage.channels();

	int widthOfDst = dstImage.cols;
	int heightOfDst = dstImage.rows;

	for (int y = 0; y <= heightOfDst - 1; ++y)
	{
		for (int x = 0; x <= widthOfDst - 1; ++x)
		{
			// 按照原来的方式计算原图坐标
			float srcX = ((x - x0 - dx)*cos(theta) + (y - y0 - dy)*sin(theta)) / scale + x0;
			float srcY = ((x0 + dx - x)*sin(theta) + (y - y0 - dy)*cos(theta)) / scale + y0;
			
			// 加1,得到在extendedImage中的坐标
			srcX++; 
			srcY++;
			 
			// get the nearest coordinate of src
			int x1 = (int)(srcX); 
			int y1 = (int)(srcY);

			// 浮点转化为整数
			int dx1 = (srcX - x1)*(1<< SHIFT);
			int dy1 = (srcY - y1)*(1<< SHIFT);

			if (numberOfChannels == 1)
			{
				// !！！注意这里的范围，在extendedImage中，原图的范围就是1~cols - 2了
				if ((x1 >= 1 && x1 <= extendedImage.cols - 2) && (y1 >= 1 && y1 <= extendedImage.rows - 2))
				{	
					//双线性插值
					//周围4个点
					//a就是最近邻像素
					//a   b
					//  p
					//c   d
					uchar a = extendedImage.at<uchar>(y1, x1);
					uchar b = extendedImage.at<uchar>(y1, x1 + 1);
					uchar c = extendedImage.at<uchar>(y1 + 1, x1);
					uchar d = extendedImage.at<uchar>(y1 + 1, x1 + 1);

					
					//int p = (a*((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b*dx1*((1 << SHIFT) - dy1) + c*((1 << SHIFT) - dx1)*dy1 + d*dx1*dy1)/(1<<(2* SHIFT));
					
					int p = a*((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b*dx1*((1 << SHIFT) - dy1) + c*((1 << SHIFT) - dx1)*dy1 + d*dx1*dy1;
					p = DESCALE(p, 2*SHIFT);

					dstImage.at<uchar>(y, x) = p;
				}
				else
				{
					// 越界赋值0
					dstImage.at<uchar>(y, x) = 0;
				}
			}
			else
			{
				if ((x1 >= 1 && x1 <= extendedImage.cols - 2) && (y1 >= 1 && y1 <= extendedImage.rows - 2))
				{
					//双线性插值
					//周围4个点
					//a就是最近邻像素
					//a   b
					//  p
					//c   d
					Vec3b a = extendedImage.at<Vec3b>(y1, x1);
					Vec3b b = extendedImage.at<Vec3b>(y1, x1 + 1);
					Vec3b c = extendedImage.at<Vec3b>(y1 + 1, x1);
					Vec3b d = extendedImage.at<Vec3b>(y1 + 1, x1 + 1);

					
					/*int p1 = (a[0] * ((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[0] * dx1*((1 << SHIFT) - dy1) + c[0] * ((1 << SHIFT) - dx1)*dy1 + d[0] * dx1*dy1)/(1<<(2*SHIFT));
					int p2 = (a[1] * ((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[1] * dx1*((1 << SHIFT) - dy1) + c[1] * ((1 << SHIFT) - dx1)*dy1 + d[1] * dx1*dy1)/ (1 << (2 * SHIFT));
					int p3 = (a[2] * ((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[2] * dx1*((1 << SHIFT) - dy1) + c[2] * ((1 << SHIFT) - dx1)*dy1 + d[2] * dx1*dy1)/ (1 << (2 * SHIFT));*/

					int p1 = a[0]*((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[0]*dx1*((1 << SHIFT) - dy1) + c[0]*((1 << SHIFT) - dx1)*dy1 + d[0]*dx1*dy1;
					p1 = DESCALE(p1, 2 * SHIFT);
					int p2 = a[1]*((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[1]*dx1*((1 << SHIFT) - dy1) + c[1]*((1 << SHIFT) - dx1)*dy1 + d[1] *dx1*dy1;
					p2 = DESCALE(p2, 2 * SHIFT);
					int p3 = a[2]*((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[2]*dx1*((1 << SHIFT) - dy1) + c[2]*((1 << SHIFT) - dx1)*dy1 + d[2] *dx1*dy1;
					p3 = DESCALE(p3, 2 * SHIFT);


					dstImage.at<cv::Vec3b>(y, x) = Vec3b(p1,p2,p3);
				}
				else
				{
					dstImage.at<cv::Vec3b>(y, x) = cv::Vec3b(0, 0, 0);
				}

			}
		}
	}
}
 
测试方法与上述相同，测试代码如下：
 Rotate_Bilinear(srcImage, dstImage, Point(srcImage.cols / 2, srcImage.rows / 2), Size(2500, 2500),30.0, 2);
 基本旋转效果都是一样的，下面我们看局部放大图
 
 这是最近邻的眼部区域
 
 双线性在保持图像细节方面要好于最近邻，而且不容易产生锯齿
 
双线性的优化
 
上面的双线性插值速度比较慢，我们对其进行优化，主要优化有：
 1.将循环内部不变量提取出来
 由于sin和cos的计算是比较慢的函数，所以可以将他们提前计算好，而不是每次循环都要计算
 如：
 double sinTheta = sin(theta);
 double cosTheta = cos(theta);
 
2.改变循环体内循环变量自增的方式
 采用加法自增的方式，而不是每次都要计算乘法，详见代码
 
注：浮点数转化为整数的优化，上面已经涉及，这里不再说明
 
优化后的代码如下：
 
void Rotate_Bilinear2(const Mat &srcImage, Mat &dstImage, Point center, Size dstSize, double theta, double scale)
{
	CV_Assert(srcImage.depth() == CV_8U);
	dstImage.create(dstSize, srcImage.type());
	dstImage.setTo(Scalar(0, 0, 0));

	int x0 = center.x;
	int y0 = center.y;
	theta = DEGREE2RADIAN(theta);

	// 
	Mat extendedImage;
	copyMakeBorder(srcImage, extendedImage, 1, 1, 1, 1, BORDER_CONSTANT, Scalar(0, 0, 0)); // 使用0填充边界

																						   // dx,dy就是dst与src图像中心的距离 
	int dx = dstImage.cols / 2 - srcImage.cols / 2;
	int dy = dstImage.rows / 2 - srcImage.rows / 2;
	int numberOfChannels = srcImage.channels();

	int widthOfDst = dstImage.cols;
	int heightOfDst = dstImage.rows;

	// 优化部分/
	// 将循环内的不变量提取出来
	double sinTheta = sin(theta);
	double cosTheta = cos(theta);
	scale = 1.0 / scale;

	// 改变了循环内部增量的方式
	double temp1= (0 - y0 - dy)*sinTheta;
	double temp2 = (0 - y0 - dy)*cosTheta;
	double dtemp1 = sinTheta;
	double dtemp2 = cosTheta;

	for (int y = 0; y <= heightOfDst - 1; ++y,temp1+=dtemp1,temp2+=dtemp2)
	{
		// 改变了循环内部增量的方式
		double temp3= ((0 - x0 - dx)*cosTheta + temp1)*scale + x0;
		double temp4= (-(0 - x0 - dx)*sinTheta + temp2)*scale + y0;
		double dtemp3 = (cosTheta)*scale;
		double dtemp4= (-sinTheta)*scale;
		for (int x = 0; x <= widthOfDst - 1; ++x,temp3+=dtemp3,temp4+=dtemp4)
		{
			// 计算原图坐标
			double srcX = temp3;
			double srcY = temp4;

			// 加1,得到在extendedImage中的坐标
			srcX++;
			srcY++;

			// get the nearest coordinate of src
			int x1 = (int)(srcX);
			int y1 = (int)(srcY);

			// 浮点转化为整数
			int dx1 = (srcX - x1)*(1 << SHIFT);
			int dy1 = (srcY - y1)*(1 << SHIFT);

			if (numberOfChannels == 1)
			{
				// !！！注意这里的范围，在extendedImage中，原图的范围就是1~cols - 2了
				if ((x1 >= 1 && x1 <= extendedImage.cols - 2) && (y1 >= 1 && y1 <= extendedImage.rows - 2))
				{
					//双线性插值
					//周围4个点
					//a就是最近邻像素
					//a   b
					//  p
					//c   d
					uchar a = extendedImage.at<uchar>(y1, x1);
					uchar b = extendedImage.at<uchar>(y1, x1 + 1);
					uchar c = extendedImage.at<uchar>(y1 + 1, x1);
					uchar d = extendedImage.at<uchar>(y1 + 1, x1 + 1);

					
					//int p = (a*((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b*dx1*((1 << SHIFT) - dy1) + c*((1 << SHIFT) - dx1)*dy1 + d*dx1*dy1)/(1<<(2* SHIFT));

					int p = a*((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b*dx1*((1 << SHIFT) - dy1) + c*((1 << SHIFT) - dx1)*dy1 + d*dx1*dy1;
					p = DESCALE(p, 2 * SHIFT);

					dstImage.at<uchar>(y, x) = p;
				}
				else
				{
					// 越界赋值0
					dstImage.at<uchar>(y, x) = 0;
				}
			}
			else
			{
				if ((x1 >= 1 && x1 <= extendedImage.cols - 2) && (y1 >= 1 && y1 <= extendedImage.rows - 2))
				{
					//双线性插值
					//周围4个点
					//a就是最近邻像素
					//a   b
					//  p
					//c   d
					Vec3b a = extendedImage.at<Vec3b>(y1, x1);
					Vec3b b = extendedImage.at<Vec3b>(y1, x1 + 1);
					Vec3b c = extendedImage.at<Vec3b>(y1 + 1, x1);
					Vec3b d = extendedImage.at<Vec3b>(y1 + 1, x1 + 1);

					
					/*int p1 = (a[0] * ((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[0] * dx1*((1 << SHIFT) - dy1) + c[0] * ((1 << SHIFT) - dx1)*dy1 + d[0] * dx1*dy1)/(1<<(2*SHIFT));
					int p2 = (a[1] * ((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[1] * dx1*((1 << SHIFT) - dy1) + c[1] * ((1 << SHIFT) - dx1)*dy1 + d[1] * dx1*dy1)/ (1 << (2 * SHIFT));
					int p3 = (a[2] * ((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[2] * dx1*((1 << SHIFT) - dy1) + c[2] * ((1 << SHIFT) - dx1)*dy1 + d[2] * dx1*dy1)/ (1 << (2 * SHIFT));*/

					int p1 = a[0] * ((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[0] * dx1*((1 << SHIFT) - dy1) + c[0] * ((1 << SHIFT) - dx1)*dy1 + d[0] * dx1*dy1;
					p1 = DESCALE(p1, 2 * SHIFT);
					int p2 = a[1] * ((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[1] * dx1*((1 << SHIFT) - dy1) + c[1] * ((1 << SHIFT) - dx1)*dy1 + d[1] * dx1*dy1;
					p2 = DESCALE(p2, 2 * SHIFT);
					int p3 = a[2] * ((1 << SHIFT) - dx1)*((1 << SHIFT) - dy1) + b[2] * dx1*((1 << SHIFT) - dy1) + c[2] * ((1 << SHIFT) - dx1)*dy1 + d[2] * dx1*dy1;
					p3 = DESCALE(p3, 2 * SHIFT);


					dstImage.at<cv::Vec3b>(y, x) = Vec3b(p1, p2, p3);
				}
				else
				{
					dstImage.at<cv::Vec3b>(y, x) = cv::Vec3b(0, 0, 0);
				}

			}
		}
	}
}
 
下面我们测试一下他们的速度
 测试环境：Intel core i5-6200U,12G，放大2倍
 
测试方法
Rotate_Nearest
Rotate_Bilinear
Rotate_Bilinear2
速度(单位ms)
58.2
144.9
78.7
可以看出，优化后的代码速度提升还是很明显的。
 
双线性代码还可以进一步的优化，有兴趣的朋友可以自己实现。
 
完整工程见github项目：QQImageProcess_OpenCV
 其中图像旋转优化的实现在 Src/ImageProcess/GeometryTransformation.h中的Rotate_系列函数中。
 
 
2016-9-11 15:12:24
 Last Updated:2017-3-11 23:22:16
 
 
非常感谢您的阅读，如果您觉得这篇文章对您有帮助，欢迎扫码进行赞赏。
 

 
 
点击上方“小白学视觉”，选择加"星标"或“置顶”
 
重磅干货，第一时间送达
 
转自|OpenCV学堂

 
01
 
引言
 
初学图像处理，很多人遇到的第一关就是图像旋转，图像旋转是图像几何变换中最具代表性的操作，包含了插值、背景处理、三角函数等相关知识，一个变换矩阵跟计算图像旋转之后的大小公式就让很多开发者最后直接调用函数了事，但是其实这个东西并没有这么难懂，可以说主要是之前别人写的公式太吓人，小编很久以前第一次接触的也是被吓晕了！所以决定从程序员可以接受的角度从新介绍一下图像旋转基本原理与OpenCV中图像旋转函数操作的基本技巧。
 
图像旋转基本原理
 
旋转涉及到两个问题，一个是图像旋转之后的大小会发生改变，会产生背景，通过背景填充方式都是填充黑色，此外旋转还是产生像素的位置迁移，新的位置像素需要通过插值计算获得，常见的插值方式有最近邻、线性插值、立方插值等。
 
首先看旋转之后的图像宽高变化，如下图所示：
 

 

 
这个是正常的平面坐标系中的旋转矩阵，可以简写为：
 

 
是一个2x3的矩阵，但是在图像中左上角是原点，要实现围绕图像的中心位置旋转，M就要重新计算，所以OpenCV中的图像旋转矩阵为：
 

 
其中scale是表示矩阵支持旋转+放缩，这里可以把Scale=1。第三列是图像旋转之后中心位置平移量。
 
函数支持
 
OpenCV中支持图像旋转的函数有两个，一个是直接支持旋转的函数，但是它支持的是90，180，270这样的特殊角度旋转。
 
void cv::rotate   (
    InputArray    src,
    OutputArray dst,
    int rotateCode
)

 
其中rotateCode参数必须为：
 
ROTATE_180,
ROTATE_90_CLOCKWISE
ROTATE_90_COUNTERCLOCKWISE 

 
函数warpAffine支持任意角度的旋转，通过定义M矩阵实现
 
void cv::warpAffine(
         InputArray      src, // 输入图像
         OutputArray dst, // 输出图像
         InputArray      M, // 旋转矩阵
         Size         dsize, // 输出图像大小
         int   flags = INTER_LINEAR, // 像素插值方式
         int   borderMode = BORDER_CONSTANT, // 背景填充默认为常量
         const Scalar &        borderValue = Scalar() // 填充颜色默认为黑色
)

 
但是M如何生成与获取，OpenCV中提供了一个函数根据输入的参数自动生成旋转矩阵M，该函数为：
 
Mat cv::getRotationMatrix2D(
         Point2f   center,
         double    angle,
         double    scale
)

 
代码演示
 
原图
 

 
使用自定义的M矩阵实现图像旋转

 
h, w, c = src.shape
# 定义矩阵
M = np.zeros((2, 3), dtype=np.float32)
# 定义角度
alpha = np.cos(np.pi / 4.0)
beta = np.sin(np.pi / 4.0)
print("alpha : ", alpha)
# 初始化矩阵
M[0, 0] = alpha
M[1, 1] = alpha
M[0, 1] = beta
M[1, 0] = -beta
cx = w / 2
cy = h / 2
tx = (1-alpha)*cx - beta*cy
ty = beta*cx + (1-alpha)*cy
M[0,2] = tx
M[1,2] = ty
# 执行旋转
dst = cv.warpAffine(src, M, (w, h))
cv.imshow("rotate-center-demo", dst)
 

 
重新计算旋转之后的图像大小，实现无Crop版本的图像旋转
 
h, w, c = src.shape
M = np.zeros((2, 3), dtype=np.float32)
alpha = np.cos(np.pi / 4.0)
beta = np.sin(np.pi / 4.0)
print("alpha : ", alpha)

# 初始旋转矩阵
M[0, 0] = alpha
M[1, 1] = alpha
M[0, 1] = beta
M[1, 0] = -beta
cx = w / 2
cy = h / 2
tx = (1-alpha)*cx - beta*cy
ty = beta*cx + (1-alpha)*cy
M[0,2] = tx
M[1,2] = ty

# change with full size
bound_w = int(h * np.abs(beta) + w * np.abs(alpha))
bound_h = int(h * np.abs(alpha) + w * np.abs(beta))

# 添加中心位置迁移
M[0, 2] += bound_w / 2 - cx
M[1, 2] += bound_h / 2 - cy
dst = cv.warpAffine(src, M, (bound_w, bound_h))
cv.imshow("rotate without cropping", dst)
 

 
背景随便变化+无Crop版本的图像旋转动态演示
 
degree = 1.0
d1 = np.pi / 180.0
while True:
    alpha = np.cos(d1*degree)
    beta = np.sin(d1*degree)
    M[0, 0] = alpha
    M[1, 1] = alpha
    M[0, 1] = beta
    M[1, 0] = -beta
    cx = w / 2
    cy = h / 2
    tx = (1 - alpha) * cx - beta * cy
    ty = beta * cx + (1 - alpha) * cy
    M[0, 2] = tx
    M[1, 2] = ty

    # change with full size
    bound_w = int(h * np.abs(beta) + w * np.abs(alpha))
    bound_h = int(h * np.abs(alpha) + w * np.abs(beta))
    M[0, 2] += bound_w / 2 - cx
    M[1, 2] += bound_h / 2 - cy
    red = np.random.randint(0, 255)
    green = np.random.randint(0, 255)
    blue = np.random.randint(0, 255)
    dst = cv.warpAffine(src, M, (bound_w, bound_h), borderMode=cv.BORDER_CONSTANT, borderValue=(blue, green, red))
    cv.imshow("rotate+background", dst)
    c = cv.waitKey(1000)
    if c == 27:
        break
    degree += 1
    print("degree", degree)
    if degree > 360:
        degree = degree % 360
 

 

 
下载1：OpenCV-Contrib扩展模块中文版教程
 
在「小白学视觉」公众号后台回复：扩展模块中文教程，即可下载全网第一份OpenCV扩展模块教程中文版，涵盖扩展模块安装、SFM算法、立体视觉、目标跟踪、生物视觉、超分辨率处理等二十多章内容。
 
下载2：Python视觉实战项目31讲
 
在「小白学视觉」公众号后台回复：Python视觉实战项目31讲，即可下载包括图像分割、口罩检测、车道线检测、车辆计数、添加眼线、车牌识别、字符识别、情绪检测、文本内容提取、面部识别等31个视觉实战项目，助力快速学校计算机视觉。
 
下载3：OpenCV实战项目20讲
 
在「小白学视觉」公众号后台回复：OpenCV实战项目20讲，即可下载含有20个基于OpenCV实现20个实战项目，实现OpenCV学习进阶。
 
下载4：leetcode算法开源书
 
在「小白学视觉」公众号后台回复：leetcode，即可下载。每题都 runtime beats 100% 的开源好书，你值得拥有！
 


 
交流群

 
欢迎加入公众号读者群一起和同行交流，目前有SLAM、三维视觉、传感器、自动驾驶、计算摄影、检测、分割、识别、医学影像、GAN、算法竞赛等微信群（以后会逐渐细分），请扫描下面微信号加群，备注：”昵称+学校/公司+研究方向“，例如：”张三 + 上海交大 + 视觉SLAM“。请按照格式备注，否则不予通过。添加成功后会根据研究方向邀请进入相关微信群。请勿在群内发送广告，否则会请出群，谢谢理解~