Binarisation

Soyez le premier à donner votre avis sur cette source.

Vue 9 368 fois - Téléchargée 974 fois

Description

Voila un petit code qui binarise une image. Il utilise allegro pour ouvrir/affiche/... les images et le graphs. J'espere que vous pourrez en tirer quelque chose ^^

Pour ceux qui voudrais voir ce que ca donne sans compiler. Renomez le .dat du zip par .exe ...

Source / Exemple :


#include <stdio.h>
#include <stdlib.h>
#include <allegro.h>

#define _DIMX 256
#define _DIMY 256

void affpoint(BITMAP *buffer,int x,int y,int gris) 
{
    int color;
    color=makecol(gris,gris,gris);
   	rectfill(buffer,x,y,x+1,y+1,color);
}
void affbar(BITMAP *buffer,int x,int y,int hauteur,int largeur,int r,int g, int b) // affiche un rectangle
{
    int color;
    color=makecol(r,g,b);
   	rectfill(buffer,x,y,x+largeur,y+hauteur,color);
}
int IntBlinde(int max,int min) // blinde l'entrée d'un entier
{
    int r;
    do {
    printf("Entrez un entier en %d et %d\n",min,max);
    scanf("%d",&r);
    if ((r>max) || (r<min)) printf("Erreur, veuillez resaisir\n");
    }while((r>max) || (r<min));
    return r;
}
int maxval(int *list,int interbas,int interhaut) // calcule la position de la valeur max sur un interval
{
    int i,max,maxv;
    maxv=0;
    for(i=interbas;i<=interhaut;i++)
    if (list[i]>maxv)
    { maxv=list[i];
    max = i ; }
return max;
}
int minval(int *list,int interbas,int interhaut) //min diff de 0 ... securité pour image de moins de 256 couleurs
{
    int i,min,minv;
    minv=list[interbas];
    for(i=interbas;i<=interhaut;i++)
    if (list[i]<minv && list[i]!=0)
    { minv=list[i];
    min = i ; }
return min;
}
int medianval(int *list,int interbas,int interhaut) //min diff de 0 ... securité pour image de moins de 256 couleurs
{
    int i,somme,median;
    somme=0;
    median=0;
    for(i=interbas;i<=interhaut;i++)
    {somme+=list[i]*i;
    median+=list[i];}
    median=somme/median;
    
return median;
}

int allegrogo() // ini de allegro
{
     //allegro ini  
     
allegro_init();
install_keyboard();
set_color_depth(16);
//ouvre la fenetre de travail
   if (set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0)!=0){
      allegro_message(allegro_error);
      allegro_exit();
      return 1;
   }
//var ini
}

