BINARISATION

#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();