关于图像滤波

最新推荐文章于 2025-06-28 23:49:47 发布

原创最新推荐文章于 2025-06-28 23:49:47 发布 · 628 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#opencv #计算机视觉

1.加入噪声

在学习滤波之前，我们要先准备一些带有噪声的图片

# 导入 skimage 库，用于图像处理和添加噪声
import skimage
# 导入 OpenCV 库，用于读取图像
import cv2
# 导入 matplotlib.pylab 库并简称为 plt，用于图像的可视化
import matplotlib.pylab as plt
# 设置 matplotlib 使用黑体字体来正常显示中文
plt.rcParams['font.sans-serif'] = ['SimHei'] 
# 解决 matplotlib 中负号显示为方块的问题
plt.rcParams['axes.unicode_minus'] = False 
# 使用 OpenCV 以灰度模式读取指定路径的图像
img = cv2.imread('001.bmp', 0)
# 将图像像素值归一化到 0 到 1 之间
img = img / 255

# 添加随机高斯噪声
# 使用 skimage 的 random_noise 函数添加高斯噪声，均值为 0，方差为 0.05
img_g = skimage.util.random_noise(img, 'gaussian', mean=0, var=0.05)
# 添加随机椒盐噪声
# 使用 skimage 的 random_noise 函数添加椒盐噪声
img_s = skimage.util.random_noise(img, 's&p')
# 添加随机均匀噪声
# 使用 skimage 的 random_noise 函数添加均匀噪声
img_j = skimage.util.random_noise(img, 'speckle')

plt.subplot(141)
plt.imshow(img,'gray')
plt.title('原图')
plt.subplot(142)
plt.imshow(img_g,'gray')
plt.title('加入高斯噪声后图像')
plt.subplot(143)
plt.imshow(img_s,'gray')
plt.title('加入椒盐噪声后图像')
plt.subplot(144)
plt.imshow(img_j,'gray')
plt.title('加入均匀噪声后图像')
plt.show()

在图像处理里，给图像添加噪声是常见操作。下面这段 Python 代码借助`skimage`、`OpenCV`和`matplotlib`库实现了该功能。先读取`001.bmp`图像并将像素值归一化到 0 到 1 之间，接着利用`skimage`的`random_noise`函数分别添加高斯、椒盐和均匀噪声。最后使用`matplotlib`将原图和加噪后的图像一同展示，方便对比不同噪声对图像的影响。

2.均值滤波

均值滤波的核心思想是基于邻域平均。对于图像中的每个像素，它会考虑其周围一个邻域（通常是一个矩形区域）内所有像素的值，然后计算这些像素值的平均值，并用这个平均值来替换该像素原来的值。

import cv2
import matplotlib.pyplot as plt
import skimage.util
import numpy as np

plt.rcParams['font.sans-serif'] = ['SimHei'] 
plt.rcParams['axes.unicode_minus'] = False 

# 读取 'char.bmp' 图像，并检查是否读取成功
img = cv2.imread('001.bmp', 0)


# 为图像添加高斯噪声
img_g = skimage.util.random_noise(img, 'gaussian')
# 将添加噪声后的图像转换为 uint8 类型
img_g = np.array(255 * img_g, dtype=np.uint8)

# 为图像添加椒盐噪声
img_s = skimage.util.random_noise(img, 's&p')
# 将添加噪声后的图像转换为 uint8 类型
img_s = np.array(255 * img_s, dtype=np.uint8)

# 为图像添加均匀噪声
img_j = skimage.util.random_noise(img,'speckle')
# 将添加噪声后的图像转换为 uint8 类型
img_j = np.array(255 * img_j, dtype=np.uint8)

