#include <windows.h>
#include <malloc.h>
#include "FreeImage.h"
#include <stdio.h>
#include <stdlib.h>
#include <GL/gl.h>
#include <GL/glut.h>
#include <GL/glu.h>

typedef struct {
	int r, g, b;
} pixel;

char imagename[80];
int img_height = 0;
int img_width = 0;
pixel **data;
pixel **temp_img;
bool grey = false;

//read the image in
pixel **read_img(char *name, int *width, int *height) {
	FIBITMAP *image;
	int i,j;
	RGBQUAD aPixel;
	//pixel **data;

	if((image = FreeImage_Load(FIF_TIFF, name, 0)) == NULL) {
		perror("FreeImage_Load");
		return NULL;
	}

	img_height = FreeImage_GetHeight(image);
	img_width = FreeImage_GetWidth(image);
	*width = FreeImage_GetWidth(image);
	*height = FreeImage_GetHeight(image);

	data = (pixel **)malloc((*height)*sizeof(pixel *));
	for(i = 0 ; i < (*height) ; i++) {
		data[i] = (pixel *)malloc((*width)*sizeof(pixel));
		for(j = 0 ; j < (*width) ; j++) {
			FreeImage_GetPixelColor(image, j, i, &aPixel);

			data[i][j].r = (aPixel.rgbRed);
			data[i][j].g = (aPixel.rgbGreen);
			data[i][j].b = (aPixel.rgbBlue);
		}
	}

	FreeImage_Unload(image);
	return data;
}

pixel **read_img2(char *name, int *width, int *height) {
	FIBITMAP *image;
	int i,j;
	RGBQUAD aPixel;
	//pixel **data;

	if((image = FreeImage_Load(FIF_TIFF, name, 0)) == NULL) {
		perror("FreeImage_Load");
		return NULL;
	}

	img_height = FreeImage_GetHeight(image);
	img_width = FreeImage_GetWidth(image);
	*width = FreeImage_GetWidth(image);
	*height = FreeImage_GetHeight(image);

	temp_img = (pixel **)malloc((*height)*sizeof(pixel *));
	for(i = 0 ; i < (*height) ; i++) {
		temp_img[i] = (pixel *)malloc((*width)*sizeof(pixel));
		for(j = 0 ; j < (*width) ; j++) {
			FreeImage_GetPixelColor(image, j, i, &aPixel);

			temp_img[i][j].r = (aPixel.rgbRed);
			temp_img[i][j].g = (aPixel.rgbGreen);
			temp_img[i][j].b = (aPixel.rgbBlue);
		}
	}

	FreeImage_Unload(image);
	return data;
}
//display the image on openGL window
void display_img (void) {
	int x,y;
	glClear(GL_COLOR_BUFFER_BIT);
	glBegin(GL_POINTS);
	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			glColor3ub(data[x][y].r,data[x][y].g,data[x][y].b);
			glVertex2f(y,x);
		}
	}
	glEnd();
	glColor3f(1.0,0.0,0.0);
	glFlush();
}
//display temporary image for max, min
void display_img2 (void) {
	int x,y;
	glClear(GL_COLOR_BUFFER_BIT);
	glBegin(GL_POINTS);
	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			glColor3ub(temp_img[x][y].r,temp_img[x][y].g,temp_img[x][y].b);
			glVertex2f(y,x);
		}
	}
	glEnd();
	glFlush();
}
//reset the image to the original
void reset_img (void) {
	int x,y;
	
	data = read_img(imagename,&img_width, &img_height);
	glClear(GL_COLOR_BUFFER_BIT);
	glBegin(GL_POINTS);
	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			glColor3ub(data[x][y].r,data[x][y].g,data[x][y].b);
			glVertex2f(y,x);
		}
	}
	glEnd();
	glFlush();
}
//write/save the image
void write_img(char *name, pixel **data, int width, int height) {
	FIBITMAP *image;
	RGBQUAD aPixel;
	int i,j;

	image = FreeImage_Allocate(width, height, 24, 0, 0, 0);

	if(!image) {
		perror("FreeImage_Allocate");
		return;
	}

	for(i = 0 ; i < height ; i++) {
		for(j = 0 ; j < width ; j++) {
			aPixel.rgbRed = data[i][j].r;
			aPixel.rgbGreen = data[i][j].g;
			aPixel.rgbBlue = data[i][j].b;

			FreeImage_SetPixelColor(image, j, i, &aPixel);
		}
	}

	if(!FreeImage_Save(FIF_TIFF, image, name, 0)) {
		perror("FreeImage_Save");
	}

	FreeImage_Unload(image);
}
//grey_filter
void grey_filter (pixel **data) {
	int x,y;
	int number;

	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			number = ((data[x][y].b) + (data[x][y].g) + (data[x][y].r))/3;
			data[x][y].b = number;
			data[x][y].g = number;
			data[x][y].r = number;
		}
	}
	display_img();
}

