【代码实现】opencv 高斯模糊和pytorch 高斯模糊

wiki百科

Gaussian Blur，也叫高斯平滑，是在Adobe Photoshop、GIMP以及Paint.NET等图像处理软件中广泛使用的处理效果，通常用它来减少图像噪声以及降低细节层次。

opencv实现

opencv实现高斯滤波有两种方式，

1、是使用自带的cv2.GaussianBlur ，
2、自己构造高斯kernel ，然后调用cv2.filter2D函数，

方法2这个高斯kernel也可以使用opencv自带的cv2.getGaussianKernel来创建，并通过乘以转置来获得NXN的核。
以下是示例代码。

import cv2
import numpy as np
original_image = np.random.rand(256, 256, 3).astype(np.float32)

# 设置高斯核大小和标准差
sigma = 0.334

# 确定高斯核大小
kernel_size = int(6 * sigma + 1)  # 通常选择为 6*sigma + 1

# 使用 OpenCV 进行高斯模糊，方法1
a = cv2.GaussianBlur(original_image, (0, 0), sigma)

# 使用 OpenCV 进行高斯模糊，方法2
kernel = cv2.getGaussianKernel(kernel_size, sigma)
kernel = kernel * kernel.transpose()

b = cv2.filter2D(original_image, -1, kernel)
print(np.abs(a - b).max())
np.allclose(a, b, atol=1e-3)

pytorch 实现

有可能在构建的网络中需要使用高斯滤波，但是又不想通过opencv实现，也可以在tensor层面对图像进行高斯滤波。也就是使用卷积的方式来实现filter。
同样实现方式也有两种，

1、使用 F.conv2d的方式
2、使用nn.Conv2d ，但权重 需要固定

需要先定义高斯核，然后在采用上述两种方式来具体实现

# 定义高斯核
def gaussian_kernel(size, sigma):
    x = torch.arange(size, dtype=torch.float32) - size // 2
    kernel_1d = torch.exp(-0.5 * (x / sigma) ** 2)
    kernel_1d /= kernel_1d.sum()
    kernel_2d = torch.outer(kernel_1d, kernel_1d)
    return kernel_2d.unsqueeze(0).unsqueeze(0)

特别需要注意的是group 要设置为3，RGB通道分别使用高斯核，不然结果会出错。
以下是两种方法的实现。

# 方法1 F.conv2d应用高斯模糊
def apply_gaussian_blur(image, kernel_size, sigma):
    padding = (kernel_size - 1) // 2

    # 使用 ReflectionPad2d 进行填充
    img_torch_pad = F.pad(image, pad=(padding, padding, padding, padding), mode='reflect')

    kernel = gaussian_kernel(kernel_size, sigma)
    kernel = kernel.repeat(3, 1, 1, 1)  # 重复以匹配输入图像的通道数
    kernel = kernel.to(image.device)

    # 使用卷积操作进行高斯模糊
    blurred_image = F.conv2d(img_torch_pad, kernel, padding=0, groups=3)
    return blurred_image

# 方法2 创建带有固定高斯核的Conv2D层
class GaussianBlur(nn.Module):
    def __init__(self, kernel_size, sigma, in_channels=3):
        super(GaussianBlur, self).__init__()
        kernel = gaussian_kernel(kernel_size, sigma)
        kernel = kernel.repeat(in_channels, 1, 1, 1)  # 重复以匹配输入图像的通道数
        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=kernel_size, padding=0,stride=1,groups=in_channels, bias=False)
        self.padding = (kernel_size-1)//2
        self.conv.weight.data = kernel
    def forward(self, x):
        x = F.pad(x, pad=(self.padding, self.padding, self.padding, self.padding), mode='reflect')
        #x = self.pad(x)
        return self.conv(x)

比较四种方法的差异

# 创建一个形状为 (1, 3, 256, 56) 的随机图像
original_image = np.random.rand(1, 3, 256, 56)
original_image_np = original_image[0].transpose(1, 2, 0)

# 将 NumPy 数组转换为 PyTorch 张量
original_image_tensor = torch.tensor(original_image, dtype=torch.float32)

# 设置高斯核大小和标准差
sigma = 0.334

# 确定高斯核大小
kernel_size = int(6 * sigma + 1)  # 通常选择为 6*sigma + 1


# opencv 方法1
opencv1 = cv2.GaussianBlur(original_image_np, (0, 0), sigma).transpose(2, 0, 1)[np.newaxis, ...] #根据sigma创建kernel，一般是6s +1 
# opencv 方法2
# 使用 OpenCV 进行高斯模糊，方法2
kernel = cv2.getGaussianKernel(kernel_size, sigma)
kernel = kernel * kernel.transpose()
opencv2 = cv2.filter2D(original_image_np, -1, kernel).transpose(2, 0, 1)[np.newaxis, ...]
# torch 方法1
torch1 = apply_gaussian_blur(original_image_tensor, kernel_size, sigma).numpy()
# torch 方法2
blur_layer = GaussianBlur(kernel_size, sigma)
torch2  = blur_layer(original_image_tensor).detach().numpy()

def all_arrays_close(*arrays):
    reference = arrays[0]
    for array in arrays[1:]:
        if not np.allclose(reference, array,rtol=1e-5, atol=1e-8):
            return False
    return True

if all_arrays_close(opencv1, opencv2, torch1, torch2):
    print("All arrays are close to each other.")
else:
    print("Arrays are not close to each other.")

输出

说明四种方法是等价的。