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 void load_pgm2ushort(unsigned short **image, int i_dim, int j_dim,
 142                                          int nb_level, char *fichier_image)
 143 {
 144   int i, j ;
 145   char buffer[SIZE_LINE_TEXT] ;
 146   unsigned char *ligne;
 147   unsigned short *ligne2;
 148   FILE *file = fopen(fichier_image, "rb");
 149
 150   fgets(buffer, SIZE_LINE_TEXT, file); /* P5 */
 151   /* on saute les lignes de commentaires */
 152   fgets(buffer, SIZE_LINE_TEXT, file);
 153   while ((buffer[0] == '#')|(buffer[0] == '\n'))
 154     fgets(buffer, SIZE_LINE_TEXT, file);
 155   /* derniere ligne lue : dimensions */
 156   fgets(buffer, SIZE_LINE_TEXT, file); /* dynamique */
 157
 158   /* data */
 159
 160   if (nb_level < 256)
 161     {
 162       // fichier en char, on converti au format ushort
 163       ligne = malloc(sizeof(unsigned char)*j_dim) ;
 164
 165       for (i=0;i<i_dim;i++)
 166         {
 167           fread(ligne, 1, j_dim, file);
 168           for (j=0;j<j_dim;j++)
 169             image[i][j] = (unsigned short)(ligne[j]) ;
 170         }
 171       free(ligne) ;
 172     }
 173   else
 174     {
 175       // fichier en short,
 176       ligne2 = malloc(sizeof(unsigned short)*j_dim) ;
 177
 178       for (i=0;i<i_dim;i++)
 179         {
 180           fread(ligne2, 2, j_dim, file);
 181           for (j=0;j<j_dim;j++)
 182             image[i][j] = (unsigned short)(ligne2[j]) ;
 183         }
 184       free(ligne2);
 185     }
 186   fclose(file);
 187 }
 188
 189
 190
 191 /**
 192  * \fn void write_int2pgm(int **image, int i_dim, int j_dim, char *fichier_image, int recal)
 193  * \brief copie au format pgm 8 bits
 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  * \param[in]  fichier_image fichier image
 199  * \param[in]  recal recalage de l'image en 0-255
 200  *
 201  */
 202 void write_int2pgm(int **image, int i_dim, int j_dim, char *fichier_image, int recal)
 203 {
 204   int i, j ;
 205   int val_min, val_max ;
 206   double coef ;
 207   unsigned char *ligne;
 208   FILE *file=fopen(fichier_image,"wb");
 209
 210   // entete pgm
 211   // format
 212   fprintf(file, "P5\n") ;
 213   fprintf(file, "# Physics and Images Processing Group\n") ;
 214   fprintf(file, "# Fresnel Institut - Marseille - France\n") ;
 215   // taille
 216   fprintf(file, "%d %d\n", j_dim, i_dim) ;
 217   // dynamique
 218   fprintf(file, "%d\n" , 255 );
 219
 220   min_max_int1d(&val_min, &val_max, image[0], i_dim*j_dim) ;
 221   coef = 255.0 / (val_max - val_min) ;
 222
 223   // on converti l'image en entier 8 bits (char)
 224   ligne = malloc(sizeof(unsigned char)*j_dim );
 225   for (i=0;i<i_dim;i++)
 226     {
 227       if (recal == 1)
 228         for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)(coef * (image[i][j]-val_min)) ;
 229       else
 230         for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)image[i][j] ;
 231       fwrite(ligne, 1, j_dim, file);
 232     }
 233
 234   fclose(file);
 235   free(ligne) ;
 236 }
 237
 238 void write_ushort2pgm(unsigned short **image, int i_dim, int j_dim, char *fichier_image, int recal)
 239 {
 240   int i, j ;
 241   int val_min, val_max ;
 242   double coef ;
 243   unsigned char *ligne;
 244   FILE *file=fopen(fichier_image,"wb");
 245
 246   // entete pgm
 247   // format
 248   fprintf(file, "P5\n") ;
 249   fprintf(file, "# Physics and Images Processing Group\n") ;
 250   fprintf(file, "# Fresnel Institute - Marseille - France\n") ;
 251   // taille
 252   fprintf(file, "%d %d\n", j_dim, i_dim) ;
 253   // dynamique
 254   fprintf(file, "%d\n" , 255 );
 255
 256   min_max_ushort1d(&val_min, &val_max, image[0], i_dim*j_dim) ;
 257   coef = 255.0 / (val_max - val_min) ;
 258
 259   // on converti l'image en entier 8 bits (char)
 260   ligne = malloc(sizeof(unsigned char)*j_dim );
 261   for (i=0;i<i_dim;i++)
 262     {
 263       if (recal == 1)
 264         for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)(coef * (image[i][j]-val_min)) ;
 265       else
 266         for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)image[i][j] ;
 267       fwrite(ligne, 1, j_dim, file);
 268     }
 269
 270   fclose(file);
 271   free(ligne) ;
 272 }
 273
 274
 275 /**
 276  * \fn void imagesc(int **image, int i_dim, int j_dim)
 277  * \brief affiche une image via xti
 278  *
 279  * \param[in]  image
 280  * \param[in]  i_dim dimension verticale de l'image
 281  * \param[in]  j_dim dimension horizontale de l'image
 282  *
 283  */
 284 void imagesc(int **image, int i_dim, int j_dim)
 285 {
 286   char nom[SIZE_NAME_FILE] ;
 287   //char cmd[SIZE_LINE_TEXT] ;
 288
 289   sprintf(nom, "imagesc_%d.pgm", getuid());
 290   write_int2pgm(image, i_dim, j_dim, nom, 1) ;
 291
 292   // affichage avec xti
 293   //sprintf(cmd, "xti %s &", nom) ;
 294   //system(cmd) ;
 295 }
 296
 297 void imagesc_ushort(unsigned short **image, int i_dim, int j_dim)
 298 {
 299   char nom[SIZE_NAME_FILE] ;
 300   //char cmd[SIZE_LINE_TEXT] ;
 301
 302   sprintf(nom, "imagesc_%d.pgm", getuid());
 303   write_ushort2pgm(image, i_dim, j_dim, nom, 1) ;
 304
 305 }