ccmain/output.h File Reference

#include "varable.h"
#include "pageres.h"
#include "notdll.h"

Go to the source code of this file.

Functions

• BOOL8 acceptable_number_string (const char *s)

  Rules for determining if string is a valid number (of some kind).
  

• INT16 count_alphanums (const char *s)

  Count number of isalphanum()s in string.
  

• INT16 count_alphas (const char *s)

  Count number of isalpha()s in string.
  

• char determine_newline_type (WERD *word, BLOCK *block, WERD *next_word, BLOCK *next_block)

  Find whether we have a wrapping or hard newline.
  

• void ensure_rep_chars_are_consistent (WERD_RES *word)

  Enforce repeating characters acceptable.
  

• char get_rep_char (WERD_RES *word)

  Return the first accepted character from the repetition string.
  

• WERD_CHOICE * make_epaper_choice (WERD_RES *word, char newline_type)

  Convert one word.
  

• INT16 make_reject (BOX *inset_box, INT16 prevright, INT16 nextleft, DENORM *denorm, char word_string[])

  Add the escape code to the string for the reject.
  

• FILE * open_outfile (const char *extension)

  Open .map & .unlv file.
  

• void output_pass (PAGE_RES_IT &page_res_it, BOOL8 write_to_shm)

  Tess output to pass to file or API.
  

• void set_unlv_suspects (WERD_RES *word)

  Modifies reject_map of word based on suspect_level.
  

• void write_cooked_text (WERD *word, const STRING &text, BOOL8 acceptable, BOOL8 pass2, FILE *fp)

  Write the cooked text (with bold for pass2 and underline for reject) to the given file.
  

• void write_map (FILE *mapfile, WERD_RES *word)

  Generates a map file, approx a 'cmp -l' of .txt file and .etx file.
  

• void write_results (PAGE_RES_IT &page_res_it, char newline_type, BOOL8 force_eol, BOOL8 write_to_shm)

  All recognition and rejection has now been done so write out word.
  

• void write_shm_text (WERD_RES *word, BLOCK *block, ROW_RES *row, const STRING &text)

  Write the cooked text to the shared memory for the api.
  

• void write_unlv_text (WERD_RES *word)

  Write text to .unlv file.
  

---

Function Documentation

BOOL8 acceptable_number_string

(

const char *

s

)

Rules for determining if string is a valid number (of some kind).

Parameters:

s

String

Returns:

TRUE if string matches what COULD be a number

Definition at line 1216 of file output.cpp.

References FALSE, and TRUE.

Referenced by set_unlv_suspects().

                                              { 
  BOOL8 prev_digit = FALSE;

  if (*s == '(')
    s++;

  if ((*s == '$') || (*s == '.') || (*s == '+') || (*s == '-'))
    s++;

  for (; *s != '\0'; s++) {
    if (isdigit (*s))
      prev_digit = TRUE;
    else if (prev_digit && ((*s == '.') || (*s == ',') || (*s == '-')))
      prev_digit = FALSE;
    else if (prev_digit &&
      (*(s + 1) == '\0') && ((*s == '%') || (*s == ')')))
      return TRUE;
    else if (prev_digit &&
      (*s == '%') && (*(s + 1) == ')') && (*(s + 2) == '\0'))
      return TRUE;
    else
      return FALSE;
  }
  return TRUE;
}

INT16 count_alphanums

(

const char *

s

)

Count number of isalphanum()s in string.

Parameters:

s

String

Returns:

count of characters that are alphanumbs

Definition at line 1198 of file output.cpp.

References count().

                                     {
  int count = 0;

  for (; *s != '\0'; s++) {
    if (isalnum (*s))
      count++;
  }
  return count;
}

INT16 count_alphas

(

const char *

s

)

Count number of isalpha()s in string.

Parameters:

s

String

Returns:

count of characters that are alphas

Definition at line 1180 of file output.cpp.

References count().

Referenced by set_unlv_suspects().

                                  {
  int count = 0;

  for (; *s != '\0'; s++) {
    if (isalpha (*s))
      count++;
  }
  return count;
}

char determine_newline_type	(	WERD *	word,
		BLOCK *	block,
		WERD *	next_word,
		BLOCK *	next_block
	)

Find whether we have a wrapping or hard newline.

Parameters:

	word	word to do
	block	current block
	next_word	next word
	next_block	block of next word

Returns:

FALSE if not at end of line.

Definition at line 613 of file output.cpp.

References WERD::bounding_box(), CTRL_HARDLINE, CTRL_NEWLINE, FALSE, WERD::flag(), BOX::left(), NULL, BOX::right(), WERD::space(), and W_EOL.

Referenced by output_pass().

                             {
  INT16 end_gap;                 // to right edge
  INT16 width;                   // of next word
  BOX word_box;                  // bounding
  BOX next_box;                  // next word
  BOX block_box;                 // block bounding

  if (!word->flag (W_EOL))
    return FALSE;                // not end of line
  if (next_word == NULL || next_block == NULL || block != next_block)
    return CTRL_NEWLINE;
  if (next_word->space () > 0)
    return CTRL_HARDLINE;        //it is tabbed
  word_box = word->bounding_box ();
  next_box = next_word->bounding_box ();
  block_box = block->bounding_box ();
                                 //gap to eol
  end_gap = block_box.right () - word_box.right ();
  end_gap -= (INT32) block->space ();
  width = next_box.right () - next_box.left ();
  //      tprintf("end_gap=%d-%d=%d, width=%d-%d=%d, nl=%d\n",
  //              block_box.right(),word_box.right(),end_gap,
  //              next_box.right(),next_box.left(),width,
  //              end_gap>width ? CTRL_HARDLINE : CTRL_NEWLINE);
  return end_gap > width ? CTRL_HARDLINE : CTRL_NEWLINE;
}

void ensure_rep_chars_are_consistent

(

WERD_RES *

word

)

Enforce repeating characters acceptable.

And this means what?

