Discussion :

[SubZero2]

Bonjour a tous.

J'essaie de developper une petite application en Deplhi pour analyser 2 sons.

Le premier serait mon son de référence et le deuxième serait enregistré avec un micro.
Le son que j'enregistre est celui d'un marteau qui frappe un tube de metal a interval regulier et avec la même intensité.

Le but est de savoir si le tube est deffectueux ou non.
Lorsqu'il est deffecteux, le bruit change nettement puisqu'aujourd'hui c'est l'oreille humaine qui detecte ce changement de sonorité et ça marche plutot pas mal.
Bon voila pour l'intro.

Maintenant pour ce qui est de Delphi, j'ai trouvé des exemples sur l'espace perso de sub0 mais le programme du spectrogramme plante quand j'ouvre les sons que j'enregistre...

Bon c'est peut etre un peu fouilli mais si vous pouviez m'orienter un peu...

Merci d'avance.

[b_reda31]

Je ne vais pas pouvoir t'aider sur ça mais ça a l'air très intérressant!
Bonne continuation

[Paul TOTH]

ah oui c'est rigolo comme projet ça

bon alors pour autant que j'en sache, un fichier son, ce n'est jamais qu'une suite de fréquences mise bout à bout pour produire le son. C'est donc une prise de fréquence toutes les X millisecondes.

si tu enregistres deux sons, et que tu veux les comparer, ça revient à comparer deux séries de nombres finalement

première chose, localiser le silence qui séparer le deux coup de marteau (signal à 0)...surement repérer le silence suivant pour baliser le coup de marteau dans le fichier son.

et là tu dois avoir donc deux suites de nombres comprenant à peu près le même nombre de valeurs qui doivent être voisines.

tu peux très simplement afficher ces valeurs dans un graph avec en X le temps et en Y l'amplitude du signal.

sur un fichier wav 16 bits tu as une série de "smallint" qui te donnent les amplitudes en fonction du temps.

le format n'est pas très compliqué :

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
 
  TWAVE = packed record 
    RIFF: THeaderRIFF;  
    Fmt : THeaderFormat;
    Data: THeaderData;
  // ici les données
  end;
 
 // avec
  THeaderRIFF = Packed Record
    ID    : Array[1..4]Of Char;  // "RIFF"
    Taille: Cardinal;            
    Format: Array[1..4]Of Char;  // "WAVE"
  end;
 
  THeaderFormat = Packed Record
    ID    : Array[1..4]Of Char;  // "fmt "
    Taille: Cardinal;            //  16
    Format: WORD;                //  1
    Mode  : WORD;                //  1
    SRate : Cardinal; //=Sample Rate 8000
    BRate : Cardinal; //=Byte Rate   8000
    Align : WORD;     // 1
    BPS   : WORD;     //Bits Per Sample 8
  end;
 
 
  THeaderData = Packed Record
    ID    : Array[1..4]Of Char;  // "data"
    Taille: Cardinal; // nombre d'octets qui suivent
  end;

la je te donne une version un peu batarde, en vrai le format contient une notion de "Chunk" avec un nom sur 4 caractères et une taille (integer) qui précède les données

sur un fichier wave simple tu as :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 "RIFF"(
  taille de fmt + data
   "fmt "(
   taille = 16 
   ...16 octets entête
   )
   "data" (
   taille des données
   ... les données...
   )
  )

c'est la partie "données" qui t'intéresse dans ton traitement.

[SubZero2]

Merci a vous deux !

Effectivement, c'est un projet rigolo et intéressant oui.

Paul > Je suis tombé sur ces infos dans les exemples de sub0.
Le décorticage du WAVE c'est ok.

Par contre le principe de fonctionnement n'est pas tout a fait comme tu le décrit.
En fait c'est comme ça que ça se passe :

J'ai - disons - 3 sons d'un tube correct et 3 sons d'un tube défectueux, ce qui me donne une sorte tolérance maxi et mini de fréquence.
Ensuite les tubes passent sur une chaine de production en continu et le marteau frappe le tube tout les X secondes.

