opencv之几何变换

文章目录

[1 前言](#1 前言)
[2 线性几何变换的主要类型](#2 线性几何变换的主要类型)
- [2.1 平移 (Translation)：](#2.1 平移 (Translation)：)
- - [2.1.1 定义](#2.1.1 定义)
  - 2.1.2代码
- [2.2 缩放 (Scaling)：](#2.2 缩放 (Scaling)：)
- - [2.2.1 定义](#2.2.1 定义)
  - [2.2.2 代码](#2.2.2 代码)
- [2.3 旋转 (Rotation)：](#2.3 旋转 (Rotation)：)
- - [2.3.1 定义](#2.3.1 定义)
  - [2.3.2 代码](#2.3.2 代码)
- [2.4 仿射变换 (Affine Transformation)：](#2.4 仿射变换 (Affine Transformation)：)
- - [2.4.1 定义](#2.4.1 定义)
  - [2.4.2 代码](#2.4.2 代码)
- [2.5 透视变换 (Perspective Transformation)：](#2.5 透视变换 (Perspective Transformation)：)
- - 2.5.1定义
  - [2.5.2 代码](#2.5.2 代码)
- 2.6线性几何变换的应用
3.重映射
彩蛋

1 前言

几何变换是计算机图像处理中的一种操作，用于对图像的几何结构进行修改。通过几何变换，可以实现图像的旋转、缩放、平移、扭曲等效果，从而改变图像的形状、位置和方向。这些变换可以是线性的或非线性的，通常使用数学矩阵来表示和计算。

一般公式

d s t ( x , y ) = s r c ( M 11 ⋅ x + M 12 ⋅ y + M 13 , M 21 ⋅ x + M 22 ⋅ y + M 23 ) dst(x, y)=src(M_{11}⋅x+M_{12}⋅y+M_{13}, M_{21}⋅x+M_{22}⋅y+M_{23}) dst(x,y)=src(M11⋅x+M12⋅y+M13,M21⋅x+M22⋅y+M23)

x , y x,y x,y表示原图像素的位置坐标， M M M表示进行变换操作的矩阵。

几何变换的实现步骤

定义变换矩阵：根据所需的几何变换类型（如平移、旋转、缩放等），创建对应的变换矩阵。
应用变换矩阵：使用变换矩阵将输入图像的每个像素位置重新计算，以生成输出图像。
插值计算：由于变换后像素的新位置可能是非整数坐标，需使用插值方法（如最近邻、双线性插值等）计算新像素位置的像素值。
生成输出图像：根据重新计算后的像素位置和插值结果，生成经过几何变换的输出图像。

2 线性几何变换的主要类型

2.1 平移 (Translation)：

2.1.1 定义

将图像中的所有像素点按固定距离移动。
数学表达式： T ( x , y ) = ( x + t x , y + t y ) T(x,y)=(x+tx,y+ty) T(x,y)=(x+tx,y+ty)
其中 t x tx tx 和 t y ty ty 是在 x 轴和 y 轴上的平移量。

平移操作将图像的每个像素点按指定的距离移动。在 OpenCV 中，可以使用 cv2.warpAffine() 来实现平移。

2.1.2代码

python 复制代码

import cv2
import numpy as np

# 读取图像
image = cv2.imread('image.jpg')

# 创建平移矩阵
tx, ty = 100, 50  # x轴和y轴的平移量
translation_matrix = np.float32([[1, 0, tx], [0, 1, ty]])

# 应用平移变换
translated_image = cv2.warpAffine(image, translation_matrix, (image.shape[1], image.shape[0]))

# 显示结果
cv2.imshow('Translated Image', translated_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

2.2 缩放 (Scaling)：

2.2.1 定义

改变图像的尺寸（放大或缩小）。
数学表达式： S ( x , y ) = ( α ⋅ x , β ⋅ y ) S(x,y)=(\alpha⋅x,\beta⋅y) S(x,y)=(α⋅x,β⋅y)
其中 α \alpha α和 β \beta β是在 x x x 轴和$ y$ 轴上的缩放因子。

缩放操作改变图像的尺寸。缩放因子决定了图像的放大或缩小程度。

2.2.2 代码

python 复制代码

import cv2

# 读取图像
image = cv2.imread('image.jpg')

# 缩放因子
scale_x, scale_y = 1.5, 1.5  # x轴和y轴的缩放因子
scaled_image = cv2.resize(image, None, fx=scale_x, fy=scale_y, interpolation=cv2.INTER_LINEAR)

# 显示结果
cv2.imshow('Scaled Image', scaled_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

2.3 旋转 (Rotation)：

2.3.1 定义

将图像绕其中心点旋转指定的角度。
数学表达式： R ( x , y ) = ( x ⋅ c o s ⁡ ( θ ) − y ⋅ s i n ⁡ ( θ ) , x ⋅ s i n ⁡ ( θ ) + y ⋅ c o s ⁡ ( θ ) ) R(x,y)=(x⋅cos⁡(θ)−y⋅sin⁡(θ),x⋅sin⁡(θ)+y⋅cos⁡(θ)) R(x,y)=(x⋅cos⁡(θ)−y⋅sin⁡(θ),x⋅sin⁡(θ)+y⋅cos⁡(θ))
其中 θ \theta θ 是旋转角度。

旋转操作将图像绕其中心旋转一定的角度。需要定义旋转矩阵并使用 cv2.warpAffine() 来应用旋转。

2.3.2 代码

python 复制代码

import cv2
import numpy as np

# 读取图像
image = cv2.imread('image.jpg')

# 获取图像的中心
center = (image.shape[1] // 2, image.shape[0] // 2)

# 创建旋转矩阵
angle = 45  # 旋转角度
scale = 1.0  # 缩放因子
rotation_matrix = cv2.getRotationMatrix2D(center, angle, scale)

# 应用旋转变换
rotated_image = cv2.warpAffine(image, rotation_matrix, (image.shape[1], image.shape[0]))

# 显示结果
cv2.imshow('Rotated Image', rotated_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

2.4 仿射变换 (Affine Transformation)：

仿射变换是一种更复杂的变换，可以同时包括平移、缩放和旋转。仿射变换的矩阵是一个2x3的矩阵。

2.4.1 定义

一种保平行的变换，允许进行平移、旋转、缩放和剪切。
数学表达式： A ( x , y ) = ( a ⋅ x + b ⋅ y + t x , c ⋅ x + d ⋅ y + t y ) A(x,y)=(a⋅x+b⋅y+tx,c⋅x+d⋅y+ty) A(x,y)=(a⋅x+b⋅y+tx,c⋅x+d⋅y+ty)
其中 a a a, b b b, c c c, d d d , t x tx tx和 t y ty ty 是变换矩阵的参数。

2.4.2 代码

python 复制代码

import cv2
import numpy as np

# 读取图像
image = cv2.imread('image.jpg')

# 定义原始图像中的三点和目标图像中的三点
pts1 = np.float32([[50, 50], [200, 50], [50, 200]])
pts2 = np.float32([[10, 100], [200, 50], [100, 250]])

# 计算仿射矩阵
affine_matrix = cv2.getAffineTransform(pts1, pts2)

# 应用仿射变换
affine_transformed_image = cv2.warpAffine(image, affine_matrix, (image.shape[1], image.shape[0]))

# 显示结果
cv2.imshow('Affine Transformed Image', affine_transformed_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

2.5 透视变换 (Perspective Transformation)：

2.5.1定义

处理图像的透视效果，通常用于校正图像中的透视扭曲。
数学表达式： P ( x , y ) = ( a ⋅ x + b ⋅ y + c d ⋅ x + e ⋅ y + f , g ⋅ x + h ⋅ y + i d ⋅ x + e ⋅ y + f ) P(x,y)=(\frac{a⋅x+b⋅y+c}{d⋅x+e⋅y+f},\frac{g⋅x+h⋅y+i}{d⋅x+e⋅y+f}) P(x,y)=(d⋅x+e⋅y+fa⋅x+b⋅y+c,d⋅x+e⋅y+fg⋅x+h⋅y+i)
其中 a , b , c , d , e , f , g , h , 和 i a, b, c, d, e, f, g, h, 和 i a,b,c,d,e,f,g,h,和i 是透视矩阵的参数。

透视变换允许你将图像从一个视角转换到另一个视角。需要定义四个点来创建透视矩阵。

2.5.2 代码

py 复制代码

import cv2
import numpy as np

# 读取图像
image = cv2.imread('image.jpg')

# 定义原始图像中的四点和目标图像中的四点
pts1 = np.float32([[50, 50], [200, 50], [50, 200], [200, 200]])
pts2 = np.float32([[10, 100], [220, 30], [30, 220], [210, 210]])

# 计算透视矩阵
perspective_matrix = cv2.getPerspectiveTransform(pts1, pts2)

# 应用透视变换
perspective_transformed_image = cv2.warpPerspective(image, perspective_matrix, (image.shape[1], image.shape[0]))

# 显示结果
cv2.imshow('Perspective Transformed Image', perspective_transformed_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

2.6线性几何变换的应用

图像校正：修正图像中的畸变和透视问题。
图像增强：通过缩放、旋转等方法提高图像的可视效果。
特效生成：创建视觉效果，如模拟相机拍摄角度等。
目标检测与识别：对图像中的目标进行标准化处理，提高算法的准确性。

线性几何变换在计算机视觉和图像处理领域中扮演了重要角色，帮助实现各种图像操作和分析。

3.重映射

3.1定义

重映射是指根据特定的映射函数，将输入图像的像素位置重新映射到输出图像的新位置。这种映射可以是线性的或非线性的，具体取决于所需的变换效果。
数学表达式： g ( x , y ) = f ( h ( x , y ) ) g(x,y)=f(h(x,y)) g(x,y)=f(h(x,y)),假设 h ( x , y ) = x 2 + y h(x,y)=x^{2}+y h(x,y)=x2+y, 则有 g ( x , y ) = f ( x 2 , y ) g(x,y)=f(x^{2},y) g(x,y)=f(x2,y)
其中 f ( x , y ) f(x,y) f(x,y)是原图像函数， g ( x , y ) g(x,y) g(x,y)是目标图像函数， h ( x , y ) h(x,y) h(x,y)是映射函数

重映射的过程

映射函数的定义：通过函数或映射矩阵定义图像中每个像素的位置变化。映射函数通常根据图像处理需求确定，例如几何变换、去畸变等。
重新计算像素位置 ：对于每个像素 (x, y)，使用映射函数计算其在输出图像中的新位置 (x', y')。
像素值的插值 ：由于新位置 (x', y') 可能不是整数，因此需要通过插值方法（如最近邻、双线性插值等）计算出该位置的像素值。
生成输出图像：将所有像素的新位置和对应的像素值合成，生成变换后的输出图像。

代码

重映射（Remapping）是通过函数 cv2.remap() 来实现的。这个函数可以将图像的每个像素点根据提供的映射规则重新定位。重映射在图像校正、图像扭曲、去畸变等操作中非常有用。

cv2.remap()函数

cv2.remap() 的基本语法如下：

python 复制代码

dst = cv2.remap(src, map_x, map_y, interpolation)

src：输入图像。

map_x 和 map_y：指定图像中每个像素在输出图像中的新位置。map_x 和 map_y 是浮点数矩阵，大小与输入图像相同。map_x 存储每个像素新的 x 坐标，map_y 存储新的 y 坐标。

interpolation：插值方法，用于插值像素值。常见的方法有：

cv2.INTER_NEAREST：最近邻插值。
cv2.INTER_LINEAR：双线性插值（默认）。
cv2.INTER_CUBIC：双三次插值。
cv2.INTER_LANCZOS4：Lanczos 插值。

以下是一个使用 cv2.remap() 实现图像水平翻转的例子：

python 复制代码

import cv2
import numpy as np

# 读取图像
src = cv2.imread('input_image.jpg')

# 获取图像尺寸
height, width = src.shape[:2]

# 创建映射矩阵
map_x = np.zeros((height, width), dtype=np.float32)
map_y = np.zeros((height, width), dtype=np.float32)

# 填充映射矩阵，使图像水平翻转
for i in range(height):
    for j in range(width):
        map_x[i, j] = width - 1 - j
        map_y[i, j] = i

# 应用重映射
dst = cv2.remap(src, map_x, map_y, cv2.INTER_LINEAR)

# 显示结果
cv2.imshow('Original Image', src)
cv2.imshow('Remapped Image', dst)
cv2.waitKey(0)
cv2.destroyAllWindows()

应用场景

去畸变：通过校正镜头的畸变，得到更加真实的图像。
图像校正：将图像从一种投影坐标系变换到另一种坐标系，例如鱼眼图像的校正。
图像扭曲：根据需求对图像进行各种扭曲和变形处理。

注意事项

map_x 和 map_y 通常是通过某种函数生成的，基于目标效果。
如果需要实现一些常见的几何变换（如平移、旋转、缩放），通常仿射变换或透视变换更为高效和方便。

cv2.remap() 是一个非常强大的函数，可以实现许多复杂的图像处理任务。

彩蛋

与前面提到的平移、旋转、缩放等标准的几何变换不同，重映射更为灵活和通用。它允许对图像的每个像素位置进行任意的重新映射，而不仅仅是线性变换。因此，虽然它属于广义上的几何变换，但其功能和应用场景与传统的几何变换有些不同。

重映射的独特性

任意变换 ：与平移、旋转、缩放等仿射变换不同，重映射可以实现任意的变换。通过提供映射矩阵 map_x 和 map_y，可以自由地将图像的像素点重新分配到新的位置，这使得重映射比其他几何变换更加灵活和强大。
广泛应用：重映射可以用于图像扭曲、鱼眼矫正、投影变换等复杂的图像处理任务。

为什么没有将重映射与其他几何变换一起介绍

操作方式不同：平移、旋转、缩放、仿射变换和透视变换都是基于矩阵运算的几何变换，通常可以通过定义一个变换矩阵直接应用到整个图像。而重映射则是基于像素级的映射，通过对每个像素的坐标进行独立计算来实现，操作上有所不同。
灵活度不同：其他几何变换的变换矩阵通常是线性的，遵循特定的规则，而重映射允许任意的非线性变换，这种高度的自由度使其更适合被单独讨论。
应用场景不同：重映射经常用于复杂的图像处理任务，而传统的几何变换更常用于图像的基本变换（如旋转、缩放）。

重映射与其他几何变换的关系

尽管重映射与平移、旋转、缩放等有操作上的差异，但它们都属于图像几何变换的范畴。在某些情况下，可以通过合适的重映射函数实现其他几何变换的效果，反之亦然。但由于重映射的灵活性，它更适合处理复杂的变换需求。

所以，重映射是一种广义的几何变换，其灵活性和功能性使得它在某些场景下更为适用，因此通常单独讨论。