OpenCV 图像变换之 —— 拉伸、收缩、扭曲和旋转

本文最后更新于：2024年5月7日下午

本文摘录 OpenCV 中的图像变换相关操作内容，重点介绍 Opencv 中的拉伸、收缩、扭曲和旋转操作。

概述

图像变换最直接的应用就是改变图像的形状、大小、方向等等，这些在OpenCV 中有部分现成的实现。

文中示例为Python代码，用到了我常用的工具库 mtutils，文中用到的该库内容主要为 opencv 和 matplotlib 库的封装，可以用命令
1
pip install mtutils
安装该库

使用时可以按照如下方式引入：

import mtutils as mt
mt.PIS(img)
mt.cv_rgb_imread(img_path)

# 或

from mtutils import PIS, cv_rgb_imread
PIS(img)
cv_rgb_imread(img_path)

均匀调整

图像放缩

我们经常遇到一些尺寸的图像，我们想转换成其他尺寸。我们可能想要增大或缩小图像，这两个任务都是可以通过相同的函数实现的。

cv2.resize()

官方文档

函数使用

cv2.resize(	
	src, 					# 源图像
	dsize[, 				# 图像尺寸，可以设置为 None，尺寸根据 fx, fy 和 src 参数确定
	dst[, 					# 输出图像
	fx[, 					# x 方向的缩放比例因子，当为0时采用 dsize 参数确定
	fy[, 					# y 方向的缩放比例因子，当为0时采用 dsize 参数确定
	interpolation]]]]		# 插值方法	
	) -> dst

参数说明

dsize 和 fx, fy 只能配置一套，即要么配置尺寸，要么配置比例，二者互斥
如dsize 为 None，则其计算方法为：

$$
dsize =\operatorname{Size}( round (f x· \operatorname{src} . cols ) , round (fy·src.rows))
$$

如 fx, fy 为 0，则其计算方法为：

$$ \begin{array}{c} fx=(double)dsize.width/src.cols\\ fy=(double)dsize.height/src.rows \end{array} $$

interpolation

文档说明

可选值	含义
cv2.INTER_NEAREST	最近邻插值
cv2.INTER_LINEAR	双线性插值
cv2.INTER_CUBIC	bicubic 插值
cv2.INTER_AREA	基于像素面积关系的重采样。这可能是图像抽取的首选方法，因为它给出了无云纹的结果。但是当图像缩放时，它类似于`cv2.INTER_NEAREST` 方法。
cv2.INTER_LANCZOS4	在8x8的邻域兰克左斯插值
cv2.INTER_LINEAR_EXACT	精确的双线性我
cv2.INTER_MAX	插补代码的掩码
cv2.WARP_FILL_OUTLIERS	填充所有目标图像像素。如果其中一些对应于源图像中的异常值，则将其设置为零
cv2.WARP_INVERSE_MAP	反变换插值

示例代码

image = mt.cv_rgb_imread('img1.jpg')
res1=cv2.resize(image, [600, 300])
res2=cv2.resize(image, None,  fx=0.5,fy = 1.5)
PIS(res1, res2)

图像金字塔

图像金字塔广泛应用于各种视觉应用中。图像金字塔是图像的集合，它由单个原始图像产生，连续降采样，直到达到一些期望的停止点。此停止点可能是单像素图像！

文献和应用中经常出现两种图像金字塔：高斯和拉普拉斯金字塔。高斯金字塔用于降采样图像，当我们要从金字塔中较低的图像重构上采样图像时，需要拉普拉斯金字塔。

cv2.pyrDown()

官方文档

模糊图像并对其进行采样。

通常，我们通过首先将层$G_i$与高斯核卷积，然后去除每个偶数行和列，从而生成金字塔的层$G_i$生成高斯金字塔(我们表示该层$G_{i+1}$)中的层$(i+1)$。当然，在这种情况下，每个图像恰好是其前身的四分之一。在输入图像$G$。上迭代该过程产生整个金字塔。
OpenCV为我们提供了一种从其前身产生每个金字塔阶段的方法：
函数使用

cv2.pyrDown(	
	src[, 			# 源图像
	dst[, 			# 目标图像
	dstsize[, 		# 输出图像尺寸
	borderType]]]	# 边缘 padding 类型
	) -> dst

