#include <Magick++.h>
#include <math.h>
#include <stdlib.h>
#include <fstream.h>
#include <complex.h>
#include <sys/time.h>
#include <unistd.h>


/* _____________________-
things to store in file :
1. image size - x , y ( int )
2. no of panels on each side - xpanels , ypanels ( int )

3. the Fractal codes for each destination panel
*/

using namespace std;
using namespace Magick;

const long MAXPANELS=200000;
const int nsforms=8;
const double _gamma=0.75;

struct panel
{
  int x,y;
  int panelsize;
  double mean;
};

struct fractalcode
{
  short int x,y;
  short int s;
  short int beta;
};

struct sform
{
  int a,b,c,d;
  double con;
  int xpixels[128];
  int ypixels[128];
 
};

char infile[80],outfile[80];
double image[512][512];
double rimage[256][256];
int rows,cols;
int panelsize;
int dxpanels,dypanels;
panel destpanels[MAXPANELS];

int rxpanels,rypanels;
panel refpanels[MAXPANELS];
int rrows,rcols;

fractalcode fractalcodes[MAXPANELS];
sform sformlist[nsforms]={{1,0,0,1,0.5},
			  {-1,0,0,1,0.5},
			  {1,0,0,-1,0.5},
			  {-1,0,0,-1,0.5},
			  {0,1,1,0,0.5},
			  {0,-1,1,0,0.5},
			  {0,1,-1,0,0.5},
			  {0,-1,-1,0,0.5}};




//___fn. to get pixel for a panel
inline double getpixel(panel p,int x,int y)
{
  return image[p.y+y][p.x+x];
}

//__fn to set pixel for a panel value
inline void setpixel(panel p,int x,int y,double value)
{
  image[p.y+y][p.x+x]=value;
}

void prepareall(int panelsize)
{

  int i,j,k;
  
  int x,y;
  for(k=0;k<8;k++)
    {
      
      for(x=0;x<panelsize;x++)
	for(y=0;y<panelsize;y++)
	  {
	    int index=x+y*panelsize;
	       
	    if(sformlist[k].a==1)
	      sformlist[k].xpixels[index]=x;
	    else if(sformlist[k].a==-1)
	      sformlist[k].xpixels[index]=panelsize-1-x;
	    
	    if(sformlist[k].b==1)
	      sformlist[k].xpixels[index] =y;
	    else if(sformlist[k].b==-1)
	      sformlist[k].xpixels[index]=panelsize-1-y;
	    
	    if(sformlist[k].c==1)
	      sformlist[k].ypixels[index]=x;
	    else if(sformlist[k].c==-1)
	      sformlist[k].ypixels[index] =panelsize-1-x;
	    
	    if(sformlist[k].d==1)
	      sformlist[k].ypixels[index]=y;
	    else if(sformlist[k].d==-1)
	      sformlist[k].ypixels[index]=panelsize-1-y;
	    
	  }
    }
  

  cout << "\nprepareall finished..." << flush;
  
}



//___fn to get pixels in transformed ref panels
// get transformed pixel
inline double getrpixel(panel p,int x,int y,int s)
{
  /*  int xc,yc;
  sform sf=sformlist[s];
  
  if(sf.a==1)
    xc=x;
  else if(sf.a==-1)
    xc=panelsize-1-x;
  
  if(sf.b==1)
    xc=y;
  else if(sf.b==-1)
    xc=panelsize-1-y;
   
  if(sf.c==1)
    yc=x;
  else if(sf.c==-1)
    yc=panelsize-1-x;
    
  if(sf.d==1)
    yc=y;
  else if(sf.d==-1)
    yc=panelsize-1-y;
  */

  int index=x+y*panelsize;
  int x1=sformlist[s].ypixels[index];
  int x2=sformlist[s].xpixels[index];
  return rimage[p.y+x1][p.x+x2];
}


double getmean(panel p)
{
  int i,j,k;
  double sum=0;
  for(i=p.y;i<p.y+panelsize;i++)
    for(j=p.x;j<p.x+panelsize;j++)
      {
	sum+=image[i][j];
      }

  return sum/(panelsize*panelsize);
  
}

