• python实现图像添加噪声、噪声处理、滤波器代码实现

    目录

    加载图像添加噪声

    图像傅里叶变换和反变换并可视化

    图像处理---高通滤波、低通滤波、带通滤波

    低通滤波器---Butterworth低通滤波器、理想低通滤波器、高斯低通滤波器

    加载图像添加噪声

    • 高斯噪声是指它的概率密度函数服从高斯分布（即正态分布）的一类噪声
    • 椒盐噪声也称为脉冲噪声，是图像中经常见到的一种噪声，它是一种随机出现的白点或者黑点，可能是亮的区域有黑色像素或是在暗的区域有白色像素（或是两者皆有）
    • 乘性噪声一般由信道不理想引起，它们与信号的关系是相乘，信号在它在，信号不在他也就不在
    1. import numpy as np
    2. import cv2
    3. import matplotlib.pyplot as plt
    4. import skimage
    5. from skimage import io
    6. import random
    7.  
    8. #img = cv2.imread('E:/python/CSDN/image/1.bmp',cv2.IMREAD_GRAYSCALE)
    9. img = plt.imread('E:/python/CSDN/image/5.bmp')
    10.  
    11. fig=plt.figure(figsize=(10, 50))
    12. #显示原图
    13. plt.subplot(12,3,1),plt.imshow(img,'gray'),plt.title('original')
    14.  
    15. def addGaussNoise(origin,var=0.0005):#添加高斯噪声函数
    16.     #var = random.uniform(0.0001, 0.04)
    17.     noisy = skimage.util.random_noise(origin, mode='gaussian', var=var)
    18.     return noisy
    19.  
    20. def addSaltNoise(origin,var=0.01):#添加椒盐噪声函数
    21.     #var = random.uniform(0.01, 0.2)
    22.     noisy = skimage.util.random_noise(origin, mode='s&p', amount=var)
    23.     return noisy
    24.  
    25. def addSpeckleNoise(origin,var=0.001):#添加乘法噪声函数
    26.     #var = random.uniform(0.0001, 0.04)
    27.     noisy = skimage.util.random_noise(origin, mode='speckle', var=var)
    28.     return noisy
    29.  
    30. img = addGaussNoise(img)
    31. #img = addSaltNoise(img)
    32. #img = addSpeckleNoise(img)
    33. #显示添加高斯噪声的原图
    34. plt.subplot(12,3,4),plt.imshow(img,'gray'),plt.title('img_add_gaussin')

    图像傅里叶变换和反变换并可视化

    1. #进行傅立叶变换，并显示结果
    2. fft2 = np.fft.fft2(img)
    3. plt.subplot(12,3,2),plt.imshow(np.abs(fft2),'gray'),plt.title('fft2')
    4.  
    5. #将图像变换的原点移动到频域矩形的中心，并显示效果
    6. shift2center = np.fft.fftshift(fft2)
    7. plt.subplot(12,3,3),plt.imshow(np.abs(shift2center),'gray'),plt.title('shift2center')
    8.  
    9. #保存图片
    10. #cv2.imwrite("E:/python/CSDN/image/fft.jpg",np.abs(fft2))
    11. #cv2.imwrite("E:/python/CSDN/image/fftshift.jpg",np.abs(shift2center))
    12.  
    13. #由于傅里叶系数的动态范围过大，无法在屏幕上显示，为了便于观察，利用对数变换将这些较大的系数值变小。经过对数变换之后，较高的数值会变成白点，而较小的数值变为黑点。为了将灰度值可视化。
    14.  
    15. #对傅立叶变换的结果进行对数变换，并显示效果
    16. log_fft2 = np.log(1 + np.abs(fft2))
    17. plt.subplot(12,3,5),plt.imshow(log_fft2,'gray'),plt.title('log_fft2')
    18.  
    19. #对中心化后的结果进行对数变换，并显示结果
    20. log_shift2center = np.log(1 + np.abs(shift2center))
    21. plt.subplot(12,3,6),plt.imshow(log_shift2center,'gray'),plt.title('log_shift2center')
    22.  
    23. #原图反变换
    24. f_image = np.fft.ifftshift(shift2center)
    25. image_new = np.fft.ifft2(f_image)   # 反变换的结果是复数
    26. image_new = np.abs(image_new)

    图像处理---高通滤波、低通滤波、带通滤波

    •     高通滤波：高频信息通过，低频信息被阻挡；
    •     低通滤波：低频信息通过，高频信息被阻挡；
    •     带通滤波：介于低频和高频之间的一带信息通过，其它信息被阻挡；
    1. #区域越小越接近原图
    2. up_high = 10
    3. left_high = 15
    4. # 掩膜-中心为0-高通滤波
    5. rows,cols = img.shape
    6. print("high pass{},{}".format(rows,cols))
    7. mask0 = np.ones(img.shape)
    8. mask0[int(rows/2-up_high):int(rows/2+up_high), int(cols/2-left_high):int(cols/2+left_high)] = 0
    9. fshift_mask0 = shift2center*mask0
    10. #plt.subplot(12,3,8),plt.imshow(np.abs(fshift_mask0),'gray'),plt.title('fshift_mask0')
    11. # 二维傅里叶反变换
    12. f_image_mask0 = np.fft.ifftshift(fshift_mask0)
    13. image_new0 = np.fft.ifft2(f_image_mask0)   # 反变换的结果是复数
    14. image_new0 = np.abs(image_new0)
    15. plt.subplot(12,3,8),plt.imshow(np.abs(image_new0),'gray'),plt.title('highPassFilter')
    16.  
    17. #保存图片
    18. #cv2.imwrite("E:/python/CSDN/image/fshift_mask_high.jpg",np.abs(fshift_mask0))
    19. #cv2.imwrite("E:/python/CSDN/image/image_new_high.jpg",np.abs(image_new0))
    20.  
    21. #区域越大越接近原图
    22. up_low = 50
    23. left_low = 15
    24. # 掩膜-中心为1-低通滤波
    25. rows,cols = img.shape
    26. print("low pass {},{}".format(rows,cols))
    27. mask1 = np.zeros(img.shape)
    28. mask1[int(rows/2-up_low):int(rows/2+up_low), int(cols/2-left_low):int(cols/2+left_low)] = 1
    29. fshift_mask1 = shift2center*mask1
    30. #plt.subplot(12,3,10),plt.imshow(np.abs(fshift_mask1),'gray'),plt.title('fshift_mask1')
    31. # 二维傅里叶反变换
    32. f_image_mask1 = np.fft.ifftshift(fshift_mask1)
    33. image_new1 = np.fft.ifft2(f_image_mask1)   # 反变换的结果是复数
    34. image_new1 = np.abs(image_new1)
    35. plt.subplot(12,3,9),plt.imshow(np.abs(image_new1),'gray'),plt.title('lowPassFilter')
    36.  
    37. # 带通滤波
    38. w = 50 #带宽
    39. radius = 20 #带中心到频率平面原点的距离
    40. rows,cols = img.shape
    41. print("low pass {},{}".format(rows,cols))
    42. mask1 = np.ones(img.shape)
    43. for i in range(0, rows):
    44.     for j in range(0, cols):
    45.         # 计算(i, j)到中心点的距离
    46.         from math import sqrt
    47.         d = sqrt(pow(i - rows, 2) + pow(j - cols, 2))
    48.         if radius - w / 2 < d < radius + w / 2:
    49.             mask1[i, j] = 0
    50.         else:
    51.             mask1[i, j] = 1
    52.  
    53. fshift_mask1 = shift2center*mask1
    54. #plt.subplot(12,3,10),plt.imshow(np.abs(fshift_mask1),'gray'),plt.title('fshift_mask1')
    55. # 二维傅里叶反变换
    56. f_image_mask1 = np.fft.ifftshift(fshift_mask1)
    57. image_new1 = np.fft.ifft2(f_image_mask1)   # 反变换的结果是复数
    58. image_new1 = np.abs(image_new1)
    59. plt.subplot(12,3,7),plt.imshow(np.abs(image_new1),'gray'),plt.title('bandPassFilter')

    低通滤波器---Butterworth低通滤波器、理想低通滤波器、高斯低通滤波器

    低通滤波器的功能是让低频率通过而滤掉或衰减高频，其作用是过滤掉包含在高频中的噪声。即低通滤波的效果是图像去噪声平滑增强，但同时也抑制了图像的边界即过滤掉图像细节，造成图像不同程序上的模糊。

    • 理想低通滤波器的滤波非常尖锐
    • 高斯低通滤波器的滤波则非常平滑
    • 巴特沃斯滤波器介于两者之间，当巴特沃斯低通滤波器的阶数较高时，接近于理想低通滤波器；当巴特沃斯低通滤波器的阶数较高时，则接近于高斯低通滤波器。
    1. # Butterworth低通滤波器的实现函数的定义
    2. def ButterworthPassFilter(image, d, n): # 定义一个Butterworth低通滤波器
    3.     f = np.fft.fft2(image)              # 快速傅里叶变换算法得到频率分布
    4.     fshift = np.fft.fftshift(f)         # 将图像中的低频部分移动到图像的中心，默认是在左上角
    5.     # fft结果是复数, 其绝对值结果是振幅；取对数的目的是将数据变换到0~255
    6.     fimg = np.log(np.abs(fshift))
    7.  
    8.     def make_transform_matrix(d):     
    9.         # 创建一个与输入图像同大小的全0矩阵，用于存储变化后的图像
    10.         transform_matrix = np.zeros(image.shape)
    11.         # 中心点值的计算，元组形式
    12.         center_point = tuple(map(lambda x: (x - 1) / 2, fimg.shape))
    13.         for i in range(transform_matrix.shape[0]):              # 行遍历
    14.             for j in range(transform_matrix.shape[1]):          # 列遍历
    15.                 def cal_distance(pa, pb):                       # 欧拉距离计算函数的定义
    16.                     from math import sqrt
    17.                     dis = sqrt((pa[0] - pb[0]) ** 2 + (pa[1] - pb[1]) ** 2)
    18.                     return dis
    19.                 dis = cal_distance(center_point, (i, j))        # 求出每个点与中心点的距离
    20.                 # 巴特沃斯低通滤波的数学公式实现
    21.                 transform_matrix[i, j] = 1 / (1 + (dis / d) ** (2 * n)) 
    22.         return transform_matrix
    23.  
    24.     d_matrix = make_transform_matrix(d)                                  # 调用自定义函数
    25.     new_img = np.abs(np.fft.ifft2(np.fft.ifftshift(fshift * d_matrix)))  # 生成新图
    26.     return new_img
    27.  
    28. print("ButterworthPassFilter {}".format(img.shape))
    29. butter_25_5 = ButterworthPassFilter(img,15, 5)  # Butterworth低通滤波处理
    30. plt.subplot(12,3,10),plt.imshow(butter_25_5,'gray'),plt.title('ButterworthPassFilter')
    31. #cv2.imwrite("E:/python/CSDN/image/ButterworthPassFilter.jpg",butter_25_5)
    32.  
    33.  
    34. # 理想低通滤波器的实现函数的定义
    35. def perfectPassFilter(image, d): # 定义一个理想低通滤波器
    36.     f = np.fft.fft2(image)              # 快速傅里叶变换算法得到频率分布
    37.     fshift = np.fft.fftshift(f)         # 将图像中的低频部分移动到图像的中心，默认是在左上角
    38.     # fft结果是复数, 其绝对值结果是振幅；取对数的目的是将数据变换到0~255
    39.     fimg = np.log(np.abs(fshift))
    40.  
    41.     def make_transform_matrix(d):     
    42.         # 创建一个与输入图像同大小的全0矩阵，用于存储变化后的图像
    43.         transform_matrix = np.zeros(image.shape)
    44.         # 中心点值的计算，元组形式
    45.         center_point = tuple(map(lambda x: (x - 1) / 2, fimg.shape))
    46.         for i in range(transform_matrix.shape[0]):              # 行遍历
    47.             for j in range(transform_matrix.shape[1]):          # 列遍历
    48.                 def cal_distance(pa, pb):                       # 欧拉距离计算函数的定义
    49.                     from math import sqrt
    50.                     dis = sqrt((pa[0] - pb[0]) ** 2 + (pa[1] - pb[1]) ** 2)
    51.                     return dis
    52.                 dis = cal_distance(center_point, (i, j))        # 求出每个点与中心点的距离
    53.                 # 理想低通滤波
    54.                 if dis<=d:  #根据理想低通滤波器产生公式,当D(i,j)<=D0,置为1 
    55.                     transform_matrix[i, j] = 1
    56.                 
    57.         return transform_matrix
    58.  
    59.     d_matrix = make_transform_matrix(d)                                  # 调用自定义函数
    60.     new_img = np.abs(np.fft.ifft2(np.fft.ifftshift(fshift * d_matrix)))  # 生成新图
    61.     return new_img
    62.  
    63. print("perfectPassFilter {}".format(img.shape))
    64. perfectPass = perfectPassFilter(img,20)  # 理想低通滤波处理
    65. plt.subplot(12,3,11),plt.imshow(perfectPass,'gray'),plt.title('perfectPassFilter')
    66. #cv2.imwrite("E:/python/CSDN/image/perfectPassFilter.jpg",perfectPass)
    67.  
    68. # 高斯低通滤波器的实现函数的定义
    69. def gaussinlowPassFilter(image, d): # 定义一个高斯低通滤波器
    70.     f = np.fft.fft2(image)              # 快速傅里叶变换算法得到频率分布
    71.     fshift = np.fft.fftshift(f)         # 将图像中的低频部分移动到图像的中心，默认是在左上角
    72.     # fft结果是复数, 其绝对值结果是振幅；取对数的目的是将数据变换到0~255
    73.     fimg = np.log(np.abs(fshift))
    74.  
    75.     def make_transform_matrix(d):     
    76.         # 创建一个与输入图像同大小的全0矩阵，用于存储变化后的图像
    77.         transform_matrix = np.zeros(image.shape)
    78.         # 中心点值的计算，元组形式
    79.         center_point = tuple(map(lambda x: (x - 1) / 2, fimg.shape))
    80.         for i in range(transform_matrix.shape[0]):              # 行遍历
    81.             for j in range(transform_matrix.shape[1]):          # 列遍历
    82.                 def cal_distance(pa, pb):                       # 欧拉距离计算函数的定义
    83.                     from math import sqrt
    84.                     dis = sqrt((pa[0] - pb[0]) ** 2 + (pa[1] - pb[1]) ** 2)
    85.                     return dis
    86.                 dis = cal_distance(center_point, (i, j))        # 求出每个点与中心点的距离
    87.                 # 高斯低通滤波
    88.                 from math import exp
    89.                 transform_matrix[i, j] = exp(-(dis*dis)/(2*(d**2))); #根据高斯低通滤波器公式H(u,v)=e^-[D^2(u,v)/2*D0^2]
    90.                 
    91.         return transform_matrix
    92.  
    93.     d_matrix = make_transform_matrix(d)                                  # 调用自定义函数
    94.     new_img = np.abs(np.fft.ifft2(np.fft.ifftshift(fshift * d_matrix)))  # 生成新图
    95.     return new_img
    96.  
    97. print("gaussinlowPassFilter {}".format(img.shape))
    98. gaussinlowPassFilter = gaussinlowPassFilter(img,20)  # 高斯低通滤波处理
    99. plt.subplot(12,3,12),plt.imshow(gaussinlowPassFilter,'gray'),plt.title('gaussinlowPassFilter')

     各阶段图像示例：

     

  • 相关阅读:
    Set与二分法效率
    SpringCloud - 微服务理论基础
    多方面浅谈互联网技术
    5分钟搞懂分布式可观测性
    16. 文件上传
    Windows Server - DHCP服务介绍及搭建
    electron使用typescript
    互联网Java工程师面试题·MySQL 篇·第二弹
    【数据结构】排序（1）插入排序、选择排序
    Go语言实现原理——Map实现原理
  • 原文地址：https://blog.csdn.net/L888666Q/article/details/126975423