几何变换

几何变换是指将一幅图像映射到另外一幅图像内的操作。

缩放

使用函数cv2.resize()实现对图像的缩放

dst = cv2.resize( src, dsize[, fx[, fy[, interpolation]]] )

• dst代表输出的目标图像，该图像的类型与src相同，其大小为dsize（当该值非零时），或者可以通过src.size()、fx、fy计算得到。

• src代表需要缩放的原始图像

• dsize代表输出图像大小。

• fx代表水平方向的缩放比例。

• fy代表垂直方向的缩放比例。

  在cv2.resize()函数中，目标图像的大小可以通过“参数dsize”或者“参数fx和fy”二者之一来指定，具体介绍如下。

  情况1：通过参数dsize指定

  如果指定参数dsize的值，则无论是否指定了参数fx和fy的值，都由参数dsize来决定目标图像的大小。

  dsize内第1个参数对应缩放后图像的宽度（width，即列数cols，与参数fx相关），第2个参数对应缩放后图像的高度（height，即行数rows，与参数fy相关）

  指定参数dsize的值时，x方向的缩放大小（参数fx）为：

  (double)dsize.width/src.cols
  

  同时，y方向的缩放大小（参数fy）为：

  (double)dsize.height/src.rows
  

  情况2：通过参数fx和fy指定

  如果参数dsize的值是None，那么目标图像的大小通过参数fx和fy来决定。此时，目标图像的大小为：

  dsize=Size(round(fx*src.cols), round(fy*src.rows)) 
  

  目标图像dst的最终大小和类型是通过src、dsize、fx、fy指定的。

• interpolation代表插值方式

  

  插值是指在对图像进行几何处理时，给无法直接通过映射得到值的像素点赋值。

  目标图像上的该像素点不能对应到原始图像的某个具体位置上，此时也要对这些像素点进行插值 处理，以完成映射。

  • 当缩小图像时，使用区域插值方式（INTER_AREA）能够得到最好的效果；

  • 当放大图像时，使用三次样条插值（INTER_CUBIC）方式和双线性插值（INTER_LINEAR）方式都能够取得较好的效果。

    三次样条插值方式速度较慢，双线性插值方式速度相对较快且效果并不逊色。

例子

使用函数cv2.resize()对一个数组进行简单缩放。

import cv2 
import numpy as np 
img=np.ones([2,4,3], dtype=np.uint8) 
size=img.shape[:2] 
rst=cv2.resize(img, size) 
print("img.shape=\n", img.shape) 
print("img=\n", img) 
print("rst.shape=\n", rst.shape) 
print("rst=\n", rst) 

注意

• 目标图像的行数是原始图像的列数。
• 目标图像的列数是原始图像的行数。

函数cv2.resize()内dsize参数与图像shape属性在行、列的顺序上是不一致的

• 在shape属性中，第1个值对应的是行数，第2个值对应的是列数
• 在dsize参数中，第1个值对应的是列数，第2个值对应的是行数

在使用cv2.resize()函数时，要额外注意参数dsize的属性顺序问题。

例子

1. 使用函数cv2.resize()完成一个简单的图像缩放。

import cv2 
img=cv2.imread("lena.jpg") 
rows, cols=img.shape[:2] 
size=(int(cols*0.9), int(rows*0.5)) 
rst=cv2.resize(img, size) 
print("img.shape=", img.shape) 
print("rst.shape=", rst.shape)

2. 控制函数cv2.resize()的fx参数、fy参数，完成图像缩放

import cv2 
img=cv2.imread("lena.jpg") 
rst=cv2.resize(img, None, fx=2, fy=0.5) 
print("img.shape=", img.shape) 
print("rst.shape=", rst.shape)

• fx进行的是水平方向的缩放
• fy进行的是垂直方向的缩放

翻转

图像的翻转采用函数cv2.flip()实现

该函数能够实现图像在水平方向翻转、垂直方向翻转、两个方向同时翻转

dst = cv2.flip( src, flipCode )

• dst代表和原始图像具有同样大小、类型的目标图像。

• src代表要处理的原始图像

• flipCode代表旋转类型。

  

  该函数中，目标像素点与原始像素点的关系可表述为：

  

例子

使用函数cv2.flip()完成图像的翻转

