#define IMAGE_UTIL_SOURCE_C_C
#include "image-util.h"
/* Image8Bit Functions */
void Free_Image_8Bit(IMAGE8BIT *animage)
{
  if (animage->row>0) {
    Free_Array((void **)animage->image, animage->row);
  }
  animage->row = 0;
  animage->image = NULL;
}


int Allocate_Image_8Bit(IMAGE8BIT *animage, int row, int col)
{
  if (animage->row>0) {
    if (animage->row == row && animage->col == col) return;
  }
  if (animage->row>0) {
    Free_Image_8Bit(animage);
  }
  animage->row = row;
  animage->col = col;
  animage->image =(unsigned char **)Allocate_Array(animage->row,
			        animage->col*sizeof(unsigned char));
  if (animage->image == NULL)
    return -1;
  return 0;
}

void Init_Image_8Bit(IMAGE8BIT *animage, unsigned char Const)
{
  if (animage->row>0) {
    int i,j;
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
	animage->image[i][j] = Const;
      }
    }
  }
}

void Copy_Image_8Bit(IMAGE8BIT *animage,IMAGE8BIT *resimage)
{
  if (animage->row>0) {
    int i,j;
    Allocate_Image_8Bit(resimage, animage->row, animage->col);
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
	resimage->image[i][j] = animage->image[i][j];
      }
    }
  }
  return;
}

 
void Change_Image_8Bit(IMAGE8BIT *animage, unsigned char old, 
		       unsigned char new)
{
  if (animage->row>0) {
    int i,j;
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
	if (animage->image[i][j] == old) {
	  animage->image[i][j] = new;
	}
      }
    }
  }
}



void Write_Image_8Bit_ToP5(IMAGE8BIT *animage, char *fName)
{
  WriteP5Char(fName, animage->row, animage->col, animage->image);
}

void Write_Image_8Bit_ToP5_With_Max(IMAGE8BIT *animage, char *fName, 
				    int maxvalue)
{
  WriteP5CharWithMax(fName, animage->row, animage->col, 
		     animage->image,maxvalue);
}

int Read_Image_FromP5(IMAGE8BIT *animage, char *fName) 
{
  
  if (animage->row>0) {
    Free_Image_8Bit(animage);
  }
  animage->image  = ReadP5(fName,&(animage->row), 
	 &(animage->col));
  if (animage->image == NULL) return -1;
  return 0;
}

int Read_Image_FromP5_No_Relocate(IMAGE8BIT *animage, char *fName) 
{
  int row, col;
  return ReadP5IntoArray(fName, animage->row, animage->col,animage->image);
}

/* Image_INT functions */
void Free_Image_INT(IMAGEINT *animage)
{
  if (animage->row>0) {
    Free_Array((void **)animage->image, animage->row);
  }
  animage->row = 0;
  animage->image = NULL;
}

int Allocate_Image_INT(IMAGEINT *animage, int row, int col)
{
  if (animage->row>0) {
    if (animage->row == row && animage->col == col) return;
  }
  if (animage->row>0) {
    Free_Image_INT(animage);
  }
  animage->row = row;
  animage->col = col;
  animage->image =(unsigned int **)
    Allocate_Array(animage->row,
		   animage->col*sizeof(unsigned int));
  if (animage->image == NULL) return -1;
  return 0;
}

void Init_Image_INT(IMAGEINT *animage, unsigned int Const)
{
  if (animage->row>0) {
    int i,j;
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
	animage->image[i][j] = Const;
      }
    }
  }
}

void Change_Image_INT(IMAGEINT *animage, unsigned int old,
		      unsigned int new)
{
  if (animage->row>0) {
    int i,j;
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
	if (animage->image[i][j] == old) {
	  animage->image[i][j] = new;
	}
      }
    }
  }
}

