/* *****************************************************************

  * BitMap.cc - Member functions for a BitMap                      *

  *  because of the complexity of the many Bit functions, they are  *

  *  not all in this file.  In this file are only the following     *

  *  functions:

  *         

  *	BitMap() - Constructor

  *     ~BitMap() - Destructor

  *

  *	int imageLength();

  *	int imageWidth();

  *	MapStatus & status;

  *   	MapStatus readMap(char * filename) ;

  *	MapStatus writeMap(char * filename);

  *

  *	// Data Access and low level manipulation functions  

  *      uchar * row(int i) - Returns a pointer to row i    

  *	 MapStatus setBit(Point point, Color clr);

  *	 Color readBit(Point point);

  *

  *

   ***************************************************************/

#include "BitMap.h"

#include <iostream.h>

#include <stdio.h>

#include "status_message.h"

inline int set_pixel_value(uchar** new_data, int y, int x, int new_val)

{

  new_data[y][x/8] |= (uchar)(new_val << (7-(x%8)));

}

inline int get_pixel_value(uchar** data, int y, int x)

{

  if((data[y][x/8]) & (1 << (7 - (x%8))))

    return 1;

  else

    return 0;

}

BitMap::BitMap()

:fImageWidth(0), fImageLength(0), fStatus(EMPTY), fMapData(NULL)

/*--------------------------------------------------------------

Primary Function: Constructor

Return Value: pointer to new BitMap

Effects: Initialize status to empty other values to zero

Rev: 10/6/95  KM

---------------------------------------------------------------*/

{ };

 BitMap::~BitMap()

/*--------------------------------------------------------------

Primary Purpose: destructor

Effects: Deletes each row of BitPairs then the array of rows

Rev: 10/6/95   KM

---------------------------------------------------------------*/

{

  if (fMapData != NULL)

    {

      int i;

      // delete each row

      for (i=0; i< fImageLength; i++)

	delete fMapData[i];

      // delete array of rows

        delete fMapData;   

    }

};

uchar * BitMap::row(int i)

/*--------------------------------------------------------------

Primary Purpose:  Access a row of the BitMap

Arguments: i is the row to access

Constraints:  i < fImageLength

Rev:  KM 10/15

---------------------------------------------------------------*/

{

  return fMapData[i];

};

MapStatus BitMap::readMap(char * filename)

/*--------------------------------------------------------------

Primary Purpose: Read an BitMap from a TIFF file

Arguments: filename of TIFF file

Return Value: A MapStatus, either VALID or READERROR

Effects:

  *  BitMap::readMap(filename) will read a two level TIFF file

  *  and place it in an BitMap.  The private fields of the BitMap

  *  set are:

         fImageWidth - the pixel width of the image

	 fImageLength - the vertical pixel length of the image

	 fstat - the status after the Read VALID, OTHERERROR,READERROR

         fMapData - an array of pointers to uchar arrays/

Constraints: filename must be a two level TIFF file

Rev: 10/15/95  KM Portions Borrowed from Assignment 1

---------------------------------------------------------------*/

{

  TIFF *tif;

  short photometric;

  // Open File - Read length and width

  tif = TIFFOpen (filename, "r");

  if(tif == NULL)

    { fStatus= OPENERROR;

      return OPENERROR;

    }

  TIFFGetField (tif, TIFFTAG_IMAGELENGTH, &fImageLength);

  TIFFGetField (tif, TIFFTAG_IMAGEWIDTH, &fImageWidth);

  TIFFGetField (tif, TIFFTAG_PHOTOMETRIC, &photometric);

  fMapData = new (uchar *)[fImageLength];

  printf("open succeeded on file %s.  length = %d. width = %d\n",

	 filename, fImageLength, fImageWidth);

  /*  if(photometric == PHOTOMETRIC_MINISWHITE)

       printf("min-is-white format\n");

  else if(photometric == PHOTOMETRIC_MINISBLACK )

    printf("min-is-black format\n"); */

  if((photometric != PHOTOMETRIC_MINISWHITE) && 

     (photometric != PHOTOMETRIC_MINISBLACK))

    printf("with an unknown(!) photometric: %d\n", photometric);

  // Calculate number of chars in a row

  int numChars = (fImageWidth / 8 ) +1 ;

  if(ENABLE_USER_INTERFACE)

    set_status("Reading %s...", filename);

  last_status = 0.0;

  for (int row = 0; row < fImageLength; ++row)

    {

      if(ENABLE_USER_INTERFACE)

	set_read_status(row, fImageLength);

      fMapData[row] = new uchar[numChars];        

      fMapData[row][numChars - 1] = 0;

      TIFFReadScanline(tif,fMapData[row],row,0);

      if(photometric != PHOTOMETRIC_MINISWHITE)

	invertBitsInBuffer(fMapData[row], numChars);

    }

  last_status = 0.0;

  if(ENABLE_USER_INTERFACE)

    set_status("Done reading %s", filename);

  TIFFClose(tif);

  fStatus = VALID; 

  return VALID;

};

