【OpenCV C++20 学习笔记】仿射变换-warpAffine, getRotationMatrix2D

原理

概述

仿射变换是矩阵乘法（线性变换）和向量加法的结合。它包含了：

• 旋转（线性变换）
• 转换（向量加法）
• 缩放（线性变换）

本质上，仿射变换就是两个图像矩阵之间的运算。

通常用一个$2\times 3$的矩阵来展示仿射变换（向量加法）：
A = [ a 00 a 01 a 10 a 11 ] 2 × 2 B = [ b 00 b 10 ] 2 × 1 A=

$$\begin{bmatrix} a_{00} & a_{01} \\ a_{10} & a_{11} \end{bmatrix}$$ _{2\times 2} B= $$\begin{bmatrix} b_{00} \\ b_{10} \end{bmatrix}$$ _{2 \times 1} A=[a00​a10​​a01​a11​​]2×2​B=[b00​b10​​]2×1​
$$M=\left[\begin{array}{cc}A& B\end{array}\right]={\left[\begin{array}{ccc}{a}_{00}& a_{01}& b_{00}\\ a_{10}& a_{11}& b_{10}\end{array}\right]}_{2\times 3}$$
$M$就是要进行仿射变换的矩阵，它可以由$A$和$B$相加得到。下面用一个2D向量$X=\left[\begin{array}{c}x\\ y\end{array}\right]$来对其进行变换。可以对其中的$A$和$B$进行计算：
$$T=A\cdot \left[\begin{array}{c}x\\ y\end{array}\right]+B$$
也可以直接对$M$进行计算。
$$T=M\cdot [x,y,1{]}^T$$
得到仿射变换后的结果$T$：
$$T=\left[\begin{array}{ccc}{a}_{00}x& a_{01}y& b_{00}\\ a_{10}x& a_{11}y& b_{10}\end{array}\right]$$
总结：变换矩阵$M$，将原矩阵$X$和结果矩阵$T$联系起来了，$X$通过$M$的变换，得到$T$

得到仿射变换的方法

在实际操作中通常有两种情况：

1. $X$和$T$已知，需要找到变换矩阵$M$
2. $M$和$X$已知，需要计算结果矩阵$T$。这种情况只需要将$M\cdot X$就能得到$T$了

也可以从几何学的角度来考虑第2种情况。如下图，图1中3个点组成的三角形经过仿射变换成了图2中的三角形：

因为三点可以确定一个平面，所以这个方法可以用在图片上；即确定图片上3个点的仿射变换，就相当于确定了整张图片的仿射变换。

API

getAffineTransform()函数

如上所诉，要像对整张图片进行放射变换，首先要确定图片上3个点的仿射变换，这个操作在OpenCV中通过getAffineTransform函数实现，其原型如下：

Mat cv::getAffineTransform(	InputArray	src,
							OutputArray	dst)
1
2

• src是包含确定仿射变换的3个点的坐标的数组
• dst是仿射变换之后3个点的坐标结果的数组
• 返回的矩阵储存了从src变换到dst的变换方式，即第一章中讲的$2\times 3$的$M$变换矩阵

这个函数的算法如下：
[ x i ′ y i ′ ] = M ⋅ [ x i y i 1 ]

$$\begin{bmatrix} x'_i \\ y'_i \end{bmatrix}$$ = M \cdot $$\begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}$$ [xi′​yi′​​]=M⋅ ​xi​yi​1​ ​

• $i=0,1,2$，即代表3个点中的每一个
• 等号左边的向量为变换后的点坐标，即$dst(i)=(x_i^{\prime },y_i^{\prime })$
• $M$为函数返回的矩阵，即储存变换方式的矩阵
• $x_i$和$y_i$为原来的点坐标，即$src(i)=(x_i,y_i)$

warpAffine()函数

确定了图片的变换方式之后，就可以将变换方式应用到图片上了。这时需要用到warpAffine()函数，其原型如下：

void cv::warpAffine(InputArray		src,
					OutputArray		dst,
					InputArray		M,
					Size			dsize,
					int				flags = INTER_LINEAR,
					int				borderMode = BORDER_CONSTANT,
					const Scalar&	borderValue = Scalar())