void Convert_INT_To_8BIT(IMAGEINT *animage, IMAGE8BIT *resimg)
{
  if (animage->row>0) {
    int i,j;
    Allocate_Image_8Bit(resimg, animage->row, animage->col);
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
        if (animage->image[i][j] <255) {
          resimg->image[i][j] = animage->image[i][j];
        }
        else {
          resimg->image[i][j] = 0;
        }
      }
    }
  }
  return;
}

void Write_Image_Int(IMAGEINT *animage, char *fName, 
		     int maxvalue)
{
  WriteP2Char(fName, animage->row, animage->col, 
	      animage->image,maxvalue);
}

int Read_Image_Int_FromP2(IMAGEINT *animage, char *fName) 
{
  int row, col;
  if (animage->row>0) {
    Free_Image_INT(animage);
  }
  animage->image = ReadP2(fName,&(animage->row),
			  &(animage->col));
  return;
}

int Read_Image_FromP2_No_Relocate(IMAGEINT *animage, char *fName) 
{
  int row, col;
  return ReadP2IntoArray(fName, animage->row, animage->col,animage->image);
}

/* Float image functions */
void Free_Image_FLOAT(IMAGEFLOAT *animage)
{
  if (animage->row>0) {
    Free_Array((void **)animage->image, animage->row);
  }
  animage->row = 0;
  animage->image = NULL;
}

int Allocate_Image_FLOAT(IMAGEFLOAT *animage, int row, int col)
{
  if (animage->row>0) {
    if (animage->row == row && animage->col == col) return;
  }
  if (animage->row>0) {
    Free_Image_FLOAT(animage);
  }
  animage->row = row;
  animage->col = col;
  animage->image =(float **)
    Allocate_Array(animage->row,
		   animage->col*sizeof(float));
  if (animage->image == NULL) return -1;
  return 0;
}

void Init_Image_FLOAT(IMAGEFLOAT *animage, float Const)
{
  if (animage->row>0) {
    int i,j;
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
	animage->image[i][j] = Const;
      }
    }
  }
}

void Change_Image_FLOAT(IMAGEFLOAT *animage, float old,
			float new)
{
  if (animage->row>0) {
    int i,j;
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
	if ( fabs(animage->image[i][j] - old) < 0.00001) {
	  animage->image[i][j] = new;
	}
      }
    }
  }
}

void Convert_FLOAT_To_8BITBinary(IMAGEFLOAT *animage, 
				 IMAGE8BIT *resimg)
{
  if (animage->row>0) {
    int i,j;
    int pValue;
    
    Allocate_Image_8Bit(resimg, animage->row, animage->col);
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
	if (animage->image[i][j] < -0.000001 ||
	    animage->image[i][j] >1.000001) {
	  printf("Warning: out of range at (%d,%d)\n", j,i);
	}
	if (animage->image[i][j] <= 0.5)
	  pValue = 0;
	else
	  pValue = 255;
	
	resimg->image[i][j] = pValue;
	
      }
    }
  }
  return;
}

void Convert_FLOAT_To_8BIT(IMAGEFLOAT *animage, IMAGE8BIT *resimg)
{
  if (animage->row>0) {
    int i,j;
    int pValue;
    
    Allocate_Image_8Bit(resimg, animage->row, animage->col);
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
	if (animage->image[i][j] < -0.000001 ||
	    animage->image[i][j] >1.000001) {
	  printf("Warning: out of range at (%d,%d)\n", j,i);
	}
	
	pValue = animage->image[i][j]*255;
	
        if (pValue <0) {
	  pValue = 0;
	}
	else {
	  if (pValue > 255)
	    pValue = 255;
	}
	
	resimg->image[i][j] = pValue;
	
      }
    }
  }
  return;
}


void Convert_8BIT_To_FLOAT(IMAGE8BIT *animage, IMAGEFLOAT *resimg)
{
  if (animage->row>0) {
    int i,j;
    float pValue;
    
    Allocate_Image_FLOAT(resimg, animage->row, animage->col);
    for (i=0; i<animage->row; i++) {
      for (j=0; j<animage->col; j++) {
	pValue = ((float)animage->image[i][j])/255.0;
        
	resimg->image[i][j] = pValue;
	
      }
    }
  }
  return;
}