dstsize 默认为图像的一半尺寸
$$
((src.cols+1)/2,(src.rows+1)/2
$$
但若设置dstsize值需要有一些严格的限制(区分了该函数和 cv2.resize),具体如下:

$$ \begin{array}{c} \mid dstsize.width * 2- src. cols \mid \leq 2 \\ \mid dstsize. height * 2- src. rows \mid \leq 2 \end{array} $$

事实上是原图像尺寸一半附近极小的区域,用于控制复杂的需要严格控制金字塔的情况,一般使用建议就不要设置整个参数了.

示例代码

1
2
3

image = mt.cv_rgb_imread('img1.jpg')
res = cv2.pyrDown(image)
PIS(image, res)

cv2.pyrDown()

官方文档

上采样为图像的两倍大小

函数使用

1	`cv2.pyrUp(src[, dst[, dstsize[, borderType]]]) -> dst`

参数和cv2.pyrUp 类似, dstsize 也同样遵循类似的限制:

$$ \begin{array}{c} \mid dstsize.width * 2- src.cols \mid \leq( dstsize.width\%2 ) \\ \mid dstsize. height * 2- src.rows \mid \leq( dstsize. height \% 2) \end{array} $$

示例代码

1
2
3

image = mt.cv_rgb_imread('img1.jpg')
res = cv2.pyrUp(image)
PIS(image, res)

拉普拉斯金字塔

我们以前已经注意到，运算符cv2.pyrUp()不是cv2.pyrDown()的逆。这是很明显的，因为cv2.pyrDown()是一个丢失信息的操作符。为了恢复原始(较高分辨率)的图像，我们需要访问下采样过程丢弃的信息。

拉普拉斯金字塔可以认为是残差金字塔，用来存储下采样后图片与原始图片的差异。这个数据形成了拉普拉斯金字塔。拉普拉斯金字塔的第$i$层由以下关系定义：
$$
L_{i}=G_{i}-U P\left(G_{i+1}\right) \otimes g_{5 \times 5}
$$

这里，运算符$UP()$通过将原始图像中的位置$(x,y)$中的每个像素映射到目标图像中的像素$(2x+1,2y+1)$来进行大小化；符号$\otimes$表示卷积；而$g_{5×5}$是$5×5$高斯核。当然，$U P\left(G_{i+1}\right) \otimes g_{5 \times 5}$是由OpenCV提供的cv2.pyrUp()运算符的定义。因此，我们可以使用OpenCV直接计算拉普拉斯算子：
$$
L_{i}=G_{i}-pyrU P\left(G_{i+1}\right)
$$
高斯金字塔和拉普拉斯金字塔在下图中显示，这显示了从子图像恢复原始图像的逆过程。请注意拉普拉斯算子是如何实际使用高斯差异的近似值的，如之前的等式和图中示意图所示。

示例代码

image = mt.cv_rgb_imread('img1.jpg')
gaussian = cv2.pyrDown(image)
laplacian = image - cv2.pyrUp(gaussian)
PIS(image, laplacian)

不均匀映射

在本节中，我们转向图像的几何操作，也就是说，这些变换起源于三维几何和投影几何的交叉点。这种操作包括均匀和不均匀的调整大小(后者称为“扭曲”)。执行这些操作有很多原因，例如，扭曲和旋转图像，使其可以叠加在现有场景的墙壁上，或人工放大用于目标识别的一组训练图像。可以拉伸、收缩、扭曲或旋转图像的功能称为“几何变换”。

对于平面区域，有两种几何变换：使用2×3矩阵的变换，称为“仿射变换”；而基于3×3矩阵进行变换，称为“透视变换”或“同形”。
你可以将后一种转换作为一种计算方法，用于计算一个特定观察者感觉三维平面的方法，而这些观察者可能不会直视平面。
仿射变换是可以以矩阵乘法后跟向量加法的形式表示的任何变换。在OpenCV中，代表这种转换的标准样式是2×3矩阵。定义如下：

$$ A \equiv\left[\begin{array}{ll}a_{00} & a_{01} \\ a_{10} & a_{11}\end{array}\right] B \equiv\left[\begin{array}{l}b_{0} \\ b_{1}\end{array}\right] T \equiv\left[\begin{array}{ll}A & B\end{array}\right] X \equiv\left[\begin{array}{l}x \\ y\end{array}\right] X^{\prime} \equiv\left[\begin{array}{l}x \\ y \\ 1\end{array}\right] $$

很容易看出，仿射变换$A·X+B$的效果完全等同于将向量$X$扩展到向量$X’$,并且简单地将$X$的转置左乘$T$。
仿射变换包含平移、旋转、侧切、缩放等功能，其中 $B$ 为平移项，其余功能由 $A$ 矩阵表示。
仿射变换可以如下显示：平面中的任何平行四边形$ABCD$可以通过一些仿射变换映射到任何其他平行四边形$A’B’C’D’$。如果这些平行四边形的面积不是零，隐含的仿射变换就由两个平行四边形的（三个顶点）唯一定义。如果喜欢，你可以想象一个仿射变换，将自己的图像画成一个大的橡胶片，然后通过在角上的推或拉变形来制作不同样子的平行四边形。
仿射变换可以将矩形转换为平行四边形。它们可以挤压形状，但必须保持两边平行。它们可以旋转或缩放它。透视变换提供更多的灵活性；透视变换可以将矩形转换为任意四边形。下图显示了各种仿射变换和透视变换的示意图。

仿射变换

仿射变换有两种情况。在第一种情况下，我们有一个想要转化的图像（或感兴趣的区域）；在第二种情况下，我们有一系列点，想要计算转换的结果。这些情况在概念上非常相似，但在实际执行方面却有很大的差异。因此，对于这些情况，OpenCV有两个不同的函数。

cv2.warpAffine()

执行放射变化的函数

官方文档

函数使用

cv2.warpAffine(
	src, 				# 源图像
	M, 					# 2×3 转换矩阵
	dsize[, 			# 输出图像尺寸
	dst[, 				# 输出图像
	flags[, 			# 差值策略
	borderMode[, 		# 边界外推方法
	borderValue]]]]) 	# 当固定值外推时需要配置的值
	-> dst

其中 $M$ 为最核心的转换矩阵，新的数据坐标由 $M$ 与原始坐标计算得到：

$$
d s t(x, y)=\operatorname{src}\left(M_{00} x+M_{01} y+M_{02}, M_{10} x+M_{11} y+M_{12}\right)
$$

然而，一般来说，该方程右边所示的位置可能不是整数像素。在这种情况下，需要使用插值来找到$dst(x,y)$的适当值。参数flags用于选择插值方法。可用的插值方法和 cv2.resize() 中的差值方法相同
示例代码

image = mt.cv_rgb_imread('img1.jpg')
M = np.array([[2, 0, 200], [0, 1, 200]], dtype='float32')
res = cv2.warpAffine(image, M , [3000, 1500])
PIS(res)

cv2.getAffineTransform()

从三对对应的点计算仿射变换。

官方文档

函数使用

cv2.getAffineTransform(
	src, 			# 源图像中三角形顶点的坐标。
	dst) 			# 目标图像中相应三角形顶点的坐标。
	-> retval  		# 仿射变换矩阵

这里的src和st是包含三个二维(x,y)点的数组。返回值是从这些点计算的仿射变换的数组。

示例代码

src = np.array([
[100, 100],
[100, 200],
[200, 200]
], dtype='float32')

tar = (src * np.array([2, 1]) + np.array([100, 100])).astype('float32')
retval = cv2.getAffineTransform(src, tar)

-->
retval
array([[  2.,   0., 100.],
       [  0.,   1., 100.]])

cv2.transform()

官方文档

适用于一系列点的仿射变换

函数使用

cv2.transform(
	src, 			# 输入阵列必须具有与 m.cols 或 m.cols-1一样多的通道(1-4)。
	m[, 			# 变换矩阵，2x2 或 2x3浮点矩阵。
	dst]) -> dst

当 $m.cols=src.channels()$
$$
\operatorname{dst}(I)=\mathrm{m} \cdot \operatorname{src}(I)
$$
当$ m.cols=src.channels()+1$
$$
\operatorname{dst}(I)=\mathrm{m} \cdot[\operatorname{src}(I) ; 1]
$$

示例代码

src = np.array([
[100, 100],
[100, 200],
[200, 200]
], dtype='float32')
M = np.array([
[  2.,   0., 100.],
[  0.,   1., 100.]
])
src = src.reshape((-1, 1, 2))
trans_tar = cv2.transform(src, M)


-->
trans_tar
array([[[300., 200.]],
       [[300., 300.]],
       [[500., 300.]]], dtype=float32)

cv2.invertAffineTransform()

官方文档

这个函数计算一个由 2 × 3 矩阵 m 表示的仿射变换，反转仿射变换。

函数使用

1
2
3

cv2.invertAffineTransform(
	M[, 			# 
	iM] ) -> iM

示例代码

M = np.array([
[  2.,   0., 100.],
[  0.,   1., 100.]
])
inv_M = cv2.invertAffineTransform(M)

-->
inv_M
array([[   0.5,   -0. ,  -50. ],
       [  -0. ,    1. , -100. ]])

透视变换

透视变换是将图像从一个视平面投影到另外一个视平面的过程，所以透视变换也被称为投影映射（Projection Mapping）。我们知道在图像的仿射变换中需要变换矩阵是一个$2x3$的两维平面变换矩阵，而透视变换本质上空间立体三维变换，根据其坐标，要把三维坐标投影到另外一个视平面，就需要一个完全不同的变换矩阵M，这是透视变换跟仿射变换最大的不同。

实现原理

透视变换

$$ \left[x^{\prime}, y^{\prime}, w^{\prime}\right]=[x, y, 1]\left[\begin{array}{lll}a_{11} & a_{12} & a_{13} \\ a_{21} & a_{22} & a_{23} \\ a_{31} & a_{32} & a_{33}\end{array}\right] $$

$ \mathrm{x}, \mathrm{y} $ 是原始图片坐标，对应得到变换后的坐标 $ x’,{y’} ,w’$，目标坐标 $ x_t=x^{\prime} / w^{\prime}, y_t=y^{\prime} / w^{\prime} $ 。
变换矩阵可以分为几部分理解
- $ \left[\begin{array}{ll}a_{11} & a_{12} \\ a_{21} & a_{22}\end{array}\right] $表示线性变换
- $ \left[\begin{array}{ll}a_{31} & a_{32}\end{array}\right]_{j} $表示平移
- $ \left[\begin{array}{ll}a_{13} & a_{23}\end{array}\right]^{T} $表示透视
可以理解成仿射等是透视变换的特殊形式。
重写之前的变换公式可以得到：

$$ x_t=\frac{x^{\prime}}{w^{\prime}}=\frac{a_{11} u+a_{21} v+a_{31}}{a_{13} u+a_{23} v+a_{33}} \\ y_t=\frac{y^{\prime}}{w^{\prime}}=\frac{a_{12} u+a_{22} v+a_{32}}{a_{13} u+a_{23} v+a_{33}} $$

cv2.warpPerspective()

实现图像的透视变换

官方文档

OpenCV 实现透视变换时 $M$ 是左乘到坐标上的，因此最终的计算公式为

$$
\operatorname{dst}(x, y)=\operatorname{src}\left(\frac{M_{11} x+M_{12} y+M_{13}}{M_{31} x+M_{32} y+M_{33}}, \frac{M_{21} x+M_{22} y+M_{23}}{M_{31} x+M_{32} y+M_{33}}\right)
$$

函数使用

cv2.warpPerspective(
	src, 					# 源图像
	M, 						# 3×3变换矩阵
	dsize[, 				# 输出图像尺寸
	dst[, 					# 输出图像
	flags[, 				# 结合插值方法(INTER_LINEAR 或 INTER_NEAREST)
							# 和将 m 设置为逆变换(dst → src)的可选标志 WARP_INVERSE_MAP。
	borderMode[, 			# 像素外推方法
	borderValue]]]]			# 常数外推方法时需要设置该值
	) -> dst

示例代码

image = mt.cv_rgb_imread('img1.jpg')
M = np.array([
[1.2, -0.5, 1.],
[1., 0.5, 1.],
[0.001, -0.001, 1]
])
res = cv2.warpPerspective(image, M, [800, 2000])
PIS(res)

cv2.getPerspectiveTransform()

从四对相应的点计算透视变换，得到透视变换矩阵。

官方文档

函数使用

cv2.getPerspectiveTransform(
	src,   			# 源图像中四边形顶点的坐标。
	dst[, 			# 目标图像中相应四边形顶点的坐标。
	solveMethod]	# 计算方法
	) -> retval

示例代码

    src_points = np.array([
        [100, 100],
        [100, 200],
        [200, 200],
        [200, 100]
    ], dtype='float32')

    tar_points = np.array([
        [76, 91],
        [113, 209],
        [169, 188],
        [156, 77]
    ], dtype='float32')
    M =cv2.getPerspectiveTransform(src_points, tar_points)

-->
M
array([[ 2.18177483e+00,  1.75775497e+00, -2.30653642e+02],
       [-7.23642384e-02,  4.31608940e+00, -2.28843046e+02],
       [ 2.96688742e-03,  8.51986755e-03,  1.00000000e+00]])

cv2.perspectiveTransform()

执行矢量的透视矩阵变换。

官方文档

函数使用

cv.perspectiveTransform(
	src, 			# 源图坐标点
	m[, 			# 3×3 透视变换矩阵
	dst]) -> dst

示例代码

    src_points = np.array([
        [100, 100],
        [100, 200],
        [200, 200],
        [200, 100]
    ], dtype='float32').reshape(-1, 1, 2)
    M = np.array([[ 2.18177483e+00,  1.75775497e+00, -2.30653642e+02],
       [-7.23642384e-02,  4.31608940e+00, -2.28843046e+02],
       [ 2.96688742e-03,  8.51986755e-03,  1.00000000e+00]], dtype='float32')
    tar_points = cv2.perspectiveTransform(src_points, M)
    
    
-->
   
tar_points
array([[[ 76.     ,  91.00001]],
       [[113.     , 209.00002]],
       [[169.     , 188.00002]],
       [[156.     ,  77.00001]]], dtype=float32)