Python에서 저역 통과 필터 흐림 이미지 기능을 구현하는 방법

저역 통과 필터를 사용하여 이미지를 흐리게

0. 소개

저역 통과 필터(저역 통과 필터, LPF)는 높은 영역을 필터링합니다. -이미지 주파수 부분의 주파수 성분을 제거하고 저주파 부분만 통과시킵니다. 따라서 이미지에 LPF를 적용하면 이미지의 세부 사항/가장자리와 노이즈/이상값이 제거됩니다. 이 프로세스는 이미지 블러링(또는 스무딩)이라고도 하며 복잡한 이미지 처리를 위한 솔루션으로 사용할 수 있습니다. 전처리 부분. Low Pass Filter, LPF) 过滤了图像中的高频部分，并仅允许低频部分通过。因此，在图像上应用 LPF 会删除图像中的细节/边缘和噪声/离群值，此过程也称为图像模糊(或平滑)，图像平滑可以作为复杂图像处理任务的预处理部分。

1. 频域中的不同类型的核与卷积

1.1 图像模糊分类

图像模糊通常包含以下类型：

• 边缘模糊 (Edge) 这种类型的模糊通常通过卷积显式地应用于图像，例如线性滤波器核或高斯核等，使用这些滤波器核可以平滑/去除图像中不必要的细节/噪声。

• 运动模糊 (Motion) 通常是由于相机在拍摄图像时抖动所产生的，也就是说，摄像机或被拍摄的对象处于移动状态。我们可以使用点扩展函数来模拟这种模糊。

• 失焦模糊 (de-focus) 当相机拍摄的对象失焦时，会产生这种类型的模糊；我们可以使用模糊 (blur) 核来模拟这种模糊。

接下来，我们创建以上三种不同类型的核，并将它们应用于图像以观察不同类型核处理图像后的结果。

1.2 使用不同核执行图像模糊

(1) 我们首先定义函数 get_gaussian_edge_blur_kernel() 以返回 2D 高斯模糊核用于边缘模糊。该函数接受高斯标准差 ( σ σ σ) 以及创建 2D 核的大小(例如，sz = 15 将创建尺寸为 15x15 的核)作为函数的参数。如下所示，首先创建了一个 1D 高斯核，然后计算两个 1D 高斯核的外积返回 2D 核：

import numpy as np
import numpy.fft as fp
from skimage.io import imread
from skimage.color import rgb2gray 
import matplotlib.pyplot as plt
import cv2

def get_gaussian_edge_blur_kernel(sigma, sz=15):
    # First create a 1-D Gaussian kernel
    x = np.linspace(-10, 10, sz)
    kernel_1d = np.exp(-x**2/sigma**2)
    kernel_1d /= np.trapz(kernel_1d) # normalize the sum to 1.0
    # create a 2-D Gaussian kernel from the 1-D kernel
    kernel_2d = kernel_1d[:, np.newaxis] * kernel_1d[np.newaxis, :]
    return kernel_2d

(2) 接下来，定义函数 get_motion_blur_kernel() 以生成运动模糊核，得到给定长度且特定方向(角度)的线作为卷积核，以模拟输入图像的运动模糊效果：

def get_motion_blur_kernel(ln, angle, sz=15):
    kern = np.ones((1, ln), np.float32)
    angle = -np.pi*angle/180
    c, s = np.cos(angle), np.sin(angle)
    A = np.float32([[c, -s, 0], [s, c, 0]])
    sz2 = sz // 2
    A[:,2] = (sz2, sz2) - np.dot(A[:,:2], ((ln-1)*0.5, 0))
    kern = cv2.warpAffine(kern, A, (sz, sz), flags=cv2.INTER_CUBIC)
    return kern

函数 get_motion_blur_kernel() 将模糊的长度和角度以及模糊核的尺寸作为参数，函数使用 OpenCV 的 warpaffine() 函数返回核矩阵(以矩阵中心为中点，使用给定长度和给定角度得到核)。

