begin process at 2013 05 26 08:54:14
  Trouver un code source :
 
dans
 
[ Dernières recherches ]
Accueil > 

Code

 > 

Graphique

 > MESIMAGES : POUR AFFICHER OU DÉBRUITER DES IMAGES

MESIMAGES : POUR AFFICHER OU DÉBRUITER DES IMAGES


 Information sur la source

Note :
Aucune note
Catégorie :Graphique Classé sous :API Windows, images, ondelettes, débruitage Niveau :Initié Date de création :23/08/2012 Date de mise à jour :04/10/2012 19:30:48 Vu / téléchargé :3 074 / 235
Auteur : pgl10

Ecrire un message privé
Site perso
Commentaire sur cette source (3)
Ajouter un commentaire et/ou une note

 Description

Cliquez pour voir la capture en taille normale
MesImages est un logiciel en API Windows pour afficher et traiter des images. Les formats d'images utilisables sont : BMP, GIF, JPG, PNG, PPM, TGA et TIFF. Pour utiliser d'autres formats, soit on utilise un convertiseur de format et Internet en propose plusieurs qui sont gratuits, soit on effectue en ligne la conversion de format. MesImages est un logiciel portable : il est directement utilisable par une simple copie et n'installe rien dans le système Windows ni dans la base de registres. Il permet d'ouvrir la première image  en faisant un glisser-déposer du fichier image sur l'exécutable. Il permet aussi d'en ouvrir une autre  en faisant un glisser-déposer du fichier de l'image nouvelle dans la fenêtre. Le mode d'emploi complet s'obtient en faisant F1. Mais le plus intéressant concerne le débruitage éventuel de l'image. Il y a beaucoup de méthodes diverses pour débruiter une image. Ici on utilise une décomposition en ondelettes suivie de la recomposition inverse. Et dans l'intervalle on annule les coefficients supérieurs qui représentent les changements les plus localisés dans l'image. Pour les discriminer il faut un seuil avec lequel on fait soit du seuillage dur soit du seuillage doux. Le calcul de ce seuil est une affaire délicate. Ici, on peut utiliser un seuil choisi manuellement ou bien calculer un seuil automatiquement. Pour le seuil automatique on a divers paramètres disponibles : le nombre de niveaux de la transformée en ondelettes, le modèle d'ondelettes en service et le calcul du seuil. Les divers types d'ondelettes disponibles ici sont celles de Haar et de Daubechies, les Symmlets, les Coiflets et les bases biorthogonales. La recherche d'un bon choix pour le seuil automatique est donc facilitée, mais c'est aussi un compromis que l'on peut personnaliser. Si le seuil est trop petit il est inefficace et s'il est trop grand il débruite mais il ajoute aussi du flou dans l'image. Les seuls deux autres traitements disponibles ici sont le zoom et l'ajout volontaire du flou dans toute l'image.

