tesseract_bin 1.0.0

data/vendor/tesseract-2.04/textord/tospace.h

@@ -0,0 +1,193 @@
+/**********************************************************************
+ * to_spacing
+ *
+ * Compute fuzzy word spacing thresholds for each row.
+ **********************************************************************/
+
+#ifndef           TOSPACE_H
+#define           TOSPACE_H
+
+#include          "blobbox.h"
+#include          "gap_map.h"
+#include          "statistc.h"
+#include          "notdll.h"
+extern BOOL_VAR_H (tosp_old_to_method, FALSE, "Space stats use prechopping?");
+extern BOOL_VAR_H (tosp_only_use_prop_rows, TRUE,
+"Block stats to use fixed pitch rows?");
+extern BOOL_VAR_H (tosp_use_pre_chopping, FALSE,
+"Space stats use prechopping?");
+extern BOOL_VAR_H (tosp_old_to_bug_fix, FALSE,
+"Fix suspected bug in old code");
+extern BOOL_VAR_H (tosp_block_use_cert_spaces, TRUE,
+"Only stat OBVIOUS spaces");
+extern BOOL_VAR_H (tosp_row_use_cert_spaces, TRUE,
+"Only stat OBVIOUS spaces");
+extern BOOL_VAR_H (tosp_narrow_blobs_not_cert, TRUE,
+"Only stat OBVIOUS spaces");
+extern BOOL_VAR_H (tosp_row_use_cert_spaces1, TRUE,
+"Only stat OBVIOUS spaces");
+extern BOOL_VAR_H (tosp_recovery_isolated_row_stats, TRUE,
+"Use row alone when inadequate cert spaces");
+extern BOOL_VAR_H (tosp_only_small_gaps_for_kern, FALSE, "Better guess");
+extern BOOL_VAR_H (tosp_all_flips_fuzzy, FALSE, "Pass ANY flip to context?");
+extern BOOL_VAR_H (tosp_fuzzy_limit_all, TRUE,
+"Dont restrict kn->sp fuzzy limit to tables");
+extern BOOL_VAR_H (tosp_stats_use_xht_gaps, TRUE,
+"Use within xht gap for wd breaks");
+extern BOOL_VAR_H (tosp_use_xht_gaps, TRUE,
+"Use within xht gap for wd breaks");
+extern BOOL_VAR_H (tosp_only_use_xht_gaps, FALSE,
+"Only use within xht gap for wd breaks");
+extern BOOL_VAR_H (tosp_rule_9_test_punct, FALSE,
+"Dont chng kn to space next to punct");
+extern BOOL_VAR_H (tosp_flip_fuzz_kn_to_sp, TRUE, "Default flip");
+extern BOOL_VAR_H (tosp_flip_fuzz_sp_to_kn, TRUE, "Default flip");
+extern BOOL_VAR_H (tosp_improve_thresh, FALSE,
+"Enable improvement heuristic");
+extern INT_VAR_H (tosp_debug_level, 0, "Debug data");
+extern INT_VAR_H (tosp_enough_space_samples_for_median, 3,
+"or should we use mean");
+extern INT_VAR_H (tosp_redo_kern_limit, 10,
+"No.samples reqd to reestimate for row");
+extern INT_VAR_H (tosp_few_samples, 40,
+"No.gaps reqd with 1 large gap to treat as a table");
+extern INT_VAR_H (tosp_short_row, 20,
+"No.gaps reqd with few cert spaces to use certs");
+extern INT_VAR_H (tosp_sanity_method, 1, "How to avoid being silly");
+extern double_VAR_H (tosp_threshold_bias1, 0,
+"how far between kern and space?");
+extern double_VAR_H (tosp_threshold_bias2, 0,
+"how far between kern and space?");
+extern double_VAR_H (tosp_narrow_fraction, 0.3,
+"Fract of xheight for narrow");
+extern double_VAR_H (tosp_narrow_aspect_ratio, 0.48,
+"narrow if w/h less than this");
+extern double_VAR_H (tosp_wide_fraction, 0.52, "Fract of xheight for wide");
+extern double_VAR_H (tosp_wide_aspect_ratio, 0.0,
+"wide if w/h less than this");
+extern double_VAR_H (tosp_fuzzy_space_factor, 0.6,
+"Fract of xheight for fuzz sp");
+extern double_VAR_H (tosp_fuzzy_space_factor1, 0.5,
+"Fract of xheight for fuzz sp");
+extern double_VAR_H (tosp_fuzzy_space_factor2, 0.72,
+"Fract of xheight for fuzz sp");
+extern double_VAR_H (tosp_gap_factor, 0.83, "gap ratio to flip sp->kern");
+extern double_VAR_H (tosp_kern_gap_factor1, 2.0,
+"gap ratio to flip kern->sp");
+extern double_VAR_H (tosp_kern_gap_factor2, 1.3,
+"gap ratio to flip kern->sp");
+extern double_VAR_H (tosp_kern_gap_factor3, 2.5,
+"gap ratio to flip kern->sp");
+extern double_VAR_H (tosp_ignore_big_gaps, -1, "xht multiplier");
+extern double_VAR_H (tosp_ignore_very_big_gaps, 3.5, "xht multiplier");
+extern double_VAR_H (tosp_rep_space, 1.6, "rep gap multiplier for space");
+extern double_VAR_H (tosp_enough_small_gaps, 0.65,
+"Fract of kerns reqd for isolated row stats");
+extern double_VAR_H (tosp_table_kn_sp_ratio, 2.25,
+"Min difference of kn & sp in table");
+extern double_VAR_H (tosp_table_xht_sp_ratio, 0.33,
+"Expect spaces bigger than this");
+extern double_VAR_H (tosp_table_fuzzy_kn_sp_ratio, 3.0,
+"Fuzzy if less than this");
+extern double_VAR_H (tosp_fuzzy_kn_fraction, 0.5, "New fuzzy kn alg");
+extern double_VAR_H (tosp_fuzzy_sp_fraction, 0.5, "New fuzzy sp alg");
+extern double_VAR_H (tosp_min_sane_kn_sp, 1.5,
+"Dont trust spaces less than this time kn");
+extern double_VAR_H (tosp_init_guess_kn_mult, 2.2,
+"Thresh guess - mult kn by this");
+extern double_VAR_H (tosp_init_guess_xht_mult, 0.28,
+"Thresh guess - mult xht by this");
+extern double_VAR_H (tosp_max_sane_kn_thresh, 5.0,
+"Multiplier on kn to limit thresh");
+extern double_VAR_H (tosp_flip_caution, 0.0,
+"Dont autoflip kn to sp when large separation");
+extern double_VAR_H (tosp_large_kerning, 0.19,
+"Limit use of xht gap with large kns");
+extern double_VAR_H (tosp_dont_fool_with_small_kerns, -1,
+"Limit use of xht gap with odd small kns");
+extern double_VAR_H (tosp_near_lh_edge, 0,
+"Dont reduce box if the top left is non blank");
+extern double_VAR_H (tosp_silly_kn_sp_gap, 0.2,
+"Dont let sp minus kn get too small");
+extern double_VAR_H (tosp_pass_wide_fuzz_sp_to_context, 0.75,
+"How wide fuzzies need context");
+void to_spacing(                       //set spacing
+                ICOORD page_tr,        //topright of page
+                TO_BLOCK_LIST *blocks  //blocks on page
+               );
+                                 //DEBUG USE ONLY
+void block_spacing_stats(TO_BLOCK *block,
+                         GAPMAP *gapmap,
+                         BOOL8 &old_text_ord_proportional,
+                         inT16 &block_space_gap_width,     //resulting estimate
+                         inT16 &block_non_space_gap_width  //resulting estimate
+                        );
+                                 //estimate for block
+void row_spacing_stats(TO_ROW *row,
+                       GAPMAP *gapmap,
+                       inT16 block_idx,
+                       inT16 row_idx,
+                       inT16 block_space_gap_width,
+                       inT16 block_non_space_gap_width  //estimate for block
+                      );
+                                 //estimate for block
+void old_to_method(TO_ROW *row,
+                   STATS *all_gap_stats,
+                   STATS *space_gap_stats,
+                   STATS *small_gap_stats,
+                   inT16 block_space_gap_width,
+                   inT16 block_non_space_gap_width  //estimate for block
+                  );
+BOOL8 isolated_row_stats(TO_ROW *row,
+                         GAPMAP *gapmap,
+                         STATS *all_gap_stats,
+                         BOOL8 suspected_table,
+                         inT16 block_idx,
+                         inT16 row_idx);
+inT16 stats_count_under(STATS *stats, inT16 threshold);
+void improve_row_threshold(TO_ROW *row, STATS *all_gap_stats);
+ROW *make_prop_words(                 //find lines
+                     TO_ROW *row,     //row to make
+                     FCOORD rotation  //for drawing
+                    );
+BOOL8 make_a_word_break(               //decide on word break
+                        TO_ROW *row,   //row being made
+                        TBOX blob_box,  //for next_blob //how many blanks?
+                        inT16 prev_gap,
+                        TBOX prev_blob_box,
+                        inT16 real_current_gap,
+                        inT16 within_xht_current_gap,
+                        TBOX next_blob_box,
+                        inT16 next_gap,
+                        uinT8 &blanks,
+                        BOOL8 &fuzzy_sp,
+                        BOOL8 &fuzzy_non);
+BOOL8 narrow_blob(TO_ROW *row, TBOX blob_box);
+BOOL8 wide_blob(TO_ROW *row, TBOX blob_box);
+BOOL8 suspected_punct_blob(TO_ROW *row, TBOX box);
+                                 //A COPY FOR PEEKING
+void peek_at_next_gap(TO_ROW *row,
+                      BLOBNBOX_IT box_it,
+                      TBOX &next_blob_box,
+                      inT16 &next_gap,
+                      inT16 &next_within_xht_gap);
+void mark_gap(             //Debug stuff
+              TBOX blob,    //blob following gap
+              inT16 rule,  // heuristic id
+              inT16 prev_gap,
+              inT16 prev_blob_width,
+              inT16 current_gap,
+              inT16 next_blob_width,
+              inT16 next_gap);
+float find_mean_blob_spacing(WERD *word);
+BOOL8 ignore_big_gap(TO_ROW *row,
+                     inT32 row_length,
+                     GAPMAP *gapmap,
+                     inT16 left,
+                     inT16 right);
+TBOX reduced_box_next(                 //get bounding box
+                     TO_ROW *row,     //current row
+                     BLOBNBOX_IT *it  //iterator to blobds
+                    );
+TBOX reduced_box_for_blob(BLOBNBOX *blob, TO_ROW *row, inT16 *left_above_xht);
+#endif