Definition at line 1059 of file output.cpp.

References WERD_RES::best_choice, and get_rep_char().

Referenced by write_results().

                                                     { 
  char rep_char = get_rep_char (word);
  char *ptr;

  ptr = (char *) word->best_choice->string ().string ();
  for (; *ptr != '\0'; ptr++) {
    if (*ptr != rep_char)
      *ptr = rep_char;
  }
}

char get_rep_char

(

WERD_RES *

word

)

Return the first accepted character from the repetition string.

Parameters:

word

Word

This is the character which is repeated, as determined earlier by fix_rep_char()

Definition at line 1040 of file output.cpp.

References WERD_RES::best_choice, REJMAP::length(), and WERD_RES::reject_map.

Referenced by ensure_rep_chars_are_consistent(), make_epaper_choice(), and write_results().

                                  {
  int i;

  for (i = 0;
    ((i < word->reject_map.length ()) &&
    (word->reject_map[i].rejected ())); i++);
  if (i < word->reject_map.length ())
    return word->best_choice->string ()[i];
  else
    return STRING (unrecognised_char)[0];
}

WERD_CHOICE* make_epaper_choice	(	WERD_RES *	word,
		char	newline_type
	)

Convert one word.

Parameters:

	word	word to do
	newline_type	type of newline

Returns:

word

Construct the epaper text string for a word, using the reject map to determine whether each blob should be rejected.

Definition at line 439 of file output.cpp.

References ASSERT_HOST, WERD_RES::best_choice, WERD::blob_list(), PBLOB::bounding_box(), WERD_RES::denorm, FALSE, WERD::flag(), get_rep_char(), REJMAP::length(), make_reject(), MAX_PATH, NO_PERM, WERD_RES::outword, WERD_RES::reject_map, BOX::right(), WERD::space(), tprintf(), TRUE, W_REP_CHAR, and WERD_RES::word.

Referenced by write_results().

                                 {
  INT16 index = 0;               //to string
  INT16 blobindex;               //to word
  INT16 prevright = 0;           //right of previous blob
  INT16 nextleft;                //left of next blob
  PBLOB *blob;
  BOX inset_box;                 //bounding box
  PBLOB_IT blob_it;              //blob iterator
  char word_string[MAX_PATH];    //converted string
  BOOL8 force_total_reject;
  char unrecognised = STRING (unrecognised_char)[0];

  blob_it.set_to_list (word->outword->blob_list ());

  ASSERT_HOST (word->reject_map.length () ==
    word->best_choice->string ().length ());
  /*
  tprintf( "\"%s\" -> length: %d;  blobcount: %d (%d)\n",
      word->best_choice->string().string(),
        word->best_choice->string().length(),
      blob_it.length(),
        blob_count( word->outword ) );
  */

  if (word->best_choice->string ().length () == 0)
    force_total_reject = TRUE;
  else {
    force_total_reject = FALSE;
    ASSERT_HOST (blob_it.length () ==
      word->best_choice->string ().length ());
  }
  if (!blob_it.empty ()) {
    for (index = 0; index < word->word->space (); index++)
      word_string[index] = ' ';  //leading blanks
  }
  /*
  Why does this generate leading blanks regardless of whether the
  word_choice string is empty, when write_cooked_text only generates leading
  blanks when the string is NOT empty???. 
  */

  if (word->word->flag (W_REP_CHAR) && tessedit_write_rep_codes) {
    strcpy (word_string + index, "|^~R");
    index += 4;
    word_string[index++] = get_rep_char (word);
  }
  else {
    if (!blob_it.empty ())
      prevright = blob_it.data ()->bounding_box ().left ();
    //actually first left
    for (blobindex = 0, blob_it.mark_cycle_pt ();
    !blob_it.cycled_list (); blobindex++, blob_it.forward ()) {
      blob = blob_it.data ();
      if (word->reject_map[blobindex].accepted ()) {
        if (word->best_choice->string ()[blobindex] == ' ')
          word_string[index++] = unrecognised; // but not rejected!!
        else
          word_string[index++] =
            word->best_choice->string ()[blobindex];
      }
      else {
        inset_box = blob->bounding_box (); // start reject
        /* Extend reject box to include rejected neighbours */
        while (!blob_it.at_last () &&
          (force_total_reject ||
        (word->reject_map[blobindex + 1].rejected ()))) {
          blobindex++;
          blob = blob_it.forward ();
          inset_box += blob->bounding_box (); // get total box
        }
        if (blob_it.at_last ())
          nextleft = inset_box.right ();
        else
          nextleft = blob_it.data_relative (1)->bounding_box ().left ();

        //       tprintf("Making reject from (%d,%d)->(%d,%d)\n",
        //          inset_box.left(),inset_box.bottom(),
        //          inset_box.right(),inset_box.top());

        index += make_reject (&inset_box, prevright, nextleft,
          &word->denorm, &word_string[index]);
      }
      prevright = blob->bounding_box ().right ();
    }
  }
  if (newline_type)
    word_string[index++] = newline_type; // end line
  word_string[index] = '\0';     // terminate string
  if (strlen (word_string) != index) {
    tprintf ("ASSERT ABOUT TO FAIL: %s, index %d len %d\n",
      word_string, index, strlen (word_string));
  }
  ASSERT_HOST (strlen (word_string) == index); // don't pass any zeros
  return new WERD_CHOICE (word_string, 0, 0, NO_PERM);
}

INT16 make_reject	(	BOX *	inset_box,
		INT16	prevright,
		INT16	nextleft,
		DENORM *	denorm,
		char	word_string[]
	)

Add the escape code to the string for the reject.

Parameters:

	inset_box	bounding box
	prevright	previous char
	nextleft	next char
	denorm	de-normalizer
	word_string	output string

Definition at line 548 of file output.cpp.

References BOX::bottom(), CTRL_INSET, BOX::left(), BOX::right(), DENORM::row(), BOX::top(), DENORM::x(), ROW::x_height(), and DENORM::y().

