缩放与裁剪

裁剪

图像的裁剪，是指将图像的某个区域切割出来。

一些常见的应用场景包括：

* 感兴趣区域提取

* 去除无用信息

* 图像增强

* 纠偏：去除不规则部分，将图像变得更加整齐

事实上，图像裁剪的裁剪通常就是一个numpy矩阵切片的过程。

其中的关键内容在于，获取目标区域的坐标。

给定一个512*512的lena图像，想要裁剪出以原图中心点为中心的，320*320的图像，代码如下所示：

import cv2
import matplotlib.pyplot as pltimg = cv2.imread('./dataset/lena.png')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(img)
plt.axis('off')
plt.show()
# numpy切片
h, w = img.shape[:2]
cropped_img = img[h // 2 - 160: h // 2 + 160, w // 2 - 160: w // 2 + 160, :]
plt.imshow(cropped_img)
plt.show()#PIL库
from PIL import Image
cropped_img = img.crop((512 // 2 - 320 // 2, 512 // 2 - 320 // 2,  # 左上角坐标512 // 2 + 320 // 2, 512 // 2 + 320 // 2)) # 右下角坐标
plt.imshow(cropped_img)
plt.show()

缩放

cv2.resize(img, dsize=(, ), interpolation=cv2.INTER_AREA)

在resize函数的参数中，第一个参数为待缩放图片，第二个参数为缩放后的尺寸。

第三个参数为插值方法，共包括：

* cv2.INTER_NEAREST：最近邻插值。

* cv2.INTER_LINEAR：双线性插值。

* cv2.INTER_CUBIC：双立方插值。

* cv2.INTER_AREA：区域插值。

* cv2.INTER_LANCZOS4：Lanczos插值

以上插值方法特点不同，下面展示其中区别

img = cv2.imread('./dataset/lena.png')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
resized_img_1 = cv2.resize(img, dsize=(256, 384), interpolation=cv2.INTER_AREA)
plt.imshow(resized_img_1)
plt.show()

插值

* 最近邻插值： 源图像中距离新像素位置最近的像素赋值给新像素。

* 例如，图像缩放了fx和fy倍，那么新图像中的像素坐标$x', y'$对应原图坐标为$f_xx, f_yy$

* 优点：速度快

* 缺点：未考虑周围像素，锯齿严重

* 双线性插值：从周围四个像素共同加权计算像素值，距离越近权重越大，距离越远权重越小

* 优点：平滑

* 速度慢

大部分使用

* 双立方插值：新图像的每个点，都参考了周围16个点的信息

* 两个基本步骤：

- 计算周围16个点的像素值

- 拟合函数计算最终像素值

* 优点：保留图像细节信息

* 缺点：计算量大，耗时长

* 区域重采样：按区域计算新像素

* 每个像素都选取一个固定大小的区域

* 每个区域通过一定算法计算一个新的像素值

* 优点：保真，不易出现伪影

* lanczos：造了一个核函数，计算新像素

* 优点：更加平滑的采样结果

* 缺点：计算成本高

其中，a为核半径，在目标像素的a范围内，通过公式计算新的像素值。

target_img = img[240: 272, 240: 272, :]
# plt.imshow(target_img)
# plt.show()nearest = cv2.resize(target_img, (768, 768), interpolation=cv2.INTER_NEAREST)
linear = cv2.resize(target_img, (768, 768), interpolation=cv2.INTER_LINEAR)
cubic = cv2.resize(target_img, (768, 768), interpolation=cv2.INTER_CUBIC)
area = cv2.resize(target_img, (768, 768), interpolation=cv2.INTER_AREA)
lanczos = cv2.resize(target_img, (768, 768), interpolation=cv2.INTER_LANCZOS4)
fig, ax = plt.subplots(nrows=1, ncols=5, figsize=(12,12))
print(ax)
ax[0].imshow(nearest)
ax[1].imshow(linear)
ax[2].imshow(cubic)
ax[3].imshow(area)
ax[4].imshow(lanczos)ax[0].axis('off')
ax[1].axis('off')
ax[2].axis('off')
ax[3].axis('off')
ax[4].axis('off')plt.show()

仿射变换和透视变换

1. 仿射变换

https://blog.csdn.net/weixin_51571728/article/details/124434728

对于二维平面来说，仿射变换就是将一个点，通过**线性变换**映射到另一个二维平面中的点。

平行原则：原来是平行线，仿射后也是平行线

直线原则：原来是直线，仿射以后也是直线

与之相对的，**非线形变换**不是仿射变换，因为其不满足仿射变换的线性性质。

一个典型的非仿射变换为透视变换。

对于矩阵来说，仿射变换的结果，可以表示为矩阵的乘积。

仿射变换通常包含以下几种操作

* 平移：沿着x，y方向移动图像

* 旋转：围绕中心点旋转图像

* 缩放：缩放到指定大小

* 错切：在平面上将图像斜切一定角度

仿射变换可用于图像对齐、图像矫正、图像增强等。

图像旋转

图像旋转是一种特殊的仿射变换

在PIL中，图像旋转有专用的函数接口img.rotate(角度，center=[ , ])，示例如下：

import PIL.Image as Image
import matplotlib.pyplot as pltimg = Image.open('E:/notebook/3c.png')
# 绕中心点逆时针转45度
rotated_img = img.rotate(45, center=[img.width // 2, img.height // 2])
fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)
ax1.imshow(img)
ax2.imshow(rotated_img)
ax1.axis('off')
ax2.axis('off')
plt.show()

OpenCV提供了更加便捷灵活的函数方法:

首先，通过指定的中心和旋转角度，定义旋转矩阵:cv2.getRotationMatrix2D((旋转中心), 角度, 缩放比例)；

其次，根据旋转矩阵，进行仿射变换，实现旋转：cv2.warpAffine(img, 旋转矩阵, (运算后矩阵的大小也就是输出图片的尺寸) )https://blog.csdn.net/m0_51545690/article/details/123959995

import cv2
img = cv2.imread('E:/notebook/3c.png')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
M = cv2.getRotationMatrix2D((img.shape[0] // 2, img.shape[1] // 2), 45, 1)
# print(M) # 旋转矩阵
#[[   0.70710678    0.70710678 -102.64170235]
# [  -0.70710678    0.70710678  208.20101013]]
# # 得到矩阵后得用到图像的仿射变换函数才可以进行最终图像的变化
rotate_img = cv2.warpAffine(img, M, (512,512))
fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)
ax1.imshow(img)
ax2.imshow(rotate_img)
ax1.axis('off')
ax2.axis('off')
plt.show()

不依赖第三方库，将一个图像按照中心点，缩小为原面积的四分之一。

import cv2
img = cv2.imread('E:/notebook/lena.png')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
def resize(image):# image是读取用opencv读取完毕的numpy矩阵# 输出为仿射变换后的矩阵，注意要将其转化为适合图像的数据类型# 此处撰写代码M = np.array([[.5, 0, 0],[0, .5, 0]])# 首先，将图像的平面坐标扩展出一个1，可直接相乘img_matrix = np.array([[i, j, 1] for j in range(512) for i in range(512)])img_matrix = img_matrix.T# 其次，乘以矩阵得到新的坐标rotated_img_matrix = np.dot(M, img_matrix)rotated_img_matrix = np.rint(rotated_img_matrix).astype(int)# 最后，按照新坐标填补像素resized_image = np.zeros_like(img)for i in range(512):for j in range(512):num = i * 512 + jx = rotated_img_matrix[1, num]y = rotated_img_matrix[0, num]if 0 < x < 512 and 0 < y < 512:resized_image[x, y] = img[i, j]return resized_image
final_img = resize(img)
plt.imshow(final_img)
plt.show()

2. 透视变换

原理：https://blog.csdn.net/m0_43609475/article/details/112847314

区别于仿射变换，透视变换是通过变换矩阵对图像进行变形，来实现视角的转换。

在透视变换中，不仅会发生平移或者旋转，也会发生图像形变。

仿射变换需要三点求解仿射矩阵，而透视变换则需要四点标定，来获得变换矩阵

常见应用：鱼眼畸变校正、鸟瞰视角变换

opencv函数：

getPerspectiveTransform([左上]，[左下]，[右上]，[右下]四个坐标)

warpPerspective(img, 旋转矩阵， 输出图片大小)

例：将图像变为正对镜头的视角

import cv2img = cv2.imread('E:/notebook/grid.png')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
print(img.shape)
M = cv2.getPerspectiveTransform(np.float32([[410, 392], [506, 677], [828, 283], [897, 635]]), np.float32([[0, 0], [0, 980], [1272, 0], [1272, 980]]))
print(M)
plt.imshow(img)
plt.show()
project_img = cv2.warpPerspective(img, M, (1272, 980))
plt.imshow(project_img)
plt.show()

https://blog.csdn.net/m0_51653200/article/details/127361624