(3) 最后，定义函数 get_out_of_focus_kernel() 以生成失焦核(模拟图像失焦模糊)，其根据给定半径创建圆用作卷积核，该函数接受半径 R (Deocus Radius) 和要生成的核大小作为输入参数：

 def get_out_of_focus_kernel(r, sz=15):
    kern = np.zeros((sz, sz), np.uint8)
    cv2.circle(kern, (sz, sz), r, 255, -1, cv2.LINE_AA, shift=1)
    kern = np.float32(kern) / 255
    return kern

(4) 接下来，实现函数 dft_convolve()，该函数使用图像的逐元素乘法和频域中的卷积核执行频域卷积(基于卷积定理)。该函数还绘制输入图像、核和卷积计算后得到的输出图像：

def dft_convolve(im, kernel):
    F_im = fp.fft2(im)
    #F_kernel = fp.fft2(kernel, s=im.shape)
    F_kernel = fp.fft2(fp.ifftshift(kernel), s=im.shape)
    F_filtered = F_im * F_kernel
    im_filtered = fp.ifft2(F_filtered)
    cmap = 'RdBu'
    plt.figure(figsize=(20,10))
    plt.gray()
    plt.subplot(131), plt.imshow(im), plt.axis('off'), plt.title('input image', size=10)
    plt.subplot(132), plt.imshow(kernel, cmap=cmap), plt.title('kernel', size=10)
    plt.subplot(133), plt.imshow(im_filtered.real), plt.axis('off'), plt.title('output image', size=10)
    plt.tight_layout()
    plt.show()

(5) 将 get_gaussian_edge_blur_kernel() 核函数应用于图像，并绘制输入，核和输出模糊图像：

im = rgb2gray(imread('3.jpg'))

kernel = get_gaussian_edge_blur_kernel(25, 25)
dft_convolve(im, kernel)

(6) 接下来，将 get_motion_blur_kernel() 函数应用于图像，并绘制输入，核和输出模糊图像：

kernel = get_motion_blur_kernel(30, 60, 25)
dft_convolve(im, kernel)

(7) 最后，将 get_out_of_focus_kernel() 函数应用于图像，并绘制输入，核和输出模糊图像：

kernel = get_out_of_focus_kernel(15, 20)
dft_convolve(im, kernel)

2. 使用 scipy.ndimage 滤波器模糊图像

scipy.ndimage 模块提供了一系列可以在频域中对图像应用低通滤波器的函数。本节中，我们通过几个示例学习其中一些滤波器的用法。

2.1 使用 fourier_gaussian() 函数

使用 scipy.ndimage 库中的 fourier_gaussian() 函数在频域中使用高斯核执行卷积操作。

(1) 首先，读取输入图像，并将其转换为灰度图像，并通过使用 FFT 获取其频域表示：

import numpy as np
import numpy.fft as fp
from skimage.io import imread
import matplotlib.pyplot as plt
from scipy import ndimage

im = imread('1.png', as_gray=True)
freq = fp.fft2(im)

(2) 接下来，使用 fourier_gaussian() 函数对图像执行模糊操作，使用两个具有不同标准差的高斯核，绘制输入、输出图像以及功率谱：

fig, axes = plt.subplots(2, 3, figsize=(20,15))
plt.subplots_adjust(0,0,1,0.95,0.05,0.05)
plt.gray() # show the filtered result in grayscale
axes[0, 0].imshow(im), axes[0, 0].set_title('Original Image', size=10)
axes[1, 0].imshow((20*np.log10( 0.1 + fp.fftshift(freq))).real.astype(int)), axes[1, 0].set_title('Original Image Spectrum', size=10)
i = 1
for sigma in [3,5]:
    convolved_freq = ndimage.fourier_gaussian(freq, sigma=sigma)
    convolved = fp.ifft2(convolved_freq).real # the imaginary part is an artifact
    axes[0, i].imshow(convolved)
    axes[0, i].set_title(r'Output with FFT Gaussian Blur, $\sigma$={}'.format(sigma), size=10)
    axes[1, i].imshow((20*np.log10( 0.1 + fp.fftshift(convolved_freq))).real.astype(int))
    axes[1, i].set_title(r'Spectrum with FFT Gaussian Blur, $\sigma$={}'.format(sigma), size=10)
    i += 1
