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 "defines.h"
  16 #include "lib_images.h"
  17 #include "lib_math.h"
  18
  19
  20 /**
  21  * \fn int type_image_ppm(int *prof, int *i_dim, int *j_dim, int *level, char *file_name)
  22  * \brief Fonction qui renvoie le type de l'image ppm et des caracteristiques
  23  *
  24  * \param[out] prof profondeur de l'image 1 pour pgm 3 pour ppm, 0 sinon
  25  * \param[out] i_dim renvoie la dimension verticale de l'image (si NULL, renvoie que prof)
  26  * \param[out] j_dim renvoie la dimension horizontale de l'image
  27  * \param[out] level renvoie la dynamique de l'image
  28  * \param[in]  file_name fichier image
  29  *
  30  * \return 1 si ok O sinon
  31  *
  32  */
  33 int type_image_ppm(int *prof, int *i_dim, int *j_dim, int *level, char *file_name)
  34 {
  35   char buffer[SIZE_LINE_TEXT] ;
  36   FILE *file ;
  37
  38   *prof = 0 ;
  39
  40   file = fopen(file_name, "rb");
  41   if (file == NULL)
  42       return 0 ;
  43
  44   // lecture de la premiere ligne
  45   fgets(buffer, SIZE_LINE_TEXT, file);
  46
  47   /* pgm */
  48   if ((buffer[0] == 'P') & (buffer[1] == '5'))
  49     *prof = 1 ; // GGG
  50   /* ppm */
  51   if ((buffer[0] == 'P') & (buffer[1] == '6'))
  52     *prof = 3 ; // RVBRVBRVB
  53
  54   /* type non gere */
  55   if (*prof == 0) return 0 ;
  56
  57   /* pour une utilisation du type */
  58   /* ret = type_image_ppm(&prof, NULL, NULL, NULL, file_name) */
  59   if (i_dim == NULL)
  60     return 1 ;
  61
  62   /* on saute les lignes de commentaires */
  63   fgets(buffer, SIZE_LINE_TEXT, file);
  64   while ((buffer[0] == '#')|(buffer[0] == '\n'))
  65     fgets(buffer, SIZE_LINE_TEXT, file);
  66
  67   /* on lit les dimensions de l'image */
  68   sscanf(buffer, "%d %d", j_dim, i_dim) ;
  69   fgets(buffer, SIZE_LINE_TEXT, file);
  70   sscanf(buffer, "%d", level) ;
  71
  72
  73   fclose(file);
  74   return 1 ;
  75 }
  76
  77
  78
  79
  80 /**
  81  * \fn void load_pgm2int(int **image, int i_dim, int j_dim,
  82  *                       int nb_level, char *fichier_image)
  83  * \brief lecture pgm 8 ou 16 bits
  84  *
  85  * \param[out] image
  86  * \param[in]  i_dim dimension verticale de l'image
  87  * \param[in]  j_dim dimension horizontale de l'image
  88  * \param[in]  nb_level dynamique de l'image
  89  * \param[in]  fichier_image fichier image
  90  *
  91  *
  92  */
  93 void load_pgm2int(int **image, int i_dim, int j_dim,
  94                   int nb_level, char *fichier_image)
  95 {
  96   int i, j ;
  97   char buffer[SIZE_LINE_TEXT] ;
  98   unsigned char *ligne;
  99   unsigned short *ligne2;
 100   FILE *file = fopen(fichier_image, "rb");
 101
 102   fgets(buffer, SIZE_LINE_TEXT, file); /* P5 */
 103   /* on saute les lignes de commentaires */
 104   fgets(buffer, SIZE_LINE_TEXT, file);
 105   while ((buffer[0] == '#')|(buffer[0] == '\n'))
 106     fgets(buffer, SIZE_LINE_TEXT, file);
 107   /* derniere ligne lue : dimensions */
 108   fgets(buffer, SIZE_LINE_TEXT, file); /* dynamique */
 109
 110   /* data */
 111
 112   if (nb_level < 256)
 113     {
 114       // fichier en char, on converti au format int
 115       ligne = (unsigned char*)malloc(sizeof(unsigned char)*j_dim) ;
 116
 117       for (i=0;i<i_dim;i++)
 118         {
 119           fread(ligne, 1, j_dim, file);
 120           for (j=0;j<j_dim;j++)
 121             image[i][j] = (int)(ligne[j]) ;
 122         }
 123       free(ligne) ;
 124     }
 125   else
 126     {
 127       // fichier en short, on converti au format int
 128       ligne2 = (unsigned short*)malloc(sizeof(unsigned short)*j_dim) ;
 129
 130       for (i=0;i<i_dim;i++)
 131         {
 132           fread(ligne2, 2, j_dim, file);
 133           for (j=0;j<j_dim;j++)
 134             image[i][j] = (int)(ligne2[j]) ;
 135         }
 136       free(ligne2);
 137     }
 138   fclose(file);
 139 }
 140
 141
 142 void load_pgm2ushort(unsigned short **image, int i_dim, int j_dim,
 143                                          int nb_level, char *fichier_image)
 144 {
 145   int i, j ;
 146   char buffer[SIZE_LINE_TEXT] ;
 147   unsigned char *ligne;
 148   unsigned short *ligne2;
 149   FILE *file = fopen(fichier_image, "rb");
 150
 151   fgets(buffer, SIZE_LINE_TEXT, file); /* P5 */
 152   /* on saute les lignes de commentaires */
 153   fgets(buffer, SIZE_LINE_TEXT, file);
 154   while ((buffer[0] == '#')|(buffer[0] == '\n'))
 155     fgets(buffer, SIZE_LINE_TEXT, file);
 156   /* derniere ligne lue : dimensions */
 157   fgets(buffer, SIZE_LINE_TEXT, file); /* dynamique */
 158
 159   /* data */
 160
 161   if (nb_level < 256)
 162     {
 163       // fichier en char, on converti au format ushort
 164       ligne = (unsigned char*)malloc(sizeof(unsigned char)*j_dim) ;
 165
 166       for (i=0;i<i_dim;i++)
 167         {
 168           fread(ligne, 1, j_dim, file);
 169           for (j=0;j<j_dim;j++)
 170             image[i][j] = (unsigned short)(ligne[j]) ;
 171         }
 172       free(ligne) ;
 173     }
 174   else
 175     {
 176       // fichier en short,
 177       ligne2 = (unsigned short*)malloc(sizeof(unsigned short)*j_dim) ;
 178
 179       for (i=0;i<i_dim;i++)
 180         {
 181           fread(ligne2, 2, j_dim, file);
 182           for (j=0;j<j_dim;j++)
 183             image[i][j] = (unsigned short)(ligne2[j]) ;
 184         }
 185       free(ligne2);
 186     }
 187   fclose(file);
 188 }
 189
 190
 191
 192 /**
 193  * \fn void write_int2pgm(int **image, int i_dim, int j_dim, char *fichier_image, int recal)
 194  * \brief copie au format pgm 8 bits
 195  *
 196  * \param[in]  image
 197  * \param[in]  i_dim dimension verticale de l'image
 198  * \param[in]  j_dim dimension horizontale de l'image
 199  * \param[in]  fichier_image fichier image
 200  * \param[in]  recal recalage de l'image en 0-255
 201  *
 202  */
 203 void write_int2pgm(int **image, int i_dim, int j_dim, char *fichier_image, int recal)
 204 {
 205   int i, j ;
 206   int val_min, val_max ;
 207   double coef ;
 208   unsigned char *ligne;
 209   FILE *file=fopen(fichier_image,"wb");
 210
 211   // entete pgm
 212   // format
 213   fprintf(file, "P5\n") ;
 214   fprintf(file, "# Physics and Images Processing Group\n") ;
 215   fprintf(file, "# Fresnel Institut - Marseille - France\n") ;
 216   // taille
 217   fprintf(file, "%d %d\n", j_dim, i_dim) ;
 218   // dynamique
 219   fprintf(file, "%d\n" , 255 );
 220
 221   min_max_int1d(&val_min, &val_max, image[0], i_dim*j_dim) ;
 222   coef = 255.0 / (val_max - val_min) ;
 223
 224   // on converti l'image en entier 8 bits (char)
 225   ligne = (unsigned char*)malloc(sizeof(unsigned char)*j_dim );
 226   for (i=0;i<i_dim;i++)
 227     {
 228       if (recal == 1)
 229         for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)(coef * (image[i][j]-val_min)) ;
 230       else
 231         for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)image[i][j] ;
 232       fwrite(ligne, 1, j_dim, file);
 233     }
 234
 235   fclose(file);
 236   free(ligne) ;
 237 }
 238
 239 void write_ushort2pgm(unsigned short **image, int i_dim, int j_dim, char *fichier_image, int recal)
 240 {
 241   int i, j ;
 242   int val_min, val_max ;
 243   double coef ;
 244   unsigned char *ligne;
 245   FILE *file=fopen(fichier_image,"wb");
 246
 247   // entete pgm
 248   // format
 249   fprintf(file, "P5\n") ;
 250   fprintf(file, "# Physics and Images Processing Group\n") ;
 251   fprintf(file, "# Fresnel Institute - Marseille - France\n") ;
 252   // taille
 253   fprintf(file, "%d %d\n", j_dim, i_dim) ;
 254   // dynamique
 255   fprintf(file, "%d\n" , 255 );
 256
 257   min_max_ushort1d(&val_min, &val_max, image[0], i_dim*j_dim) ;
 258   coef = 255.0 / (val_max - val_min) ;
 259
 260   // on converti l'image en entier 8 bits (char)
 261   ligne = (unsigned char*)malloc(sizeof(unsigned char)*j_dim );
 262   for (i=0;i<i_dim;i++)
 263     {
 264       if (recal == 1)
 265         for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)(coef * (image[i][j]-val_min)) ;
 266       else
 267         for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)image[i][j] ;
 268       fwrite(ligne, 1, j_dim, file);
 269     }
 270
 271   fclose(file);
 272   free(ligne) ;
 273 }
 274
 275
 276 /**
 277  * \fn void imagesc(int **image, int i_dim, int j_dim)
 278  * \brief affiche une image via xti
 279  *
 280  * \param[in]  image
 281  * \param[in]  i_dim dimension verticale de l'image
 282  * \param[in]  j_dim dimension horizontale de l'image
 283  *
 284  */
 285 void imagesc(int **image, int i_dim, int j_dim)
 286 {
 287   char nom[SIZE_NAME_FILE] ;
 288   //char cmd[SIZE_LINE_TEXT] ;
 289
 290   sprintf(nom, "imagesc_%d.pgm", getuid());
 291   write_int2pgm(image, i_dim, j_dim, nom, 1) ;
 292
 293   // affichage avec xti
 294   //sprintf(cmd, "xti %s &", nom) ;
 295   //system(cmd) ;
 296 }
 297
 298 void imagesc_ushort(unsigned short **image, int i_dim, int j_dim)
 299 {
 300   char nom[SIZE_NAME_FILE] ;
 301   //char cmd[SIZE_LINE_TEXT] ;
 302
 303   sprintf(nom, "imagesc_%d.pgm", getuid());
 304   write_ushort2pgm(image, i_dim, j_dim, nom, 1) ;
 305
 306 }