人工智能 | 深度学习——图像数据处理

末蓝、 2022-04-04 15:09 768阅读 0赞

**目录**

0.图像数据情况

1.图像数据处理

1.1.图像扩增

1.1.1.图像平移

1.1.2.图像翻转

1.1.3.随机角度旋转

1.1.4.变色

1.1.5.图像亮度+对比度 调节

1.2.图像预处理

1.2.1.灰度图转换

1.2.2.图像梯度运算

1.2.3.图像滤波

1.2.4.图像二值化

1.2.5.腐蚀+膨胀

1.2.6.边缘检测

2.Python代码

--------------------

# 0.图像数据情况 #

> ***【图像数据】***
> 
> （1）4张电商网站的商品主图，图像大小\[800, 800, 3\]
> 
> （2）4张电商网站的用户评论晒图，图像大小不一，一般小于\[100, 100, 3\]
> 
> ***【python类库】***
> 
> （1）os\\re\\numpy
> 
> （2）PIL.Image：（第三方图像处理库）中的“图像类包装器”，负责图像加载、图像保存、图像转换、图像展示等（***读取的图像为<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=800x800 at 0x1D10ECB7668>格式***）
> 
> （3）PIL.ImageChops：（第三方图像处理库）中的“图像编辑器”
> 
> （4）PIL.ImageEnhance：（第三方图像处理库）中的“图像增强器”
> 
> （5）cv2：opencv库（***读取的图像为矩阵形式***）

# 1.图像数据处理 #

## 1.1.图像扩增 ##

> ***【扩增方法如下】***
> 
> ### 1.1.1.图像平移 ###
> 
> ![2020032917092772.png][]
> 
>  特别的，在平移的过程中应当注意，最好不要将图像的主体位置平移出了可见区域，不然会影响后续的边缘检测。
> 
> ### 1.1.2.图像翻转  ###
> 
> ![20200329171201692.png][]
> 
> ###  1.1.3.随机角度旋转 ###
> 
> ![20200329171301870.png][]
> 
> ### 1.1.4.变色 ###
> 
> ### ![20200329171331126.png][] 1.1.5.图像亮度+对比度 调节 ###
> 
> ![20200329171423101.png][] 注意，亮度与对比度调节方式类似，只不过控制的参数不同。

## 1.2.图像预处理 ##

> ***【图像预处理流程】***
> 
> ① 导入图像  →  ② 灰度图转换  →  ④ 去噪（图像滤波）→ ③ 图像梯度运算  →  ⑤ 图像二值化  →  ⑥ 图像滤波  →  ⑦ 腐蚀 + 膨胀  →  ⑧ 边缘检测  →  ⑨ 图像裁剪（转换成RGB）  →  ⑩ 图像重构

### 1.2.1.灰度图转换 ###

> ***【灰度转换原因】***
> 
> ① 自然界中，颜色本身非常容易受到光照的影响，rgb变化很大，反而梯度信息能提供更本质的信息
> 
> ② 三通道转为一通道后，运算量大大减少（三维数据 → 二维数组）
> 
> ③ opencv的很多函数只支持单通道
> 
> ***【灰度转换函数】***
> 
>  *  **PIL.Image.convert(mode)**
>  *  mode: 1，L，P，RGB，RGBA，CMYK，YCbCr，I，F([参考博客][Link 1])
>  *  **cv2.cvtColor(src, code, dst=None, dstCn=None)**
>  *  src：图像矩阵
>  *  code：颜色空间转换代码（请参见 \#[ColorConversionCodes][] ）

### 1.2.2.图像梯度运算 ###

> ***【梯度运算原因】***
> 
> ①图像中的真实边界点处的梯度强度大于其左右领域的梯度强度值。因此，在图像分割时，可以将基于梯度的边缘检测和阀值分割相结合
> 
> ***【图像梯度运算函数】***
> 
>  *  **cv2.Sobel(src, ddepth, dx, dy, dst=None, ksize=None, scale=None, delta=None, borderType=None)**
>  *  src：图像矩阵（一般为灰度图像）
>  *  ddepth：输出图像深度，请参见@ref filter\_depths "combinations"；（[如果是8位输入图像，则会导致导数截断][8]）
>  *  dx：导数x的阶（一般为一阶导）
>  *  dy：导数y的阶（一般为一阶导）
>  *  ksize：扩展Sobel内核的大小；它必须是1、3、5或7
>  *  borderType：像素外推法，见 \#BorderTypes

