/** Page.cc contains the member functions for the primary OCR class Page */

#include "system.h"

#include "Page.h"

#include "convertMap.h"

#include "get_skew.h"

#include "Component.h"

#include "status_message.h"

/*** Member functions of class Page.     ***/

int Page::get_height()

{

  return fRLEMap->imageLength();

}

int Page::get_width()

{

  return fRLEMap->imageWidth();

}

int Page::get_linenum(int col, int row)

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

Primary Purpose: Returns line number of x,y coordinates (just uses y for now)

                 called from proc equation_mark in new_ui.tcl

Return value: line number or -1 if no line is here.

Requires: setLines be run first

Rev: 4/21/96

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

{

  assert (flineinfo != NULL);

  int linenum= -1;

  for (int i = 0; i < fnumLines; i++)

    if (flineinfo[i].fstartrow <= row && flineinfo[i].fendrow >= row)

      {

	linenum = i;

	if (ENABLE_USER_INTERFACE)

	  {

	    // save last mark before it is overwritten

	    docommand("set curline %d",linenum);

	    docommand("set curline_startrow %d",flineinfo[i].fstartrow);

	    docommand("set curline_endrow %d",flineinfo[i].fendrow);

	    // this will change with zoning

	    docommand("set curline_startcol %d",0);

	    docommand("set curline_endcol %d",get_width());

	  }

	break;

      }

return linenum;

}

int Page::send_words_to_tcl()

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

Primary Purpose:  Display words in tcl

Rev - AR

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

{

  int word_count = 0;

  int unknown_char_count = 0;

  int low_precision_count = 0;

  int mispelled_count = 0;

  char* send_chars;

  Word* temp_word;

  if(ENABLE_USER_INTERFACE) set_status("Displaying text");

  for(ListElement* ptr = (words())->first; ptr != NULL; ptr = ptr->next)

    {

      word_count++;

      set_text_display_status(word_count, fWordList->num_words);

      temp_word = (Word*)ptr->item;

      send_chars = backslashify(temp_word->characters);

      /*	printf("Added word %s Confidence = %d\n", send_chars, 

	       temp_word->confid); */

      if(temp_word->confid < VERY_LOW_CONFIDENCE)

	  {

	    docommand("addword \"%s\" %d %d UNKNOWN_CHAR", send_chars, temp_word->ul.x(),  temp_word->ul.y());

	    unknown_char_count++;

	  }

      else if(temp_word->confid < LOW_CONFIDENCE)

	  {

	    docommand("addword \"%s\" %d %d LOW_PRECISION", send_chars, temp_word->ul.x(),  temp_word->ul.y());

	    low_precision_count++;

	  }

      else if((temp_word->mispelled) && SPELLCHECK)

	  {

	    docommand("addword \"%s\" %d %d MISPELLED", send_chars, temp_word->ul.x(),  temp_word->ul.y());

	    mispelled_count++;

	  }

      else

	  {

	    docommand("addword \"%s\" %d %d OK", send_chars, temp_word->ul.x(),  temp_word->ul.y());

	  }

      update();

    }

  if(ENABLE_USER_INTERFACE)

      {

    set_status("Done displaying text");

    set_status("Apparent word accuracy: %.3lf%%", (100 - (100 * ((double)(mispelled_count + unknown_char_count + low_precision_count) / (double)word_count))));

  }

}

int Page::deskew(int deskew_method)

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

Primary Purpose: Deskew the page

Arguments: 1 - RLE Rotation

           0 - BitMap Rotation

Return Value: 1 if successful, 0 if unsuccessful

Effects: updates the bitmap and rlemap of the page

Constraints: RLEMap Rotation is not currently reliable and probably

should not be used

Rev: AR

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

{

  /* a little ugly.... if the page is rotated

     in here, return 1, else 0 */

  if(deskew_method == RLE_DESKEW)

      {

	if(fRLEMap->deskew())

	{

	  convertMap(fRLEMap, fBitMap);

	  return 1;

	}

	return 0;

      }

  else

      {

      double skew = get_skew(fRLEMap);

      if((skew >= MINIMUM_SKEW_ANGLE)||(skew <= - MINIMUM_SKEW_ANGLE))

	  {

	    fBitMap->rotateMap(skew);

	    convertMap(fBitMap, fRLEMap);

	    return 1;

	  }

      return 0;

    }

}