# 对添加高斯噪声的图像进行 3x3 均值滤波
img_g_l = cv2.blur(img_g, (3, 3))
# 对添加椒盐噪声的图像进行 3x3 均值滤波
img_s_l = cv2.blur(img_s, (3, 3))
# 对添加均匀噪声的图像进行 3x3 均值滤波
img_j_l = cv2.blur(img_j, (3, 3))
# 对添加高斯噪声的图像进行 5x5 均值滤波
img_g_l1 = cv2.blur(img_g, (5, 5))
# 对添加椒盐噪声的图像进行 5x5 均值滤波
img_s_l1 = cv2.blur(img_s, (5, 5))
# 对添加均匀噪声的图像进行 5x5 均值滤波
img_j_l1 = cv2.blur(img_j, (5, 5))

# 绘制子图
plt.subplot(331)
plt.imshow(img_g, 'gray')
plt.title('带高斯噪声图片')
plt.subplot(334)
plt.imshow(img_s, 'gray')
plt.title('带椒盐噪声图片')
plt.subplot(337)
plt.imshow(img_j, 'gray')
plt.title('带均匀噪声图片')
plt.subplot(332)
plt.imshow(img_g_l, 'gray')
plt.title('均值滤波后图像(3*3)')
plt.subplot(333)
plt.imshow(img_g_l1, 'gray')
plt.title('均值滤波后图像(5*5)')
plt.subplot(335)
plt.imshow(img_s_l, 'gray')
plt.title('均值滤波后图像(3*3)')
plt.subplot(336)
plt.imshow(img_s_l1, 'gray')
plt.title('均值滤波后图像(5*5)')
plt.subplot(338)
plt.imshow(img_j_l, 'gray')
plt.title('均匀噪声 3x3 均值滤波后图像')
plt.subplot(339)
plt.imshow(img_j_l1, 'gray')
plt.title('均匀噪声 5x5 均值滤波后图像')

# 在所有子图绘制完成后调用 plt.show()
plt.show()

利用cv2、skimage.util、numpy和matplotlib.pyplot库，先读取001.bmp灰度图像，再用skimage.util.random_noise函数添加高斯、椒盐和均匀噪声，并将噪声图像转换为uint8类型。之后，针对添加不同噪声的图像，分别进行 3x3 和 5x5 的均值滤波，使用cv2.blur函数实现。最后，通过matplotlib.pyplot绘制子图，直观呈现带噪声图像以及均值滤波后的图像效果，帮助我们清晰对比不同噪声和滤波参数对图像的影响。

3.高斯滤波

高斯滤波基于高斯函数，它是一种加权平均滤波方法。在对图像进行处理时，对于图像中的每个像素，会根据其邻域内像素与该像素的距离，使用高斯函数为邻域内的像素分配不同的权重，离中心像素越近的像素权重越大，离得越远权重越小。然后计算这些邻域像素的加权平均值，用该值替换中心像素的值，从而实现图像的平滑处理。

高斯滤波在python的使用方式：使用cv2.GaussianBlur函数进行高斯滤波，(5, 5)表示邻域的大小，0表示高斯核的标准差，当标准差为 0 时，会根据邻域大小自动计算合适的标准差。

# 空域高斯滤波
import cv2
import matplotlib.pyplot as plt
import skimage.util
import numpy as np

img = cv2.imread('001.bmp', 0)
img_g = cv2.imread('001_g.bmp', 0)
img_s = cv2.imread('001_s.bmp', 0)

# 为原始图像添加均匀噪声
img_j = skimage.util.random_noise(img,'speckle')
img_j = np.array(255 * img_j, dtype=np.uint8)

# 对带有高斯噪声的图像 img_g 进行高斯滤波操作
# cv2.GaussianBlur 是 OpenCV 中用于高斯滤波的函数
# 第一个参数 img_g 是输入的带有高斯噪声的图像
# 第二个参数 (3, 3) 是高斯核的大小，这里表示 3x3 的核
# 第三个参数 0 是 X 方向的高斯核标准差，设置为 0 时，OpenCV 会根据核大小自动计算
# 第四个参数 5 是 Y 方向的高斯核标准差，这里指定为 5
img_g_l = cv2.GaussianBlur(img_g, (3, 3), 0, 5)