Referenced by make_epaper_choice().

  {
  INT16 index;                   // to string
  INT16 xpos;                    // start of inset
  INT16 ypos;
  INT16 width;                   // size of inset
  INT16 height;
  INT16 left_offset;             // shift form prev char
  INT16 right_offset;            // shift to next char
  INT16 baseline_offset;         // shift from baseline
  INT16 inset_index = 0;         // number of inset
  INT16 min_chars;               // min width estimate
  INT16 max_chars;               // max width estimate
  float x_centre;                // centre of box

  index = 0;
  x_centre = (inset_box->left () + inset_box->right ()) / 2.0;
  left_offset =
    (INT16) (denorm->x (inset_box->left ()) - denorm->x (prevright));
  right_offset =
    (INT16) (denorm->x (nextleft) - denorm->x (inset_box->right ()));
  xpos = (INT16) floor (denorm->x (inset_box->left ()));
  width = (INT16) ceil (denorm->x (inset_box->right ())) - xpos;
  ypos = (INT16) floor (denorm->y (inset_box->bottom (), x_centre));
  height = (INT16) ceil (denorm->y (inset_box->top (), x_centre)) - ypos;
  baseline_offset = ypos - (INT16) denorm->y (bln_baseline_offset, x_centre);
  word_string[index++] = CTRL_INSET; // escape code
  min_chars = (INT16) ceil (0.27 * width / denorm->row ()->x_height ());
  max_chars = (INT16) floor (1.8 * width / denorm->row ()->x_height ());
  /*
  Ensure min_chars and max_chars are in the range 0..254. This ensures that
  we can add 1 to them to avoid putting \0 in a string, and still not exceed
  the max value in a byte.
  */
  if (min_chars < 0)
    min_chars = 0;
  if (min_chars > 254)
    min_chars = 254;
  if (max_chars < min_chars)
    max_chars = min_chars;
  if (max_chars > 254)
    max_chars = 254;
  word_string[index++] = min_chars + 1; // min chars
  word_string[index++] = max_chars + 1; // max chars
  word_string[index++] = 2;      //type?
  word_string[index++] = inset_index / 255 + 1; // store index
  word_string[index++] = inset_index % 255 + 1;
  return index;                  // size of string
}

FILE* open_outfile

(

const char *

extension

)

Open .map & .unlv file.

Parameters:

extension

MSDOS extension, added to imagebasename

Note:

Global: imagebasename

Returns:

file handle to file

Definition at line 952 of file output.cpp.

References CANTOPENFILE, ERRCODE::error(), EXIT, imagebasename, and STRING::string().

Referenced by output_pass().

                                          {
  STRING file_name;
  FILE *outfile;

  file_name = imagebasename + extension;
  if (!(outfile = fopen (file_name.string (), "w"))) {
    CANTOPENFILE.error ("open_outfile", EXIT, "%s %d",
      file_name.string (), errno);
  }
  return outfile;
}

void output_pass	(	PAGE_RES_IT &	page_res_it,
		BOOL8	write_to_shm
	)

Tess output to pass to file or API.

Definition at line 122 of file output.cpp.

References BLOCK_RES::block, PAGE_RES_IT::block(), check_debug_pt(), cprintf(), determine_newline_type(), FALSE, PAGE_RES_IT::forward(), PAGE_RES_IT::next_block(), PAGE_RES_IT::next_word(), NO_BLOCK, NULL, ocr_send_text(), open_outfile(), PAGE_RES_IT::restart_page(), textfile, txt_mapfile, unlv_file, WERD_RES::word, PAGE_RES_IT::word(), and write_results().

                                     {
  BLOCK_RES *block_of_last_word;
  INT16 block_id;
  BOOL8 force_eol;               // During output
  BLOCK *nextblock;              // block of next word
  WERD *nextword;                // next word

#ifdef TEXT_VERBOSE
  // gets a 'w', see ccmain/tesseractmain.dox
  cprintf("w");
#endif
  if (tessedit_write_txt_map)
    txt_mapfile = open_outfile (".map");
  if (tessedit_write_unlv)
    unlv_file = open_outfile (".unlv");
  page_res_it.restart_page ();
  block_of_last_word = NULL;
  while (page_res_it.word () != NULL) {
    check_debug_pt (page_res_it.word (), 120);
    if (tessedit_write_block_separators &&
    block_of_last_word != page_res_it.block ()) {
      block_of_last_word = page_res_it.block ();
      if (block_of_last_word->block->text_region () == NULL) {
        if (block_of_last_word->block->poly_block () == NULL)
          block_id = 1;
        else
          block_id =
            ((WEIRD_BLOCK *) block_of_last_word->block->poly_block ())->
            id_no(); 
      }
      else
        block_id = block_of_last_word->block->text_region ()->id_no ();
      if (!NO_BLOCK)
        fprintf (textfile, "|^~tr%d\n", block_id);
      fprintf (txt_mapfile, "|^~tr%d\n", block_id);
    }

    force_eol = (tessedit_write_block_separators &&
      (page_res_it.block () != page_res_it.next_block ())) ||
      (page_res_it.next_word () == NULL);

    if (page_res_it.next_word () != NULL)
      nextword = page_res_it.next_word ()->word;
    else
      nextword = NULL;
    if (page_res_it.next_block () != NULL)
      nextblock = page_res_it.next_block ()->block;
    else
      nextblock = NULL;
    write_results (page_res_it, // regardless of tilde crunching
      determine_newline_type (page_res_it.word ()->word,
         page_res_it.block ()->block, nextword, nextblock),
         force_eol, write_to_shm);
    page_res_it.forward ();
  }
  if (write_to_shm)
    ocr_send_text(FALSE); 
  if (tessedit_write_block_separators) {
    if (!NO_BLOCK)
      fprintf (textfile, "|^~tr\n");
    fprintf (txt_mapfile, "|^~tr\n");
  }
  if (tessedit_write_txt_map) {
    fprintf (txt_mapfile, "\n"); // because txt gets one
    #ifdef __UNIX__
    fsync (fileno (txt_mapfile));
    #endif
    fclose(txt_mapfile); 
  }
}

