ccmain/docqual.cpp File Reference

#include "mfcpch.h"
#include <ctype.h>
#include "docqual.h"
#include "tstruct.h"
#include "tfacep.h"
#include "reject.h"
#include "tessvars.h"
#include "genblob.h"
#include "secname.h"

Go to the source code of this file.

Defines

• #define EXTERN

Functions

• void convert_bad_unlv_chs (WERD_RES *word_res)

  Converts all '~' to '-' & '^' to ' ' in this word.
  

• INT16 count_outline_errs (char c, INT16 outline_count)

  Test if character is in known-odd categories.
  

• BOOL8 crude_match_blobs (PBLOB *blob1, PBLOB *blob2)

  Compares two blobs' bounding boxes & lengths of outlines.
  

• void doc_and_block_rejection (PAGE_RES_IT &page_res_it, BOOL8 good_quality_doc)

  Reject big chunks.
  

• INT16 failure_count (WERD_RES *word)

  Count up all the blanks (' ') in word's best_choice string.
  

• GARBAGE_LEVEL garbage_word (WERD_RES *word, BOOL8 ok_dict_word)

  Determine probability that word is garbage using manu heuristic/rules.
  

• void insert_rej_cblobs (WERD_RES *word)

  Put rejected word blobs back into the outword.
  

• void merge_tess_fails (WERD_RES *word_res)

  Change pairs of tess failures to a single one (merge/collapse).
  

• BOOL8 noise_outlines (WERD *word)

  Determine if more 'too' small outlines than 'regular' outlines (noise).
  

• BOOL8 potential_word_crunch (WERD_RES *word, GARBAGE_LEVEL garbage_level, BOOL8 ok_dict_word)

  Determine if word could be garbage or otherwise questionable.
  

• void print_boxes (WERD *word)

  Print all bounding boxes for blobs in word.
  

• void quality_based_rejection (PAGE_RES_IT &page_res_it, BOOL8 good_quality_doc)

  Deal with rejected blobs and clean up errant tilde's.
  

• void reject_whole_page (PAGE_RES_IT &page_res_it)

  Dont believe any of it; set map to 00..00 for all words.
  

• BOOL8 terrible_word_crunch (WERD_RES *word, GARBAGE_LEVEL garbage_level)

  Determine if word very likely is utter garbage, tuned with several globals.
  

• void tilde_crunch (PAGE_RES_IT &page_res_it)
• void tilde_delete (PAGE_RES_IT &page_res_it)

  Determine if word could be bad and delete all '~'s in it?
  

• void unrej_good_chs (WERD_RES *word, ROW *row)

  Unreject POTENTIAL rejects if the blob passes the blob and outline checks.
  

• void unrej_good_quality_words (PAGE_RES_IT &page_res_it)

  Unreject potential.
  

• INT16 word_blob_quality (WERD_RES *word, ROW *row)

  Find number of blobs in outword that are identical to those of inword.
  

• void word_char_quality (WERD_RES *word, ROW *row, INT16 *match_count, INT16 *accepted_match_count)

  Check word's blobs' quality.
  

• CRUNCH_MODE word_deletable (WERD_RES *word, INT16 &delete_mode)

  Delete suspicious word if a bunch of constraints are met.
  

• INT16 word_outline_errs (WERD_RES *word)

  Count errors in word's outlines using count_outline_errs().
  

---

Define Documentation

#define EXTERN

Note:

File: docqual.cpp (Formerly docqual.c)
Document Quality Metrics

Author:

Phil Cheatle

Date:

Mon May 9 11:27:28 BST 1994

 * (C) Copyright 1994, Hewlett-Packard Ltd.
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 ** http://www.apache.org/licenses/LICENSE-2.0
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.

Definition at line 33 of file docqual.cpp.

---

Function Documentation

void convert_bad_unlv_chs

(

WERD_RES *

word_res

)

Converts all '~' to '-' & '^' to ' ' in this word.

Parameters:

word_res

Word results

Returns:

none, instead updates word's reject_map

Definition at line 1106 of file docqual.cpp.

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

Referenced by tilde_crunch().

                                              {
  char *ptr;                     //string ptr
  int i;

  ptr = (char *) word_res->best_choice->string ().string ();
  for (i = 0; i < word_res->reject_map.length (); i++) {
    if (ptr[i] == '~') {
      ptr[i] = '-';
      if (word_res->reject_map[i].accepted ())
        word_res->reject_map[i].setrej_unlv_rej ();
    }
    if (ptr[i] == '^') {
      ptr[i] = ' ';
      if (word_res->reject_map[i].accepted ())
        word_res->reject_map[i].setrej_unlv_rej ();
    }
  }
}

INT16 count_outline_errs	(	char	c,
		INT16	outline_count
	)

Test if character is in known-odd categories.

Parameters:

	c	character
	outline_count	outlines we have

Returns:

difference between outline_count and what it should be

• outlines_odd = "Non standard number of outlines" = "%| " is rejected outright
• outlines_2 = "Non standard number of outlines" = "ij!?%\":;" tells tess to expect TWO outlines
• if it's anything else, tess is to expected ONE outline

So, count_outline_errs() returns 0 if c has the EXPECTED number of outlines.

Definition at line 475 of file docqual.cpp.

Referenced by unrej_good_chs(), word_char_quality(), and word_outline_errs().

                                                      { 
  int expected_outline_count;

  if (STRING (outlines_odd).contains (c))
    return 0;                    //Dont use this char
  else if (STRING (outlines_2).contains (c))
    expected_outline_count = 2;
  else
    expected_outline_count = 1;
  return abs (outline_count - expected_outline_count);
}

BOOL8 crude_match_blobs	(	PBLOB *	blob1,
		PBLOB *	blob2
	)

Compares two blobs' bounding boxes & lengths of outlines.

Parameters:

	blob1	first blob
	blob2	second blob

Returns:

TRUE if blob1 == blob2

Definition at line 227 of file docqual.cpp.

References PBLOB::bounding_box(), BOX::contains(), FALSE, PBLOB::out_list(), and TRUE.

Referenced by unrej_good_chs(), word_blob_quality(), and word_char_quality().

                                                    { 
  BOX box1 = blob1->bounding_box ();
  BOX box2 = blob2->bounding_box ();

  if (box1.contains (box2) &&
    box2.contains (box1) &&
    (blob1->out_list ()->length () == blob1->out_list ()->length ()))
    return TRUE;
  else
    return FALSE;
}

void doc_and_block_rejection	(	PAGE_RES_IT &	page_res_it,
		BOOL8	good_quality_doc
	)

Reject big chunks.

Parameters:

	page_res_it	pointer to page in question ?
	good_quality_doc	1 or 0, document is good

Returns:

none

Reject all of the page or block of it's deemed bad (too big)

If the page has too many rejects - reject all of it. If any block has too many rejects - reject all words in the block

Definition at line 608 of file docqual.cpp.

References AC_UNACCEPTABLE, acceptable_word_string(), WERD_RES::best_choice, PAGE_RES_IT::block(), BLOCK_RES::block, BLOCK_RES::char_count, ROW_RES::char_count, FALSE, PAGE_RES_IT::forward(), REJMAP::length(), NULL, PAGE_RES_IT::page_res, PAGE_RES_IT::prev_row(), BLOCK_RES::rej_count, ROW_RES::rej_count, REJMAP::rej_word_block_rej(), REJMAP::reject_count(), WERD_RES::reject_map, WERD_RES::reject_spaces, reject_whole_page(), PAGE_RES_IT::restart_page(), PAGE_RES_IT::row(), ROW_RES::row, SECURE_NAMES, WERD::space(), tprintf(), TRUE, ROW_RES::whole_word_rej_count, PAGE_RES_IT::word(), WERD_RES::word, and word_char_quality().