for a in axes.ravel():
    a.axis('off')    
plt.show()

2.2 使用 fourier_uniform() 函数

scipy.ndimage 模块的函数 fourier_uniform() 实现了多维均匀傅立叶滤波器。频率阵列与给定尺寸的方形核的傅立叶变换相乘。接下来，我们学习如何使用 LPF (均值滤波器)模糊输入灰度图像。

(1) 首先，读取输入图像并使用 DFT

1. 주파수 영역의 다양한 유형의 커널 및 컨볼루션🎜

1.1 이미지 흐림 분류

🎜이미지 흐림에는 일반적으로 다음 유형이 포함됩니다. 🎜

• 🎜Edge Blur(Edge) 이 유형의 흐림은 일반적으로 선형 필터 커널 또는 가우시안 커널 등과 같은 컨볼루션을 통해 이미지에 명시적으로 적용되며 이러한 필터 커널을 사용하여 이미지를 부드럽게/제거합니다. 이미지에 불필요한 디테일/노이즈가 있습니다. 🎜
• 🎜모션 블러(Motion)는 일반적으로 이미지를 캡처할 때 카메라 흔들림, 즉 카메라나 촬영되는 피사체가 움직이는 경우 발생합니다. 이 흐림을 시뮬레이션하기 위해 점 확산 기능을 사용할 수 있습니다. 🎜
• 🎜초점 흐림(de-focus) 이러한 유형의 흐림은 카메라에 포착된 물체의 초점이 맞지 않을 때 발생합니다(). 흐림 ) 커널을 사용하여 이 흐림을 시뮬레이션합니다. 🎜
🎜🎜다음으로 위의 세 가지 유형의 커널을 생성하고 이를 이미지에 적용하여 다양한 유형의 커널이 이미지를 처리한 결과를 관찰합니다. 🎜

1.2 다른 커널을 사용하여 이미지 블러 수행

🎜(1) 먼저 get_gaussian_edge_blur_kernel() 함수를 정의하여 2D</code를 반환합니다. > 가장자리 흐림에는 Gaussian Blur 커널이 사용됩니다. 이 함수는 가우스의 표준 편차( σ)와 생성된 <code>2D 커널의 크기를 허용합니다(예: sz = 15는 커널을 생성합니다) 15x15 code> 크기)를 함수의 매개변수로 사용합니다. 아래와 같이 1D 가우스 커널이 먼저 생성된 후 두 개의 1D 가우스 커널의 외부 곱이 계산되어 2D 커널이 반환됩니다. : 🎜

im = imread('1.png', as_gray=True)
freq = fp.fft2(im)

🎜 (2) 다음으로 get_motion_blur_kernel() 함수를 정의하여 모션 블러 커널을 생성하고, 주어진 길이와 특정 방향(각도)을 갖는 선을 얻습니다. ) 입력 이미지의 모션 블러 효과를 시뮬레이션하기 위한 컨볼루션 커널: 🎜

freq_uniform = ndimage.fourier_uniform(freq, size=10)

