图像预处理_01

图像预处理

1.在计算机视觉和图像处理领域，图像预处理是一个重要的步骤，它能够提高后续处理（如特征提取、目标检测等）的准确性和效率。OpenCV 提供了许多图像预处理的函数和方法，以下是一些常见的图像预处理操作：

• 图像色彩的空间转换
• 图像大小调整
• 图像仿射变换
• 图像翻转
• 图像裁剪
• 图像二值化处理
• 图像去噪
• 边缘检测
• 图像平滑处理
• 图像形态学

图像翻转

1.cv2.flip 是 OpenCV 库中的一个函数，用于翻转图像。翻转可以是水平翻转、垂直翻转或同时水平和垂直翻转。这个函数接受两个参数：要翻转的图像和一个指定翻转类型的标志。

2.函数签名

cv2.flip(src, flipCode[, dst]) -> dst

3.参数说明

（1）src：输入图像，可以是任意类型和深度的多通道图像。

（2）flipCode：指定翻转类型的整数标志：

• 0：沿 X 轴翻转（垂直翻转）
• 1：沿 Y 轴翻转（水平翻转）
• -1：沿 X 轴和 Y 轴翻转（同时水平和垂直翻转）

（3）dst：可选参数，输出图像。如果未提供，输出图像将与输入图像具有相同的尺寸和类型。

4.示例

以下是一些使用 cv2.flip 的示例代码：

import cv2

img = cv2.imread('../images/car.png')

#图像翻转
#img:输入图像，可以是任意类型和深度的多通道图像。
# 第二个参数：翻转的方式
    # 0:垂直翻转
    # 1：水平翻转
    # -1：水平垂直翻转一起
f_img=cv2.flip(img,-1)