MapStatus BitMap::writeTclMap(char * filename, 

			      Point & ul, Point & lr, int scaledown)

{

  FILE *  outfile;

  int numChars= fImageWidth /8 + 1;

  outfile = fopen(filename, "w");

  if(!outfile)

    cout << " Could not open " << filename << endl;

  fprintf(outfile, "%s_width %d\n",filename,fImageWidth);

  fprintf(outfile, "%s_height %d\n",filename,fImageLength);

  fprintf(outfile, "static char %s_bits[] {\n",filename);

  for (int r = 0; r < fImageLength; r++)

      {

	for(int col=0; col < numChars; col++)

	    {

	      fprintf(outfile, "%4#x,", fMapData[r][col]);

	      if (!(r == fImageLength-1 && col == numChars-1))

		fprintf(outfile, " ,");

	      if (((r*numChars + col) % 15)==0)

		fprintf(outfile,"\n");

	    }

      }

  fprintf(outfile,"}\n");

  fclose(outfile);

}

short int BitMap::grayScale(Point & ul, Point & lr)

// Dummy function for now

{

   int numPixels = pixelsInRegion( ul, lr);

   int area = (lr.x() - ul.x()+1) * (lr.y() - ul.y()+1);

   if (area < numPixels) {

     printf("Uh oh! Area = %d and pixels = %d\n", area, numPixels);

     assert(area >= numPixels);

   }

   short int gscale =(short int)(((float)numPixels/area) * 255);

   return gscale;

 };

int BitMap::pixelsInRegion( Point  ul,  Point lr)

{

  assert (ul >= Point(0,0));  /* did someone overload these? */

  if (!(lr <= Point(fImageWidth, fImageLength))) 

       printf("problem\n");

  assert (lr <= Point(fImageWidth, fImageLength));

  if(ul > lr)return 0;

  int ulx = ul.x(); int uly = ul.y();

  int lrx = lr.x(); int lry = lr.y();

  uchar * curRow;

  int pixCount = 0;

  for(int r = uly; r <= lry; r++)

    {

      curRow = row(r);

      // Count middle (whole) characters

      pixCount += pixelsBetween(curRow, ulx, lrx);

//      cout << pixelsBetween(curRow,ulx,lrx) <<" ";

//      cout << pixCount << endl;

    }

  return pixCount;

};

void testBitMap(char * filename)

// Reads in BitMap and prints on screen

{

    BitMap * m = new BitMap;

    m->readMap(filename);

    int numChars = (m->imageWidth() / 8 )+ 1;

    for (int r = 0; r < m->imageLength(); r++){

      for (int c =0; c < numChars; c++) byteprint(m->row(r)[c]);

    printf( "\n");

  }

};

void byteprint(char d) // print bits in a byte, high bit on left

{

  for (int i= 7; i>=0; --i) {

    if ((d>>i)&1) printf("X");

    else printf(" ");

  } 

};

void bitprint(char d, int x)

{

  if ((d>>(7-x))&1) cout << "X";

  else cout << " ";

};

class Page;

void testPixelsInRegion(BitMap * bmap, RLEMap * rmap)

// Reads in file and compares pixelsInRegion to RLEVersion