Referenced by quality_based_rejection().

                                                     {
  INT16 block_no = 0;
  INT16 row_no = 0;
  BLOCK_RES *current_block;
  ROW_RES *current_row;

  BOOL8 rej_word;
  BOOL8 prev_word_rejected;
  INT16 char_quality;
  INT16 accepted_char_quality;

  if ((page_res_it.page_res->rej_count * 100.0 /
  page_res_it.page_res->char_count) > tessedit_reject_doc_percent) {
    reject_whole_page(page_res_it); 
    #ifndef SECURE_NAMES
    if (tessedit_debug_doc_rejection) {
      tprintf ("REJECT ALL #chars: %d #Rejects: %d; \n",
        page_res_it.page_res->char_count,
        page_res_it.page_res->rej_count);
    }
    #endif
  }
  else {
    #ifndef SECURE_NAMES
    if (tessedit_debug_doc_rejection)
      tprintf ("NO PAGE REJECTION #chars: %d  # Rejects: %d; \n",
        page_res_it.page_res->char_count,
        page_res_it.page_res->rej_count);
    #endif

    /* Walk blocks testing for block rejection */

    page_res_it.restart_page ();
    while (page_res_it.word () != NULL) {
      current_block = page_res_it.block ();
      if (current_block->block->text_region () != NULL)
        block_no = current_block->block->text_region ()->id_no ();
      else
        block_no = -1;
      if ((page_res_it.block ()->char_count > 0) &&
        ((page_res_it.block ()->rej_count * 100.0 /
        page_res_it.block ()->char_count) >
      tessedit_reject_block_percent)) {
        #ifndef SECURE_NAMES
        if (tessedit_debug_block_rejection)
          tprintf ("REJECTING BLOCK %d  #chars: %d;  #Rejects: %d\n",
            block_no,
            page_res_it.block ()->char_count,
            page_res_it.block ()->rej_count);
        #endif
        prev_word_rejected = FALSE;
        while ((page_res_it.word () != NULL) &&
        (page_res_it.block () == current_block)) {
          if (tessedit_preserve_blk_rej_perfect_wds) {
            rej_word =
              (page_res_it.word ()->reject_map.reject_count () > 0)
              || (page_res_it.word ()->reject_map.length () <
              tessedit_preserve_min_wd_len);
            if (rej_word && tessedit_dont_blkrej_good_wds
              && !(page_res_it.word ()->reject_map.length () <
              tessedit_preserve_min_wd_len)
              &&
              (acceptable_word_string
              (page_res_it.word ()->best_choice->string ().
            string ()) != AC_UNACCEPTABLE)) {
              word_char_quality (page_res_it.word (),
                page_res_it.row ()->row,
                &char_quality,
                &accepted_char_quality);
              rej_word = char_quality !=
                page_res_it.word ()->reject_map.length ();
            }
          }
          else
            rej_word = TRUE;
          if (rej_word) {
            /*
              Reject spacing if both current and prev words are rejected.
              NOTE - this is NOT restricted to FUZZY spaces.
           When tried this generated more space errors.
            */
            if (tessedit_use_reject_spaces &&
              prev_word_rejected &&
              (page_res_it.prev_row () == page_res_it.row ()) &&
              (page_res_it.word ()->word->space () == 1))
              page_res_it.word ()->reject_spaces = TRUE;
            page_res_it.word ()->reject_map.rej_word_block_rej ();
          }
          prev_word_rejected = rej_word;
          page_res_it.forward ();
        }
      }
      else {
        #ifndef SECURE_NAMES
        if (tessedit_debug_block_rejection)
          tprintf
            ("NOT REJECTING BLOCK %d #chars: %d  # Rejects: %d; \n",
            block_no, page_res_it.block ()->char_count,
            page_res_it.block ()->rej_count);
        #endif

        /* Walk rows in block testing for row rejection */
        row_no = 0;
        while ((page_res_it.word () != NULL) &&
        (page_res_it.block () == current_block)) {
          current_row = page_res_it.row ();
          row_no++;
     /*
   Reject whole row if:
    fraction of chars on row which are rejected exceed a limit AND
    fraction rejects which occur in WHOLE WERD rejects is LESS THAN a limit
     */
          if ((page_res_it.row ()->char_count > 0) &&
            ((page_res_it.row ()->rej_count * 100.0 /
            page_res_it.row ()->char_count) >
            tessedit_reject_row_percent) &&
            ((page_res_it.row ()->whole_word_rej_count * 100.0 /
            page_res_it.row ()->rej_count) <
          tessedit_whole_wd_rej_row_percent)) {
            #ifndef SECURE_NAMES
            if (tessedit_debug_block_rejection)
              tprintf
                ("REJECTING ROW %d  #chars: %d;  #Rejects: %d\n",
                row_no, page_res_it.row ()->char_count,
                page_res_it.row ()->rej_count);
            #endif
            prev_word_rejected = FALSE;
            while ((page_res_it.word () != NULL) &&
            (page_res_it.row () == current_row)) {
              /* Preserve words on good docs unless they are mostly rejected*/
              if (!tessedit_row_rej_good_docs && good_quality_doc) {
                rej_word =
                  page_res_it.word ()->reject_map.
                  reject_count () /
                  (float) page_res_it.word ()->reject_map.
                  length () > tessedit_good_doc_still_rowrej_wd;
              }

              /* Preserve perfect words anyway */
              else if (tessedit_preserve_row_rej_perfect_wds) {
                rej_word =
                  (page_res_it.word ()->reject_map.
                  reject_count () > 0)
                  || (page_res_it.word ()->reject_map.
                  length () < tessedit_preserve_min_wd_len);
                if (rej_word && tessedit_dont_rowrej_good_wds
                  && !(page_res_it.word ()->reject_map.
                  length () <
                  tessedit_preserve_min_wd_len)
                  &&
                  (acceptable_word_string
                  (page_res_it.word ()->best_choice->
                string ().string ()) != AC_UNACCEPTABLE)) {
                  word_char_quality (page_res_it.word (),
                    page_res_it.row ()->row,
                    &char_quality,
                    &accepted_char_quality);
                  rej_word = char_quality !=
                    page_res_it.word ()->reject_map.length ();
                }
              }
              else
                rej_word = TRUE;
              if (rej_word) {
                /*
                  Reject spacing if both current and prev words are rejected.
                  NOTE - this is NOT restricted to FUZZY spaces.
              When tried this generated more space errors.
                */
                if (tessedit_use_reject_spaces &&
                  prev_word_rejected &&
                  (page_res_it.prev_row () ==
                  page_res_it.row ())
                  && (page_res_it.word ()->word->space () ==
                  1))
                  page_res_it.word ()->reject_spaces = TRUE;
                page_res_it.word ()->reject_map.
                  rej_word_row_rej(); 
              }
              prev_word_rejected = rej_word;
              page_res_it.forward ();
            }
          }
          else {
            #ifndef SECURE_NAMES
            if (tessedit_debug_block_rejection)
              tprintf
                ("NOT REJECTING ROW %d #chars: %d  # Rejects: %d; \n",
                row_no, page_res_it.row ()->char_count,
                page_res_it.row ()->rej_count);
            #endif
            while ((page_res_it.word () != NULL) &&
              (page_res_it.row () == current_row))
              page_res_it.forward ();
          }
        }
      }
    }
  }
}

INT16 failure_count

(

WERD_RES *

word

)

Count up all the blanks (' ') in word's best_choice string.

Parameters:

word

Word

Returns:

count