//Ntsc_filter
void Ntsc_filter (pixel **data){
	int x,y;

	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			data[x][y].b = 0.114 * data[x][y].b;
			data[x][y].g = 0.587 * data[x][y].g;
			data[x][y].r = 0.299 * data[x][y].r;
		}
	}
	display_img();
}
//Monochrome
void Monochrome (pixel **data){
	int x,y;
	int number = 0;

	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			number = data[x][y].b + data[x][y].g + data[x][y].r;
			number = number / 3;
			if (number > 128){
				data[x][y].b = 255;
				data[x][y].g = 255;
				data[x][y].r = 255;
			}
			else if (number <= 128) {
				data[x][y].b = 0;
				data[x][y].g = 0;
				data[x][y].r = 0;
			}
			else {}
			number = 0.0;
		}
	}
	display_img();
}

//Red channel
void Rchannel (pixel **data) {
	int x,y;
	
	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			data[x][y].g = 0;
			data[x][y].b = 0;
		}
	}
	display_img();
}
//Green channel
void Gchannel (pixel **data) {
	int x,y;
	
	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			data[x][y].r = 0;
			data[x][y].b = 0;
		}
	}
	display_img();
}
//Blue Channel
void Bchannel (pixel **data) {
	int x,y;

	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			data[x][y].g = 0;
			data[x][y].r = 0;
		}
	}
	display_img();
}

//Vertical Flip
void Vflip (pixel **data) {
	int x,y;
	int half_height = img_height/2;
	pixel temppixel;

	for (x=1; x < half_height; x++){
		for (y=1; y < img_width; y++) {
			temppixel.b = data[img_height-x][y].b;
			data[img_height-x][y].b = data[x][y].b;
			data[x][y].b = temppixel.b;
			
			temppixel.g = data[img_height-x][y].g;
			data[img_height-x][y].g = data[x][y].g;
			data[x][y].g = temppixel.g;
		
			temppixel.r = data[img_height-x][y].r;
			data[img_height-x][y].r = data[x][y].r;
			data[x][y].r = temppixel.r;
		}
	}
	display_img();

}

//cool filtering effect
void filter1 (pixel **data) {
	int x,y;

	for (x=1; x < img_height; x++){
		for (y=1; y < img_width; y++) {
			if (data[x][y].b < 128)
				data[x][y].b = 255;
			else
				data[x][y].b = 0;
			if (data[x][y].g < 128)
				data[x][y].g = 255;
			else
				data[x][y].g = 0;
			if (data[x][y].r < 128)
				data[x][y].r = 255;
			else
				data[x][y].r = 0;
		}
	}
	display_img();
}


//cool filtering effect 2
void filter2 (pixel **data){
    int x,y;

	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			if (data[x][y].b > 128)
				data[x][y].b = 255;
			else
				data[x][y].b = 0;
			if (data[x][y].g > 128)
				data[x][y].g = 255;
			else
				data[x][y].g = 0;
			if (data[x][y].r > 128)
				data[x][y].r = 255;
			else
				data[x][y].r = 0;
		}
	}
	display_img();
}
//horizontal flip
void Hflip (pixel **data) {
	int x,y;
	
	int half_width = img_width/2;
	pixel temppixel;

	for (x=1; x < img_height; x++){
		for (y=1; y < half_width; y++) {
			temppixel.b = data[x][img_width-y].b;
			data[x][img_width-y].b = data[x][y].b;
			data[x][y].b = temppixel.b;
			
			temppixel.g = data[x][img_width-y].g;
			data[x][img_width-y].g = data[x][y].g;
			data[x][y].g = temppixel.g;
		
			temppixel.r = data[x][img_width-y].r;
			data[x][img_width-y].r = data[x][y].r;
			data[x][y].r = temppixel.r;
		}
	
	}
	display_img();
}