🎜 함수 get_motion_blur_kernel()는 블러의 길이와 각도, 블러 커널의 크기를 매개변수로 사용합니다. OpenCV의 warpaffine ()을 사용합니다. 이 함수는 커널 행렬을 반환합니다(행렬의 중심을 중간점으로 취하고, 주어진 길이와 주어진 각도를 사용하여 커널을 얻습니다). . 🎜🎜(3) 마지막으로 get_out_of_focus_kernel() 함수를 정의하여 초점이 맞지 않는 커널(초점이 맞지 않는 이미지 흐림 시뮬레이션)을 생성합니다. 컨볼루션 커널로 사용하기 위해 주어진 반경을 기반으로 하는 원, 이 함수는 반경 R(Deocus Radius)과 생성될 커널 크기를 입력 매개변수로 허용합니다. : 🎜

fig, (axes1, axes2) = plt.subplots(1, 2, figsize=(20,10))
plt.gray() # show the result in grayscale
im1 = fp.ifft2(freq_uniform)
axes1.imshow(im), axes1.axis('off')
axes1.set_title('Original Image', size=10)
axes2.imshow(im1.real) # the imaginary part is an artifact
axes2.axis('off')
axes2.set_title('Blurred Image with Fourier Uniform', size=10)
plt.tight_layout()
plt.show()

🎜(4) 다음으로, 이미지의 요소별 곱셈과 주파수의 컨볼루션 커널을 사용하여 주파수 영역 컨볼루션을 수행하는 dft_convolve() 함수를 구현합니다. 도메인(컨볼루션 정리에 기초함) 이 함수는 또한 컨볼루션 계산 후 얻은 입력 이미지, 커널 및 출력 이미지를 플롯합니다. 🎜

plt.figure(figsize=(10,10))
plt.imshow( (20*np.log10( 0.1 + fp.fftshift(freq_uniform))).real.astype(int))
plt.title('Frequency Spectrum with fourier uniform', size=10)
plt.show()

🎜(5) get_gaussian_edge_blur_kernel() 커널 함수를 이미지에 적용합니다. 입력, 커널 및 출력 흐릿한 이미지 플롯: 🎜

freq_ellipsoid = ndimage.fourier_ellipsoid(freq, size=10)
im1 = fp.ifft2(freq_ellipsoid)

🎜(6) 다음으로 get_motion_blur_kernel() 함수를 이미지에 적용하고 흐릿한 입력, 커널 및 출력을 플롯합니다. image: 🎜

fig, (axes1, axes2) = plt.subplots(1, 2, figsize=(20,10))
axes1.imshow(im), axes1.axis('off')
axes1.set_title('Original Image', size=10)
axes2.imshow(im1.real) # the imaginary part is an artifact
axes2.axis('off')
axes2.set_title('Blurred Image with Fourier Ellipsoid', size=10)
plt.tight_layout()
plt.show()

🎜(7) 마지막으로 get_out_of_focus_kernel() 함수를 이미지에 적용하고 입력, 커널 및 출력 흐림 이미지를 그립니다. 🎜

plt.figure(figsize=(10,10))
plt.imshow( (20*np.log10( 0.1 + fp.fftshift(freq_ellipsoid))).real.astype(int))
plt.title('Frequency Spectrum with Fourier ellipsoid', size=10)
plt.show()

🎜2 사용. scipy.ndimage 필터는 이미지를 흐리게 합니다 🎜🎜 scipy.ndimage 모듈은 주파수 영역의 이미지에 저역 통과 필터를 적용할 수 있는 일련의 기능을 제공합니다. 이 섹션에서는 여러 예제를 통해 이러한 필터 중 일부를 사용하는 방법을 알아봅니다. 🎜

2.1 fourier_gaussian() 함수 사용

🎜 scipy.ndimage 라이브러리의 fourier_gaussian() 함수를 사용하여 가우시안 커널을 사용하여 컨볼루션을 수행합니다. 주파수 영역이 작동합니다. 🎜🎜(1) 먼저 입력 이미지를 읽고 이를 회색조 이미지로 변환한 다음 FFT를 사용하여 주파수 영역 표현을 얻습니다. 🎜