void set_unlv_suspects

(

WERD_RES *

word

)

Modifies reject_map of word based on suspect_level.

Parameters:

word

Word

Note:

Global:

• tessedit_minimal_rejection,
• suspect_level,
• suspect_rating_per_ch,
• suspect_accept_rating

• suspect_level = 0 - dont reject ANYTHING
• suspect_level = 1 or 2 - partial rejection
• suspect_level 3 - BEST

To reject JUST tess failures in the .map file set suspect_level 3 and tessedit_minimal_rejection.

Definition at line 1085 of file output.cpp.

References AC_UNACCEPTABLE, acceptable_number_string(), acceptable_word_string(), WERD_RES::best_choice, count_alphas(), REJMAP::length(), R_1IL_CONFLICT, R_BLOCK_REJ, R_DOC_REJ, R_MM_REJECT, R_POSTNN_1IL, R_ROW_REJ, WERD_RES::reject_map, safe_dict_word(), and WERD_RES::tess_accepted.

Referenced by write_results().

                                       { 
  int len = word->reject_map.length ();
  int i;
  const char *ptr;
  float rating_per_ch;

  ptr = word->best_choice->string ().string ();

  if (suspect_level == 0) {
    for (i = 0; i < len; i++) {
      if (word->reject_map[i].rejected ())
        word->reject_map[i].setrej_minimal_rej_accept ();
    }
    return;
  }

  if (suspect_level >= 3)
    return;                      // Use defaults

  /* NOW FOR LEVELS 1 and 2 Find some stuff to unreject*/

  if (safe_dict_word (ptr) && (count_alphas (ptr) > suspect_short_words)) {
    /* Unreject alphas in dictionary words */
    for (i = 0; i < len; i++) {
      if (word->reject_map[i].rejected () && isalpha (ptr[i]))
        word->reject_map[i].setrej_minimal_rej_accept ();
    }
  }

  rating_per_ch = word->best_choice->rating () / word->reject_map.length ();

  if (rating_per_ch >= suspect_rating_per_ch)
    return;                      //Dont touch bad ratings

  if ((word->tess_accepted) || (rating_per_ch < suspect_accept_rating)) {
    /* Unreject any Tess Acceptable word - but NOT tess reject chs*/
    for (i = 0; i < len; i++) {
      if (word->reject_map[i].rejected () && (ptr[i] != ' '))
        word->reject_map[i].setrej_minimal_rej_accept ();
    }
  }

  for (i = 0; i < len; i++) {
    if (word->reject_map[i].rejected ()) {
      if (word->reject_map[i].flag (R_DOC_REJ))
        word->reject_map[i].setrej_minimal_rej_accept ();
      if (word->reject_map[i].flag (R_BLOCK_REJ))
        word->reject_map[i].setrej_minimal_rej_accept ();
      if (word->reject_map[i].flag (R_ROW_REJ))
        word->reject_map[i].setrej_minimal_rej_accept ();
    }
  }

  if (suspect_level == 2)
    return;

  if (!suspect_constrain_1Il ||
  (word->reject_map.length () <= suspect_short_words)) {
    for (i = 0; i < len; i++) {
      if (word->reject_map[i].rejected ()) {
        if ((word->reject_map[i].flag (R_1IL_CONFLICT) ||
          word->reject_map[i].flag (R_POSTNN_1IL)))
          word->reject_map[i].setrej_minimal_rej_accept ();

        if (!suspect_constrain_1Il &&
          word->reject_map[i].flag (R_MM_REJECT))
          word->reject_map[i].setrej_minimal_rej_accept ();
      }
    }
  }

  if ((acceptable_word_string (word->best_choice->string ().string ())
    != AC_UNACCEPTABLE) ||
  acceptable_number_string (word->best_choice->string ().string ())) {
    if (word->reject_map.length () > suspect_short_words) {
      for (i = 0; i < len; i++) {
        if (word->reject_map[i].rejected () &&
          (!word->reject_map[i].perm_rejected () ||
          word->reject_map[i].flag (R_1IL_CONFLICT) ||
          word->reject_map[i].flag (R_POSTNN_1IL) ||
        word->reject_map[i].flag (R_MM_REJECT))) {
          word->reject_map[i].setrej_minimal_rej_accept ();
        }
      }
    }
  }
}

void write_cooked_text	(	WERD *	word,
		const STRING &	text,
		BOOL8	acceptable,
		BOOL8	pass2,
		FILE *	fp
	)

Write the cooked text (with bold for pass2 and underline for reject) to the given file.

Parameters:

	word	word to do
	text	text to write
	acceptable	good stuff
	pass2	done on pass2
	fp	file to write

Returns:

none

Definition at line 657 of file output.cpp.

References BOLD_OFF, BOLD_ON, BOX::bottom(), WERD::bounding_box(), ERRCODE::error(), EXIT, WERD::flag(), IMAGE::get_ysize(), INT32FORMAT, BOX::left(), STRING::length(), NO_BLOCK, num_popped, page_image, BOX::right(), WERD::space(), STRING::string(), BOX::top(), tprintf(), UNDERLINE_OFF, UNDERLINE_ON, W_EOL, WRITEFAILED, XOFFSET, and YOFFSET.