double getrmean(panel p)
{
  int i,j,k;
  double sum=0;
  for(i=p.y;i<p.y+panelsize;i++)
    for(j=p.x;j<p.x+panelsize;j++)
      {
	sum+=rimage[i][j];
      }

  return sum/(panelsize*panelsize);
  
}



// prepare the destination panels - original image
void preparedestpanels()
{

  cout << "\npreparing destination panels..." << flush;
  
  int i,j,k;
  int count=0;
  dxpanels=cols/panelsize;
  dypanels=rows/panelsize;
  int ndestpanels=dxpanels*dypanels;
  
  for(i=0;i<rows;i+=panelsize)
    for(j=0;j<cols;j+=panelsize)
      {
	panel r;
	r.x=j; r.y=i;
	r.panelsize=panelsize;
	r.mean=getmean(r);
	
	destpanels[count++]=r;	
      }

  cout << "\nprepatedestpanels : generated " << count << " panels..." << flush;
  
}


// prepare the reference image which is half the size  of original image
// also prepare the reference panels
void preparerefimage()
{

  cout << "\npreparing reference image ... " << flush;
  
  int i,j,k;
  rrows=rows/2;
  rcols=cols/2;

  for(i=0;i<rcols;i++)
    for(j=0;j<rrows;j++)
      {
	int xx=2*i;
	int yy=2*j;

	double val=(image[yy][xx]+image[yy+1][xx]+image[yy][xx+1]+image[xx+1][yy+1]);
	rimage[yy][xx]=(val*_gamma)/4;
      }

  cout << "\nprepared the ref image by averaging the destination image..." << flush;
  

  rxpanels=rcols-(panelsize-1);
  rypanels=rrows-(panelsize-1);

  
  int nrefpanels=rxpanels*rypanels;

  cout << "\npreparerefimage : no of panels - " << nrefpanels << flush;
  
  // prepare the reference panels
  int count=0;
  for(i=0;i<rypanels;i++)
    for(j=0;j<rxpanels;j++)
      {
	
	panel r;
	r.x=j;r.y=i;
	r.panelsize=panelsize;
	r.mean=getrmean(r);
	refpanels[count++]=r;	
      }  

  cout << "\npreparerefimage : prepared ref panels. count : " << count << flush;
}


void readimage(char* filename)
{


  cout << "\nreadimage : " << filename << flush;
  Image source;
  
  source = Image(filename);
  cols = source.baseColumns();  
  rows = source.baseRows();
  source.classType(DirectClass);
  source.quantizeColorSpace(GRAYColorspace);

  Pixels viewsrc(source);
  PixelPacket *pixelsrc = viewsrc.get(0,0,cols,rows);
  
  for(int x=0;x<rows;x++)
    for(int y=0;y<cols;y++)
      {
	image[x][y] = ((ColorGray)(*pixelsrc)).shade();	
	pixelsrc++;
      }
  pixelsrc-= cols*rows;
  
}

void writeimage(char* filename,int ask=0)
{

  cout << "\nwriteimage : " << filename << flush;
  
  char buffer[80];
  if(ask)
    {

      char choice;
      cout << "\nWant to save the image(y/n)  : ";
      cin >> choice;
      if(choice!='y' && choice!='Y')
	return;

      cout << "Enter filename : " ;
      cin >> buffer;
    }
  
  Image fspectrum(Geometry(cols,rows),"white");
  fspectrum.classType(DirectClass);
  fspectrum.quantizeColorSpace(GRAYColorspace);
  Pixels fview(fspectrum);
  PixelPacket *fpixels = fview.get(0,0,cols,rows);

  for(int x=0;x<rows;x++)
    for(int y=0;y<cols;y++)
      {
	(*fpixels) = ColorGray(image[x][y]);
	fpixels++;
      }
    
  fview.sync();
  fspectrum.write((ask==1) ? buffer : filename);

}