Definition at line 1484 of file docqual.cpp.

References WERD_RES::best_choice.

Referenced by word_deletable().

                                    { 
  char *str = (char *) word->best_choice->string ().string ();
  int tess_rejs = 0;

  for (; *str != '\0'; str++) {
    if (*str == ' ')
      tess_rejs++;
  }
  return tess_rejs;
}

GARBAGE_LEVEL garbage_word	(	WERD_RES *	word,
		BOOL8	ok_dict_word
	)

Determine probability that word is garbage using manu heuristic/rules.

Parameters:

	word	Word in question
	ok_dict_word	0 or 1, 1 if word in dictionary

Note:

Global:

• crunch_include_numerals,
• crunch_leave_ok_strings, and
• crunch_debug
• also: SYSTEM_DAWG_PERM, FREQ_DAWG_PERM, USER_DAWG_PERM, NUMBER_PERM, and AC_UNACCEPTABLE)

Returns:

G_NEVER_CRUNCH, G_TERRIBLE, G_DODGY, or G_OK

Two steps: first step scans through letters of word and gathers statistics and updates state-machine. Second step works at the word-level together with statistics from first step. Neato.

Definition at line 1181 of file docqual.cpp.

References AC_UNACCEPTABLE, acceptable_word_string(), WERD_RES::best_choice, FREQ_DAWG_PERM, G_DODGY, G_NEVER_CRUNCH, G_OK, G_TERRIBLE, REJMAP::length(), NULL, NUMBER_PERM, WERD_RES::reject_map, SYSTEM_DAWG_PERM, tprintf(), and USER_DAWG_PERM.

Referenced by tilde_crunch().

                                                               { 
  enum STATES
  {
    JUNK,
    FIRST_UPPER,
    FIRST_LOWER,
    FIRST_NUM,
    SUBSEQUENT_UPPER,
    SUBSEQUENT_LOWER,
    SUBSEQUENT_NUM
  };
  char *str = (char *) word->best_choice->string ().string ();
  STATES state = JUNK;
  int len = 0;
  int isolated_digits = 0;
  int isolated_alphas = 0;
  int bad_char_count = 0;
  int tess_rejs = 0;
  int dodgy_chars = 0;
  int ok_chars;
  char last_char = ' ';
  int alpha_repetition_count = 0;
  int longest_alpha_repetition_count = 0;
  int longest_lower_run_len = 0;
  int lower_string_count = 0;
  int longest_upper_run_len = 0;
  int upper_string_count = 0;
  int total_alpha_count = 0;
  int total_digit_count = 0;

  /* Step 1: Scan letters of word and set up a bunch of variables
      Working at the level of individual letters */
  for (; *str != '\0'; str++) {
    len++;
    if (isupper (*str)) {
      total_alpha_count++;
      switch (state) {
        case SUBSEQUENT_UPPER:
        case FIRST_UPPER:
          state = SUBSEQUENT_UPPER;
          upper_string_count++;
          if (longest_upper_run_len < upper_string_count)
            longest_upper_run_len = upper_string_count;
          if (last_char == *str) {
            alpha_repetition_count++;
            if (longest_alpha_repetition_count < alpha_repetition_count) {
              longest_alpha_repetition_count = alpha_repetition_count;
            }
          }
          else {
            last_char = *str;
            alpha_repetition_count = 1;
          }
          break;
        case FIRST_NUM:
          isolated_digits++;
        default:
          state = FIRST_UPPER;
          last_char = *str;
          alpha_repetition_count = 1;
          upper_string_count = 1;
          break;
      }
    }
    else if (islower (*str)) {
      total_alpha_count++;
      switch (state) {
        case SUBSEQUENT_LOWER:
        case FIRST_LOWER:
          state = SUBSEQUENT_LOWER;
          lower_string_count++;
          if (longest_lower_run_len < lower_string_count)
            longest_lower_run_len = lower_string_count;
          if (last_char == *str) {
            alpha_repetition_count++;
            if (longest_alpha_repetition_count < alpha_repetition_count) {
              longest_alpha_repetition_count = alpha_repetition_count;
            }
          }
          else {
            last_char = *str;
            alpha_repetition_count = 1;
          }
          break;
        case FIRST_NUM:
          isolated_digits++;
        default:
          state = FIRST_LOWER;
          last_char = *str;
          alpha_repetition_count = 1;
          lower_string_count = 1;
          break;
      }
    }
    else if (isdigit (*str)) {
      total_digit_count++;
      switch (state) {
        case FIRST_NUM:
          state = SUBSEQUENT_NUM;
        case SUBSEQUENT_NUM:
          break;
        case FIRST_UPPER:
        case FIRST_LOWER:
          isolated_alphas++;
        default:
          state = FIRST_NUM;
          break;
      }
    }
    else {
      if (*str == ' ')
        tess_rejs++;
      else
        bad_char_count++;
      switch (state) {
        case FIRST_NUM:
          isolated_digits++;
          break;
        case FIRST_UPPER:
        case FIRST_LOWER:
          isolated_alphas++;
        default:
          break;
      }
      state = JUNK;
    }
  }

  /* Step 2: Combine result of Step 1 with heuristics to determine
     whether word is garbage. Working at the level of whole word */
  switch (state) {
    case FIRST_NUM:
      isolated_digits++;
      break;
    case FIRST_UPPER:
    case FIRST_LOWER:
      isolated_alphas++;
    default:
      break;
  }

  if (crunch_include_numerals) {
    total_alpha_count += total_digit_count - isolated_digits;
  }

  if (crunch_leave_ok_strings &&
    (len >= 4) &&
    (2 * (total_alpha_count - isolated_alphas) > len) &&
  (longest_alpha_repetition_count < crunch_long_repetitions)) {
    if ((crunch_accept_ok &&
      (acceptable_word_string (str) != AC_UNACCEPTABLE)) ||
      (longest_lower_run_len > crunch_leave_lc_strings) ||
      (longest_upper_run_len > crunch_leave_uc_strings))
      return G_NEVER_CRUNCH;
  }
  if ((word->reject_map.length () > 1) &&
    (strpbrk (str, " ") == NULL) &&
    ((word->best_choice->permuter () == SYSTEM_DAWG_PERM) ||
    (word->best_choice->permuter () == FREQ_DAWG_PERM) ||
    (word->best_choice->permuter () == USER_DAWG_PERM) ||
    (word->best_choice->permuter () == NUMBER_PERM) ||
    (acceptable_word_string (str) != AC_UNACCEPTABLE) || ok_dict_word))
    return G_OK;

  ok_chars = len - bad_char_count - isolated_digits -
    isolated_alphas - tess_rejs;

  if (crunch_debug > 3) {
    tprintf ("garbage_word: \"%s\"\n",
      word->best_choice->string ().string ());
    tprintf ("LEN: %d  bad: %d  iso_N: %d  iso_A: %d  rej: %d\n",
      len,
      bad_char_count, isolated_digits, isolated_alphas, tess_rejs);
  }
  if ((bad_char_count == 0) &&
    (tess_rejs == 0) &&
    ((len > isolated_digits + isolated_alphas) || (len <= 2)))
    return G_OK;

  if ((tess_rejs > ok_chars) ||
    ((tess_rejs > 0) && ((bad_char_count + tess_rejs) * 2 > len)))
    return G_TERRIBLE;

  if (len > 4) {
    dodgy_chars = 2 * tess_rejs + bad_char_count +
      isolated_digits + isolated_alphas;
    if ((dodgy_chars > 5) || ((dodgy_chars / (float) len) > 0.5))
      return G_DODGY;
    else
      return G_OK;
  }
  else {
    dodgy_chars = 2 * tess_rejs + bad_char_count;
    if (((len == 4) && (dodgy_chars > 2)) ||
      ((len == 3) && (dodgy_chars > 2)) || (dodgy_chars >= len))
      return G_DODGY;
    else
      return G_OK;
  }
}

