[Perfect Slayer]

On a tout juste commencé les grandes explication en cours.. mais malheuresmeent on a pas encore vu comment décomposer le tout.. Si tu dis qu'il existe des algorithmes FFT, alors je regarderais ça se week-end pour l'implémenter dans ma source. Mais déjà, rien que le fait d'avoir eu un cours dessus m'a aidé à bien comprendre comment était organisé le tout (je n'avais aucune notion au paravant).
Merci pour tes infos Neoflo (si jamais t'as déjà les liens des algorithmes, fait-les moi parvenir sinon je chercherai par moi-même).
Je n'ai pas trop le temps d'avancer dessus pour l'instant.. Peut-être en mercredi ou jeudi soir..

[neoflo]

Tiens, un cours que j'ai fait sur le traiteement d'image, ça pourra peut être t'aider.

Le cours est encore en cours de correction :

http://humbert-florent.ftp-developpez.com/algorithmique/traitement/traitement.pdf

[neoflo]

J'ajoute que je n'ai pas développé la FFT dans mon cours.

En général, dans les cours de traitement du signal, les algorithmes que l'on voit fonctionne en une dimension. Pour deux dimensions, je pense que c'est à peu près pareil, mais je n'ai jamais vu.

[Perfect Slayer]

Je viens de jetter un coup d'oeil rapide à ton document et en un mot : bravo
Très complet (ca va m'en faire de la lecture !) et ca me donne une utilisation des maths et de l'algorithmique que je ne connaissais pas au paravent (bon ok, je n'ai pas tellement d'expérience que ca (MP + option info)).
Je vois que tu es sur le FTP de developpez.com, serais-tu un de leurs rédacteurs ?

[neoflo]

J'ai effectivement un espace :

http://humbert-florent.developpez.com

Je n'ai pas encore le statut de rédacteur à cause de léger problème que j'ai eu avec le responsable. Mais ce n'est qu'une question de temps.

Le cours sur le débruitage qu'il y a sur le lien devrait te donner pas mal de raison d'utiliser des mathématiques avançés.

[Perfect Slayer]

Bon alors apres avoir lu plusieurs site web, j'en suis arrivé à peu pres là :

Pour avoir mes pourcentages en fonction des fréquences :
- il faut que je prenne un passage du son (par exemple 0.01 sec)
- j'imagine qu'il tourne en boucle, il est donc périodique de fréquence 1/0.01 = 10Hz
- A partir de se signal, j'utilies les algo de FFT, je récupère donc les an (a indice n) et le bn (b indice n) de la décomposition en série de fourrier. Ces derniers correspond alors à l'amplitudes des signaux sinusoidaux de 10Hz, 20Hz, 30Hz.. Donc normalement en comparant ces an et bn, je peux connaitre le pourcentage des frequences ? (d'ailleurs je les compare à quoi ? a0 ?)

Voilà, j'ai compris ca : corrigez-moi si ce n'est pas ca.. Sinon j'ai une question aussi, apparement les algorithmes prennent des fonctions.. Or moi j'ai un ensemble de points de la courbe représentatrice de la fonction.. J'ai pas encore très bien lu les algorithmes pour savoir si c'était génant ou pas..

[neoflo]

, j'utilies les algo de FFT, je récupère donc les an (a indice n) et le bn (b indice n) de la décomposition en série de fourrier

Normalement, dans les transformées de Fourier discrète, il n'y a pas de série de Fourier (comme je l'ai déjà dit), tu es sûr de l'algorithme ? Normalement, il prend en entrée une suite à support bornée.

Mais ce qui est bizarre, c'est que tu parles de a_n et b_n qui n'est définie que pour les séries de Fourier.

[Perfect Slayer]

Bon bah je crois que je vais me mettre au C directement parce là je bloque completement avec la FFT.. Je trouve pas comment faire en PHP et ca commence à m'énerver..
Rectification.. Ca me fait tout aussi chier de reprendre le code en C.. Je suis HS là..

[neoflo]

Il y a peut-être des bibliothques en php permettant de faire cela.

Mais un gros problème étant que le php est interpreté. Alors si un programme mets 10 20 sec en C à faire les calculs, en php, je ne sais pas ça va prendre combien de temps.

Et encore, pour certains algorithmes de débruitage, il faut 15 20min sur une petite image (genre 512 * 512) noir et blanc pour la restaurer. J'ose pas imaginer en php.

Programmer la FFT, je l'ai déjà fait pour une dimension, j'ai déjà trouvé sur un site une astuce pour passer facilement à la 2D, mais c'est assez casse gueule.

[kad]

Hello

Ce que tu veux veux faire relève en effet du traitement de signal sonore. Je ne suis pas très calée sur ce sujet, sauf du point de vue astronomique: en effet, les images satellites météorologies (NOAA ou METEOSAT) ne sont qu'une succession de sons transmis par onde radio, et décodés pour être réinterprétés en image. Il existe plusieurs logiciels en radio-astronomie qui existent pour interpréter ses signaux, notamment  WXtoImg.
J'espère que ça pourra t'aider


nb: Ceci fut mon premier post. Cette journée restera à jamais gravée dans ma mémoire... Quoi? J'en fais trop? naaaaaan...... lol

[Perfect Slayer]

Bah ce qui serait pas mal c'est si je pouvais trouver les algorithmes de FFT en langage algorithmique... (et non en maths..). A ce moment là je pourrais les transcrire.. Parce que j'ai regarder mais la librairie de C, j'en ai pour 15 ans à la refaire.. Sinon j'ai posté sur developpez.com.. Ils auront peut-être quelque chose pour moi.

[neoflo]

Je vais te donner gentiment le code source que j'avasi fait en scilab qui permettait de calculer une TFD en une dimension.

Il faudrait ensuite utiliser la page : http://www.essi.fr/~leroux/crim2/node50.html pour le faire convertir en deux dimensions.

Code:

////////////////////////////
// Partie 1: TFD rapide  ///
////////////////////////////


//Fonction permettant de realiser le decoupage
// d'un vecteur X de taille pair en deux vecteurs
// Le premier aura les valeurs des indices impair
// Le second aura les valeurs des indices pair
function [X0, X1] = decouper(X);
 dimensionX = length(X);
 for k=0:dimensionX/2-1;
   X0(k+1) = X(2*k+1);
   X1(k+1) = X(2*k+2);
 end;
endfunction;

//Tests de la fonction
[dec1, dec2] = decouper([1,2,4,5]');


//Transformee Fourier Discrete Rapide
// Precondition: X de dimension 2^q 
function T= TFDrapide(X)
 dimensionX = length(X);
 if (dimensionX==1) then
    //cas d'arret 
    T(1) = X(1);
  else
    //cas general
    [X0, X1] = decouper(X);
    TFDX0 = TFDrapide(X0);
    TFDX1 = TFDrapide(X1);
    for k=0:dimensionX/2-1;
      T(k+1) = TFDX0(k+1) + exp(-2* %i * %pi * k/ dimensionX) * TFDX1(k+1);
      T(k+1+dimensionX/2) = TFDX0(k+1) - exp(-2* %i * %pi * k/ dimensionX) * TFDX1(k+1);
    end;
  end;
endfunction;


///////////////////////////////////
// Partie 2: TFD rapide inverse  //
///////////////////////////////////


//Transformee Fourier Discrete Inverse Rapide
function T = TFDrapideInverse(X)
 dimensionX = length(X);
 T = TFDrapide(X);
 for k=0:dimensionX-1;
   T(k+1) = conj(T(k+1)) / dimensionX;
 end;
endfunction;



/////////////////////////////
// FONCTION POUR LES TESTS //
/////////////////////////////

//version moins optimise du calcul de la TFD
// par simple application de la definition de la TFD
function T = TFD(X);
  dimensionX = length(X); 
 for k=0:dimensionX-1;
   somme=0;
   for n=0:dimensionX-1;
     somme = somme + X(n+1)* exp(-2*%i*%pi*k*n/dimensionX);
   end;
   T(k+1) = somme;
 end;
endfunction;


//version moins optimise du calcul de la TFD inverse
// par simple application de la definition de la TFD inverse
function T = TFDinverse(X);
 dimensionX = length(X);
 for k=0:dimensionX-1;
   somme=0;
   for n=0:dimensionX-1;
     somme = somme + X(n+1)* exp(2*%i*%pi*k*n/dimensionX);
   end;
   T(k+1) = somme / dimensionX;
 end;
endfunction;

[Perfect Slayer]

Oki merci, c'est gentil à toi. Je voyais ca plus compliqué en fait.. La fonction est récursive mais si je me souviens bien, ca ne doit pas poser de probleme à PHP..
Sinon, dans le pire des cas : j'ai en TD info de physique ou justement on allait construire ca.. (en Mapple quel merde ce langage..). Si j'ai le temps je retranscris ca en PHP et le test ce soir.
Encore merci

[Perfect Slayer]

Arf fait ###, j'ai jamais vu de calculs de complexe avec PHP.. ! Va falloir que je vois ca..

[neoflo]

Suffit de faire soit :

- Un type abstrait de donnée Tableau complexe qui contient un tableau de réel et un tableau de imaginaire
- Un type abstrait Complexe (mais peut-être moins rapide mais à l'avantage de ne pas nécessiter deux fois plus d'appel de fonctions)

Pis utiliser des cos et des sin au lieu de l'exp.