int Read_ALineFromImage(IMAGEINT *animage, int *line, 
			int crow,
			int fcolor)
{
  int i, k;
  int flag;
  
  if (crow > animage->row || crow < 0) {
    printf("Line number %d is out of range <0, %d>.\n",
	   crow, animage->row-1);
    for (i=0; i<4; i++)
      line[i] = i + animage->col + 10;
    return 0;
  }
  if (crow == animage->row) return 0;
  k = 0;
  flag = 0;
  
  for (i=0; i< animage->col; i++) {
    if (animage->image[crow][i] == fcolor) {
      if (flag ==0) {
        flag = 1;
        line[k++] = i;
      }
    }
    else {
      if (flag == 1) {
        line[k++] = i-1;
        flag = 0;
      }
    }
  }
  if (flag) {
    line[k++] = i-1;
  }
  if (k&0x01) {
    printf("Warning: there are odd number of pairs %d\n", k);
  }
  for (i=0; i<4; i++) {
    line[k+i] = i + animage->col +10;
  }
 
  return k;
}


int ReadP5MaxValue(char *fName)
{
  FILE *IN;
  unsigned char **dArray;
  char string[32];
  int i,j; 
  if ( (IN= fopen(fName,"rb"))==NULL) 
   {
      fprintf(stderr,"Cannot open file '%s'\n", fName);
      return 0;
    }
   fscanf(IN,"%s",string);
   if ( strcmp(string,"P5"))
     {
      fprintf(stderr,"The system only works for P5 type PGM file.\n");
      fclose(IN);
      return 0;
     }
   while(1) {
     fscanf(IN,"%s",string);
     if (string[0] == '#') {
       while (  getc(IN) != '\n');
     }
     else {
       break;
     }
   }
   
   sscanf(string,"%d",&j);
   
   fscanf(IN, "%d\n%d\n",&j,&i);
   fclose(IN);
   return i;
 }


unsigned char **ReadP5(char *fName, int *row, int *col)
{
  FILE *IN;
  unsigned char **dArray;
  char string[32];
  int i,j; 
  if ( (IN= fopen(fName,"rb"))==NULL)  {
    fprintf(stderr,"Cannot open file '%s'\n", fName);
    *row = *col = 0;
    return NULL;
  }
  fscanf(IN,"%s",string);
  if ( strcmp(string,"P5")) {
    fprintf(stderr,"The system only works for P5 type PGM file.\n");
    fclose(IN);
    *row = *col = 0;
    return NULL;
  }
  while (1) {
    fscanf(IN,"%s",string); 
    if (string[0] == '#') {
      while (  getc(IN) != '\n');
    }
    else {
      sscanf(string,"%d",col);
      break;
    }
  }
  fscanf(IN, "%d%d",row,&i);
  getc(IN);
  dArray = (unsigned char **)Allocate_Array(*row,*col);
  for (i=0; i< (*row); i++) {
    if (fread(dArray[i],sizeof(unsigned char), (*col), IN) != (*col)) {
      fprintf(stderr,"Error when reading '%s' file.\n",fName);
      Free_Array((void **)dArray, *row);
      fclose(IN);
      *row = *col = 0;
      return NULL;
    }
  }
  fclose(IN);
  
  return dArray;
}


