/**
 * \file lib_images.c
 * \brief Librairie de lecture/ecriture d'image ppm/pgm 8/16 bits
 * \author NB - PhyTI 
 * \version x.x
 * \date 20 decembre 2009
 *
 */

#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <unistd.h>

#include "lib_images.h"
#include "lib_math.h"


/**
 * \fn int type_image_ppm(int *prof, int *i_dim, int *j_dim, int *level, char *file_name)
 * \brief Fonction qui renvoie le type de l'image ppm et des caracteristiques
 *
 * \param[out] prof profondeur de l'image 1 pour pgm 3 pour ppm, 0 sinon
 * \param[out] i_dim renvoie la dimension verticale de l'image (si NULL, renvoie que prof)
 * \param[out] j_dim renvoie la dimension horizontale de l'image
 * \param[out] level renvoie la dynamique de l'image
 * \param[in]  file_name fichier image
 *
 * \return 1 si ok O sinon
 *
 */
int type_image_ppm(int *prof, uint32 *i_dim, uint32 *j_dim, int *level, char *file_name)
{
  char buffer[SIZE_LINE_TEXT] ;
  FILE *file ;

  *prof = 0 ;
 
  file = fopen(file_name, "rb");
  if (file == NULL) 
      return 0 ;
 
  // lecture de la premiere ligne
  fgets(buffer, SIZE_LINE_TEXT, file);
 
  /* pgm */
  if ((buffer[0] == 'P') & (buffer[1] == '5'))
    *prof = 1 ; // GGG
  /* ppm */
  if ((buffer[0] == 'P') & (buffer[1] == '6'))
    *prof = 3 ; // RVBRVBRVB

  /* type non gere */
  if (*prof == 0) return 0 ;

  /* pour une utilisation du type */
  /* ret = type_image_ppm(&prof, NULL, NULL, NULL, file_name) */
  if (i_dim == NULL)  
    return 1 ;

  /* on saute les lignes de commentaires */
  fgets(buffer, SIZE_LINE_TEXT, file);
  while ((buffer[0] == '#')|(buffer[0] == '\n')) 
    fgets(buffer, SIZE_LINE_TEXT, file);
  
  /* on lit les dimensions de l'image */
  sscanf(buffer, "%d %d", j_dim, i_dim) ;
  fgets(buffer, SIZE_LINE_TEXT, file);
  sscanf(buffer, "%d", level) ;
  

  fclose(file);
  return 1 ;
}




/**
 * \fn void load_pgm2int(int **image, int i_dim, int j_dim, 
 *		         int nb_level, char *fichier_image)
 * \brief lecture pgm 8 ou 16 bits
 *
 * \param[out] image 
 * \param[in]  i_dim dimension verticale de l'image
 * \param[in]  j_dim dimension horizontale de l'image
 * \param[in]  nb_level dynamique de l'image
 * \param[in]  fichier_image fichier image
 *
 *
 */
void load_pgm2int(int **image, int i_dim, int j_dim, 
		  int nb_level, char *fichier_image)
{
  int i, j ;
  char buffer[SIZE_LINE_TEXT] ;
  unsigned char *ligne;
  unsigned short *ligne2;
  FILE *file = fopen(fichier_image, "rb");
  
  fgets(buffer, SIZE_LINE_TEXT, file); /* P5 */
  /* on saute les lignes de commentaires */
  fgets(buffer, SIZE_LINE_TEXT, file);
  while ((buffer[0] == '#')|(buffer[0] == '\n')) 
    fgets(buffer, SIZE_LINE_TEXT, file);
  /* derniere ligne lue : dimensions */
  fgets(buffer, SIZE_LINE_TEXT, file); /* dynamique */

  /* data */

  if (nb_level < 256)
    {
      // fichier en char, on converti au format int
      ligne = malloc(sizeof(unsigned char)*j_dim) ;
      
      for (i=0;i<i_dim;i++)
	{
	  fread(ligne, 1, j_dim, file);
	  for (j=0;j<j_dim;j++)    
	    image[i][j] = (int)(ligne[j]) ; 
	}
      free(ligne) ;
    }
  else
    {
      // fichier en short, on converti au format int
      ligne2 = malloc(sizeof(unsigned short)*j_dim) ;
      
      for (i=0;i<i_dim;i++)
	{
	  fread(ligne2, 2, j_dim, file);
	  for (j=0;j<j_dim;j++)    
	    image[i][j] = (int)(ligne2[j]) ; 
	}
      free(ligne2);
    }  
  fclose(file);
}



/**
 * \fn void write_int2pgm(int **image, int i_dim, int j_dim, char *fichier_image, int recal)
 * \brief copie au format pgm 8 bits
 *
 * \param[in]  image 
 * \param[in]  i_dim dimension verticale de l'image
 * \param[in]  j_dim dimension horizontale de l'image
 * \param[in]  fichier_image fichier image
 * \param[in]  recal recalage de l'image en 0-255
 *
 */
void write_int2pgm(int **image, int i_dim, int j_dim, char *fichier_image, int recal)
{
  int i, j ;
  int val_min, val_max ; 
  double coef ;
  unsigned char *ligne;
  FILE *file=fopen(fichier_image,"wb");

  // entete pgm
  // format
  fprintf(file, "P5\n") ;
  fprintf(file, "# Physics and Images Processing Group\n") ;
  fprintf(file, "# Fresnel Institut - Marseille - France\n") ;
  // taille
  fprintf(file, "%d %d\n", j_dim, i_dim) ;
  // dynamique
  fprintf(file, "%d\n" , 255 );
  
  min_max_int1d(&val_min, &val_max, image[0], i_dim*j_dim) ;
  coef = 255.0 / (val_max - val_min) ;
  
  // on converti l'image en entier 8 bits (char)
  ligne = malloc(sizeof(unsigned char)*j_dim );
  for (i=0;i<i_dim;i++) 
    {
      if (recal == 1)
	for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)(coef * (image[i][j]-val_min)) ;
      else
	for (j=0;j<j_dim;j++) ligne[j] = (unsigned char)image[i][j] ;
      fwrite(ligne, 1, j_dim, file);
    }

  fclose(file);
  free(ligne) ;
}



/**
 * \fn void imagesc(int **image, int i_dim, int j_dim)
 * \brief affiche une image via xti
 *
 * \param[in]  image 
 * \param[in]  i_dim dimension verticale de l'image
 * \param[in]  j_dim dimension horizontale de l'image
 *
 */
void imagesc(int **image, int i_dim, int j_dim)
{
  char nom[SIZE_NAME_FILE] ;
  //char cmd[SIZE_LINE_TEXT] ;

  sprintf(nom, "imagesc_%d_%d.pgm", getuid(), rand()%20);
  write_int2pgm(image, i_dim, j_dim, nom, 1) ;

  // affichage avec xti
  //sprintf(cmd, "xti %s &", nom) ;
  //system(cmd) ;
}