import numpy as np
import numpy.fft as fp
from skimage.color import rgb2gray
from skimage.io import imread
import matplotlib.pyplot as plt
from scipy import signal
from matplotlib.ticker import LinearLocator, FormatStrFormatter

im = rgb2gray(imread('1.png'))
freq = fp.fft2(im)

🎜( 2) 다음으로, fourier_gaussian() 함수를 사용하여 표준 편차가 다른 두 개의 가우스 커널을 사용하여 이미지에 흐림 작업을 수행하고 입력 이미지와 출력 이미지를 플로팅합니다. 파워 스펙트럼: 🎜

kernel = np.outer(signal.gaussian(im.shape[0], 1), signal.gaussian(im.shape[1], 1))

2.2 fourier_uniform() 함수를 사용하세요.

🎜scipy.ndimage 모듈의 함수 fourier_uniform()을 사용하여 다차원 균일 푸리에를 구현하세요. 필터. 주파수 배열은 주어진 크기의 정사각형 커널의 푸리에 변환으로 곱해집니다. 다음으로 LPF(평균 필터)를 사용하여 입력 회색조 이미지를 흐리게 하는 방법을 알아봅니다. 🎜🎜(1) 먼저 입력 이미지를 읽고 DFT를 사용하여 주파수 영역 표현을 얻습니다. 🎜

im = imread('1.png', as_gray=True)
freq = fp.fft2(im)

(2) 然后，使用函数 fourier_uniform() 应用 10x10 方形核(由功率谱上的参数指定)，以获取平滑输出：

freq_uniform = ndimage.fourier_uniform(freq, size=10)

(3) 绘制原始输入图像和模糊后的图像：

fig, (axes1, axes2) = plt.subplots(1, 2, figsize=(20,10))
plt.gray() # show the result in grayscale
im1 = fp.ifft2(freq_uniform)
axes1.imshow(im), axes1.axis('off')
axes1.set_title('Original Image', size=10)
axes2.imshow(im1.real) # the imaginary part is an artifact
axes2.axis('off')
axes2.set_title('Blurred Image with Fourier Uniform', size=10)
plt.tight_layout()
plt.show()

(4) 最后，绘制显示方形核的功率谱：

plt.figure(figsize=(10,10))
plt.imshow( (20*np.log10( 0.1 + fp.fftshift(freq_uniform))).real.astype(int))
plt.title('Frequency Spectrum with fourier uniform', size=10)
plt.show()

2.3 使用 fourier_ellipsoid() 函数

与上一小节类似，通过将方形核修改为椭圆形核，我们可以使用椭圆形核生成模糊的输出图像。

(1) 类似的，我们首先在图像的功率谱上应用函数 fourier_ellipsoid()，并使用 IDFT 在空间域中获得模糊后的输出图像：

freq_ellipsoid = ndimage.fourier_ellipsoid(freq, size=10)
im1 = fp.ifft2(freq_ellipsoid)

(2) 接下来，绘制原始输入图像和模糊后的图像：

fig, (axes1, axes2) = plt.subplots(1, 2, figsize=(20,10))
axes1.imshow(im), axes1.axis('off')
axes1.set_title('Original Image', size=10)
axes2.imshow(im1.real) # the imaginary part is an artifact
axes2.axis('off')
axes2.set_title('Blurred Image with Fourier Ellipsoid', size=10)
plt.tight_layout()
plt.show()

(3) 最后，显示应用椭圆形核后图像的频谱：

plt.figure(figsize=(10,10))
plt.imshow( (20*np.log10( 0.1 + fp.fftshift(freq_ellipsoid))).real.astype(int))
plt.title('Frequency Spectrum with Fourier ellipsoid', size=10)
plt.show()



3. 使用 scipy.fftpack 实现高斯模糊

我们已经学习了如何在实际应用中使用 numpy.fft 模块的 2D-FFT。在本节中，我们将介绍 scipy.fftpack 模块的 fft2() 函数用于实现高斯模糊。