Referenced by classify_word_pass1(), classify_word_pass2(), and write_results().

                        {
  INT16 index;                   //blank counter
  int status;
  static int newaline = 1;
  static int havespace = 0;
  char buff[512];
  const char *wordstr = text.string ();
  int i = 0;
  char unrecognised = STRING (unrecognised_char)[0];
  static int old_segs = 0;
  BOX mybox;
  for (i = 0; wordstr[i] != '\0'; i++) {
    if (wordstr[i] == ' ')
      buff[i] = unrecognised;
    else
      buff[i] = wordstr[i];
  }
  buff[i] = '\0';

  if (fp == stdout) {
    tprintf ("Cooked=%s, %d segs, acceptable=%d",
      buff, num_popped - old_segs, acceptable);
    old_segs = num_popped;
    return;
  }

  if (text.length () > 0) {
    for (index = 0; index < word->space (); index++) {
      status = fprintf (fp, " ");
      havespace = 1;
      if (status < 0)
        WRITEFAILED.error ("write_cooked_text", EXIT,
          "Space Errno: %d", errno);
    }
    if (pass2) {
      status = fprintf (fp, BOLD_ON);
      if (status < 0)
        WRITEFAILED.error ("write_cooked_text", EXIT,
          "Bold Errno: %d", errno);
    }
    if (!acceptable) {
      status = fprintf (fp, UNDERLINE_ON);
      if (status < 0)
        WRITEFAILED.error ("write_cooked_text", EXIT,
          "Underline Errno: %d", errno);
    }

                                 //xiaofan
    if (NO_BLOCK && word && strlen (buff)) {
      mybox = word->bounding_box ();
      if (newaline || !havespace) {
        fprintf (fp, " ");
        newaline = 0;
      }
      fprintf (fp, "(%d," INT32FORMAT ",%d," INT32FORMAT ")",
        XOFFSET + mybox.left (),
        YOFFSET + page_image.get_ysize () - mybox.top (),
        XOFFSET + mybox.right (),
        YOFFSET + page_image.get_ysize () - mybox.bottom ());
      havespace = 0;
    }

    status = fprintf (fp, "%s", buff);
    if (status < 0)
      WRITEFAILED.error ("write_cooked_text", EXIT,
        "Word Errno: %d", errno);
    if (pass2) {
      status = fprintf (fp, BOLD_OFF);
      if (status < 0)
        WRITEFAILED.error ("write_cooked_text", EXIT,
          "Bold off Errno: %d", errno);
    }
    if (!acceptable) {
      status = fprintf (fp, UNDERLINE_OFF);
      if (status < 0)
        WRITEFAILED.error ("write_cooked_text", EXIT,
          "Underline off Errno: %d", errno);
    }
  }
  if (word->flag (W_EOL)) {
    status = fprintf (fp, "\n");
    newaline = 1;
    if (status < 0)
      WRITEFAILED.error ("write_cooked_text", EXIT,
        "Newline Errno: %d", errno);
  }
  status = fflush (fp);
  if (status != 0)
    WRITEFAILED.error ("write_cooked_text", EXIT, "Fflush Errno: %d", errno);
}

void write_map	(	FILE *	mapfile,
		WERD_RES *	word
	)

Generates a map file, approx a 'cmp -l' of .txt file and .etx file.

Parameters:

	mapfile	mapfile to write to
	word	Word

Write a map file of 0's and 1'a which associates characters from the .txt file with those in the .etx file. 0 = .txt char was deleted. 1 = .txt char is kept. Note that there may be reject regions in the .etx file WITHOUT .txt chars being rejected. The map file should be the same length, and the same number of lines as the .txt file

The paramaterised input is because I thought I might be able to generate multiple map files in a single run. However, it didn't work because newdiff needs etx files!

Definition at line 891 of file output.cpp.

References ASSERT_HOST, WERD_RES::best_choice, ERRCODE::error(), EXIT, WERD::flag(), REJMAP::length(), WERD_RES::reject_map, WERD_RES::reject_spaces, WERD::space(), STRING::string(), W_EOL, W_REP_CHAR, WERD_RES::word, and WRITEFAILED.

Referenced by write_results().

                               {
  INT16 index;
  int status;
  STRING mapstr = "";

  if (word->best_choice->string ().length () > 0) {
    for (index = 0; index < word->word->space (); index++) {
      if (word->reject_spaces &&
        (suspect_level >= suspect_space_level) &&
        !tessedit_minimal_rejection && !tessedit_zero_rejection)
        /*
       Write rejected spaces to .map file ONLY. Newdiff converts
       these back to accepted spaces AFTER generating basic space
       stats but BEFORE using .etx
       */
        status = fprintf (mapfile, "0");
      else
        status = fprintf (mapfile, "1");
      if (status < 0)
        WRITEFAILED.error ("write_map", EXIT, "Space Errno: %d", errno);
    }

    if ((word->word->flag (W_REP_CHAR) && tessedit_write_rep_codes)) {
      for (index = 0; index < 5; index++)
        mapstr += '1';
    }
    else {
      ASSERT_HOST (word->reject_map.length () ==
        word->best_choice->string ().length ());

      for (index = 0; index < word->reject_map.length (); index++) {
        if (word->reject_map[index].accepted ())
          mapstr += '1';
        else
          mapstr += '0';
      }
    }
    status = fprintf (mapfile, "%s", mapstr.string ());
    if (status < 0)
      WRITEFAILED.error ("write_map", EXIT, "Map str Errno: %d", errno);
  }
  if (word->word->flag (W_EOL)) {
    status = fprintf (mapfile, "\n");
    if (status < 0)
      WRITEFAILED.error ("write_map", EXIT, "Newline Errno: %d", errno);
  }
  status = fflush (mapfile);
  if (status != 0)
    WRITEFAILED.error ("write_map", EXIT, "fflush Errno: %d", errno);
}

void write_results	(	PAGE_RES_IT &	page_res_it,
		char	newline_type,
		BOOL8	force_eol,
		BOOL8	write_to_shm
	)

All recognition and rejection has now been done so write out word.

Parameters:

	page_res_it	full info
	newline_type	type of newline
	force_eol	0 or 1, override tilde crunch?
	write_to_shm	0 or 1, send to api

Returns:

none

Generate the following:

• .txt file - giving the final best choices with NO highlighting
• .raw file - giving the tesseract top choice output for each word
• .map file - showing how the .txt file has been rejected in the .ep file
• epchoice list - a list of one element per word, containing the text for the epaper. Reject strings are inserted.
• inset list - a list of bounding boxes of reject insets - indexed by the reject strings in the epchoice text.

Definition at line 214 of file output.cpp.

References ASSERT_HOST, WERD_RES::best_choice, WERD::blob_list(), BLOCK_RES::block, PAGE_RES_IT::block(), character_count, check_debug_pt(), CR_DELETE, CR_KEEP_SPACE, CR_NONE, CTRL_INSET, dict_word(), ensure_rep_chars_are_consistent(), WERD_RES::ep_choice, FALSE, WERD::flag(), get_rep_char(), REJMAP::length(), make_epaper_choice(), NO_BLOCK, NO_PERM, WERD_RES::outword, rawfile, WERD_RES::reject_map, REJMAP::remove_pos(), PAGE_RES_IT::row(), set_unlv_suspects(), WERD::space(), STRING::string(), textfile, tprintf(), TRUE, txt_mapfile, WERD_RES::unlv_crunch_mode, unlv_file, W_BOL, W_EOL, W_FUZZY_NON, W_FUZZY_SP, W_REP_CHAR, WERD_RES::word, PAGE_RES_IT::word(), word_count, write_cooked_text(), write_map(), write_shm_text(), and write_unlv_text().

Referenced by output_pass().

                    {
  WERD_RES *word = page_res_it.word (); //word to do
  WERD_CHOICE *ep_choice;        //ep format
  STRING repetition_code;
  const STRING *wordstr;
  const char *text;
  int i;
  char unrecognised = STRING (unrecognised_char)[0];
  char ep_chars[32];             //Only for unlv_tilde_crunch
  int ep_chars_index = 0;
  char txt_chs[32];              //Only for unlv_tilde_crunch
  char map_chs[32];              //Only for unlv_tilde_crunch
  int txt_index = 0;
  static BOOL8 tilde_crunch_written = FALSE;
  static BOOL8 last_char_was_newline = TRUE;
  static BOOL8 last_char_was_tilde = FALSE;
  static BOOL8 empty_block = TRUE;
  BOOL8 need_reject = FALSE;
  char *ptr;                     //string ptr
  PBLOB_IT blob_it;              //blobs

  /*
   if (word->best_choice->string().length() == 0)
    {
      tprintf("No output: to output\n");
    }
    else if (word->best_choice->string()[0]==' ')
    {
      tprintf("spaceword to output\n");
    }
    else if (word->best_choice->string()[0]== '\0' )
    {
      tprintf("null to output\n");
    }*/
  if (word->unlv_crunch_mode != CR_NONE
  && !tessedit_zero_kelvin_rejection && !tessedit_word_for_word) {
    if ((word->unlv_crunch_mode != CR_DELETE) &&
      (!tilde_crunch_written ||
      ((word->unlv_crunch_mode == CR_KEEP_SPACE) &&
      (word->word->space () > 0) &&
      !word->word->flag (W_FUZZY_NON) &&
    !word->word->flag (W_FUZZY_SP)))) {
      if (!word->word->flag (W_BOL) &&
        (word->word->space () > 0) &&
        !word->word->flag (W_FUZZY_NON) &&
      !word->word->flag (W_FUZZY_SP)) {
        /* Write a space to separate from preceeding good text */
        txt_chs[txt_index] = ' ';
        map_chs[txt_index++] = '1';
        ep_chars[ep_chars_index++] = ' ';
        last_char_was_tilde = FALSE;
      }
      need_reject = TRUE;
    }
    if ((need_reject && !last_char_was_tilde) || (force_eol && empty_block)) {
      /* Write a reject char - mark as rejected unless zero_rejection mode */
      last_char_was_tilde = TRUE;
      txt_chs[txt_index] = unrecognised;
      if (tessedit_zero_rejection || (suspect_level == 0)) {
        map_chs[txt_index++] = '1';
        ep_chars[ep_chars_index++] = unrecognised;
      }
      else {
        map_chs[txt_index++] = '0';
        /* The ep_choice string is a faked reject to allow newdiff to
         sync the .etx with the .txt and .map files.
         */
        ep_chars[ep_chars_index++] = CTRL_INSET; // escape code
        ep_chars[ep_chars_index++] = 1; // dummy reject
        ep_chars[ep_chars_index++] = 1; // dummy reject
        ep_chars[ep_chars_index++] = 2; // type
        ep_chars[ep_chars_index++] = 1; // dummy reject
        ep_chars[ep_chars_index++] = 1; // dummy reject
      }
      tilde_crunch_written = TRUE;
      last_char_was_newline = FALSE;
      empty_block = FALSE;
    }

    if ((word->word->flag (W_EOL) && !last_char_was_newline) || force_eol) {
      /* Add a new line output */
      txt_chs[txt_index] = '\n';
      map_chs[txt_index++] = '\n';
      ep_chars[ep_chars_index++] = newline_type; // end line

      tilde_crunch_written = FALSE; // Coordinates of the real newline
      last_char_was_newline = TRUE;
      last_char_was_tilde = FALSE;
    }
    txt_chs[txt_index] = '\0';
    map_chs[txt_index] = '\0';
    if (tessedit_write_output && !NO_BLOCK) // xiaofan ?
      fprintf (textfile, "%s", txt_chs);

    if (tessedit_write_unlv)
      fprintf (unlv_file, "%s", txt_chs);

    if (tessedit_write_txt_map)
      fprintf (txt_mapfile, "%s", map_chs);

    ep_chars[ep_chars_index] = '\0'; // terminate string
    word->ep_choice = new WERD_CHOICE (ep_chars, 0, 0, NO_PERM);

    if (force_eol)
      empty_block = TRUE;
    return;
  }

  /* NORMAL PROCESSING of non tilde crunched words */

  tilde_crunch_written = FALSE;
  if (newline_type)
    last_char_was_newline = TRUE;
  else
    last_char_was_newline = FALSE;
  empty_block = force_eol;       // About to write a real word

  if (unlv_tilde_crunching &&
    last_char_was_tilde &&
    (word->word->space () == 0) &&
    !(word->word->flag (W_REP_CHAR) && tessedit_write_rep_codes) &&
  (word->best_choice->string ()[0] == ' ')) {
    /* Prevent adjacent tilde across words - we know that adjacent
      tildes within words have been removed */
    ptr = (char *) word->best_choice->string ().string ();
    strcpy (ptr, ptr + 1);       //shuffle up
    word->reject_map.remove_pos (0);
    blob_it = word->outword->blob_list ();
    delete blob_it.extract ();   // get rid of reject blob
  }
  if (newline_type ||
    (word->word->flag (W_REP_CHAR) && tessedit_write_rep_codes))
    last_char_was_tilde = FALSE;
  else {
    if (word->reject_map.length () > 0) {
      if (word->best_choice->string ()[word->reject_map.length () - 1] ==
        ' ')
        last_char_was_tilde = TRUE;
      else
        last_char_was_tilde = FALSE;
    }
    else if (word->word->space () > 0)
      last_char_was_tilde = FALSE;
    /* else it is unchanged as there are no output chars */
  }

  ptr = (char *) word->best_choice->string ().string ();
  ASSERT_HOST (strlen (ptr) == word->reject_map.length ());

  if (word->word->flag (W_REP_CHAR) && tessedit_consistent_reps)
    ensure_rep_chars_are_consistent(word); 

  set_unlv_suspects(word); 
  check_debug_pt (word, 120);
  if (tessedit_rejection_debug) {
    tprintf ("Dict word: \"%s\": %d\n",
      word->best_choice->string ().string (),
      dict_word (word->best_choice->string ().string ()));
  }

  if (tessedit_write_unlv) {
    write_unlv_text(word); 
  }

  if (word->word->flag (W_REP_CHAR) && tessedit_write_rep_codes) {
    repetition_code = "|^~R";
    repetition_code += get_rep_char (word);
    wordstr = &repetition_code;
  }
  else {
    wordstr = &(word->best_choice->string ());
    if (tessedit_zero_rejection) {
      /* OVERRIDE ALL REJECTION MECHANISMS - ONLY REJECT TESS FAILURES */
      text = wordstr->string ();
      for (i = 0; text[i] != '\0'; i++) {
        if (word->reject_map[i].rejected ())
          word->reject_map[i].setrej_minimal_rej_accept ();
      }
    }
    if (tessedit_minimal_rejection) {
      /* OVERRIDE ALL REJECTION MECHANISMS - ONLY REJECT TESS FAILURES */
      text = wordstr->string ();
      for (i = 0; text[i] != '\0'; i++) {
        if ((text[i] != ' ') && word->reject_map[i].rejected ())
          word->reject_map[i].setrej_minimal_rej_accept ();
      }
    }
  }

  if (write_to_shm)
    write_shm_text (word, page_res_it.block ()->block,
      page_res_it.row (), *wordstr);

  if (tessedit_write_output)
    write_cooked_text (word->word, *wordstr, TRUE, FALSE, textfile);

  if (tessedit_write_raw_output)
    write_cooked_text (word->word, word->raw_choice->string (),
      TRUE, FALSE, rawfile);

  if (tessedit_write_txt_map)
    write_map(txt_mapfile, word); 

  ep_choice = make_epaper_choice (word, newline_type);
  word->ep_choice = ep_choice;

  character_count += word->best_choice->string ().length ();
  word_count++;
}