import cv2 
img=cv2.imread("lena.jpg") 
x=cv2.flip(img,0) 
y=cv2.flip(img,1) 
xy=cv2.flip(img, -1) 
cv2.imshow("img", img) 
cv2.imshow("x", x) 
cv2.imshow("y", y) 
cv2.imshow("xy", xy) 
cv2.waitKey() 
cv2.destroyAllWindows() 

仿射

仿射变换是指图像可以通过一系列的几何变换来实现平移、旋转等多种操作。

该变换能够保持图像的平直性和平行性。

平直性是指图像经过仿射变换后，直线仍然是直线；平行性是指图像在完成仿射变换后，平行线仍然是平行线。

OpenCV中的仿射函数为cv2.warpAffine()，其通过一个变换矩阵（映射矩阵）M实现变换，具体为：

dst(x, y)=src(M11x+M12y+M13, M21x+M22y+M23)

通过一个变换矩阵M，将原始图像O变换为仿射图像R。

采用仿射函数cv2.warpAffine()实现对图像的变换，该函数的语法格式如下：

dst = cv2.warpAffine( src, M, dsize[, flags[, borderMode[, borderValue]]] )

• dst代表仿射后的输出图像，该图像的类型和原始图像的类型相同。dsize决定输出图像的实际大小。
• src代表要仿射的原始图像。
• M代表一个2×3的变换矩阵。使用不同的变换矩阵，就可以实现不同的仿射变换。
• dsize代表输出图像的尺寸大小。
• flags代表插值方法，默认为INTER_LINEAR。当该值为WARP_INVERSE_MAP时，意味着M是逆变换类型，实现从目标图像dst到原始图像src的逆变换。
• borderMode代表边类型，默认为BORDER_CONSTANT。当该值为BORDER_TRANSPARENT时，意味着目标图像内的值不做改变，这些值对应原始图像内的异常值。
• borderValue代表边界值，默认是0。

在OpenCV中使用函数cv2.warpAffine()实现仿射变换，忽略其可选参数后的语法格式为：

dst = cv2.warpAffine( src , M , dsize ) 

其通过转换矩阵M将原始图像src转换为目标图像dst：

dst(x, y)=src(M11x+M12y+M13, M21x+M22y+M23)

进行何种形式的仿射变换完全取决于转换矩阵M。

平移

将原始图像src向右侧移动100个像素、向下方移动200个像素，则其对应关系为：

dst (x, y)=src (x+ 100, y+ 200)

将上述表达式补充完整，即：

dst (x, y)=src (1·x+ 0·y+ 100, 0·x+ 1·y+ 200)

可以确定对应的转换矩阵M中各个元素的值为：

例子

图像平移

import cv2 
import numpy as np 
img=cv2.imread("lena.jpg") 
height, width=img.shape[:2] 
x=100 
y=200 
M = np.float32([[1, 0, x], [0, 1, y]]) 
move=cv2.warpAffine(img, M, (width, height)) 
cv2.imshow("original", img) 
cv2.imshow("move", move) 
cv2.waitKey() 
cv2.destroyAllWindows() 

旋转

可以通过函数cv2.getRotationMatrix2D()获取转换矩阵。该函数的语法格式为：

retval=cv2.getRotationMatrix2D(center, angle, scale)

• center为旋转的中心点。
• angle为旋转角度，正数表示逆时针旋转，负数表示顺时针旋转。
• scale为变换尺度（缩放大小）。

想要以图像中心为圆点，逆时针旋转45°，并将目标图像缩小为原始图像的0.6倍，则在调用函数cv2.getRotationMatrix2D()生成转换矩阵M时所使用的语句为：

M=cv2.getRotationMatrix2D((width/2,height/2),45,0.6)

例子

图像旋转

import cv2 
img=cv2.imread("lena.jpg") 
height, width=img.shape[:2] 
M=cv2.getRotationMatrix2D((width/2, height/2),45,0.6) 
rotate=cv2.warpAffine(img, M, (width, height)) 
cv2.imshow("original", img) 
cv2.imshow("rotation", rotate) 
cv2.waitKey() 
cv2.destroyAllWindows() 

更复杂的仿射变换

对于更复杂仿射变换，OpenCV提供了函数cv2.getAffineTransform()来生成仿射函数cv2.warpAffine()所使用的转换矩阵M。

该函数的语法格式为：

retval=cv2.getAffineTransform(src, dst) 

• src代表输入图像的三个点坐标。
• dst代表输出图像的三个点坐标。