Je doit donc analyser le son produit en temps réel et être capable de savoir si celui ci dépasse ou est en dessous de mes tolérances.

Je vais essayer de chercher dans la direction de cet exemple : Oscillopscope

Me reste toujours comment calculer en temps réel la fréquence du son qui passe dans le micro ...

[Paul TOTH]

Me reste toujours comment calculer en temps réel la fréquence du son qui passe dans le micro ...

ah ben ça c'est pas très différent du traitement par fichier...sauf qu'au lieu de lire un fichier, tu vas traiter des buffers remplis par la capture...mais au final c'est toujours un tableau de fréquences

[Jipété]

Salut !

bon alors pour autant que j'en sache, un fichier son, ce n'est jamais qu'une suite de fréquences mise bout à bout pour produire le son. C'est donc une prise de fréquence toutes les X millisecondes.

Euh, moi j'aurais dit "une suite d'amplitudes (de niveaux, quoi)", étant entendu que selon la vitesse de variation de la dite amplitude par rapport à la fréquence d'échantillonnage du signal, ça va déterminer la fréquence du son.
C'est donc une prise de niveau toutes les X millisecondes (fréquence d'échantillonnage).
Et ce sont ces valeurs de niveaux qui sont enregistrées dans le fichier.
Mes 2 cts,
--
jp

[Paul TOTH]

lol je vois qu'on est tous les deux aussi à l'aise avec le concept

on a donc des variations de fréquences dont on mesure l'amplitude à interval de temps régulier

[SubZero2]

Et ce sont ces valeurs de niveaux qui sont enregistrées dans le fichier.

Voila ou est mon probleme . C'est que je ne veux pas comparer le volume du son ( variation de "niveaux" ) mais une variation dans la note ( frequence donc ).
Le volume varie meme pour un meme tube. Au moment de la frappe du marteau le volume est brutalement elevé et redescent petit a petit.
Et avec le graph, on voit bien que la frequence ne change casiment pas.

En partant de l'exmple suivant , j'imagine que dans le TTimer, je doit dire toutes les 500 ms je parcours mon RecData et je regarde quelle est la frequence de changement d'oscillation. Sans oublier de multiplier tout ca par 2 ...

Qu'en pensez vous ?

[Jipété]

Ben moi je pense que t'es dans une sale histoire,
Je m'explique : à l'oreille des fréquences très proches et/ou des niveaux très voisins seraient indétectables, mais dans le fichier les valeurs seront différentes.

À partir de quelle différence des données tu dois considérer que les sons sont différents ?
Est-ce que deux coups de marteau consécutifs sur un même tube vont produire deux groupes de données identiques ? C'est pas sûr... Il va te falloir prendre en compte une notion de "marge" (à mon avis).
Mes 2 cts,
--
jp

[Lung]

Peut-être que le composant BASS, peut t'aider ...

[philnext]