void write_shm_text	(	WERD_RES *	word,
		BLOCK *	block,
		ROW_RES *	row,
		const STRING &	text
	)

Write the cooked text to the shared memory for the api.

Definition at line 758 of file output.cpp.

References ROW::ascenders(), WERD::baseline_denormalise(), WERD_RES::best_choice, WERD::blob_list(), ROW_RES::bold, WERD_RES::bold, BOX::bottom(), WERD::bounding_box(), PBLOB::bounding_box(), WERD_RES::denorm, ROW::descenders(), EUC_BOLD, EUC_ITALIC, WERD::flag(), ROW_RES::font1, WERD_RES::font1, ROW_RES::font1_count, WERD_RES::font1_count, IMAGE::get_ysize(), ROW_RES::italic, WERD_RES::italic, BOX::left(), STRING::length(), ocr_append_char(), OCR_CDIR_LEFT_RIGHT, ocr_char_space(), OCR_LDIR_DOWN_RIGHT, OCR_NL_NEWLINE, OCR_NL_NONE, ocr_send_text(), OKAY, WERD_RES::outword, page_image, pixels_to_pts(), WERD_RES::reject_map, BOX::right(), ROW_RES::row, WERD::space(), BOX::top(), TRUE, W_BOL, W_DONT_CHOP, W_EOL, WERD_RES::word, and ROW::x_height().

