#include <iostream>
#include <fstream>
#include <string>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

const int NB=1;
const int GB=1;
unsigned char* inputImage;
unsigned char* outputImage;
int pictureWidth;
int pictureHight;

void GaussBlur(unsigned char* gauss_image){
	char Gauss[]={99, 68, 35, 10};
	unsigned char g_tmp_image[pictureWidth][pictureHight];
	int g_acc; //can be only 16 bits
	int tot=0; //can be only 16 bits
	for(int k=-GB; k<=GB; k++){
		tot+=Gauss[abs(k)];
	}
	/*
	 * Horisontal Gaussian blur
	 */
	for(int x=0; x<pictureWidth; x++){
		for(int y=0; y<pictureHight; y++){
			g_tmp_image[x][y]=0;
		}
	}
	for(int x=GB; x<pictureWidth-GB; x++){
		for(int y=GB; y<pictureHight-GB; y++){
			g_acc=0;
			for(int k=-GB; k<=GB; k++){
				g_acc+=inputImage[x+k + pictureWidth*y]*Gauss[abs(k)];
			}
			g_tmp_image[x][y]=g_acc/tot;
		}
	}
	/*
	 * Vertical Gaussian blur
	 */
	for(int i=0; i<pictureWidth*pictureHight; i++){
		gauss_image[i]=0;
	}
	for(int x=GB; x<pictureWidth-GB; x++){
		for(int y=GB; y<pictureHight-GB; y++){
			g_acc=0;
			for(int k=-GB; k<GB; k++){
				g_acc+=g_tmp_image[x][y+k]*Gauss[abs(k)];
			}
			gauss_image[x + y*pictureWidth]=g_acc/tot;
		}
	}
}

void ComputeEdges(unsigned char* gauss_image){
	char maxdiff, val;

	for(int i=0; i<pictureWidth*pictureHight; i++){
		outputImage[i]=0;
	}

	for(int x=NB; x<pictureWidth-NB; x++){
		for(int y=NB; y<pictureHight-NB; y++){
			maxdiff=0;
			for(int k=-NB; k<=NB; k++){
				for(int l=-NB; l<=NB; l++){
					if(k!=0 || l!=0){
						val=abs( ((int)gauss_image[x+k +pictureWidth*(y+1)])- gauss_image[x + pictureWidth*y]);
						if(val>maxdiff){
							maxdiff=val;
						}
					}
				}
			}
			outputImage[x + pictureWidth*y]=maxdiff;
		}
	}
}

void outputPicture(char *fileName)
{
  FILE *f;

  cout<<"Output picture"<<endl;

  /* Open file */

  if(!(f=fopen(fileName,"wt+")))
  {
    printf("%s Can't open file\n",fileName);
  }

  fprintf(f, "P2\n");
  fprintf(f,"%d %d\n", pictureWidth, pictureHight);
  fprintf(f,"255\n");

  for(int i=0; i<pictureHight*pictureWidth; i++){
	  fprintf(f,"%d\n", outputImage[i]);
  }

  fclose(f);
}

void readingPicture(char *fileName){
	cout<<"reading Picture "<<fileName<<endl;
	string line;
	ifstream pictureFile (fileName);
	if (pictureFile.is_open())
	{
		while ( pictureFile.good() )
		{
			getline (pictureFile,line);
			if(!(line[0]=='P' && line[1]=='2')) break;
			getline (pictureFile,line);
			while(line[0]=='#'){
				getline (pictureFile,line);
			}
			int spaceIndex=line.find_first_of(" ");
			pictureWidth=atoi(line.substr(0, spaceIndex).c_str());
			pictureHight=atoi(line.substr(spaceIndex+1, line.size()).c_str());
			cout << pictureWidth <<"  "<<pictureHight<< endl;
			inputImage= new unsigned char[pictureWidth*pictureHight];
			getline (pictureFile,line);
			getline (pictureFile,line);
			for(int i=0; i<pictureHight*pictureWidth; i++){
				int spaceIndex=line.find_first_of(" ");
				if(spaceIndex==-1){
					inputImage[i]=atoi(line.substr(0, line.size()).c_str());
					getline (pictureFile,line);
				}else{
					inputImage[i]=atoi(line.substr(0, spaceIndex).c_str());
					line=line.substr(spaceIndex+1, line.size());
				}
			}
		}
		pictureFile.close();
	}
  else cout << "Unable to open file"<<endl;
}

int main(){
	readingPicture("goldenBridge.pgm");
	unsigned char* gaussImage;
	gaussImage=new unsigned char[pictureWidth*pictureHight];
	GaussBlur(gaussImage);
	outputImage=new unsigned char[pictureWidth*pictureHight];
	ComputeEdges(gaussImage);
	outputPicture("outputPicture.pgm");
	return 0;
}