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

 Learn.cc - 

 readlearnfiles - sources the tcl file to change learn files

 learn(char * tifffile, char * asciifile)

 Performs character learning by reading tiff and  ascii translation

 Characters are partitioned into character groups as described 

 in system.cc.  See learn function for more details

 writeLearnedGroups(char * filename) Writes learned character to file

 readLearnedGroups(char * filename) Reads saved learned characters 

                                    from file. 

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

#include "tcl_interface.h"

#include "system.h"

#include "learn.h"

#include "Page.h"

#include "list.h"

void readLearnFiles()

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

Primary Purpose: Sources learnfile.tcl where new learn files can be 

specified without recompiling   **/

{

  docommand("source learnfile.tcl");

}

bool whitespace(char c)

// Returns TRUE if c is a whitespace charater (called by learn.cc)

{

  if ( c == '\n' || c == '\t' || c == ' ') return TRUE;

  return FALSE;

}

bool blank(char * string)

{

  if (string == NULL) return TRUE;

  int len = strlen(string);

  for(int c=0; c< len; c++)

    {

    if (!(whitespace(string[c])))

	return FALSE;

    }

  return TRUE;

}

void printLearnedGroups()

{

  // Just print these guys out to make sure they are ok.

    for(unsigned int i = 0; i < NumCharGroups; i++)   

	for(ListElement * ptr = LearnedGroups[i].first; 

	    ptr != NULL; ptr = ptr->next)

	  { Component * item = (Component *) ptr->item;

	  printf("learned char %s, group %d\n", item->fasciiId, 

			  item->charGroup);

	  }

}

int lengthNextWord(char * buffer,int offset, int buflength)

{

  // counts things in '< >' as one character

  int count;

  for(int c=offset; c < buflength && !(whitespace(buffer[c])); c++)

    {

	 if(buffer[c] == '<')

	   {

	     while((buffer[c] != '>') && (c < buflength))

	       c++;

	     count++;

	   }

	 else

	   count++;

    }

  return count;

}

int learn(Component * comp, char * id, Confidence threshold)

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

Primary Purpose: Make a copy of this component and add it to 

                 LearnedGroups. id is ascii identification.

		 Component will only be learned if confidence

		 is below threshold or if id and asciiid dont match

Arguments: comp - component to learn

                  id - ascii identification

		  threshold - confidence threshold for learning

Return Value: 1 if component was learned, 0 otherwise

Rev: 4/25/96

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

{

  Component * newcomp;

 if (comp->confid() < threshold || !(strcmp(comp->fasciiId, id)))

    {

      newcomp = comp->copy();

      delete newcomp->fasciiId;

      newcomp->fasciiId = new char[strlen(id)+1];

      strcpy(newcomp->fasciiId , id);

      LearnedGroups[newcomp->charGroup].Append(newcomp);

      return 1;

    }

  return 0;

}

void learn(char * tifFile, char * asciiFile, bool synchwords)

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

Primary Purpose:  Learns from TIFF and ascii file.  Groups learned

                  characters by baseline into LearnedGroups and

                   sets properties.

Arguments: tiffFile name of a tiff file to learn from

           asciiFile name of an ascii translation file

Effects:  Assumes a one to one correspondence between each connected

component on a line of the tif file and each character on the corresponding

line of the ascii file. 

Rev:  4/26/96

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

{

  Page * learnPage = new Page;

  initCharBitsSet();

  if(learnPage->readMap(tifFile) != VALID)

    {

      printf("Problem opening the learn image file (file doesn't exist?)\n");

      return;

    }

  learnPage->setLines();

  learnPage->extractComponents(MinHorizSeparation);

  learnPage->extractWords();

  learn(learnPage, asciiFile, synchwords);

  //  delete learnPage; 

}

void learn(Page * learnPage, char * asciiFile, bool synchWords)

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

Primary Purpose:  Learns from a Page and an ascii file.  Used from

                  tcl user interface under File/Learn opation

		  Groups learned

                  characters by baseline into LearnedGroups and

                   sets properties.