//___parameters are panelsize only now
void compress(char* filename)
{

  cout << "\nCompressing image ..." << flush;
  panelsize=4;

  prepareall(panelsize);
  
  preparedestpanels();
  preparerefimage();
  
  int ndestpanels=dxpanels*dypanels;
  int nrefpanels=rxpanels*rypanels;
  
  double error,beta,diff;
  double besterror,bestbeta,bestform;
  int bestsform;
  panel bestrpanel;
  
  int i,j,k;
  cout << "\ncompress:  no of destination panels :: " << ndestpanels << flush;
  
  for(i=0;i<ndestpanels;i++)
    {
      besterror=9999999;
      for(j=0;j<nrefpanels;j++)
	{
	  // calculate difference in mean;
	  beta=destpanels[i].mean-refpanels[j].mean;


	  // try all orientations of ref image to suit best image for this destination panel
	  int s;
	  error=0;
	   for(s=0;s<nsforms;s++)
	    {
	      error=0;
	      int x,y;
	      for(x=0;x<panelsize;x++)
		for(y=0;y<panelsize;y++)
		  {
		    // get diff between corresponding pixels
		    diff=getpixel(destpanels[i],x,y)-getrpixel(refpanels[j],x,y,s);
		    // calc variance 
		    error+=(diff-beta)*(diff-beta)*255*255;
		  }
	  
	      /*
	  
	      error=0;
	      int x,y;
	      int dx,dy,rx,ry;
	      dx=destpanels[i].x;
	      dy=destpanels[i].y;
	      rx=refpanels[j].x;
	      ry=refpanels[j].y;
	      
	     
	      for(x=0;x<panelsize;x++)
		for(y=0;y<panelsize;y++)
		  {
		    // get diff between corresponding pixels

		    //		    diff=getpixel(destpanels[i],x,y)-getrpixel(refpanels[j],x,y,s);
		    diff=image[dy+y][dx+x]-rimage[ry+y][rx+x];
		    // calc variance 
		    error+=(diff-beta)*(diff-beta)*255*255;
		    
		  }
	      */
	  
	      if(error<besterror)
		{
		  besterror=error;
		  bestsform=s;
		  bestbeta=beta;
		  bestrpanel=refpanels[j];
		}
	    } // for s
	  

	   if(besterror==0) break;
	} // for refpanels

      // add the best region panel for dest panel here
      
      fractalcodes[i].x=bestrpanel.x;
      fractalcodes[i].y=bestrpanel.y;
      fractalcodes[i].s=bestsform;
      fractalcodes[i].beta=int(bestbeta*255);
      cout << "\ndone for destination panel : " << i << " out of "  << ndestpanels  << flush;
      cout << "\nDestpanels coords : " << destpanels[i].x << "," << destpanels[i].y << flush;
      cout << "\nbestrefpanel coords : " << bestrpanel.x << "," << bestrpanel.y << "  Error : " << error << flush;
     
    }
  

  // compression done
  // now fractal codes have the fractal information
  // save to file
  
  cout << "\ncompress : writing the fractal codes to filename : " << filename;

  FILE* fp=fopen(filename,"wb");
  fwrite(&cols,sizeof(cols),1,fp);
  fwrite(&rows,sizeof(rows),1,fp);
  fwrite(&dxpanels,sizeof(dxpanels),1,fp);
  fwrite(&dypanels,sizeof(dypanels),1,fp);

  fwrite(fractalcodes,sizeof(fractalcode),ndestpanels,fp);

  fclose(fp);

  cout  << "\nCompress : All the records written to file..." << flush;
  
  
  
}