1
2
3
4
5
6
7

• M为储存转换方式的矩阵，即getAffineTransform函数的输出结果
• dsize为输出图片dst的尺寸
• flags指定插值计算方法，默认为INTER_LINEAR，即双线性插值；特别地，当该参数的值为WARP_INVERSE_MAP的时候，执行与转换矩阵M相反的转换，即$dst\to src$
• borderMode指定外推计算方法，默认为BORDER_CONSTANT，即用单色进行外推扩充；特别的，当该参数的值为BORDER_TRANSPARENT时，超出原图范围的像素点将不被改函数修改
• borderValue参数只有在borderMode = BORDER_CONSTANT时，才需要提供，用来指定扩充的像素颜色

这个函数的算法如下：
$$dst(x,y)=src(M_{11}x+M_{12}y+M_{13},M_{21}x+M_{22}y+M_{23})$$
即第一章中讲的$T=M\cdot [x,y,1{]}^T$

getRotationMatrix2D()函数

上述的变换还只能像第一章的图中所展示的那样将图片进行变形。如果想要图中的三角形旋转一定的角度，则需要用到getRotationMatrix2D()方法，其原型如下：

Mat cv::getRotationMatrix2D(Point2f	center,
							double angle,
							double scale)
1
2
3

该函数与getAffineTransform函数类似，返回一个转换矩阵

• center为旋转中心在原图中的位置坐标
• angle为旋转角度，正值为逆时针旋转（坐标原点在左上角）
• scale为各向同性缩放因子

该函数返回的变换矩阵如下：
[ α β ( 1 − α ) ⋅ c e n t e r . x − β ⋅ c e n t e r . y − β α β ⋅ c e n t e r . x + ( 1 − α ) ⋅ c e n t e r . y ]

$$\begin{bmatrix} \alpha & \beta & (1-\alpha) \cdot center.x-\beta \cdot center.y \\ -\beta & \alpha & \beta \cdot center.x+(1-\alpha) \cdot center.y \end{bmatrix}$$ [α−β​βα​(1−α)⋅center.x−β⋅center.yβ⋅center.x+(1−α)⋅center.y​]

• $\alpha =scale\cdot \cos angle$
• $\beta =scale\cdot \sin angle$

示例

本示例先将图片进行仿射变换，再将其顺时针旋转50度，并缩小到0.6倍。完整代码如下：

#include <opencv2/imgproc.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>

using namespace cv;
using namespace std;

int main() {
	Mat src{ imread("lena.jpg") };

	//原图中的3个点
	Point2f srcTri[3];
	srcTri[0] = Point2f(0.f, 0.f);
	srcTri[1] = Point2f(src.cols - 1.f, 0.f);
	srcTri[2] = Point2f(0.f, src.rows - 1.f);

	//变换后3个点的坐标
	Point2f dstTri[3];
	dstTri[0] = Point2f(0.f, src.rows * 0.33f);
	dstTri[1] = Point2f(src.cols*0.85f, src.rows * 0.25f);
	dstTri[2] = Point2f(src.cols*0.15f, src.rows * 0.7f);

	//获取变换矩阵
	Mat warp_mat = getAffineTransform(srcTri, dstTri);

	//用于储存变换结果的矩阵（和原图有相同的尺寸和数据类型）
	Mat warp_dst{ Mat::zeros(src.rows, src.cols, src.type()) };
	//仿射变换
	warpAffine(src, warp_dst, warp_mat, warp_dst.size());

	Point center{ Point(warp_dst.cols / 2, warp_dst.rows / 2) };
	double angle{ -50.0 };
	double scale{ 0.6 };

	//获取旋转的变换矩阵
	Mat rot_mat{ getRotationMatrix2D(center, angle, scale) };

	//用于储存旋转结果的矩阵
	Mat warp_rotate_dst;
	//旋转变换
	warpAffine(warp_dst,warp_rotate_dst, rot_mat, warp_dst.size());

	imshow("原图", src);
	imshow("仿射变换", warp_dst);
	imshow("仿射变换+旋转", warp_rotate_dst);
	waitKey(0);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

运行结果如下：