#include "Page.h" // Inclou pam.h
#include "Bitmap.h"
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "Errors.h"

Page::Page(const char *filename)
{
	map = NULL;
	hist = NULL;
	text = NULL;
	readMap(filename);
}

Page::~Page()
{
	delete map;
}

void Page::readMap(const char *filename)
{
	FILE *fp;
	int i,j;
	char *image; // FIXME: Good type
	tuple *tuplerow;

	if (!strcmp(filename, "-"))
		fp = stdin;
	else
		// FIXME: exception
		
		if(!(fp = fopen(filename,"r")))
			Errors::Fatal("Cannot open filename.");

	// Si existia un mapa, el borrem.
	if(map != NULL)
		delete map;

	pnm_readpaminit(fp, &pamImage, sizeof(pamImage));
	// FIXME: Read ok

	width = pamImage.width;
	height = pamImage.height;

	map = new Bitmap(width,height);
	tuplerow = pnm_allocpamrow(&pamImage);


	for (i=0; i<height; i++)
	{
		pnm_readpamrow(&pamImage, tuplerow);
		for (j=0; j<width; j++)
		{
			// We only read the first sample (changing 0 and 1)
			map->pixels[i][j] = tuplerow[j][0]?0:1;
		}
	}
	pnm_freepamrow(tuplerow);

	fclose(fp);
}

void Page::writeMap(const char *filename) const
{
	pam outpam;
	FILE *fp;
	tuple *tuplerow;
	int i,j;

	outpam = pamImage;
	outpam.width = width;
	outpam.height = height;
	
	fprintf(stderr,"Writting %s: w:%i,h:%i\n", filename, width, height);

	if (!strcmp(filename, "-"))
		fp = stdout;
	else
		// FIXME: exception
		
		if(!(fp = fopen(filename,"w")))
			Errors::Fatal("Cannot open filename.");

	outpam.file = fp;

	pnm_writepaminit(&outpam);

	tuplerow = pnm_allocpamrow(&outpam);

	for (i=0; i<height; i++)
	{
		for (j=0; j<width; j++)
		{
			// We only write the first sample (changing 0 and 1)
			tuplerow[j][0] = map->pixels[i][j]?0:1;
		}
		pnm_writepamrow(&outpam, tuplerow);
	}
	pnm_freepamrow(tuplerow);
	
	fclose(fp);
}

/*
static void Page::Initialize()
{
	pnm_init(NULL,NULL);
}
*/

float Page::ratioBlackWhite() const
{
	int i,j;
	float white=0, black=0;

	for(i=0; i<height; i++)
		for (j=0; j<width; j++)
			if (map->pixels[i][j] == 0)
				white++;
			else
				black++;
	return black/white;
}

void Page::calcHistogram()
{
	if (hist!=NULL)
		delete hist;

	map->calcHistogram(hist);
}

void Page::rotateMap(float angle)
{
	Bitmap *newmap;
	rotateMap(angle, newmap);

	// Interchange maps: New -> Page's
	delete map;
	map = newmap;

	height = map->get_height();
	width = map->get_width();
}

void Page::rotateMap(float angle, Bitmap* &mapNew)
{
	// Code taken from OCRchie
  int nx,ny,newheight,newwidth,oldheight,oldwidth,i,j,halfnewheight,halfnewwidth;
  int halfoldheight,halfoldwidth;
  double radians;
  double cosval,sinval;

  radians =  -(angle) / ((180 / 3.142));
  cosval = cos(radians);
  sinval = sin(radians);

  oldheight = height;
  oldwidth = width;
  
  newwidth = (int)abs((int)(oldwidth*cosval)) + (int)abs((int)(oldheight*sinval));
  newheight = (int)abs((int)(-oldwidth*sinval)) + (int)abs((int)(oldheight*cosval));

  halfnewheight = newheight / 2;
  halfnewwidth = newwidth / 2;
  halfoldwidth = oldwidth /2;
  halfoldheight = oldheight /2 ;

  int num_chars = (newwidth / 8) + 1;

  mapNew = new Bitmap(newwidth,newheight);
  mapNew->setToZero();

  for(i=0;i < newheight;i++)
      {
        for(j=0;j < newwidth;j++)
            {
              nx =(int)( (j - halfnewwidth)*cosval + (i-halfnewheight)*sinval);
              ny =(int)( -((j - halfnewwidth)*sinval) + (i - halfnewheight)*cosval);
              nx = nx + halfoldwidth;
              ny = ny + halfoldheight;
              if ((nx < oldwidth) && (ny < oldheight) && (nx > 0) && (ny > 0))
                {
		    mapNew->pixels[i][j] = map->pixels[ny][nx];
                }
              else
                  {
		    mapNew->pixels[i][j] = 0;
                  }
            }
      }


}

