图像基本操作
学习图像处理的基本操作，例如缩放、平移、旋转等基本转换。
知识点
- 图像的缩放
- 图像的平移
- 图像的旋转
- 图像的翻转
基本的图像变换方法
图像的变换是运用某些方法将图像从一个图像空间转换到另一个图像空间，同时改变图像中的像素值。图像的变换在视觉领域是比较常见的操作，在处理图片的时候我们经常能够用到旋转、平移、翻转等变换方法。下图是图像变换的例子。
图像的缩放处理是常见的变换方法，在修图软件中常常会用到。在图像拼接时我们常常会将图片旋转、平移、翻转，在画面数字编辑和游戏制作过程中会经常使用这些方法对图像进行处理。深度学习领域我们常常会用到这些图像处理方法来处理数据集。下面我们将介绍一些常见的变换。
尺寸调整
在终端使用下面命令下载本次实验所需图片，并使用 unzip images.zip 命令解压压缩包
wget https://labfile.oss-internal.aliyuncs.com/courses/2480/images.zip
有时候我们需要将尺寸过大的图片调整到一个相对合适的大小，反之较小尺寸的图片也需要扩增其尺寸。我们可以使用 cv2.resize 函数来实现尺寸调整。首先我们在 /home/project 目录下创建 args.py 文件。
import cv2
import argparse
ap = argparse.ArgumentParser()
ap.add_argument("--image", type = str, help = "image path")
args = ap.parse_args()
image = cv2.imread(args.image)
保存 args.py 脚本，然后打开 Code.ipynb，使用下面的命令读取 images 目录下的 cup.jpg 图片。
%run args.py --image images/cup.jpg
接下来将使用 cv2.resize 函数来对图片的尺寸进行缩放，该函数的第一个参数 image 是要被缩放的图片。第二个参数 (0, 0) 是一个元组，表示输出图片的尺寸，元组内的第一个元素表示图片的宽，第二个表示图片的高，后面会解释为什么这里将此参数设置为 (0, 0)。第三参数 fx = 0.5 表示沿图片的宽的缩放系数，第四参数 fy = 0.5 表示沿图片的高的缩放系数。第五个参数 interpolation = cv2.INTER_AREA) 是插值方法，表明图片是用哪种方法被缩放的，cv2.resize 默认的插值方法是 cv2.INTER_LINEAR，大家也可以尝试使用其他方法： cv2.INTER_NEAREST、cv2.INTER_CUBIC、cv2.INTER_LANCZ0S4。我们也可以尝试定义输出图片尺寸来对图片进行缩放。
resized = cv2.resize(image, (0, 0), fx=0.5, fy=0.5, interpolation = cv2.INTER_AREA)
cv2.imwrite("resized.jpg",resized)
我们分别使用 image.shape 和 resized.shape 方法来看一下缩放后的图片大小。可以看到图片的高和宽被缩小了 0.5 倍。
我们可以使用另一种方法对图片进行缩放，我们可以事先定义缩放后的图片的尺寸。首先我们先通过 shape 方法获取原始图片的高和宽。
height, width = image.shape[:2]
下面代码中用 w 表示输出图片的宽，并将其赋值为 200 个像素。为了让输出图片保持纵横比避免图片被过度拉伸我们要计算缩放比例：缩放比例 = 定义的宽度 / 原图的宽度， 即代码中的 200 / width。输出图片的高就等于原图的高乘以缩放比例，即代码中的 height * (200 / width)。这里要注意的是一定要用 int 函数把计算结果转换成整型，因为输出图片的尺寸要是整型。
w = 200
h = int(height * (200 / width))
h
可以在 IPython 中输入 h 查看高是多少，下图中 Out[9] 的输出是 133 表示缩放后图片的高为 133。
下面我们使用 cv2.resize 函数对图片进行缩放，这次我们的参数只有三个，第一个参数 image 是传入函数的原图片，第二参数 (w, h) 是输出图片的尺寸，第三个参数 interpolation = cv2.INTER_AREA 是插值方法。当然我们也可以先定义输出图片的高，根据输出图片的高计算缩放比例。最后我们使用 cv2.imwrite 保存图片。
resized = cv2.resize(image, (w, h), interpolation = cv2.INTER_AREA)
cv2.imwrite("resized.jpg",resized)
用 resized.shape 来看一下缩放后图片的尺寸。
现在我们来解决前面提到的为什么要将第二个参数，即输出尺寸设置为 (0, 0) 的问题，当将此参数设置为 (0, 0) 时，图片的输出尺寸由后面两个缩放系数 fx 和 fy 分别与函数的输入图片的宽和高相乘得出，当此参数不等于 (0, 0) 时，输出图片的尺寸等于我们自己设定的值。
最后我们来看一下图片缩放的效果，左上角是使用缩放系数缩放的 0.5 倍的图片。左下角是事先定义尺寸的宽为 200 高为 133 的图片。右边的大图是原始图片。
平移
图片的平移是让图片中所有的像素点沿着坐标轴移动相同的距离，视觉上看起来就是图片在进行上、下、左、右移动。在对图片进行平移前，我们在 args.py 文件第一行添加下面代码。
import numpy as np
导入 NumPy 模块，接下来的操作要用到该模块。保存修改后使用下面命令运行 args.py 脚本。
%run args.py --image images/cup.jpg
接下来我们使用 shape 方法获取图片的高和宽。
height, width = image.shape[:2]
对图片进行平移时，要先确定图片向哪个方向移动、移动多少。所以下面一行代码表示定义的图片平移规则。
M = np.float32([[1, 0, 100], [0, 1, 50]])
上面的代码表示用 np.float32 创建一个 2*3 矩阵 M，列表 [[1, 0, 100], [0, 1, 50]] 定义了图片会向哪个方向移动和移动多少。列表的第一个元素 [1, 0, 100] 中的 1, 0 表示图片将沿着水平方向移动，100 表示图片在水平方向将会向右移动 100 个像素。第二个元素 [0, 1, 50] 中的 0, 1 表示图片将会沿着垂直方向移动，50 表示图片在垂直方向上将会向下移动 50 个像素。
translation = cv2.warpAffine(image, M, (width, height))
cv2.imwrite("translation1.jpg", translation)
上面的代码表示使用 cv2.warpAffine 函数对图片进行平移，第一个参数 image 是要被平移的图片。第二个参数 M 是刚才创建的矩阵 M。第三个参数 (width, height) 是输出的图片尺寸，这里我们输出的尺寸和输入的原始图片尺寸一样，width 表示图片的宽，height 表示图片的高。最后我们保存图片。如下图中左图是原始图片，右图是平移后的结果。
同样的，通过下面的代码重新定义图片的平移规则。
M = np.float32([[1, 0, -150], [0, 1, -80]])
创建了一个 2*3 矩阵。这次让图片在水平方向上向左移动 150 个像素，在垂直方向上往上移动 80 个像素。
translation = cv2.warpAffine(image, M, (width, height))
cv2.imwrite("translation2.jpg", translation)
然后通过 cv2.warpAffine 函数让图片完成移动操作。使用 cv2.imwrite 函数保存图片后来看看操作结果，左图是输入的原始图片，右图是平移后结果。
旋转
图片的旋转是通过将图片的所有像素点按照相同的方向和角度，围绕一个定点旋转实现的。可以通过结合 cv2.getRotationMatrix2D 和 cv2.warpAffine 实现。要进行旋转操作首先需要构造一个旋转矩阵，使用 cv2.getRotationMatrix2D 来构造一个这样的矩阵。
M = cv2.getRotationMatrix2D((50, 50), 30, 1)
函数的第一个参数 (50, 50) 表示图片中的像素点将要围绕坐标为 (50, 50) 的点旋转。第二个参数 30 表示图片逆时针旋转 30 度。最后一个参数 1 表示图片的缩放系数，这里设置为 1 表示图片将保持原有尺寸
rotation = cv2.warpAffine(image, M, (width, height))
cv2.imwrite("rotation1.jpg", rotation)
上面代码表示使用 cv2.warpAffine 对图片进行旋转，第一个参数 image 是要被旋转的图片，第二个参数 M 是创建的旋转矩阵，第三个参数 (width, height) 表示输出的图片尺寸。最后保存图片。
如下图所示，左图是输入的原始图片，右图是旋转结果。
下面代码表示创建一个新的旋转矩阵，这次将让图片中的像素点围绕坐标为 (50, 50) 的点顺时针旋转 60 度，且将图片缩放 0.5 倍。
M = cv2.getRotationMatrix2D((50, 50), -60, 0.5)
使用 cv2.warpAffine 函数对图片进行旋转，然后保存图片。
rotation = cv2.warpAffine(image, M, (width, height))
cv2.imwrite("rotation2.jpg", rotation)
执行结果如下图，下图左图是输入的原始图片，右图是旋转结果。
翻转
图片的翻转是指让图片沿着水平方向或垂直方向进行翻转，可以使用 cv2.flip 函数实现。
从上面的代码看，图片的翻转代码很简单。函数的第一个参数 image 是要被翻转的图片。第二个参数 1 表示图片沿着水平方向翻转。下图是翻转结果，左图是输入的原始图片，右图是沿着水平方向翻转的结果。
让图片沿其他方向翻转，更改函数第二参数为 0 表示图片沿垂直方向翻转，然后保存图片。
turn = cv2.flip(image, 1)
cv2.imwrite("turn1.jpg", turn)
让图片沿其他方向翻转，更改函数第二参数为 0 表示图片沿垂直方向翻转，然后保存图片。
turn = cv2.flip(image, 0)
cv2.imwrite("turn2.jpg", turn)
再次修改函数的第二个参数为 -1 表示这次让图片沿水平和垂直两个方向翻转，然后保存图片。
turn = cv2.flip(image, -1)
cv2.imwrite("turn3.jpg", turn)
图像运算
介绍一些图像的算术运算和按位运算，同时还将介绍关于图像的掩膜，最后将了解一些关于颜色空间的知识。
知识点
- 图像的算术运算
- 图像的按位运算
- 掩膜
- 颜色空间
运算和颜色空间简介
图像的算术运算和按位运算在图像处理中有很多应用，例如图像的算术运算在图像增强中普遍应用，其可对图片进行增加亮度、减少亮度、增强对比度等操作以满足特定的图像处理需求，还可以通过将两幅图片进行算术运算以达到图像融合的效果。图像的按位运算在图像分割、目标检测和识别、模式识别中得到广泛的应用，例如通过按位运算操作，可以提取图片中真正感兴趣的区域而忽略其他区域，在图像分割中可以用按位运算将前景物体从图片中分割开来。下图是图像运算的一个例子。
颜色空间是对色彩的说明，RGB 颜色空间是在处理图像时常常遇到的，但是除了 RGB 颜色空间人们还创建了其他很多的颜色空间，每种颜色空间都有各自的优缺点，有时候我们需要将图片从一种颜色空间转换到另一种颜色空间进行处理
算术运算
图像的算术运算比较简单，使用 cv2.add 、cv2.subtract、cv2.multiply、cv2.divide 即可实现加、减、乘、除运算。
我们用下面命令下载需要用到的图片，然后使用 unzip images.zip 解压压缩包。
wget https://labfile.oss-internal.aliyuncs.com/courses/2480/images.zip
创建并编辑 args.py 文件。首先导入要使用到的模块，本节实验我们会用到 cv2、argparse、numpy 模块。
import cv2
import argparse
import numpy as np
然后创建一个 argparse.ArgumentParser 对象用于添加命令行参数。
ap = argparse.ArgumentParser()
使用 add_argument 添加命令行参数，这里和之前学习的有点不同，这个函数多了一个 action = "append" 参数，这个参数将允许多次使用 --image 命令读取多张图片。 然后 parse_args 将命令解析并存储到列表中。
ap.add_argument("--image", action = "append", type = str, help = "image2 path")
args = ap.parse_args()
可以使用从命令行获取到的图片路径读取图片了。首先用 if 语句判断是否获取到图片，如果获取到了图片路径，则 args.image 为真并执行后面的代码。然后再次用 if 语句判断是否获取到了多张图片路径，本次实验将用到两张图片，所以这里会获得 image[0] 和 image[1] 两张图片。如果只获取一张图片路径，则将只读取 args.image[0] 这一张图片。
if args.image:
if len(args.image) > 1:
image1 = cv2.imread(args.image[0])
image2 = cv2.imread(args.image[1])
else:
image = cv2.imread(args.image[0])
保存脚本后打开 Code.ipynb，运行下面的命令以读取图片。将会读取下载的其中两张图片，分别是 images/cup.jpg 和 images/pug.jpg。
%run args.py --image images/cup.jpg --image images/pug.jpg
对单张图片的所有像素进行运算需要创建一个和图片尺寸、通道数一样的矩阵，然后再用这个矩阵同图片进行算术运算。首先通过 image1.shape 我们获取图片矩阵的维数。
M = image1.shape
np.ones 创建一个所有元素都是 1 的矩阵 x。
x = np.ones(M, dtype = "uint8")
这个函数的第一个参数 M 是获取到的图片的维度，将告诉函数创建一个通道数、宽、高都和原图片一样的矩阵，第二个参数 dtype = "uint8" 表示每个元素数据类型都是 8 位无符号整型（因为像素值的范围是 0 到 255，而 uint8 的范围也是 0 到 255）。
将矩阵 x 乘以一个整数 150 使得矩阵中的每个元素都是 150。
x = x * 150
使用 cv2.add 函数将图片和矩阵进行相加，也就是对图片中的每个像素值进行相加运算。该函数的第一个参数 image1 是的原始图片，第二个参数 x 是创建的矩阵。这里要确保图片的尺寸和通道数与创建矩阵的维数是一样的，否则在执行脚本时会报错。最后保存运算后的图片。
sums = cv2.add(image1, x)
cv2.imwrite("sums.jpg", sums)
下图左边是原始图片，右边是图片中每个像素都相加 150 的结果，因为像素值变得更大，数值接近 255 所以图片看起来更亮。
图片的减法和图片的加法类似，通过 cv2.subtract 实现图片的减法，函数的两个参数 image1 和 x 分别是原始图片和创建的矩阵。
sub = cv2.subtract(image1, x)
cv2.imwrite("sub.jpg", sub)
下图左边是原始图片，右边是图片中每个像素值都减 150 的结果，因为像素值变得更小，数值接近 0，所以图片看起来很暗。
通过 cv2.multiply 对图片进行相乘操作，函数的两个参数 image1 和 x 分别是原始图片和创建的矩阵。
mul = cv2.multiply(image1, x)
cv2.imwrite("mul.jpg", mul)
下图左边是原始图片，右边是图片中每个像素值都乘 150 的结果，可以看到相乘的结果是一张白色的图片，因为每个像素值相乘后都变为 255。
最后下面是使用 cv2.divide 函数进行相除运算，函数的两个参数 image1 和 x 分别是原始图片和创建的矩阵。
div = cv2.divide(image1, x)
cv2.imwrite("div.jpg", div)
下图左边是原始图片，右边是图片中每个像素值都除以 150 的结果。因为每个像素值都与 150 相除所以像素值都变得很小、接近 0，所以整张图片几乎是黑色看不到任何内容
可以- 看一下像素值的变化。
- image1[100, 200] 表示原始图片中第 100 行、第 200 列的像素值为 [180, 185, 176]
- sums[100, 200] 表示加法运算后的值为 [255, 255, 255]。
- sub[100, 200] 表示减法运算后的值为 [30, 35, 26]。
- mul[100, 200] 表示乘法运算后的像素值为 [255, 255, 255]。
- div[100, 200] 表示除法运算后的像素值。
以上运算后的结果与单纯的十进制算术运算结果不同。这是因为用 8 位无符号整数表示 0 到 255，OpenCV 的算术运算函数是饱和运算，当运算结果大于 255 时函数输出 255，当运算结果小于 0 时函数输出 0。这里需要同 NumPy 的算术运算区分开，NumPy 的运算是取模运算，即当运算结果大于 255 时则最后得到的是运算结果对 256 取模。
下面来对比下 OpenCV 和 NumPy 算术运算的区别。 首先我们使用 np.uint8 构建两个 8 位无符号整数的 NumPy 数组：x 是 150， y 是 160。
x, y = np.uint8([150]), np.uint8([160])
首先用 OpenCV 做加、减运算，用 cv2.add 计算 x 加 y 的结果为 255，用 cv2.subtract 计算相减的结果为 0。因为 OpenCV 是进行饱和运算的， 所以当运算结果大于 255 时函数输出为 255，运算值小于 0 时函数输出为 0。
再使用 NumPy 进行加、减运算，计算 x + y 的结果为 54，计算相减的结果为 246。因为在 NumPy 中对大于 255 的值进行取模运算，所以这里用 x + y 的值 310对 256 进行取模得到 54，同样的 x - y 的值 -10 对 256 进行取模得到 246。
对两张照片进行算术运算的操作和上面基本一样，只需为运算函数提供两张尺寸和通道数相同的图片即可。下面一行代码使用前面学习过的 cv2.resize 函数将第二张图片的宽和高调整到和第一张图片相同的大小。
image2 = cv2.resize(image2, (image1.shape[1], image1.shape[0]), interpolation=cv2.INTER_CUBIC)
使用 cv2.add 函数对两张图片进行加运算，第一个参数 image1 和第二个参数 image2 分别是读取的图片。
sums = cv2.add(image1, image2)
cv2.imwrite("sums.jpg", sums)
下图是执行加运算的结果。左边和中间的图片是要进行加运算的两张图片，右边的图片是进行加运算的结果。
同样的，使用 cv2.subtract 对两张图片进行减运算。
sub = cv2.subtract(image1, image2)
cv2.imwrite("sub.jpg", sub)
下图中最右边的图片是两张图片执行减运算的结果。
使用 cv2.multiply 对两张图片进行乘运算。
mul = cv2.multiply(image1, image2)
cv2.imwrite("mul.jpg", mul)
下图中最右边的图片是两张图片执行乘运算的结果。因为乘法运算时很多像素值大于 255 所以很多像素值被函数设置为 255。
使用 cv2.divide 对两张图片进行除法运算。
div = cv2.divide(image1, image2)
cv2.imwrite("div.jpg", div)
下图中最右边的图片是两张图片执行乘运算的结果。因为两张图片相除使像素值变得接近 0 所以整张图片趋近于黑色。
按位运算
OpenCV 的位运算是对像素值的二进制位进行的运算，有 4 种按位运算： and、or、xor、not。and 运算是当两个像素值都大于 0 时为真，or 运算是当两个像素值有一个大于 0 时为真，xor 运算是当两个像素值有一个大于 0 但不同时都大于 0 则为真。not 则是一个取反的运算。
首先我们在 IPython 中运行下面命令读取两张图片。
%run args.py --image images/cup.jpg --image images/rectangle.jpg
看下按位运算作用于像素值的例子，在 Ipython 中创建两个 NumPy 数组 a 和 b 表示两个像素值。
a = np.array([20, 40, 167], dtype=np.uint8)
b = np.array([80, 48, 240], dtype=np.uint8)
使用 cv2.bitwise_and 函数对两个像素值进行 and 运算。函数的第一个参数是创建的数组 a，第二个参数是创建的数组 b。
cv2.bitwise_and(a, b)
OpenCV 的位运算是对像素值的二进制位进行的运算，a 中的 20 的二进制是 00010100，b 中的 80 的二进制是 01010000，对两个数进行 and 计算得到 00010000 其对应十进制就是 16。同理 a 中的 40 和 b 中的 48 的 and 运算结果是 32， a 中的167 和 b 中的 240 的 and 运算结果是 160。使用 cv2.bitwise_or 函数对两个像素值进行 or 运算，函数的两个参数分别是 a 和 b。
cv2.bitwise_or(a, b)
从结果中可以看到，a 中的 167 的二进制是 10100111，b 中的 240 的二进制是 11110000，对两个数进行 xor 运算得到 01010111 其对应十进制就是 87。剩下的两个值同理可得。
使用 cv2.bitwise_not 对数组 a 进行取反运算。
cv2.bitwise_not(a)
从结果中可以看到，a 中的 20 的二进制是 00010100，则执行 not 运算后的二进制值是 11101011 也就是十进制的 235。剩下的两个值同理可得。
了解两个像素值的运算后再来看看图片的按位运算。两张图片的按位运算就是将两张尺寸通道数相同的图片中的每个像素值分别进行 and、or、xor、not 运算。首先通过 cv2.resize 函数将两张图片调整到相同大小。
image2 = cv2.resize(image2, (image1.shape[1], image1.shape[0]), interpolation=cv2.INTER_CUBIC)
使用 cv2.bitwise_and 对两张图片进行 and 运算，函数的第一个参数 image1 是我们读取的 images/cup.jpg 图片，第二个参数 image2 是我们读取的 images/rectangle.jpg 图片。
i_and = cv2.bitwise_and(image1, image2)
cv2.imwrite("i_and.jpg", i_and)
看看两张图片 and 操作的结果。下图左图是 image1/cup.jpg， 中间的图片是 image1/rectangle.jpg ，右边的图片是两张图片 and 运算后的结果。可以看到中间图片的黑色的区域起到了遮挡的作用。
使用 cv2.bitwise_or 对两张图片进行 or 运算。
i_or = cv2.bitwise_or(image1, image2)
cv2.imwrite("i_or.jpg", i_or)
下面是进行 or 操作的结果。可以看到在 or 运算中白色区域充当了遮挡作用。
使用 cv2.bitwise_xor 对两张图片进行 xor 运算。
i_xor = cv2.bitwise_xor(image1, image2)
cv2.imwrite("i_xor.jpg", i_xor)
下图是执行 xor 的运算结果，因为 xor 运算是当两个像素值有一个大于 0 但不同时都大于 0 则为真，导致右边图片中对应中间图片的白色区域产生变化
使用 cv2.bitwise_not 对两张图片进行 not 运算。该函数的参数只有一个，这里我们使用 image1 作为参数。
i_not = cv2.bitwise_not(image1)
cv2.imwrite("i_not.jpg", i_not)
下图是执行 not 的运算结果。 not 函数是一个取反的运算，如下图所示，最右边的图片的像素值的二进制形式都被取反了。
掩膜
掩膜（mask）是图像按位计算的一种应用，其目的是只显示出图片中感兴趣的区域并遮盖其他部分。现在来看一下掩膜的具体操作。掩膜的应用比较简单，下面代码中用 np.zeros 创建一张黑色图片，因为这张图片的尺寸要和进行掩膜操作的原图片的尺寸一样，所以使用 shape 方法获取 image1 的宽和高，然后将这两个值作为参数传递给函数。然后将感兴趣的区域的像素值赋值为 255，这里选取的区域 mask[100:300, 200:300] 也就是感兴趣区域为白色。
mask = np.zeros(image1.shape[:2], np.uint8)
mask[100:300, 200:300] = 255
mask 图片。
使用 cv2.bitwise_and 函数进行掩膜操作，函数第一个和第二个参数相同，都是原始图片 image1 ，第三个参数 mask 就是刚才创建的掩膜图片。该函数会把原图片中对应于掩膜图片的白色区域显示出来，其他区域会被黑色遮盖。下图左边是原图片，右边是提取出感兴趣的区域。
imagemask = cv2.bitwise_and(image1, image1, mask = mask)
cv2.imwrite("imagemask.jpg", imagemask)
下图是进行掩膜操作的结果
颜色空间
除了RGB 颜色空间，还有很多其他的颜色空间，例如 HSV，LAB 等，颜色空间是一种描述色彩的模型，其作用是在不同的标准下对不同颜色的说明。OpenCV 中有上百种颜色空间转换方法，用 cv2.cvtColor 方法将图片转换为灰度图。函数的第一个参数 image1 是要被转换为灰度图的图片。第二个参数 cv2.COLOR_BGR2GRAY 表示颜色空间转换类型，这里表示将图片从 RGB 彩色图片转换为灰度图
grayimage = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
cv2.imwrite("grayimage.jpg", grayimage)
转换的结果。
用 cv2.cvtColor 方法将图片转换为 HSV 图片。函数的第一个参数 image1 是要被转换为 HSV 图的图片。第二个参数 cv2.COLOR_BGR2HSV 表示颜色空间转换类型。这里表示将图片从 RGB 彩色图片转换为 HSV 图片。
hsvimage = cv2.cvtColor(image1, cv2.COLOR_BGR2HSV)
cv2.imwrite("HSVimage.jpg", hsvimage)
下图是转换结果。