{

  int bmapcnt, rmapcnt;

  cout << "Testing pixelsInRegion " << endl;

   bmapcnt = bmap->pixelsInRegion(Point(0,0), 

		Point(bmap->imageWidth()-1, bmap->imageLength()-1));

   rmapcnt = rmap->pixelsInRegion(Point(0,0), 

	 Point(rmap->imageWidth()-1, rmap->imageLength()-1));				     

  cout << "For whole page:";

  cout <<" Bitmap-" << bmapcnt << " RLEMap-" << rmapcnt << endl;

  cout << "Start on char edge end on edge (8,8) (16,21) ";  

   bmapcnt = bmap->pixelsInRegion(Point(8,8), Point(16,21));

   rmapcnt = rmap->pixelsInRegion(Point(8,8), Point(16,21));

  cout <<" Bitmap-" << bmapcnt << " RLEMap-" << rmapcnt << endl;

  cout << "Start on char edge, end mid char (0,8) (50,21)";

   bmapcnt = bmap->pixelsInRegion(Point(0,8), Point(50,21));

   rmapcnt = rmap->pixelsInRegion(Point(0,8), Point(50,21));

  cout <<" Bitmap-" << bmapcnt << " RLEMap-" << rmapcnt << endl;

  cout << "Start mid char, end on edge (2,8) (7,21)";

   bmapcnt = bmap->pixelsInRegion(Point(2,8), Point(7,21));

   rmapcnt = rmap->pixelsInRegion(Point(2,8), Point(7,21));

  cout <<" Bitmap-" << bmapcnt << " RLEMap-" << rmapcnt << endl;

  cout << "Start mid char, end mid char (2,8) (9,21)";

   bmapcnt = bmap->pixelsInRegion(Point(2,8), Point(9,21));

   rmapcnt = rmap->pixelsInRegion(Point(2,8), Point(9,21));

  cout <<" Bitmap-" << bmapcnt << " RLEMap-" << rmapcnt << endl;

  cout << "Start and, end same char (2,8) (4,21)";

   bmapcnt = bmap->pixelsInRegion(Point(2,4), Point(4,21));

   rmapcnt = rmap->pixelsInRegion(Point(2,4), Point(4,21));

  cout <<" Bitmap-" << bmapcnt << " RLEMap-" << rmapcnt << endl;

};

MapStatus BitMap::rotateMap(Angle angle) 

/* 

   Thanks to Clint Staley and S. Jacques @calpoly 

   for this bitmap rotation alg.

   copied and slightly modified since it wass a pain getting

   the RLE rotate to work and I think this might be decently

   fast -AR

*/

{

  int nx,ny,newheight,newwidth,oldheight,oldwidth,i,j,halfnewheight,halfnewwidth;

  int halfoldheight,halfoldwidth;

  double radians; 

  double cosval,sinval;

  uchar** newMapData;

  fprintf(stderr,"Rotating Image %lf Degrees\n",angle);

  radians =  -(angle) / ((180 / 3.142));

  cosval = cos(radians);

  sinval = sin(radians);

  oldheight = fImageLength;

  oldwidth = fImageWidth;

  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 ;

  newMapData = new (uchar*) [newheight];

  int num_chars = (newwidth / 8) + 1;

  for (int row = 0; row < newheight; ++row)

      {

	newMapData[row] = new uchar[num_chars];        

	for (int k = 0; k < num_chars; k++)

	  newMapData[row][k] = '\0';

      }

  last_status = 0.0;

  for(i=0;i < newheight;i++)

      {

	if(ENABLE_USER_INTERFACE)

	  set_rotation_status((int)i, (int)newheight);

	for(j=0;j < newwidth;j++)

	    {

/*	      set_pixel_value(newMapData, i, j, 0); 

	      break;  */

	      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))

		{

		  if(get_pixel_value(fMapData, ny, nx))

		    set_pixel_value(newMapData, i, j, 1);

		  else

		    set_pixel_value(newMapData, i, j, 0);

		}

	      else

		  {

		    set_pixel_value(newMapData, i, j, 0);		

		  }

	    }

      }

  if(ENABLE_USER_INTERFACE)

    set_status("Rotating Image: Done");

  last_status = 0.0;

/* free up the old storage */  

  for(i = 0; i < fImageLength; i++)

      {

	free(fMapData[i]);

      }

  free(fMapData);

/* assign pointer, etc to the new stuff */

  fMapData = newMapData;

  fImageLength = newheight;

  fImageWidth = newwidth;

}

/*

int set_pixel_value(uchar** new_data, int y, int x, int new_val)

{

  new_data[y][x/8] |= (uchar)(new_val << (7-(x%8)));

}

int get_pixel_value(uchar** data, int y, int x)

{

  if((data[y][x/8]) & (1 << (7 - (x%8))))

    return 1;

  else

    return 0;

}

*/