参数值src和dst是包含三个二维数组(x, y)点的数组。

指代原始图像和目标图像内平行四边形的三个顶点（左上角、右上角、左下角）

上述参数通过函数cv2.getAffineTransform()定义了两个平行四边形。

src和dst中的三个点分别对应平行四边形的左上角、右上角、左下角三个点。

函数cv2.warpAffine()以函数cv2.getAffineTransform()获取的转换矩阵M为参数，将src中的点仿射到dst中。

函数cv2.getAffineTransform()对所指定的点完成映射后，将所有其他点的映射关系按照指定点的关系计算确定。

import cv2 
import numpy as np 
img=cv2.imread('lena.bmp') 
rows, cols, ch=img.shape 
p1=np.float32([[0,0], [cols-1,0], [0, rows-1]]) 
p2=np.float32([[0, rows*0.33], [cols*0.85, rows*0.25], [cols*0.15, rows*0.7]]) 
M=cv2.getAffineTransform(p1, p2) 
dst=cv2.warpAffine(img, M, (cols, rows)) 
cv2.imshow("origianl", img) 
cv2.imshow("result", dst) 
cv2.waitKey() 
cv2.destroyAllWindows() 

透视

• 仿射变换可以将矩形映射为任意平行四边形
• 透视变换则可以将矩形映射为任意四边形

透视变换通过函数cv2.warpPerspective()实现

dst = cv2.warpPerspective( src, M, dsize[, flags[, borderMode[, borderValue]]] )

• dst代表透视处理后的输出图像，该图像和原始图像具有相同的类型。dsize决定输出图像的实际大小。
• src代表要透视的图像。
• M代表一个3×3的变换矩阵。
• dsize代表输出图像的尺寸大小。
• flags代表插值方法，默认为INTER_LINEAR。当该值为WARP_INVERSE_MAP时，意味着M是逆变换类型，能实现从目标图像dst到原始图像src的逆变换。
• borderMode代表边类型，默认为BORDER_CONSTANT。当该值为BORDER_TRANSPARENT时，意味着目标图像内的值不做改变，这些值对应原始图像内的异常值。
• borderValue代表边界值，默认是0。

与仿射变换一样，同样可以使用一个函数来生成函数cv2.warpPerspective()所使用的转换矩阵。

该函数是cv2.getPerspectiveTransform()，其语法格式为：

retval = cv2.getPerspectiveTransform( src, dst )

• src代表输入图像的四个顶点的坐标。
• dst代表输出图像的四个顶点的坐标。

src参数和dst参数是包含四个点的数组，与仿射变换函数cv2.getAffineTransform()中的三个点是不同的。

图像透视

import cv2 
import numpy as np 
img=cv2.imread('demo.bmp') 
rows, cols=img.shape[:2] 
pts1 = np.float32([[150,50], [400,50], [60,450], [310,450]]) 
pts2 = np.float32([[50,50], [rows-50,50], [50, cols-50], [rows-50, cols-50]]) 
M=cv2.getPerspectiveTransform(pts1, pts2) 
dst=cv2.warpPerspective(img, M, (cols, rows)) 
cv2.imshow("img", img) 
cv2.imshow("dst", dst) 
cv2.waitKey() 
cv2.destroyAllWindows() 

重映射

把一幅图像内的像素点放置到另外一幅图像内的指定位置，这个过程称为重映射。

OpenCV内的重映射函数cv2.remap()其语法格式如下：

dst = cv2.remap( src, map1, map2, interpolation[, borderMode[, borderValue]] ) 

• dst代表目标图像，它和src具有相同的大小和类型。

• src代表原始图像。

• map1参数有两种可能的值：

  • 表示(x, y)点的一个映射。
  • 表示CV_16SC2 , CV_32FC1, CV_32FC2类型(x, y)点的x值。

• map2参数同样有两种可能的值：

  • 当map1表示(x, y)时，该值为空。
  • 当map1表示(x, y)点的x值时，该值是CV_16UC1, CV_32FC1类型(x, y)点的y值。

  map1,map2 可以代表的不仅仅是一个点，而是多个点

• Interpolation代表插值方式，这里不支持INTER_AREA方法

  

• borderMode代表边界模式。当该值为BORDER_TRANSPARENT时，表示目标图像内的对应源图像内奇异点（outliers）的像素不会被修改。

• borderValue代表边界值，该值默认为0。