# 对带有椒盐噪声的图像进行高斯滤波操作
# 输入图像为 img_s，核大小为 3x3
# X 方向标准差为 0，Y 方向标准差为 5
img_s_l = cv2.GaussianBlur(img_s, (3, 3), 0, 5)

# 对带有均匀噪声的图像进行 3x3 高斯滤波
img_j_l = cv2.GaussianBlur(img_j, (3, 3), 0, 5)

# 再次对带有高斯噪声的图像 img_g 进行高斯滤波
# 这次使用 5x5 的高斯核
# X 方向标准差为 0，Y 方向标准差为 5
img_g_l1 = cv2.GaussianBlur(img_g, (5, 5), 0, 5)

# 再次对带有椒盐噪声的图像 img_s 进行高斯滤波
# 使用 5x5 的高斯核
# X 方向标准差为 0，Y 方向标准差为 5
img_s_l1 = cv2.GaussianBlur(img_s, (5, 5), 0, 5)

# 对带有均匀噪声的图像进行 5x5 高斯滤波
img_j_l1 = cv2.GaussianBlur(img_j, (5, 5), 0, 5)

# 调整子图布局为 3x3
plt.figure(figsize=(12, 12))

plt.subplot(331)
plt.imshow(img_g, 'gray')
plt.title('带高斯噪声图片')
plt.subplot(334)
plt.imshow(img_s, 'gray')
plt.title('带椒盐噪声图片')
plt.subplot(337)
plt.imshow(img_j, 'gray')
plt.title('带均匀噪声图片')

plt.subplot(332)
plt.imshow(img_g_l, 'gray')
plt.title('高斯滤波后图像(3*3) - 高斯噪声')
plt.subplot(335)
plt.imshow(img_s_l, 'gray')
plt.title('高斯滤波后图像(3*3) - 椒盐噪声')
plt.subplot(338)
plt.imshow(img_j_l, 'gray')
plt.title('高斯滤波后图像(3*3) - 均匀噪声')

plt.subplot(333)
plt.imshow(img_g_l1, 'gray')
plt.title('高斯滤波后图像(5*5) - 高斯噪声')
plt.subplot(336)
plt.imshow(img_s_l1, 'gray')
plt.title('高斯滤波后图像(5*5) - 椒盐噪声')
plt.subplot(339)
plt.imshow(img_j_l1, 'gray')
plt.title('高斯滤波后图像(5*5) - 均匀噪声')

plt.show()

在图像处理领域，滤波是一项关键技术，有助于去除噪声、优化图像质量。今天，我用 Python 和 OpenCV 库对图像进行高斯滤波处理，跟大家分享一下过程。

我读取了三张特殊图像，一张带有高斯噪声，一张带有均匀噪声，另一张带有椒盐噪声。利用 cv2.GaussianBlur 函数对它们进行处理，分别尝试了 3x3 和 5x5 两种不同大小的高斯核，并且将 X 方向的高斯核标准差设为 0，让 OpenCV 自动计算，Y 方向标准差设为 5。

最后，借助 matplotlib 库把原始噪声图像和滤波后的图像绘制在同一张图上。通过对比能直观看到，不同大小的高斯核在处理不同噪声时效果各异。大家也可以动手试试，调整参数，看看还能发现什么有趣的结果。

4.非线性中值滤波器

中值滤波器的核心原理是基于排序统计。对于图像中的每个像素，它会考虑该像素邻域内（通常是一个矩形区域）所有像素的值，将这些值进行排序，然后取排序后的中间值作为该像素的新值。例如，在一个 3x3 的邻域中，有 9 个像素值，将它们从小到大排序后，第 5 个值就是中间值，用这个中间值替换中心像素原来的值。