void Page::tryAngles(float min, float max, float step)
{
	float i;
	float std_dev;


	for(i=min; i<=max; i+=step)
	{
		std_dev = std_dev_lines_angle(i);
		fprintf(stderr, "Angle: %f, Dev: %f\n", i,
			std_dev);
	}
}

float Page::std_dev_lines_angle(float angle)
{
	float retval;

	Bitmap *tmpmap;
	Histogram *tmphist;


	if (angle == 0)
	{
		map->calcHistogram(tmphist);
	}
	else
	{
		rotateMap(angle,tmpmap);
		tmpmap->calcHistogram(tmphist);
		delete tmpmap;
	}

	retval = tmphist->get_std_dev();

	delete tmphist;

	return retval;
}

float Page::getSkew(int depth, float margin)
{
	float x1,x2,x3;
	float y1,y2,y3;
	float newx, newy;
	int i;

	x1 = -margin;
	x2 = 0;
	x3 = margin;

	/* Bret's Method */
	/*
	for (i=0; i<depth; i++)
	{
		y1 = std_dev_lines_angle(x1);
		y2 = std_dev_lines_angle(x2);
		y3 = std_dev_lines_angle(x3);
		fprintf(stderr, "New stddevs: %f, %f, %f\n", y1, y2, y3);

		newx = x2 - 0.5 * ((x2-x1)*(x2-x1) * (y2-y3) -
			(x2-x3)*(x2-x3) * (y2-y1)) /
			((x2-x1) * (y2-y3) - (x2-x3) * (y2-y1));

		// Comprovacions

		// Resultat
		if (newx > x1 && newx < x2)
		{
			x3 = x2;
			x2 = newx;
		}
		else if (newx > x2 && newx < x3)
		{
			x1 = x2;
			x2 = newx;
		}
		else
			Errors::Fatal("No convergence!");
		fprintf(stderr, "Nous punts: %f, %f, %f\n", x1,x2,x3);
	}
	*/

	/* Golden Slice */
	y1 = std_dev_lines_angle(x1);
	y2 = std_dev_lines_angle(x2);
	y3 = std_dev_lines_angle(x3);

	for (i=0; i<depth; i++)
	{

		// Flanc esquerra
		newx = (x2+x1)/2;
		newy = std_dev_lines_angle(newx);

		// Resultat
		if (newy < y2 )
		{
			x1 = newx;
			y1 = newy;
		}
		else // newy < y2
		{
			x3 = x2;
			y3 = y2;
			x2 = newx;
			y2 = newy;
		}

		// Flanc dret
		newx = (x3+x2)/2;
		newy = std_dev_lines_angle(newx);

		// Resultat
		if (newy < y2 )
		{
			x3 = newx;
			y3 = newy;
		}
		else // newy < y2
		{
			x1 = x2;
			y1 = y2;
			x2 = newx;
			y2 = newy;
		}
		fprintf(stderr, "Nous punts: %f, %f, %f\n", x1,x2,x3);
	}
	return x2;
}

void Page::getText()
{
	if (text == NULL)
		text = new Text();

	text->getLines(map);
}