cv2.imshow('old', img)
cv2.imshow('new', f_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像仿射变换

仿射变换（Affine Transformation）是一种线性变换，它保持了点之间的相对距离不变，即平行线在变换后仍然保持平行。在图像处理中，仿射变换常用于旋转、缩放、平移和剪切等操作。

cv2.warpAffine 函数

1.仿射变换 函数

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

2.参数说明：

• src: 输入图像。
• M : 2x3 的变换矩阵，类型为 np.float32。
• dsize : 输出图像的尺寸，形式为 (width, height)。
• dst (可选): 输出图像。如果未提供，则会自动创建一个新的图像。

图像旋转

1.旋转操作可以将图像绕着某个点旋转一定的角度

2.cv2.getRotationMatrix2D 是 OpenCV 库中的一个函数，用于获取旋转矩阵。这个函数主要用于图像的旋转变换。旋转矩阵是一个 2x3 的矩阵，可以用来将图像围绕指定的中心点旋转指定的角度，并且可以选择是否进行缩放。

3.函数签名

cv2.getRotationMatrix2D(center, angle, scale) -> M

4.参数说明

• center ：旋转中心点的坐标，格式为 (x, y)。
• angle：旋转角度，单位为度。正角度表示逆时针旋转，负角度表示顺时针旋转。
• scale：缩放比例。如果设置为 1，则不进行缩放。

5.返回值

• M：2x3 的旋转矩阵。

6.示例

以下是一个使用 cv2.getRotationMatrix2D 的示例代码，

import cv2

img = cv2.imread('../../images/car.png')

#图像的旋转
#img:选择图片对象
#第二个参数：矩阵，决定图片是什么操作
    #旋转坐标
center = (100,120)
    #旋转的角度
du = 30
    #获取图片旋转矩阵
        #1:不缩放，保留不变
M = cv2.getRotationMatrix2D(center, du, 1)
#第三个参数：图片的像素(宽高度)
    #获取宽高度
(h, w) = img.shape[:2]
#第四个参数
w_img=cv2.warpAffine(img,M,(w,h))
cv2.imshow('image', w_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像平移

平移操作可以将图像中的每个点沿着某个方向移动一定的距离

import cv2
import numpy as np

img = cv2.imread('../../images/car.png')


(h,w) = img.shape[:2]
#定义平移水平和垂直移动的距离
ty = 50
tx = 100
#创建一个平移矩阵
    #[1,0,tx]
        #1,0:tx移动的起始点
            #1表示沿着x轴平移
            #0表示y轴不操作
        #tx：移动的距离
    #[0,1,ty]
        #0,1:ty移动的起始点
            #1表示沿着y轴平移
            #0表示x轴不操作
        #ty：移动的距离
t_img = np.float32([[1,0,tx], [0,1,ty]])
#或者(有点问题)
# t_img = cv2.getRotationMatrix2D((tx,ty), -1,1)

w_img = cv2.warpAffine(img, t_img, (w,h))

cv2.imshow('new_m', w_img)
cv2.imshow('old_m', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

其中，tx 和 ty 分别表示在x轴和y轴方向上的平移距离。

图像缩放

缩放操作可以改变图像的大小

import cv2
import numpy as np

img = cv2.imread('../../images/car.png')
(h,w) = img.shape[:2]
print(h,w) #276 754
#定义缩放因子(定义缩放的参数),大于1是放大，小于1是缩小
    #ww、hh：缩放比例
ww = 1.5
hh = 1.5
m = np.float32([[ww,0,0], [0,hh,0]])
#仿射变换
    #w*ww和h*hh:扩大倍数乘以尺寸，等于最终缩放的尺寸，但结果确实小数点
    # 因为像素是整型，所以(int(w*ww), int(h*hh)要强转为整型
t_img = cv2.warpAffine(img, m, (int(w*ww), int(h*hh)))
(h,w) = t_img.shape[:2]
print(h,w) #414 1131
cv2.imshow('img', t_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

ww 和 yy 分别表示在x轴和y轴方向上的缩放因子。

图像剪切

剪切操作可以改变图像的形状，使其在某个方向上倾斜

import cv2
import numpy as np

img = cv2.imread('../../images/car.png')
(h,w) = img.shape[:2]
#定义图像剪切的形状
sx = 0.2
sy = 0.5
#定义矩阵
#[1,sx,0]
    #x和y轴同时进行操作
#[sy,1,0]]
    #x和y轴同时进行操作
M = np.float32([[1,sx,0], [sy,1,0]])
#图像剪切
i_img = cv2.warpAffine(img, M, (w,h))
cv2.imshow('old', img)
cv2.imshow('new', i_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像色彩空间转换

1.OpenCV中的色彩空间转换是将图像从一种颜色表示形式转换为另一种颜色表示形式的过程。常见的颜色空间包括RGB、HSV、YUV等。

2.色彩空间转换有几个重要的作用：

• 方便图像处理：在不同的颜色空间中，对应的通道代表了不同的属性，例如在RGB空间中，红、绿、蓝三个通道分别代表了颜色的强度，而在HSV空间中，H(色相)代表了颜色的种类，S(饱和度)代表了颜色的深浅，V(亮度)代表了颜色的明暗。因此，对于不同的处理需求，选择不同的颜色空间进行处理可以更加方便。
• 提高图像处理效果：在某些情况下，使用某些特定的颜色空间可以提高图像处理的效果。例如，在HSV空间中，可以通过调整S(饱和度)和V(亮度)来提高图像的对比度并去除噪点。
• 节省计算资源：在某些情况下，使用特定的颜色空间可以帮助我们节省计算资源。例如，在RGB空间中，每个像素需要3个通道来表示，而在灰度空间中，每个像素只需要一个通道就可以表示。因此，如果我们只需要处理亮度信息而不需要颜色信息时，将图像转换为灰度空间可以节省计算资源。

总之，色彩空间转换在图像处理中是一项非常重要的技术，它可以方便我们对图像进行处理，并提高图像处理的效果和节省计算资源。

2.cv2.cvtColor()是OpenCV中的一个函数，用于图像颜色空间的转换。它可以将一个图像从一个颜色空间转换为另一个颜色空间，比如从RGB到灰度图像的转换，或者从BGR到HSV的转换等。

2.函数的语法如下：

cv2.cvtColor(src, code)

3.参数说明：

• src：输入图像，可以是一个NumPy数组或者一个OpenCV的Mat对象。
• code：指定转换的类型，可以使用预定义的转换代码，例如cv2.COLOR_BGR2GRAY表示从BGR到灰度图像的转换。

BGR 转 Gray（灰度）

BGR 转 Gray（灰度），将彩色图像转换为灰度图像，可以减少数据量并简化算法。

import cv2

img = cv2.imread('../../images/car.png')
print(img)

#图像色彩空间转换
#opencv默认的图像格式是BGR
#cv2.COLOR_BGR2GRAY 把BGR图像转换成灰度图像
gay_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
print(gay_img)
cv2.imshow('old', img)
cv2.imshow('new', gay_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

BGR 转 HSV

BGR 转 HSV，HSV（Hue, Saturation, Value）色彩空间在颜色分割和颜色识别中非常有用。

import cv2
#在某些情况下，使用某些特定的颜色空间可以提高图像处理的效果。
# 例如，在HSV空间中，可以通过调整S(饱和度)和V(亮度)来提高图像的对比度并去除噪
img = cv2.imread('../../images/car.png')
print(img)

#图像色彩空间转换
#opencv默认的图像格式是BGR
#cv2.COLOR_BGR2HSV 把BGR图像转换成HSV图像
gay_img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
print(gay_img)
cv2.imshow('old', img)
cv2.imshow('new', gay_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像二值化处理(图像的矩阵会有变化)

1.cv2.threshold 是 OpenCV 中用于图像二值化的函数。它通过设置阈值将图像分为前景和背景，常用于图像处理和分析。以下是该函数的主要功能和用法简介：

2.功能

• cv2.threshold 将灰度图像转换为二值图像，根据指定的阈值将像素值分为两类：高于阈值的像素设为一个值（通常是255），低于阈值的像素设为另一个值（通常是0）。

3.语法

retval, dst = cv2.threshold(src, thresh, maxval, type)

4.参数

（1）src: 输入的灰度图像。

（2）thresh: 阈值，决定分割的界限。

（3）maxval: 当像素值超过阈值时，赋予的最大值（通常为255）。

（4）type: 阈值类型，常用的有：

• cv2.THRESH_BINARY: 超过阈值的像素设为最大值，其余设为0。
• cv2.THRESH_BINARY_INV: 超过阈值的像素设为0，其余设为最大值。
• cv2.THRESH_TRUNC: 超过阈值的像素设为阈值，其余不变。
• cv2.THRESH_TOZERO: 超过阈值的像素不变，其余设为0。
• cv2.THRESH_TOZERO_INV: 超过阈值的像素设为0，其余不变。

5.返回值

• retval: 实际使用的阈值（可能与输入值不同）。
• dst: 输出的二值图像。

6.案例

import cv2

#把图像装换为灰度图像,直接在读取时进行转换
#g_img不同的转换。图片效果有点不同
# g_img = cv2.imread('../images/car.png', cv2.COLOR_BGR2GRAY)

img = cv2.imread('../images/car.png')
g_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#应用阈值
#rs：实际应用阈值，
#t_img:转换图像
rs, t_img = cv2.threshold(g_img, 100, 255, cv2.THRESH_BINARY)
cv2.imshow('new', t_img)
cv2.imshow('old', g_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

7.结果对比

• 一步完成BGR图像转灰度：g_img = cv2.imread('../images/car.png', cv2.COLOR_BGR2GRAY)

• 分步完成

img = cv2.imread('../images/car.png')
g_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

图像掩膜

1.它通常用于创建掩膜，以便从图像中提取特定颜色的区域。

2.函数原型

cv2.inRange(src, lowerb, upperb)

3.参数

• src: 输入的图像，可以是彩色图像或灰度图像。
• lowerb: 颜色范围的下界（数组或元组），指定了要提取的颜色的最小值。
• upperb: 颜色范围的上界（数组或元组），指定了要提取的颜色的最大值。

4.返回值

• 返回一个二值图像，白色部分表示在指定颜色范围内的区域，黑色部分表示不在范围内的区域

5.案例

import numpy as np

img = cv2.imread('../images/car2.png')
#把img转换成HSV空间
hsv_img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
#获取蓝色所在的HSV范围，在网上搜
#颜色下限范围
lower = np.array([100,100,50])
#颜色上限范围
height = np.array([140,255,255])
#hsv_img 输入的图像是HSV的，其他的不行，找不到指定颜色区域
mask = cv2.inRange(hsv_img, lower, height)
cv2.imshow('new', mask)
cv2.imshow('old', hsv_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像位与操作

1.cv2.bitwise_and() 是 OpenCV 库中的一个函数，用于对两个图像进行按位与操作。这个操作会逐个像素地对两个输入图像进行比较，只有在两个像素均为 255（白色）时，输出的像素才会为 255（白色），否则输出为 0（黑色）。这个函数在图像处理中的应用非常广泛，尤其是在掩膜和图像分割等任务中

2.函数原型

dst = cv2.bitwise_and(src1, src2, mask=None)

3.参数说明

• src1: 第一个输入图像。
• src2: 第二个输入图像。两幅图像应具有相同的尺寸和类型。
• mask: 可选参数，用于指定一个掩膜。如果提供，只有在掩膜的相应位置为非零时，才会计算输出。

4.返回值

• 返回按位与操作后的图像（dst）。

5.案例

import cv2
import numpy as np

# 读取图像
image = cv2.imread("images/car.png")
# 将图像从 BGR 转换到 HSV 颜色空间
hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
# 定义颜色范围，(蓝色区域)
lower = np.array([100, 100, 100])
upper = np.array([140, 255, 255])
# 使用 inRange 函数创建掩模
mask = cv2.inRange(hsv_image, lower, upper)
#位与操作
image = cv2.bitwise_and(image,image,mask=mask)
cv2.imshow('01', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像检测轮廓

cv2.findContours

1.cv2.findContours 函数可以在二值图像中找到轮廓，并返回轮廓的点集。轮廓可以用来表示物体的边界，常用于物体检测、分割和形状分析。

2.语法

contours, hierarchy = cv2.findContours(image, mode, method)

3.参数

（1）image : 输入的二值图像。通常在调用该函数之前需要将图像转换为灰度图像并进行二值化处理（如使用 cv2.threshold 或 cv2.Canny）。

（2）mode: 轮廓检索模式：

• cv2.RETR_EXTERNAL: 只检索外部轮廓。
• cv2.RETR_LIST: 检索所有轮廓，并将其放入列表中。
• cv2.RETR_TREE: 检索所有轮廓，并建立层级关系。

（3）method: 轮廓逼近方法：

• cv2.CHAIN_APPROX_SIMPLE: 压缩轮廓，仅保留端点。
• cv2.CHAIN_APPROX_NONE: 保留所有轮廓点。

4.返回值

• contours: 一个 Python 列表，其中每个元素是一个轮廓（即一组点），轮廓的点以 NumPy 数组的形式存储。
• hierarchy: 轮廓的层级信息，包含轮廓之间的关系。

5.案例

import cv2
import numpy as np

"""
图象论库
"""
def lunkuo():
    img = cv2.imread('../images/car.png')
    #在二值化处理前，把图像转换为灰度图像
    #转换为灰值图片的原因
        #为了二值化处理
    gay_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    #二值化处理
    ret, t_img = cv2.threshold(gay_img, 170,255,cv2.THRESH_BINARY)
    #检测轮廓
    # myList,c = cv2.findContours(t_img, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
    myList,c = cv2.findContours(t_img, cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)

    #将灰度图像转换为BGR色彩图像
    bgr_img = cv2.cvtColor(t_img, cv2.COLOR_GRAY2BGR)
    #画出检测的轮廓的点
    out_bgr_img = cv2.drawContours(bgr_img, myList, -1,(0,255,0), 1);
    out_img = cv2.drawContours(img, myList, -1,(0,255,0), 1);

    #画灰度的轮廓，轮廓的点不明显，所有要画原图
    cv2.imshow('img',out_img)
    cv2.imshow('bgr_img',out_bgr_img)
    cv2.imshow('t_img',t_img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


"""
图象轮廓+掩膜，截取车牌号
"""
def cai_lun():
    img = cv2.imread('../images/car.png')
    # 把img转换成HSV空间
    hsv_img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    # 获取蓝色所在的HSV范围，在网上搜
    # 颜色下限范围
    lower = np.array([100, 100, 50])
    # 颜色上限范围
    height = np.array([140, 255, 255])
    # 创建掩膜
    # hsv_img 输入的图像是HSV的，其他的不行，找不到指定颜色区域,返回灰白图像
    mask = cv2.inRange(hsv_img, lower, height)
    # #二值化处理
    ret, t_img = cv2.threshold(mask, 170, 255, cv2.THRESH_BINARY)
    # 检测轮廓
    # myList,c = cv2.findContours(t_img, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
    myList, c = cv2.findContours(t_img, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)

    # 将灰度图像转换为BGR色彩图像
    bgr_img = cv2.cvtColor(t_img, cv2.COLOR_GRAY2BGR)
    # 画出检测的轮廓的点
    out_img = cv2.drawContours(bgr_img, myList, -1, (0, 255, 0), 1);

    for c in myList:
        x, y, w, h = cv2.boundingRect(c)
        print(f"x={x},y={y},w={w},h={h}")
        if w > 100 and h > 50:
            #画出矩形，找到轮廓
            cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0))
            cai_img = img[y:y + h, x:w + x]
        # 画出轮廓
        # img1=cv2.rectangle(img,(x,y), (x+w, y+h),(0,255,0))
        # img2=cv2.rectangle(img,(326,170), (326+168, 170+54),(0,255,0))

    # 显示的代码放最后，就会是这个遍历最大的轮廓
    cv2.imshow('cai_img', cai_img)
    # cv2.imshow('img1',img)
    # cv2.imshow('img1',img1)
    # cv2.imshow('img2',img2)
    # cv2.imshow('new',out_img)
    # cv2.imshow('old',hsv_img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

# cai_lun()
lunkuo()

cv2.drawContours()

1.cv2.drawContours 是 OpenCV 库中的一个函数，用于在图像上绘制轮廓。这个函数非常有用，特别是在图像处理和计算机视觉任务中，比如对象检测、形状分析等。

2.参数说明

（1）image:输入图像，通常是彩色图像（BGR格式）或灰度图像。

（2）contours:轮廓列表。每个轮廓是一个 numpy.ndarray，表示一组点的集合，这些点定义了一个轮廓。轮廓可以是多边形的顶点坐标。

（3）contourIdx:要绘制的轮廓索引。如果设置为 -1，则绘制所有轮廓。如果设置为非负整数，则只绘制该索引对应的轮廓。

（4）color:绘制轮廓的颜色。对于彩色图像，颜色是一个包含三个值的元组，分别对应蓝色、绿色和红色通道的值（例如 (0, 255, 0) 表示绿色）。对于灰度图像，颜色是一个整数值。

（5）thickness:轮廓线的厚度。如果设置为 1，则绘制实线。如果设置为负值（例如 -1），则填充轮廓内部区域。

（6）lineType:轮廓线的类型。

• cv2.LINE_4: 4连通线
• cv2.LINE_8: 8连通线
• cv2.LINE_AA: 抗锯齿线（平滑线）

（7）maxLevel:绘制轮廓的最大层级。如果设置为 0，则只绘制当前层级的轮廓。如果设置为正数，则绘制该层级及以下层级的轮廓。

（8）offset:轮廓点的偏移量。如果需要将轮廓绘制在图像的某个特定位置，可以使用这个参数。默认值为 None，表示没有偏移。

cv2.boundingRect 函数介绍

1.cv2.boundingRect 是 OpenCV 中用于计算轮廓的最小外接矩形的函数。这个函数可以返回一个包含轮廓的最小矩形的边界框，通常用于对象检测、图像分割等任务中。最小外接矩形是一个完全包围轮廓的矩形，其边与图像的坐标轴平行。

2.案例

import cv2

# 读取图像并转换为灰度图像
image = cv2.imread("images/car.png")
# 将图像从BGR到灰度图像的转换
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 二值化处理
retval, binary_image = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)
# 查找轮廓
contours, hierarchy = cv2.findContours(binary_image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# 把灰度图像转换彩色图像
output_image = cv2.cvtColor(binary_image, cv2.COLOR_GRAY2BGR)
# 绘制轮廓
cv2.drawContours(output_image, contours, -1, (0, 255, 0), 2)
# 在每个轮廓上绘制最小外接矩形
for contour in contours:
    #获取绘制轮廓的边界框
    x, y, w, h = cv2.boundingRect(contour)
    cv2.rectangle(output_image, (x, y), (x + w, y + h), (0, 100, 0), 2)
# 显示结果
cv2.imshow('Contours', output_image)
cv2.waitKey(0)
cv2.destroyAllWindows()