Page::Page()

/**Page::Page - constructor allocates bitmap and rlemap*/

{

  fBitMap = new BitMap;

  fRLEMap = new RLEMap;

  fEqnList = new EqnMarkers;

  fLineComponents = NULL;

  fWordList = NULL;

}

Page::~Page()

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

Primary Purpose:  Destructor deallocates private fields that

have been created.

Rev:

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

{

  if (flineinfo) delete flineinfo;

  for (int  i = 0; i <fnumLines; i++)

        if(fLineComponents[i] != NULL) delete fLineComponents[i];

  if(fLineComponents) delete fLineComponents;

  if (fBitMap) delete fBitMap;

  if (fRLEMap) delete fRLEMap;

  if (fWordList) delete fWordList;

  if (fEqnList) delete fEqnList;

}

Angle Page::skewAngle()

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

Primary Purpose: Determine the angle of rotation of the RLEMap r

Arguments: pointer to an RLEMap

Return Value: detected angle of rotation

Code is in get_skew.cc

Rev: AR

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

{

  return get_skew(fRLEMap);

}

MapStatus Page::readMap(char * filename)

 // Calls BitMap::readMap and then converts

{

  MapStatus status;

  status = fBitMap->readMap(filename);

  convertMap(fBitMap, fRLEMap);

  return status;

}

MapStatus Page::setLines()

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

Primary Purpose:  Set flineinfo array in Page class with the 

      starting and ending rows of each line of text.

      Also sets fnumLines to the number of lines

Arguments: none

Return Value: A Mapstatus either VALID, EMPTY if there is no

   data in the RLEMAP, or OTHERERROR if there is an unexpected error

Effects:  Allocates flineinfo and fills with starting and ending row

   of each line.  The following global variables are used as parameters

   in this function.  These are defined in system.cc

   NoiseTolerance - Rows whose number of pixels is less than  this value

                will be considered empty (current val 6). 

   MinVertSeparation - The minimum number of rows separating lines of text.

                 Lines will be merged if actual Separation is less than this

		 value. (current val 3)

   MinLineSize - The minimum number of rows in a line of text.  

                 Any smaller lines are discarded (currentval 5)

Constraints: Page::readMap() must be run first to fill fRLEMap 

Rev: 10/26 KM

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

{

   int maxrow = fRLEMap->imageLength() - 1;      // maximum row number 

   int actualSeparation = MinVertSeparation + 1; // must be bigger than min

                                                 // for line 0

   int linenum=0;                                // current line number

   int prvlinenum = 0;

   int lineSize;                                 // # rows in current line 

   int maxLines = maxrow/MinLineSize;           // max # of lines of text 

   if(maxrow == 0) return EMPTY;

   flineinfo = new LineMarker[maxLines]; 

   for (int i = 0; i < maxrow;)

	{

	  LineMarker & thisLine = flineinfo[linenum];

	  LineMarker & prevLine = flineinfo[prvlinenum];

	  while (i < maxrow && fRLEMap->row(i)->numPixels < NoiseTolerance)

	    i++;

	  thisLine.fstartrow = i++;

	  while (i < maxrow &&fRLEMap->row(i)->numPixels > NoiseTolerance)

	    i++;

	  lineSize = i - thisLine.fstartrow +1;

	  // If this line is less than MinVertSeparation away

	  //  from the last line.  Join the two together.

	  if (linenum > 0)

	    {

	      actualSeparation = thisLine.fstartrow - prevLine.fendrow;

	    }

	  if (actualSeparation < MinVertSeparation)

	    {

	     // If too small of a separation, add into prev row

	     prevLine.fendrow = i;

	   }

	  else if (lineSize >= MinLineSize)

	    {

	    thisLine.fendrow = i;

/*	    printf (" Line %d  Start: %d  End: %d  lineHeight %d\n", 

	        linenum,thisLine.fstartrow,

	        thisLine.fendrow, 

	        thisLine.fendrow  - thisLine.fstartrow +1);

*/

	    prvlinenum = linenum;

	    linenum++;

	  }

	  if (linenum >= maxLines) return OTHERERROR;

	}

   fnumLines = linenum;   // Set number of lines in page class

   if((ENABLE_USER_INTERFACE) && DISPLAY_LINE_BOUNDARIES)

     {

       display_line_boundaries();

     }

   /*   printf("Setlines found a total of %d lines.\n", fnumLines); */

   if(ENABLE_USER_INTERFACE) 

     update(); 

   return VALID;

 }