Arguments: tiffFile name of a tiff file to learn from

           asciiFile name of an ascii translation file

Effects:  Assumes a one to one correspondence between each connected

component on a line of the tif file and each character on the corresponding

line of the ascii file. 

Rev:  4/26/96

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

{

  FILE * transFile;

  transFile = fopen(asciiFile,"r");

  if(!transFile)

    {

      printf("Could not open the ascii learn file");

      return;

    }

  if (LearnedGroups == NULL)

    LearnedGroups = new Components[NumCharGroups]; 

  int maxCharsPerLine = learnPage->bmap()->imageWidth() / MinLineSize; 

  char buffer[maxCharsPerLine];

  int i = -1;

  int buflength=0;

  bool instring= FALSE;

  bool emptyLine;

  Components * components = NULL;

  Words * words;

  Component * item;

  double width, height = 0.0;

  int h;

      words = learnPage->words();

      int c = 0;

      Word * word;

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

	  (i < learnPage->numLines()) ; ptr = ptr->next)

	{	

	  word = (Word *) ptr->item;

	  // if new line get new  text line

	  if (word->characters[0] == '\n' || buflength == 0)

	    {

	      char * ok;

	      do {

		ok =fgets(buffer, maxCharsPerLine, transFile);

	      } while (ok && blank(buffer)); // skip blank lines.

	      buflength= strlen(buffer);

              components = learnPage->line(++i);

	      c =0;

	      if (word->characters[0] == '\n') continue;

	    }

	  // skip over white space

	  while(whitespace(buffer[c]) && c < buflength)c++;

	  // Make sure we have an equal # of components characters

	  if (synchWords && 

	      (word->charCount == lengthNextWord(buffer,c,buflength)))

	    {

	      // skip over this word

	      while(!(whitespace(buffer[c])) && c < buflength)

		c++;

	      continue; // move on to the next word

	    }

	  for (int ch = 0; ch < word->charCount; ch++) 

	    { 

	      while(whitespace(buffer[c]) && c < buflength)c++;

	      item = word->character[ch]; 

	      if (c >= buflength) break;

		 // Link string translation to component.  Characters between

		 // brackets are for one component.

		   if(buffer[c] == '<' && !instring)

		     {

		       instring = TRUE;

		       int startString = c;

		       while(c++ < buflength && buffer[c] != '>');

		       int endString = c+1;

		       int stringSize = endString - startString;

		       char newstring[stringSize+1];

		       strncpy(newstring, &buffer[startString],stringSize);

		       newstring[stringSize] = '\0';

		       // learn if id's don't match or below threshold

		       learn(item, newstring, ConfidenceThreshold);

		       c++;

		       instring = FALSE;

		     }

		   else

		     {

                       char newstring[2];

      		       newstring[0] = buffer[c++];

		       newstring[1]= '\0';

		       learn(item, newstring, ConfidenceThreshold);

		     }

		   LearnedGroups[item->charGroup].Append(item);

		   //ptr->item = NULL; // Set to Null in page so it wont get

	                    // clobbered on delete

		   h = item->lr().y() - item->ul().y();

		   if (h > height) height = h;

		   width = item->lr().x() - item->ul().x();

		   if (height/width > MaxHWRatio)

		     MaxHWRatio = height/width;

		   if (h/width < MinHWRatio)

		     MinHWRatio = h/width;

		   if (width < MinWidth)

		     MinWidth = (int) width;

		 }

	}

  if (fgets(buffer, maxCharsPerLine, transFile))

      printf("Uh, oh. There are more characters to learn!\n");

  /*  printf("Maximum height/width ratio = %f\n", MaxHWRatio); */

  /*  printf("Minimum height/width ratio = %f\n", MinHWRatio); */

  // printLearnedGroups();

}

int writeLearnedGroups(char * filename)

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

