数字图像处理(一)之灰度转换和卷积python实现


使用Python实现数字图像处理中如下功能:

  1. 彩色图像转成灰度图像
  2. 实现图像的相关&卷积操作
  3. 实现图像的高斯核卷积

使用的库和python版本如下:

  • imageio:2.9.0 用于读取磁盘中的图片文件
  • numpy:1.20.3 用于矩阵等操作
  • matplotlib:3.4.2 用于画图
  • python:3.8.11

项目地址:xiaohuiduan/image_process (github.com)

读取图像

在进行图像处理操作前,首先需要对图像进行读取。这里使用imageio库对图片进行读取,并将其转成numpy数组。

下面定义一个covert_img_to_array函数,用于读取图片。

def covert_img_to_array(self, path:str) -> np.array:
    """[将图片转成Array便于处理]

        Args:
            path (str): [图片保存位置]

        Returns:
            np.array: [返回numpy数组,数组元素uint8]
        """
    return np.array(imageio.imread(path))

展示图片

使用matplotlib库用于展示图片,为了更高的展示如片,定义下show_img函数,当不指定col或者row时尽量以方正的形式去展示图片。

def show_img(self,title:str, imgs:list, cmaps:list,row:int = 0,col:int = 0):
    """展示图片 len(imgs) must equal to the len of cmaps

    Args:
        title (str): [图像标题]
        imgs (list): [图片元组]
        cmaps (list): [mask,plt以何种形式展示图片,可参考官方文档使用:'gray'表示灰度图,None表示彩色图]
        row (int, optional): [指令row]. Defaults to 0.
        col (int, optional): [指令col]. Defaults to 0.
    """
    if len(imgs) != len(cmaps):
        print("图片和mask的len必须相同")
    else:
        if row == 0 and col !=0:
            row = np.ceil(len(imgs)/col).astype("uint8")
        elif row!=0 and col == 0:
            col = np.ceil(len(imgs)/row).astype("uint8")
        elif row*col < len(imgs):
            # 尽量以方正的形式去展示图片
            row = np.ceil(np.sqrt(len(imgs))).astype("uint8")
            col = np.ceil(len(imgs)/row).astype("uint8")

        for index,img in enumerate(imgs):
            plt.subplot(row,col,index+1)
            plt.imshow(img,cmap=cmaps[index])
        plt.suptitle(title)
        plt.show()

彩色图像转成灰度图像

彩色图像一般来说RGB表示的。也就是说,如果有一张64*64大小的图片,那么它在numpy中便是以64*64*3的shape进行保存的。将RGB图片转成灰度图有两种方式:

  1. \(gray=\frac{R+G+B}{3}\)
  2. \(gray=R*0.2989 + G*0.5870 + B*0.1140\) 这种灰度转换称之为NTSC标准,考虑了人类的彩色感知体验。

下面定义covert_rgb_to_gray函数,其中method如果为average,则使用第一种方式灰度转换方式;默认为NTSC,使用第二种方式转换。

def covert_rgb_to_gray(self, image:np.array, method:str = 'NTSC') -> np.array:
    """将RGB图像转成gray图像

    Args:
        image (np.array): [rgb图像]
        method (str, optional): [转换模式]. Defaults to 'NTSC'.

    Returns:
        Array: [返回的灰度图像]
    """
    if method == 'average':
        gray_img = image[:,:,0]/3+image[:,:,1]/3+image[:,:,2]/3
    
    else:
        gray_img = image[:,:,0]*0.2989 + image[:,:,1]*0.5870 + image[:,:,2]*0.1140
    return gray_img

图像卷积

图像卷积的公式如下所示,\(g\)代表输入的像素矩阵,\(w\)代表的是权重系数矩阵也就是所谓的卷积核kernel。

\[h(x,y) =\sum_{s=-a}^{a} \sum_{t=-b}^{b} w(s,t)g(x-s,y-t) \]

这里有一个很需要值得注意的点,那就是相关操作。相关操作和卷积很类似,相关操作的公式如下:

\[h(x,y) =\sum_{s=-a}^{a} \sum_{t=-b}^{b} w(s,t)g(x+s,y+t) \]

在网络有一些博客文章,在解释卷积的时候,使用的是第一个公式,但是在做计算或者实现代码的时候却用的是第二个公式,这样做是不对的。因为卷积的kernel与相关的kernel相差了\(180^{\circ}\)

