#include "system.h"
#include "Component.h"
#include "BitMap.h"
#include <assert.h>
#include "list.h"
#include "tcl_interface.h"

/*** Component.cc
  Member functions for Components 
  Component functions defined in Component.h
  rev 12/9/95 KM
***/


Components::Components()
:List()
{
}


Components::~Components()
{
  for (ListElement *ptr = first; ptr != NULL && ptr->item!=NULL; 
       ptr = ptr->next) {
    if (ptr->item != NULL)
      delete (Component *) (ptr->item);
     }
  while(!IsEmpty())
    Remove();

}


int Component::AddToComponent(ListElement* intrvl, RLEMap* rlemap)
//this needs to be fixed to trap page boundaries
//or else pad the page with a blank line at top and bottom
{
  assert(intrvl != NULL);
  List* list = new List();           //make a new queue
  ListElement* current;
  ListElement* nextelt;
  int counter = 0;
  int currentRow;

  if (intrvl->previous != NULL)
    intrvl->previous->next = intrvl->next;
  else rlemap->fMapData[((RLEPair *) intrvl->item)->row]->first = intrvl->next;
  if (intrvl->next != NULL)
    intrvl->next->previous = intrvl->previous;
  list->first = intrvl;              //put starting interval on queue
  list->last = intrvl;
  list->length = 1;
  intrvl->next = NULL;
  intrvl->previous = NULL;
  currentRow = 0;
  while ((intrvl = list->first) != NULL && 
	 currentRow < rlemap->imageLength()) //Take an interval off queue
    {
      currentRow = ((RLEPair *) intrvl->item)->row;
      for (int i=-1; i < 2; i+=2) { 
	current = rlemap->fMapData[currentRow+i]->first;
	while ((current != NULL) 
	       && (((RLEPair *) current->item)->start <= 
		   ((RLEPair *) intrvl->item)->end+MinHorizSeparation)) {

//	  printf("Looking at an interval on row %d that goes from %d to %d\n",
//		 currentRow, ((RLEPair *) intrvl->item)->start,
//		  ((RLEPair *) intrvl->item)->end);

	  if ((((RLEPair *) current->item)->end 
	       >= ((RLEPair *) intrvl->item)->start-1) 
	      && (((RLEPair *) current->item)->start <= 
		  ((RLEPair *) intrvl->item)->end+MinHorizSeparation)) {
//	  printf("Adding connection for interval on row %d that goes from %d to %d\n", currentRow+i,
//		 ((RLEPair *) current->item)->start,
//		  ((RLEPair *) current->item)->end);
	
	    if (current->previous != NULL)
	      current->previous->next = current->next;   //take off RLEMap
	    else
	      rlemap->fMapData[currentRow+i]->first = current->next;
	    if (current->next != NULL)
	      current->next->previous = current->previous;
	    nextelt = current->next;
	    list->last->next = current;                //add to queue
	    current->previous = list->last;
	    list->last = current;
	    current->next = NULL;
	    current = nextelt;
	    list->length++;
	  } else
	    current = current->next;
	}
      }
      
      if ((((RLEPair *) intrvl->item)->start < ful.x()) || (ful.x()==-1)) {
	ful.x() = ((RLEPair *) intrvl->item)->start;
//	printf("Changed ful.x to %d\n", ful.x());
      }
      if ((((RLEPair *) intrvl->item)->end > flr.x()) || (flr.x()==-1)) {
	flr.x() = ((RLEPair *) intrvl->item)->end;
//	printf("Changed flr.x to %d\n", flr.x());
      }
      if ((((RLEPair *) intrvl->item)->row < ful.y()) || (ful.y()==-1)) {
	ful.y() = ((RLEPair *) intrvl->item)->row;
//	printf("Changed ful.y to %d\n", ful.y());
      }
      if ((((RLEPair *) intrvl->item)->row > flr.y()) || (flr.y()==-1)) {
	flr.y() = ((RLEPair *) intrvl->item)->row;
//	printf("Changed flr.y to %d\n", flr.y());
      }      
      list->first = intrvl->next;
      if (intrvl->next != NULL)
	intrvl->next->previous = NULL;
      delete ((RLEPair *) (intrvl->item));
      delete intrvl;               //so the letter O won't go forever
      counter++;
      list->length--;
    }

  delete list;
  return counter;

}

