在傅立叶域中将图像与内核卷积

时间:2019-02-26 03:11:36

标签: python image-processing scipy fft convolution

我在图像和卷积内核周围使用零填充,将它们转换为傅立叶域,然后将它们反转以得到卷积图像,请参见下面的代码。但是,结果是错误的。我原本希望图像模糊,但是输出是四个偏移的季度。为什么输出错误,我该如何修复代码?

输入图像:

input image

卷积结果:

output image

from PIL import Image,ImageDraw,ImageOps,ImageFilter
import numpy as np 
from scipy import fftpack
from copy import deepcopy
import imageio
## STEP 1 ##
im1=Image.open("pika.jpeg")
im1=ImageOps.grayscale(im1)
im1.show()
print("s",im1.size)
## working on this image array
im_W=np.array(im1).T
print("before",im_W.shape)
if(im_W.shape[0]%2==0):
im_W=np.pad(im_W, ((1,0),(0,0)), 'constant')
if(im_W.shape[1]%2==0):
im_W=np.pad(im_W, ((0,0),(1,0)), 'constant')
print("after",im_W.shape)
Boxblur=np.array([[1/9,1/9,1/9],[1/9,1/9,1/9],[1/9,1/9,1/9]])
dim=Boxblur.shape[0]

##padding before frequency domain multipication
pad_size=(Boxblur.shape[0]-1)/2
pad_size=int(pad_size)
##padded the image(starts here)

p_im=np.pad(im_W, ((pad_size,pad_size),(pad_size,pad_size)), 'constant')
t_b=(p_im.shape[0]-dim)/2
l_r=(p_im.shape[1]-dim)/2
t_b=int(t_b)
l_r=int(l_r)

##padded the image(ends here)

## padded the kernel(starts here)
k_im=np.pad(Boxblur, ((t_b,t_b),(l_r,l_r)), 'constant')
print("hjhj",k_im)
print("kernel",k_im.shape)

##fourier transforms image and kernel
fft_im = fftpack.fftshift(fftpack.fft2(p_im))
fft_k  = fftpack.fftshift(fftpack.fft2(k_im))
con_in_f=fft_im*fft_k
ifft2 = abs(fftpack.ifft2(fftpack.ifftshift(con_in_f)))
convolved=(np.log(abs(ifft2))* 255 / np.amax(np.log(abs(ifft2)))).astype(np.uint8)
final=Image.fromarray(convolved.T)
final.show()
u=im1.filter(ImageFilter.Kernel((3,3), [1/9,1/9,1/9,1/9,1/9,1/9,1/9,1/9,1/9], scale=None, offset=0))
u.show()

1 个答案:

答案 0 :(得分:1)

离散傅里叶变换(DFT)和FFT(计算DFT)的起源都来自两者的第一个元素(对于图像,为左上像素)输入和输出。这就是为什么我们经常在输出上使用fftshift函数,以便将原点移动到我们更熟悉的位置(图像的中间)的原因。

这意味着在将其传递给FFT函数之前,我们需要将3x3均匀加权模糊内核转换为如下形式:

1/9  1/9  0  0  ... 0  1/9
1/9  1/9  0  0  ... 0  1/9
  0    0  0  0  ... 0    0
...  ...               ...
  0    0  0  0  ... 0    0
1/9  1/9  0  0  ... 0  1/9

也就是说,内核的中间位于图像的左上角,中间的上方和左侧的像素环绕并出现在图像的右端和底端。

我们可以使用ifftshift函数执行此操作,该函数在填充后应用于内核。在填充内核时,我们需要注意起源(内核中间)在内核映像k_im.shape // 2中的位置k_im(整数除法)处。最初,原点位于[3,3]//2 == [1,1]。通常,我们匹配大小的图像大小相等,例如[256,256]。原点将在[256,256]//2 == [128,128]。这意味着我们需要在左侧和右侧(以及底部和顶部)填充不同的量。我们需要谨慎计算此填充:

sz = img.shape  # the sizes we're matching
kernel = np.ones((3,3)) / 9
sz = (sz[0] - kernel.shape[0], sz[1] - kernel.shape[1])  # total amount of padding
kernel = np.pad(kernel, (((sz[0]+1)//2, sz[0]//2), ((sz[1]+1)//2, sz[1]//2)), 'constant')
kernel = fftpack.ifftshift(kernel)

请注意,不需要填充输入图像img(尽管如果要强制执行FFT便宜的尺寸,则可以执行此操作)。也不需要在乘法之前将fftshift应用于FFT的结果,然后在之后立即反转此移位,这些移位是多余的。仅在要显示傅立叶域图像时,才应使用fftshift。最后,对滤镜图像进行对数缩放是错误的。

结果代码是(我使用pyplot进行显示,完全不使用PIL):

import numpy as np
from scipy import misc
from scipy import fftpack
import matplotlib.pyplot as plt

img = misc.face()[:,:,0]

kernel = np.ones((3,3)) / 9
sz = (img.shape[0] - kernel.shape[0], img.shape[1] - kernel.shape[1])  # total amount of padding
kernel = np.pad(kernel, (((sz[0]+1)//2, sz[0]//2), ((sz[1]+1)//2, sz[1]//2)), 'constant')
kernel = fftpack.ifftshift(kernel)

filtered = np.real(fftpack.ifft2(fftpack.fft2(img) * fftpack.fft2(kernel)))
plt.imshow(filtered, vmin=0, vmax=255)
plt.show()

请注意,我正在使用逆FFT的实部。虚部应仅包含非常接近零的值,这是在计算中舍入误差的结果。取绝对值(尽管很普遍)是不正确的。例如,您可能想对包含负值的图像应用滤镜,或者应用产生负值的滤镜。在这里取绝对值会产生人工制品。如果逆FFT的输出包含的虚数值明显不同于零,则填充滤波内核的方式存在错误。

还要注意,这里的内核很小,因此模糊效果也很小。为了更好地看到模糊的效果,请制作更大的内核,例如np.ones((7,7)) / 49