Pour ce type de problème le plus efficace (je l'ai déja fait pour des pb similaires) est de stocker les 2 sons et comparer les FFT de chacun.
http://www.lohninger.com/fourier.html

[SubZero2]

Bonjour a tous !
Tout d'abord merci pour toutes ces infos. Je ne sais toujours pas a quoi sert cette transformation de Fourier mais bon. D'ailleurs, si quelqu'un pouvait m'expliquer avec des mots simples, ce serait super sympa

Bon voila ou j'en suis dans mon projet.
J'ai decidé de partir toujours du même exemple de sub0, celui qui lit en direct l'entrée micro et de voir ce que je pouvais faire avec les ifnos qu'il recupère.

La fonction Vumeter de l'exemple me donne accés à tous les points dont il se sert pour dessiner la sinusoïde. J'ai donc fait une petite fonction qui fait ceci :

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
56
57
58
59
60
procedure TForm1.TraiteMonTableau;
var
  i, freq, moy: integer;
  switch: boolean;
  Rect: Trect;
  mespoints: array of TPoint;
begin
  switch := True;
  freq := 0;
 
  for I := 0 to Length(MonTableau) - 2 do
  begin
    Memo1.Lines.Add(IntToStr(MonTableau[I]));
    if MonTableau[i] = 120 then
      Inc(freq);
 
    SetLength(mespoints, Length(mespoints)+1);
    mespoints[Length(mespoints)-1].X := I;
    mespoints[Length(mespoints)-1].Y := MonTableau[i];
  end;
 
  if Length(MonTableau) > 0 then
  begin
     moy := Moyenne(MonTableau);
     moy := 120;
     LabelMoy.Caption := 'Moyenne : ' + IntToStr(moy);
 
     switch := (MonTableau[I] >= moy);
     freq := 0;
 
     for I := 0 to Length(MonTableau) - 2 do
     begin
        if (MonTableau[I] >= moy) and (not switch) then
        begin
           switch := true;
           Inc(Freq);
        end;
        if (MonTableau[I] <= moy) and (switch) then
        begin
           switch := false;
           Inc(Freq);
        end;
     end;
 
     LabelFreq.Caption := 'Fréquence : ' + IntToStr((Freq*10) div 2)  // Le Timer a un interval de 100 ms
 
     Rect.Left := 0;
     Rect.Top := 0;
     Rect.Right := Image1.Width;
     Rect.Bottom := Image1.Height;
     Image1.Canvas.Pen.Color := clWhite;
     Image1.Canvas.FillRect(Rect);
     Image1.Canvas.Pen.Color := clRed;
     Image1.Canvas.Polyline(mespoints);
 
     SetLength(MonTableau, 0);
 
     Application.ProcessMessages;
  end;
end;

Cette fonction me donne le nombre de fois ou je suis au dessus de la mediane et en dessous. Je divise donc par 2 et j'ai donc le nombre de periodes en une seconde ( mon timer.interval * 10 ).

Bon visiblement c'est pas super precis. Car en enregistrent le son sui sort du telephone, censé être un LA 440 et bien je tourne plutot autour des 500, 550 et ça varie sans cesse alors que le graphique lui ne bouge pas.

Bon voila pour mon petit roman du matin.
Si vous avez des idées, elles sont les bienvenues evidemment !

[user 56gt8]

Tout son peut être décrit comme une somme de sinusoide simple dont chacune a sa propre fréquence et sa propre amplitude.

La transformation de fourier permet de décomposer le son en un ensemble de sinusoides sous forme de coefficients réels et imaginaires permettant d'obtenir les magnitudes (amplitude) et phases (fréquences) de chaque composant fréquentiel.

tout ca est très bien expliqué ici:
http://www.unilim.fr/pages_perso/jea...ourier/fft.htm

Dans ton cas cela pourrait permettre de déterminer quelles sont les harmoniques/niveau du son du tuyau quand il est en bon état, une description 'spectrale de référence'.
En gros ca te donnerait un truc comme 1024 vu-mètre,chacun représentant un fréquence différente

Il y a aussi le composant 'FFTreal' qui permet de faire ca.
http://ldesoras.free.fr/src/FFTReal-1.03.zip
traduit en objet pascal par un collaborateur de Image line et également
traducteur du sdk vst de steinberg en delphi.Gros poisson quoi.

Les exemples de lohninger sont très explicites sur 'comment ca marche'.
Par contre ses classes ne sont pas performantes(mais ultra simple à utiliser).Pour de bonnes performances la FFTreal est préférable.

[Sub0]

J'avais fait une unité pour l'analyse de fréquence, elle est prévue pour s'intègrer au vumetre... Peut-être que ça te servira...

http://www.developpez.net/forums/sho...4447&page=3#40

[SubZero2]

Bon après plusieurs recherches sur le net, il existe visiblement plein de solution pros qui deja tout ca trés bien...

Envoi d'ultra-sons / ecoute avec des "stetoscopes" ...
Nous allons donc nous orienter vers cette solutions. Pas trop le temps de reinventer la roue en fait ...

En tout cas merci a tous pour vos réponse trés instructives.