Primary Purpose:  Write Learned groups out to file for reading

                  in by readLearnedGroups

Arguments: filename to write learned chars to 

Return Value: 1 if successful 0 if not

Effects:  Writes contents of LearnedGroups array out to filename

LearnedGroups is an array of lists of components that is decleared

in system.cc and initialized by the learn() function.

For each group writes the number of Components the group contains

followed by the group data.

Other learned values such as MinWidth MinHWRatio etc are written to

the file as well.

Constraints: LearnedGroups must be initialized and filled with learned

chars before this function is invoked.

Rev: 11/27 KM

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

{

  int status;

  FILE * outfile;

  assert(LearnedGroups != NULL);

  outfile = fopen(filename, "w");

  if (outfile == NULL)

      {

	printf("error openning %s \n", filename);

	return 0;

      }

  // Write global information about learned characters

  fwrite(&NumCharGroups, sizeof(NumCharGroups),1, outfile);

  fwrite(&MaxHWRatio, sizeof(MaxHWRatio),1, outfile);

  fwrite(&MinWidth, sizeof(MinWidth),1,outfile);

  fwrite(&MinHWRatio, sizeof(MinHWRatio),1,outfile);

  for(unsigned int i = 0; i < NumCharGroups; i++)   

      {

	unsigned int numChars = LearnedGroups[i].length;

	// Write group number and number of characters

	fwrite(&i, sizeof(i), 1, outfile);

	status = fwrite(&numChars, sizeof(numChars),1,outfile);

	if (status == 0) return 0;

	for(ListElement * ptr = LearnedGroups[i].first; 

	    ptr != NULL; ptr = ptr->next)

	    {

	      Component * comp = (Component *) ptr->item;

	      status = fwrite(comp, sizeof(Component),1,outfile);	     

//	      printf("\tChar:%c status:%d \n", comp->asciiId(), status);

	      int stringSize = strlen(comp->fasciiId) +1;

	      status = fwrite(&stringSize, sizeof(stringSize),1,outfile);

              status = fwrite(comp->fasciiId, stringSize,1,outfile);

	      for(int p = 0; p < numProperties; p++)

		  {

		    status = fwrite(&(comp->fproperty[p]), 

				  sizeof(Property),

				  1, outfile);

		    if (status == 0) 

			{

			  printf("Error writing properties of comp %c",

				 comp->asciiId());

			  return 0;

			}

		  }

	    }

      }

  status = fclose(outfile);

  if (status == -1) return 0;

  else return 1;

}

int readLearnedGroups(char * filename)

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

Primary Purpose:  Read Learned groups from file that has been

                  created by writeLearnedGroups

Arguments: filename to read learned chars from 

Return Value: 1 if successful 0 if not

Effects:  Reads contents of filename into LearnedGroups array

LearnedGroups is an array of lists of components that is decleared

in system.cc and initialized here or in the learn() function.

Constraints: LearnedGroups must not yet be initialized

Rev: 11/27 KM

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