Source

  • char monprojet[] = "MesImages v 0.8";
  • char nomModel[300]; // nom complet du fichier à afficher
  • int larg; // largeur de l'image
  • int haut; // hauteur de l'image
  • int lsup=10; // supplément de largeur entre la fenêtre et l'image ( 2 marges )
  • int hsup=74; // supplément expérimental de hauteur entre la fenêtre et l'image
  • int hbet; // hauteur de barre d'état
  • UCHAR *ucpBitsMem; // les pixels BGRA de l'image
  • int cx,cy,xe,ye; // largeur et hauteur de la fenêtre et de l'écran
  • int prem; // prem : 1 pour le premier affichage et 0 ensuite
  • int zoom; // zoom : 1 ( éch. 1 ) ou 2 ( éch. 1/2 ) ou 4 ( éch. 1/4 )
  • int imin; // imin : 1 si l'image actuelle est une miniature ou 0 si non
  • int nmax; // nombre d'images qui se suivent en fenêtre maximisée
  • int faire; // variable d'état pour newModel : -1, 0, 1 ou 2
  • char buf[1024]; // un buffer de travail réutilisable
  • int nn=4; // nombre de niveaux pour la transformée en ondelettes
  • int ms=3; // méthode de seuillage dur ou doux ( dur : 1 ou 2 doux : 3 )
  • int intscr; // entier lu par scrolling pour le seuil manuel de débruitage
  • // si intscr=0 c'est le seuil automatique qui sera activé.
  • void flouter() {
  • int i, j, k, na, nb; // pour un flou avec 0 < a=alfa < b=beta < 0.125
  • UCHAR *temp;
  • double alfa, beta, tota; // k l m
  • alfa=0.03; // n p q
  • beta=0.09; // r s t
  • temp = (UCHAR*)malloc(4*larg*haut*sizeof(UCHAR));
  • for(i=0; i<larg*haut*4; i++) temp[i] = ucpBitsMem[i]; // nouveau p = (1-4a-4b)p+a(k+m+r+t)+b(l+n+q+s)
  • for(i=0; i<haut; i++) // i : indice ligne
  • for(j=0; j<larg; j++) // j : indice colonne
  • for(k=0; k<3; k++) { // pour RGB seulement
  • na = nb = 0;
  • tota = 0.0;
  • if(j>0 && i>0 ) {tota = tota + alfa*(double)temp[4*((j-1)+(i-1)*larg)+k]; na=na+1;}
  • if(j>0 && i<haut-1) {tota = tota + alfa*(double)temp[4*((j-1)+(i+1)*larg)+k]; na=na+1;}
  • if(j<larg-1 && i>0 ) {tota = tota + alfa*(double)temp[4*((j+1)+(i-1)*larg)+k]; na=na+1;}
  • if(j<larg-1 && i<haut-1) {tota = tota + alfa*(double)temp[4*((j+1)+(i+1)*larg)+k]; na=na+1;}
  • if(j>0 ) {tota = tota + beta*(double)temp[4*((j-1)+i*larg)+k]; nb=nb+1;}
  • if(i>0 ) {tota = tota + beta*(double)temp[4*(j+(i-1)*larg)+k]; nb=nb+1;}
  • if(i<haut-1) {tota = tota + beta*(double)temp[4*(j+(i+1)*larg)+k]; nb=nb+1;}
  • if(j<larg-1) {tota = tota + beta*(double)temp[4*((j+1)+i*larg)+k]; nb=nb+1;}
  • tota = tota + (1.0-(alfa*(double)na+beta*(double)nb))*(double)temp[4*(j+i*larg)+k];
  • ucpBitsMem[4*(j+i*larg)+k] = (UCHAR)((int)(tota+0.5)); // 0.5 pour la conversion double => int
  • }
  • free (temp);
  • hBmpMem = BufferToHBitmap(ucpBitsMem, (long)larg, (long)(-haut)); // mise à jour de l'image affichée
  • SelectObject(hdcMem, hBmpMem);
  • InvalidateRect(hWnd, NULL, TRUE);
  • }
  • double inline dabs(double x){return (x<0)?-x:x;}
  • void debruiter() { // transformation en ondelettes
  • double *temp; // et restitution débruitée
  • double *vect;
  • double sigma, seuil, s, t;
  • int largt, hautt, maxt, i, j, k, itmp, ln, hn, n;
  • largt=hautt=2;
  • while(largt<larg) largt=2*largt;
  • while(hautt<haut) hautt=2*hautt;
  • temp = (double*)malloc(4*largt*hautt*sizeof(double));
  • for(i=0; i<largt*hautt*4; i=i+4) {
  • temp[i+0] = 33.0;
  • temp[i+1] = 33.0;
  • temp[i+2] = 33.0;
  • temp[i+3] = 0.0;
  • }
  • for(i=0; i<haut; i++) // copie et conversion de l'image actuelle
  • for(j=0; j<larg; j++)
  • for(k=0; k<3; k++) {
  • temp[4*(j+i*largt)+k] = (double)ucpBitsMem[4*(j+i*larg)+k];
  • }
  • maxt=largt;
  • if(maxt<hautt) maxt=hautt;
  • vect = (double*)malloc(maxt*sizeof(double));
  • ln=largt;
  • hn=hautt;
  • for(n=0; n<nn; n++) { // transformée en ondelettes à nn niveaux
  • for(i=0; i<hn; i++) for(k=0; k<3; k++) { // transformation des lignes
  • for(j=0; j<ln; j++) vect[j]=temp[4*(j+i*largt)+k];
  • transformer(vect, ln); // |---------------|
  • for(j=0; j<ln; j++) temp[4*(j+i*largt)+k]=vect[j]; // |BB2|HB2| |
  • } // |---|---| HB1 |
  • for(j=0; j<ln; j++) for(k=0; k<3; k++) { // transformation des colonnes |BH2|HH2| |
  • for(i=0; i<hn; i++) vect[i]=temp[4*(j+i*largt)+k]; // |-------|-------|
  • transformer(vect, hn); // | | |
  • for(i=0; i<hn; i++) temp[4*(j+i*largt)+k]=vect[i]; // | BH1 | HH1 |
  • } // | | |
  • ln=ln/2; // |---------------|
  • hn=hn/2;
  • // HB1 signifie : fréquences hautes pour les lignes, basses pour les colonnes et 1-er niveau de transformée, etc.
  • }
  • sigma=sigmab(temp, largt, hautt); // estimation de l'écart type du bruit
  • ln=largt;
  • hn=hautt;
  • switch(ms) {
  • case 1: // seuillage dur n° 1 ( avec le NormalShrink )
  • for(n=0; n<nn; n++) {
  • if(intscr!=0) seuil = (double)intscr;
  • if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 1);
  • for(i=0; i<hn/2; i++) // les 3 composantes RGB sont annulées ensemble
  • for(j=ln/2; j<ln; j++) { // seuillage du rectangle HBn
  • s=0.0; for(k=0;k<3;k++){t=temp[4*(j+i*largt)+k]; s=s+t*t;} s=sqrt(s);
  • if(s < seuil) for(k=0; k<3; k++) temp[4*(j+i*largt)+k]=0.0;
  • }
  • if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 2);
  • for(i=hn/2; i<hn; i++) // seuillage du rectangle BHn
  • for(j=0; j<ln/2; j++) {
  • s=0.0; for(k=0;k<3;k++){t=temp[4*(j+i*largt)+k]; s=s+t*t;} s=sqrt(s);
  • if(s < seuil) for(k=0; k<3; k++) temp[4*(j+i*largt)+k]=0.0;
  • }
  • if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 3);
  • for(i=hn/2; i<hn; i++) // seuillage du rectangle HHn
  • for(j=ln/2; j<ln; j++) {
  • s=0.0; for(k=0;k<3;k++){t=temp[4*(j+i*largt)+k]; s=s+t*t;} s=sqrt(s);
  • if(s < seuil) for(k=0; k<3; k++) temp[4*(j+i*largt)+k]=0.0;
  • }
  • ln=ln/2;
  • hn=hn/2;
  • }
  • break;
  • case 2: // seuillage dur n° 2 ( avec le NormalShrink )
  • for(n=0; n<nn; n++) {
  • if(intscr!=0) seuil = (double)intscr;
  • if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 1);
  • for(i=0; i<hn/2; i++) // chaque composante RGB est annulée séparément
  • for(j=ln/2; j<ln; j++) // seuillage du rectangle HBn
  • for(k=0; k<3; k++)
  • if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
  • if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 2);
  • for(i=hn/2; i<hn; i++) // seuillage du rectangle BHn
  • for(j=0; j<ln/2; j++)
  • for(k=0; k<3; k++)
  • if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
  • if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 3);
  • for(i=hn/2; i<hn; i++) // seuillage du rectangle HHn
  • for(j=ln/2; j<ln; j++)
  • for(k=0; k<3; k++)
  • if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
  • ln=ln/2;
  • hn=hn/2;
  • }
  • break;
  • case 3: // seuillage doux ( avec le NormalShrink )
  • for(n=0; n<nn; n++) {
  • if(intscr!=0) seuil = (double)intscr;
  • if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 1);
  • for(i=0; i<hn/2; i++) // chaque composante RGB est annulée séparément
  • for(j=ln/2; j<ln; j++) // seuillage du rectangle HBn
  • for(k=0; k<3; k++)
  • if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
  • else if(temp[4*(j+i*largt)+k]>0.0) temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]-seuil;
  • else temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]+seuil;
  • if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 2);
  • for(i=hn/2; i<hn; i++) // seuillage du rectangle BHn
  • for(j=0; j<ln/2; j++)
  • for(k=0; k<3; k++)
  • if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
  • else if(temp[4*(j+i*largt)+k]>0.0) temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]-seuil;
  • else temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]+seuil;
  • if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 3);
  • for(i=hn/2; i<hn; i++) // seuillage du rectangle HHn
  • for(j=ln/2; j<ln; j++)
  • for(k=0; k<3; k++)
  • if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
  • else if(temp[4*(j+i*largt)+k]>0.0) temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]-seuil;
  • else temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]+seuil;
  • ln=ln/2;
  • hn=hn/2;
  • }
  • break;
  • }
  • for(n=0; n<nn; n++) { // restitution à nn niveaux
  • ln=ln*2;
  • hn=hn*2;
  • for(j=0; j<ln; j++) for(k=0; k<3; k++) { // restitution des colonnes
  • for(i=0; i<hn; i++) vect[i]=temp[4*(j+i*largt)+k];
  • restituer(vect, hn);
  • for(i=0; i<hn; i++) temp[4*(j+i*largt)+k]=vect[i];
  • }
  • for(i=0; i<hn; i++) for(k=0; k<3; k++) { // restitution des lignes
  • for(j=0; j<ln; j++) vect[j]=temp[4*(j+i*largt)+k];
  • restituer(vect, ln);
  • for(j=0; j<ln; j++) temp[4*(j+i*largt)+k]=vect[j];
  • }
  • }
  • free(vect);
  • for(i=0; i<haut; i++) // mise à jour de l'image affichée
  • for(j=0; j<larg; j++)
  • for(k=0; k<3; k++) {
  • itmp = (int)(temp[4*(j+i*largt)+k]+0.5);
  • if(itmp<0) itmp=0;
  • if(itmp>255) itmp=255;
  • ucpBitsMem[4*(j+i*larg)+k] = (UCHAR)itmp;
  • }
  • free(temp);
  • hBmpMem = BufferToHBitmap(ucpBitsMem, (long)larg, (long)(-haut));
  • SelectObject(hdcMem, hBmpMem);
  • InvalidateRect(hWnd, NULL, TRUE);
  • } 