void insert_rej_cblobs

(

WERD_RES *

word

)

Put rejected word blobs back into the outword.

Parameters:

word

Word

Returns:

none

Note:

NOTE!!! AFTER insert_rej_cblobs(), THE CHOICES LIST WILL NOT HAVE THE CORRECT NUMBER OF ELEMENTS.

Definition at line 1542 of file docqual.cpp.

References ASSERT_HOST, WERD_RES::best_choice, WERD::blob_list(), gblob_sort_list(), REJMAP::initialise(), STRING::length(), REJMAP::length(), WERD_RES::outword, WERD::rej_blob_list(), WERD_RES::reject_map, and TRUE.

Referenced by quality_based_rejection().

                                       {
  PBLOB_IT blob_it;              // blob iterator
  PBLOB_IT rej_blob_it;
  const STRING *wordstr;
  int old_len;
  int rej_len;
  char new_str[512];
  REJMAP new_map;
  int i = 0;                     //new_str index
  int j = 0;                     //old_str index
  int new_len;

  gblob_sort_list (word->outword->rej_blob_list (), TRUE);
  rej_blob_it.set_to_list (word->outword->rej_blob_list ());
  if (rej_blob_it.empty ())
    return;
  rej_len = rej_blob_it.length ();
  blob_it.set_to_list (word->outword->blob_list ());
  wordstr = &(word->best_choice->string ());
  old_len = wordstr->length ();
  ASSERT_HOST (word->reject_map.length () == old_len);
  ASSERT_HOST (blob_it.length () == old_len);
  if ((old_len + rej_len) > 511)
    return;                      //Word is garbage anyway prevent abort
  new_map.initialise (old_len + rej_len);

  while (!rej_blob_it.empty ()) {
    if ((j >= old_len) ||
      (rej_blob_it.data ()->bounding_box ().left () <=
    blob_it.data ()->bounding_box ().left ())) {
      /* Insert reject blob */
      if (j >= old_len)
        blob_it.add_to_end (rej_blob_it.extract ());
      else
        blob_it.add_before_stay_put (rej_blob_it.extract ());
      if (!rej_blob_it.empty ())
        rej_blob_it.forward ();
      new_str[i] = ' ';
      new_map[i].setrej_rej_cblob ();
      i++;
    }
    else {
      new_str[i] = (*wordstr)[j];
      new_map[i] = word->reject_map[j];
      i++;
      j++;
      blob_it.forward ();
    }
  }
  /* Add any extra normal blobs to strings */
  while (j < wordstr->length ()) {
    new_str[i] = (*wordstr)[j];
    new_map[i] = word->reject_map[j];
    i++;
    j++;
  }
  new_str[i] = '\0';
  /*
    tprintf(
          "\nOld len %d; New len %d; New str \"%s\"; New map \"%s\"\n",
          old_len, i, new_str, new_map );
  */
  ASSERT_HOST (i == blob_it.length ());
  ASSERT_HOST (i == old_len + rej_len);
  word->reject_map = new_map;
  *((STRING *) wordstr) = new_str;
  new_len = strlen (word->best_choice->string ().string ());
  ASSERT_HOST (word->reject_map.length () == new_len);
  ASSERT_HOST (word->outword->blob_list ()->length () == new_len);
}

void merge_tess_fails

(

WERD_RES *

word_res

)

Change pairs of tess failures to a single one (merge/collapse).

Parameters:

word_res

Results on word in question

Returns:

none, updates word's reject_map

Definition at line 1133 of file docqual.cpp.

References ASSERT_HOST, WERD_RES::best_choice, WERD::blob_list(), REJMAP::length(), merge_blobs(), WERD_RES::outword, WERD_RES::reject_map, and REJMAP::remove_pos().

Referenced by tilde_crunch(), and tilde_delete().

                                          {
  char *ptr;                     //string ptr
  PBLOB_IT blob_it;              //blobs
  int i = 0;
  int len;

  len = strlen (word_res->best_choice->string ().string ());
  ASSERT_HOST (word_res->reject_map.length () == len);
  ASSERT_HOST (word_res->outword->blob_list ()->length () == len);

  ptr = (char *) word_res->best_choice->string ().string ();
  blob_it = word_res->outword->blob_list ();
  while (*ptr != '\0') {
    if ((*ptr == ' ') && (*(ptr + 1) == ' ')) {
      strcpy (ptr + 1, ptr + 2); //shuffle up
      word_res->reject_map.remove_pos (i);
      merge_blobs (blob_it.data_relative (1), blob_it.data ());
      delete blob_it.extract (); //get rid of spare
    }
    else {
      i++;
      ptr++;
    }
    blob_it.forward ();
  }
  len = strlen (word_res->best_choice->string ().string ());
  ASSERT_HOST (word_res->reject_map.length () == len);
  ASSERT_HOST (word_res->outword->blob_list ()->length () == len);
}

BOOL8 noise_outlines

(

WERD *

word

)

Determine if more 'too' small outlines than 'regular' outlines (noise).

Parameters:

word

Word

Note:

Global: bln_x_height

Returns:

TRUE if more/same count of tiny outlines as good outlines in word

Cycle through blobs for word, looking at BB of outlines: if size of BB is less than small_limit, it's a small_outline_count, else it's a outline_count. Answer is boolean of the comparison: small_outline_count >= outline_count

Definition at line 1507 of file docqual.cpp.

References WERD::blob_list(), BOX::height(), outline_it, and BOX::width().

Referenced by word_deletable().

                                 { 
  PBLOB_IT blob_it;
  OUTLINE_IT outline_it;
  BOX box;                       // BB of outline
  INT16 outline_count = 0;       // regular count
  INT16 small_outline_count = 0; // tiny/noise count
  INT16 max_dimension;           // the larger of the BB dims
  float small_limit = bln_x_height * crunch_small_outlines_size;

  blob_it.set_to_list (word->blob_list ());
  for (blob_it.mark_cycle_pt (); !blob_it.cycled_list (); blob_it.forward ()) {
    outline_it.set_to_list (blob_it.data ()->out_list ());
    for (outline_it.mark_cycle_pt(); !outline_it.cycled_list(); outline_it.forward()) {
      outline_count++;
      box = outline_it.data ()->bounding_box ();
      if (box.height () > box.width ())
        max_dimension = box.height ();
      else
        max_dimension = box.width ();
      if (max_dimension < small_limit)
        small_outline_count++;
    }
  }
  return (small_outline_count >= outline_count);
}

BOOL8 potential_word_crunch	(	WERD_RES *	word,
		GARBAGE_LEVEL	garbage_level,
		BOOL8	ok_dict_word
	)

Determine if word could be garbage or otherwise questionable.

Parameters:

	word	Word
	garbage_level	G_NEVER_CRUNCH, G_TERRIBLE, G_DODGY, or G_OK
	ok_dict_word	0 or 1, 1 if word in dictionary

Note:

Global:

• crunch_pot_indicators,
• crunch_pot_poor_rate,
• crunch_pot_poor_cert,
• crunch_debug

Returns:

TRUE if count of 'clues' that word sucks >= crunch_pot_indicators

Definition at line 974 of file docqual.cpp.

References AC_UNACCEPTABLE, acceptable_word_string(), WERD_RES::best_choice, G_OK, REJMAP::length(), WERD_RES::reject_map, and tprintf().