int ReadP5IntoArray(char *fName, int row, int col, unsigned char **dArray)
{
  FILE *IN;
  char string[32];
  int i,j;
  int imrow, imcol;
  if ( (IN= fopen(fName,"rb"))==NULL) {
    fprintf(stderr,"Cannot open file '%s'\n", fName);
    return -1;
  }
  fscanf(IN,"%s",string);
  if ( strcmp(string,"P5")) {
    fprintf(stderr,"The system only works for P5 type PGM file.\n");
    fclose(IN);
    return -1;
  }
  while(1) {
    fscanf(IN,"%s",string);
    if (string[0] == '#') {
      while (  getc(IN) != '\n');
    }
    else {
      sscanf(string,"%d",&imcol);
      break;
    }
  }
  fscanf(IN, "%d%d",&imrow,&i);
  getc(IN);
  
  if (imrow != row || imcol != col) {
    printf("Wrong size when reading %s file. ", fName);
    printf("Actual Size: %d,%d Should be: %d,%d\n",imrow,imcol,row,col);
    return -1;
  }
  for (i=0; i< (row); i++) {
    if (fread(dArray[i],sizeof(unsigned char), col, IN) != col) {
      fprintf(stderr,"Error when reading '%s' file.\n",fName);
      fclose(IN);
      return -1;
    }
  }
  fclose(IN);
  /* printf("Reading '%s' PGM file Done.\n",fName); */
  return 0;
}

unsigned int **ReadP2(char *fName, int *row, int *col)
{
  FILE *IN;
  unsigned int **dArray;
  char string[32];
  int i,j; 
  if ( (IN= fopen(fName,"rb"))==NULL)  {
    fprintf(stderr,"Cannot open file '%s'\n", fName);
    *row = *col = 0;
    return NULL;
  }
  fscanf(IN,"%s",string);
  if ( strcmp(string,"P2")) {
    fprintf(stderr,"The system only works for P2 type PGM file.\n");
    fclose(IN);
    *row = *col = 0;
    return NULL;
  }
  while (1) {
    fscanf(IN,"%s",string); 
    if (string[0] == '#') {
      while (  getc(IN) != '\n');
    }
    else {
      sscanf(string,"%d",col);
      break;
    }
  }
  fscanf(IN, "%d%d",row,&i);
  getc(IN);
  dArray = (unsigned int **)Allocate_Array(*row,(*col)*sizeof(unsigned int));
  for (i=0; i< (*row); i++) {
    for (j=0; j< (*col); j++) {
      if (fscanf(IN,"%d", &(dArray[i][j])) != 1) {
	fprintf(stderr,"Error when reading '%s' file.\n",fName);
	Free_Array((void **)dArray, *row);
	fclose(IN);
	*row = *col = 0;
	return NULL;
      }
    }
  }
  fclose(IN);
  return dArray;
}


int ReadP2IntoArray(char *fName, int row, int col, unsigned int **dArray)
{
  FILE *IN;
  char string[32];
  int i,j;
  int imrow, imcol;
  if ( (IN= fopen(fName,"rb"))==NULL) {
    fprintf(stderr,"Cannot open file '%s'\n", fName);
    return -1;
  }
  fscanf(IN,"%s",string);
  if ( strcmp(string,"P2")) {
    fprintf(stderr,"The system only works for P5 type PGM file.\n");
    fclose(IN);
    return -1;
  }
  while(1) {
    fscanf(IN,"%s",string);
    if (string[0] == '#') {
      while ( getc(IN) != '\n');
    }
    else {
      sscanf(string,"%d",&imcol);
      break;
    }
  }
  fscanf(IN, "%d%d",&imrow,&i);
  getc(IN);
  
  if (imrow != row || imcol != col) {
    printf("Wrong size when reading %s file. ", fName);
    printf("Actual Size: %d,%d Should be: %d,%d\n",imrow,imcol,row,col);
    return -1;
  }
  for (i=0; i< row; i++) {
    for (j=0; j< col; j++) {
      if (fscanf(IN,"%d", &(dArray[i][j])) != 1) {
	fprintf(stderr,"Error when reading '%s' file.\n",fName);
	fclose(IN);
	return -1;
      }
    }
  }
  fclose(IN);
  
  return 0;
}