char monprojet[] = "MesImages v 0.8";
char nomModel[300]; // nom complet du fichier à afficher
int larg;           // largeur de l'image
int haut;           // hauteur de l'image
int lsup=10;        // supplément de largeur entre la fenêtre et l'image ( 2 marges )
int hsup=74;        // supplément expérimental de hauteur entre la fenêtre et l'image
int hbet;           // hauteur de barre d'état
UCHAR *ucpBitsMem;  // les pixels BGRA de l'image
int cx,cy,xe,ye;    // largeur et hauteur de la fenêtre et de l'écran
int prem;           // prem : 1 pour le premier affichage et 0 ensuite
int zoom;           // zoom : 1 ( éch. 1 ) ou 2 ( éch. 1/2 ) ou 4 ( éch. 1/4 )
int imin;           // imin : 1 si l'image actuelle est une miniature ou 0 si non
int nmax;           // nombre d'images qui se suivent en fenêtre maximisée
int faire;          // variable d'état pour newModel : -1, 0, 1 ou 2 
char buf[1024];     // un buffer de travail réutilisable
int nn=4;           // nombre de niveaux pour la transformée en ondelettes 
int ms=3;           // méthode de seuillage dur ou doux ( dur : 1 ou 2 doux : 3 )
int intscr;         // entier lu par scrolling pour le seuil manuel de débruitage
                    // si intscr=0 c'est le seuil automatique qui sera activé.
   
