#include "image.h"
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* Some of the code are from elsewhere. The PGM routines are taken from 
 * G. Daivs code.
 *
 * Mow-Song, Ng 2/9/2002
 * msng@mmu.edu.my
 * http://www.pesona.mmu.edu.my/~msng
 *
 * I do not claim copyright to the code, but if you use them or modify them,
 * please drop me a mail.
 *
 */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int SetImage(PIMAGE pimageSrc, unsigned char val)
{
	if (pimageSrc->pixel[0] != NULL){
		memset(pimageSrc->pixel[0], val, (pimageSrc->xsize) * (pimageSrc->ysize) * sizeof(unsigned char));
		return 1;
	}
	else{
		return 0;
	}
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int ImageDynamicRange(PIMAGE pimage, unsigned char *MaxPixel, unsigned char *MinPixel)
{
	unsigned char TempPixel;
	int i, j;

	*MaxPixel=MIN_GREY;
	*MinPixel=MAX_GREY;

	if (pimage->pixel[0] != NULL){

		for (j=0; j<pimage->ysize; j++){
			for (i=0; i<pimage->xsize; i++){
				
				TempPixel=pimage->pixel[j][i];
				
				if (TempPixel > *MaxPixel){
					*MaxPixel=TempPixel;
				}
				
				if (TempPixel < *MinPixel){
					*MinPixel=TempPixel;
				}
			}
		}	
		
		return 1;
	}
	else{
		return 0;
	}
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
PIMAGE ReadRawGreyFile(int xsize, int ysize, char *filename)
{   
   int i;
   PIMAGE pimage;
   FILE *fp;
	
   pimage = (PIMAGE)malloc(sizeof(IMAGE));
   pimage->xsize=xsize;
   pimage->ysize=ysize;
	
   /* Allocate memory */
   if(!ImageBufferAlloc(pimage)){
      free(pimage);
      return NULL;
   }
	
   /* open the file */
   if ((fp=fopen(filename, "rb"))==NULL){      
      ImageBufferFree(pimage);
      free(pimage);
      return NULL;
   }
	
   i=fread(pimage->pixel[0], sizeof(unsigned char), 
      (pimage->xsize)*(pimage->ysize), fp);
	
   fclose(fp);
	
   if (i!=(pimage->ysize)*(pimage->xsize)){
      ImageBufferFree(pimage);
      free(pimage);
      return NULL;
   }
   else{
      return pimage;
   }
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
PFIMAGE ReadRawGreyFileToFloat(int xsize, int ysize, char *filename)
{   
   int i;
   PFIMAGE pfimage;
   FILE *fp;
	unsigned char **temp, *tempLinear;

	/* temporary buffer */
	temp = Byte_Alloc(ysize , xsize);
	tempLinear=temp[0];

   if(temp == NULL){
      return NULL;
   }
 
	/* open the file */
   if ((fp=fopen(filename, "rb"))==NULL){      
      free(temp[0]);
		return NULL;
   }
	
   /* read the image */
	i=fread(temp[0], sizeof(unsigned char), xsize*ysize, fp);
	fclose(fp);
	
	if (i!=ysize*xsize){
      free(temp[0]);
      return NULL;
   }

   pfimage = (PFIMAGE)malloc(sizeof(FIMAGE));
   pfimage->xsize=xsize;
   pfimage->ysize=ysize;
	
   /* Allocate memory */
   if(!FImageBufferAlloc(pfimage)){
      free(pfimage);
      free(temp[0]);
		return NULL;
   }
	
   /* Copy */
	for (i=0; i< xsize*ysize; i++){
		pfimage->pixelLinear[i]=(double)tempLinear[i];
	}
	
	free(temp[0]);

	return pfimage;
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int WriteFloatToRawGreyFile(PFIMAGE pfimage, char *filename)
{
   int i;
   FILE *fp;
	unsigned char **temp, *tempLinear;
   
	temp=Byte_Alloc(pfimage->ysize, pfimage->xsize);
	tempLinear=temp[0];

	if (temp==NULL){
		return 0;
	}

	if((fp=fopen(filename, "wb"))==NULL){
		free(temp[0]);
      return 0;
   }
	
	/* Copy */
	for (i=0; i<pfimage->xsize*pfimage->ysize; i++){
		tempLinear[i]=(int)((pfimage->pixelLinear[i]+0.5) < 0.0 ? 0 : 
						 ((pfimage->pixelLinear[i]+0.5) > 255.0 ? 255 : 
						  (pfimage->pixelLinear[i]+0.5)));
	}

   i=fwrite(temp[0], sizeof(unsigned char), (pfimage->ysize)*(pfimage->xsize), fp);
	
   fclose(fp);

	free(temp[0]);

   if (i!=(pfimage->ysize)*(pfimage->xsize)){
      return 0;
   }
   else{
      return i;
   }	
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
PLIMAGE ReadRaw32File(int xsize, int ysize, char *filename)
{   
   int i;
   PLIMAGE plimage;
   FILE *fp;
	
   plimage = (PLIMAGE)malloc(sizeof(LIMAGE));
   plimage->xsize=xsize;
   plimage->ysize=ysize;
	
   /* Allocate memory */
   if(!LImageBufferAlloc(plimage)){
      free(plimage);
      return NULL;
   }
	
   /* open the file */
   if ((fp=fopen(filename, "rb"))==NULL){      
      LImageBufferFree(plimage);
      free(plimage);
      return NULL;
   }
	
   i=fread(plimage->pixel[0], sizeof(int),
      (plimage->xsize)*(plimage->ysize), fp);
	
   fclose(fp);
	
   if (i!=(plimage->ysize)*(plimage->xsize)){
      LImageBufferFree(plimage);
      free(plimage);
      return NULL;
   }
   else{
      return plimage;
   }
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
PFIMAGE ReadRawFloatFile(int xsize, int ysize, char *filename)
{   
   int i;
   PFIMAGE pfimage;
   FILE *fp;
	
   pfimage = (PFIMAGE)malloc(sizeof(FIMAGE));
   pfimage->xsize=xsize;
   pfimage->ysize=ysize;
	
   /* Allocate memory */
   if(!FImageBufferAlloc(pfimage)){
      free(pfimage);
      return NULL;
   }
	
   /* open the file */
   if ((fp=fopen(filename, "rb"))==NULL){      
      FImageBufferFree(pfimage);
      free(pfimage);
      return NULL;
   }
	
   i=fread(pfimage->pixel[0], sizeof(double),
      (pfimage->xsize)*(pfimage->ysize), fp);
	
   fclose(fp);
	
   if (i!=(pfimage->ysize)*(pfimage->xsize)){
      FImageBufferFree(pfimage);
      free(pfimage);
      return NULL;
   }
   else{
      return pfimage;
   }
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int WriteRawGreyFile(PIMAGE pimage, char *filename)
{
   int i;
   FILE *fp;
   
   if((fp=fopen(filename, "wb"))==NULL){
      return 0;
   }
	
   i=fwrite(pimage->pixel[0], sizeof(unsigned char),
      (pimage->ysize)*(pimage->xsize), fp);
	
   fclose(fp);
	
   if (i!=(pimage->ysize)*(pimage->xsize)){
      return 0;
   }
   else{
      return i;
   }
	
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int WriteRaw32File(PLIMAGE plimage, char *filename)
{
   int i;
   FILE *fp;
   
   if((fp=fopen(filename, "wb"))==NULL){
      return 0;
   }
	
   i=fwrite(plimage->pixel[0], sizeof(int),
      (plimage->xsize)*(plimage->ysize), fp);
	
   fclose(fp);
	
   if (i!=(plimage->ysize)*(plimage->xsize)){
      return 0;
   }
   else{
      return i;
   }
	
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int WriteRawFloatFile(PFIMAGE pfimage, char *filename)
{
   int i;
   FILE *fp;
   
   if((fp=fopen(filename, "wb"))==NULL){
      return 0;
   }
	
   i=fwrite(pfimage->pixel[0], sizeof(double),
      (pfimage->xsize)*(pfimage->ysize), fp);
	
   fclose(fp);
	
   if (i!=(pfimage->ysize)*(pfimage->xsize)){
      return 0;
   }
   else{
      return i;
   }
	
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int ImageBufferAlloc(PIMAGE pimage)
{
   /* allocate memory */
   pimage->pixel = Byte_Alloc(pimage->ysize , pimage->xsize);
	pimage->pixelLinear=pimage->pixel[0];
	
   if(pimage->pixel[0] == NULL){
      return FALSE;
   }
   return TRUE;
}


/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void ImageFree(PIMAGE pimage)
{
   ImageBufferFree(pimage);
   free(pimage);
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void ImageBufferFree(PIMAGE pimage)
{
	free(pimage->pixelLinear);
	free(pimage->pixel);
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int LImageBufferAlloc(PLIMAGE plimage)
{
   /* allocate memory */
   plimage->pixel = Int_Alloc(plimage->ysize , plimage->xsize);
	plimage->pixelLinear=plimage->pixel[0];
	
   if(plimage->pixel[0] == NULL){
      return FALSE;
   }
   return TRUE;
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void LImageFree(PLIMAGE plimage)
{
	LImageBufferFree(plimage);
	free(plimage);
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void LImageBufferFree(PLIMAGE plimage)
{
	int i;
	free(plimage->pixelLinear);
	/* free the row pointers */
	free(plimage->pixel);
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void FImageFree(PFIMAGE pfimage)
{
   FImageBufferFree(pfimage);
   free(pfimage);
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int FImageBufferAlloc(PFIMAGE pfimage)
{
   /* allocate memory */
   pfimage->pixel = (double **)Mem_Alloc(pfimage->ysize , 
      pfimage->xsize, sizeof(double));

	pfimage->pixelLinear=pfimage->pixel[0];
   
	if(pfimage->pixel[0] == NULL){
      return FALSE;
   }
   return TRUE;
}


/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void FImageBufferFree(PFIMAGE pfimage)
{
	free(pfimage->pixelLinear);
	free(pfimage->pixel);
}