Referenced by tilde_crunch().

                                                {
  float rating_per_ch;
  int adjusted_len;
  char *str = (char *) word->best_choice->string ().string (); // word's string
  BOOL8 word_crunchable;
  int poor_indicator_count = 0;

  word_crunchable =
    !crunch_leave_accept_strings ||
    (word->reject_map.length () < 3) ||
    ((acceptable_word_string (str) == AC_UNACCEPTABLE) && !ok_dict_word);

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

  if (rating_per_ch > crunch_pot_poor_rate) {
    if (crunch_debug > 2) {
      tprintf ("Potential poor rating on \"%s\"\n",
        word->best_choice->string ().string ());
    }
    poor_indicator_count++;
  }

  if (word_crunchable &&
  (word->best_choice->certainty () < crunch_pot_poor_cert)) {
    if (crunch_debug > 2) {
      tprintf ("Potential poor cert on \"%s\"\n",
        word->best_choice->string ().string ());
    }
    poor_indicator_count++;
  }

  if (garbage_level != G_OK) {
    if (crunch_debug > 2) {
      tprintf ("Potential garbage on \"%s\"\n",
        word->best_choice->string ().string ());
    }
    poor_indicator_count++;
  }
  return (poor_indicator_count >= crunch_pot_indicators);
}

void print_boxes

(

WERD *

word

)

Print all bounding boxes for blobs in word.

Parameters:

word

Word in question

Returns:

none

Definition at line 447 of file docqual.cpp.

References WERD::blob_list(), and BOX::print().

                             { 
  PBLOB_IT it;
  BOX box;  // bounding box

  it.set_to_list (word->blob_list ());
  for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
    box = it.data ()->bounding_box ();
    box.print ();
  }
}

void quality_based_rejection	(	PAGE_RES_IT &	page_res_it,
		BOOL8	good_quality_doc
	)

Deal with rejected blobs and clean up errant tilde's.

Parameters:

	page_res_it	pointer to page in question ?
	good_quality_doc	0 or 1, which pass ?

Note:

Global:

• tessedit_good_quality_unrej and
• unlv_tilde_crunching

Returns:

none, but word's reject_map is updated

Definition at line 496 of file docqual.cpp.

References doc_and_block_rejection(), insert_rej_cblobs(), NULL, tilde_crunch(), tilde_delete(), and unrej_good_quality_words().

Referenced by recog_all_words().

                                                     {
  if ((tessedit_good_quality_unrej && good_quality_doc))
    unrej_good_quality_words(page_res_it); 
  doc_and_block_rejection(page_res_it, good_quality_doc); 

  page_res_it.restart_page ();
  while (page_res_it.word () != NULL) {
    insert_rej_cblobs (page_res_it.word ());
    page_res_it.forward ();
  }

  if (unlv_tilde_crunching) {
    tilde_crunch(page_res_it); 
    tilde_delete(page_res_it); 
  }
}

void reject_whole_page

(

PAGE_RES_IT &

page_res_it

)

Dont believe any of it; set map to 00..00 for all words.

Parameters:

page_res_it

Returns:

none

Go through all words on page and set their reject_map to rejected, then update page's page_res.

Definition at line 822 of file docqual.cpp.

References PAGE_RES_IT::forward(), NULL, PAGE_RES_IT::page_res, REJMAP::rej_word_doc_rej(), WERD_RES::reject_map, PAGE_RES_IT::restart_page(), TRUE, and PAGE_RES_IT::word().

Referenced by doc_and_block_rejection().

                                                 { 
  page_res_it.restart_page ();
  while (page_res_it.word () != NULL) {
    page_res_it.word ()->reject_map.rej_word_doc_rej ();
    page_res_it.forward ();
  }
  page_res_it.page_res->rejected = TRUE; // whole page is rejected
}

BOOL8 terrible_word_crunch	(	WERD_RES *	word,
		GARBAGE_LEVEL	garbage_level
	)

Determine if word very likely is utter garbage, tuned with several globals.

Parameters:

	word	Word
	garbage_level	G_NEVER_CRUNCH, G_TERRIBLE, G_DODGY, or G_OK

Note:

Global:

• crunch_debug,
• crunch_terrible_rating,
• crunch_terrible_garbage,
• crunch_poor_garbage_cert,
• crunch_poor_garbage_rate,
• crunch_rating_max

Returns:

TRUE if count of 'clues' that word sucks >= crunch_pot_indicators

Definition at line 926 of file docqual.cpp.

References WERD_RES::best_choice, FALSE, G_OK, G_TERRIBLE, REJMAP::length(), WERD_RES::reject_map, tprintf(), and TRUE.

Referenced by tilde_crunch().

                                                                        { 
  float rating_per_ch;
  int adjusted_len;
  int crunch_mode = 0;

  if ((word->best_choice->string ().length () == 0) ||
    (strspn (word->best_choice->string ().string (), " ") ==
    word->best_choice->string ().length ()))
    crunch_mode = 1;
  else {
    adjusted_len = word->reject_map.length ();
    if (adjusted_len > crunch_rating_max)
      adjusted_len = crunch_rating_max;
    rating_per_ch = word->best_choice->rating () / adjusted_len;

    if (rating_per_ch > crunch_terrible_rating)
      crunch_mode = 2;
    else if (crunch_terrible_garbage && (garbage_level == G_TERRIBLE))
      crunch_mode = 3;
    else if ((word->best_choice->certainty () < crunch_poor_garbage_cert) &&
      (garbage_level != G_OK))
      crunch_mode = 4;
    else if ((rating_per_ch > crunch_poor_garbage_rate) &&
      (garbage_level != G_OK))
      crunch_mode = 5;
  }
  if (crunch_mode > 0) {
    if (crunch_debug > 2) {
      tprintf ("Terrible_word_crunch (%d) on \"%s\"\n",
        crunch_mode, word->best_choice->string ().string ());
    }
    return TRUE;
  }
  else
    return FALSE;
}

void tilde_crunch

(

PAGE_RES_IT &

page_res_it

)

Definition at line 834 of file docqual.cpp.

References WERD_RES::best_choice, convert_bad_unlv_chs(), CR_KEEP_SPACE, dict_word(), DOC_DAWG_PERM, FALSE, PAGE_RES_IT::forward(), G_NEVER_CRUNCH, garbage_word(), merge_tess_fails(), NULL, potential_word_crunch(), PAGE_RES_IT::restart_page(), terrible_word_crunch(), tprintf(), TRUE, WERD_RES::unlv_crunch_mode, and PAGE_RES_IT::word().