void flouter() {    
int i, j, k, na, nb;                                        // pour un flou avec 0 < a=alfa < b=beta < 0.125
UCHAR *temp;
double alfa, beta, tota;                                    //                   k  l  m
     alfa=0.03;                                             //                   n  p  q
     beta=0.09;                                             //                   r  s  t
     temp = (UCHAR*)malloc(4*larg*haut*sizeof(UCHAR));
     for(i=0; i<larg*haut*4; i++) temp[i] = ucpBitsMem[i];  //  nouveau p = (1-4a-4b)p+a(k+m+r+t)+b(l+n+q+s)  
     for(i=0; i<haut; i++)          // i : indice ligne
         for(j=0; j<larg; j++)      // j : indice colonne
             for(k=0; k<3; k++) {   // pour RGB seulement 
                 na = nb = 0;
                 tota = 0.0;
                 if(j>0      && i>0     ) {tota = tota + alfa*(double)temp[4*((j-1)+(i-1)*larg)+k]; na=na+1;}
                 if(j>0      && i<haut-1) {tota = tota + alfa*(double)temp[4*((j-1)+(i+1)*larg)+k]; na=na+1;}
                 if(j<larg-1 && i>0     ) {tota = tota + alfa*(double)temp[4*((j+1)+(i-1)*larg)+k]; na=na+1;}
                 if(j<larg-1 && i<haut-1) {tota = tota + alfa*(double)temp[4*((j+1)+(i+1)*larg)+k]; na=na+1;}
                 if(j>0     ) {tota = tota + beta*(double)temp[4*((j-1)+i*larg)+k]; nb=nb+1;}
                 if(i>0     ) {tota = tota + beta*(double)temp[4*(j+(i-1)*larg)+k]; nb=nb+1;}
                 if(i<haut-1) {tota = tota + beta*(double)temp[4*(j+(i+1)*larg)+k]; nb=nb+1;}
                 if(j<larg-1) {tota = tota + beta*(double)temp[4*((j+1)+i*larg)+k]; nb=nb+1;}
                 tota = tota + (1.0-(alfa*(double)na+beta*(double)nb))*(double)temp[4*(j+i*larg)+k];
                 ucpBitsMem[4*(j+i*larg)+k] = (UCHAR)((int)(tota+0.5));  // 0.5 pour la conversion double => int
             }
     free (temp);
     hBmpMem = BufferToHBitmap(ucpBitsMem, (long)larg, (long)(-haut));   // mise à jour de l'image affichée
     SelectObject(hdcMem, hBmpMem);
     InvalidateRect(hWnd, NULL, TRUE);     
}
   