映射参数的理解

重映射通过修改像素点的位置得到一幅新图像。

在构建新图像时，需要确定新图像中每个像素点在原始图像中的位置。所以，映射函数的作用是查找新图像像素在原始图像内的位置，该过程是将新图像像素映射到原始图像的过程，因此被称为反向映射。

参数map1和参数map2用来说明反向映射，map1针对的是坐标x, map2针对的是坐标y。map1和map2的值都是浮点数。因此，目标图像可以映射回一个非整数的值，这意味着目标图像可以“反向映射”到原始图像中两个像素点之间的位置(该位置是不存在像素值的)。可以采用不同的方法实现插值，函数中的interpolation参数可以控制插值方式。

由于参数map1和参数map2的值是浮点数，所以通过函数cv2.remamp()所能实现的映射关系变得更加随意，可以通过自定义映射参数实现不同形式的映射。

函数cv2.remap()中参数map1指代的是像素点所在位置的列号，参数map2指代的是像素点所在位置的行号。

例如: 想将目标图像（映射结果图像）中某个点A映射为原始图像内处于第0行第3列上的像素点B，那么需要将A点所对应的参数map1对应位置上的值设为3，参数map2对应位置上的值设为0。所以，通常情况下，将map1写为mapx，并且将map2写成mapy。

如果想将目标图像（映射结果图像）中所有像素点都映射为原始图像内处于第0行第3列上的像素点B，那么需要将参数map1内的值均设为3，将参数map2内的值均设为0。

如果想将目标图像（映射结果图像）中所有像素点都映射为原始图像内处于第0行第3列上的像素点B，那么需要将参数map1内的值均设为3，将参数map2内的值均设为0。

例子

将目标数组内的所有像素点都映射为原始图像内第0行第3列上的像素点，

可以确定：

• 用来指定列的参数map1（mapx）内的值均为3。
• 用来指定行的参数map2（mapy）内的值均为0。

import cv2 
import numpy as np 
img=np.random.randint(0,256, size=[4,5], dtype=np.uint8) 
rows, cols=img.shape 
mapx = np.ones(img.shape, np.float32)*3 
mapy = np.ones(img.shape, np.float32)*0 
rst=cv2.remap(img, mapx, mapy, cv2.INTER_LINEAR) 
print("img=\n", img) 
print("mapx=\n", mapx) 
print("mapy=\n", mapy) 
print("rst=\n", rst) 
# 目标图像（数组）dst内的所有值都来源于原始图像中第0行第3列上的像素值252。

复制

通过该函数实现图像的复制

在映射时，将参数进行如下处理：

• 将map1的值设定为对应位置上的x轴坐标值。
• 将map2的值设定为对应位置上的y轴坐标值。

import cv2 
import cv2 
import numpy as np 
img=cv2.imread("img\\lena.jpg") 
rows, cols=img.shape[:2] 
mapx = np.zeros(img.shape[:2], np.float32) 
mapy = np.zeros(img.shape[:2], np.float32) 
for i in range(rows): 
    for j in range(cols): 
        mapx.itemset((i, j), j) 
        mapy.itemset((i, j), i) 
rst=cv2.remap(img, mapx, mapy, cv2.INTER_LINEAR) 
cv2.imshow("original", img) 
cv2.imshow("result", rst) 
cv2.waitKey() 
cv2.destroyAllWindows() 

绕x轴翻转

如果想让图像绕着x轴翻转，意味着在映射过程中：

• x坐标轴的值保持不变。
• y坐标轴的值以x轴为对称轴进行交换。

反映在map1和map2上：

• map1的值保持不变。
• map2的值调整为“总行数-1-当前行号”。

import cv2 
import numpy as np 
img=cv2.imread("img\\lena.jpg") 
rows, cols=img.shape[:2] 
mapx = np.zeros(img.shape[:2], np.float32) 
mapy = np.zeros(img.shape[:2], np.float32) 
for i in range(rows): 
	for j in range(cols): 
		mapx.itemset((i, j), j) 
		mapy.itemset((i, j), rows-1-i) 
rst=cv2.remap(img, mapx, mapy, cv2.INTER_LINEAR) 
cv2.imshow("original", img) 
cv2.imshow("result", rst) 
cv2.waitKey() 
cv2.destroyAllWindows() 

绕y轴翻转

如果想让图像绕着y轴翻转，意味着在映射过程中：

