Mesimages : pour afficher ou débruiter des images
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.
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.
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.
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.