double inline dabs(double x){return (x<0)?-x:x;}
   
void debruiter() {   // transformation en ondelettes
double *temp;        // et restitution débruitée
double *vect;
double sigma, seuil, s, t;
int largt, hautt, maxt, i, j, k, itmp, ln, hn, n;
     largt=hautt=2;
     while(largt<larg) largt=2*largt;
     while(hautt<haut) hautt=2*hautt;
     temp = (double*)malloc(4*largt*hautt*sizeof(double));
     for(i=0; i<largt*hautt*4; i=i+4) {
          temp[i+0] = 33.0;
          temp[i+1] = 33.0;
          temp[i+2] = 33.0;
          temp[i+3] = 0.0;
     }
     for(i=0; i<haut; i++)         // copie et conversion de l'image actuelle
         for(j=0; j<larg; j++)
             for(k=0; k<3; k++) {
                  temp[4*(j+i*largt)+k] = (double)ucpBitsMem[4*(j+i*larg)+k];
             }
     maxt=largt;
     if(maxt<hautt) maxt=hautt;
     vect = (double*)malloc(maxt*sizeof(double));
     ln=largt;
     hn=hautt;
     for(n=0; n<nn; n++) {            // transformée en ondelettes à nn niveaux
         for(i=0; i<hn; i++) for(k=0; k<3; k++) {  // transformation des lignes
             for(j=0; j<ln; j++) vect[j]=temp[4*(j+i*largt)+k];
             transformer(vect, ln);                              //                   |---------------|
             for(j=0; j<ln; j++) temp[4*(j+i*largt)+k]=vect[j];  //                   |BB2|HB2|       |
         }                                                       //                   |---|---|  HB1  |
         for(j=0; j<ln; j++) for(k=0; k<3; k++) {  // transformation des colonnes     |BH2|HH2|       |
             for(i=0; i<hn; i++) vect[i]=temp[4*(j+i*largt)+k];  //                   |-------|-------|
             transformer(vect, hn);                              //                   |       |       |
             for(i=0; i<hn; i++) temp[4*(j+i*largt)+k]=vect[i];  //                   |  BH1  |  HH1  |
         }                                                       //                   |       |       |
         ln=ln/2;                                                //                   |---------------|
         hn=hn/2;  
     // HB1 signifie : fréquences hautes pour les lignes, basses pour les colonnes et 1-er niveau de transformée, etc.
     }
     sigma=sigmab(temp, largt, hautt);  // estimation de l'écart type du bruit
     ln=largt;
     hn=hautt;
     switch(ms) {
        case 1:                         // seuillage dur n° 1 ( avec le NormalShrink )
           for(n=0; n<nn; n++) {
               if(intscr!=0) seuil = (double)intscr;
               if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 1);
               for(i=0; i<hn/2; i++)         // les 3 composantes RGB sont annulées ensemble
                   for(j=ln/2; j<ln; j++) {  // seuillage du rectangle HBn
                       s=0.0; for(k=0;k<3;k++){t=temp[4*(j+i*largt)+k]; s=s+t*t;} s=sqrt(s);
                       if(s < seuil) for(k=0; k<3; k++) temp[4*(j+i*largt)+k]=0.0;
                   }
               if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 2);
               for(i=hn/2; i<hn; i++)        // seuillage du rectangle BHn
                   for(j=0; j<ln/2; j++) {
                       s=0.0; for(k=0;k<3;k++){t=temp[4*(j+i*largt)+k]; s=s+t*t;} s=sqrt(s);
                       if(s < seuil) for(k=0; k<3; k++) temp[4*(j+i*largt)+k]=0.0;
                   }
               if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 3);
               for(i=hn/2; i<hn; i++)        // seuillage du rectangle HHn
                   for(j=ln/2; j<ln; j++) {
                       s=0.0; for(k=0;k<3;k++){t=temp[4*(j+i*largt)+k]; s=s+t*t;} s=sqrt(s);
                       if(s < seuil) for(k=0; k<3; k++) temp[4*(j+i*largt)+k]=0.0;
                   }
               ln=ln/2;
               hn=hn/2;
           }
           break;
        case 2:                         // seuillage dur n° 2 ( avec le NormalShrink )
           for(n=0; n<nn; n++) {
               if(intscr!=0) seuil = (double)intscr;
               if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 1);
               for(i=0; i<hn/2; i++)         // chaque composante RGB est annulée séparément
                   for(j=ln/2; j<ln; j++)    // seuillage du rectangle HBn
                       for(k=0; k<3; k++) 
                           if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
               if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 2);
               for(i=hn/2; i<hn; i++)        // seuillage du rectangle BHn
                   for(j=0; j<ln/2; j++)
                       for(k=0; k<3; k++) 
                           if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
               if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 3);
               for(i=hn/2; i<hn; i++)        // seuillage du rectangle HHn
                   for(j=ln/2; j<ln; j++)
                       for(k=0; k<3; k++) 
                           if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
               ln=ln/2;
               hn=hn/2;
           }
           break;
        case 3:                         // seuillage doux ( avec le NormalShrink )
           for(n=0; n<nn; n++) {
               if(intscr!=0) seuil = (double)intscr;
               if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 1);
               for(i=0; i<hn/2; i++)         // chaque composante RGB est annulée séparément
                   for(j=ln/2; j<ln; j++)    // seuillage du rectangle HBn
                       for(k=0; k<3; k++) 
                           if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
                           else if(temp[4*(j+i*largt)+k]>0.0) temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]-seuil;
                                else temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]+seuil;
               if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 2);
               for(i=hn/2; i<hn; i++)        // seuillage du rectangle BHn
                   for(j=0; j<ln/2; j++)
                       for(k=0; k<3; k++) 
                           if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
                           else if(temp[4*(j+i*largt)+k]>0.0) temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]-seuil;
                                else temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]+seuil;
               if(intscr==0) seuil = sqrt(log((double)(ln*hn/4)/(double)nn))*sigma*sigma/ecart(temp, largt, ln, hn, 3);
               for(i=hn/2; i<hn; i++)        // seuillage du rectangle HHn
                   for(j=ln/2; j<ln; j++)
                       for(k=0; k<3; k++) 
                           if(dabs(temp[4*(j+i*largt)+k])<seuil) temp[4*(j+i*largt)+k]=0.0;
                           else if(temp[4*(j+i*largt)+k]>0.0) temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]-seuil;
                                else temp[4*(j+i*largt)+k]=temp[4*(j+i*largt)+k]+seuil;
               ln=ln/2;
               hn=hn/2;
           }
           break;
     }
     for(n=0; n<nn; n++) {                         // restitution à nn niveaux
         ln=ln*2; 
         hn=hn*2;
         for(j=0; j<ln; j++) for(k=0; k<3; k++) {  // restitution des colonnes
             for(i=0; i<hn; i++) vect[i]=temp[4*(j+i*largt)+k];
             restituer(vect, hn);
             for(i=0; i<hn; i++) temp[4*(j+i*largt)+k]=vect[i];
         }
         for(i=0; i<hn; i++) for(k=0; k<3; k++) {  // restitution des lignes
             for(j=0; j<ln; j++) vect[j]=temp[4*(j+i*largt)+k];
             restituer(vect, ln);
             for(j=0; j<ln; j++) temp[4*(j+i*largt)+k]=vect[j];
         }
     }
     free(vect);
     for(i=0; i<haut; i++)      // mise à jour de l'image affichée
         for(j=0; j<larg; j++)
             for(k=0; k<3; k++) {
                  itmp = (int)(temp[4*(j+i*largt)+k]+0.5);
                  if(itmp<0) itmp=0;
                  if(itmp>255) itmp=255;
                  ucpBitsMem[4*(j+i*larg)+k] = (UCHAR)itmp;
             }
     free(temp);
     hBmpMem = BufferToHBitmap(ucpBitsMem, (long)larg, (long)(-haut)); 
     SelectObject(hdcMem, hBmpMem);
     InvalidateRect(hWnd, NULL, TRUE);     
}

 Conclusion