• y坐标轴的值保持不变。
• x坐标轴的值以y轴为对称轴进行交换。

反映在map1和map2上：

• map2的值保持不变。
• map1的值调整为“总列数-1-当前列号”。

import cv2 
import numpy as np 
img=cv2.imread("img\\lena.jpg") 
rows, cols=img.shape[:2] 
mapx = np.zeros(img.shape[:2], np.float32) 
mapy = np.zeros(img.shape[:2], np.float32) 
for i in range(rows): 
	for j in range(cols): 
		mapx.itemset((i, j), cols-1-j) 
		mapy.itemset((i, j), i) 
rst=cv2.remap(img, mapx, mapy, cv2.INTER_LINEAR) 
cv2.imshow("original", img) 
cv2.imshow("result", rst) 
cv2.waitKey() 
cv2.destroyAllWindows() 

绕x轴、y轴翻转

• x坐标轴的值以y轴为对称轴进行交换。
• y坐标轴的值以x轴为对称轴进行交换。

反映在map1和map2上：

• map1的值调整为“总列数-1-当前列号”。
• map2的值调整为“总行数-1-当前行号”。

import cv2 
import numpy as np 
img=cv2.imread("img\\lena.jpg") 
rows, cols=img.shape[:2] 
mapx = np.zeros(img.shape[:2], np.float32) 
mapy = np.zeros(img.shape[:2], np.float32) 
for i in range(rows): 
	for j in range(cols): 
		mapx.itemset((i, j), cols-1-j) 
		mapy.itemset((i, j), rows-1-i) 
rst=cv2.remap(img, mapx, mapy, cv2.INTER_LINEAR) 
cv2.imshow("original", img) 
cv2.imshow("result", rst) 
cv2.waitKey() 
cv2.destroyAllWindows() 

x轴、y轴互换

如果想让图像的x轴、y轴互换，意味着在映射过程中，对于任意一点，都需要将其x轴、y轴坐标互换。

反映在mapx和mapy上：

• mapx的值调整为所在行的行号。
• mapy的值调整为所在列的列号。

如果行数和列数不一致，上述运算可能存在值无法映射的情况。默认情况下，无法完成映射的值会被处理为0。

import cv2 
import numpy as np 
img=cv2.imread("img\\lena.jpg") 
rows, cols=img.shape[:2] 
mapx = np.zeros(img.shape[:2], np.float32) 
mapy = np.zeros(img.shape[:2], np.float32) 
for i in range(rows): 
	for j in range(cols): 
		mapx.itemset((i, j), i) 
		mapy.itemset((i, j), j) 
rst=cv2.remap(img, mapx, mapy, cv2.INTER_LINEAR) 
cv2.imshow("original", img) 
cv2.imshow("result", rst) 
cv2.waitKey() 
cv2.destroyAllWindows() 

图像缩放

使用函数cv2.remap()缩小图像。

缩小图像后，可以将图像固定在围绕其中心的某个区域。

• 在目标图像的x轴(0.25·x轴长度，0.75·x轴长度)区间内生成缩小图像；x轴其余区域的点取样自x轴上任意一点的值。

• 在目标图像的y轴(0.25·y轴长度，0.75·y轴长度)区间内生成缩小图像；y轴其余区域的点取样自y轴上任意一点的值。

为了处理方便，不在上述区域的点都取(0,0)坐标点的值。

import cv2 
import numpy as np 
img=cv2.imread("img\\lena.jpg") 
rows, cols=img.shape[:2] 
mapx = np.zeros(img.shape[:2], np.float32) 
mapy = np.zeros(img.shape[:2], np.float32) 
for i in range(rows): 
	for j in range(cols): 
		if 0.25*cols< i <0.75*cols and 0.25*rows< j <0.75*rows: 
			mapx.itemset((i, j),2*( j - cols*0.25 ) + 0.5)   # x1关于x的映射函数 (x:0,x1:0.25) (x:1,x1:0.75)
			mapy.itemset((i, j),2*( i - rows*0.25 ) + 0.5) 
		else: 
			mapx.itemset((i, j),0) 
			mapy.itemset((i, j),0) 
rst=cv2.remap(img, mapx, mapy, cv2.INTER_LINEAR) 
cv2.imshow("original", img) 
cv2.imshow("result", rst) 
cv2.waitKey() 
cv2.destroyAllWindows()