ccmain/tfacepp.cpp

Go to the documentation of this file.

#include "mfcpch.h"
#ifdef __UNIX__
#include          <assert.h>
#endif
#include          "errcode.h"
#include          "tessarray.h"
//#include                        "fxtop.h"
#include          "werd.h"
#include          "tfacep.h"
#include          "tstruct.h"
#include          "tfacepp.h"
#include          "tessvars.h"
#include          "reject.h"

#define EXTERN

EXTERN BOOL_VAR (tessedit_override_permuter, TRUE, "According to dict_word");
static POLY_MATCHER tess_matcher; //current matcher
static POLY_TESTER tess_tester;  //current tester
static POLY_TESTER tess_trainer; //current trainer
static DENORM *tess_denorm;      //current denorm
static WERD *tess_word;          //current word

#define MAX_UNDIVIDED_LENGTH 24

WERD_CHOICE *recog_word(
                        WERD *word,
                        DENORM *denorm,
                        POLY_MATCHER matcher,
                        POLY_TESTER tester,
                        POLY_TESTER trainer,
                        BOOL8 testing,
                        WERD_CHOICE *&raw_choice,
                        BLOB_CHOICE_LIST_CLIST *blob_choices,
                        WERD *&outword
                       ) {
  WERD_CHOICE *word_choice;
  UINT8 perm_type;
  UINT8 real_dict_perm_type;

  if (word->blob_list ()->empty ()) {
    word_choice = new WERD_CHOICE ("", 10.0f, -1.0f, TOP_CHOICE_PERM);
    raw_choice = new WERD_CHOICE ("", 10.0f, -1.0f, TOP_CHOICE_PERM);
    outword = word->poly_copy (denorm->row ()->x_height ());
  }
  else
    word_choice = recog_word_recursive (word, denorm, matcher, tester,
      trainer, testing, raw_choice,
      blob_choices, outword);
  if ((word_choice->string ().length () !=
    outword->blob_list ()->length ()) ||
  (word_choice->string ().length () != blob_choices->length ())) {
    tprintf
      ("recog_word ASSERT FAIL String:\"%s\"; Strlen=%d; #Blobs=%d; #Choices=%d\n",
      word_choice->string ().string (), word_choice->string ().length (),
      outword->blob_list ()->length (), blob_choices->length ());
  }
  ASSERT_HOST (word_choice->string ().length () ==
    outword->blob_list ()->length ());
  ASSERT_HOST (word_choice->string ().length () == blob_choices->length ());

  /* Copy any reject blobs into the outword */
  outword->rej_blob_list ()->deep_copy (word->rej_blob_list ());

  if (tessedit_override_permuter) {
    /* Override the permuter type if a straight dictionary check disagrees. */
    perm_type = word_choice->permuter ();
    if ((perm_type != SYSTEM_DAWG_PERM) &&
    (perm_type != FREQ_DAWG_PERM) && (perm_type != USER_DAWG_PERM)) {
      real_dict_perm_type = dict_word (word_choice->string ().string ());
      if (((real_dict_perm_type == SYSTEM_DAWG_PERM) ||
        (real_dict_perm_type == FREQ_DAWG_PERM) ||
        (real_dict_perm_type == USER_DAWG_PERM)) &&
        (alpha_count (word_choice->string ().string ()) > 0))
        word_choice->set_permuter (real_dict_perm_type); //Use dict perm
    }
    if (tessedit_rejection_debug && perm_type != word_choice->permuter ()) {
      tprintf ("Permuter Type Flipped from %d to %d\n",
        perm_type, word_choice->permuter ());
    }
  }
  assert ((word_choice == NULL) == (raw_choice == NULL));
  return word_choice;
}