{

  int status;

  FILE * infile;

  unsigned int numGroups;           // # of groups stored in file.

  initCharBitsSet();

  if(LearnedGroups == NULL)

    LearnedGroups = new Components[NumCharGroups];

  infile = fopen(filename, "r");

  if (infile == NULL)

      {

	printf("error openning %s \n", filename);

	return 0;

      }

  // Read Globals

  fread(&numGroups, sizeof(numGroups),1, infile);

  assert(numGroups == NumCharGroups);

  fread(&MaxHWRatio, sizeof(MaxHWRatio),1, infile);

  fread(&MinWidth, sizeof(MinWidth),1,infile);

  fread(&MinHWRatio, sizeof(MinHWRatio),1,infile);

  for(unsigned int i = 0; i < NumCharGroups; i++)   

      {

	unsigned int groupnum;

	unsigned int numChars;

	fread(&groupnum, sizeof(groupnum), 1, infile);

	assert(groupnum == i);

	fread(&numChars, sizeof(numChars),1,infile);

	printf("\nReading group %d - %d characters\n",i,numChars);

	for(unsigned int c = 0; c< numChars; c++)

	    {

	      Component * comp = new Component;

	      short int * savepropptr = comp->fproperty;

	      status = fread(comp, sizeof(Component),1,infile);	     

	      int stringSize;

	      status = fread(&stringSize, sizeof(stringSize),1,infile);

              comp->fasciiId = new  char[stringSize];

              status = fread(comp->fasciiId, stringSize,1,infile);

	      comp->fproperty = savepropptr;

	      for(int p = 0; p < numProperties; p++)

		  {

		    status = fread(&(comp->fproperty[p]), sizeof(Property),

			      1, infile);

		    if (status == 0) 

		      {

			printf("Error reading properties");

			return 0;

		      }

		  }

//	      printf("\tChar:%c status:%d ", comp->asciiId(), status);

//	      printVector(comp->properties(), numProperties);

	      LearnedGroups[i].Append(comp);

	    }

      }

  status = fclose(infile);

  if (status == -1) return 0;

  else return 1;

}

void testLearn()

{

  learn("/amd/nfs/cochise/home/ee/cs169/fa95/class/cs169-ab/train.tif",

	   "/amd/nfs/cochise/home/ee/cs169/fa95class/cs169-ab/train.txt"); 

}

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

  FUNCTIONS BEYOND THIS POINT ARE FOR AVERAGING LEARNED CHARACTERS

  AND ARE NOT CURRENTLY USED.

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

void initLearnedChars()

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

Primary Purpose: Initializes learned character array. Sets asciiId

to array offset.

Rev: KM 11/6/95

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

{

  LearnedChars = new Component[256];

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

    {

      LearnedChars[i].asciiId() = (char)i;

    }

}

void oldlearn(char * tifFile, char * asciiFile)

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

Primary Purpose:  builds property vectors for LearnedChars array

Arguments: tiffFile name of a tiff file to learn from

           asciiFile name of an ascii translation file

Effects:  Assumes a one to one correspondence between each connected

component on a line of the tif file and each character on the corresponding

line of the ascii file.  For learned characters confidence is set

to the number of examples.

Rev:  11/6/95

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

{

  FILE * transFile;

  transFile = fopen(asciiFile,"r");

  Page * learnPage = new Page;

  initCharBitsSet();

  learnPage->readMap(tifFile);

  learnPage->setLines();

  learnPage->extractComponents(MinHorizSeparation);         /* why minlinesize? */

  int maxCharsPerLine = learnPage->bmap()->imageWidth() / MinLineSize; 

  char buffer[maxCharsPerLine];

  int i = 0;

  int buflength;

  bool emptyLine;

  Components * components;

  Component * item;

  int count[256]; // a count of how many of each char have been encountered

  int prop[256][numProperties]; // Character property sums. Need ints so that 

                                 // property sum does

                                // not exceed char boundaries

  char id;

  initLearnedChars();

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

    {

      count[i] = 0;

      for (int p  = 0; p < numProperties; p++)

	prop[i][p] = 0;

    }

  i=0; 

  int offset;

  while (i < learnPage->numLines() &&  

	 fgets(buffer, maxCharsPerLine, transFile))

      {

	buflength = strlen(buffer);

	components = learnPage->line(i++);

	int c = 0;

	for (ListElement* ptr = components->first; ptr != NULL; 

	     ptr = ptr->next) 

	  {

	  item = (Component *)(ptr->item);

	  // skip over white space

	  while(whitespace(buffer[c]) && c < buflength)c++;

	  if (c >= buflength)break;

	  id =  buffer[c++];

	  count[id]++;  // increment character count

	  for (offset=0; offset < numProperties; offset++)

	    prop[id][offset] += (item->properties())[offset];

	  LearnedChars[i].numBits() += item->numBits();

	}

      }

  // now divide by count and put in Learned character

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

      {

	if(count[j] > 0)