Tracer la transformée de Fourier rapide(FFT) en Python

1. Utilisez le module Python scipy.fft pour la transformée de Fourier rapide
2. Utilisez le module Python numpy.fft pour la transformée de Fourier rapide

Dans cet article du didacticiel Python, nous allons comprendre la transformation de Fourier rapide et la tracer en Python.

L’analyse de Fourier transmet une fonction en tant qu’agrégat de composants périodiques et extrait ces signaux des composants. Lorsque la fonction et sa transformée sont échangées avec les parties discrètes, elles sont alors exprimées en tant que transformée de Fourier.

FFT fonctionne principalement avec des algorithmes de calcul pour augmenter la vitesse d’exécution. Algorithmes de filtrage, multiplication, traitement d’images sont quelques-unes de ses applications.

Utilisez le module Python scipy.fft pour la transformée de Fourier rapide

L’un des points les plus importants à mesurer dans la transformée de Fourier rapide est que nous ne pouvons l’appliquer qu’aux données dans lesquelles l’horodatage est uniforme. Le module scipy.fft convertit le domaine temporel donné en domaine fréquentiel. La FFT de longueur N séquence x[n] est calculée par la fonction fft().

Par exemple,

from scipy.fftpack import fft
import numpy as np

x = np.array([4.0, 2.0, 1.0, -3.0, 1.5])
y = fft(x)
print(y)

Production:

[5.5       -0.j         6.69959347-2.82666927j 0.55040653+3.51033344j
 0.55040653-3.51033344j 6.69959347+2.82666927j]

Nous pouvons également utiliser des signaux bruités car ils nécessitent un calcul élevé. Par exemple, nous pouvons utiliser la fonction numpy.sin() pour créer une série de sinus et la tracer. Pour tracer la série, nous utiliserons le module Matplotlib.

Voir l’exemple suivant.

import scipy.fft
import matplotlib.pyplot as plt
import numpy as np


N = 500
T = 1.0 / 600.0
x = np.linspace(0.0, N * T, N)
y = np.sin(60.0 * 2.0 * np.pi * x) + 0.5 * np.sin(90.0 * 2.0 * np.pi * x)
y_f = scipy.fft.fft(y)
x_f = np.linspace(0.0, 1.0 / (2.0 * T), N // 2)

plt.plot(x_f, 2.0 / N * np.abs(y_f[: N // 2]))
plt.show()

Notez que le module scipy.fft est construit sur le module scipy.fftpack avec plus de fonctionnalités supplémentaires et des fonctionnalités mises à jour.

Utilisez le module Python numpy.fft pour la transformée de Fourier rapide

Le numpy.fft fonctionne de manière similaire au module scipy.fft. Le scipy.fft exporte certaines fonctionnalités du numpy.fft.

Le numpy.fft est considéré comme plus rapide lorsqu’il s’agit de tableaux 2D. La mise en œuvre est la même.

Par exemple,

import matplotlib.pyplot as plt
import numpy as np

N = 500
T = 1.0 / 600.0
x = np.linspace(0.0, N * T, N)
y = np.sin(60.0 * 2.0 * np.pi * x) + 0.5 * np.sin(90.0 * 2.0 * np.pi * x)
y_f = np.fft.fft(y)
x_f = np.linspace(0.0, 1.0 / (2.0 * T), N // 2)

plt.plot(x_f, 2.0 / N * np.abs(y_f[: N // 2]))
plt.show()