Tracer le spectre de fourier d'un signal sonore enregistré. (CPGE)

[invitea0be6529]

Bonjour à tous !

Voilà maintenant quelques temps que je cherche à tracer le spectre de fourier de quelques signales sonores enregistrés sur mon PC (ceci dans le cadre d'un projet de fin d'année).
J'essaie de faire ça avec python car mon programme d'info repose principalement sur python.

J'utilise sur python le module fft de numpy et j'obtiens assez facilement la fft de mon signal ainsi, cependant pour tracer un spectre de fourier, il faut tracer l'amplitude en fonction de la fréquence, et je ne vois malheureusement pas comment faire ceci. Comment je fais pour relier mon tableau "array" d'amplitudes à un "array" de fréquences ?

from scipy.io import wavfile as w
import matplotlib.pyplot as plt
import numpy as np


def affiche_proprietes(filename): #retourne la fréquence d'échantillonage, le tableau des échantillons du son numérisé, et la durée de l'enregistrement

F,T=w.read(filename,'r')

time=float(len(T))/float(F)
return (F,T,time)

def affiche_onde(filename): #Ici j'affiche simplement l'onde en elle même comme des logiciels tels qu'Audacity pourraient le faire

son,F,T,resolution,time=affich e_proprietes(filename)
x=np.linspace(0,time,len(T))
plt.plot(x,T)
plt.show()

J'effectue ensuite ma fft de la façon suivant: Fft=np.fft.fft(T)
Ensuite je ne sais plus quoi faire, donc j'ai quelques questions:
-Dois-je prendre la partie réelle ou le module des résultats de ma fft pour tracer le spectre ?
-Comment construire l'axe des abcisses, donc des fréquences ?

Et je crois que c'est tout.

Petit information supplémentaire, je voudrais pouvoir tracer ce spectre pour retrouver la fréquence d'une note de guitare par exemple.
Voilà voilà merci d'avance pour votre aide !
-----

[zoup1]

Quand on trace un spectre, bien souvent ce qu'il est intéressant de tracer c'est le spectre de puissance, c'est à dire le carré du module et bien souvent en échelle logarithmique. Mais on peut regarder ce que l'on veut !
Pour l'axe des abscisses, visiblement numpy propose la méthode fftfreq pour retourner le tableau des valeurs

des exemples ici : http://www.tangentex.com/PythonTFD.htm

[invitea0be6529]

Bonsoir et merci de votre réponse !

J'ai testé la méthode fftfreq, pour un signal de tableau T tel que T.size me donne 22050, et de fréquence d'échantillonage 44100, j'ai donc un timestep de 1/44100. Le souci c'est que quand je fait donc freq=np.fft.fftfreq(n,d=timest ep) (n=22050) j'obtiens des fréquences négatives.. :/

>>> f='C:\\Users\\pleym\\Desktop\\ TIPE\\test.wav'
>>> F,T,time=affiche_proprietes(f)
>>> F,T,time
(44100, memmap([ 0, 1222, 2438, ..., -31275, -30895, -30460], dtype=int16), 0.5)
>>> n=T.size
>>> timestep=1./F
>>> freq=np.fft.fftfreq(n,timestep )
>>> freq
array([ 0., 2., 4., ..., -6., -4., -2.])

Peut-être m'y suis-je mal pris ?

[invitea0be6529]

J'ai bêtement essayer de prendre les valeurs absolues des valeurs de mon tableau de fréquences et j'obtiens la bonne fréquence de mon signal, mais je ne pense pas que c'est comme cela qu'il faut s'y prendre, j'attends votre avis Evidemment le son que j'ai pris ici est un son très basique monofréquence.

[A voir en vidéo sur Futura]

[zoup1]

Bonsoir,

la fonction fft est la forme la plus générale. Elle permet de calculer la transformée de fourier d'une fonction complexe. Dans ce cas de figure, elle renvoie les coefficients de fourrier pour des fréquences qui positives et négatives. Dans le cas où la fonction d'entrée est réelle, les coefficients pour les fréquences positives sont simplement complexe conjugués des coefficients pour les fréquences positives. Cela fait partie des propriétés de la transformée de fourier. fftfreq est associée à cette fonction et renvoie les fréquences positives et négatives correspondantes.
SI on a une fonction réelle, seule la première partie du résultat est intéressante puisque la deuxième qui correspond aux fréquences négatives peuvent être déduites des premières par la symétrie énoncée ci-avant.
Pour éviter cette redondance d'information, il existe une autre fonction qui s'appelle rfft qui elle ne prend que des fonctions réelles en entrée et ne renvoie que ce qui est nécessaire à savoir les coefficients pour les fréquences positives. la fonction associée pour construire l'axe des abscisses est alors rfftfteq.

[invitea0be6529]

D'accord, alors j'ai essayé ce que vous m'avez dit et voilà ma fonction spectre:

def spectre(filename):

F,T,time=affiche_proprietes( filename )
n=T.size
timestep=1./F
freq=np.fft.rfftfreq(n,timeste p)
for i in range(len(freq)):

freq[i]=abs(freq[i])

fourier=np.fft.rfft(T)
L=[]
for i in range(len(fourier)):

L.append(fourier[i])

for i in range(len(L)):

L[i]=np.sqrt(L[i].real**2+L[i].imag**2)

fourier=np.array(L)
plt.plot(freq,fourier)
plt.show()

et pour un enregistrement da la première corde d'une guitare j'obtiens :

spectre.jpg
spectre.jpg


Le soucis, enfin ce que je comprends pas c'est que normalement la fréquence de ma première corde doit tourner autour des 165Hz, or ma plus grand raie se situe dans les 400Hz, et la minuscule petit crotte tout en bas à gauche correspond à environ 160Hz, comment puis-je lire la fréquence que ma corde a sur mon spectre ?

[zoup1]

import numpy as np
import matplotlib.pyplot as plt
t
# Number of samplepoints
N = 600
# sample spacing
T = 1.0 / 800.0
x = np.linspace(0.0, N*T, N)
y = np.sin(50.0 * 2.0*np.pi*x) + 0.5*np.sin(80.0 * 2.0*np.pi*x)


yf = np.fft.rfft(y)
xf = np.fft.rfftfreq(N, T)


fig, ax = plt.subplots()
ax.plot(xf, 2.0/N * np.abs(yf),'-')
plt.show()

Voici un exemple simple qui fonctionne.
Il n'y a pas vraiment de bidouillage à faire. L'utilisation est très simple.
J'ai a cette occasion été surpris de constater qu'il y a une différence entre numpy.fft et scipy.fftpack dans la façon dont sont renvoyés les résultats. numpy renvoie un tableau de valeurs complexes alors que scipy renvoie un tableau de valeurs réelles, le indices pairs correspondent alors à la partie imaginaire de la réponse alors que les indices impaire correspondent à la partie réelle (à moins que ce ne soit le contraire). bref, la version numpy est plus facilement utilisable.

[invitea0be6529]

Tout d'abord merci pour toutes vos réponses.

Ensuite maintenant que je suis capable de tracer le spectre, comment puis-je retrouver la fréquence de ma note à partir de celui-ci ?

[zoup1]

C'est une toute autre question et cela dépend de ce à quoi ressemble votre signal.
Par exemple si votre signal est quasi sinusoïdal, alors il est plus que vraisemblable que le fondamental correspondra à la plus grande amplitude.
Mais pour un signal quelconque rien ne garantit cela. Il faut alors faire une recherche des pics et trouver un moyen de sélectionner celui correspondant au fondamental.

Voici un lien vers une page web qui explore différentes possibilités en python :
https://blog.ytotech.com/2015/11/01/...aks-in-python/

J'espère que tu y trouveras ton bonheur !

[invitea0be6529]

Merci pour tout !
Et bonne fin de semaine