src/lib_images.c~

   1 /**
   2  * \file lib_images.c
   3  * \brief Librairie de lecture/ecriture d'image ppm/pgm 8/16 bits
   4  * \author NB - PhyTI
   5  * \version x.x
   6  * \date 20 decembre 2009
   7  *
   8  */
   9
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <malloc.h>
  13 #include <unistd.h>
  14
  15 #include "lib_images.h"
  16 #include "lib_math.h"
  17
  18
  19 /**
  20  * \fn int type_image_ppm(int *prof, int *i_dim, int *j_dim, int *level, char *file_name)
  21  * \brief Fonction qui renvoie le type de l'image ppm et des caracteristiques
  22  *
  23  * \param[out] prof profondeur de l'image 1 pour pgm 3 pour ppm, 0 sinon
  24  * \param[out] i_dim renvoie la dimension verticale de l'image (si NULL, renvoie que prof)
  25  * \param[out] j_dim renvoie la dimension horizontale de l'image
  26  * \param[out] level renvoie la dynamique de l'image
  27  * \param[in]  file_name fichier image
  28  *
  29  * \return 1 si ok O sinon
  30  *
  31  */
  32 int type_image_ppm(int *prof, uint32 *i_dim, uint32 *j_dim, int *level, char *file_name)
  33 {
  34   char buffer[SIZE_LINE_TEXT] ;
  35   FILE *file ;
  36
  37   *prof = 0 ;
  38
  39   file = fopen(file_name, "rb");
  40   if (file == NULL)
  41       return 0 ;
  42
  43   // lecture de la premiere ligne
  44   fgets(buffer, SIZE_LINE_TEXT, file);
  45
  46   /* pgm */
  47   if ((buffer[0] == 'P') & (buffer[1] == '5'))
  48     *prof = 1 ; // GGG
  49   /* ppm */
  50   if ((buffer[0] == 'P') & (buffer[1] == '6'))
  51     *prof = 3 ; // RVBRVBRVB
  52
  53   /* type non gere */
  54   if (*prof == 0) return 0 ;
  55
  56   /* pour une utilisation du type */
  57   /* ret = type_image_ppm(&prof, NULL, NULL, NULL, file_name) */
  58   if (i_dim == NULL)
  59     return 1 ;
  60
  61   /* on saute les lignes de commentaires */
  62   fgets(buffer, SIZE_LINE_TEXT, file);
  63   while ((buffer[0] == '#')|(buffer[0] == '\n'))
  64     fgets(buffer, SIZE_LINE_TEXT, file);
  65
  66   /* on lit les dimensions de l'image */
  67   sscanf(buffer, "%d %d", j_dim, i_dim) ;
  68   fgets(buffer, SIZE_LINE_TEXT, file);
  69   sscanf(buffer, "%d", level) ;
  70
  71
  72   fclose(file);
  73   return 1 ;
  74 }
  75
  76
  77
  78
  79 /**
  80  * \fn void load_pgm2int(int **image, int i_dim, int j_dim,
  81  *                       int nb_level, char *fichier_image)
  82  * \brief lecture pgm 8 ou 16 bits
  83  *
  84  * \param[out] image
  85  * \param[in]  i_dim dimension verticale de l'image
  86  * \param[in]  j_dim dimension horizontale de l'image
  87  * \param[in]  nb_level dynamique de l'image
  88  * \param[in]  fichier_image fichier image
  89  *
  90  *
  91  */
  92 void load_pgm2int(int **image, int i_dim, int j_dim,
  93                   int nb_level, char *fichier_image)
  94 {
  95   int i, j ;
  96   char buffer[SIZE_LINE_TEXT] ;
  97   unsigned char *ligne;
  98   unsigned short *ligne2;
  99   FILE *file = fopen(fichier_image, "rb");
 100
 101   fgets(buffer, SIZE_LINE_TEXT, file); /* P5 */
 102   /* on saute les lignes de commentaires */
 103   fgets(buffer, SIZE_LINE_TEXT, file);
 104   while ((buffer[0] == '#')|(buffer[0] == '\n'))
 105     fgets(buffer, SIZE_LINE_TEXT, file);
 106   /* derniere ligne lue : dimensions */
 107   fgets(buffer, SIZE_LINE_TEXT, file); /* dynamique */
 108
 109   /* data */
 110
 111   if (nb_level < 256)
 112     {
 113       // fichier en char, on converti au format int
 114       ligne = malloc(sizeof(unsigned char)*j_dim) ;
 115
 116       for (i=0;i<i_dim;i++)
 117         {
 118           fread(ligne, 1, j_dim, file);
 119           for (j=0;j<j_dim;j++)
 120             image[i][j] = (int)(ligne[j]) ;
 121         }
 122       free(ligne) ;
 123     }
 124   else
 125     {
 126       // fichier en short, on converti au format int
 127       ligne2 = malloc(sizeof(unsigned short)*j_dim) ;
 128
 129       for (i=0;i<i_dim;i++)
 130         {
 131           fread(ligne2, 2, j_dim, file);
 132           for (j=0;j<j_dim;j++)
 133             image[i][j] = (int)(ligne2[j]) ;
 134         }
 135       free(ligne2);
 136     }
 137   fclose(file);
 138 }
 139
 140
 141
 142 /**
 143  * \fn void write_int2pgm(int **image, int i_dim, int j_dim, char *fichier_image, int recal)
 144  * \brief copie au format pgm 8 bits
 145  *
 146  * \param[in]  image
 147  * \param[in]  i_dim dimension verticale de l'image
 148  * \param[in]  j_dim dimension horizontale de l'image
 149  * \param[in]  fichier_image fichier image
 150  * \param[in]  recal recalage de l'image en 0-255
 151  *
 152  */
 153 void write_int2pgm(int **image, int i_dim, int j_dim, char *fichier_image, int recal)
 154 {
 155   int i, j ;
 156   int val_min, val_max ;
 157   double coef ;
 158   unsigned char *ligne;
 159   FILE *file=fopen(fichier_image,"wb");
 160
 161   // entete pgm
 162   // format
 163   fprintf(file, "P5\n") ;
 164   fprintf(file, "# Physics and Images Processing Group\n") ;
 165   fprintf(file, "# Fresnel Institut - Marseille - France\n") ;
 166   // taille
 167   fprintf(file, "%d %d\n", j_dim, i_dim) ;
 168   // dynamique
 169   fprintf(file, "%d\n" , 255 );
 170
 171   min_max_int1d(&val_min, &val_max, image[0], i_dim*j_dim) ;
 172   coef = 255.0 / (val_max - val_min) ;
 173
 174   // on converti l'image en entier 8 bits (char)
 175   ligne = malloc(sizeof(unsigned char)*j_dim );
 176   for (i=0;i<i_dim;i++)
 177     {
 178       if (recal == 1)
 179         for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)(coef * (image[i][j]-val_min)) ;
 180       else
 181         for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)image[i][j] ;
 182       fwrite(ligne, 1, j_dim, file);
 183     }
 184
 185   fclose(file);
 186   free(ligne) ;
 187 }
 188
 189
 190
 191 /**
 192  * \fn void imagesc(int **image, int i_dim, int j_dim)
 193  * \brief affiche une image via xti
 194  *
 195  * \param[in]  image
 196  * \param[in]  i_dim dimension verticale de l'image
 197  * \param[in]  j_dim dimension horizontale de l'image
 198  *
 199  */
 200 void imagesc(int **image, int i_dim, int j_dim)
 201 {
 202   char nom[SIZE_NAME_FILE] ;
 203   //char cmd[SIZE_LINE_TEXT] ;
 204
 205   sprintf(nom, "imagesc_%d_%d.pgm", getuid(), rand()%20);
 206   write_int2pgm(image, i_dim, j_dim, nom, 1) ;
 207
 208   // affichage avec xti
 209   //sprintf(cmd, "xti %s &", nom) ;
 210   //system(cmd) ;
 211 }