但是值得注意的是,在卷积神经网络中,实际上使用的数学公式是相关相关运算,如下图所示。因为在CNN中,kernel的参数是学习过来的,kernel是否翻转并不会影响结果。

理解卷积

前置知识:

卷积定理指出,函数卷积的傅里叶变换是函数傅里叶变换的乘积。至于推导,可以查一下资料。

\[\mathcal{F}\{f * g\}=\mathcal{F}\{f\} \cdot \mathcal{F}\{g\} \]

提一下图像卷积的含义。如果一个如下的均值滤波器对图像进行卷积,从人类的直觉进行出发,可以去除噪声和平滑图像。(在图像中,一般图像噪声的频率比较大,图像边缘部分的频率也比较大。 因此使用均值滤波器可以去除噪声和平滑图像。)

\[1 / 9\left[\begin{array}{lll} 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \end{array}\right] \]

那么为什么会造成这种现象呢?如何从数学的角度来解释均值滤波器的作用呢?

如下所示,图左边是一个一维均值滤波器的函数图像,图右边是均值函数在频域上面的图像。在右边图像上,可以发现一个很明显的特点:频率越高,\(F(\mu)\)越小。

那么如果将\(F(\mu)\)与某另外一个频域上面的函数(比如图像)相乘,显而易见,如果图像的频率越高,则\(F(\mu)\)与之相乘被拖下水的的程度就越大。也就是说,相乘之后,频率低的就被抬上去了,频率高的被拉下去了。

说的细一点,其实从上图可以看到,随着频率的增大,\(F(\mu)\)并不是严格的下降,中间有一个波浪的起伏,这样会在边缘造成一些不好的现象。但是高斯滤波不会有这种情况。后面会介绍高斯滤波。

均值滤波器的二维频域图如下所示:

矩阵点积

下面定义矩阵点积函数。

def __matrix_dot_product(self,matrix,kernel):
    """矩阵点乘 [1,2,3]*[4,5,6] = 1*4 + 2*5 + 3*6 = 32
    
    Args:
        matrix ([type]): [部分图像]
        kernel ([type]): [kernel]

    Returns:
        [type]: [点乘结果]
    """
    if len(matrix) != len(kernel):
        print("点积失败,大小不一致")
    else:
        # 速度快
        return (np.multiply(matrix,kernel)).sum()

        # result = 0
        # for i, row_nums in enumerate(matrix):
        #     for j,num in enumerate(row_nums):
        #         result += num * kernel[i][j]
        # return result 

图像padding

如果不对图像进行padding的话,会造成一个现象,图像越卷越小。在卷积的时候,我们希望卷积后的图像大小与原图像保持一致(CNN网络可能会越卷越小),因此需要对图像进行padding。padding有两种方式,一种在填充0,一种是填充与其距离最近的元素。下图中图像周围虚线部分就是padding的元素。

https://github.com/vdumoulin/conv_arithmetic

下面是实现padding操作的具体函数。实际上,可以直接使用np.pad操作实现。(但是我的作业要求不能使用pad操作,只能自己实现)

    def __padding(self, padding_type:str, image:np.array, padding_w:int, padding_h:int):
        """对图片进行padding

        Args:
            padding_type (str): [padding方式]
            image (np.array): [图片]
            padding_w (int): [宽度pdding]
            padding_h (int): [高度padding,一般来说padding_w = padding_h]

        Returns:
            [type]: [返回padding之后的结果]
        """
        image_w = image.shape[0]
        image_h = image.shape[1]

        padding_image = np.zeros((image_w+padding_w*2,image_h+padding_h*2))
        padding_image[padding_w:padding_w+image_w,padding_h:padding_h+image_h] = image

        if padding_type == 'zero':
            return padding_image

        if padding_type == "replicate": 
            # 补充四个角
            padding_image[0:padding_w+1,0:padding_h+1] = image[0,0]
            padding_image[image_w+padding_w-1:,0:padding_h+1] = image[image_w-1,0]
            padding_image[0:padding_w+1,image_h+padding_h-1:] = image[0,image_h-1]
            padding_image[image_w+padding_w-1:,image_h+padding_h-1:] = image[image_w-1,image_h-1]

            # 补充旁边的元素
            for i in range(padding_w+1,image_w+padding_w-1):
                padding_image[i,0:padding_h] = image[i-padding_w,0]
                padding_image[i,image_h+padding_h:] = image[i-padding_w,image_h-1]
                
            
            for i in range(padding_h+1,image_h+padding_h-1):
                padding_image[0:padding_w,i] = image[0,i-padding_h]
                padding_image[image_w+padding_w:,i] = image[image_w-1,i-padding_h]
            return padding_image