import cv2
import matplotlib.pyplot as plt
img=cv2.imread('001.bmp',0)
# 读取带椒盐噪声的图像，以灰度模式读取
img_s = cv2.imread('001_s.bmp', 0)
# 对带高斯噪声的图像 img_g 进行 3x3 中值滤波
img_g_l = cv2.medianBlur(img_g, 3)
# 对带椒盐噪声的图像 img_s 进行 3x3 中值滤波
img_s_l = cv2.medianBlur(img_s, 3)
# 对带高斯噪声的图像 img_g 进行 5x5 中值滤波
img_g_l1 = cv2.medianBlur(img_g, 5)
# 对带椒盐噪声的图像 img_s 进行 5x5 中值滤波
img_s_l1 = cv2.medianBlur(img_s, 5)
# 为图像增加均匀噪声
img_j = skimage.util.random_noise(img,'speckle')
img_j = np.array(255 * img_j, dtype=np.uint8)
# 对带均匀噪声的图像 img_g 进行 3x3 中值滤波
img_j_1 = cv2.medianBlur(img_j, 3)
# 对带均匀噪声的图像 img_g 进行 5x5 中值滤波
img_j_11 = cv2.medianBlur(img_j, 5)
plt.subplot(331)
plt.imshow(img_g,'gray')
plt.title('带高斯噪声图片')
plt.subplot(334)
plt.imshow(img_s,'gray')
plt.title('带椒盐噪声图片')
plt.subplot(332)
plt.imshow(img_g_l,'gray')
plt.title('中值滤波后图像(3*3)')
plt.subplot(333)
plt.imshow(img_g_l1,'gray')
plt.title('中值滤波后图像(5*5)')
plt.subplot(335)
plt.imshow(img_s_l,'gray')
plt.title('中值滤波后图像(3*3)')
plt.subplot(336)
plt.imshow(img_s_l1,'gray')
plt.title('中值滤波后图像(5*5)')
plt.subplot(337)
plt.imshow(img_j,'gray')
plt.title('带均匀噪声图片')
plt.subplot(338)
plt.imshow(img_j_1,'gray')
plt.title('中值滤波后图像(3*3)')
plt.subplot(339)
plt.imshow(img_j_11,'gray')
plt.title('中值滤波后图像(5*5)')
plt.show()

实验开始，我选用了一张基础图像，分别获取了带有椒盐噪声、高斯噪声以及添加了均匀噪声的图像版本。随后，使用中值滤波函数cv2.medianBlur，对这些噪声图像分别进行 3x3 和 5x5 窗口大小的中值滤波操作。窗口大小的变化，就像是调整了筛选像素值的范围，对滤波效果有着直接的影响。

完成滤波后，通过matplotlib库将原始噪声图像与滤波后的图像一一呈现。从展示的结果中，我们能清晰看到，中值滤波对于椒盐噪声有着显著的抑制作用，原本杂乱的椒盐噪点被有效去除，图像变得干净许多。在处理高斯噪声和均匀噪声时，虽然不能像去除椒盐噪声那般完美，但也在一定程度上降低了噪声的干扰，图像的清晰度和视觉效果得到了提升。同时，对比不同窗口大小的滤波结果，能发现 5x5 窗口在平滑图像方面效果更明显，不过也可能会损失一些细节；3x3 窗口则在保留细节上稍胜一筹。

5.空域锐化滤波

图像在传输或处理过程中，可能会变得模糊。空域锐化滤波的核心思路是增强图像中灰度突变的部分，也就是边缘和细节，让图像看起来更清晰、更有层次感。它主要基于微分运算，因为在图像中，边缘处的灰度变化剧烈，通过对图像进行微分处理，可以突出这些灰度变化，从而实现锐化效果。

