Wykreślanie szybkiej transformacji Fouriera w Pythonie

Ważną rzeczą w fft jest to, że może być stosowany tylko do danych, w których znacznik czasu jest jednolity (tj. jednolite pobieranie próbek w czasie, jak pokazano powyżej).

W przypadku niejednorodnego pobierania próbek należy użyć funkcji do dopasowania danych. Istnieje kilka samouczków i funkcji do wyboru:

Https://github.com/tiagopereira/python_tips/wiki/Scipy%3A-curve-fitting http://docs.scipy.org/doc/numpy/reference/generated/numpy.polyfit.html

Jeśli dopasowanie nie jest opcją, możesz bezpośrednio użyć jakiejś formy interpolacji, aby interpolować dane do jednolitego pobierania próbek:

Https://docs.scipy.org/doc/scipy-0.14.0/reference/tutorial/interpolate.html

Gdy masz jednolite próbki, będziesz musiał tylko martwić się o delta czasu (t[1] - t[0]) swoich próbek. W takim przypadku możesz bezpośrednio użyć fft funkcje

Y    = numpy.fft.fft(y)
freq = numpy.fft.fftfreq(len(y), t[1] - t[0])

pylab.figure()
pylab.plot( freq, numpy.abs(Y) )
pylab.figure()
pylab.plot(freq, numpy.angle(Y) )
pylab.show()

Wysoki skok, jaki masz, wynika z części DC (niezrównanej, tj. freq = 0) twojego sygnału. To kwestia skali. Jeśli chcesz zobaczyć zawartość częstotliwości innej niż DC, do wizualizacji może być konieczne wykreślenie z offsetu 1, a nie z offsetu 0 FFT sygnału.

Modyfikowanie przykładu podanego powyżej przez @ PaulH

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

# Number of samplepoints
N = 600
# sample spacing
T = 1.0 / 800.0
x = np.linspace(0.0, N*T, N)
y = 10 + np.sin(50.0 * 2.0*np.pi*x) + 0.5*np.sin(80.0 * 2.0*np.pi*x)
yf = scipy.fftpack.fft(y)
xf = np.linspace(0.0, 1.0/(2.0*T), N/2)

plt.subplot(2, 1, 1)
plt.plot(xf, 2.0/N * np.abs(yf[0:N/2]))
plt.subplot(2, 1, 2)
plt.plot(xf[1:], 2.0/N * np.abs(yf[0:N/2])[1:])

Wykresy wyjściowe:

Innym sposobem jest wizualizacja danych w skali logów:

Użycie:

plt.semilogy(xf, 2.0/N * np.abs(yf[0:N/2]))

Pokaże:

[1]} jako uzupełnienie udzielonych już odpowiedzi, chciałbym zwrócić uwagę, że często ważne jest, aby bawić się wielkością pojemników na FFT. Sensowne byłoby przetestowanie kilku wartości i wybranie tej, która ma większy sens dla Twojej aplikacji. Często jest w tej samej wielkości liczby próbek. Zostało to przyjęte przez większość udzielonych odpowiedzi i daje wspaniałe i rozsądne wyniki. Jeśli ktoś chce to zbadać, Oto Mój kod Wersja:

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
import scipy.fftpack

fig = plt.figure(figsize=[14,4])
N = 600           # Number of samplepoints
Fs = 800.0
T = 1.0 / Fs      # N_samps*T (#samples x sample period) is the sample spacing.
N_fft = 80        # Number of bins (chooses granularity)
x = np.linspace(0, N*T, N)     # the interval
y = np.sin(50.0 * 2.0*np.pi*x) + 0.5*np.sin(80.0 * 2.0*np.pi*x)   # the signal

# removing the mean of the signal
mean_removed = np.ones_like(y)*np.mean(y)
y = y - mean_removed

# Compute the fft.
yf = scipy.fftpack.fft(y,n=N_fft)
xf = np.arange(0,Fs,Fs/N_fft)

##### Plot the fft #####
ax = plt.subplot(121)
pt, = ax.plot(xf,np.abs(yf), lw=2.0, c='b')
p = plt.Rectangle((Fs/2, 0), Fs/2, ax.get_ylim()[1], facecolor="grey", fill=True, alpha=0.75, hatch="/", zorder=3)
ax.add_patch(p)
ax.set_xlim((ax.get_xlim()[0],Fs))
ax.set_title('FFT', fontsize= 16, fontweight="bold")
ax.set_ylabel('FFT magnitude (power)')
ax.set_xlabel('Frequency (Hz)')
plt.legend((p,), ('mirrowed',))
ax.grid()

##### Close up on the graph of fft#######
# This is the same histogram above, but truncated at the max frequence + an offset. 
offset = 1    # just to help the visualization. Nothing important.
ax2 = fig.add_subplot(122)
ax2.plot(xf,np.abs(yf), lw=2.0, c='b')
ax2.set_xticks(xf)
ax2.set_xlim(-1,int(Fs/6)+offset)
ax2.set_title('FFT close-up', fontsize= 16, fontweight="bold")
ax2.set_ylabel('FFT magnitude (power) - log')
ax2.set_xlabel('Frequency (Hz)')
ax2.hold(True)
ax2.grid()

plt.yscale('log')

Wykresy wyjściowe: