Discussion :

[la_maman_a_tristan]

Salutations

Voilà, dans le cadre d'un projet scolaire, je dois, à partir d'un fichier wav contenant un son pur (c'est à dire une seule note avec une fréquence bien définie), retrouver cette sus-dite fréquence.

(En vrai, mon fichier wav contient plusieurs notes, mais je me charge de découper mon wav en n=nombre de notes fichiers, et je les anaylse un par un)

Voici donc mon code, j'utilise la transformée de Fourier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
frequences = []
#Ouverture du fichier wav à décrypter
wav_original = wave.open("sons/elpkzgyldd.wav",'rb')
(nchannels, sampwidth, framerate, nframes, comptype, compname) = wav_original.getparams()
 
#Ensuite, il va découper le fichier wav en n=nombre de notes fichiers
nbr_notes = nframes/2500
 
for i in range(0, nbr_notes):
    debut = int(i*2500)
    fin = int((i*2500)+2500)
 
    wav_original.setpos(debut)
    print wav_original.tell()
    donnee_partie = wav_original.readframes(int((fin-debut)*framerate))
 
    partie_fichier_son = wave.open('dcrpt_fichier.wav','wb')
    partie_fichier_son.setnchannels(nchannels)
    partie_fichier_son.setsampwidth(sampwidth)
    partie_fichier_son.setframerate(framerate)
    partie_fichier_son.writeframes(donnee_partie)
    partie_fichier_son.close()
 
    #Maintenant, on applique la transformée de Fourier
    wav = wave.open("dcrpt_fichier.wav",'rb')
    (nchannels, sampwidth, framerate, nframes, comptype, compname) = wav.getparams()
    frames = wav.readframes(nframes)
 
    data = struct.unpack('%sh' % (nframes * nchannels), frames)
 
    w = np.fft.fft(data)
    freqs = np.fft.fftfreq(len(w))
    idx=np.argmax(np.abs(w)**2)
    freq=freqs[idx]
    frequence=abs(freq*framerate)
 
    #On arrondit la fréquence, car elle est non-entière
    partie_decimale = frequence-int(frequence)
    if(partie_decimale >= 0.5):
        frequence=int(frequence+0.5)
    else:
        frequence=int(frequence-0.5)
 
    frequences.append(frequence)
    wav.close()
    os.remove("dcrpt_fichier.wav")
print frequences

Voici ce que me retourne cet algorithme :
[247, 182, 247, 182, 248, 182, 248]

Or il est censé me retourner :
[247, 182, 248, 182, 249, 182, 250]

D'accord on est pas très loin, mais il me faut les fréquences exactes

Et parfois, les écarts sont éléphantesques ! Par exemple je dois obtenir ceci :
[266, 264, 255, 265, 266, 247, 260, 262, 255, 249, 267, 266]

Et mon algorithme retourne :
[267, 265, 265, 267, 267, 266, 266, 266, 266, 266, 267, 267]

Ventre-saint-gris ! me direz-vous, que fait donc cette transformée de Fourier ?
Existe-t-il un moyen d'obtenir les fréquences exactes ? Je ne tiens point forcément à utiliser la transformée de Fourier, car comme dans le cochon, tout est bon pour que je parvienne à mes fins !

En vous remerciant d'avance de l'intérêt que vous porterez à mon problème !

[__dardanos__]

Bonjour.
Quelles sont les valeurs sans l'arrondi ?
Peut-on avoir le fichier "elpkzgyldd.wav".

[la_maman_a_tristan]

Sans l'arrondi, voici les valeurs :

[248.21999999999997, 181.91250000000002, 248.28300000000002, 181.91250000000002, 249.16500000000002, 181.91250000000002, 249.16500000000002]

Et voici le fichier :
elpkzgyldd.zip

Merci d'avance

[__dardanos__]

Par exemple, pour la troisième fréquence, tu obtiens 247 et tu t'attends à 248.
J'ai tracé le carré de l'amplitude de la FFT (Figure jointe). Je n'ai pas fait la correction sur les abscisses (l'arrondi).

On ne peut pas directement prendre la valeur maximale des points calculés. Il faut ajuster la courbe auparavant (avec une gaussienne par exemple).
D'où le petit décalage.

[la_maman_a_tristan]

Je te remercie de ton aide, mais comment dans mon cas pourrais-je implémenter ta solution ? Je dois avouer que je ne maîtrise pas très bien les FFT...

[__dardanos__]

Salut.
Comme tu as fait du bon travail, je te donne un petit coup de pouce pour terminer.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import wave, struct
from time import sleep
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
 
def func(x,a,b,c):
    return c * np.exp( -np.power( (x-a)/b, 2) )
 
plt.ion()   # utilise pyplot en interactif
 
# Ouverture du fichier wav a decrypter
wav_original = wave.open("son/elpkzgyldd.wav",'rb')
 
nchannels = wav_original.getnchannels()     # Returns number of audio channels (1 for mono, 2 for stereo)
framerate = wav_original.getframerate()     # Returns sampling frequency
nframes   = wav_original.getnframes()       # Returns number of audio frames
 
# Decouper le fichier en plusieurs parties (une note par partie)
frequences, freq_gauss = [], []
larg_frame = 2500
for posi in range(0,nframes,larg_frame):
 
    # Sequence contenant une note
    wav_original.setpos(posi)
    donnee = wav_original.readframes(larg_frame)
    data = struct.unpack('%sh' % (larg_frame * nchannels), donnee)
 
    # Transformee de Fourier
    w     = np.fft.fft(data)
    sig   = np.real(w * w.conjugate())
    freqs = np.fft.fftfreq(len(w)) * framerate
 
    # Estimation de la frequence
    idx = np.argmax(sig)
    f0, maxi = np.abs(freqs[idx]), sig[idx]
    frequences.append( f0 )
 
    # Ajustement par une gaussienne
    ind = np.where( np.abs(freqs - f0) < 20 )
    popt, pcov = curve_fit( func, freqs[ind], sig[ind]/maxi, p0=[f0,1,1] )
    a, b, c = popt
    freq_gauss.append(a)
 
    # Affichage
    plt.plot( freqs[ind], sig[ind], 'o')
    fnew = np.linspace( freqs[ind][0], freqs[ind][-1], 512)
    plt.plot( fnew, maxi * func(fnew,a,b,c), 'r')
    plt.draw() ; sleep(2) ; plt.clf()
 
wav_original.close()
 
for res in (frequences,freq_gauss):
    print np.round(res, 0)
print "Resultats attendus :\n[247, 182, 248, 182, 249, 182, 250]"

[la_maman_a_tristan]

Un très, très grand merci, cela marche exactement comme je le voulais !

Vraiment, ça fait chaud au cœur de voir que la magie d'internet est toujours présente