import cv2
import matplotlib.pyplot as plt
import numpy as np
img=cv2.imread('001.bmp',0)
# Roberts 算子部分，用于图像的边缘检测
# 定义 Roberts 算子的 x 方向卷积核
Robertx = np.array([[-1, 0], [0, 1]])
# 定义 Roberts 算子的 y 方向卷积核
Roberty = np.array([[0, -1], [1, 0]])
# 使用 cv2.filter2D 函数将 Roberts x 方向卷积核应用到图像上
# -1 表示输出图像的数据类型与输入图像相同
img_x = cv2.filter2D(img, -1, Robertx)
# 使用 cv2.filter2D 函数将 Roberts y 方向卷积核应用到图像上
img_y = cv2.filter2D(img, -1, Roberty)
# 计算 Roberts 算子处理后的图像，通过计算 x 和 y 方向的绝对值之和
img_r = abs(img_x) + abs(img_y)

# Prewitt 算子部分，用于图像的边缘检测
# 定义 Prewitt 算子的 x 方向卷积核
Prewittx = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]])
# 定义 Prewitt 算子的 y 方向卷积核
Prewitty = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]])
# 使用 cv2.filter2D 函数将 Prewitt x 方向卷积核应用到图像上
img_x = cv2.filter2D(img, -1, Prewittx)
# 使用 cv2.filter2D 函数将 Prewitt y 方向卷积核应用到图像上
img_y = cv2.filter2D(img, -1, Prewitty)
# 计算 Prewitt 算子处理后的图像，通过计算 x 和 y 方向的绝对值之和
img_p = abs(img_x) + abs(img_y)

# Sobel 算子部分，用于图像的边缘检测
# 使用 cv2.Sobel 函数对图像进行边缘检测
# -1 表示输出图像的数据类型与输入图像相同
# 第一个 1 表示在 x 方向求导的阶数
# 第二个 1 表示在 y 方向求导的阶数
img_s = cv2.Sobel(img, -1, 1, 1)
plt.subplot(141)
plt.imshow(img,'gray')
plt.title('原图')
plt.subplot(142)
plt.imshow(img_r,'gray')
plt.title('Roberts 算子滤波后图')
plt.subplot(143)
plt.imshow(img_p,'gray')
plt.title('Prewitt 算子滤波后图')
plt.subplot(144)
plt.imshow(img_s,'gray')
plt.title('Sobel 算子滤波后图')
plt.show()

在图像处理的领域中，边缘检测是极为关键的基础操作，它帮助我们提取图像中目标物体的轮廓，为后续的图像分析和理解奠定基础。今天，通过一段 Python 代码，我对 Roberts、Prewitt 和 Sobel 这三种常见的边缘检测算子进行了实践。

我先读取了一张灰度图像，这张图像将作为我们进行边缘检测的原始素材。代码中，对于 Roberts 算子，分别定义了 x 和 y 方向的卷积核，通过对图像在这两个方向上进行卷积操作，并将结果合并，得到了 Roberts 算子处理后的图像。Prewitt 算子同样如此，精心构建 x 和 y 方向的卷积核，应用到图像上后计算出对应的边缘检测结果。而 Sobel 算子，直接调用 OpenCV 中的函数，指定在 x 和 y 方向上的求导阶数，完成对图像的边缘检测。

最后，借助 matplotlib 库将原始图像以及经过这三种算子滤波后的图像一同展示出来。从展示的结果中，我们能直观地看到不同算子对图像边缘检测的效果差异。Roberts 算子相对更突出图像中尖锐的边缘部分；Prewitt 算子检测出的边缘较为平滑；Sobel 算子则在一定程度上兼顾了边缘的准确性和连续性。

6.对均值滤波，高斯滤波和中值滤波器的比较

在上面我们学习并使用了三种滤波器，可是他们孰优孰劣还是各有千秋呢？让我们华山论剑，拭目以待！！！

import skimage
import cv2
import matplotlib.pylab as plt
plt.rcParams['font.sans-serif'] = ['SimHei'] 
plt.rcParams['axes.unicode_minus'] = False 
img = cv2.imread('001.bmp', 0)
img = img / 255
# 添加随机椒盐噪声
img_s = skimage.util.random_noise(img,'salt')
# 添加随机均匀噪声
img_sj = skimage.util.random_noise(img_s,'speckle')
# 均值滤波
img_m = cv2.blur(img_sj, (5, 5))
# 高斯滤波
img_mg = cv2.GaussianBlur(img_m, (5, 5), 0, 5)
img_g = cv2.GaussianBlur(img_sj, (5, 5), 0, 5)