Referenced by quality_based_rejection().

                                            { 
  WERD_RES *word;
  GARBAGE_LEVEL garbage_level;
  PAGE_RES_IT copy_it;
  BOOL8 prev_potential_marked = FALSE;
  BOOL8 found_terrible_word = FALSE;
  int dict_type;
  BOOL8 ok_dict_word;

  page_res_it.restart_page ();
  while (page_res_it.word () != NULL) {
    word = page_res_it.word ();

    if (crunch_early_convert_bad_unlv_chs)
      convert_bad_unlv_chs(word); 

    if (crunch_early_merge_tess_fails)
      merge_tess_fails(word); 

    if (word->reject_map.accept_count () != 0) {
      found_terrible_word = FALSE;
      prev_potential_marked = FALSE; // Forget earlier potential crunches
    }
    else {
      dict_type = dict_word (word->best_choice->string ().string ());
      ok_dict_word = (dict_type > 0) && (dict_type != DOC_DAWG_PERM);
      garbage_level = garbage_word (word, ok_dict_word);

      if ((garbage_level != G_NEVER_CRUNCH) &&
      (terrible_word_crunch (word, garbage_level))) {
        if (crunch_debug > 0) {
          tprintf ("T CRUNCHING: \"%s\"\n",
            word->best_choice->string ().string ());
        }
        word->unlv_crunch_mode = CR_KEEP_SPACE;
        if (prev_potential_marked) {
          while (copy_it.word () != word) {
            if (crunch_debug > 0) {
              tprintf ("P1 CRUNCHING: \"%s\"\n",
                copy_it.word ()->best_choice->string ().
                string ());
            }
            copy_it.word ()->unlv_crunch_mode = CR_KEEP_SPACE;
            copy_it.forward ();
          }
          prev_potential_marked = FALSE;
        }
        found_terrible_word = TRUE;
      }
      else if ((garbage_level != G_NEVER_CRUNCH) &&
        (potential_word_crunch (word,
      garbage_level, ok_dict_word))) {
        if (found_terrible_word) {
          if (crunch_debug > 0) {
            tprintf ("P2 CRUNCHING: \"%s\"\n",
              word->best_choice->string ().string ());
          }
          word->unlv_crunch_mode = CR_KEEP_SPACE;
        }
        else if (!prev_potential_marked) {
          copy_it = page_res_it;
          prev_potential_marked = TRUE;
          if (crunch_debug > 1) {
            tprintf ("P3 CRUNCHING: \"%s\"\n",
              word->best_choice->string ().string ());
          }
        }
      }
      else {
        found_terrible_word = FALSE;
        prev_potential_marked = FALSE; // Forget earlier potential crunches
        if (crunch_debug > 2) {
          tprintf ("NO CRUNCH: \"%s\"\n",
            word->best_choice->string ().string ());
        }
      }
    }
    page_res_it.forward ();
  }
}

void tilde_delete

(

PAGE_RES_IT &

page_res_it

)

Determine if word could be bad and delete all '~'s in it?

Parameters:

page_res_it

Results of page

Note:

Global: crunch_early_merge_tess_fails,

Returns:

none, but word's maps are modified!

Calls word_deletable()

Definition at line 1030 of file docqual.cpp.

References WERD_RES::best_choice, CR_NONE, FALSE, WERD::flag(), PAGE_RES_IT::forward(), merge_tess_fails(), NULL, PAGE_RES_IT::restart_page(), tprintf(), TRUE, WERD_RES::unlv_crunch_mode, W_BOL, W_EOL, PAGE_RES_IT::word(), WERD_RES::word, and word_deletable().

Referenced by quality_based_rejection().

                                            { 
  WERD_RES *word;
  PAGE_RES_IT copy_it;
  BOOL8 deleting_from_bol = FALSE;
  BOOL8 marked_delete_point = FALSE;
  INT16 debug_delete_mode;
  CRUNCH_MODE delete_mode;
  INT16 x_debug_delete_mode;
  CRUNCH_MODE x_delete_mode;

  page_res_it.restart_page ();
  while (page_res_it.word () != NULL) {
    word = page_res_it.word ();

    delete_mode = word_deletable (word, debug_delete_mode);
    if (delete_mode != CR_NONE) {
      if (word->word->flag (W_BOL) || deleting_from_bol) {
        if (crunch_debug > 0) {
          tprintf ("BOL CRUNCH DELETING(%d): \"%s\"\n",
            debug_delete_mode,
            word->best_choice->string ().string ());
        }
        word->unlv_crunch_mode = delete_mode;
        deleting_from_bol = TRUE;
      }
      else if (word->word->flag (W_EOL)) {
        if (marked_delete_point) {
          while (copy_it.word () != word) {
            x_delete_mode = word_deletable (copy_it.word (),
              x_debug_delete_mode);
            if (crunch_debug > 0) {
              tprintf ("EOL CRUNCH DELETING(%d): \"%s\"\n",
                x_debug_delete_mode,
                copy_it.word ()->best_choice->string ().
                string ());
            }
            copy_it.word ()->unlv_crunch_mode = x_delete_mode;
            copy_it.forward ();
          }
        }
        if (crunch_debug > 0) {
          tprintf ("EOL CRUNCH DELETING(%d): \"%s\"\n",
            debug_delete_mode,
            word->best_choice->string ().string ());
        }
        word->unlv_crunch_mode = delete_mode;
        deleting_from_bol = FALSE;
        marked_delete_point = FALSE;
      }
      else {
        if (!marked_delete_point) {
          copy_it = page_res_it;
          marked_delete_point = TRUE;
        }
      }
    }
    else {
      deleting_from_bol = FALSE;
      marked_delete_point = FALSE; // Forget earlier potential crunches
    }
    /* The following step has been left till now as the tess fails are used to
      determine if the word is deletable.
    */
    if (!crunch_early_merge_tess_fails)
      merge_tess_fails(word); 
    page_res_it.forward ();
  }
}

void unrej_good_chs	(	WERD_RES *	word,
		ROW *	row
	)

Unreject POTENTIAL rejects if the blob passes the blob and outline checks.

Parameters:

	word	Word in question
	row	word's row?

Note:

Global:

• docqual_excuse_outline_errs and
• bln_x_height

Returns:

none, updates word's reject_map

Definition at line 371 of file docqual.cpp.

References WERD_RES::best_choice, WERD::blob_list(), PBLOB::bounding_box(), count_outline_errs(), crude_match_blobs(), delete_word(), WERD_RES::denorm, FALSE, WERD::gblob_list(), BOX::left(), make_bln_copy(), make_ed_word(), make_tess_word(), NULL, WERD_RES::outword, WERD_RES::reject_map, DENORM::scale(), and WERD_RES::word.

Referenced by unrej_good_quality_words().

                                              { 
  WERD *bln_word;                //BL norm init word
  TWERD *tessword;               //tess format
  WERD *init_word;               //BL norm init word
  PBLOB_IT outword_it;
  PBLOB_IT initial_it;
  INT16 i;
  INT16 init_blobs_left;
  BOOL8 matched;
  BOX out_box;
  PBLOB *test_blob;
  DENORM denorm;
  float bln_xht;
  INT16 j = 0;

  if (word->word->gblob_list ()->empty ())
    return;

  bln_xht = bln_x_height / word->denorm.scale (); // xht used for blnorm
  bln_word = make_bln_copy (word->word, row, bln_xht, &denorm);
  /* NOTE: Need to convert to tess format and back again to ensure that the
    same float -> int rounding of coords is done to source wd as out wd before
    comparison
  */
  tessword = make_tess_word (bln_word, NULL);
  init_word = make_ed_word (tessword, bln_word); // convert word
  delete bln_word;
  delete_word(tessword);  // get rid of it

  initial_it.set_to_list (init_word->blob_list ());
  init_blobs_left = initial_it.length ();
  outword_it.set_to_list (word->outword->blob_list ());

  for (outword_it.mark_cycle_pt ();
  !outword_it.cycled_list (); outword_it.forward ()) {
    out_box = outword_it.data ()->bounding_box ();

    /* Skip any initial blobs LEFT of current outword blob */
    while (!initial_it.at_last () &&
    (initial_it.data ()->bounding_box ().left () < out_box.left ())) {
      initial_it.forward ();
      init_blobs_left--;
    }

    /* See if current outword blob matches any initial blob with the same left
      coord. (Normally only one but possibly more - in unknown order) */
    i = 0;
    matched = FALSE;
    do {
      test_blob = initial_it.data_relative (i++);
      matched = crude_match_blobs (test_blob, outword_it.data ());
      if (matched &&
        (word->reject_map[j].accept_if_good_quality ()) &&
        (docqual_excuse_outline_errs ||
        (count_outline_errs (word->best_choice->string ()[j],
        outword_it.data ()->out_list ()->
        length ()) == 0)))
        word->reject_map[j].setrej_quality_accept ();
    }
    while (!matched &&
      (init_blobs_left - i > 0) &&
      (i < 129) &&
      !initial_it.at_last () &&
      test_blob->bounding_box ().left () == out_box.left ());
    j++;
  }
  delete init_word;
}