(1) 使用灰度图像作为输入，并使用 FFT 从图像中创建 2D 频率响应数组：

import numpy as np
import numpy.fft as fp
from skimage.color import rgb2gray
from skimage.io import imread
import matplotlib.pyplot as plt
from scipy import signal
from matplotlib.ticker import LinearLocator, FormatStrFormatter

im = rgb2gray(imread('1.png'))
freq = fp.fft2(im)

(2) 通过计算两个 1D 高斯核的外积，在空间域中创建高斯 2D 核用作 LPF：

kernel = np.outer(signal.gaussian(im.shape[0], 1), signal.gaussian(im.shape[1], 1))

(3) 使用 DFT 获得高斯核的频率响应：

freq_kernel = fp.fft2(fp.ifftshift(kernel))

(4) 使用卷积定理通过逐元素乘法在频域中将 LPF 与输入图像卷积：

convolved = freq*freq_kernel # by the Convolution theorem

(5) 使用 IFFT 获得输出图像，需要注意的是，要正确显示输出图像，需要缩放输出图像：

im_blur = fp.ifft2(convolved).real
im_blur = 255 * im_blur / np.max(im_blur)

(6) 绘制图像、高斯核和在频域中卷积后获得图像的功率谱，可以使用 matplotlib.colormap 绘制色，以了解不同坐标下的频率响应值：

plt.figure(figsize=(20,20))
plt.subplot(221), plt.imshow(kernel, cmap='coolwarm'), plt.colorbar()
plt.title('Gaussian Blur Kernel', size=10)
plt.subplot(222)
plt.imshow( (20*np.log10( 0.01 + fp.fftshift(freq_kernel))).real.astype(int), cmap='inferno')
plt.colorbar()
plt.title('Gaussian Blur Kernel (Freq. Spec.)', size=10)
plt.subplot(223), plt.imshow(im, cmap='gray'), plt.axis('off'), plt.title('Input Image', size=10)
plt.subplot(224), plt.imshow(im_blur, cmap='gray'), plt.axis('off'), plt.title('Output Blurred Image', size=10)
plt.tight_layout()
plt.show()

(7) 要绘制输入/输出图像和 3D 核的功率谱，我们定义函数 plot_3d()，使用 mpl_toolkits.mplot3d 模块的 plot_surface() 函数获取 3D 功率谱图，给定相应的 Y 和Z值作为 2D 阵列传递：

def plot_3d(X, Y, Z, cmap=plt.cm.seismic):
    fig = plt.figure(figsize=(20,20))
    ax = fig.gca(projection='3d')
    # Plot the surface.
    surf = ax.plot_surface(X, Y, Z, cmap=cmap, linewidth=5, antialiased=False)
    #ax.plot_wireframe(X, Y, Z, rstride=10, cstride=10)
    #ax.set_zscale("log", nonposx='clip')
    #ax.zaxis.set_scale('log')
    ax.zaxis.set_major_locator(LinearLocator(10))
    ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
    ax.set_xlabel('F1', size=15)
    ax.set_ylabel('F2', size=15)
    ax.set_zlabel('Freq Response', size=15)
    #ax.set_zlim((-40,10))
    # Add a color bar which maps values to colors.
    fig.colorbar(surf) #, shrink=0.15, aspect=10)
    #plt.title('Frequency Response of the Gaussian Kernel')
    plt.show()

(8) 在 3D 空间中绘制高斯核的频率响应，并使用 plot_3d() 函数：

Y = np.arange(freq.shape[0]) #-freq.shape[0]//2,freq.shape[0]-freq.shape[0]//2)
X = np.arange(freq.shape[1]) #-freq.shape[1]//2,freq.shape[1]-freq.shape[1]//2)
X, Y = np.meshgrid(X, Y)
Z = (20*np.log10( 0.01 + fp.fftshift(freq_kernel))).real
plot_3d(X,Y,Z)