void Component::setProperties(BitMap * map)  // was BitMap
/*--------------------------------------------------------------
Primary Purpose: Set the property vector for this component
Arguments:  The BitMap to which this component belongs
Return Value:
Effects: The component is divided into a 5 by 5 grid.  A gray
    scale (0 - 255) for each section is determined.  The gray scale
    is 0 for all white, 255 for all black, but normally will be somewhere
    between the two.  The gray scales are represented in properties
    0-24. 
    Property 25 is the grayscale accross the top.
    Property 26 is the grayscale accross the bottom.
    Property 27 is the width/height ratio again scaled to (0-255)
    Actually the formula for property 27 is
        width/ height * 255  if height > width
        1- height/width * 255 if width > height
    This way near 0 is very tall and thin
             near 128 height near width
	     near 255 very wide
    Property 28 is  Indicator of a vertically disjoint character
     like i and j.
    Also the total number of black pixels is set in fnumBits.
    // This is not used at this time.    
Constraints: The data fields ful and flr must already be set 
   before calling this function. These fields specify a bounding
   box for the character within the BitMap.
Rev: 12/9 KM
---------------------------------------------------------------*/
{
  if (ful > flr) 
    printf("Problem\n");
  assert (ful <= flr);
  short int hflag[NumHorizDiv + 1];  // flags horizontal section dividers
  short int vflag[NumVertDiv + 1];   // flags vertical section dividers
  float height, width;
  int propNum;
  float darkest = 0;
  float lightest; 
  int darkrow = 0;
  int lightrow = 0;

  Point sectionLr, sectionUl;
  // Set Number of bits
  fnumBits = map->pixelsInRegion(ful, flr);

  setSectionFlags(hflag, vflag);
  for (int r = 0; r < NumVertDiv; r++)
    for (int c = 0; c < NumHorizDiv; c++)
      {
	propNum = (r * NumHorizDiv) + c;
	sectionUl = Point(hflag[c], vflag[r]);
	sectionLr = Point(hflag[c+1]-1, vflag[r+1]-1);
	if (sectionUl <= sectionLr)
	  fproperty[propNum] = map->grayScale(sectionUl, sectionLr); 
	assert(fproperty[propNum] >= 0 && fproperty[propNum] < 256);
      }

  // set the height/width ratio
  // 0 is very thin 128 is even 256 is very wide.
  width = flr.x() - ful.x() + 1;
  height = flr.y() - ful.y() + 1;
 
  // Grayscale across the top - Indicator of top bar
  sectionUl = Point(ful.x(), ful.y());
  sectionLr = Point(flr.x(), ful.y() + (int)(height/(NumVertDiv*2)));
  fproperty[25] = map->grayScale(sectionUl, sectionLr);

   // Grayscale across bottom - Indicator of a foot for l opposed to 1
  sectionUl = Point(ful.x(),  flr.y() -  (int)(height/(NumVertDiv*2)));
  sectionLr = Point(flr.x(),  flr.y());
  fproperty[26] = map->grayScale(sectionUl, sectionLr);

  float hdivw = (float)height/width;
  float wdivh = (float) width/height;
  if (width > height)
       fproperty[27]= (short int) ((1- hdivw/2)*255);
  else
    fproperty[27] = (short int)((wdivh/2)* 255);

  // is this a disjoint character like i or j  255 = yes 0 = no
  fproperty[28]=0;
  lightest = width;
  for(int row = ful.y(); row < flr.y(); row++)
      {
	int pixelsThisRow = pixelsBetween(map->row(row), ful.x(), flr.x());
	if(!(pixelsThisRow))
	      fproperty[28]=255;
      }

  fproperty[29]= 0;
    for(int p = 0; p < numProperties; p++)	
      assert(fproperty[p] >= 0 && fproperty[p] < 256);


}

void Component::setSectionFlags(short int hflag[], short int vflag[])
/*--------------------------------------------------------------
Primary Purpose: Breaks this component into a grid NumHorizDiv X NumVertDiv
    for determining grayscale property vectors.
Arguments:  hflag[] is an empty array to be filled by this procedure with
    the starting columns of each horizontal subdivision.  vflag[] will
    be filled with the vertical subdivisions.
Effects:  fills hflag[] with the starting column for each subdivision.
     The last element of the array is actually the pixel immediately 
     following the last  subdivision.  The last subdivision contains any 
     remaining pixels that did not divide evenly amongst the divisions.
     vflag[NumHorizDiv] is comparable for vertical supdivisions.
     Example ful = (0,25) flr = (52,46) NumHorizDiv = NumVertDiv = 5
         hflag[6] = { 0,10,20,30,40,53 }
	 vflag[6] = {25.29.33.37.41.47 } 
Constraints: ful and flr must be set to mark the bounding box before
   calling this procedure.
Rev:  10/27 KM
---------------------------------------------------------------*/
{
  int ulx = ful.x();  int uly = ful.y();
  int lrx = flr.x();  int lry = flr.y();

  int width =  lrx - ulx+1;
  int height = lry - uly+1;

  int horizDiv = width/NumHorizDiv;
  int vertDiv = height/NumVertDiv;

  int horizExtra = width - horizDiv*NumHorizDiv;
  int vertExtra = height - vertDiv*NumVertDiv;

  int i, add;
  for (i = 0; i < NumHorizDiv; i++)
    {
    if(horizExtra - i > 0) add = i; else add = horizExtra;
    hflag[i] = ulx + (i*horizDiv)+ add;
  }
  hflag[i] = lrx + 1;              // Closes off last division

  int j;
  for(j = 0; j < NumVertDiv; j ++)
      {
    if(vertExtra - j > 0) add = j; else add = vertExtra;
    vflag[j] = uly + (j*vertDiv)+ add;
  }
  vflag[j] = lry + 1;

    


}