void unrej_good_quality_words

(

PAGE_RES_IT &

page_res_it

)

Unreject potential.

Parameters:

page_res_it

pointer to page in question ?

Returns:

none

Accept potential rejects in words which pass some checks

- Contains a potential reject
- Word looks like a sensible alpha word.
- Word segmentation is the same as the original image
	- All characters have the expected number of outlines
	- NOTE: the rejection counts are recalculated after unrejection
	- CANT do it in a single pass without a bit of fiddling
	- keep it simple but inefficient

Definition at line 533 of file docqual.cpp.

References AC_UNACCEPTABLE, acceptable_word_string(), WERD_RES::best_choice, PAGE_RES_IT::block(), ROW_RES::char_count, BLOCK_RES::char_count, check_debug_pt(), PAGE_RES_IT::forward(), REJMAP::length(), NULL, PAGE_RES_IT::page_res, REJMAP::quality_recoverable_rejects(), ROW_RES::rej_count, BLOCK_RES::rej_count, PAGE_RES_IT::rej_stat_word(), WERD_RES::reject_map, PAGE_RES_IT::restart_page(), PAGE_RES_IT::row(), ROW_RES::row, unrej_good_chs(), ROW_RES::whole_word_rej_count, and PAGE_RES_IT::word().

Referenced by quality_based_rejection().

                                                        {
  WERD_RES *word;
  ROW_RES *current_row;
  BLOCK_RES *current_block;
  int i;

  page_res_it.restart_page ();
  while (page_res_it.word () != NULL) {
    check_debug_pt (page_res_it.word (), 100);
    if (bland_unrej) {
      word = page_res_it.word ();
      for (i = 0; i < word->reject_map.length (); i++) {
        if (word->reject_map[i].accept_if_good_quality ())
          word->reject_map[i].setrej_quality_accept ();
      }
      page_res_it.forward ();
    }
    else if ((page_res_it.row ()->char_count > 0) &&
      ((page_res_it.row ()->rej_count /
      (float) page_res_it.row ()->char_count) <=
    quality_rowrej_pc)) {
      word = page_res_it.word ();
      if (word->reject_map.quality_recoverable_rejects () &&
        (tessedit_unrej_any_wd ||
        acceptable_word_string (word->best_choice->string ().string ())
      != AC_UNACCEPTABLE)) {
        unrej_good_chs (word, page_res_it.row ()->row);
      }
      page_res_it.forward ();
    }
    else {
      /* Skip to end of dodgy row */
      current_row = page_res_it.row ();
      while ((page_res_it.word () != NULL) &&
        (page_res_it.row () == current_row))
        page_res_it.forward ();
    }
    check_debug_pt (page_res_it.word (), 110);
  }
  page_res_it.restart_page ();
  page_res_it.page_res->char_count = 0;
  page_res_it.page_res->rej_count = 0;
  current_block = NULL;
  current_row = NULL;
  while (page_res_it.word () != NULL) {
    if (current_block != page_res_it.block ()) {
      current_block = page_res_it.block ();
      current_block->char_count = 0;
      current_block->rej_count = 0;
    }
    if (current_row != page_res_it.row ()) {
      current_row = page_res_it.row ();
      current_row->char_count = 0;
      current_row->rej_count = 0;
      current_row->whole_word_rej_count = 0;
    }
    page_res_it.rej_stat_word ();
    page_res_it.forward ();
  }
}

INT16 word_blob_quality	(	WERD_RES *	word,
		ROW *	row
	)

Find number of blobs in outword that are identical to those of inword.

Parameters:

	word	Word in question
	row	Row the word came from

Returns:

Count of good blobs

ASSUME blobs in both initial word and outword are in ascending order of left hand blob edge.

Todo:

outword is word on edges of block vs inword is any word within a block, right (in word_blob_quality())?

Definition at line 139 of file docqual.cpp.

References WERD::blob_list(), PBLOB::bounding_box(), cprintf(), crude_match_blobs(), delete_word(), WERD_RES::denorm, FALSE, WERD::gblob_list(), BOX::left(), make_bln_copy(), make_ed_word(), make_tess_word(), NULL, WERD_RES::outword, DENORM::scale(), and WERD_RES::word.

Referenced by recog_all_words(), and recog_interactive().

                                  {
  WERD *bln_word;                //BL norm init word
  TWERD *tessword;               //tess format
  WERD *init_word;               //BL norm init word
  PBLOB_IT outword_it;
  PBLOB_IT initial_it;
  INT16 i;
  INT16 init_blobs_left;
  INT16 match_count = 0;
  BOOL8 matched;
  BOX out_box;
  PBLOB *test_blob;
  DENORM denorm;
  float bln_xht;

#ifdef TEXT_VERBOSE
  // gets a 'v', see ccmain/tesseractmain.dox
  cprintf("v");
#endif
  if (word->word->gblob_list ()->empty ())
    return 0;
  bln_xht = bln_x_height / word->denorm.scale (); //xht used for blnorm
  bln_word = make_bln_copy (word->word, row, bln_xht, &denorm);

  /* NOTE: Need to convert to tess format and back again to ensure that the
    same float -> int rounding of coords is done to source wd as out wd before
    comparison
  */

  //   if (!bln_word->flag(W_POLYGON))
  //           tprintf( "NON POLYGON BLN WERD\n");
  tessword = make_tess_word (bln_word, NULL);
  init_word = make_ed_word (tessword, bln_word); // convert word
  //   if (!init_word->flag(W_POLYGON))
  //         tprintf( "NON POLYGON INIT WERD\n");
  //   tprintf( "SOURCE BLOBS-AFTER TESS:\n");
  //   print_boxes( init_word );
  //   tprintf( "OUTPUT BLOBS:\n");
  //   print_boxes( word->outword );

  initial_it.set_to_list (init_word->blob_list ());
  init_blobs_left = initial_it.length ();
  outword_it.set_to_list (word->outword->blob_list ());
  delete bln_word;
  delete_word(tessword);  //get rid of it

  for (outword_it.mark_cycle_pt ();
  !outword_it.cycled_list (); outword_it.forward ()) {
    out_box = outword_it.data ()->bounding_box ();

    /* Skip any initial blobs LEFT of current outword blob */
    while (!initial_it.at_last () &&
    (initial_it.data ()->bounding_box ().left () < out_box.left ())) {
      initial_it.forward ();
      init_blobs_left--;
    }

    /* See if current outword blob matches any initial blob with the same left
      coord. (Normally only one but possibly more - in unknown order) */

    i = 0;
    matched = FALSE;
    do {
      test_blob = initial_it.data_relative (i++);
      matched = crude_match_blobs (test_blob, outword_it.data ());
      if (matched)
        match_count++;
    }
    while (!matched &&
      (init_blobs_left - i > 0) &&
      (i < 129) &&
      !initial_it.at_last () &&
      test_blob->bounding_box ().left () == out_box.left ());
  }
  delete init_word;
  return match_count;
}

void word_char_quality	(	WERD_RES *	word,
		ROW *	row,
		INT16 *	match_count,
		INT16 *	accepted_match_count
	)

Check word's blobs' quality.

Parameters:

	word	Word in question
	row	word's row?
	match_count	Return variable for caller
	accepted_match_count	Return variable for caller

Note:

Global: bln_x_height

Returns:

none

