数字图像处理(一)之灰度转换和卷积python实现
使用Python实现数字图像处理中如下功能:
彩色图像转成灰度图像
实现图像的相关&卷积操作
实现图像的高斯核卷积
使用的库和python版本如下:
imageio:2.9.0 用于读取磁盘中的图片文件
numpy:1.20.3 用于矩阵等操作
matplotlib:3.4.2 用于画图
python:3.8.11
读取图像
在进行图像处理操作前,首先需要对图像进行读取。这里使用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图片转成灰度图有两种方式:
gray=R+G+B3
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)=∑s=−aa∑t=−bbw(s,t)g(x−s,y−t)
这里有一个很需要值得注意的点,那就是相关操作。相关操作和卷积很类似,相关操作的公式如下:
h(x,y)=∑s=−aa∑t=−bbw(s,t)g(x+s,y+t)
在网络有一些博客文章,在解释卷积的时候,使用的是第一个公式,但是在做计算或者实现代码的时候却用的是第二个公式,这样做是不对的。因为卷积的kernel与相关的kernel相差了180∘。
但是值得注意的是,在卷积神经网络中,实际上使用的数学公式是相关相关运算,如下图所示。因为在CNN中,kernel的参数是学习过来的,kernel是否翻转并不会影响结果。
理解卷积
前置知识:
卷积定理指出,函数卷积的傅里叶变换是函数傅里叶变换的乘积。至于推导,可以查一下资料。
F{f∗g}=F{f}⋅F{g}
提一下图像卷积的含义。如果一个如下的均值滤波器对图像进行卷积,从人类的直觉进行出发,可以去除噪声和平滑图像。(在图像中,一般图像噪声的频率比较大,图像边缘部分的频率也比较大。 因此使用均值滤波器可以去除噪声和平滑图像。)
1/9⎡⎣⎢111111111⎤⎦⎥
那么为什么会造成这种现象呢?如何从数学的角度来解释均值滤波器的作用呢?
如下所示,图左边是一个一维均值滤波器的函数图像,图右边是均值函数在频域上面的图像。在右边图像上,可以发现一个很明显的特点:频率越高,F(μ)越小。
那么如果将F(μ)与某另外一个频域上面的函数(比如图像)相乘,显而易见,如果图像的频率越高,则F(μ)与之相乘被拖下水的的程度就越大。也就是说,相乘之后,频率低的就被抬上去了,频率高的被拉下去了。
说的细一点,其实从上图可以看到,随着频率的增大,F(μ)并不是严格的下降,中间有一个波浪的起伏,这样会在边缘造成一些不好的现象。但是高斯滤波不会有这种情况。后面会介绍高斯滤波。
均值滤波器的二维频域图如下所示:
矩阵点积
下面定义矩阵点积函数。
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的元素。
下面是实现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×5,那么padding的长宽便是2。
图像相关操作
前面说过图像的卷积实际上就是将kernel进行翻转180∘,然后进行相关运算,因此可以先定义相关操作函数:
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∘)。
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,σx,σy)=12πσxσye−(x22σx2+y22σy2)
二维高斯核的频域图如下所示。
下面是二维高斯滤波函数的定义,其中σx=σ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())
结果
灰度转换结果
高斯核卷积
参考
数字图像处理(第三版)
作者: 段小辉
出处: https://www.cnblogs.com/xiaohuiduan