data/vendor/tesseract-2.04/textord/tovars.cpp

@@ -0,0 +1,87 @@
+/**********************************************************************
+ * File:        tovars.cpp  (Formerly to_vars.c)
+ * Description: Variables used by textord.
+ * Author:		Ray Smith
+ * Created:		Tue Aug 24 16:55:02 BST 1993
+ *
+ * (C) Copyright 1993, 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          "tovars.h"
+
+#define EXTERN
+
+EXTERN BOOL_VAR (textord_show_initial_words, FALSE, "Display separate words");
+EXTERN BOOL_VAR (textord_show_new_words, FALSE, "Display separate words");
+EXTERN BOOL_VAR (textord_show_fixed_words, FALSE,
+"Display forced fixed pitch words");
+EXTERN BOOL_VAR (textord_blocksall_fixed, FALSE, "Moan about prop blocks");
+EXTERN BOOL_VAR (textord_blocksall_prop, FALSE,
+"Moan about fixed pitch blocks");
+EXTERN BOOL_VAR (textord_blocksall_testing, FALSE, "Dump stats when moaning");
+EXTERN BOOL_VAR (textord_test_mode, FALSE, "Do current test");
+EXTERN BOOL_VAR (textord_repeat_extraction, TRUE, "Extract repeated chars");
+EXTERN INT_VAR (textord_dotmatrix_gap, 3,
+"Max pixel gap for broken pixed pitch");
+EXTERN INT_VAR (textord_repeat_threshold, 4,
+"Min multiple for repeated char");
+EXTERN INT_VAR (textord_debug_block, 0, "Block to do debug on");
+EXTERN INT_VAR (textord_pitch_range, 2, "Max range test on pitch");
+EXTERN double_VAR (textord_repeat_rating, 6, "Min rating for equal blobs");
+EXTERN double_VAR (textord_wordstats_smooth_factor, 0.05,
+"Smoothing gap stats");
+EXTERN double_VAR (textord_width_smooth_factor, 0.10,
+"Smoothing width stats");
+EXTERN double_VAR (textord_words_width_ile, 0.4,
+"Ile of blob widths for space est");
+EXTERN double_VAR (textord_words_maxspace, 4.0, "Multiple of xheight");
+EXTERN double_VAR (textord_words_default_maxspace, 3.5,
+"Max believable third space");
+EXTERN double_VAR (textord_words_default_minspace, 0.6,
+"Fraction of xheight");
+EXTERN double_VAR (textord_words_min_minspace, 0.3, "Fraction of xheight");
+EXTERN double_VAR (textord_words_default_nonspace, 0.2,
+"Fraction of xheight");
+EXTERN double_VAR (textord_words_initial_lower, 0.25,
+"Max inital cluster size");
+EXTERN double_VAR (textord_words_initial_upper, 0.15,
+"Min initial cluster spacing");
+EXTERN double_VAR (textord_words_minlarge, 0.75,
+"Fraction of valid gaps needed");
+EXTERN double_VAR (textord_words_pitchsd_threshold, 0.040,
+"Pitch sync threshold");
+EXTERN double_VAR (textord_words_def_fixed, 0.016,
+"Threshold for definite fixed");
+EXTERN double_VAR (textord_words_def_prop, 0.090,
+"Threshold for definite prop");
+EXTERN INT_VAR (textord_words_veto_power, 5,
+"Rows required to outvote a veto");
+EXTERN double_VAR (textord_pitch_rowsimilarity, 0.08,
+"Fraction of xheight for sameness");
+EXTERN BOOL_VAR (textord_pitch_scalebigwords, FALSE,
+"Scale scores on big words");
+EXTERN double_VAR (words_initial_lower, 0.5, "Max inital cluster size");
+EXTERN double_VAR (words_initial_upper, 0.15, "Min initial cluster spacing");
+EXTERN double_VAR (words_default_prop_nonspace, 0.25, "Fraction of xheight");
+EXTERN double_VAR (words_default_fixed_space, 0.75, "Fraction of xheight");
+EXTERN double_VAR (words_default_fixed_limit, 0.6, "Allowed size variance");
+EXTERN double_VAR (textord_words_definite_spread, 0.30,
+"Non-fuzzy spacing region");
+EXTERN double_VAR (textord_spacesize_ratiofp, 2.8,
+"Min ratio space/nonspace");
+EXTERN double_VAR (textord_spacesize_ratioprop, 2.0,
+"Min ratio space/nonspace");
+EXTERN double_VAR (textord_fpiqr_ratio, 1.5, "Pitch IQR/Gap IQR threshold");
+EXTERN double_VAR (textord_max_pitch_iqr, 0.20, "Xh fraction noise in pitch");
+EXTERN double_VAR (textord_fp_min_width, 0.5, "Min width of decent blobs");

data/vendor/tesseract-2.04/textord/tovars.h

@@ -0,0 +1,94 @@
+/**********************************************************************
+ * File:        tovars.h  (Formerly to_vars.h)
+ * Description: Variables used by textord.
+ * Author:		Ray Smith
+ * Created:		Tue Aug 24 16:55:02 BST 1993
+ *
+ * (C) Copyright 1993, 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.
+ *
+ **********************************************************************/
+
+#ifndef           TOVARS_H
+#define           TOVARS_H
+
+#include          "varable.h"
+#include          "notdll.h"
+
+extern BOOL_VAR_H (textord_show_initial_words, FALSE,
+"Display separate words");
+extern BOOL_VAR_H (textord_show_new_words, FALSE, "Display separate words");
+extern BOOL_VAR_H (textord_show_fixed_words, FALSE,
+"Display forced fixed pitch words");
+extern BOOL_VAR_H (textord_blocksall_fixed, FALSE, "Moan about prop blocks");
+extern BOOL_VAR_H (textord_blocksall_prop, FALSE,
+"Moan about fixed pitch blocks");
+extern BOOL_VAR_H (textord_blocksall_testing, FALSE,
+"Dump stats when moaning");
+extern BOOL_VAR_H (textord_test_mode, FALSE, "Do current test");
+extern BOOL_VAR_H (textord_repeat_extraction, TRUE, "Extract repeated chars");
+extern INT_VAR_H (textord_dotmatrix_gap, 3,
+"Max pixel gap for broken pixed pitch");
+extern INT_VAR_H (textord_repeat_threshold, 4,
+"Min multiple for repeated char");
+extern INT_VAR_H (textord_debug_block, 0, "Block to do debug on");
+extern INT_VAR_H (textord_pitch_range, 2, "Max range test on pitch");
+extern double_VAR_H (textord_repeat_rating, 6, "Min rating for equal blobs");
+extern double_VAR_H (textord_wordstats_smooth_factor, 0.05,
+"Smoothing gap stats");
+extern double_VAR_H (textord_width_smooth_factor, 0.10,
+"Smoothing width stats");
+extern double_VAR_H (textord_words_width_ile, 0.4,
+"Ile of blob widths for space est");
+extern double_VAR_H (textord_words_maxspace, 4.0, "Multiple of xheight");
+extern double_VAR_H (textord_words_default_maxspace, 3.5,
+"Max believable third space");
+extern double_VAR_H (textord_words_default_minspace, 0.6,
+"Fraction of xheight");
+extern double_VAR_H (textord_words_min_minspace, 0.3, "Fraction of xheight");
+extern double_VAR_H (textord_words_default_nonspace, 0.2,
+"Fraction of xheight");
+extern double_VAR_H (textord_words_initial_lower, 0.25,
+"Max inital cluster size");
+extern double_VAR_H (textord_words_initial_upper, 0.15,
+"Min initial cluster spacing");
+extern double_VAR_H (textord_words_minlarge, 0.75,
+"Fraction of valid gaps needed");
+extern double_VAR_H (textord_words_pitchsd_threshold, 0.025,
+"Pitch sync threshold");
+extern double_VAR_H (textord_words_def_fixed, 0.01,
+"Threshold for definite fixed");
+extern double_VAR_H (textord_words_def_prop, 0.06,
+"Threshold for definite prop");
+extern INT_VAR_H (textord_words_veto_power, 5,
+"Rows required to outvote a veto");
+extern double_VAR_H (textord_pitch_rowsimilarity, 0.08,
+"Fraction of xheight for sameness");
+extern BOOL_VAR_H (textord_pitch_scalebigwords, FALSE,
+"Scale scores on big words");
+extern double_VAR_H (words_initial_lower, 0.5, "Max inital cluster size");
+extern double_VAR_H (words_initial_upper, 0.15,
+"Min initial cluster spacing");
+extern double_VAR_H (words_default_prop_nonspace, 0.25,
+"Fraction of xheight");
+extern double_VAR_H (words_default_fixed_space, 0.75, "Fraction of xheight");
+extern double_VAR_H (words_default_fixed_limit, 0.6, "Allowed size variance");
+extern double_VAR_H (textord_words_definite_spread, 0.30,
+"Non-fuzzy spacing region");
+extern double_VAR_H (textord_spacesize_ratiofp, 2.8,
+"Min ratio space/nonspace");
+extern double_VAR_H (textord_spacesize_ratioprop, 2.0,
+"Min ratio space/nonspace");
+extern double_VAR_H (textord_fpiqr_ratio, 1.5, "Pitch IQR/Gap IQR threshold");
+extern double_VAR_H (textord_max_pitch_iqr, 0.20,
+"Xh fraction noise in pitch");
+extern double_VAR_H (textord_fp_min_width, 0.5, "Min width of decent blobs");
+#endif