Referenced by write_results().

                     {
  INT32 index;                   //char counter
  INT32 index2;                  //char counter
  INT32 length;                  //chars in word
  INT32 ptsize;                  //font size
  INT8 blanks;                   //blanks in word
  UINT8 enhancement;             //bold etc
  UINT8 font;                    //font index
  char unrecognised = STRING (unrecognised_char)[0];
  PBLOB *blob;
  BOX blob_box;                  //bounding box
  PBLOB_IT blob_it;              //blob iterator
  WERD copy_outword;             // copy to denorm
  UINT32 rating;                 //of char
  BOOL8 lineend;                 //end of line

                                 //point size
  ptsize = pixels_to_pts ((INT32) (row->row->x_height () + row->row->ascenders () - row->row->descenders ()), 300);
  if (word->word->flag (W_BOL) && ocr_char_space () < 128
    && ocr_send_text (TRUE) != OKAY)
    return;                      //release failed
  copy_outword = *(word->outword);
  copy_outword.baseline_denormalise (&word->denorm);
  blob_it.set_to_list (copy_outword.blob_list ());
  length = text.length ();

  if (length > 0) {
    blanks = word->word->space ();
    if (blanks == 0 && tessedit_word_for_word && !word->word->flag (W_BOL))
      blanks = 1;
    for (index = 0; index < length; index++, blob_it.forward ()) {
      blob = blob_it.data ();
      blob_box = blob->bounding_box ();

      enhancement = 0;
      if (word->italic > 0 || word->italic == 0 && row->italic > 0)
        enhancement |= EUC_ITALIC;
      if (word->bold > 0 || word->bold == 0 && row->bold > 0)
        enhancement |= EUC_BOLD;
      if (tessedit_write_ratings)
        rating = (UINT32) (-word->best_choice->certainty () / 0.035);
      else if (tessedit_zero_rejection)
        rating = text[index] == ' ' ? 100 : 0;
      else
        rating = word->reject_map[index].accepted ()? 0 : 100;
      if (rating > 255)
        rating = 255;
      if (word->font1_count > 2)
        font = word->font1;
      else if (row->font1_count > 8)
        font = row->font1;
      else
                                 //font index
        font = word->word->flag (W_DONT_CHOP) ? 0 : 1;

      lineend = word->word->flag (W_EOL) && index == length - 1;
      if (word->word->flag (W_EOL) && tessedit_zero_rejection
      && index < length - 1 && text[index + 1] == ' ') {
        for (index2 = index + 1; index2 < length && text[index2] == ' ';
          index2++);
        if (index2 == length)
          lineend = TRUE;
      }

      if (!tessedit_zero_rejection || text[index] != ' '
      || tessedit_word_for_word) {
                                 //confidence
        ocr_append_char (text[index] == ' ' ? unrecognised : text[index], blob_box.left (), blob_box.right (), page_image.get_ysize () - 1 - blob_box.top (), page_image.get_ysize () - 1 - blob_box.bottom (), font, (UINT8) rating,
          ptsize,                //point size
          blanks, enhancement,   //enhancement
          OCR_CDIR_LEFT_RIGHT,
          OCR_LDIR_DOWN_RIGHT,
          lineend ? OCR_NL_NEWLINE : OCR_NL_NONE);
        blanks = 0;
      }

    }
  }
  else if (tessedit_word_for_word) {
    blanks = word->word->space ();
    if (blanks == 0 && !word->word->flag (W_BOL))
      blanks = 1;
    blob_box = word->word->bounding_box ();

    enhancement = 0;
    if (word->italic > 0)
      enhancement |= EUC_ITALIC;
    if (word->bold > 0)
      enhancement |= EUC_BOLD;
    rating = 100;
    if (word->font1_count > 2)
      font = word->font1;
    else if (row->font1_count > 8)
      font = row->font1;
    else
                                 //font index
      font = word->word->flag (W_DONT_CHOP) ? 0 : 1;

    lineend = word->word->flag (W_EOL);

                                 //font index
    ocr_append_char (unrecognised, blob_box.left (), blob_box.right (), page_image.get_ysize () - 1 - blob_box.top (), page_image.get_ysize () - 1 - blob_box.bottom (), font,
      rating,                    //confidence
      ptsize,                    //point size
      blanks, enhancement,       //enhancement
      OCR_CDIR_LEFT_RIGHT,
      OCR_LDIR_DOWN_RIGHT,
      lineend ? OCR_NL_NEWLINE : OCR_NL_NONE);
  }
}

void write_unlv_text

(

WERD_RES *

word

)

Write text to .unlv file.

Parameters:

word

Word

Definition at line 971 of file output.cpp.

References WERD_RES::best_choice, ERRCODE::error(), EXIT, WERD::flag(), WERD_RES::reject_map, WERD_RES::reject_spaces, WERD::space(), unlv_file, W_EOL, WERD_RES::word, and WRITEFAILED.

Referenced by write_results().

                                     { 
  const char *wordstr;

  char buff[512];                //string to output
  int i = 0;
  int j = 0;
  char unrecognised = STRING (unrecognised_char)[0];
  int status;
  char space_str[3];

  wordstr = word->best_choice->string ().string ();

  /*
  DONT need to do anything special for repeated char words - at
  this stage the repetition char has been identified and any other
  chars have been rejected.
  */

  for (; wordstr[i] != '\0'; i++) {
    if ((wordstr[i] == ' ') ||
      (wordstr[i] == '~') || (wordstr[i] == '^') || (wordstr[i] == '|'))
      buff[j++] = unrecognised;
    else {
      if (word->reject_map[i].rejected ())
        buff[j++] = '^';         //Add suspect marker
      buff[j++] = wordstr[i];
    }
  }
  buff[j] = '\0';

  if (strlen (wordstr) > 0) {
    if (word->reject_spaces &&
      (suspect_level >= suspect_space_level) &&
      !tessedit_minimal_rejection && !tessedit_zero_rejection)
      strcpy (space_str, "^ ");  //Suspect space
    else
      strcpy (space_str, " ");   //Certain space

    for (i = 0; i < word->word->space (); i++) {
      status = fprintf (unlv_file, "%s", space_str);
      if (status < 0)
        WRITEFAILED.error ("write_unlv_text", EXIT,
          "Space Errno: %d", errno);
    }

    status = fprintf (unlv_file, "%s", buff);
    if (status < 0)
      WRITEFAILED.error ("write_unlv_text", EXIT, "Word Errno: %d", errno);
  }
  if (word->word->flag (W_EOL)) {
    status = fprintf (unlv_file, "\n");
    if (status < 0)
      WRITEFAILED.error ("write_unlv_text", EXIT,
        "Newline Errno: %d", errno);
  }
  status = fflush (unlv_file);
  if (status != 0)
    WRITEFAILED.error ("write_unlv_text", EXIT, "Fflush Errno: %d", errno);
}

---