CONVERTIR UNE IMAGE 16 MILLIONS DE COULEURS EN NIVEAUX DE GRIS [BORLAND C++]

/*********************************************************************
									nom: conv_nb
                           programmé par Draven
                           le 18/06/2003
**********************************************************************/

#include <stdio.h>      /* printf(), scanf, fopen() ... */
#include <stdlib.h>		/* exit() */
#include <windows.h>		/*BITMAPFILEHEADER et BITMAPINFOHEADER */

/* structure comprenant les 2 en-têtes du fichier bitmap (54 octets) */
typedef struct
{
     BITMAPFILEHEADER file; /*information sur le fichier (ex type,taille du fichier ) */
     BITMAPINFOHEADER info; /*information sur la données de l'image (ex nbrcouleur utilise, longueur,largeur, taille de l'image) */
}HEADER;

typedef struct
{
	BYTE bleu;
   BYTE vert;
   BYTE rouge;
}PIXEL;

HEADER en_tete(FILE*,HEADER,char *);
void changer(FILE*,HEADER);
void traitement(FILE *,FILE *, HEADER);

void main()
{
   char nom_fichier[50];
	FILE *source;
   FILE *destination;
   HEADER header;

   printf("Entrez le nom du fichier: ");
   scanf("%s",nom_fichier);
   if((source=fopen(nom_fichier,"rb"))==NULL)
   {
   	printf("erreur à l'ouverture du fichier\n");
     	exit(-1);
  	}
   /* créer un fichier temporaire pour recopier une partie du fichier source*/
   if((destination=fopen("tempo.bmp","wb"))==NULL)
   {
   	printf("erreur à l'ouverture du fichier\n");
      exit(-1);
   }
   header=en_tete(source,header,nom_fichier);
   changer(destination,header);
 	traitement(source,destination, header);
   printf("FIN");
   fclose(source);
   fclose(destination);

   remove(nom_fichier);  /* supprimer le fichier source */
   rename("tempo.bmp",nom_fichier); /*renommer le fichier temporaire avec le nom du fichier source */
}
/*********************************************************************
								nom:  en_tete
                        role: lire l'en-tete du fichier bitmap passé en parametre
**********************************************************************/
HEADER en_tete(FILE* fd,HEADER header,char *nom_fichier)
{
	fread(&header,sizeof(HEADER),1,fd); /* lire les 54 premiers octets qui constitue l'en-tete */
   /* tester si les 2 premiers octets sont B et M */
   if(header.file.bfType!=0x4D42)
   {
   	printf("%s n'est pas un fichier bitmap\n",nom_fichier);
      fclose(fd);
      exit(-1);
   }
   /* on teste si l'image est en 16 millions de couleurs */
   if(header.info.biBitCount!=24 || header.info.biBitCount!=0)
   {
   	printf("Le fichier %s n'est pas en 16 millions de couleurs\n",nom_fichier);
      fclose(fd);
      exit(-1);
   }
   return header;
}

/******************************************************************
							nom:  changer
                     role: transforme l'en-tete pour un fichier image de 256 couleurs
                       		et créer la palette de niveaux de gris.
                           L'en-tête modifié et la palette seront envoyé dans un nouveau fichier vide.
*******************************************************************/
void changer(FILE* destination,HEADER header)
{
   int i;
   RGBQUAD palette;    /* description d'un pixel. composé d'une valeur bleu, vert, rouge, et de bourrage */
   /*modification de l'en-tête*/
   header.info.biBitCount=8; /* utilisation de 256 couleurs */
   header.info.biClrUsed=256; /* nbr de couleurs utilisé (256)*/
	header.info.biClrImportant=256;
	/* copie de l'entete bmp (54 premiers octets) de le fichier "tempo.bmp" */
   fwrite(&header,sizeof(HEADER),1,destination);

   /* création de la palette en niveau de gris*/
   for(i=0;i<256;i++)
   {
      /* la palette se compose d'une composante bleue, verte, rouge, et d'un octet de bourrage*/
   	palette.rgbBlue=i;
      palette.rgbGreen=i;
      palette.rgbRed=i;
      palette.rgbReserved=0x00;
      /* écrire les quatre octets composant la couleur dans le fichier */
      fwrite(&palette,sizeof(RGBQUAD),1,destination);
   }
}

/*********************************************************************
								nom:  traitement
                        role: reconstitue l'image couleurs en niveaux de gris
**********************************************************************/
void traitement(FILE *source ,FILE *destination, HEADER header)
{
	int longueur,longueur32,bourrage;
   int longueur32_nb,bourrage_nb;
   int cpt,i;
   int nouveau_pixel;
   int tempo;
   PIXEL pixel;
   longueur=header.info.biWidth;
   /* la largeur d'une image doit être un multiple de 4 (32 bits)
      si ce n'est pas le cas des bourrage de 0 seront inserer a la fin */

   /* Ici on calcule le nombre de bourrage pour chaque largeur de l'image en 16 millions de couleurs*/
   /* pour le format 16 millions de couleurs*/
   longueur32=longueur*3;
   while((longueur32%4)!=0)
   	longueur32++;
   bourrage=longueur32-(longueur*3);

   /* Ici on calcule le nombre de bourrage pour chaque largeur de l'image en 256 couleurs*/
   /* pour le format 256 couleurs*/
   longueur32_nb=longueur;
   while((longueur32_nb%4)!=0)
   	longueur32_nb++;
   bourrage_nb=longueur32_nb-longueur;

   /* se positionner au debut de la données de l'image pour l'image de 16 millions de couleurs */
   fseek(source,0x36,SEEK_SET);
   /* se positionner en fin de fichier, c'est à dire juste après la palette */
   fseek(destination,0x00,SEEK_END);

   /* faire autant de fois que la hauteur de l'image*/
   for(cpt=0;cpt<header.info.biHeight;cpt++)
   {
      /* faire cette boucle pour chaque pixel de la largeur de l'image */
      for(i=0;i<longueur;i++)
      {
         /* lire trois octets dans le fichier source qui correspondent aux composantes bleue, verte et rouge*/
			fread(&pixel,sizeof(pixel),1,source);
         /* on additionne la valeur des 3 composantes du pixel que l on divise par trois pour obtenir la valeur en niveau de gris */
         nouveau_pixel=(pixel.bleu+pixel.vert+pixel.rouge)/3;
         /* ecrire la nouvelle valeur du pixel dans le fichier source*/
         /* pour une image en 256 couleurs 1 octet suffit pour coder un pixel*/
         fputc(nouveau_pixel,destination);
      }
      /* avancer du nombre de bit de bourrage de l'image en 16 millions de couleurs*/
      fseek(source,bourrage,SEEK_CUR);

      /* ecrire le nombre de bourrage nécessaire dans l'image de 256 couleurs*/
      for(i=0;i<bourrage_nb;i++)
      	fputc(0x00,destination);
   }
}