data/vendor/tesseract-2.04/textord/underlin.cpp

@@ -0,0 +1,312 @@
+/**********************************************************************
+ * File:        underlin.cpp  (Formerly undrline.c)
+ * Description: Code to chop blobs apart from underlines.
+ * Author:		Ray Smith
+ * Created:		Mon Aug  8 11:14:00 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.
+ *
+ **********************************************************************/
+
+#include "mfcpch.h"
+#ifdef __UNIX__
+#include          <assert.h>
+#endif
+#include          "underlin.h"
+
+#define PROJECTION_MARGIN 10     //arbitrary
+#define EXTERN
+
+EXTERN double_VAR (textord_underline_offset, 0.1, "Fraction of x to ignore");
+EXTERN BOOL_VAR (textord_restore_underlines, TRUE,
+"Chop underlines & put back");
+
+/**********************************************************************
+ * restore_underlined_blobs
+ *
+ * Find underlined blobs and put them back in the row.
+ **********************************************************************/
+
+void restore_underlined_blobs(                 //get chop points
+                              TO_BLOCK *block  //block to do
+                             ) {
+  inT16 chop_coord;              //chop boundary
+  TBOX blob_box;                  //of underline
+  BLOBNBOX *u_line;              //underline bit
+  TO_ROW *row;                   //best row for blob
+  ICOORDELT_LIST chop_cells;     //blobs to cut out
+                                 //real underlines
+  BLOBNBOX_LIST residual_underlines;
+  OUTLINE_LIST left_outlines;    //in current blob
+  OUTLINE_LIST right_outlines;   //for next blob
+  C_OUTLINE_LIST left_coutlines;
+  C_OUTLINE_LIST right_coutlines;
+  ICOORDELT_IT cell_it = &chop_cells;
+                                 //under lines
+  BLOBNBOX_IT under_it = &block->underlines;
+  BLOBNBOX_IT ru_it = &residual_underlines;
+
+  if (block->get_rows()->empty())
+    return;  // Don't crash if there are no rows.
+  for (under_it.mark_cycle_pt (); !under_it.cycled_list ();
+  under_it.forward ()) {
+    u_line = under_it.extract ();
+    blob_box = u_line->bounding_box ();
+    row = most_overlapping_row (block->get_rows (), u_line);
+    find_underlined_blobs (u_line, &row->baseline, row->xheight,
+      row->xheight * textord_underline_offset,
+      &chop_cells);
+    cell_it.set_to_list (&chop_cells);
+    for (cell_it.mark_cycle_pt (); !cell_it.cycled_list ();
+    cell_it.forward ()) {
+      chop_coord = cell_it.data ()->x ();
+      if (cell_it.data ()->y () - chop_coord > textord_fp_chop_error + 1) {
+        split_to_blob (u_line, chop_coord,
+          textord_fp_chop_error + 0.5,
+          &left_outlines, &left_coutlines,
+          &right_outlines, &right_coutlines);
+        if (!left_outlines.empty ())
+          ru_it.
+            add_after_then_move (new
+            BLOBNBOX (new PBLOB (&left_outlines)));
+        else if (!left_coutlines.empty ())
+          ru_it.
+              add_after_then_move (new
+              BLOBNBOX (new
+              C_BLOB (&left_coutlines)));
+                                 //right edge of lbob
+        chop_coord = cell_it.data ()->y ();
+        split_to_blob (NULL, chop_coord,
+          textord_fp_chop_error + 0.5,
+          &left_outlines, &left_coutlines,
+          &right_outlines, &right_coutlines);
+        if (!left_outlines.empty ())
+          row->insert_blob (new BLOBNBOX (new PBLOB (&left_outlines)));
+        else if (!left_coutlines.empty ())
+          row->
+              insert_blob (new BLOBNBOX (new C_BLOB (&left_coutlines)));
+        else {
+          ASSERT_HOST(FALSE);
+          fprintf (stderr,
+            "Error:no outlines after chopping from %d to %d from (%d,%d)->(%d,%d)\n",
+            cell_it.data ()->x (), cell_it.data ()->y (),
+            blob_box.left (), blob_box.bottom (),
+            blob_box.right (), blob_box.top ());
+        }
+        u_line = NULL;           //no more blobs to add
+      }
+      delete cell_it.extract ();
+    }
+    if (!right_outlines.empty () || !right_coutlines.empty ()) {
+      split_to_blob (NULL, blob_box.right (),
+        textord_fp_chop_error + 0.5,
+        &left_outlines, &left_coutlines,
+        &right_outlines, &right_coutlines);
+      if (!left_outlines.empty ())
+        ru_it.
+          add_after_then_move (new BLOBNBOX (new PBLOB (&left_outlines)));
+      else if (!left_coutlines.empty ())
+        ru_it.
+            add_after_then_move (new
+            BLOBNBOX (new C_BLOB (&left_coutlines)));
+    }
+    if (u_line != NULL) {
+      if (u_line->blob() != NULL)
+        delete u_line->blob();
+      if (u_line->cblob() != NULL)
+        delete u_line->cblob();
+      delete u_line;
+    }
+  }
+  if (!ru_it.empty ()) {
+    ru_it.move_to_first ();
+    for (ru_it.mark_cycle_pt (); !ru_it.cycled_list (); ru_it.forward ()) {
+      under_it.add_after_then_move (ru_it.extract ());
+    }
+  }
+}
+
+
+/**********************************************************************
+ * most_overlapping_row
+ *
+ * Return the row which most overlaps the blob.
+ **********************************************************************/
+
+TO_ROW *most_overlapping_row(                    //find best row
+                             TO_ROW_LIST *rows,  //list of rows
+                             BLOBNBOX *blob      //blob to place
+                            ) {
+  inT16 x = (blob->bounding_box ().left ()
+    + blob->bounding_box ().right ()) / 2;
+  TO_ROW_IT row_it = rows;       //row iterator
+  TO_ROW *row;                   //current row
+  TO_ROW *best_row;              //output row
+  float overlap;                 //of blob & row
+  float bestover;                //best overlap
+
+  best_row = NULL;
+  bestover = (float) -MAX_INT32;
+  if (row_it.empty ())
+    return NULL;
+  row = row_it.data ();
+  row_it.mark_cycle_pt ();
+  while (row->baseline.y (x) + row->descdrop > blob->bounding_box ().top ()
+  && !row_it.cycled_list ()) {
+    best_row = row;
+    bestover =
+      blob->bounding_box ().top () - row->baseline.y (x) + row->descdrop;
+    row_it.forward ();
+    row = row_it.data ();
+  }
+  while (row->baseline.y (x) + row->xheight + row->ascrise
+  >= blob->bounding_box ().bottom () && !row_it.cycled_list ()) {
+    overlap = row->baseline.y (x) + row->xheight + row->ascrise;
+    if (blob->bounding_box ().top () < overlap)
+      overlap = blob->bounding_box ().top ();
+    if (blob->bounding_box ().bottom () >
+      row->baseline.y (x) + row->descdrop)
+      overlap -= blob->bounding_box ().bottom ();
+    else
+      overlap -= row->baseline.y (x) + row->descdrop;
+    if (overlap > bestover) {
+      bestover = overlap;
+      best_row = row;
+    }
+    row_it.forward ();
+    row = row_it.data ();
+  }
+  if (bestover < 0
+    && row->baseline.y (x) + row->xheight + row->ascrise
+    - blob->bounding_box ().bottom () > bestover)
+    best_row = row;
+  return best_row;
+}
+
+
+/**********************************************************************
+ * find_underlined_blobs
+ *
+ * Find the start and end coords of blobs in the underline.
+ **********************************************************************/
+
+void find_underlined_blobs(                            //get chop points
+                           BLOBNBOX *u_line,           //underlined unit
+                           QSPLINE *baseline,          //actual baseline
+                           float xheight,              //height of line
+                           float baseline_offset,      //amount to shrinke it
+                           ICOORDELT_LIST *chop_cells  //places to chop
+                          ) {
+  inT16 x, y;                    //sides of blob
+  ICOORD blob_chop;              //sides of blob
+  TBOX blob_box = u_line->bounding_box ();
+                                 //cell iterator
+  ICOORDELT_IT cell_it = chop_cells;
+  STATS upper_proj (blob_box.left (), blob_box.right () + 1);
+  STATS middle_proj (blob_box.left (), blob_box.right () + 1);
+  STATS lower_proj (blob_box.left (), blob_box.right () + 1);
+  C_OUTLINE_IT out_it;           //outlines of blob
+
+  ASSERT_HOST (u_line->cblob () != NULL);
+
+  out_it.set_to_list (u_line->cblob ()->out_list ());
+  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
+    vertical_cunderline_projection (out_it.data (),
+      baseline, xheight, baseline_offset,
+      &lower_proj, &middle_proj, &upper_proj);
+  }
+
+  for (x = blob_box.left (); x < blob_box.right (); x++) {
+    if (middle_proj.pile_count (x) > 0) {
+      for (y = x + 1;
+        y < blob_box.right () && middle_proj.pile_count (y) > 0; y++);
+      blob_chop = ICOORD (x, y);
+      cell_it.add_after_then_move (new ICOORDELT (blob_chop));
+      x = y;
+    }
+  }
+}
+
+
+/**********************************************************************
+ * vertical_cunderline_projection
+ *
+ * Compute the vertical projection of a outline from its outlines
+ * and add to the given STATS.
+ **********************************************************************/
+
+void vertical_cunderline_projection(                        //project outlines
+                                    C_OUTLINE *outline,     //outline to project
+                                    QSPLINE *baseline,      //actual baseline
+                                    float xheight,          //height of line
+                                    float baseline_offset,  //amount to shrinke it
+                                    STATS *lower_proj,      //below baseline
+                                    STATS *middle_proj,     //centre region
+                                    STATS *upper_proj       //top region
+                                   ) {
+  ICOORD pos;                    //current point
+  ICOORD step;                   //edge step
+  inT16 lower_y, upper_y;        //region limits
+  inT32 length;                  //of outline
+  inT16 stepindex;               //current step
+  C_OUTLINE_IT out_it = outline->child ();
+
+  pos = outline->start_pos ();
+  length = outline->pathlength ();
+  for (stepindex = 0; stepindex < length; stepindex++) {
+    step = outline->step (stepindex);
+    if (step.x () > 0) {
+      lower_y =
+        (inT16) floor (baseline->y (pos.x ()) + baseline_offset + 0.5);
+      upper_y =
+        (inT16) floor (baseline->y (pos.x ()) + baseline_offset +
+        xheight + 0.5);
+      if (pos.y () >= lower_y) {
+        lower_proj->add (pos.x (), -lower_y);
+        if (pos.y () >= upper_y) {
+          middle_proj->add (pos.x (), lower_y - upper_y);
+          upper_proj->add (pos.x (), upper_y - pos.y ());
+        }
+        else
+          middle_proj->add (pos.x (), lower_y - pos.y ());
+      }
+      else
+        lower_proj->add (pos.x (), -pos.y ());
+    }
+    else if (step.x () < 0) {
+      lower_y =
+        (inT16) floor (baseline->y (pos.x () - 1) + baseline_offset +
+        0.5);
+      upper_y =
+        (inT16) floor (baseline->y (pos.x () - 1) + baseline_offset +
+        xheight + 0.5);
+      if (pos.y () >= lower_y) {
+        lower_proj->add (pos.x () - 1, lower_y);
+        if (pos.y () >= upper_y) {
+          middle_proj->add (pos.x () - 1, upper_y - lower_y);
+          upper_proj->add (pos.x () - 1, pos.y () - upper_y);
+        }
+        else
+          middle_proj->add (pos.x () - 1, pos.y () - lower_y);
+      }
+      else
+        lower_proj->add (pos.x () - 1, pos.y ());
+    }
+    pos += step;
+  }
+
+  for (out_it.mark_cycle_pt (); !out_it.cycled_list (); out_it.forward ()) {
+    vertical_cunderline_projection (out_it.data (),
+      baseline, xheight, baseline_offset,
+      lower_proj, middle_proj, upper_proj);
+  }
+}