tesseract_bin 1.0.0

data/vendor/tesseract-2.04/ccmain/fixxht.cpp

@@ -0,0 +1,825 @@
+/**********************************************************************
+ * File:        fixxht.cpp  (Formerly fixxht.c)
+ * Description: Improve x_ht and look out for case inconsistencies
+ * Author:		Phil Cheatle
+ * Created:		Thu Aug  5 14:11:08 BST 1993
+ *
+ * (C) Copyright 1992, 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.
+ *
+ **********************************************************************/
+
+#include "mfcpch.h"
+#include          <string.h>
+#include          <ctype.h>
+#include          "varable.h"
+#include          "tessvars.h"
+#include          "control.h"
+#include          "reject.h"
+#include          "fixxht.h"
+#include          "secname.h"
+
+#define EXTERN
+
+EXTERN double_VAR (x_ht_fraction_of_caps_ht, 0.7,
+"Fract of cps ht est of xht");
+EXTERN double_VAR (x_ht_variation, 0.35,
+"Err band as fract of caps/xht dist");
+EXTERN double_VAR (x_ht_sub_variation, 0.5,
+"Err band as fract of caps/xht dist");
+EXTERN BOOL_VAR (rej_trial_ambigs, TRUE,
+"reject x-ht ambigs when under trial");
+EXTERN BOOL_VAR (x_ht_conservative_ambigs, FALSE,
+"Dont rely on ambigs + maxht");
+EXTERN BOOL_VAR (x_ht_check_est, TRUE, "Cross check estimates");
+EXTERN BOOL_VAR (x_ht_case_flip, FALSE, "Flip or reject suspect case");
+EXTERN BOOL_VAR (x_ht_include_dodgy_blobs, TRUE,
+"Include blobs with possible noise?");
+EXTERN BOOL_VAR (x_ht_limit_flip_trials, TRUE,
+"Dont do trial flips when ambigs are close to xht?");
+EXTERN BOOL_VAR (rej_use_check_block_occ, TRUE,
+"Analyse rejection behaviour");
+
+EXTERN STRING_VAR (chs_non_ambig_caps_ht,
+"!#$%&()/12346789?ABDEFGHIKLNQRT[]\\bdfhkl",
+"Reliable ascenders");
+EXTERN STRING_VAR (chs_x_ht, "acegmnopqrsuvwxyz", "X height chars");
+EXTERN STRING_VAR (chs_non_ambig_x_ht, "aenqr", "reliable X height chars");
+EXTERN STRING_VAR (chs_ambig_caps_x, "cCmMoO05sSuUvVwWxXzZ",
+"X ht or caps ht chars");
+EXTERN STRING_VAR (chs_bl_ambig_caps_x, "pPyY", " Caps or descender ambigs");
+
+/* The following arent used in this module but are used in applybox.c */
+EXTERN STRING_VAR (chs_caps_ht,
+"!#$%&()/0123456789?ABCDEFGHIJKLMNOPQRSTUVWXYZ[]\\bdfhkl{|}",
+"Ascender chars");
+EXTERN STRING_VAR (chs_desc, "gjpqy", "Descender chars");
+EXTERN STRING_VAR (chs_non_ambig_bl,
+"!#$%&01246789?ABCDEFGHIKLMNORSTUVWXYZabcdehiklmnorstuvwxz",
+"Reliable baseline chars");
+EXTERN STRING_VAR (chs_odd_top, "ijt", "Chars with funny ascender region");
+EXTERN STRING_VAR (chs_odd_bot, "()35JQ[]\\/{}|", "Chars with funny base");
+
+/* The following arent used but are defined for completeness */
+EXTERN STRING_VAR (chs_bl,
+"!#$%&()/01246789?ABCDEFGHIJKLMNOPRSTUVWXYZ[]\\abcdefhiklmnorstuvwxz{}",
+"Baseline chars");
+EXTERN STRING_VAR (chs_non_ambig_desc, "gq", "Reliable descender chars");
+
+/*************************************************************************
+ * re_estimate_x_ht()
+ *
+ * Walk the blobs in the word together with the text string and reject map.
+ * NOTE: All evaluation is done on the baseline normalised word. This is so that
+ * the TBOX class can be used (integer). The reasons for this are:
+ *   a) We must use the outword - ie the Tess result
+ *   b) The outword is always converted to integer representation as that is how
+ *      Tess works
+ *   c) We would like to use the TBOX class, cos its there - this is integer
+ *      precision.
+ *   d) If we de-normed the outword we would get rounding errors and would find
+ *      that integers are too imprecise (x-height around 15 pixels instead of a
+ *      scale of 128 in bln form.
+ *   CONVINCED?
+ *
+ * A) Try to re-estimatate x-ht and caps ht from confirmed pts in word.
+ *
+ *    FOR each non reject blob
+ *       IF char is baseline posn ambiguous
+ *			Remove ambiguity by comparing its posn with respect to baseline.
+ *		IF char is a confirmed x-ht char
+ *			Add x-ht posn to confirmed_x_ht pts for word
+ *    IF char is a confirmed caps-ht char
+ *			Add blob_ht to caps ht pts for word
+ *
+ *    IF Std Dev of caps hts < 2  (AND # samples > 0)
+ *		Use mean as caps ht estimate (Dont use median as we can expect a
+ *			fair variation between the heights of the NON_AMBIG_CAPS_HT_CHS)
+ *    IF Std Dev of caps hts >= 2  (AND # samples > 0)
+ *			Suspect small caps font.
+ *			Look for 2 clusters,	each with Std Dev < 2.
+ *			IF 2 clusters found
+ *			Pick the smaller median as the caps ht estimate of the smallcaps.
+ *
+ *    IF failed to estimate a caps ht
+ *       Use the median caps ht if there is one,
+ *		ELSE use the caps ht estimate of the previous word. NO!!!
+ *
+ *
+ *    IF there are confirmed x-height chars
+ *			Estimate confirmed x-height as the median value
+ *    ELSE IF there is a confirmed caps ht
+ *			Estimate confirmed x-height as a fraction of confirmed caps ht value
+ *		ELSE
+ *			Use the value for the previous word or the row value if this is the
+ *			first word in the block. NO!!!
+ *
+ * B) Add in case ambiguous blobs based on confirmed x-ht/caps ht, changing case
+ *    as necessary. Reestimate caps ht and x-ht as in A, using the extended
+ *    clusters.
+ *
+ * C) If word contains rejects, and x-ht estimate significantly differs from
+ *    original estimate, return TRUE so that the word can be rematched
+ *************************************************************************/
+
+void re_estimate_x_ht(                     //improve for 1 word
+                      WERD_RES *word_res,  //word to do
+                      float *trial_x_ht    //new match value
+                     ) {
+  PBLOB_IT blob_it;
+  inT16 blob_ht_above_baseline;
+
+  const char *word_str;
+  inT16 i;
+  inT16 offset;
+
+  STATS all_blobs_ht (0, 300);   //every blob in word
+  STATS x_ht (0, 300);           //confirmed pts in wd
+  STATS caps_ht (0, 300);        //confirmed pts in wd
+  STATS case_ambig (0, 300);     //lower case ambigs
+
+  inT16 rej_blobs_count = 0;
+  inT16 rej_blobs_max_height = 0;
+  inT32 rej_blobs_max_area = 0;
+  float x_ht_ok_variation;
+  float max_blob_ht;
+  float marginally_above_x_ht;
+
+  TBOX blob_box;                  //blob bounding box
+  float est_x_ht = 0.0;          //word estimate
+  float est_caps_ht = 0.0;       //word estimate
+                                 //based on hard data?
+  BOOL8 est_caps_ht_certain = FALSE;
+  BOOL8 est_x_ht_certain = FALSE;//based on hard data?
+  BOOL8 trial = FALSE;           //Sepeculative values?
+  BOOL8 no_comment = FALSE;      //No change in xht
+  float ambig_lc_x_est;
+  float ambig_uc_caps_est;
+  inT16 x_ht_ambigs = 0;
+  inT16 caps_ht_ambigs = 0;
+
+  /* Calculate default variation of blob x_ht from bln x_ht for bln word */
+  x_ht_ok_variation =
+    (bln_x_height / x_ht_fraction_of_caps_ht - bln_x_height) * x_ht_variation;
+
+  word_str = word_res->best_choice->string ().string ();
+  /*
+    Cycle blobs, allocating to one of the stats sets when possible.
+  */
+  blob_it.set_to_list (word_res->outword->blob_list ());
+  for (blob_it.mark_cycle_pt (), i = 0, offset = 0;
+  !blob_it.cycled_list (); blob_it.forward (),
+           offset += word_res->best_choice->lengths()[i++]) {
+    if (!dodgy_blob (blob_it.data ())) {
+      blob_box = blob_it.data ()->bounding_box ();
+      blob_ht_above_baseline = blob_box.top () - bln_baseline_offset;
+      all_blobs_ht.add (blob_ht_above_baseline, 1);
+
+      if (word_res->reject_map[i].rejected ()) {
+        rej_blobs_count++;
+        if (blob_box.height () > rej_blobs_max_height)
+          rej_blobs_max_height = blob_box.height ();
+        if (blob_box.area () > rej_blobs_max_area)
+          rej_blobs_max_area = blob_box.area ();
+      }
+      else {
+        if (STRING (chs_non_ambig_x_ht).contains (word_str[offset]))
+          x_ht.add (blob_ht_above_baseline, 1);
+
+        if (STRING (chs_non_ambig_caps_ht).contains (word_str[offset]))
+          caps_ht.add (blob_ht_above_baseline, 1);
+
+        if (STRING (chs_ambig_caps_x).contains (word_str[offset])) {
+          case_ambig.add (blob_ht_above_baseline, 1);
+          if (STRING (chs_x_ht).contains (word_str[offset]))
+            x_ht_ambigs++;
+          else
+            caps_ht_ambigs++;
+        }
+
+        if (STRING (chs_bl_ambig_caps_x).contains (word_str[offset])) {
+          if (STRING (chs_x_ht).contains (word_str[offset])) {
+            /* confirm x_height provided > 15% total height below baseline */
+            if ((bln_baseline_offset - blob_box.bottom ()) /
+              (float) blob_box.height () > 0.15)
+              x_ht.add (blob_ht_above_baseline, 1);
+          }
+          else {
+            /* confirm caps_height provided < 5% total height below baseline */
+            if ((bln_baseline_offset - blob_box.bottom ()) /
+              (float) blob_box.height () < 0.05)
+              caps_ht.add (blob_ht_above_baseline, 1);
+          }
+        }
+      }
+    }
+  }
+  est_caps_ht = estimate_from_stats (caps_ht);
+  est_x_ht = estimate_from_stats (x_ht);
+  est_ambigs(word_res, case_ambig, &ambig_lc_x_est, &ambig_uc_caps_est);
+  max_blob_ht = all_blobs_ht.ile (0.9999);
+
+  #ifndef SECURE_NAMES
+  if (debug_x_ht_level >= 20) {
+    tprintf ("Mode20:A: %s ", word_str);
+    word_res->reject_map.print (debug_fp);
+    tprintf (" XHT:%f CAP:%f MAX:%f AMBIG X:%f CAP:%f\n",
+      est_x_ht, est_caps_ht, max_blob_ht,
+      ambig_lc_x_est, ambig_uc_caps_est);
+  }
+  #endif
+  if (!x_ht_conservative_ambigs &&
+    (ambig_lc_x_est > 0) &&
+    (ambig_lc_x_est == ambig_uc_caps_est) &&
+  (max_blob_ht > ambig_lc_x_est + x_ht_ok_variation)) {
+                                 //may be zero but believe xht
+    ambig_uc_caps_est = est_caps_ht;
+    #ifndef SECURE_NAMES
+    if (debug_x_ht_level >= 20)
+      tprintf ("Mode20:B: Fiddle ambig_uc_caps_est to %f\n",
+        ambig_lc_x_est);
+    #endif
+  }
+
+  /* Now make some estimates */
+
+  if ((est_x_ht > 0) ||
+    (est_caps_ht > 0) ||
+  ((ambig_lc_x_est > 0) && (ambig_lc_x_est != ambig_uc_caps_est))) {
+    /* There is some sensible data to go on so make the most of it. */
+    if (debug_x_ht_level >= 20)
+      tprintf ("Mode20:C: Sensible Data\n", ambig_lc_x_est);
+    if (est_x_ht > 0) {
+      est_x_ht_certain = TRUE;
+      if (est_caps_ht == 0) {
+        if ((ambig_uc_caps_est > ambig_lc_x_est) &&
+          (ambig_uc_caps_est > est_x_ht + x_ht_ok_variation))
+          est_caps_ht = ambig_uc_caps_est;
+        else
+          est_caps_ht = est_x_ht / x_ht_fraction_of_caps_ht;
+      }
+      if (case_ambig.get_total () > 0)
+        improve_estimate(word_res, est_x_ht, est_caps_ht, x_ht, caps_ht);
+      est_caps_ht_certain = caps_ht.get_total () > 0;
+      #ifndef SECURE_NAMES
+      if (debug_x_ht_level >= 20)
+        tprintf ("Mode20:D: Est from xht XHT:%f CAP:%f\n",
+          est_x_ht, est_caps_ht);
+      #endif
+    }
+    else if (est_caps_ht > 0) {
+      est_caps_ht_certain = TRUE;
+      if ((ambig_lc_x_est > 0) &&
+        (ambig_lc_x_est < est_caps_ht - x_ht_ok_variation))
+        est_x_ht = ambig_lc_x_est;
+      else
+        est_x_ht = est_caps_ht * x_ht_fraction_of_caps_ht;
+      if (ambig_lc_x_est + ambig_uc_caps_est > 0)
+        improve_estimate(word_res, est_x_ht, est_caps_ht, x_ht, caps_ht);
+      est_x_ht_certain = x_ht.get_total () > 0;
+      #ifndef SECURE_NAMES
+      if (debug_x_ht_level >= 20)
+        tprintf ("Mode20:E: Est from caps XHT:%f CAP:%f\n",
+          est_x_ht, est_caps_ht);
+      #endif
+    }
+    else {
+      /* Do something based on case ambig chars alone - we have guessed that the
+        ambigs are lower case. */
+      est_x_ht = ambig_lc_x_est;
+      est_x_ht_certain = TRUE;
+      if (ambig_uc_caps_est > ambig_lc_x_est) {
+        est_caps_ht = ambig_uc_caps_est;
+        est_caps_ht_certain = TRUE;
+      }
+      else
+        est_caps_ht = est_x_ht / x_ht_fraction_of_caps_ht;
+
+      #ifndef SECURE_NAMES
+      if (debug_x_ht_level >= 20)
+        tprintf ("Mode20:F: Est from ambigs XHT:%f CAP:%f\n",
+          est_x_ht, est_caps_ht);
+      #endif
+    }
+    /* Check for sane interpretation of evidence:
+      Try shifting caps ht if min certain caps ht is not significantly greater
+      than the estimated x ht or the max certain x ht is not significantly less
+      than the estimated caps ht. */
+    if (x_ht_check_est) {
+      if ((caps_ht.get_total () > 0) &&
+      (est_x_ht + x_ht_ok_variation >= caps_ht.ile (0.0001))) {
+        trial = TRUE;
+        est_caps_ht = est_x_ht;
+        est_x_ht = x_ht_fraction_of_caps_ht * est_caps_ht;
+
+        #ifndef SECURE_NAMES
+        if (debug_x_ht_level >= 20)
+          tprintf ("Mode20:G: Trial XHT:%f CAP:%f\n",
+            est_x_ht, est_caps_ht);
+        #endif
+      }
+      else if ((x_ht.get_total () > 0) &&
+      (est_caps_ht - x_ht_ok_variation <= x_ht.ile (0.9999))) {
+        trial = TRUE;
+        est_x_ht = est_caps_ht;
+        est_caps_ht = est_x_ht / x_ht_fraction_of_caps_ht;
+        #ifndef SECURE_NAMES
+        if (debug_x_ht_level >= 20)
+          tprintf ("Mode20:H: Trial XHT:%f CAP:%f\n",
+            est_x_ht, est_caps_ht);
+        #endif
+      }
+    }
+  }
+
+  else {
+    /* There is no sensible data so we're in the dark. */
+
+    marginally_above_x_ht = bln_x_height +
+      x_ht_ok_variation * x_ht_sub_variation;
+    /*
+      If there are no rejects, or the only rejects have a narrow height, or have
+      a small area compared to a normal char, then estimate the x-height as the
+      original one. (I.e dont fiddle about if the only rejects look like
+      punctuation) - we use max height as mean or median will be too low if
+      there are only two blobs - Eg "F."
+    */
+
+    if (debug_x_ht_level >= 20)
+      tprintf ("Mode20:I: In the dark\n");
+
+    if ((rej_blobs_count == 0) ||
+      (rej_blobs_max_height < 0.3 * max_blob_ht) ||
+    (rej_blobs_max_area < 0.3 * max_blob_ht * max_blob_ht)) {
+      no_comment = TRUE;
+      if (debug_x_ht_level >= 20)
+        tprintf ("Mode20:J: No comment due to no rejects\n");
+    }
+    else if (x_ht_limit_flip_trials &&
+      ((max_blob_ht < marginally_above_x_ht) ||
+      ((ambig_lc_x_est > 0) &&
+      (ambig_lc_x_est == ambig_uc_caps_est) &&
+    (ambig_lc_x_est < marginally_above_x_ht)))) {
+      no_comment = TRUE;
+      if (debug_x_ht_level >= 20)
+        tprintf ("Mode20:K: No comment as close to xht %f < %f\n",
+          ambig_lc_x_est, marginally_above_x_ht);
+    }
+    else if (x_ht_conservative_ambigs && (ambig_uc_caps_est > 0)) {
+      trial = TRUE;
+      est_caps_ht = ambig_lc_x_est;
+      est_x_ht = x_ht_fraction_of_caps_ht * est_caps_ht;
+
+      #ifndef SECURE_NAMES
+      if (debug_x_ht_level >= 20)
+        tprintf ("Mode20:L: Trial XHT:%f CAP:%f\n",
+          est_x_ht, est_caps_ht);
+      #endif
+    }
+    /*
+      If the top of the word is nowhere near where we expect ascenders to be
+      (less than half the x_ht -> caps_ht distance) - suspect an all caps word
+      at the x-ht. Estimate x-ht accordingly - but only as a TRIAL!
+      NOTE we do NOT check location of baseline. Commas can descend as much as
+      real descenders so we would need to do something to make sure that any
+      disqualifying descenders were not at the end.
+    */
+    else {
+      if (max_blob_ht <
+      (bln_x_height + bln_x_height / x_ht_fraction_of_caps_ht) / 2.0) {
+        trial = TRUE;
+        est_x_ht = x_ht_fraction_of_caps_ht * max_blob_ht;
+        est_caps_ht = max_blob_ht;
+
+        #ifndef SECURE_NAMES
+        if (debug_x_ht_level >= 20)
+          tprintf ("Mode20:M: Trial XHT:%f CAP:%f\n",
+            est_x_ht, est_caps_ht);
+        #endif
+      }
+      else {
+        no_comment = TRUE;
+        if (debug_x_ht_level >= 20)
+          tprintf ("Mode20:N: No comment as nothing else matched\n");
+      }
+    }
+  }
+
+  /* Sanity check - reject word if fails */
+
+  if (!no_comment &&
+    ((est_x_ht > 2 * bln_x_height) ||
+    (est_x_ht / word_res->denorm.scale () <= min_sane_x_ht_pixels) ||
+  (est_caps_ht <= est_x_ht) || (est_caps_ht >= 2.5 * est_x_ht))) {
+    no_comment = TRUE;
+    if (!trial && rej_use_xht) {
+      if (debug_x_ht_level >= 2) {
+        tprintf ("Sanity check rejecting %s ", word_str);
+        word_res->reject_map.print (debug_fp);
+        tprintf ("\n");
+      }
+      word_res->reject_map.rej_word_xht_fixup ();
+
+    }
+    if (debug_x_ht_level >= 20)
+      tprintf ("Mode20:O: No comment as nothing else matched\n");
+  }
+
+  if (no_comment || trial) {
+    word_res->x_height = bln_x_height / word_res->denorm.scale ();
+    word_res->guessed_x_ht = TRUE;
+    word_res->caps_height = (bln_x_height / x_ht_fraction_of_caps_ht) /
+      word_res->denorm.scale ();
+    word_res->guessed_caps_ht = TRUE;
+    /*
+    Reject ambigs in the current word if we are uncertain and:
+        there are rejects OR
+        there is only one char which is an ambig OR
+        there is conflict between the case of the ambigs even though there is
+        no height separation Eg "Ms" recognised from "MS"
+    */
+    if (rej_trial_ambigs &&
+      ((word_res->reject_map.reject_count () > 0) ||
+      (word_res->reject_map.length () == 1) ||
+    ((x_ht_ambigs > 0) && (caps_ht_ambigs > 0)))) {
+      #ifndef SECURE_NAMES
+      if (debug_x_ht_level >= 2) {
+        tprintf ("TRIAL Rej Ambigs %s ", word_str);
+        word_res->reject_map.print (debug_fp);
+      }
+      #endif
+      reject_ambigs(word_res);
+      if (debug_x_ht_level >= 2) {
+        tprintf (" ");
+        word_res->reject_map.print (debug_fp);
+        tprintf ("\n");
+      }
+    }
+  }
+  else {
+    word_res->x_height = est_x_ht / word_res->denorm.scale ();
+    word_res->guessed_x_ht = !est_x_ht_certain;
+    word_res->caps_height = est_caps_ht / word_res->denorm.scale ();
+    word_res->guessed_caps_ht = !est_caps_ht_certain;
+  }
+
+  if (!no_comment && (fabs (est_x_ht - bln_x_height) > x_ht_ok_variation))
+    *trial_x_ht = est_x_ht / word_res->denorm.scale ();
+  else
+    *trial_x_ht = 0.0;
+
+  #ifndef SECURE_NAMES
+  if (((*trial_x_ht > 0) && (debug_x_ht_level >= 3)) ||
+  (debug_x_ht_level >= 5)) {
+    tprintf ("%s ", word_str);
+    word_res->reject_map.print (debug_fp);
+    tprintf
+      (" X:%0.2f Cps:%0.2f Mxht:%0.2f RJ MxHt:%d MxAr:%d Rematch:%c\n",
+      est_x_ht, est_caps_ht, max_blob_ht, rej_blobs_max_height,
+      rej_blobs_max_area, *trial_x_ht > 0 ? '*' : ' ');
+  }
+  #endif
+
+}
+
+
+/*************************************************************************
+ * check_block_occ()
+ * Checks word for coarse block occupancy, rejecting more chars and flipping
+ * case of case ambiguous chars as required.
+ *************************************************************************/
+
+void check_block_occ(WERD_RES *word_res) {
+  PBLOB_IT blob_it;
+  STRING new_string;
+  STRING new_string_lengths(word_res->best_choice->lengths());
+//  char new_string_lengths[word_res->best_choice->lengths().length() + 1];
+  REJMAP new_map = word_res->reject_map;
+  WERD_CHOICE *new_choice;
+
+  const char *word_str = word_res->best_choice->string ().string ();
+  inT16 i;
+  inT16 offset;
+  inT16 reject_count = 0;
+  char confirmed_char[UNICHAR_LEN + 1];
+  char temp_char[UNICHAR_LEN + 1];
+  float x_ht;
+  float caps_ht;
+
+  new_string_lengths[0] = 0;
+
+  if (word_res->x_height > 0)
+    x_ht = word_res->x_height * word_res->denorm.scale ();
+  else
+    x_ht = bln_x_height;
+
+  if (word_res->caps_height > 0)
+    caps_ht = word_res->caps_height * word_res->denorm.scale ();
+  else
+    caps_ht = x_ht / x_ht_fraction_of_caps_ht;
+
+  blob_it.set_to_list (word_res->outword->blob_list ());
+
+  for (blob_it.mark_cycle_pt (), i = 0, offset = 0;
+  !blob_it.cycled_list (); blob_it.forward (),
+           offset += word_res->best_choice->lengths()[i++]) {
+    strncpy(temp_char, word_str + offset,
+            word_res->best_choice->lengths()[i]); //default copy
+    temp_char[word_res->best_choice->lengths()[i]] = '\0';
+    if (word_res->reject_map[i].accepted ()) {
+      check_blob_occ (temp_char,
+                      blob_it.data ()->bounding_box ().
+                      top () - bln_baseline_offset, x_ht,
+                      caps_ht, confirmed_char);
+
+      if (strcmp(confirmed_char, "") == 0) {
+        if (rej_use_check_block_occ) {
+          new_map[i].setrej_xht_fixup ();
+          reject_count++;
+        }
+      }
+      else
+        strcpy(temp_char, confirmed_char);
+    }
+    new_string += temp_char;
+    new_string_lengths[i] = strlen(temp_char);
+    new_string_lengths[i + 1] = 0;
+
+  }
+  if ((reject_count > 0) || (new_string != word_str)) {
+    if (debug_x_ht_level >= 2) {
+      tprintf ("Shape Verification: %s ", word_str);
+      word_res->reject_map.print (debug_fp);
+      tprintf (" -> %s ", new_string.string ());
+      new_map.print (debug_fp);
+      tprintf ("\n");
+    }
+    new_choice = new WERD_CHOICE (new_string.string (),
+                                  new_string_lengths.string(),
+                                  word_res->best_choice->rating (),
+                                  word_res->best_choice->certainty (),
+                                  word_res->best_choice->permuter ());
+    delete word_res->best_choice;
+    word_res->best_choice = new_choice;
+    word_res->reject_map = new_map;
+  }
+}
+
+
+/*************************************************************************
+ * check_blob_occ()
+ *
+ * Checks blob for position relative to position above baseline
+ * Return 0 for reject, or (possibly case shifted) confirmed char
+ *************************************************************************/
+
+void check_blob_occ(char* proposed_char,
+                    inT16 blob_ht_above_baseline,
+                    float x_ht,
+                    float caps_ht,
+                    char* confirmed_char) {
+  BOOL8 blob_definite_x_ht;
+  BOOL8 blob_definite_caps_ht;
+  float acceptable_variation;
+
+  acceptable_variation = (caps_ht - x_ht) * x_ht_variation;
+  /* ??? REJECT if expected descender and nothing significantly below BL */
+
+  /* ??? REJECT if expected ascender and nothing significantly above x-ht */
+
+  /*
+    IF AMBIG_CAPS_X_CHS
+      IF blob is definitely an ascender ( > xht + xht err )AND
+        char is an x-ht char
+      THEN
+        flip case
+      IF blob is defintiely an x-ht ( <= xht + xht err ) AND
+        char is an ascender char
+      THEN
+        flip case
+  */
+  blob_definite_x_ht = blob_ht_above_baseline <= x_ht + acceptable_variation;
+  blob_definite_caps_ht = blob_ht_above_baseline >=
+    caps_ht - acceptable_variation;
+
+  if (STRING (chs_ambig_caps_x).contains (*proposed_char)) {
+    if ((!blob_definite_x_ht && !blob_definite_caps_ht) ||
+        ((strcmp(proposed_char, "0") == 0) && !blob_definite_caps_ht) ||
+        ((strcmp(proposed_char, "o") == 0) && !blob_definite_x_ht)) {
+      strcpy(confirmed_char, "");
+      return;
+    }
+
+    else if (blob_definite_caps_ht &&
+    STRING (chs_x_ht).contains (*proposed_char)) {
+      if (x_ht_case_flip) {
+                                 //flip to upper case
+        proposed_char[0] = (char) toupper (*proposed_char);
+        return;
+      } else {
+        strcpy(confirmed_char, "");
+        return;
+      }
+    }
+
+    else if (blob_definite_x_ht &&
+    !STRING (chs_x_ht).contains (*proposed_char)) {
+      if (x_ht_case_flip) {
+                                 //flip to lower case
+        proposed_char[0] = (char) tolower (*proposed_char);
+      } else {
+        strcpy(confirmed_char, "");
+        return;
+      }
+    }
+  }
+  else
+  if ((STRING (chs_non_ambig_x_ht).contains (*proposed_char)
+    && !blob_definite_x_ht)
+    || (STRING (chs_non_ambig_caps_ht).contains (*proposed_char)
+        && !blob_definite_caps_ht)) {
+    strcpy(confirmed_char, "");
+    return;
+  }
+  strcpy(confirmed_char, proposed_char);
+  return;
+}
+
+
+float estimate_from_stats(STATS &stats) {
+  if (stats.get_total () <= 0)
+    return 0.0;
+  else if (stats.get_total () >= 3)
+    return stats.ile (0.5);      //median
+  else
+    return stats.mean ();
+}
+
+
+void improve_estimate(WERD_RES *word_res,
+                      float &est_x_ht,
+                      float &est_caps_ht,
+                      STATS &x_ht,
+                      STATS &caps_ht) {
+  PBLOB_IT blob_it;
+  inT16 blob_ht_above_baseline;
+
+  const char *word_str;
+  inT16 i;
+  inT16 offset;
+  TBOX blob_box;                  //blob bounding box
+  char confirmed_char[UNICHAR_LEN + 1];
+  char temp_char[UNICHAR_LEN + 1];
+  float new_val;
+
+  /* IMPROVE estimates here - if good estimates, and case ambig chars,
+    rescan blobs to fix case ambig blobs, re-estimate hts  ??? maybe always do
+    it after deciding x-height
+  */
+
+  blob_it.set_to_list (word_res->outword->blob_list ());
+  word_str = word_res->best_choice->string ().string ();
+  for (blob_it.mark_cycle_pt (), i = 0, offset = 0;
+       !blob_it.cycled_list (); blob_it.forward (),
+           offset += word_res->best_choice->lengths()[i++]) {
+    if ((STRING (chs_ambig_caps_x).contains (word_str[offset])) &&
+    (!dodgy_blob (blob_it.data ()))) {
+      blob_box = blob_it.data ()->bounding_box ();
+      blob_ht_above_baseline = blob_box.top () - bln_baseline_offset;
+      strncpy(temp_char, word_str + offset,
+              word_res->best_choice->lengths()[i]);
+      temp_char[word_res->best_choice->lengths()[i]] = '\0';
+      check_blob_occ (temp_char,
+                      blob_ht_above_baseline,
+                      est_x_ht, est_caps_ht, confirmed_char);
+      if (strcmp(confirmed_char, "") != 0) {
+        if (STRING (chs_x_ht).contains (*confirmed_char))
+          x_ht.add (blob_ht_above_baseline, 1);
+        else
+          caps_ht.add (blob_ht_above_baseline, 1);
+      }
+    }
+  }
+  new_val = estimate_from_stats (x_ht);
+  if (new_val > 0)
+    est_x_ht = new_val;
+  new_val = estimate_from_stats (caps_ht);
+  if (new_val > 0)
+    est_caps_ht = new_val;
+}
+
+
+void reject_ambigs(  //rej any accepted xht ambig chars
+                   WERD_RES *word) {
+  const char *word_str;
+  int i = 0;
+
+  word_str = word->best_choice->string ().string ();
+  while (*word_str != '\0') {
+    if (STRING (chs_ambig_caps_x).contains (*word_str))
+      word->reject_map[i].setrej_xht_fixup ();
+    word_str += word->best_choice->lengths()[i++];
+  }
+}
+
+
+void est_ambigs(                          //xht ambig ht stats
+                WERD_RES *word_res,
+                STATS &stats,
+                float *ambig_lc_x_est,    //xht est
+                float *ambig_uc_caps_est  //caps est
+               ) {
+  float x_ht_ok_variation;
+  STATS short_ambigs (0, 300);
+  STATS tall_ambigs (0, 300);
+  PBLOB_IT blob_it;
+  TBOX blob_box;                  //blob bounding box
+  inT16 blob_ht_above_baseline;
+
+  const char *word_str;
+  inT16 i;
+  inT16 offset;
+  float min;                     //min ambig ch ht
+  float max;                     //max ambig ch ht
+  float short_limit;             // for lower case
+  float tall_limit;              // for upper case
+
+  x_ht_ok_variation =
+    (bln_x_height / x_ht_fraction_of_caps_ht - bln_x_height) * x_ht_variation;
+
+  if (stats.get_total () == 0) {
+    *ambig_lc_x_est = 0;
+    *ambig_uc_caps_est = 0;
+  }
+  else {
+    min = stats.ile (0.0);
+    max = stats.ile (0.99999);
+    if ((max - min) < x_ht_ok_variation) {
+      *ambig_lc_x_est = *ambig_uc_caps_est = stats.mean ();
+      //close enough
+    }
+    else {
+    /* Try reclustering into lower and upper case chars */
+      short_limit = min + (max - min) * x_ht_variation;
+      tall_limit = max - (max - min) * x_ht_variation;
+      word_str = word_res->best_choice->string ().string ();
+      blob_it.set_to_list (word_res->outword->blob_list ());
+      for (blob_it.mark_cycle_pt (), i = 0, offset = 0;
+      !blob_it.cycled_list (); blob_it.forward (),
+               offset += word_res->best_choice->lengths()[i++]) {
+        if (word_res->reject_map[i].accepted () &&
+          STRING (chs_ambig_caps_x).contains (word_str[offset]) &&
+        (!dodgy_blob (blob_it.data ()))) {
+          blob_box = blob_it.data ()->bounding_box ();
+          blob_ht_above_baseline =
+            blob_box.top () - bln_baseline_offset;
+          if (blob_ht_above_baseline <= short_limit)
+            short_ambigs.add (blob_ht_above_baseline, 1);
+          else if (blob_ht_above_baseline >= tall_limit)
+            tall_ambigs.add (blob_ht_above_baseline, 1);
+        }
+      }
+      *ambig_lc_x_est = short_ambigs.mean ();
+      *ambig_uc_caps_est = tall_ambigs.mean ();
+      /* Cop out if we havent got sensible clusters. */
+      if (*ambig_uc_caps_est - *ambig_lc_x_est <= x_ht_ok_variation)
+        *ambig_lc_x_est = *ambig_uc_caps_est = stats.mean ();
+      //close enough
+    }
+  }
+}
+
+
+/*************************************************************************
+ * dodgy_blob()
+ * Returns true if the blob has more than one outline, one above the other.
+ * These are dodgy as the top blob could be noise, causing the bounding box xht
+ * to be misleading
+ *************************************************************************/
+
+BOOL8 dodgy_blob(PBLOB *blob) {
+  OUTLINE_IT outline_it = blob->out_list ();
+  inT16 highest_bottom = -MAX_INT16;
+  inT16 lowest_top = MAX_INT16;
+  TBOX outline_box;
+
+  if (x_ht_include_dodgy_blobs)
+    return FALSE;                //no blob is ever dodgy
+  for (outline_it.mark_cycle_pt ();
+  !outline_it.cycled_list (); outline_it.forward ()) {
+    outline_box = outline_it.data ()->bounding_box ();
+    if (lowest_top > outline_box.top ())
+      lowest_top = outline_box.top ();
+    if (highest_bottom < outline_box.bottom ())
+      highest_bottom = outline_box.bottom ();
+  }
+  return highest_bottom >= lowest_top;
+}