WERD_CHOICE *recog_word_recursive(
                                  WERD *word,
                                  DENORM *denorm,
                                  POLY_MATCHER matcher,
                                  POLY_TESTER tester,
                                  POLY_TESTER trainer,
                                  BOOL8 testing,
                                  WERD_CHOICE *&raw_choice,
                                  BLOB_CHOICE_LIST_CLIST *blob_choices,
                                  WERD *&outword
                                 ) {
  INT32 initial_blob_choice_len;
  INT32 word_length;             //no of blobs
  STRING word_string;            //converted from tess
  ARRAY tess_ratings;            //tess results
  A_CHOICE tess_choice;          //best word
  A_CHOICE tess_raw;             //raw result
  TWERD *tessword;               //tess format
  BLOB_CHOICE_LIST *choice_list; //fake list
                                 //iterator
  BLOB_CHOICE_LIST_C_IT choice_it;

  tess_matcher = matcher;        //install matcher
  tess_tester = testing ? tester : NULL;
  tess_trainer = testing ? trainer : NULL;
  tess_denorm = denorm;
  tess_word = word;
  //      blob_matchers[1]=call_matcher;
  if (word->blob_list ()->length () > MAX_UNDIVIDED_LENGTH) {
    return split_and_recog_word (word, denorm, matcher, tester, trainer,
      testing, raw_choice, blob_choices,
      outword);
  }
  else {
    if (word->flag (W_EOL))
      last_word_on_line = TRUE;
    else
      last_word_on_line = FALSE;
    initial_blob_choice_len = blob_choices->length ();
    tessword = make_tess_word (word, NULL);
    tess_ratings = cc_recog (tessword, &tess_choice, &tess_raw,
      testing
      && tester != NULL /* ? call_tester : NULL */ ,
      testing
      && trainer !=
      NULL /* ? call_train_tester : NULL */ );
                                 //convert word
    outword = make_ed_word (tessword, word);
    if (outword == NULL) {
      outword = word->poly_copy (denorm->row ()->x_height ());
    }
    delete_word(tessword);  //get rid of it
                                 //no of blobs
    word_length = outword->blob_list ()->length ();
                                 //convert all ratings
    convert_choice_lists(tess_ratings, blob_choices); 
                                 //copy string
    word_string = tess_raw.string;
    while (word_string.length () < word_length)
      word_string += " ";        //pad with blanks
    raw_choice = new WERD_CHOICE (word_string.string (),
      tess_raw.rating, tess_raw.certainty,
      tess_raw.permuter);
    word_string = tess_choice.string;
    if (word_string.length () > word_length) {
      tprintf ("recog_word: Discarded long string \"%s\"\n",
        word_string.string ());
      word_string = NULL;        //should never happen
    }
    if (blob_choices->length () - initial_blob_choice_len != word_length) {
      word_string = NULL;        //force rejection
      tprintf ("recog_word: Choices list len:%d; blob lists len:%d\n",
        blob_choices->length (), word_length);
      choice_it.set_to_list (blob_choices); //list of lists
      while (blob_choices->length () - initial_blob_choice_len <
      word_length) {
        choice_list = new BLOB_CHOICE_LIST; //get fake one
        choice_it.add_to_end (choice_list); //add to list
        tprintf ("recog_word: Added dummy choice list\n");
      }
      while (blob_choices->length () - initial_blob_choice_len >
      word_length) {
        choice_it.move_to_last ();
        delete choice_it.extract (); //should never happen
        tprintf ("recog_word: Deleted choice list\n");
      }
    }
    while (word_string.length () < word_length)
      word_string += " ";        //pad with blanks

    assert (raw_choice != NULL);
    if (tess_choice.string)
      strfree(tess_choice.string);
    if (tess_raw.string)
      strfree(tess_raw.string);
    return new WERD_CHOICE (word_string.string (),
      tess_choice.rating, tess_choice.certainty,
      tess_choice.permuter);
  }
}