int findminred(int x, int y){
	int i=0;
	int j=0;
	int minred=256;

	for (i=x; i<x+3; i++){
		for (j=y; j<y+3; j++){
			if (temp_img[i][j].r < minred){
				minred = temp_img[i][j].r;
			}
			else {}
		}
	}
	return minred;
}
int findmingreen(int x, int y){
	int i=0;
	int j=0;
	int mingreen=256;

	for (i=x; i<x+3; i++){
		for (j=y; j<y+3; j++){
			if (temp_img[i][j].g < mingreen){
				mingreen = temp_img[i][j].g;
			}
			else {}
		}
	}
	return mingreen;
}
int findminblue(int x, int y){
	int i=0;
	int j=0;
	int minblue=256;

	for (i=x; i<x+3; i++){
		for (j=y; j<y+3; j++){
			if (temp_img[i][j].b < minblue){
				minblue = temp_img[i][j].b;
			}
			else {}
		}
	}
	return minblue;
}
int findmaxred(int x, int y){
	int i=0;
	int j=0;
	int maxred=0;

	for (i=x; i<x+3; i++){
		for (j=y; j<y+3; j++){
			if (temp_img[i][j].r > maxred){
				maxred = temp_img[i][j].r;
			}
			else {}
		}
	}
	return maxred;
}
int findmaxgreen(int x, int y){
	int i=0;
	int j=0;
	int maxgreen=0;

	for (i=x; i<x+3; i++){
		for (j=y; j<y+3; j++){
			if (temp_img[i][j].g > maxgreen){
				maxgreen = temp_img[i][j].g;
			}
			else {}
		}
	}
	return maxgreen;
}
int findmaxblue(int x, int y){
	int i=0;
	int j=0;
	int maxblue=0;

	for (i=x; i<x+3; i++){
		for (j=y; j<y+3; j++){
			if (temp_img[i][j].b > maxblue){
				maxblue = temp_img[i][j].b;
			}
			else {}
		}
	}
	return maxblue;
}
void Max (pixel **data) {
	int x,y;
	int maxred=0;
	int maxgreen=0;
	int maxblue=0;

	for (x=1; x<img_height-1; x++){
		for (y=1; y<img_width-1; y++){																	
			maxred = findmaxred(x-1,y-1);
			maxgreen = findmaxgreen(x-1,y-1);
			maxblue = findmaxblue(x-1,y-1);
			data[x][y].r = maxred;
			data[x][y-1].r = maxred;
			data[x][y+1].r = maxred;
			data[x-1][y].r = maxred;
			data[x-1][y+1].r = maxred;
			data[x-1][y-1].r = maxred;
			data[x+1][y].r = maxred;
			data[x+1][y+1].r = maxred;
			data[x+1][y-1].r = maxred; 
			data[x][y].g = maxgreen;
			data[x][y-1].g = maxgreen;
			data[x][y+1].g = maxgreen;
			data[x-1][y].g = maxgreen;
			data[x-1][y+1].g = maxgreen;
			data[x-1][y-1].g = maxgreen;
			data[x+1][y].g = maxgreen;
			data[x+1][y+1].g = maxgreen;
			data[x+1][y-1].g = maxgreen; 
			data[x][y].b = maxblue;
			data[x][y-1].b = maxblue;
			data[x][y+1].b = maxblue;
			data[x-1][y].b = maxblue;
			data[x-1][y+1].b = maxblue;
			data[x-1][y-1].b = maxblue;
			data[x+1][y].b = maxblue;
			data[x+1][y+1].b = maxblue;
			data[x+1][y-1].b = maxblue; 

			maxred = 0;
			maxgreen = 0;
			maxblue = 0;
		}
	}
	display_img();
//	display_img2();
}
void Min (pixel **data) {
	int x,y;
	int minred=256;
	int mingreen=256;
	int minblue=256;

	for (x=1; x<img_height-1; x++){
		for (y=1; y<img_width-1; y++){																	
			minred = findminred(x-1,y-1);
			mingreen = findmingreen(x-1,y-1);
			minblue = findminblue(x-1,y-1);
			data[x][y].r = minred;
			data[x][y-1].r = minred;
			data[x][y+1].r = minred;
			data[x-1][y].r = minred;
			data[x-1][y+1].r = minred;
			data[x-1][y-1].r = minred;
			data[x+1][y].r = minred;
			data[x+1][y+1].r = minred;
			data[x+1][y-1].r = minred; 
			data[x][y].g = mingreen;
			data[x][y-1].g = mingreen;
			data[x][y+1].g = mingreen;
			data[x-1][y].g = mingreen;
			data[x-1][y+1].g = mingreen;
			data[x-1][y-1].g = mingreen;
			data[x+1][y].g = mingreen;
			data[x+1][y+1].g = mingreen;
			data[x+1][y-1].g = mingreen; 
			data[x][y].b = minblue;
			data[x][y-1].b = minblue;
			data[x][y+1].b = minblue;
			data[x-1][y].b = minblue;
			data[x-1][y+1].b = minblue;
			data[x-1][y-1].b = minblue;
			data[x+1][y].b = minblue;
			data[x+1][y+1].b = minblue;
			data[x+1][y-1].b = minblue; 

			minred = 256;
			mingreen = 256;
			minblue = 256;
		}
	}
	display_img();
//	display_img2();
}
//RGB switching filter when applied 3 times returns to the original image
void RGBswitch (pixel **data){
	int x,y;

	pixel green;
	pixel red;
	pixel blue;

	for (x=0; x < img_height; x++){
		for (y=0; y < img_width; y++){
			green.g = data[x][y].g;
			red.r = data[x][y].r;
			blue.b = data[x][y].b;
			data[x][y].g = red.r;
			data[x][y].b = green.g;
			data[x][y].r = blue.b;
		}
	}
	display_img();
}
void keyboard (unsigned char key, int x, int y) {
	switch (key) {
		case 0x1B:
		case 'q':
		case 'Q':
			exit(0);
			break;
		case 'g':
		case 'G':
			reset_img();
			grey_filter(data);
			break;
		case 'v':
		case 'V':
			Vflip(data);
			break;
		case 'h':
		case 'H':
			Hflip(data);
			break;
		case 'r':
		case 'R':
			RGBswitch(data);
			break;
		case 'm':
		case 'M':
			reset_img();
			Monochrome(data);
			break;
		case 'n':
		case 'N':
			reset_img();
			Ntsc_filter(data);
			break;
		case 'b':
		case 'B':
			reset_img();
			Bchannel(data);
			break;
		case 'e':
		case 'E':
			reset_img();
			Gchannel(data);
			break;
		case 'd':
		case 'D':
			reset_img();
			Rchannel(data);
			break;
		case 't':
		case 'T':
			reset_img();
			break;
		case 'w':
		case 'W':
			write_img("backup.tif", data, img_width, img_height);
			break;
		case 'x':
		case 'X':
			Max(data);
			break;
		case 'z':
		case 'Z':
			Min(data);
			break;
		case 'j':
		case 'J':
			reset_img();
			filter1(data);
			break;
		case 'k':
		case 'K':
			reset_img();
			filter2(data);
			break;

	}
	
}