En raison de la place limitée mon envoi comporte tout ce qu'il faut pour compiler les sources mais les bibliothèques nécessaires à l'édition de liens ne sont pas incluses. Cependant on trouve dans mon site web : http://pgl10.chez.com une archive complète avec les bibliothèques et davantage d'images pour faire d'autres essais. Toutes vos remarques ou améliorations éventuelles sont les bienvenues.

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Historique

09 septembre 2012 15:06:48 :
version 0.65 : petite correction et diverses amélioration
15 septembre 2012 21:11:42 :
Plusieurs modifications
15 septembre 2012 21:50:46 :
La version 0.75 corrige un petit problème pour le flou commandé.
28 septembre 2012 19:30:07 :
La version 0.76 clarifie quelques explications un peu ambigues.
28 septembre 2012 20:18:24 :
Correction du numéro de version affiché.
04 octobre 2012 19:00:52 :
En version 0.8 une précision et un ajout
04 octobre 2012 19:30:48 :
En version 0.8 une précision et un ajout

 Sources du même auteur

Source avec Zip Source avec une capture COMPARAISON DE QUATRE MÉTHODES OPENGL POUR AFFICHER UN OBJET...
Source avec Zip Source avec une capture POUR DÉPLACER DES OBJETS 3D DANS UNE SCÈNE WINDOWS 3D
Source avec Zip Source avec une capture MAGEO3D, POUR GÉRER LES POINTS ET LES VECTEURS DE L'ESPACE R...
Source avec Zip Source avec une capture OBTENIR DANS UN FICHIER LE CONTENU D'UN DOSSIER WINDOWS
Source avec Zip Source avec une capture UNE LISTE HÉTÉROGÈNE DOUBLEMENT CHAINÉE
Toutes les sources de pgl10

 Sources de la même categorie