Distance Component::distance(Component * comp) 
/*--------------------------------------------------------------
Primary Purpose: Determines heuristic distance between two components
Arguments:  Another component to compare
Return Value: integer value which represents the distance between two 
   components. Distance = sum over i of
                       weight *square (this->fproperty[i] - comp->fproperty[i])
		       weight for i == 27, 28 is 3 weight is 1 for all other 
		       properties
Constraints: setProperties must have been run on both components

Rev: 11/1 KM
---------------------------------------------------------------*/
{
  Property * a = fproperty;
  Property * b = comp->properties();
  Distance dist=0;
  int dif=0;
  int worst = 0;
  int weight = 1;

  for(int i= 0; i < numProperties; i++)
    { 


     if (i == 27 || i == 28) weight = 3;
     else weight = 1;
     
       dif = (a[i] - b[i]);      
      dist += weight*dif*dif;
    }

  return dist;
}









void printVector(short int vector[], int size)
{
  for (int i = 0; i < size; i++)
    cout << vector[i] << " " ;
  cout << endl;

}


void testProperties(Component* c, BitMap * map)
{
  short int hflag[NumHorizDiv + 1];  // flags horizontal section dividers
  short int vflag[NumVertDiv + 1];   // flags vertical section dividers

  cout << "First test subDivisions  " << endl;
  c->setSectionFlags(hflag, vflag);
  cout << "Horizontal flags" <<endl;
  printVector(hflag, NumHorizDiv + 1);
  cout << "Vertical flags" <<endl;
  printVector(vflag, NumHorizDiv + 1);

  cout << "Now lets look at the properties " << endl;
  // setSectionFlags will actually get called again within setProperties
  c->setProperties(map);
  printVector(c->properties(), NumHorizDiv*NumVertDiv + 1);
  cout << endl << " The distance of this component from itself: " << " ";
  cout << c->distance(c) << endl;

}

void Component::display_bounding_box()
{
  int ulx = (ul()).x();
  int uly = (ul()).y();
  int lrx = (lr()).x();
  int lry = (lr()).y();
  scale(ulx); scale(uly); scale(lrx); scale(lry);
  
  docommand(".main_window.display.work_space create rectangle %d %d %d %d -outline blue -tags IMAGE_TAG",  ulx, uly, lrx, lry);
}  

Distance Component::recognize(Component * learnedchars)
// This is out of date. Current recognize is below
{
  Distance d, nextd;
  char id;

//  printf("Another call to recognize\n");
  d = (256*256)*numProperties;  // this is the biggest distance
                        

	       
    for (int i = 0; i < 256; i++)
	{
	  if(learnedchars[i].confid() != 0)
	      {
		nextd = distance(&learnedchars[i]);
//		printf("Distance = %d, character = %c\n", nextd, i);
		if (nextd < d)
		    {
		      d = nextd;
		      id = (char) i;
		    }
	      }
	  
	}
  
  fasciiId = id;
  /*  printf("Recognized a Component: %c\n", id); */
  return d;
}


Distance Component::recognize(Components * learnedgroups, bool allGroups)
{
  Distance d, worstDistance,nextd;
  char id;
  short int fontid;
  float tempd;
  worstDistance = 150000;

//  printf("Another call to new recognize\n");
  d = (65536)*numProperties;  // this is the biggest distance
  
                        
    fconfid = 0;

    for(int g = 0; g < NumCharGroups &&
 	((fconfid < ConfidenceThreshold) || allGroups); g++)
    {
      int offset = (charGroup+g) % NumCharGroups;
      if (offset == 4 && charGroup != 4) continue;
      for (ListElement* ptr = learnedgroups[offset].first; ptr != NULL;
	 ptr = ptr->next)
	{
	  Component * item = (Component *) ptr->item;
	  nextd = distance(item);
//	  printf("Distance = %d, character = %c\n", nextd, i);
	  if (nextd < d)
	      {
		d = nextd;
		id = item->fasciiId;
		fontid = item->ffontId;
	      }

	}

      if (d >= worstDistance) 
	  tempd = worstDistance - 1;
      else tempd = d;
	
	fconfid = (unsigned short int)
	  (255 - (tempd/worstDistance)*256);
      if(charGroup == 4) break;  // dont check other groups for floaters
    }
  

  fasciiId = id;


  ffontId = fontid;
//  printf("Recognized a Component: %c in font#%d  %d %u\n", 
//	 id, fontid, fconfid, d);



  return d;
}



int Component::vertShrink(BitMap * bitmap)
{
  int r;
  int shrunk = 0;
	for(r = ful.y(); r < flr.y(); r++)
	      if (pixelsBetween(bitmap->row(r), ful.x(), flr.x()))
		  {
		    ful.y() = r;
		    shrunk = 1;
		    break;
		  }
	for(r = flr.y(); r > ful.y(); r--)
	      if (pixelsBetween(bitmap->row(r), ful.x(), flr.x()))
		  {
		    flr.y() = r;
		    shrunk = 1;
		    break;		    
		  }
		
  return shrunk;
      }