# 中值滤波之前将图像数据类型转换为 uint8
img_mg = np.array(255 * img_mg, dtype=np.uint8)
img_sj = np.array(255 * img_sj, dtype=np.uint8)

# 中值滤波
img_mgd = cv2.medianBlur(img_mg, 5)
img_d = cv2.medianBlur(img_sj, 5)

# 显示图像
plt.subplot(241)
plt.imshow(img, cmap='gray')  # 添加 cmap='gray' 确保以灰度显示
plt.title('原图')
plt.subplot(242)
plt.imshow(img_s, cmap='gray')
plt.title('椒盐噪声')
plt.subplot(243)
plt.imshow(img_sj, cmap='gray')
plt.title('椒盐均匀噪声')
plt.subplot(244)
plt.imshow(img_m, cmap='gray')
plt.title('均值滤波')
plt.subplot(245)
plt.imshow(img_mg, cmap='gray')
plt.title('均值高斯滤波')
plt.subplot(246)
plt.imshow(img_mgd, cmap='gray')
plt.title('均值高斯中值滤波')
plt.subplot(247)
plt.imshow(img_g, cmap='gray')   
plt.title('高斯滤波')
plt.subplot(248)
plt.imshow(img_d, cmap='gray')
plt.title('中值滤波')
plt.show()

从一张灰度图像出发，我利用skimage库先后为其添加了椒盐噪声和均匀噪声，模拟真实场景中图像可能遭受的干扰，让原本清晰的图像变得 “千疮百孔”。随后，便是本次实践的重头戏 —— 滤波处理。

运用cv2库中的均值滤波、高斯滤波和中值滤波方法，尝试恢复图像的本来面目。均值滤波像一个 “平均主义者”，简单地对邻域像素求平均，初步抚平噪声；高斯滤波则更为 “细腻”，考虑了像素的权重，对图像进行加权平均，在平滑噪声的同时更好地保留了部分图像细节；中值滤波表现得十分 “果断”，它选取邻域像素的中间值替换当前像素，对椒盐噪声有着显著的抑制效果。

在处理过程中，不同滤波方法按顺序组合，如先均值滤波再高斯滤波，又或者是先高斯滤波再中值滤波，每一种组合都为图像带来了不同程度的改善。通过matplotlib库将原始图像、添加噪声后的图像以及经过各种滤波处理后的图像一同展示，对比效果一目了然。

分析结果

对于均匀噪声

均值滤波：能在一定程度上平滑噪声，但可能会使图像整体变模糊。

高斯滤波：对均匀噪声有较好的抑制效果，能在保留图像细节的同时减少噪声。

中值滤波：对均匀噪声的处理效果相对较弱，可能无法很好地去除噪声。

对于椒盐噪声

均值滤波：会将椒盐噪声扩散到周围像素，使图像变得模糊，处理效果较差。

高斯滤波：虽然能减少噪声，但对椒盐噪声的去除效果不如中值滤波，也会使图像变模糊。

中值滤波：是处理椒盐噪声的最佳选择，能有效去除噪声，同时保留图像的边缘和细节。

7.cv实现均值滤波器底层代码

以上我们皆是通过使用多个库实现滤波，接下来让我们尝试仅使用opencv实现均值滤波器底层代码。

import cv2

# 求平均
def getAverage(list):
    """
    计算列表中所有元素的平均值

    参数:
    list (list): 包含数值的列表

    返回:
    float: 列表元素的平均值
    """
    temp = 0
    # 遍历列表，累加每个元素的值
    for i in list:
        temp = temp + i
    # 计算平均值
    avg = temp / len(list)
    return avg