void Page::display_line_boundaries()

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

Primary Purpose: Display line boundaries in TCL/TK.  Called from

setLines if ENABLE_USER_INTERFACE and DISPLAY_LINE_BOUNDARIES are

set to TRUE

Effects:  Draws a blue line between each line of text

Rev:  AR

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

{

  int centerline, width;

  for(int j=0; j < fnumLines; j++)

    {

      centerline = (flineinfo[j].fendrow + flineinfo[j + 1].fstartrow) / 2;

      width = flineinfo[j + 1].fstartrow - flineinfo[j].fendrow;

      scale(centerline);

      scale(width);

      /* having this pathname here is probably not such a good idea...*/

      docommand(".main_window.display.work_space create line %d %d %d %d -width %d -fill blue -tags {project_ray IMAGE_TAG} -stipple @/usr/sww/share/tclX-7.3a/tkX/3.6a/demos/bitmaps/grey.25", 0, centerline, bmap()->imageWidth(), centerline, width);

    }

}

int test_rlemap_lines(RLEMap* rmap)

{

  int length = rmap->imageLength();

  for(int i = 0; i < length; i++)

    printf("On line %d, numpixels = %d\n", i, rmap->fMapData[i]->numPixels);

}

MapStatus Page::extractComponents(int horizMerge)

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

                     Component extraction routines.

*

* Given the top and bottom line of a row we want to generate a list of

* components. The general method is to find the closest dot, trace its 

* connected dots, then project upwards and downwards and add anything we 

* find there to the component. We will erase the component from the RLEMap

* as it is added to the component list. By projecting up and down 

* from the piece we first find we should be able

* to completely encompass characters like :;i?|! The only problems are 

* italic or ligatured characters where we may pick up two or more 

* characters at a time (which would be bad) or characters fragmented 

* with a vertical gap.

Primary Purpose: Main extraction routine.

Effects: Makes new components and puts them in a list. Deletes components 

         from RLE map. Fills in component boundaries and calls 

	 Component::setProperties to set the property vector

         Lastly convertMap is run to rebuild the RLEMap

Constraints: Page::setLines() must be run first 

Rev: 4/28/96

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