Source avec Zip Source avec une capture COMPARAISON DE QUATRE MÉTHODES OPENGL POUR AFFICHER UN OBJET... par pgl10
Source avec Zip Source avec une capture POUR DÉPLACER DES OBJETS 3D DANS UNE SCÈNE WINDOWS 3D par pgl10
Source avec Zip Source avec une capture PLANNING D'EQUIPE par grephit
Source avec Zip APPLICATION DE DESSIN DE QUELQUES FIGURES par laguchori
Source avec Zip Source avec une capture HDR EXPOSURE FUSION par mecrosoft
Toutes les sources de la catégorie Graphique

 Sources en rapport avec celle ci

Source avec Zip Source avec une capture POUR DÉPLACER DES OBJETS 3D DANS UNE SCÈNE WINDOWS 3D par pgl10
Source avec Zip Source avec une capture AFFIMOFF : UNE VISIONNEUSE 3D AVEC PARAMÉTRISATION ET TEXTUR... par pgl10
Source avec Zip Source avec une capture CALCUL D'UNE RACINE NUMÉRIQUE par pgl10
Source avec Zip Source avec une capture C++ FORMAT D'IMAGE AVEC QT par pop70
Source avec Zip Source avec une capture MONPPM : UN AFFICHEUR .PPM par pgl10

Commentaires et avis

Commentaire de pgl10 le 09/09/2012 15:07:51