下图显示了 3D 空间中高斯 LPF 核的功率谱：



(9) 绘制 3D 空间中输入图像的功率谱：

Z = (20*np.log10( 0.01 + fp.fftshift(freq))).real
plot_3d(X,Y,Z)



(10) 最后，绘制输出图像的功率谱(通过将高斯核与输入图像卷积获得)：

Z = (20*np.log10( 0.01 + fp.fftshift(convolved))).real
plot_3d(X,Y,Z)



从输出图像的频率响应中可以看出，高频组件被衰减，从而导致细节的平滑/丢失，并导致输出图像模糊。

4. 彩色图像频域卷积

在本节中，我们将学习使用 scipy.signal 模块的 fftconvolve() 函数，用于与 RGB 彩色输入图像进行频域卷积，从而生成 RGB 彩色模糊输出图像：

scipy.signal.fftconvolve(in1, in2, mode='full', axes=None)

函数使用 FFT 卷积两个 n 维数组 in1 和 in2，并由 mode 参数确定输出大小。卷积模式 mode 具有以下类型：

• 输出是输入的完全离散线性卷积，默认情况下使用此种卷积模式

• 输出仅由那些不依赖零填充的元素组成，in1 或 in2 的尺寸必须相同

• 输出的大小与 in1 相同，并以输出为中心

4.1 基于 scipy.signal 模块的彩色图像频域卷积

接下来，我们实现高斯低通滤波器并使用 Laplacian 高通滤波器执行相应操作。

(1) 首先，导入所需的包，并读取输入 RGB 图像：

from skimage import img_as_float
from scipy import signal
import numpy as np
import matplotlib.pyplot as plt

im = img_as_float(plt.imread('1.png'))

(2) 实现函数 get_gaussian_edge_kernel()，并根据此函数创建一个尺寸为 15x15 的高斯核：

def get_gaussian_edge_blur_kernel(sigma, sz=15):
    # First create a 1-D Gaussian kernel
    x = np.linspace(-10, 10, sz)
    kernel_1d = np.exp(-x**2/sigma**2)
    kernel_1d /= np.trapz(kernel_1d) # normalize the sum to 1.0
    # create a 2-D Gaussian kernel from the 1-D kernel
    kernel_2d = kernel_1d[:, np.newaxis] * kernel_1d[np.newaxis, :]
    return kernel_2d
kernel = get_gaussian_edge_blur_kernel(sigma=10, sz=15)

(3) 然后，使用 np.newaxis 将核尺寸重塑为 15x15x1，并使用 same 模式调用函数 signal.fftconvolve()：

im1 = signal.fftconvolve(im, kernel[:, :, np.newaxis], mode='same')
im1 = im1 / np.max(im1)

在以上代码中使用的 mode='same'，可以强制输出形状与输入阵列形状相同，以避免边框效应。

(4) 接下来，使用 laplacian HPF 内核，并使用相同函数执行频域卷积。需要注意的是，我们可能需要缩放/裁剪输出图像以使输出值保持像素的浮点值范围 [0,1] 内：

kernel = np.array([[0,-1,0],[-1,4,-1],[0,-1,0]])
im2 = signal.fftconvolve(im, kernel[:, :, np.newaxis], mode='same')
im2 = im2 / np.max(im2)
im2 = np.clip(im2, 0, 1)

(5) 最后，绘制输入图像和使用卷积创建的输出图像。

plt.figure(figsize=(20,10))
plt.subplot(131), plt.imshow(im), plt.axis('off'), plt.title('original image', size=10)
plt.subplot(132), plt.imshow(im1), plt.axis('off'), plt.title('output with Gaussian LPF', size=10)
plt.subplot(133), plt.imshow(im2), plt.axis('off'), plt.title('output with Laplacian HPF', size=10)
plt.tight_layout()
plt.show()

위 내용은 Python에서 저역 통과 필터 흐림 이미지 기능을 구현하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!