关于图像锐化的一份介绍

在这篇文章中，我将介绍有关图像锐化有关的知识，具体包括锐化的简单介绍、一阶锐化与二阶锐化等方面内容。

一、锐化

1.1 概念

锐化（sharpening）就是指将图象中灰度差增大的方法，一次来增强物体的轮廓与边缘。因为发生锐化的地方都是发生灰度差突变的地方，所以锐化算法都是基于微分作用。

1.2 作用

一般来说，锐化增强灰度差，除了使物体与轮廓的细节增强后，它还是重要的预处理的一步，为了方便之后的物体检测与识别等。

二、一阶微分锐化方法

一阶微分锐化的计算公式十分简单，具体如下：

2.1 单方向一阶锐化

单方向的一阶锐化即是对某特定方向的边缘信息进行增强。通常，我们通过模板来实现，比如：

代码与处理后图像分别为：（代码中为了增强最后锐化后的效果，采用了垂直方向的锐化，而非上述模板中水平方向的锐化）

python 复制代码

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

image = cv2.imread(r'C:\Users\20349\Desktop\picture\tree.png')

# 定义单方向一阶微分锐化模板
kernel = np.array([[1, 0, -1],
                       [2, 0, -2],
                       [1, 0, -1]])

# 应用卷积核到图像上
sharpened_image = cv2.filter2D(image, -1, kernel)

image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
sharpened_image_rgb = cv2.cvtColor(sharpened_image, cv2.COLOR_BGR2RGB)

fig, axes = plt.subplots(1, 2)

# 显示原图和处理后的图像
axes[0].imshow(image_rgb)
axes[0].set_title('Original Image')
axes[0].axis('off')  # 不显示坐标轴

axes[1].imshow(sharpened_image_rgb)
axes[1].set_title('Sharpened Image')
axes[1].axis('off')  # 不显示坐标轴

plt.show()

具体关于实现锐化部分的函数类似地可以写成代码如下：

python 复制代码

def filter_2d(image, kernel):
    # 获取图像和卷积核的尺寸
    image_height, image_width, *image_channels = image.shape
    kernel_height, kernel_width = kernel.shape

    # 确保卷积核是奇数尺寸，以便有中心点
    if kernel_height % 2 == 0 or kernel_width % 2 == 0:
        raise ValueError("卷积核的宽高都应该是奇数")

    # 计算填充大小
    pad_size_height = kernel_height // 2
    pad_size_width = kernel_width // 2

    # 创建一个带有边框填充的图像副本，使用零填充
    padded_image = cv2.copyMakeBorder(image, pad_size_height, pad_size_height, pad_size_width, pad_size_width,
                                      cv2.BORDER_CONSTANT)

    # 如果图像是彩色图像，则需要分别处理每个通道
    if len(image_channels) > 0:
        channels = cv2.split(padded_image)
        output_channels = []
        for channel in channels:
            output_channel = np.zeros_like(channel)
            # 对于每个像素位置应用卷积
            for y in range(pad_size_height, image_height + pad_size_height):
                for x in range(pad_size_width, image_width + pad_size_width):
                    region = channel[y - pad_size_height:y + pad_size_height + 1,
                             x - pad_size_width:x + pad_size_width + 1]
                    output_channel[y - pad_size_height, x - pad_size_width] = (region * kernel).sum()
            output_channels.append(output_channel)
        output_image = cv2.merge(output_channels)
    else:
        # 对于灰度图像直接处理
        output_image = np.zeros_like(image)
        for y in range(pad_size_height, image_height + pad_size_height):
            for x in range(pad_size_width, image_width + pad_size_width):
                region = padded_image[y - pad_size_height:y + pad_size_height + 1,
                         x - pad_size_width:x + pad_size_width + 1]
                output_image[y - pad_size_height, x - pad_size_width] = (region * kernel).sum()

    return output_image

（该函数代码与实际调用的函数代码略有不同）

此外，在进行了上述步骤后进行取绝对值操作，可以增强对比度，避免负值影响问题等。

2.2 无方向一阶锐化

通过观察处理结果，我们发现单方向一阶微分锐化对于矩形特征的物体处理效果优秀，但对于不规则的物体处理效果有所欠缺，此时就需要无方向一阶微分锐化。

交叉微分锐化

首先是交叉微分锐化，其表达式为：

该方法可以用代码表示为如下，以及其处理结果也如下所示：

python 复制代码

def roberts_cross(image):
    image_height, image_width = image.shape

    output_image = np.zeros_like(image)

    # 定义Roberts算子
    kernel_x = np.array([[1, 0], [0, -1]])
    kernel_y = np.array([[0, -1], [1, 0]])

    # 对每个像素应用Roberts算子
    for y in range(0, image_height - 1):
        for x in range(0, image_width - 1):
            region = image[y:y + 2, x:x + 2]

            gradient_x = (region * kernel_x).sum()
            gradient_y = (region * kernel_y).sum()
            output_image[y, x] = np.sqrt(gradient_x ** 2 + gradient_y ** 2)

    # 归一化
    output_image = cv2.normalize(output_image, None, 0, 255, cv2.NORM_MINMAX)
    return output_image.astype(np.uint8)

Sobel锐化

关于Sobel锐化可以用表达式表示为：

其中：

代码以及结果分别为：

python 复制代码

def sobel_sharpen(image):
    image_float = image.astype(float)

    # 定义Sobel算子
    kernel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
    kernel_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])

    # 计算x方向和y方向的梯度
    gradient_x = cv2.filter2D(image_float, -1, kernel_x)
    gradient_y = cv2.filter2D(image_float, -1, kernel_y)

    # 合并两个方向的梯度
    gradient_magnitude = np.sqrt(gradient_x ** 2 + gradient_y ** 2)

    sharpened_image = image_float + gradient_magnitude

    sharpened_image = np.clip(sharpened_image, 0, 255)
    return sharpened_image.astype(np.uint8)