### 1.2.3.图像滤波 ###

> ***【图像滤波的原因】***
> 
> ① 保留图像细节特征的条件下对目标图像的噪声进行抑制
> 
> ***【图像滤波运算函数】***
> 
>  *  **【线性滤波】**
>  *  → 2D滤波
>  *  **cv2.filter2D(src, ddepth, kernel\[, dst\[, anchor\[, delta\[, borderType\]\]\]\])**
>  *  ddepth：输出图像深度（-1使用src.depth（））
>  *  kernel：模糊核大小（set形式：核越大，图像越模糊（缺陷））
>  *  → ***均值滤波（核 - 归一化）***
>  *  **cv2.blur(src, ksize, dst=None, anchor=None, borderType=None)**
>  *  src：图像矩阵（一般为灰度图像）
>  *  ksize：模糊核大小（set形式：核越大，图像越模糊（缺陷））
>  *  anchor：锚点；默认值点（-1，-1）表示锚点位于内核
>  *  → ***方框滤波（核 - 非归一化）***
>  *  **cv2.boxFilter(src, ddepth, ksize, dst=None, anchor=None, normalize=None, borderType=None)**
>  *  ddepth：输出图像深度（-1使用src.depth（））
>  *  normalize：指定内核是否按其区域归一化（1表示归一化）
>  *  其他参数同“均值滤波”
>  *  → ***高斯滤波***
>  *  **cv2.GaussianBlur(src, ksize, sigmaX, dst=None, sigmaY=None, borderType=None)**
>  *  ksize：高斯核大小。ksize.width和ksize.height可以不同但必须是正数和奇数
>  *  sigmaX：X方向高斯核标准差
>  *  sigmaY：Y方向上的高斯核标准差；如果sigmaY为零，则设置为等于sigmaX；如果两个sigma均为零，则分别从ksize.width和ksize.height计算
>  *  其他参数同“均值滤波”
>  *  **【非线性滤波】**
>  *  → ***中值滤波***
>  *  **cv2.medianBlur(src, ksize, dst=None)**
>  *  参数同“均值滤波”
>  *  → ***双边滤波***
>  *  **cv2.bilateralFilter(src, d, sigmaColor, sigmaSpace, dst=None, borderType=None)**
>  *  src：图像矩阵（一般为灰度图像）
>  *  d：滤波过程中使用的每个像素邻域的直径。如果是非正的，则从sigmaSpace计算
>  *  sigmaColor：空间高斯函数标准差
>  *  sigmaSpace：灰度值相似性高斯函数标准差（[参考博客][Link 2]）
>  *  → ***形态学滤波***
>  *  **cv2.morphologyEx(src, op, kernel, dst=None, anchor=None, iterations=None, borderType=None, borderValue=None)** \-> dst
>  *  src：图像矩阵。通道的数量可以是任意的。深度应该是一个CV\_8U, CV\_16U, CV\_16S, CV\_32F或CV\_64F
>  *  op：形态操作的类型。参考 [\# MorphTypes][MorphTypes]
>  *  kenel：用于膨胀的结构元素；如果elemenat=Mat（），则用3 x 3矩形结构元素。可用getStructuringElement创建
>  *  anchor：锚在构件内的位置;默认值(-1，-1)表示锚点位于元素中心
>  *  iterations：应用侵蚀的次数

### 1.2.4.图像二值化 ###

> ***【图像二值化原因】***
> 
> ①凸显待裁剪的目标轮廓
> 
> ②大大减少运算量，提高模型运行效率
> 
> （\#compare, \#inRange, \#threshold, \#adaptiveThreshold, [\#Canny][Canny],）
> 
> ***【图像二值化运算函数】***
> 
>  *  → ***全局阙值***
>  *  **cv2.threshold(src, thresh, maxval, type, dst=None)**
>  *  src：图像矩阵（一般为灰度图像）
>  *  thresh：二值化阙值
>  *  maxval：与\#THRESH\_BINARY和\#THRESH\_BINARY\_INV阈值类型一起使用的最大值
>  *  type：阙值类型(查看\#[ThresholdTypes][]) cv2.THRESH\_BINARY / cv2.THRESH\_BINARY\_INV / cv2.THRESH\_TRUNC / cv2.THRESH\_TOZERO / cv2.THRESH\_TOZERO\_INV
>  *  → ***局部阙值***
>  *  **cv2.adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C, dst=None)**
>  *  src：图像矩阵（一般为灰度图像）
>  *  maxValue：分配给满足条件的像素的非零值
>  *  adaptiveMethod：要使用的自适应阈值算法，请参见\#AdaptiveThresholdTypes（[CV\_ADAPTIVE\_THRESH\_MEAN\_C、CV\_ADAPTIVE\_THRESH\_GAUSSIAN\_C][ThresholdTypes]）
>  *  thresholdType：阙值类型（CV\_THRESH\_BINARY, CV\_THRESH\_BINARY\_INV：意思同上）

### 1.2.5.腐蚀+膨胀 ###

> ***【图像腐蚀及膨胀的原因】***（[参考博客][Link 3]）
> 
> ①腐蚀：让暗的区域变大
> 
> ②膨胀：让亮的区域变大
> 
> ***【腐蚀+膨胀运算函数】***
> 
>  *  → ***腐蚀***
>  *  **cv2.erode(src, kernel, dst=None, anchor=None, iterations=None, borderType=None, borderValue=None)**
>  *  src：二值图像矩阵
>  *  kernel：腐蚀核；如果“element=Mat()”，则使用“3 x 3”矩形结构元素。内核可以使用 [\# getStructuringElement][getStructuringElement]。特别的，腐蚀核的形状和元素值对最终的腐蚀结果影响较大。
>  *  anchor：锚定在元素中的位置；默认值（-1，-1）表示锚定位于元素中心
>  *  iterations：腐蚀的次数
>  *  → ***膨胀***
>  *  **cv2.dilate(src, kernel, dst=None, anchor=None, iterations=None, borderType=None, borderValue=None)**
>  *  参数理解同上

### 1.2.6.边缘检测 ###

> ***【边缘检测的原因】***
> 
> ①去除图像中的无用部分，提高图像识别模型性能
> 
> ***【边缘检测运算函数】***
> 
>  *  → ***轮廓查找***
>  *  **cv2.findContours(image, mode, method, contours=None, hierarchy=None, offset=None)**** **\-> contours, hierarchy
>  *  image：二值图像矩阵
>  *  mode：轮廓检索模式。参照 [\# RetrievalModes][RetrievalModes]
>  *  method：轮廓近似的方法。参照  [\# ContourApproximationModes][RetrievalModes]
>  *  contour：检测到的轮廓，每个轮廓都是以点向量的形式进行存储即使用point类型的vector表示
>  *  hierarchy：可选的输出向量(std::vector)，包含了图像的拓扑信息，作为轮廓数量的表示hierarchy包含了很多元素，每个轮廓contours\[i\]对应hierarchy中hierarchy\[i\]\[0\]~hierarchy\[i\]\[3\],分别表示后一个轮廓，前一个轮廓，父轮廓，内嵌轮廓的索引，如果没有对应项，则相应的hierarchy\[i\]设置为负数。
>  *  offset：轮廓点可选偏移量，有默认值Point()，对ROI图像中找出的轮廓并要在整个图像中进行分析时使用
>  *  → ***计算各轮廓对应面积***
>  *  **cv2.contourArea(contour, oriented=None)** -> retval
>  *  contour：二维点（轮廓顶点）的输入向量，存储在std::vector或Mat中。（cv2.findContours的返回值）
>  *  oriented：面向区域标志。如果为真，则函数根据轮廓方向(顺时针或逆时针)返回一个有符号的面积值。使用此功能，您可以通过取面积的符号来确定轮廓的方向。默认情况下，参数为false，这意味着返回绝对值。
>  *  → ***查找包含输入的最小区域的旋转矩形***
>  *  ***cv2.minAreaRect(points)*** \-> retval
>  *  points：二维点的输入向量，存储在std::vector\\<\\>或Mat中（也就是sort(,key=cv2.contourArea(),)之后的结果）
>  *  → ***获得最小外接旋转矩形的4个顶点***
>  *  ***cv2.boxPoints(box, points=None)*** \-> points
>  *  box：cv2.minAreaRect的返回值（输入旋转矩形）
>  *  points：矩形的四个顶点的输出数组
>  *  → ***画线***
>  *  ***cv2.rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None)*** \-> img
>  *  img：图像矩阵（RGB：线可为彩色；GRAY：线为黑白色）
>  *  pt1：矩形顶点（对角线顶点之一）
>  *  pt2：与pt1相对的矩形的顶点（对角线顶点之二）
>  *  color：矩形颜色(三维列表\[r,g,b\])
>  *  thickness：线宽。像\#FILLED这样的负值表示函数必须绘制一个填充矩形
>  *  lineType：线的类型. 参考 \#LineTypes
>  *  shift：点坐标中的小数位数

# 2.Python代码 #

# ! /usr/bin/env python
    # coding:utf-8
    # python interpreter:3.6.2
    # author: admin_maxin
    import io, os
    import numpy as np
    import cv2
    import re
    from PIL import Image, ImageEnhance, ImageChops
    
    
    class PicExpansion:
    
        # =====================================图像扩增
        def __init__(self, path):
            """
            初始化图片文件路径
            :param path: 初始路径
            """
            self.path = path  # 起始路径
            self.sub = []     # 子文件夹下文件的个数
            self.num = 0      # 文件总数
    
        def get_Imgs_Paths(self, *suffix):
            """
            批量获取图片名称
            :return:文件夹下的所有图像名称列表
            """
            trees = os.walk(self.path)
    
            pathArray = []
            # 获取所有文件的绝对路径
            # [str1, str2, ...]
            for root, dirs, files in trees:
                self.sub.append(len(files))
                for fn in files:
                    if os.path.splitext(fn)[1] in suffix:   # 判断图片文件的格式
                        fname = os.path.join(root, fn)
                        pathArray.append(fname)
            self.num = sum(self.sub)
            return pathArray
    
        def reSize(self, filepaths, *suffix):
            """
            原始图像大小调整
            :param filepaths:
            :return:
            """
            for i in range(self.num):
                img = Image.open(filepaths[i])
                img2 = img.resize(suffix)
                img2.save(filepaths[i])
            return None
    
        def move(self, filepath):
            """
            图像平移
            :return:
            """
            img = Image.open(filepath)
            tmp = min(img.height, img.width)/10
            return ImageChops.offset(img, np.random.randint(0, tmp, 1))
    
        def flip(self, filepath):
            """
            图像翻转
            :return:
            """
            img = Image.open(filepath)
            return img.transpose(Image.FLIP_LEFT_RIGHT)
    
        def rotation(self, filepath):
            """
            随机角度旋转
            :param filepaths:
            :return:
            """
            img = Image.open(filepath)
            return img.rotate(angle=np.random.randint(0, 360, 1))
    
        def changeColor(self, filepath):
            """
            随机颜色
            :param filepaths:
            :return:
            """
            img = cv2.imread(filepath)
            img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
            img_hsv[:, :, 0] = (img_hsv[:, :, 0] + np.random.randint(1, 180)) % 180
            img_hsv[:, :, 1] = (img_hsv[:, :, 1] + np.random.randint(1, 255)) % 255
            img_hsv[:, :, 2] = (img_hsv[:, :, 2] + np.random.randint(1, 255)) % 255
            return cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR)
    
        def changeBright_and_contrast(self, filepath, alpha=1, beta=0):
            """
            调整图像亮度 + 对比图
            :param filepath:
            :param alpha: 对比度参数
             :param beta: 亮度参数
            :return:
            """
            img = Image.open(filepath)
            return Image.eval(img, lambda x: x*alpha + beta)
    
        # def deNoisingColored(self, filepath):
        #     """
        #     去除彩色图像高斯噪声
        #     :param filepath:
        #     :return:
        #     """
        #     img = cv2.imread(filepath)
        #     return cv2.fastNlMeansDenoisingColored(img, None, 10, 10, 7, 21)
        #
        # def local_threshold(self, filepath):
        #     """
        #     灰度图二值化（局部阙值）
        #     :param filepath:
        #     :return:
        #     """
        #     img = cv2.imread(filepath)
        #     img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        #     ret, binary = cv2.threshold(img, 2*(np.max(img)-np.min(img))/5, 255, cv2.THRESH_BINARY)
        #     return binary
    
        # =====================================图像预处理
        def box_detect(self, filepath):
            """
            边缘检测及裁剪
            :param filepath:
            :return:
            """
            # 转换为灰度图
            img = cv2.imread(filepath)
            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            image = Image.open(filepath)
    
            # 留下具有高水平梯度和低垂直梯度的图像区域
            gradX = cv2.Sobel(gray, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=-1)
            gradY = cv2.Sobel(gray, ddepth=cv2.CV_32F, dx=0, dy=1, ksize=-1)
            gradient = cv2.addWeighted(gradX, 1, gradY, 2, 1)
            # gradient = cv2.subtract(gradX, gradY)
            # Sobel函数求完导数后会有负值，还有会大于255的值。而原图像是uint8，即8位无符号数，所以Sobel建立的图像位数不够，会有截断。
            # 因此要使用16位有符号的数据类型，即cv2.CV_16S。处理完图像后，再使用cv2.convertScaleAbs()函数将其转回原来的uint8格式，
            # 否则图像无法显示。
            gradient = cv2.convertScaleAbs(gradient)
            cv2.imwrite(str(np.random.randint(100, 200, 1))+".jpg", gradient)
    
            # 均值滤波
            blurred = cv2.blur(gradient, (9, 9))
            # ret, binary = cv2.threshold(img, 90, 255, cv2.THRESH_BINARY)
            # ret, binary = cv2.threshold(img, 160, 255, cv2.THRESH_BINARY)
            # 二值化
            (ret, thresh) = cv2.threshold(blurred, 2*(np.max(img)-np.min(img))/5, 255, cv2.THRESH_BINARY)
    
            # 图像滤波
            kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (25, 25))  # 返回指定形状及尺寸的结构元素
            closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)    # 形态学滤波
    
            # 腐蚀与膨胀
            element = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3), (-1, -1))
            closed = cv2.erode(closed, element, iterations=4)
            closed = cv2.dilate(closed, element, iterations=4)
            # cv2.imwrite(str(np.random.randint(100, 200, 1))+".jpg", closed)
    
            # 边缘检测
            cnts, _ = cv2.findContours(closed.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
            cc = cv2.Canny(closed.copy(), 80, 150)
            ccc = cv2.Canny(closed.copy(), 50, 100)
            ret = np.hstack((cc, ccc))
            c = sorted(cnts, key=cv2.contourArea, reverse=True)[0]
            rect = cv2.minAreaRect(c)              # 得到最小外接旋转矩形的（中心(x,y), (宽,高), 旋转角度）
            box = np.int0(cv2.boxPoints(rect))     # cv2.boxPoints:得到最小外接旋转矩形的四个顶点。用于绘制旋转矩形。
    
            # 裁剪
            Xs = [i[0] for i in box]  # 获取4个顶点x坐标
            Ys = [i[1] for i in box]  # 获取4个顶点y坐标
            x1 = min(Xs)
            x2 = max(Xs)
            y1 = min(Ys)
            y2 = max(Ys)
            hight = y2 - y1
            width = x2 - x1
    
            # # 给原图画线
            # out = cv2.rectangle(img, (x1, y1), (x1 + width, y1 + hight), (0, 0, 255), 20)
            # cv2.imwrite(str(np.random.randint(100, 200, 1)) + ".jpg", out)
    
            return cv2.resize(img[y1:y1 + hight, x1:x1 + width], (32, 32))
    
    
    
    if "__main__" == __name__:
        path = "E:\\picOriginal"
        test = PicExpansion(path)
        filepaths = test.get_Imgs_Paths(".jpg", ".png")
    
        # 图像增强方法的个数
        fuc = 2
    
        # 操作循环i次
        for i in range(1):
            # 分文件夹操作
            for j in range(1, len(test.sub)):
                tmp = 0
                # 遍历商品路径列表
                for k in range(test.num):
                    cls = int(filepaths[k].split("\\")[-2])
                    if cls == j:
                        # tmp += 1
                        # img = test.move(filepaths[k])  # 图像平移
                        # img.save(filepaths[k].split("_")[0]+"_"+str(test.sub[j]+tmp)+".jpg")
                        # tmp += 1
                        # img = test.flip(filepaths[k])  # 图像翻转
                        # img.save(filepaths[k].split("_")[0]+"_"+str(test.sub[j]+tmp)+".jpg")
                        # tmp += 1
                        # img = test.rotation(filepaths[k])   # 随机角度旋转
                        # img.save(filepaths[k].split("_")[0]+"_"+str(test.sub[j]+tmp)+".jpg")
                        # tmp += 1
                        # img = test.changeColor(filepaths[k])  # 颜色变换
                        # cv2.imwrite(filepaths[k].split("_")[0]+"_"+str(test.sub[j]+tmp)+".jpg", img)
                        # tmp += 1
                        # img = test.changeBright_and_contrast(filepaths[k], 1, beta=80)   # 亮度调节
                        # img.save(filepaths[k].split("_")[0]+"_"+str(test.sub[j]+tmp)+".jpg")
                        # tmp += 1
                        # img = test.changeBright_and_contrast(filepaths[k], 4, 0)   # 对比度调节
                        # img.save(filepaths[k].split("_")[0]+"_"+str(test.sub[j]+tmp)+".jpg")
                        # tmp += 1
                        # img = test.cvtColor_gray(filepaths[k])  # 灰度图转化
                        # cv2.imwrite(filepaths[k].split("_")[0]+"_"+str(test.sub[j]+tmp)+".jpg", img)
                        # tmp += 1
                        # img = test.deNoisingColored(filepaths[k])  # 去除图像噪声
                        # cv2.imwrite(filepaths[k].split("_")[0]+"_"+str(test.sub[j]+tmp)+".jpg", img)
                        # tmp += 1
                        # img = test.local_threshold(filepaths[k])
                        # cv2.imwrite(filepaths[k].split("_")[0] + "_" + str(test.sub[j] + tmp) + ".jpg", img)
                        tmp += 1
                        img = test.box_detect(filepaths[k])
                        # cv2.imwrite(filepaths[k].split("_")[0] + "_" + str(test.sub[j] + tmp) + ".jpg", img)
    
                test.sub[j] = test.sub[j] * (fuc + 1)

[2020032917092772.png]: /images/20220404/9fb61dbbbd4c4f8b83643aed51a34c12.png
[20200329171201692.png]: /images/20220404/a0aa7643aec34ec998f32313f67bd733.png
[20200329171301870.png]: /images/20220404/2641076be4204bb9a9b3f0aa1d82e059.png
[20200329171331126.png]: /images/20220404/0afcf14f1b5b42e083b5797f81e89f4b.png
[20200329171423101.png]: /images/20220404/f691c53950104486bc6649ced4e89bde.png
[Link 1]: https://blog.csdn.net/icamera0/article/details/50843172
[ColorConversionCodes]: https://docs.opencv.org/3.1.0/d7/d1b/group__imgproc__misc.html
[8]: https://blog.csdn.net/lvchenqiang_/article/details/78695495?locationNum=8&fps=1
[Link 2]: https://blog.csdn.net/qq_40962368/article/details/80922275
[MorphTypes]: https://www.cnblogs.com/my-love-is-python/p/10395049.html
[Canny]: https://www.cnblogs.com/FHC1994/p/9133015.html
[ThresholdTypes]: https://www.jianshu.com/p/19689781a37e
[Link 3]: https://blog.csdn.net/alw_123/article/details/83868878
[getStructuringElement]: https://blog.csdn.net/kksc1099054857/article/details/76569718
[RetrievalModes]: https://blog.csdn.net/keith_bb/article/details/70185209