Mesimages : pour afficher ou débruiter des images

Soyez le premier à donner votre avis sur cette source.

Vue 7 286 fois - Téléchargée 1 364 fois

Description

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 / Exemple :


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.

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
331
Date d'inscription
samedi 18 décembre 2004
Statut
Membre
Dernière intervention
9 janvier 2022
2
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.
Messages postés
331
Date d'inscription
samedi 18 décembre 2004
Statut
Membre
Dernière intervention
9 janvier 2022
2
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.
Messages postés
331
Date d'inscription
samedi 18 décembre 2004
Statut
Membre
Dernière intervention
9 janvier 2022
2
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.

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.