1.数字图像处理：空间域滤波

1.1 滤波器核（相关核）与卷积

图像上的邻域计算

线性空间滤波的原理

滤波器核（相关核）是如何得到的？

空间域的卷积

卷积：滤波器核与window中的对应值相乘后所有值相加得到一个像素值，滑动窗口遍历整个图像

滤波器核（相关核）与卷积的区别

截图来源：【小动画】彻底理解卷积【超形象】卷的由来，小元老师

滤波器核对称时，翻转与不翻转没有影响，所以卷积等于相关性

卷积的物理实质可以通过以下几个方面进行理解，这些方面涉及到信号处理、系统响应和图像处理等领域

1.2 图像加噪

噪声点的判定标准

由灰度直方图得到概率密度函数的方法

从含噪图像中确定具体噪声模型的系统化方法？

选取实验用的实验图像，完成图像读取和显示，给图像加上高斯噪声

import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt

# 打开图片并转换为灰度图像
img_dir = r'D:\Document\Experiment\data\image1.jpg'
# 读取图像并转换为灰度
gray = cv.imread(img_dir, 0)
image_array = np.array(gray)

# 定义高斯噪声的参数
mean = 0  # 均值
sigma = 80  # 标准差（调整噪声强度）

# 生成高斯噪声
gaussian_noise = np.random.normal(mean, sigma, image_array.shape)

# 将噪声加入图像
noisy_image = image_array + gaussian_noise

# 将噪声后的图像剪裁到0-255范围内，并转换为uint8
noisy_image_clipped = np.clip(noisy_image, 0, 255).astype(np.uint8)

# 显示原图和加入噪声后的图像
plt.figure(figsize=(10,5))
plt.subplot(1,2,1)
plt.title('Original Image')
plt.imshow(image_array, cmap='gray')

plt.subplot(1,2,2)
plt.title('Noisy Image')
plt.imshow(noisy_image_clipped, cmap='gray')
plt.show()

1.3 均值滤波、高斯滤波、中值滤波

均值滤波

高斯滤波

中值滤波

为了使得卷积能够正常进行，对原图像外围进行填充（padding）

用自己编写的滤波函数分别对实验图像进行滤波；

import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt

# 读取图像并转换为灰度
img_dir = r'D:\Document\Experiment\data\image1.jpg'  # 图像路径
gray = cv.imread(img_dir, 0)  # 读取图像，并将其转换为灰度图像

# 定义高斯噪声的参数
mean = 0  # 高斯噪声的均值
sigma = 80  # 高斯噪声的标准差，用于控制噪声强度

# 生成高斯噪声并添加到图像
gaussian_noise = np.random.normal(mean, sigma, gray.shape)  # 生成与图像相同大小的高斯噪声
noisy_image = gray + gaussian_noise  # 将生成的噪声添加到图像
noisy_image_clipped = np.clip(noisy_image, 0, 255).astype(np.uint8)  # 将噪声叠加后的图像值限制在0到255，并转换为uint8类型