如果想使得卷积之后的结果与原图像一致,padding_w,padding_h为卷积核大小的一半(向下取整,卷积核大小一般是奇数)。比如核的大小是\(5 \times 5\),那么padding的长宽便是\(2\)

图像相关操作

前面说过图像的卷积实际上就是将kernel进行翻转\(180^{\circ}\),然后进行相关运算,因此可以先定义相关操作函数:

def corr2D(self, image:np.array, kernel:np.array, padding:str = 'zero') -> np.array:
    """对图片进行相关运算。

    Args:
        image (np.array): [(*,*)shape的图片]
        kernel (np.array): [kernel,kernel为奇数]
        padding (str, optional): [zero以零填充,replicate以邻近的填充]. Defaults to 'zero'.

    Returns:
        [type]: [description]
    """
    kernel_size_w = kernel.shape[0]
    kernel_size_h = kernel.shape[1]

    image_w,image_h = image.shape
    
    
    padding_w = kernel_size_w // 2
    padding_h = kernel_size_h // 2

    # 将图片padding起来
    padding_image = self.__padding(padding,image,padding_w,padding_h)

    new_image = np.zeros((image_w,image_h))
    for i in range(image_w):
        for j in range(image_h):
            new_image[i][j] = self.__matrix_dot_product(padding_image[i:i+kernel_size_w,j:j+kernel_size_h],kernel)

    return new_image.clip(0,255).astype("uint8")

卷积操作

旋转kernel

旋转kernel的代码很简单,如下所示,通过以下操作可以将行和列翻转(相当于反转了\(180^{\circ}\))。

def flip_180(self, arr: np.array) -> np.array:
    return arr[::-1,::-1]

卷积

将kernel继续宁翻转,然后进行相关运算便是卷积了。

def conv2D(self, image:np.array, kernel:np.array, padding:str = 'zero') -> np.array:
    """二维卷积

    Args:
        image (np.array): [(*,*)shape的图片]
        kernel (np.array): [kernel,kernel为奇数]
        padding (str, optional): [zero以零填充,replicate以邻近的填充]. Defaults to 'zero'.

    Returns:
        [type]: [卷积好的结果]
    """
    return self.corr2D(image,self.flip_180(kernel),padding)

高斯核

二维高斯核的公式如下所示:

\[G(x, y,\sigma_x,\sigma_y)=\frac{1}{2 \pi \sigma_{x}\sigma_{y}} e^{-\left(\frac{x^{2}}{2{\sigma_x}^2} + \frac{y^{2}}{2{\sigma_y}^2}\right)} \]

二维高斯核的频域图如下所示。

下面是二维高斯滤波函数的定义,其中\(\sigma_x=\sigma_y=sig\)。并对卷积核进行归一化,使得所有元素加起来和为1。

    def gauss_2d_kernel(self,sig,m=0):
        """产生高斯核

        Args:
            sig ([type]): [高斯核参数 sigx = sigy]
            m (int, optional): [高斯kernel的大小]. Defaults to 0. if m=0,then m = ceil(3*sig)*2 +1

        Returns:
            [type]: [m*m大小的高斯核]
        """
        fit_m = math.ceil(3 * sig)*2+1

        if m == 0:
            m = fit_m
        if m < fit_m:
            print("你的核的size应该大一点")
        
        # 中心点
        center = m //2
        kernel = np.zeros(shape=(m,m))
        for i in range(m):
            for j in range(m):
                kernel[i][j] = (1/(2*math.pi*sig**2))*math.e**(-((i-center)**2+(j-center)**2)/(2*sig**2))
		# 归一化
        return kernel/(kernel.sum())

结果

灰度转换结果

高斯核卷积

参考

  • 数字图像处理(第三版)

项目地址:xiaohuiduan/image_process (github.com)

posted @ 2021-10-08 22:38  段小辉  阅读(381)  评论(0编辑  收藏  举报