Dans la version 0.65 j'ai fait une petite correction et plusieurs améliorations. Le menu et le mode d'emploi ( F1 ) sont plus détaillés. La méthode de calcul du seuil automatique est changée, elle se base maintenant sur le "NormalSchrink". A ce propos, il faut noter que la transformée en ondelette est réversible : si les coefficients sont inchangés la transformée inverse fournit une image identique à l'image originale. Le seuillage doux, manuel ou automatique, diminue les coefficients, donc si on débruite plusieurs fois en seuillage doux on augmente le débruitage ( et le flou qui l'accompagne ). Par contre, le débruitage dur annule les petits coefficients tandis que les autres sont inchangés. Si on débruite plusieurs fois en seuillage dur il ne sert à rien d'annuler une nouvelle fois les coefficients qui ont été déjà annulés la première fois, cela ne change plus rien. A noter que de nombreux choix arbitraires sont facilement modifiables dans la programmation : le modèle d'ondelette utilisée, le nombre de niveaux de la transformée ou le calcul du seuil automatique. Il faut aussi noter que l'effet de débruitage automatique obtenu varie en apparence d'une image à l'autre.

Commentaire de pgl10 le 15/09/2012 21:16:36

Dans la version 0.7 j'ai fait diverses modifications, simplifications et commentaires supplémentaires. Le changement le plus important concerne une meilleure programmation de la transformée en ondelettes quand celle-ci utilise plusieurs niveaux de transformation.

Commentaire de pgl10 le 04/10/2012 19:35:50

Dans la version 0.8 j'ai précisé la signification de HB1, BH1, HH1 ... En plus, j'ai ajouté un petit programme simplissime de démontration du débruitage d'un signal par transformée en ondelettes qui fonctionne en mode console.

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

integer des images dans le EXE [ par pipo ] qq un sait il comment inserer dans bitmap dans l'exe final (winapi) ! un peu comme en MCF ! integer des images dans le EXE [ par pipo ] qq un sait il comment inserer dans bitmap dans l'exe final (winapi) ! un peu comme en MCF ! integer des images dans le EXE [ par pipo ] qq un sait il comment inserer dans bitmap dans l'exe final (winapi) ! un peu comme en MCF ! IMAGE dans une liste .......... [ par lilo44 ] salutj'essai de coder un chat pi je voudrais gerer les smileys. je cherche donc un fonction qui puisse gerer les images, les retours a la ligne .En gr programme de marquage d'images [ par michaeldalinbis ] bonjour,nous sommes 3 étudiants et faisons des recherches sur la stéganographie.recherchons plus précisément des programmes(le + compréhensible possib Afficher des images [ par Heero ] Comment on fait pour afficher des images dans une appli console sous vc++ ? boutons avec images [ par crazy666 ] je sais ca peut parraitre très con et certains vont se marrer et dire oh le newbie en lisant ca mais g un petit pbje veux créer des boutons avec des i Besoin d'images pour un jeu de rôle [ par LightningFlik ] Voilà, je fais un jeu de rôle et je n'ai pas d'images. Je pourrais évidemment les prendre dans d'autres jeux (c'et ce que j'ai fait mais ce n'est que pleeeeeeeeeaaaaaaase:images bmp [ par kambo ] salut ! j'aimerais savoir comment inserer une bmp dans une fenetre ,serait-t-il possible de la manipuler avec la souris ,ou de la localiser ds un repe images JPEG en vidéo MPEG1 [ par brozman ] Bonjour, je dois faire un programme qui genere un fichier video au format MPEG1 a partir d'images JPEG,est-ce qu'il existe des programmes, des sources


Nos sponsors


Sondage...

Comparez les prix


Samsung Galaxy S
Entre 529€ et 529€

Visiter le guide achat

CalendriCode

Mai 2013
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Photothèque

Photo KältePhoto Green world, abstract environmental backgrounds for your design
Photo Red cushion starfish in a coral reef 

Visiter la photothèque

A découvrir
 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 1,045 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales
Outils Convertisseur VB/C# Snippets et scripts Outils en ligne La ToolBox
Communauté Programmation Photographie Technologie Newsgroups Emploi Forum Blogs
Guide d'achat Téléphonie mobile Image et son Informatique Bureautique Jeux vidéo
Logiciels Internet & Réseau Développement Market Android Jeux & Loisirs Graphisme Multimédia Sécurité Pilotes
Loisirs Cartes virtuelles Vidéos droles Jeux en ligne Géoguide AndroLib [FR] AndroLib [US] FormidApps [FR] FormidApps [US]