# 均值滤波实现
# 其中，均值滤波一般的具体实现步骤是:
# .选择一个(2n+l) x (2n+l)的窗口(通常为3 x 3或5 x 5)，并用该窗口沿图像数据进行行或列的滑动；
# .读取窗口下各对应像素的灰度值；
# .求取这些像素的灰度平均值替代窗口中心位置的原始像素灰度值。
def mean_filter(image, kernel_size=3):
    # 填充大小
    # 根据传入的窗口大小 kernel_size 计算需要的填充尺寸
    # 因为均值滤波会涉及到窗口的滑动，所以为了保持输出图像的尺寸与输入图像相同，需要在图像的边缘进行填充。对于 3x3 的窗口，pad_size 为 1；对于 5x5 的窗口，pad_size 为 2
    pad_size = kernel_size // 2  # 根据核大小计算需要的填充尺寸
    # 使用 np.pad 函数将原始图像进行填充，pad_size 为填充的边界大小，mode='constant' 指定使用常数值填充，constant_values=0 表示用 0 填充。这使得在处理图像边缘时能够避免索引超出边界的错误。
    padded_image = np.pad(image, pad_size, mode='constant', constant_values=0)  # 用常数0填充图像边缘
    # 创建一个与输入图像 image 形状相同的全零数组 output_image，用于存储均值滤波后的结果。
    output_image = np.zeros_like(image)  # 初始化输出图像，大小与原图一致
    
    # 滑动窗口进行均值滤波
    # 外层循环：通过 for 循环遍历填充后的图像的行，从 pad_size 开始到 padded_image.shape[0] - pad_size 结束。这样做是为了避免在处理图像边缘时出现越界
    for i in range(pad_size, padded_image.shape[0] - pad_size):
        # 内层循环：同样通过 for 循环遍历填充后的图像的列，范围与行的处理相同。这两个嵌套循环用于对图像的每一个像素进行处理
        for j in range(pad_size, padded_image.shape[1] - pad_size):
        	# 获取窗口内的像素：通过切片操作从填充后的图像中获取当前窗口的像素值。窗口的大小为 (kernel_size, kernel_size)，即从 (i-pad_size, j-pad_size) 到 (i+pad_size, j+pad_size) 的区域
            window = padded_image[i-pad_size:i+pad_size+1, j-pad_size:j+pad_size+1]  # 获取窗口内的像素
            # 使用 np.mean(window) 计算窗口中像素值的平均值，并将结果赋值给输出图像 output_image 的对应位置。为了保持位置一致性，索引使用 i-pad_size 和 j-pad_size
            output_image[i-pad_size, j-pad_size] = np.mean(window)  # 计算窗口像素的平均值，并赋给输出图像的对应位置
    
    return output_image  # 返回滤波后的图像

# 高斯滤波实现
# 高斯滤波一般的具体实现步骤是:
# .选择一个(2n+l) x (2n+l)的窗口(通常为3 x 3或5 x 5)，生成二维高斯模板，并用该窗口沿图像数据进行行或列的滑动；
# .读取窗口下各对应像素的灰度值；
# .求取这些像素与二维高斯模板对应位置元素的乘积再求和，用该值替代窗口中心位置的原始像素灰度值。
def gaussian_kernel(kernel_size=3, sigma=1.0):
    k = kernel_size // 2  # 计算高斯核中心的偏移
    gaussian_kernel = np.zeros((kernel_size, kernel_size), dtype=np.float32)  # 初始化高斯核
    for x in range(-k, k + 1):  # 遍历核的行坐标
        for y in range(-k, k + 1):  # 遍历核的列坐标
            gaussian_kernel[x + k, y + k] = np.exp(-(x**2 + y**2) / (2 * sigma**2))  # 根据高斯公式计算权重
    gaussian_kernel /= (2 * np.pi * sigma**2)  # 归一化常数
    gaussian_kernel /= gaussian_kernel.sum()  # 对高斯核进行归一化，使其所有元素的和为1
    return gaussian_kernel  # 返回生成的高斯核

def gaussian_filter(image, kernel_size=3, sigma=1.0):
    pad_size = kernel_size // 2  # 计算填充大小
    padded_image = np.pad(image, pad_size, mode='constant', constant_values=0)  # 用常数0填充图像边缘
    output_image = np.zeros_like(image)  # 初始化输出图像
    
    kernel = gaussian_kernel(kernel_size, sigma)  # 生成高斯核
    
    # 滑动窗口进行高斯滤波
    for i in range(pad_size, padded_image.shape[0] - pad_size):
        for j in range(pad_size, padded_image.shape[1] - pad_size):
            window = padded_image[i-pad_size:i+pad_size+1, j-pad_size:j+pad_size+1]  # 获取窗口内的像素
            output_image[i-pad_size, j-pad_size] = np.sum(window * kernel)  # 计算窗口像素与高斯核的加权和
    
    return output_image  # 返回滤波后的图像

# 中值滤波实现
# 中值滤波一般的具体实现步骤是：
# .选择一个(2n+l)x(2n+l)的窗口(通常为3x3或5x5)，并用该窗口沿图像数据进行行或列的滑动；
# .读取窗口下各对应像素的灰度值；
# .将这些灰度值从小到大排成一列，用排序所得的中值替代窗口中心位置的原始像素灰度值；
def median_filter(image, kernel_size=3):
    pad_size = kernel_size // 2  # 计算填充大小
    padded_image = np.pad(image, pad_size, mode='constant', constant_values=0)  # 用常数0填充图像边缘
    output_image = np.zeros_like(image)  # 初始化输出图像
    
    # 滑动窗口进行中值滤波
    for i in range(pad_size, padded_image.shape[0] - pad_size):
        for j in range(pad_size, padded_image.shape[1] - pad_size):
            # 获取窗口内的像素
            window = padded_image[i-pad_size:i+pad_size+1, j-pad_size:j+pad_size+1]  
            output_image[i-pad_size, j-pad_size] = np.median(window)  # 计算窗口像素的中值，并赋给输出图像的对应位置
    
    return output_image  # 返回滤波后的图像