// __xsize , ysize , xpanels, ypanels --- from original image parameters
void decompress(char* filename)
{ 
  cout << "\ndecompress called..." << flush;
  
  //___routine for reading parameters from file____

  int xsize,ysize,xpanels,ypanels;
  
  FILE* fp=fopen(filename,"rb");
  fread(&xsize,sizeof(xsize),1,fp);
  fread(&ysize,sizeof(ysize),1,fp);
  fread(&xpanels,sizeof(xpanels),1,fp);
  fread(&ypanels,sizeof(ypanels),1,fp);
  int ncodes=xpanels*ypanels;

  fread(fractalcodes,sizeof(fractalcode),ncodes,fp);

  fclose(fp);

  // read params from file

  //  cout << "\ndecompress : no of panels in destination image : " << ncodes << flush;
  
  //  cout  << "\ndecompress:  read the parameters from file ... now decompressing the image ..." << flush;
  
  double scalefactor=cols/xsize;
  int ndestpanels=xpanels*ypanels;
  panelsize=cols/xpanels;
  
  prepareall(panelsize);
  
  preparedestpanels();
  preparerefimage();
  
 
  int i,j,k;

  cout << "\nScale factor : " << scalefactor << "\npanelsize : "<<panelsize << "\n" << flush;
  
  for(i=0;i<ndestpanels;i++)
    {

      //  cout << "\ndecompress : trying to decompress panel no. : " << i << flush;
      
      int x=(int)(scalefactor*fractalcodes[i].x+0.49);
      int y=(int)(scalefactor*fractalcodes[i].y+0.49);
      if(x>=rxpanels) x=rxpanels-1;
      if(y>=rypanels) y=rypanels-1;

      cout << "\nRefpanel no  : " << x+y*rxpanels << " sform : " << fractalcodes[i].s << "\ndestpanel no : " << i << flush;
      panel refpanel=refpanels[x+y*rxpanels];
      panel destpanel=destpanels[i];

      //cout << "\nStarting the double loop for transforming the doman to range block " << flush;
      for(j=0;j<panelsize;j++)
	for(k=0;k<panelsize;k++)
	  {
	    // cout << "\ncalling getrpixel... value of s : " << fractalcodes[i].s << flush;
	    double val=getrpixel(refpanel,j,k,fractalcodes[i].s)+double(fractalcodes[i].beta)/255.0;
	    //double val=rimage[refpanel.y+k][refpanel.x+j]+double(fractalcodes[i].beta)/255.0;
	    
	    if(val<0)
	      val=0;
	    else if
	      (val>1) val=1;

	    //cout << "\ncalling setpixel..." << flush;
	    setpixel(destpanel,j,k,val);    
	  }
    }
  
  // one iteration is finished here
  // repeat this many times to get the final image
  
}

void main()
{
  while(1)
    {
      

      cout << endl << "    MAIN MENU ";
      cout << endl << "---------------";
      cout << endl << "1. Compress image";
      cout << endl << "2. Decompress image";

      cout << endl << "3. Exit";
  
      cout << "\n\n\n";

      cout << "Enter choice :";

      char buffer[80];
      fgets(buffer,79,stdin);
      int choice=atoi(buffer);

      if(choice==3)
	break;
      if(choice<1 || choice>>3)
	continue;

 
      cout  << "\n\nEnter infile : ";
      cin >> infile;
      cout << "\nEnter outfile :";
      cin >> outfile;

      if(choice==1) // compress file
	{
	  readimage(infile);
	  compress(outfile);

	  cout << "\nMain : succesfully returned from function compress " << flush;
	}

      if(choice==2) // decompress image
	{
	  int i;

	  // first read the square image
	  int x,y;
	  cout << "\n Enter xres , yres :" << flush;
	  cin >> x,y;

	  char buffer[80];
	  sprintf(buffer,"convert -scale %dx%d square.gif s.gif",x,y);
	  system(buffer);

	  cout << "\nReading s.gif ( the square image )..." << flush;
	  readimage("s.gif");
	  // this has gone to image array
	  
	  
	  // 8 iterations of decompress
	  for(i=0;i<15;i++)
	    {
	      cout << "\nCalling iteration no : "<< i << flush;
	      decompress(infile);
	      sprintf(buffer,"file%d.gif",i);
	      writeimage(buffer);
	      
	    }
	  
	  // now image is in image
	  
	  cout << "\nWriting the image to : " << outfile << flush;
	  
	  writeimage(outfile);
	  cout << "\nWritten the image to  : " << outfile << flush;
	  
	  cout << "\nCheck it out..." << flush;
	  
	  
	}
      
    }
  
}