def main():
    """
    主函数，实现均值滤波并显示原始图像和处理后的图像
    """
    # 读取指定路径的图像，以灰度模式读取
    image = cv2.imread('cat.jpg', 0)
    # 显示原始图像
    cv2.imshow('srcImage', image)

    # 复制原始图像到dst，用于存储处理后的图像
    dst = image.copy()
    # 获取图像的高度
    height = image.shape[0]
    # 获取图像的宽度
    width = image.shape[1]

    # 边界不做处理
    # 遍历图像的每一行（排除边界）
    for row in range(1, height - 1):
        # 遍历图像的每一列（排除边界）
        for col in range(1, width - 1):
            # 创建一个3✖️3的9阶滤波器
            np = [image[row - 1][col - 1], image[row - 1][col], image[row - 1][col + 1],
                  image[row][col - 1], image[row][col], image[row][col + 1],
                  image[row + 1][col - 1], image[row + 1][col], image[row + 1][col + 1]]
            # 求平均值
            avg = getAverage(np)
            # 给目标图像中对应像素赋灰度值
            dst[row][col] = avg
    # 显示处理后的图像
    cv2.imshow('dstImage', dst)
    # 等待按键事件
    cv2.waitKey(0)

if __name__ == '__main__':
    # 调用主函数
    main()

8.cv实现中值滤波器底层代码

通过以上的内容，我们可以轻松的通过改求均值为求中值得到中值滤波器的底层代码

import cv2

# 求中值
def getMedian(num_list):
    """
    计算列表中所有元素的中值

    参数:
    num_list (list): 包含数值的列表

    返回:
    int/float: 列表元素的中值
    """
    # 对列表进行排序
    sorted_list = sorted(num_list)
    # 返回排序后列表中间位置的元素作为中值
    return sorted_list[len(sorted_list) // 2]

def main():
    """
    主函数，实现中值滤波并显示原始图像和处理后的图像
    """
    # 读取指定路径的图像
    image = cv2.imread('cat.jpg', 0)
    cv2.imshow('srcImage', image)

    # 复制原始图像，用于存储处理后的图像
    dst = image.copy()
    # 获取图像的高度
    height = image.shape[0]
    # 获取图像的宽度
    width = image.shape[1]

    # 边界不做处理
    # 遍历图像的每一行
    for row in range(1, height - 1):
        # 遍历图像的每一列（排除边界列）
        for col in range(1, width - 1):
            np = [image[row - 1][col - 1], image[row - 1][col], image[row - 1][col + 1],
                  image[row][col - 1], image[row][col], image[row][col + 1],
                  image[row + 1][col - 1], image[row + 1][col], image[row + 1][col + 1]]
            # 调用getMedian函数计算中值
            median = getMedian(np)
            # 将计算得到的中值赋给目标图像对应位置的像素
            dst[row][col] = median

    # 显示处理后的图像
    cv2.imshow('dstImage', dst)
    cv2.waitKey(0)

if __name__ == '__main__':
    main()

9.结语

在探索图像处理中各类滤波代码的征程里，我们领略了均值滤波的简洁高效、高斯滤波的细腻加权、中值滤波的果断去噪，还有空域锐化滤波对图像边缘与细节的精妙雕琢。每一种滤波方法都像是一把独特的钥匙，开启了改善图像质量、挖掘图像信息的大门。希望这篇博客能成为你在图像处理领域前行的得力助手，当你面对不同图像问题时，能依据这些代码思路灵活运用，找到最合适的解决方案。

祝愿各位在图像处理的奇妙世界中持续探索，不断创造出更清晰、更具价值的图像成果。无论是投身学术研究，为图像识别、计算机视觉等领域添砖加瓦；还是用于日常摄影修图，让每一张照片都能展现出独特魅力，都能借助这些滤波知识达成目标。愿代码如同灵动画笔，在数字图像的画布上绘出绚丽风景，收获满满的成就与惊喜！