# 进行均值滤波、高斯滤波、中值滤波
mean_filtered_img = mean_filter(noisy_image_clipped, kernel_size=3)  # 应用均值滤波，使用3x3窗口
gaussian_filtered_img = gaussian_filter(noisy_image_clipped, kernel_size=3, sigma=1.0)  # 应用高斯滤波，使用3x3窗口，sigma为1.0
median_filtered_img = median_filter(noisy_image_clipped, kernel_size=3)  # 应用中值滤波，使用3x3窗口

# 定义运算及其标题
operations = [
    ("Original", gray),  # 原始图像
    ("Noised", noisy_image_clipped),  # 添加噪声后的图像
    ("Mean Filter", mean_filtered_img),  # 均值滤波后的图像
    ("Gaussian Filter", gaussian_filtered_img),  # 高斯滤波后的图像
    ("Median Filter", median_filtered_img)  # 中值滤波后的图像
]

# 绘图
plt.figure(figsize=(15, 7))  # 设置绘图窗口大小
for i, (title, result) in enumerate(operations, 1):  # 遍历运算结果
    plt.subplot(2, 3, i)  # 创建子图，2行3列
    plt.title(title)  # 设置子图标题
    plt.imshow(result, cmap='gray')  # 显示图像，使用灰度颜色映射
    plt.axis('off')  # 关闭坐标轴显示

plt.tight_layout()  # 自动调整子图布局，使之不重叠
plt.show()  # 显示图像

用OpenCV自带的滤波函数对实验图像分别进行滤波；

# （4）用OpenCV自带的滤波函数对实验图像分别进行滤波；
import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt

# 读取图像并转换为灰度
img_dir = r'D:\Document\Experiment\data\image1.jpg'
gray = cv.imread(img_dir, 0)

# 灰度加噪（添加高斯噪声）
mean = 0  # 均值
sigma = 80  # 标准差（调整噪声强度）
gaussian_noise = np.random.normal(mean, sigma, gray.shape)  # 生成高斯噪声
noisy_image = gray + gaussian_noise  # 将噪声加入图像
noisy_image_clipped = np.clip(noisy_image, 0, 255).astype(np.uint8)  # 剪裁到0-255范围并转换为uint8

# 均值滤波实现
def mean_filter(image, kernel_size=5):
    # 使用cv2的blur函数进行均值滤波
    return cv.blur(image, (kernel_size, kernel_size))

# 高斯滤波实现
def gaussian_filter(image, kernel_size=5, sigma=1.0):
    # 使用cv2的GaussianBlur函数进行高斯滤波
    return cv.GaussianBlur(image, (kernel_size, kernel_size), sigma)

# 中值滤波实现
def median_filter(image, kernel_size=5):
    # 使用cv2的medianBlur函数进行中值滤波
    return cv.medianBlur(image, kernel_size)

# 进行均值滤波、高斯滤波、中值滤波
mean_filtered_img = mean_filter(noisy_image_clipped)
gaussian_filtered_img = gaussian_filter(noisy_image_clipped)
median_filtered_img = median_filter(noisy_image_clipped)

# 定义运算及其标题
operations = [
    ("Original", gray),
    ("Noised", noisy_image_clipped),
    ("Mean Filter", mean_filtered_img),
    ("Gaussian Filter", gaussian_filtered_img),
    ("Median Filter", median_filtered_img)
]

# 绘图
plt.figure(figsize=(15, 7))
for i, (title, result) in enumerate(operations, 1):
    plt.subplot(2, 3, i)
    plt.title(title)
    plt.imshow(result, cmap='gray')
    plt.axis('off')  # 关闭坐标轴显示

plt.tight_layout()
plt.show()