Une ondelette pour le traitement du signal numérique

Soyez le premier à donner votre avis sur cette source.

Vue 12 546 fois - Téléchargée 666 fois

Description

Je l'ai longtemps chercher donc j'en fait profiter tout le monde

Source / Exemple :


/**************************************************

  • Fichier : FastSymmlet8.C
  • Format : ANSI C++
* *
  • Last modified on March 6th 1998
  • Dernière modification le 6 mars 1998
*
  • Free for any use, but this copyright notice must remain.
  • Provide as is. Use at your risks.
*
  • Gratuit pour toute utilisation, mais préservez cette mention.
  • Sans garantie aucune, utilisez à vos risques.
*
  • C++ implementation of the Symmlet8 wavelet.
  • See end of the file for usage.
*
  • Cette classe utilise les ondelettes Symmlet8. Son
  • utilisation est très simple (voir la fin du fichier
  • pour un exemple). Elle suppose des conditions périodiques
  • aux bords.
*
                                                                                                      • /
#include <iostream.h> static const float scale[8] = {0.0322231006040782f, -0.0126039672622638f, -0.0992195435769564f, 0.297857795605605f, 0.803738751805386f, 0.497618667632563f, -0.0296355276459604f, -0.0757657147893567f}; static const float wavelet[8] = {0.0757657147893567f, -0.0296355276459604f, -0.497618667632563f, 0.803738751805386f, -0.297857795605605f, -0.0992195435769564f, 0.0126039672622638f, 0.0322231006040782f}; /************************************************
  • An efficient implementation of
  • the Fast Wavelet Transform using
  • Symmlet8 wavelets (FBI fingerprints standard)
                                                                                                  • /
class FastSymmlet8 { public: static void transform (int,float *); static void invTransform (int,float *); static void expand (int,float *); class NotAPowerOf2Exception{}; class NotDivisibleBy2Exception{}; static void invTransform(int,float *, int); static void transform(int,float *, int); private: }; void FastSymmlet8::transform(int length,float * v, int last) { float * ans=new float[last]; for(int k=0;k<last;k++) { ans[k]=0; } int half=last/2; for(int k=0;k<half-3;k++) { ans[k+half]=v[(2*k+0)]*wavelet[0]+v[(2*k+1)]*wavelet[1]+v[(2*k+2)]*wavelet[2]+v[(2*k+3)]*wavelet[3]+v[(2*k+4)]*wavelet[4]+v[(2*k+5)]*wavelet[5]+v[(2*k+6)]*wavelet[6]+v[(2*k+7)]*wavelet[7]; ans[k]=v[(2*k+0)]*scale[0]+v[(2*k+1)]*scale[1]+v[(2*k+2)]*scale[2]+v[(2*k+3)]*scale[3]+v[(2*k+4)]*scale[4]+v[(2*k+5)]*scale[5]+v[(2*k+6)]*scale[6]+v[(2*k+7)]*scale[7]; } ans[last-3]=v[last-6]*wavelet[0]+v[last-5]*wavelet[1]+v[last-4]*wavelet[2]+v[last-3]*wavelet[3]+v[last-2]*wavelet[4]+v[last-1]*wavelet[5]+v[0]*wavelet[6]+v[1]*wavelet[7]; ans[half-3]=v[last-6]*scale[0]+v[last-5]*scale[1]+v[last-4]*scale[2]+v[last-3]*scale[3]+v[last-2]*scale[4]+v[last-1]*scale[5]+v[0]*scale[6]+v[1]*scale[7]; ans[last-2]=v[last-4]*wavelet[0]+v[last-3]*wavelet[1]+v[last-2]*wavelet[2]+v[last-1]*wavelet[3]+v[0]*wavelet[4]+v[1]*wavelet[5]+v[2]*wavelet[6]+v[3]*wavelet[7]; ans[half-2]=v[last-4]*scale[0]+v[last-3]*scale[1]+v[last-2]*scale[2]+v[last-1]*scale[3]+v[0]*scale[4]+v[1]*scale[5]+v[2]*scale[6]+v[3]*scale[7]; ans[last-1]=v[last-2]*wavelet[0]+v[last-1]*wavelet[1]+v[0]*wavelet[2]+v[1]*wavelet[3]+v[2]*wavelet[4]+v[3]*wavelet[5]+v[4]*wavelet[6]+v[5]*wavelet[7]; ans[half-1]=v[last-2]*scale[0]+v[last-1]*scale[1]+v[0]*scale[2]+v[1]*scale[3]+v[2]*scale[4]+v[3]*scale[5]+v[4]*scale[6]+v[5]*scale[7]; for(int k=0;k<last;k++) { v[k]=ans[k]; } delete[] ans; } void FastSymmlet8::transform (int length,float * v) { int last; for (last=length;last>8;last/=2) { transform(length,v,last); } if(last!=8) { cout<< "Attention : n'est pas une puissance de 2 : " << length << endl; cout<< "Careful : not a power of 2 : " << length << endl; throw NotAPowerOf2Exception(); } } void FastSymmlet8::invTransform(int length, float * v, int last) { int ResultingLength=2*last; float * ans=new float[ResultingLength]; for(int k=0;k<ResultingLength;k++) { ans[k]=0; } for(int k=0;2*k+7<ResultingLength;k++) { ans[(2*k+7)]+=scale[7]*v[k]+wavelet[7]*v[k+last] ; ans[(2*k+6)]+=scale[6]*v[k]+wavelet[6]*v[k+last] ; ans[(2*k+5)]+=scale[5]*v[k]+wavelet[5]*v[k+last] ; ans[(2*k+4)]+=scale[4]*v[k]+wavelet[4]*v[k+last] ; ans[(2*k+3)]+=scale[3]*v[k]+wavelet[3]*v[k+last] ; ans[(2*k+2)]+=scale[2]*v[k]+wavelet[2]*v[k+last] ; ans[(2*k+1)]+=scale[1]*v[k]+wavelet[1]*v[k+last] ; ans[(2*k+0)]+=scale[0]*v[k]+wavelet[0]*v[k+last] ; } ans[ResultingLength-6]+=scale[0]*v[last-3]+wavelet[0]*v[ResultingLength-3] ; ans[ResultingLength-5]+=scale[1]*v[last-3]+wavelet[1]*v[ResultingLength-3] ; ans[ResultingLength-4]+=scale[2]*v[last-3]+wavelet[2]*v[ResultingLength-3] ; ans[ResultingLength-3]+=scale[3]*v[last-3]+wavelet[3]*v[ResultingLength-3] ; ans[ResultingLength-2]+=scale[4]*v[last-3]+wavelet[4]*v[ResultingLength-3] ; ans[ResultingLength-1]+=scale[5]*v[last-3]+wavelet[5]*v[ResultingLength-3] ; ans[0]+=scale[6]*v[last-3]+wavelet[6]*v[ResultingLength-3] ; ans[1]+=scale[7]*v[last-3]+wavelet[7]*v[ResultingLength-3] ; ans[ResultingLength-4]+=scale[0]*v[last-2]+wavelet[0]*v[ResultingLength-2] ; ans[ResultingLength-3]+=scale[1]*v[last-2]+wavelet[1]*v[ResultingLength-2] ; ans[ResultingLength-2]+=scale[2]*v[last-2]+wavelet[2]*v[ResultingLength-2] ; ans[ResultingLength-1]+=scale[3]*v[last-2]+wavelet[3]*v[ResultingLength-2] ; ans[0]+=scale[4]*v[last-2]+wavelet[4]*v[ResultingLength-2] ; ans[1]+=scale[5]*v[last-2]+wavelet[5]*v[ResultingLength-2] ; ans[2]+=scale[6]*v[last-2]+wavelet[6]*v[ResultingLength-2] ; ans[3]+=scale[7]*v[last-2]+wavelet[7]*v[ResultingLength-2] ; ans[ResultingLength-2]+=scale[0]*v[last-1]+wavelet[0]*v[ResultingLength-1] ; ans[ResultingLength-1]+=scale[1]*v[last-1]+wavelet[1]*v[ResultingLength-1] ; ans[0]+=scale[2]*v[last-1]+wavelet[2]*v[ResultingLength-1] ; ans[1]+=scale[3]*v[last-1]+wavelet[3]*v[ResultingLength-1] ; ans[2]+=scale[4]*v[last-1]+wavelet[4]*v[ResultingLength-1] ; ans[3]+=scale[5]*v[last-1]+wavelet[5]*v[ResultingLength-1] ; ans[4]+=scale[6]*v[last-1]+wavelet[6]*v[ResultingLength-1] ; ans[5]+=scale[7]*v[last-1]+wavelet[7]*v[ResultingLength-1] ; for(int k=0;k<ResultingLength;k++) { v[k]=ans[k]; } delete[] ans; } void FastSymmlet8::invTransform (int length,float * v) { int last; for (last=8;2*last<=length;last*=2) { invTransform(length, v,last); } if(last!=length) { cout << "Careful: not a power of 2 : " << length << endl; cout << "Attention : n'est pas une puissance de 2 : " << length << endl; throw NotAPowerOf2Exception(); } } void FastSymmlet8::expand(int length, float * v) { int last=length/2; int ResultingLength=2*last; float * ans=new float[ResultingLength]; for(int k=0;k<ResultingLength;k++) { ans[k]=0; } for(int k=0;2*k+7<ResultingLength;k++) { ans[(2*k+7)]+=scale[7]*v[k]; ans[(2*k+6)]+=scale[6]*v[k]; ans[(2*k+5)]+=scale[5]*v[k]; ans[(2*k+4)]+=scale[4]*v[k]; ans[(2*k+3)]+=scale[3]*v[k]; ans[(2*k+2)]+=scale[2]*v[k]; ans[(2*k+1)]+=scale[1]*v[k]; ans[(2*k+0)]+=scale[0]*v[k]; } ans[ResultingLength-6]+=scale[0]*v[last-3]; ans[ResultingLength-5]+=scale[1]*v[last-3]; ans[ResultingLength-4]+=scale[2]*v[last-3]; ans[ResultingLength-3]+=scale[3]*v[last-3]; ans[ResultingLength-2]+=scale[4]*v[last-3]; ans[ResultingLength-1]+=scale[5]*v[last-3]; ans[0]+=scale[6]*v[last-3]; ans[1]+=scale[7]*v[last-3]; ans[ResultingLength-4]+=scale[0]*v[last-2]; ans[ResultingLength-3]+=scale[1]*v[last-2]; ans[ResultingLength-2]+=scale[2]*v[last-2]; ans[ResultingLength-1]+=scale[3]*v[last-2]; ans[0]+=scale[4]*v[last-2]; ans[1]+=scale[5]*v[last-2]; ans[2]+=scale[6]*v[last-2]; ans[3]+=scale[7]*v[last-2]; ans[ResultingLength-2]+=scale[0]*v[last-1]; ans[ResultingLength-1]+=scale[1]*v[last-1]; ans[0]+=scale[2]*v[last-1]; ans[1]+=scale[3]*v[last-1]; ans[2]+=scale[4]*v[last-1]; ans[3]+=scale[5]*v[last-1]; ans[4]+=scale[6]*v[last-1]; ans[5]+=scale[7]*v[last-1]; for(int k=0;k<length;k++) { v[k]=ans[k]; } delete[] ans; } /***************
  • Thanks to Peter Meerwald for pointing out a bug on the web release
  • of this code.
                              • /
int main () { int length = 32; float t[32]={1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f}; FastSymmlet8::transform(length,t); FastSymmlet8::invTransform (length,t); for(int k=0;k<length;k++) { cout << t[k] << endl; } }

Conclusion :


D'autres info sur :

http://www.ondelette.com/

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

akyso110
Messages postés
1
Date d'inscription
lundi 26 mars 2007
Statut
Membre
Dernière intervention
26 mars 2007
-
Ha... j'en révais...
Mais comment passer cette methode à une ensemble 2D pour l'imagerie ?
Car si j'ai bien compris le concept des ondelettes, c'est que je peux rester dans l'ensemble frequence/temps (ou frequence/espace) et acceder à toutes les information (position et frequence)
C'est bien cela ?
cs_mercibeaucoup
Messages postés
4
Date d'inscription
samedi 2 décembre 2006
Statut
Membre
Dernière intervention
6 juin 2007
-
tu peut faire une modification sur ce code pour faire la transformation en ondelette d'une image s.v.p
djaghloul
Messages postés
1
Date d'inscription
mercredi 19 octobre 2005
Statut
Membre
Dernière intervention
19 octobre 2005
-
Bonjour,
Il est clair que vous êtes d'un niveau académique très élaboré.
Est-ce que vous pouvez m'orienter vers des sources sur les ondelettes géometriques ?
Cordialement.
lpikachu58
Messages postés
351
Date d'inscription
samedi 2 février 2002
Statut
Membre
Dernière intervention
6 mai 2004
2 -
Pour faire de la transformée en ondelette qui est une transfomée temps espace fréquence qui permet en analyse multirésolution des images et du signal.
cs_LordBob
Messages postés
2865
Date d'inscription
samedi 2 novembre 2002
Statut
Membre
Dernière intervention
11 mai 2009
8 -
mais c'est fait pour faire quoi exactement?

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.