Python+OpenCV：傅里叶变换(Fourier Transform)

灰太狼 2022-12-21 10:50 149阅读 0赞

## Python+OpenCV：傅里叶变换(Fourier Transform) ##

####################################################################################################
    # 图像傅里叶变换(Image Fourier Transform)
    def lmc_cv_image_fourier_transform():
        """
            函数功能: 图像傅里叶变换(Image Fourier Transform)。
        """
    
        # Fourier Transform in Numpy
        image = lmc_cv.imread('D:/99-Research/Python/Image/messi.jpg', flags=lmc_cv.IMREAD_GRAYSCALE)
        fft_image = np.fft.fft2(image)
        fft_shift_image = np.fft.fftshift(fft_image)
        magnitude_spectrum = 20 * np.log(np.abs(fft_shift_image))
        pyplot.figure('Fourier Transform in Numpy')
        pyplot.subplot(1, 2, 1)
        pyplot.imshow(image, cmap='gray')
        pyplot.title('Original Image')
        pyplot.xticks([])
        pyplot.yticks([])
        pyplot.subplot(1, 2, 2)
        pyplot.imshow(magnitude_spectrum, cmap='gray')
        pyplot.title('Magnitude Spectrum')
        pyplot.xticks([])
        pyplot.yticks([])
        pyplot.show()
    
        # high pass filtering and reconstruct the image in Numpy
        rows, cols = image.shape
        crow, ccol = rows // 2, cols // 2
        fft_shift_image[crow - 30:crow + 31, ccol - 30:ccol + 31] = 0
        fft_ishift = np.fft.ifftshift(fft_shift_image)
        inverse_image_complex = np.fft.ifft2(fft_ishift)
        inverse_image_real = np.real(inverse_image_complex)
        pyplot.figure('HPF Fourier Transform in Numpy')
        pyplot.subplot(1, 3, 1)
        pyplot.imshow(image, cmap='gray')
        pyplot.title('Original Image')
        pyplot.xticks([])
        pyplot.yticks([])
        pyplot.subplot(1, 3, 2)
        pyplot.imshow(inverse_image_real, cmap='gray')
        pyplot.title('Image after HPF')
        pyplot.xticks([])
        pyplot.yticks([])
        pyplot.subplot(1, 3, 3)
        pyplot.imshow(inverse_image_real)
        pyplot.title('High Pass Filtering Image')
        pyplot.xticks([])
        pyplot.yticks([])
        pyplot.show()
    
        # Fourier Transform in OpenCV
        dft_image = lmc_cv.dft(np.float32(image), flags=lmc_cv.DFT_COMPLEX_OUTPUT)
        dft_shift_image = np.fft.fftshift(dft_image)
        magnitude_spectrum = 20 * np.log(lmc_cv.magnitude(dft_shift_image[:, :, 0], dft_shift_image[:, :, 1]))
        pyplot.figure('Fourier Transform in OpenCV')
        pyplot.subplot(1, 2, 1)
        pyplot.imshow(image, cmap='gray')
        pyplot.title('Original Image')
        pyplot.xticks([])
        pyplot.yticks([])
        pyplot.subplot(1, 2, 2)
        pyplot.imshow(magnitude_spectrum, cmap='gray')
        pyplot.title('Magnitude Spectrum')
        pyplot.xticks([])
        pyplot.yticks([])
        pyplot.show()
    
        # low pass filtering and reconstruct the image in OpenCV
        rows, cols = image.shape
        crow, ccol = rows // 2, cols // 2
        # create a mask first, center square is 1, remaining all zeros
        mask = np.zeros((rows, cols, 2), np.uint8)
        mask[crow - 30:crow + 30, ccol - 30:ccol + 30] = 1
        # apply mask and inverse DFT
        fft_shift_image = dft_shift_image * mask
        fft_ishift = np.fft.ifftshift(fft_shift_image)
        inverse_image = lmc_cv.idft(fft_ishift)
        inverse_image = lmc_cv.magnitude(inverse_image[:, :, 0], inverse_image[:, :, 1])
        pyplot.figure('LPF Fourier Transform in OpenCV')
        pyplot.subplot(1, 2, 1)
        pyplot.imshow(image, cmap='gray')
        pyplot.title('Original Image')
        pyplot.xticks([])
        pyplot.yticks([])
        pyplot.subplot(1, 2, 2)
        pyplot.imshow(inverse_image, cmap='gray')
        pyplot.title('Low Pass Filtering Image')
        pyplot.xticks([])
        pyplot.yticks([])
        pyplot.show()
    
        # Performance Optimization of DFT
        print("{} {}".format(rows, cols))
        nrows = lmc_cv.getOptimalDFTSize(rows)
        ncols = lmc_cv.getOptimalDFTSize(cols)
        print("{} {}".format(nrows, ncols))
        # pad zeros method 1
        new_image = np.zeros((nrows, ncols))
        new_image[:rows, :cols] = image
        # pad zeros method 2
        right = ncols - cols
        bottom = nrows - rows
        bordertype = lmc_cv.BORDER_CONSTANT  # just to avoid line breakup in PDF file
        new_image = lmc_cv.copyMakeBorder(image, 0, bottom, 0, right, bordertype, value=0)
        # calculate the DFT performance comparison of Numpy function
        number = 1000
        start_time = time.time()
        for i in range(number):
            np.fft.fft2(image)
        print(f"{number} loops, best of {(time.time() - start_time) / number} ms per loop")
        start_time = time.time()
        for i in range(number):
            np.fft.fft2(image, [nrows, ncols])
        print(f"{number} loops, best of {(time.time() - start_time) / number} ms per loop")
        # calculate the DFT performance comparison of OpenCV function
        start_time = time.time()
        for i in range(number):
            lmc_cv.dft(np.float32(image), flags=lmc_cv.DFT_COMPLEX_OUTPUT)
        print(f"{number} loops, best of {(time.time() - start_time) / number} ms per loop")
        start_time = time.time()
        for i in range(number):
            lmc_cv.dft(np.float32(new_image), flags=lmc_cv.DFT_COMPLEX_OUTPUT)
        print(f"{number} loops, best of {(time.time() - start_time) / number} ms per loop")
    
        # High Pass Filter or Low Pass Filter
        # simple averaging filter without scaling parameter
        mean_filter = np.ones((3, 3))
        # creating a gaussian filter
        x = lmc_cv.getGaussianKernel(5, 10)
        gaussian = x * x.T
        # different edge detecting filters
        # scharr in x-direction
        scharr = np.array([[-3, 0, 3],
                           [-10, 0, 10],
                           [-3, 0, 3]])
        # sobel in x direction
        sobel_x = np.array([[-1, 0, 1],
                            [-2, 0, 2],
                            [-1, 0, 1]])
        # sobel in y direction
        sobel_y = np.array([[-1, -2, -1],
                            [0, 0, 0],
                            [1, 2, 1]])
        # laplacian
        laplacian = np.array([[0, 1, 0],
                              [1, -4, 1],
                              [0, 1, 0]])
        filters = [mean_filter, gaussian, laplacian, sobel_x, sobel_y, scharr]
        filter_name = ['mean_filter', 'gaussian', 'laplacian', 'sobel_x', 'sobel_y', 'scharr_x']
        fft_filters = [np.fft.fft2(x) for x in filters]
        fft_shift = [np.fft.fftshift(y) for y in fft_filters]
        magnitude_spectrum = [20 * np.log(np.abs(z) + 1.00) for z in fft_shift]
        pyplot.figure('High Pass Filter or Low Pass Filter')
        for i in range(6):
            pyplot.subplot(2, 3, i + 1)
            pyplot.imshow(magnitude_spectrum[i], cmap='gray')
            pyplot.title(filter_name[i])
            pyplot.xticks([])
            pyplot.yticks([])
        pyplot.show()
    
        # 根据用户输入保存图像
        if ord("q") == (lmc_cv.waitKey(0) & 0xFF):
            # 销毁窗口
            pyplot.close('all')
        return

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 4][]

### Performance Optimization of DFT ###

581 739  
600 750

calculate the DFT performance comparison of Numpy function:  
1000 loops, best of 0.057367880821228026 ms per loop  
1000 loops, best of 0.022089494943618775 ms per loop

calculate the DFT performance comparison of OpenCV function:  
1000 loops, best of 0.010666451215744019 ms per loop  
1000 loops, best of 0.005198104381561279 ms per loop

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70]: /images/20221120/9afcbaca4bc44881bb25c7d4fba6f064.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 1]: /images/20221120/eb485f5b3e724c06bb193eb6a80aecfa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 2]: /images/20221120/9afc565a65b84e61b662520b8f486c64.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 3]: /images/20221120/e34a8b7c9744468b82bf87fa454306cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 4]: /images/20221120/5f6d5a9207834913b66a862862e51cf1.png