{

  int currentCol, startRow, endRow, rowHeight;

  ListElement* intrvl;

  ListElement* tempintrvl;

  /*  printf("fnumLines = %d\n", fnumLines); */

  Component* comp;

  int  totalSpacing = 0;  // total blank horizontal pixels between components

  int  baselines[MaxVertSize];     // array for finding the baseline

  last_status = 0.0;

  int compCounter = 0;

  int i;

  int j;

  int upwardBound;      // Projection distances different for equations

  int downwardBound;    // and non-equations

  bool inEqn;          // Variables for finding if the center of a comp

  int centerx;         // is in an equation.

  int centery;

    printf("Extracting Components\n");

   fLineComponents = new Components*[fnumLines];

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

    if(ENABLE_USER_INTERFACE)

      set_component_status(i, fnumLines);

    currentCol = 0;

    startRow = flineinfo[i].fstartrow;

    endRow = flineinfo[i].fendrow;

    rowHeight = endRow - startRow;

    assert(rowHeight > 0);

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

      baselines[j] = 0;

    fLineComponents[i] = new Components();

    while (currentCol<=fRLEMap->imageWidth()) {  //until we reach the end of the page

	//Build component starting with closest black dot

	intrvl = fRLEMap->FindNearHorizDot(currentCol, startRow, endRow);

	if (intrvl == NULL) {

	//  printf("Reached end of line\n");

	  break;

	}

	comp = new Component(); //Make a new component named comp

	assert(comp->AddToComponent(intrvl, fRLEMap, horizMerge));

	//Now we want to extend upwards 

	//First check if there is a blank space to the right 

	tempintrvl =

	  fRLEMap->FindNearHorizDot(comp->lr().x(), startRow, endRow);

	if (tempintrvl != NULL && ((RLEPair*) tempintrvl->item)->start > 

	    comp->lr().x()+horizMerge+1)

	  while (comp->ul().y() < endRow) {

	// find the center of the component to check if we are in an equation

	centerx = (comp->ul().x() + comp->lr().x())/2;

	centery = (comp->ul().y() + comp->lr().y())/2;

 	inEqn = inEquation(centerx, centery);

	// Determine projection distance.  Only project for non Equations.

	if(inEqn)

	  {

	    upwardBound = comp->ul().y()+1;

	    downwardBound = comp->lr().y() - 1;

	  }

	else

	  {

	    upwardBound = startRow;

	    downwardBound = endRow;

	  }

	    intrvl = fRLEMap->FindNearVertDot(comp->ul().x(), 

					      comp->lr().x(), comp->lr().y(),

					      upwardBound);

					      //  startRow);

	    if ((intrvl != NULL) && (!comp->AddToComponent(intrvl, fRLEMap,

							   horizMerge)))

	      break;

	    if (intrvl == NULL) break;

	  }

	else

	  while (comp->ul().y() < endRow) {

       	// find the center of the component to check if we are in an equation

	    centerx = (comp->ul().x() + comp->lr().x())/2;

	    centery = (comp->ul().y() + comp->lr().y())/2;

	    inEqn = inEquation(centerx, centery);

	    // Determine projection distance.  Only project for non Equations.

	    if(inEqn)

	      {

		upwardBound = comp->ul().y()+1;

		downwardBound = comp->lr().y() - 1;

	      }

	    else // regular text

	      {

		upwardBound = startRow;

		downwardBound = endRow;

	      }

	    intrvl = fRLEMap->FindNearVertDot(comp->ul().x(), 

					      comp->lr().x(), comp->ul().y(),

					      upwardBound);

					      // startRow);

	    if ((intrvl != NULL) && (!comp->AddToComponent(intrvl, fRLEMap, 

							   horizMerge)));

	    break;

	    if (intrvl == NULL) break;

	  }

	//Now we want to extend downwards

	while (comp->lr().y() > startRow) {

	  intrvl = fRLEMap->FindNearVertDot(comp->ul().x(), comp->lr().x(), 

						    comp->lr().y(), downwardBound);

	  if ((intrvl != NULL) && (!comp->AddToComponent(intrvl, fRLEMap,

							 horizMerge)))

	    break;

	  if (intrvl == NULL) break;

	}

	// Now we toss out the noise

	int size;

	if (comp != NULL) {

	  if (comp->ul() < Point(0,0))

	    printf("Here's a problem. %d, %d\n", comp->ul().x(), comp->ul().y());

	  else

	    size = fBitMap->pixelsInRegion(comp->ul(), comp->lr());

	}

	  else

	    size = 0;

	Component * prev = (Component *)(fLineComponents[i]->last->item);

	if (size < MinComponentSize) {

//	  printf("Deleting some noise of size %d\n", size);

	  // printComponent(comp);

	  delete comp;

	  comp = NULL;

	}

	else if (prev != NULL && 

		 abs(comp->ul().x() - prev->ul().x()) <= 1 &&

 	         abs(comp->lr().x() == prev->lr().x()) <= 1)

	  {

	    // Check and see if this and the previous component have the

	    // same x boundaries, if so merge the two.  Good for = and :

	    prev->join(comp);

	    prev->setProperties(fBitMap);

	    delete comp;

	    comp ==NULL;

	  }

	else

	    {

	      compCounter++;

	      // display a rectangle around the component

	      if(ENABLE_USER_INTERFACE)

		  {

		    if(DISPLAY_BOUNDING_BOXES)

		      comp->display_bounding_box();

		  }

	  // JMH - make an array of frequency of the y coord of bottom of comp

	      int vertOffset = endRow - comp->lr().y();

	      if(vertOffset < MaxVertSize && vertOffset >= 0)

		baselines[vertOffset]++;

	      comp->setProperties(fBitMap);

	      if(fLineComponents[i]->last != NULL)

		{

		  int thisSpacing = comp->ul().x() - 

		    ((Component *) (fLineComponents[i]->last->item))->lr().x();

		  // if a realy big space, make space the width of this comp

		  if (thisSpacing > 200) 

		  thisSpacing = 2*(comp->lr().x() - comp->ul().x());

		totalSpacing += thisSpacing;

		}

	      fLineComponents[i]->Append(comp);       // add this component to list

	      currentCol = (comp->ul()).x() + 1;   // update position on page

	    }

      }

    // find most popular bottom of comp and call it the baseline

    int counter = 0;

    int baseline;