/* Program for Filtering an Image with a specified Filter */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Function Prototype */
void Load_Raw_Image(const char *filename, double **image, int ix, int iy);
void Save_Raw_Image(char *filename, double **image, int ix, int iy);
double** Load_Filter(char *filename, int *hx, int *hy);
void Filter_Image(double **image,int ix,int iy,double **filter,int hx,int hy,
				  double **outimg);
double** Allocate_Matrix(int ix, int iy);

double  **image=NULL, **filter=NULL, **outimage=NULL, **tempimage=NULL;

int main(int argc, char *argv[])
{
        char    in_filename[50],out_filename[50],junk[10],filter_filename[50];
        int     ix,iy,hx,hy,i,j;

        printf("\nFILTER IMAGE\n");

        //-------------------------------------------------------------//
        // Parse the arguments otherwise get them
        if(argc<6)
        {   printf("\nUseage: filter <Input Image> <ix> <iy> <Filter File> <Output Image>\n");
            printf("Enter Arguments : ");
            scanf("%s %d %d %s %s",in_filename,&ix,&iy,filter_filename,out_filename);
            gets(junk);
        }
        else
        {   strcpy(in_filename,argv[1]);
			ix = atoi(argv[2]);
            iy = atoi(argv[3]);
			strcpy(filter_filename,argv[4]);
            strcpy(out_filename,argv[5]);
        }

        /*-------------------------------------------------------------*/
        /* Allocate Memory for the Input and Output Images */ 
		printf("\t| Allocating Memory ........................ ");
		image = Allocate_Matrix(ix,iy);
		outimage = Allocate_Matrix(ix,iy);
		printf("COMPLETE\n");
        /*-------------------------------------------------------------*/
        /* Load the image	*/
        printf("\t| Loading Image ............................ ");
		Load_Raw_Image(in_filename,image,ix,iy);
		printf("COMPLETE\n");

		/* Load the Filter while allocating the filter within the function */
		printf("\t| Loading Filter ........................... ");
		filter = Load_Filter(filter_filename,&hx, &hy);
		printf("COMPLETE\n");

		printf("%d %d\n",hx,hy);
		for(i=0;i<hy;i++) {
			for(j=0;j<hx;j++) {
				printf("%5.3lf ",filter[i][j]);
			}
			printf("\n");
		}
		/* Now filter the Image with the filter */
		printf("\t| Filtering Image .......................... ");
		Filter_Image(image,ix,iy,filter,hx,hy,outimage);
		printf("COMPLETE\n");

		/* Save the filtered Image */
		printf("\t| Saving Image ............................. ");
		Save_Raw_Image(out_filename,outimage,ix,iy);
		printf("COMPLETE\n");

		return 0;
}

void Load_Raw_Image(const char *filename, double **image, int ix, int iy)
{
	FILE *infile;
	int x, y;

	infile = fopen(filename,"rb");
	if(infile == NULL) {
		printf("ERROR - Could not open input File\n");
		exit(-1);
	}

	for(y=0;y<iy;y++) {
		for(x=0;x<ix;x++) {
			image[y][x]=(double)getc(infile);
		}
	}
	fclose(infile);
}

/*	This function saves the raw image from the image matrix of
**	size ix by iy into the file "filename" 
*/
void Save_Raw_Image(char *filename, double **image, int ix, int iy)
{
	FILE *infile;
	int x, y;

	infile = fopen(filename,"wb");
	if(infile == NULL) {
		printf("ERROR - Could not open output File\n");
		exit(-1);
	}

	for(y=0;y<iy;y++) {
		for(x=0;x<ix;x++) {
			putc((unsigned char)image[y][x],infile);
		}
	}
	fclose(infile);

}


/*	This function reads in the filter from an ASCII file with the
	format as follows:

	2 3
	0.1 0.1
	0.2 0.2
	0.2 0.2
	
	Where the first number is the number of columns, the second number is the
	number of the rows, followed by the data in one row per line format.
	
	This function will automatically allocate memory for the filter.
*/
	
double** Load_Filter(char *filename, int *hx, int *hy)
{
	FILE *infile;
	double **filter;
	int x, y, i;

	infile = fopen(filename,"rt");
	if(infile == NULL) {
		printf("ERROR - Could not open filter File\n");
		exit(-1);
	}

	/* Read in the filter dimensions x and then y */
	fscanf(infile,"%d %d",hx, hy);
	/* Allocate the matrix for the size of the filter */
	filter = Allocate_Matrix(*hx,*hy);
	/* Now read in the filter coeffs - one row at a time */
	for(y=0;y<*hy;y++) {
		for(x=0;x<*hx;x++) {
			fscanf(infile,"%lf ", &(filter[y][x]));
		}
	}

	/* Now we have read in the filter so close the filter file */
	fclose(infile);
	return filter;

}

void Filter_Image(double **image,int ix,int iy,double **filter,int hx,int hy,
				  double **outimage) 
{
	double value;
	//double value, tempimage[206][204];
	int i,j,k,l,newx,newy,xc,yc,xcnew,ycnew;

	newx=ix+hx+hx;
	newy=iy+hy+hy;

	/*	We need to allocate a temporary image to hold
		the padded image so that the filter works on the borders */
	tempimage=(double **) calloc(newy,sizeof(double));
	if (tempimage == NULL) {
		printf("ERROR - Matrix allocation failure");
		exit(-1);
	}
	for(i=0;i<newy;i++)
	{
			tempimage[i]= (double *) calloc(newx,sizeof(double));
			if (tempimage[i] == NULL){
				printf("ERROR - Matrix allocation failure");
				exit(-1);
			}
	}

	/* Copy the image into tempimage */
	for(i=hy;i<iy+hy;i++) {
		for(j=hx;j<ix+hx;j++) {
			tempimage[i][j] = image[i-hy][j-hx];
		}
	}

	// Get the center position of the filter
	xc = (int)(hx/2); yc = (int)(hy/2);
	xcnew=hx-xc;
	ycnew=hy-yc;
	/* Now Convolve the tempimage with the filter */
	for(i=hy;i<iy+hy;i++) {
		for(j=hx;j<ix+hx;j++) {
			value=0.0;
			for(k=0;k<hy;k++) {
				for(l=0;l<hx;l++) {
					value=value+(filter[k][l]*tempimage[i+k-ycnew][j+l-xcnew]);
				}
			}
			outimage[i-hy][j-hx]=value;
		}
	}

}


double** Allocate_Matrix(int ix, int iy)
{
	int i;
	double **matrix;

	matrix=(double **) calloc(iy,sizeof(double));
	if (matrix == NULL) {
		printf("ERROR - Matrix allocation failure");
		exit(-1);
	}
	for(i=0;i<iy;i++)
	{
			matrix[i]= (double *) calloc(ix,sizeof(double));
			if (matrix[i] == NULL){
				printf("ERROR - Matrix allocation failure");
				exit(-1);
			}
	}
	return matrix;
}