Combination of blob quality and outline quality & determine how many good chars are there - i.e., chars which pass the blob AND outline tests.

Definition at line 277 of file docqual.cpp.

References WERD_RES::best_choice, WERD::blob_list(), PBLOB::bounding_box(), count_outline_errs(), cprintf(), crude_match_blobs(), delete_word(), WERD_RES::denorm, FALSE, WERD::gblob_list(), BOX::left(), make_bln_copy(), make_ed_word(), make_tess_word(), NULL, WERD_RES::outword, WERD_RES::reject_map, DENORM::scale(), and WERD_RES::word.

Referenced by classify_word_pass2(), doc_and_block_rejection(), recog_all_words(), and recog_interactive().

                                                    {
  WERD *bln_word;                //BL norm init word
  TWERD *tessword;               //tess format
  WERD *init_word;               //BL norm init word
  PBLOB_IT outword_it;
  PBLOB_IT initial_it;
  INT16 i;
  INT16 init_blobs_left;
  BOOL8 matched;
  BOX out_box;
  PBLOB *test_blob;
  DENORM denorm;
  float bln_xht;
  INT16 j = 0;

#ifdef TEXT_VERBOSE
  // gets a 'y', see ccmain/tessvars.doxfg
  cprintf("y");
#endif
  *match_count = 0;
  *accepted_match_count = 0;
  if (word->word->gblob_list ()->empty ())
    return;

  bln_xht = bln_x_height / word->denorm.scale (); //xht used for blnorm
  bln_word = make_bln_copy (word->word, row, bln_xht, &denorm);
  /* NOTE: Need to convert to tess format and back again to ensure that the
    same float -> int rounding of coords is done to source wd as out wd before
    comparison
  */
  tessword = make_tess_word (bln_word, NULL);
  init_word = make_ed_word (tessword, bln_word); //convert word
  delete bln_word;
  delete_word(tessword);  //get rid of it
  //   tprintf( "SOURCE BLOBS-AFTER TESS:\n");
  //   print_boxes( init_word );
  //   tprintf( "OUTPUT BLOBS:\n");
  //   print_boxes( word->outword );

  initial_it.set_to_list (init_word->blob_list ());
  init_blobs_left = initial_it.length ();
  outword_it.set_to_list (word->outword->blob_list ());

  for (outword_it.mark_cycle_pt ();
  !outword_it.cycled_list (); outword_it.forward ()) {
    out_box = outword_it.data ()->bounding_box ();

    /* Skip any initial blobs LEFT of current outword blob */
    while (!initial_it.at_last () &&
    (initial_it.data ()->bounding_box ().left () < out_box.left ())) {
      initial_it.forward ();
      init_blobs_left--;
    }

    /* See if current outword blob matches any initial blob with the same left
      coord. (Normally only one but possibly more - in unknown order) */

    i = 0;
    matched = FALSE;
    do {
      test_blob = initial_it.data_relative (i++);
      matched = crude_match_blobs (test_blob, outword_it.data ());
      if (matched &&
        (count_outline_errs (word->best_choice->string ()[j],
        outword_it.data ()->out_list ()->length ()) == 0)) {
        (*match_count)++;
        if (word->reject_map[j].accepted ())
          (*accepted_match_count)++;
      }
    }
    while (!matched &&
      (init_blobs_left - i > 0) &&
      (i < 129) &&
      !initial_it.at_last () &&
      test_blob->bounding_box ().left () == out_box.left ());
    j++;
  }
  delete init_word;
}

CRUNCH_MODE word_deletable	(	WERD_RES *	word,
		INT16 &	delete_mode
	)

Delete suspicious word if a bunch of constraints are met.

Parameters:

	word	Word in question
	delete_mode	Actually a return value (0..11) for tilde_delete()

Note:

Global:

• bln_baseline_offset,
• bln_x_height,
• crunch_del_min_ht,
• crunch_del_min_width,
• crunch_del_max_ht,
• crunch_del_low_word,
• crunch_del_high_word,
• crunch_del_rating,
• crunch_del_cert.

Returns:

• CR_DELETE,
• CR_NONE,
• CR_LOOSE_SPACE

DELETE WERDS AT ENDS OF ROWS IF
   Word is crunched AND
   ( string length = 0                                          OR
     > 50% of chars are "|" (before merging)                    OR
     certainty < -10                                            OR
     rating /char > 60                                          OR
     TOP of word is more than 0.5 xht BELOW baseline            OR
     BOTTOM of word is more than 0.5 xht ABOVE xht              OR
     length of word < 3xht                                      OR
     height of word < 0.7 xht                                   OR
     height of word > 3.0 xht                                   OR
     >75% of the outline BBs have longest dimension < 0.5xht )

Definition at line 1409 of file docqual.cpp.

References BOX::bottom(), WERD::bounding_box(), CR_DELETE, CR_LOOSE_SPACE, CR_NONE, failure_count(), BOX::height(), REJMAP::length(), noise_outlines(), WERD_RES::outword, WERD_RES::reject_map, BOX::top(), WERD_RES::unlv_crunch_mode, and BOX::width().

Referenced by tilde_delete().

                                                               { 
  int word_len = word->reject_map.length ();
  float rating_per_ch;
  BOX box;                       // BB of word

  if (word->unlv_crunch_mode == CR_NONE) {
    delete_mode = 0;
    return CR_NONE;
  }

  if (word_len == 0) {
    delete_mode = 1;
    return CR_DELETE;
  }

  box = word->outword->bounding_box ();
  if (box.height () < crunch_del_min_ht * bln_x_height) {
    delete_mode = 4;
    return CR_DELETE;
  }

  if (noise_outlines (word->outword)) {
    delete_mode = 5;
    return CR_DELETE;
  }

  if ((failure_count (word) * 1.5) > word_len) {
    delete_mode = 2;
    return CR_LOOSE_SPACE;
  }

  if (word->best_choice->certainty () < crunch_del_cert) {
    delete_mode = 7;
    return CR_LOOSE_SPACE;
  }

  rating_per_ch = word->best_choice->rating () / word_len;

  if (rating_per_ch > crunch_del_rating) {
    delete_mode = 8;
    return CR_LOOSE_SPACE;
  }

  if (box.top () < bln_baseline_offset - crunch_del_low_word * bln_x_height) {
    delete_mode = 9;
    return CR_LOOSE_SPACE;
  }

  if (box.bottom () >
  bln_baseline_offset + crunch_del_high_word * bln_x_height) {
    delete_mode = 10;
    return CR_LOOSE_SPACE;
  }

  if (box.height () > crunch_del_max_ht * bln_x_height) {
    delete_mode = 11;
    return CR_LOOSE_SPACE;
  }

  if (box.width () < crunch_del_min_width * bln_x_height) {
    delete_mode = 3;
    return CR_LOOSE_SPACE;
  }

  delete_mode = 0;
  return CR_NONE;
}

INT16 word_outline_errs

(

WERD_RES *

word

)

Count errors in word's outlines using count_outline_errs().

Parameters:

word

Word

Returns:

count of errors

Definition at line 246 of file docqual.cpp.

References WERD_RES::best_choice, WERD::blob_list(), count_outline_errs(), and WERD_RES::outword.

Referenced by recog_all_words(), and recog_interactive().

                                        {
  PBLOB_IT outword_it;
  INT16 i = 0;
  INT16 err_count = 0;

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

  for (outword_it.mark_cycle_pt ();
  !outword_it.cycled_list (); outword_it.forward ()) {
    err_count += count_outline_errs (word->best_choice->string ()[i],
      outword_it.data ()->out_list ()-> length ());
    i++;
  }
  return err_count;
}

---