void WriteP5Char(char *fName, int row, int col, 
		 unsigned char **dArray)
{
  FILE *OUT;
  int i,j;
  if ( (OUT = fopen(fName, "wb")) == NULL) {
    fprintf(stderr,"Failed when writing file '%s'.\n", fName);
    return;
  }
  printf("Writing '%s' ..... ", fName);
  fflush(stdout);
  fprintf(OUT,"P5\n");
  fprintf(OUT,"%d %d\n%d\n",col,row,255);
  for (i=0; i<row; i++) {
    j = fwrite(dArray[i], sizeof(unsigned char), col, OUT);
    if (j!= col) {
      fprintf(stderr,"Error when writing file '%s'.\n", fName);
      fclose(OUT);
      return;
    }
  }
  fclose(OUT);
  printf(" DONE.\n");
  return;
}

void WriteP5CharWithMax(char *fName, int row, int col, 
			unsigned char **dArray, int maxValue)
{
  FILE *OUT;
  int i,j;
  if ( (OUT = fopen(fName, "wb")) == NULL) {
    fprintf(stderr,"Failed when writing file '%s'.\n", fName);
    return;
  }
  printf("Writing '%s' ..... ", fName);
  fflush(stdout);
  fprintf(OUT,"P5\n");
  fprintf(OUT,"%d %d\n%d\n",col,row,maxValue);
  for (i=0; i<row; i++) {
    j = fwrite(dArray[i], sizeof(unsigned char), col, OUT);
    if (j!= col) {
      fprintf(stderr,"Error when writing file '%s'.\n", fName);
      fclose(OUT);
      return;
    }
  }
  fclose(OUT);
  printf(" DONE.\n");
  return;
}


void WriteP2Char(char *fName, int row, int col, 
		 unsigned int **dArray, int maxValue)
{
  FILE *OUT;
  int i,j;
  if ( (OUT = fopen(fName, "wb")) == NULL) {
    fprintf(stderr,"Failed when writing file '%s'.\n", fName);
    return;
  }
  printf("Writing '%s' ..... ", fName);
  fflush(stdout);
  fprintf(OUT,"P2\n");
  fprintf(OUT,"%d %d\n%d\n",col,row,maxValue);
  for (i=0; i<row; i++) {
    for (j=0; j<col; j++) {
      fprintf(OUT,"%d ", dArray[i][j]);
    }
    fprintf(OUT,"\n");
  }
  fclose(OUT);
  printf(" DONE.\n");
  return;
}

int Calc_Local_Variance(IMAGE8BIT *animage, int wsize,
			 int crow, int ccol,
			 double *avg, double *var)
{
  int i,j, k;
  double tmp, vtmp, val;

  k = 0;
  tmp = 0.0;
  vtmp = 0.0;
  for (i=(crow-wsize); i<=(crow+wsize); i++) {
    for (j=(ccol-wsize); j<=(ccol+wsize); j++) {
      if (i>=0 && i < animage->row &&
	  j>=0 && j < animage->col) {
	k++;
	val = (double)animage->image[i][j]/256.;
	tmp += val;
	vtmp += val * val;
      }
    }
  }
  if (k==0) {
    *avg = 0;
    *var = 0;
    return k;
  }
  *avg = tmp/(double)k;
  *var = (vtmp/(double)k - (*avg)*(*avg))*300.;
  return k;
}

  
int Calc_Local_MinMax(IMAGE8BIT *animage, int wsize,
		       int crow, int ccol,
		       double *MinVal, double *MaxVal)
{
  int i,j, k;
  double tmp, vtmp, val;

  k = 0;
  tmp = 0.0;
  vtmp = 0.0;
  *MinVal = 3000.;
  *MaxVal = 0.0;
  for (i=(crow-wsize); i<=(crow+wsize); i++) {
    for (j=(ccol-wsize); j<=(ccol+wsize); j++) {
      if (i>=0 && i < animage->row &&
	  j>=0 && j < animage->col) {
	if (*MinVal > (double)animage->image[i][j]) {
	  *MinVal = (double)animage->image[i][j];
	}
	if (*MaxVal < (double)animage->image[i][j]) {
	  *MaxVal = (double)animage->image[i][j];
	}
	k++;
      }
    }
  }
  *MinVal /= 256.;
  *MaxVal /= 256.;
  return k;
}