int main(int argc, char **argv) {
	printf("This is a simple image editing program\nwhich can add some cool effects on the\nimages being edited and save the copy as backup.tif\n");
	printf("Input the name of the image you want to edit\n(example:image.tif)\n= ");
	scanf("%s",&imagename);
	pixel **data;
	int w, h;
	printf("T = reset image\n");
	printf("G = grey scale image\n");
	printf("N = NTSC image\n");
	printf("M = Monochrome image\n");
	printf("R = Switch RGB channels\n");
	printf("E = Green channel\n");
	printf("D = Red channel\n");
	printf("B = Blue channel\n");
	printf("V = vertical flip\n");
	printf("H = horizontal flip\n");
	printf("J = myfilter 1\n");
	printf("K = myfilter 2\n");
	printf("X = max filter\n");
	printf("Z = min filter\n");
	printf("W = write/save image\n");
	printf("Q = Quit\n");
	data = read_img(imagename, &w, &h);
	temp_img = read_img2(imagename, &w, &h);
	glutInit(&argc, argv);
	glutInitWindowSize(w,h);
	glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
	glutCreateWindow("output");
	glutKeyboardFunc(keyboard);
	glutDisplayFunc(display_img);
	//glutIdleFunc(display_img);
	glClear(GL_COLOR_BUFFER_BIT);
	glClearColor(0.0,0.0,0.0,0.0);
	glMatrixMode(GL_PROJECTION);
	glPointSize(8.0);
	gluOrtho2D(0.0,img_width-1,0.0,img_height-1);
	reset_img();
	glutMainLoop();
	
}