SciPy - fft2() Function

---

---

The scipy.fft.fft2() function gives you the 2D Fast Fourier Transform (FFT) of a 2D array. It changes spatial or time-domain signals into frequency domain data showing the data as a sum of sinusoidal components.

People often use the scipy.fft.fft2() function to look at frequency parts of 2D signals in image processing, pattern recognition, and signal analysis. This method also helps with things like filtering images finding features, and changing frequencies.

The plan parameter in scipy.fft.fft2 allows users to use the precomputed FFT plans to realize better performance for repeating transforms of big datasets, significantly cutting down computation time.

The fft() function calculates the FFT for one-dimensional signals like audio or time-series data, transforming them into the frequency domain. The fft2() approach works with 2D signals like pictures or matrices, examining frequency patterns in two dimensions.

Syntax

The syntax for the SciPy fft2() method is as follows −

.fft2(x, s=None, axes=(-2, -1), norm=None, overwrite_x=False, workers=None, *, plan=None)

Parameters

This method accepts the following parameters −

• x (array_like) − Input 2D array to be transformed. It can be real or complex.

• s − Shape of the FFT to compute along each axis. If given, the input is either zero-padded or truncated to match the specified shape. Default is the shape of the input array.

• axes − Axes over which the FFT is computed. Default is the last two axes (-2, -1) of the input array.

• norm − The normalization mode allows control over scaling: "backward" (default, no scaling), "ortho" (unitary scaling for energy preservation), and "forward" (scales the output by 1/n, where n is the transform length).

• overwrite_x − If True, allows the input array x to be overwritten for better performance. Default is False.

• workers − Number of parallel workers to use for computation. Default is None, meaning a single thread is used.

• plan − Precomputed plan for FFT optimization (advanced use). Default is None.

Return Value

y (ndarray) − The transformed 2D array in the frequency domain. The output is complex, containing the amplitude and phase information of the frequency components.

Example 1

This is a basic example of calculating the 2D FFT of a basic 2x2 array using fft2() method and then transforming this array into the frequency domain for evaluating the frequency components of the signal.

import numpy as np
from scipy.fft import fft2

# Define a 2D input array
x = np.array([[1, 2], [3, 4]])

# Compute the 2D FFT
result = fft2(x)
print("2D FFT Result:\n", result)

When we run above program, it produces following result

2D FFT Result:
 [[10.-0.j -2.-0.j]
 [-4.-0.j  0.-0.j]]

Example 2

This is an example of using zero padding with the 2D FFT to expand the input array to 4x4 form, giving increased frequency resolution and greater extents of frequency analysis in the output.

import numpy as np
from scipy.fft import fft2

# Compute 2D FFT with a different shape
fft_padded = fft2(x, s=(4, 4))
print("2D FFT with zero-padding:\n", fft_padded)

Following is an output of the above code

2D FFT with zero-padding:
 [[10.-0.j  4.-6.j -2.-0.j  4.+6.j]
 [ 3.-7.j -3.-5.j -1.+1.j  5.-1.j]
 [-4.-0.j -2.+2.j  0.-0.j -2.-2.j]
 [ 3.+7.j  5.+1.j -1.-1.j -3.+5.j]]

Example 3

The norm parameter controls the scaling of the FFT result, so that the amplitude is represented correctly.

The ortho normalization ensures that the FFT and the inverse FFT scale consistently. This is useful in image processing applications where changes in frequency space need to be reversed to the original spatial domain without distortion.

The below code, first does a 2D FFT with normalization using fft2() method on a sample matrix and then reconstructs the original image with the inverse FFT ifft2() method using the same normalization.

import numpy as np
from scipy.fft import fft2, ifft2

a = np.array([[10, 20], [30, 40]])

# Perform FFT with normalization
fft_result = fft2(a, norm="ortho")

# Inverse FFT with the same normalization
reconstructed_image = ifft2(fft_result, norm="ortho")

print("Reconstructed Image:\n", reconstructed_image)

Output of the above code is as follows

Reconstructed Image:
 [[10.-0.j 20.+0.j]
 [30.+0.j 40.+0.j]]