WERD_CHOICE *split_and_recog_word(
                                  WERD *word,
                                  DENORM *denorm,
                                  POLY_MATCHER matcher,
                                  POLY_TESTER tester,
                                  POLY_TESTER trainer,
                                  BOOL8 testing,
                                  WERD_CHOICE *&raw_choice,
                                  BLOB_CHOICE_LIST_CLIST *blob_choices,
                                  WERD *&outword
                                 ) {
  //   INT32  outword1_len;
  //   INT32  outword2_len;
  WERD *first_word;              //poly copy of word
  WERD *second_word;             //fabricated word
  WERD *outword2;                //2nd output word
  PBLOB *blob;
  WERD_CHOICE *result;           //resturn value
  WERD_CHOICE *result2;          //output of 2nd word
  WERD_CHOICE *raw_choice2;      //raw version of 2nd
  float gap;                     //blob gap
  float bestgap;                 //biggest gap
  PBLOB_LIST new_blobs;          //list of gathered blobs
  PBLOB_IT blob_it;
                                 //iterator
  PBLOB_IT new_blob_it = &new_blobs;

  first_word = word->poly_copy (denorm->row ()->x_height ());
  blob_it.set_to_list (first_word->blob_list ());
  bestgap = -MAX_INT32;
  while (!blob_it.at_last ()) {
    blob = blob_it.data ();
    gap = blob_it.data_relative (1)->bounding_box ().left () -
      blob->bounding_box ().right (); //gap to next
    blob_it.forward ();
    if (gap > bestgap) {
      bestgap = gap;             //find biggest
      new_blob_it = blob_it;     //save position
    }
  }
  new_blobs.assign_to_sublist (&new_blob_it, &blob_it); //take 2nd half
  second_word = new WERD (&new_blobs, 1, NULL); //make it a word
  ASSERT_HOST (word->blob_list ()->length () ==
    first_word->blob_list ()->length () +
    second_word->blob_list ()->length ());

  result = recog_word_recursive (first_word, denorm, matcher,
    tester, trainer, testing, raw_choice,
    blob_choices, outword);
  delete first_word;             //done that one
  result2 = recog_word_recursive (second_word, denorm, matcher,
    tester, trainer, testing, raw_choice2,
    blob_choices, outword2);
  delete second_word;            //done that too
  *result += *result2;           //combine ratings
  delete result2;
  *raw_choice += *raw_choice2;
  delete raw_choice2;            //finished with it

  //   outword1_len= outword->blob_list()->length();
  //   outword2_len= outword2->blob_list()->length();
  outword->join_on (outword2);   //join words
  delete outword2;
  //   if ( outword->blob_list()->length() != outword1_len + outword2_len )
  //      tprintf( "Split&Recog: part1len=%d; part2len=%d; combinedlen=%d\n",
  //          outword1_len, outword2_len, outword->blob_list()->length() );
  //   ASSERT_HOST( outword->blob_list()->length() == outword1_len + outword2_len );
  return result;
}


LIST call_matcher(
                  TBLOB *ptblob,
                  TBLOB *tessblob,
                  TBLOB *ntblob,
                  void *,
                  TEXTROW *
                 ) {
  PBLOB *pblob;                  //converted blob
  PBLOB *blob;                   //converted blob
  PBLOB *nblob;                  //converted blob
  LIST result;                   //tess output
  BLOB_CHOICE *choice;           //current choice
  char string[2];                //char converted
  BLOB_CHOICE_LIST ratings;      //matcher result
  BLOB_CHOICE_IT it;             //iterator

  blob = make_ed_blob (tessblob);//convert blob
  if (blob == NULL)
    return NULL;                 //can't do it
  pblob = ptblob != NULL ? make_ed_blob (ptblob) : NULL;
  nblob = ntblob != NULL ? make_ed_blob (ntblob) : NULL;
  (*tess_matcher) (pblob, blob, nblob, tess_word, tess_denorm, ratings);
  //match it
  delete blob;                   //don't need that now
  if (pblob != NULL)
    delete pblob;
  if (nblob != NULL)
    delete nblob;
  it.set_to_list (&ratings);     //get list
  result = NULL;
  string[1] = '\0';
  for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
    choice = it.data ();
    string[0] = choice->char_class ();
    result = append_choice (result, string,
      choice->rating (), choice->certainty (),
      choice->config ());
  }
  return result;                 //converted list
}


void call_tester(
                 TBLOB *tessblob,
                 BOOL8 correct_blob,
                 char *text,
                 INT32 count,
                 LIST result
                ) {
  PBLOB *blob;                   //converted blob
  BLOB_CHOICE_LIST ratings;      //matcher result

  blob = make_ed_blob (tessblob);//convert blob
  if (blob == NULL)
    return;
  convert_choice_list(result, ratings); //make it right type
  if (tess_tester != NULL)
    (*tess_tester) (blob, tess_denorm, correct_blob, text, count, &ratings);
  delete blob;                   //don't need that now
}


void call_train_tester(
                       TBLOB *tessblob,
                       BOOL8 correct_blob,
                       char *text,
                       INT32 count,
                       LIST result
                      ) {
  PBLOB *blob;                   //converted blob
  BLOB_CHOICE_LIST ratings;      //matcher result

  blob = make_ed_blob (tessblob);//convert blob
  if (blob == NULL)
    return;
  convert_choice_list(result, ratings); //make it right type
  if (tess_trainer != NULL)
    (*tess_trainer) (blob, tess_denorm, correct_blob, text, count, &ratings);
  delete blob;                   //don't need that now
}

---