int main(int argc, char *argv[])
{
    
//var ini
  int image[_DIMY+1][_DIMY+1];
  int imaged[_DIMY+1][_DIMY+1];
  int gris[256];
  int dimx,dimy,i,j,k;
  char* nom_fichier="image.bmp";
  BITMAP* imagep;
  BITMAP* buffer; 

//choix de l'image
do {
printf("Binarisation : Andrieu Jerome ( hackziner ) \n");  
printf("hackziner@hotmail.com hackziner@gmail.com\n"); 
printf("1 - generation aleatoire d'une image\n");  
printf("2 - charger image.bmp du repertoire courant\n");  
scanf("%d",&i);
}while(i<1 && i>2);

switch(i) 
{

case 1: //image aleatoire
     

     //dimension
printf("Entrez les dimensions de l'image en X puis Y\n");
dimx = IntBlinde(_DIMX,2);
dimy = IntBlinde(_DIMY,2);  
//ini alleg
     allegrogo();
     buffer = create_bitmap(640, 480) ;
//gene aleatoire

//printf("Generation d'une image aleatoire\n");
for(i=0;i<(dimy/2);i++)
for(j=0;j<dimx;j++)
image[j][i]=rand()%128;

for(i=(dimy/2);i<dimy;i++)
for(j=0;j<dimx;j++)
image[j][i]=rand()%128+128;

//affiche l'image
for(i=0;i<dimy;i++)
for(j=0;j<dimx;j++)
affpoint(buffer,j,i,image[j][i]);
blit(buffer, screen, 0, 0, 0, 0, 640, 480) ;
break;                         
  
case 2: // charge image.bmp
     allegrogo();
     buffer = create_bitmap(640, 480) ; // on aurai pu define la resolution
    // Quel image a chargé
    //printf("Entre le num de l'image a charger \n");
    //rewind(stdin);
    //scanf("%c",nom_fichier[5]);
   	// charge l'image
   	imagep=load_bitmap(nom_fichier,NULL); // charge 
   		if (!image)
   		{
            printf("erreur de chargement de l'image");// si erreur quitte 
      		exit(EXIT_FAILURE);
        }
//printf("On change les dimensions manuelles par celles de l'image chargee\n");
dimx=imagep->w;     // on prend les dimensions de l'image chargée
dimy=imagep->h;
blit(imagep,buffer, 0,0,0,0,imagep->w,imagep->h); //on copie l'image dans le buffer
// on met l'image dans le tableau

for(i=0;i<dimy;i++) //on converti l'image en niveau de gris 8 bit et on la met dans le tableau image
{
for(j=0;j<dimx;j++)
{
k=getg16(getpixel(buffer,j,i));
k+=getr16(getpixel(buffer,j,i));
k+=getb16(getpixel(buffer,j,i));
k=k/3;
image[j][i]=k;
//printf("x=%d y=%d col=%d \n",j,i,k);

}
}

break;
}

destroy_bitmap(imagep); // on enleve l'image de la memoire

  
//calcule des gris

for(i=0;i<256;i++) //ini a 0 de la liste
gris[i]=0;

for(i=0;i<dimy;i++) // compte les gris par niveau
for(j=0;j<dimx;j++)
gris[image[j][i]]++;

k=4; // valeur de reduction de la taille du graph
for(i=0;i<256;i++) //affiche le graph de gris
affbar(buffer,i,475-(gris[i]/k),gris[i]/k,1,240,255-i,1);

//binarisation min entre 2 max

// calcule des valeurs clefs  
//printf("Calcule des max a droite et gauche\n");
//printf("g=%d,d=%d\n",maxval(gris,0,128),maxval(gris,128,255));
affbar(buffer,maxval(gris,0,128),460,20,2,5,5,140); //calcule min a gauche
affbar(buffer,maxval(gris,128,255),460,20,2,5,5,140);//calcule min a droite
affbar(buffer,minval(gris,maxval(gris,0,128),maxval(gris,128,255)),460,20,2,5,240,5); //calcule min entre 2 max

//binarisation
k= minval(gris,maxval(gris,0,128),maxval(gris,128,255)); 
for(i=0;i<dimy;i++)
for(j=0;j<dimx;j++)
if(image[j][i]<k) imaged[j][i]=0; else imaged[j][i]=255;

//affiche l'image
for(i=0;i<dimy;i++)
for(j=0;j<dimx;j++)
affpoint(buffer,j+dimx,i,imaged[j][i]);

//binarisation medianne 2 max

// calcule des valeurs clefs  
//printf("Calcule des max a droite et gauche\n");
//printf("g=%d,d=%d\n",maxval(gris,0,128),maxval(gris,128,255));
//affbar(buffer,maxval(gris,0,128),460,20,2,5,5,140);
//affbar(buffer,maxval(gris,128,255),460,20,2,5,5,140);
affbar(buffer,medianval(gris,maxval(gris,0,128),maxval(gris,128,255)),460,20,2,5,140,5); // mediane entre 2 max

//binarisation
k= medianval(gris,maxval(gris,0,128),maxval(gris,128,255));
for(i=0;i<dimy;i++)
for(j=0;j<dimx;j++)
if(image[j][i]<k) imaged[j][i]=0; else imaged[j][i]=255;

//affiche l'image
for(i=0;i<dimy;i++)
for(j=0;j<dimx;j++)
affpoint(buffer,j+dimx,i+dimy,imaged[j][i]);
rewind(stdin);

blit(buffer, screen, 0, 0, 0, 0, 640, 480) ; // copie le buffer a l'ecran 
readkey();
 // system("PAUSE");	
 return 0;  
}END_OF_MAIN();

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
7
Date d'inscription
lundi 10 mars 2008
Statut
Membre
Dernière intervention
14 mai 2008

une binarisation c'est donnée (transformer) l'image en deux classes (noir) pour l'objet par exemple et bland pour le fond
Messages postés
10
Date d'inscription
lundi 16 décembre 2002
Statut
Membre
Dernière intervention
24 janvier 2005

Ben, tu la converti en noir et blanc ...
Le programme determine les 2 maximum sur l'histrogram entre 0-128 et 128-256.
Ensuite il prend pour valeur seuil la plus petite valeur de l'histogram entre ces 2 maximum, ou il fait la moyenne ou medianne ( je me rappel plus de ce que j'ai fait dans le prog )
et l'utilise pour seuil pour convertir l'image en noir et blanc ...

Desole j'ai pas ete tres clair ... la fatigue surement :/

( euh accessoirement si qqn a l'intention de pomper cette source pour le td d'info 13 de L'E.. enfin voila, ils se reconnaitront, merci de le faire vous mêmes et de pas pomper ^^ )
Messages postés
921
Date d'inscription
vendredi 20 décembre 2002
Statut
Membre
Dernière intervention
23 septembre 2010

Mais c'est quoi la binarisation d'une image ???
Arg !
Messages postés
2
Date d'inscription
lundi 3 janvier 2005
Statut
Membre
Dernière intervention
22 janvier 2005

est ce possible de le faire pour JPEG sous borland???
Messages postés
134
Date d'inscription
mardi 22 avril 2003
Statut
Membre
Dernière intervention
23 décembre 2009

oups... j'me me comprends même dans ma phrase ...
Afficher les 7 commentaires

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.