#include <textord.h>

Public Member Functions
	Textord (CCStruct *ccstruct)

	~Textord ()

void	TextordPage (PageSegMode pageseg_mode, const FCOORD &reskew, int width, int height, Pix binary_pix, Pix thresholds_pix, Pix grey_pix, bool use_box_bottoms, BLOBNBOX_LIST diacritic_blobs, BLOCK_LIST blocks, TO_BLOCK_LIST to_blocks)

void	CleanupSingleRowResult (PageSegMode pageseg_mode, PAGE_RES *page_res)

bool	use_cjk_fp_model () const

void	set_use_cjk_fp_model (bool flag)

void	to_spacing (ICOORD page_tr, TO_BLOCK_LIST *blocks)

ROW *	make_prop_words (TO_ROW *row, FCOORD rotation)

ROW *	make_blob_words (TO_ROW *row, FCOORD rotation)

void	find_components (Pix pix, BLOCK_LIST blocks, TO_BLOCK_LIST *to_blocks)

void	filter_blobs (ICOORD page_tr, TO_BLOCK_LIST *blocks, BOOL8 testing_on)

void	compute_block_xheight (TO_BLOCK *block, float gradient)

void	make_spline_rows (TO_BLOCK *block, float gradient, BOOL8 testing_on)

compute_row_xheight
Estimate the xheight of this row. Compute the ascender rise and descender drop at the same time. Set xheigh_evidence to the number of blobs with the chosen xheight that appear in this row.
void	compute_row_xheight (TO_ROW *row, const FCOORD &rotation, float gradient, int block_line_size)

Public Attributes
bool	textord_single_height_mode = false

bool	tosp_old_to_method = false

bool	tosp_old_to_constrain_sp_kn = false

bool	tosp_only_use_prop_rows = true

bool	tosp_force_wordbreak_on_punct = false

bool	tosp_use_pre_chopping = false

bool	tosp_old_to_bug_fix = false

bool	tosp_block_use_cert_spaces = true

bool	tosp_row_use_cert_spaces = true

bool	tosp_narrow_blobs_not_cert = true

bool	tosp_row_use_cert_spaces1 = true

bool	tosp_recovery_isolated_row_stats = true

bool	tosp_only_small_gaps_for_kern = false

bool	tosp_all_flips_fuzzy = false

bool	tosp_fuzzy_limit_all = true

bool	tosp_stats_use_xht_gaps = true

bool	tosp_use_xht_gaps = true

bool	tosp_only_use_xht_gaps = false

bool	tosp_rule_9_test_punct = false

bool	tosp_flip_fuzz_kn_to_sp = true

bool	tosp_flip_fuzz_sp_to_kn = true

bool	tosp_improve_thresh = false

int	tosp_debug_level = 0

int	tosp_enough_space_samples_for_median = 3

int	tosp_redo_kern_limit = 10

int	tosp_few_samples = 40

int	tosp_short_row = 20

int	tosp_sanity_method = 1

double	tosp_old_sp_kn_th_factor = 2.0

double	tosp_threshold_bias1 = 0

double	tosp_threshold_bias2 = 0

double	tosp_narrow_fraction = 0.3

double	tosp_narrow_aspect_ratio = 0.48

double	tosp_wide_fraction = 0.52

double	tosp_wide_aspect_ratio = 0.0

double	tosp_fuzzy_space_factor = 0.6

double	tosp_fuzzy_space_factor1 = 0.5

double	tosp_fuzzy_space_factor2 = 0.72

double	tosp_gap_factor = 0.83

double	tosp_kern_gap_factor1 = 2.0

double	tosp_kern_gap_factor2 = 1.3

double	tosp_kern_gap_factor3 = 2.5

double	tosp_ignore_big_gaps = -1

double	tosp_ignore_very_big_gaps = 3.5

double	tosp_rep_space = 1.6

double	tosp_enough_small_gaps = 0.65

double	tosp_table_kn_sp_ratio = 2.25

double	tosp_table_xht_sp_ratio = 0.33

double	tosp_table_fuzzy_kn_sp_ratio = 3.0

double	tosp_fuzzy_kn_fraction = 0.5

double	tosp_fuzzy_sp_fraction = 0.5

double	tosp_min_sane_kn_sp = 1.5

double	tosp_init_guess_kn_mult = 2.2

double	tosp_init_guess_xht_mult = 0.28

double	tosp_max_sane_kn_thresh = 5.0

double	tosp_flip_caution = 0.0

double	tosp_large_kerning = 0.19

double	tosp_dont_fool_with_small_kerns = -1

double	tosp_near_lh_edge = 0

double	tosp_silly_kn_sp_gap = 0.2

double	tosp_pass_wide_fuzz_sp_to_context = 0.75

bool	textord_no_rejects = false

bool	textord_show_blobs = false

bool	textord_show_boxes = false

int	textord_max_noise_size = 7

int	textord_baseline_debug = 0

double	textord_blob_size_bigile = 95

double	textord_noise_area_ratio = 0.7

double	textord_blob_size_smallile = 20

double	textord_initialx_ile = 0.75

double	textord_initialasc_ile = 0.90

int	textord_noise_sizefraction = 10

double	textord_noise_sizelimit = 0.5

int	textord_noise_translimit = 16

double	textord_noise_normratio = 2.0

bool	textord_noise_rejwords = true

bool	textord_noise_rejrows = true

double	textord_noise_syfract = 0.2

double	textord_noise_sxfract = 0.4

double	textord_noise_hfract = 1.0/64

int	textord_noise_sncount = 1

double	textord_noise_rowratio = 6.0

bool	textord_noise_debug = FALSE

double	textord_blshift_maxshift = 0.00

double	textord_blshift_xfraction = 9.99

Detailed Description

Definition at line 68 of file textord.h.

Constructor & Destructor Documentation

tesseract::Textord::Textord ( CCStruct * ccstruct )

explicit

Definition at line 35 of file textord.cpp.

     : ccstruct_(ccstruct), use_cjk_fp_model_(false),
       // makerow.cpp ///////////////////////////////////////////
       BOOL_MEMBER(textord_single_height_mode, false,
                   "Script has no xheight, so use a single mode",
                   ccstruct_->params()),
       // tospace.cpp ///////////////////////////////////////////
       BOOL_MEMBER(tosp_old_to_method, false, "Space stats use prechopping?",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_old_to_constrain_sp_kn, false,
                   "Constrain relative values of inter and intra-word gaps for "
                   "old_to_method.",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_only_use_prop_rows, true,
                   "Block stats to use fixed pitch rows?",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_force_wordbreak_on_punct, false,
                   "Force word breaks on punct to break long lines in non-space "
                   "delimited langs",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_use_pre_chopping, false,
                   "Space stats use prechopping?",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_old_to_bug_fix, false, "Fix suspected bug in old code",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_block_use_cert_spaces, true,
                   "Only stat OBVIOUS spaces",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_row_use_cert_spaces, true, "Only stat OBVIOUS spaces",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_narrow_blobs_not_cert, true,
             "Only stat OBVIOUS spaces",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_row_use_cert_spaces1, true, "Only stat OBVIOUS spaces",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_recovery_isolated_row_stats, true,
                   "Use row alone when inadequate cert spaces",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_only_small_gaps_for_kern, false, "Better guess",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_all_flips_fuzzy, false, "Pass ANY flip to context?",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_fuzzy_limit_all, true,
                   "Dont restrict kn->sp fuzzy limit to tables",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_stats_use_xht_gaps, true,
                   "Use within xht gap for wd breaks",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_use_xht_gaps, true, "Use within xht gap for wd breaks",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_only_use_xht_gaps, false,
                   "Only use within xht gap for wd breaks",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_rule_9_test_punct, false,
                   "Dont chng kn to space next to punct",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_flip_fuzz_kn_to_sp, true, "Default flip",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_flip_fuzz_sp_to_kn, true, "Default flip",
                   ccstruct_->params()),
       BOOL_MEMBER(tosp_improve_thresh, false, "Enable improvement heuristic",
                   ccstruct_->params()),
       INT_MEMBER(tosp_debug_level, 0, "Debug data",
                  ccstruct_->params()),
       INT_MEMBER(tosp_enough_space_samples_for_median, 3,
            "or should we use mean",
                  ccstruct_->params()),
       INT_MEMBER(tosp_redo_kern_limit, 10,
                  "No.samples reqd to reestimate for row",
                  ccstruct_->params()),
       INT_MEMBER(tosp_few_samples, 40,
                  "No.gaps reqd with 1 large gap to treat as a table",
                  ccstruct_->params()),
       INT_MEMBER(tosp_short_row, 20,
                  "No.gaps reqd with few cert spaces to use certs",
                  ccstruct_->params()),
       INT_MEMBER(tosp_sanity_method, 1, "How to avoid being silly",
                  ccstruct_->params()),
       double_MEMBER(tosp_old_sp_kn_th_factor, 2.0,
                     "Factor for defining space threshold in terms of space and "
                     "kern sizes",
                     ccstruct_->params()),
       double_MEMBER(tosp_threshold_bias1, 0,
                     "how far between kern and space?",
                     ccstruct_->params()),
       double_MEMBER(tosp_threshold_bias2, 0,
                     "how far between kern and space?",
                     ccstruct_->params()),
       double_MEMBER(tosp_narrow_fraction, 0.3, "Fract of xheight for narrow",
                     ccstruct_->params()),
       double_MEMBER(tosp_narrow_aspect_ratio, 0.48,
                     "narrow if w/h less than this",
                     ccstruct_->params()),
       double_MEMBER(tosp_wide_fraction, 0.52, "Fract of xheight for wide",
                     ccstruct_->params()),
       double_MEMBER(tosp_wide_aspect_ratio, 0.0, "wide if w/h less than this",
                     ccstruct_->params()),
       double_MEMBER(tosp_fuzzy_space_factor, 0.6,
                     "Fract of xheight for fuzz sp",
                     ccstruct_->params()),
       double_MEMBER(tosp_fuzzy_space_factor1, 0.5,
                     "Fract of xheight for fuzz sp",
                     ccstruct_->params()),
       double_MEMBER(tosp_fuzzy_space_factor2, 0.72,
                     "Fract of xheight for fuzz sp",
                     ccstruct_->params()),
       double_MEMBER(tosp_gap_factor, 0.83, "gap ratio to flip sp->kern",
                     ccstruct_->params()),
       double_MEMBER(tosp_kern_gap_factor1, 2.0, "gap ratio to flip kern->sp",
                     ccstruct_->params()),
       double_MEMBER(tosp_kern_gap_factor2, 1.3, "gap ratio to flip kern->sp",
                     ccstruct_->params()),
       double_MEMBER(tosp_kern_gap_factor3, 2.5, "gap ratio to flip kern->sp",
                     ccstruct_->params()),
       double_MEMBER(tosp_ignore_big_gaps, -1, "xht multiplier",
                     ccstruct_->params()),
       double_MEMBER(tosp_ignore_very_big_gaps, 3.5, "xht multiplier",
                     ccstruct_->params()),
       double_MEMBER(tosp_rep_space, 1.6, "rep gap multiplier for space",
                     ccstruct_->params()),
       double_MEMBER(tosp_enough_small_gaps, 0.65,
                     "Fract of kerns reqd for isolated row stats",
                     ccstruct_->params()),
       double_MEMBER(tosp_table_kn_sp_ratio, 2.25,
                     "Min difference of kn & sp in table",
                     ccstruct_->params()),
       double_MEMBER(tosp_table_xht_sp_ratio, 0.33,
                     "Expect spaces bigger than this",
                     ccstruct_->params()),
       double_MEMBER(tosp_table_fuzzy_kn_sp_ratio, 3.0,
                     "Fuzzy if less than this",
                     ccstruct_->params()),
       double_MEMBER(tosp_fuzzy_kn_fraction, 0.5, "New fuzzy kn alg",
                     ccstruct_->params()),
       double_MEMBER(tosp_fuzzy_sp_fraction, 0.5, "New fuzzy sp alg",
                     ccstruct_->params()),
       double_MEMBER(tosp_min_sane_kn_sp, 1.5,
                     "Dont trust spaces less than this time kn",
                     ccstruct_->params()),
       double_MEMBER(tosp_init_guess_kn_mult, 2.2,
                     "Thresh guess - mult kn by this",
                     ccstruct_->params()),
       double_MEMBER(tosp_init_guess_xht_mult, 0.28,
                     "Thresh guess - mult xht by this",
                     ccstruct_->params()),
       double_MEMBER(tosp_max_sane_kn_thresh, 5.0,
                     "Multiplier on kn to limit thresh",
                     ccstruct_->params()),
       double_MEMBER(tosp_flip_caution, 0.0,
                     "Dont autoflip kn to sp when large separation",
                     ccstruct_->params()),
       double_MEMBER(tosp_large_kerning, 0.19,
                     "Limit use of xht gap with large kns",
                     ccstruct_->params()),
       double_MEMBER(tosp_dont_fool_with_small_kerns, -1,
                     "Limit use of xht gap with odd small kns",
                     ccstruct_->params()),
       double_MEMBER(tosp_near_lh_edge, 0,
                     "Dont reduce box if the top left is non blank",
                     ccstruct_->params()),
       double_MEMBER(tosp_silly_kn_sp_gap, 0.2,
                     "Dont let sp minus kn get too small",
                     ccstruct_->params()),
       double_MEMBER(tosp_pass_wide_fuzz_sp_to_context, 0.75,
                     "How wide fuzzies need context",
                     ccstruct_->params()),
       // tordmain.cpp ///////////////////////////////////////////
       BOOL_MEMBER(textord_no_rejects, false, "Don't remove noise blobs",
                   ccstruct_->params()),
       BOOL_MEMBER(textord_show_blobs, false, "Display unsorted blobs",
                   ccstruct_->params()),
       BOOL_MEMBER(textord_show_boxes, false, "Display unsorted blobs",
                   ccstruct_->params()),
       INT_MEMBER(textord_max_noise_size, 7, "Pixel size of noise",
                   ccstruct_->params()),
       INT_MEMBER(textord_baseline_debug, 0, "Baseline debug level",
                   ccstruct_->params()),
       double_MEMBER(textord_blob_size_bigile, 95, "Percentile for large blobs",
                     ccstruct_->params()),
       double_MEMBER(textord_noise_area_ratio, 0.7,
                     "Fraction of bounding box for noise",
                     ccstruct_->params()),
       double_MEMBER(textord_blob_size_smallile, 20,
                     "Percentile for small blobs",
                     ccstruct_->params()),
       double_MEMBER(textord_initialx_ile, 0.75,
                     "Ile of sizes for xheight guess",
                     ccstruct_->params()),
       double_MEMBER(textord_initialasc_ile, 0.90,
                     "Ile of sizes for xheight guess",
                     ccstruct_->params()),
       INT_MEMBER(textord_noise_sizefraction, 10,
                  "Fraction of size for maxima",
                  ccstruct_->params()),
       double_MEMBER(textord_noise_sizelimit, 0.5,
                     "Fraction of x for big t count",
                     ccstruct_->params()),
       INT_MEMBER(textord_noise_translimit, 16, "Transitions for normal blob",
                  ccstruct_->params()),
       double_MEMBER(textord_noise_normratio, 2.0,
                     "Dot to norm ratio for deletion",
                     ccstruct_->params()),
       BOOL_MEMBER(textord_noise_rejwords, true, "Reject noise-like words",
                   ccstruct_->params()),
       BOOL_MEMBER(textord_noise_rejrows, true, "Reject noise-like rows",
                   ccstruct_->params()),
       double_MEMBER(textord_noise_syfract, 0.2,
                     "xh fract height error for norm blobs",
                     ccstruct_->params()),
       double_MEMBER(textord_noise_sxfract, 0.4,
                     "xh fract width error for norm blobs",
                     ccstruct_->params()),
       double_MEMBER(textord_noise_hfract, 1.0/64,
                     "Height fraction to discard outlines as speckle noise",
                     ccstruct_->params()),
       INT_MEMBER(textord_noise_sncount, 1, "super norm blobs to save row",
                  ccstruct_->params()),
       double_MEMBER(textord_noise_rowratio, 6.0,
                     "Dot to norm ratio for deletion",
                     ccstruct_->params()),
       BOOL_MEMBER(textord_noise_debug, false, "Debug row garbage detector",
                   ccstruct_->params()),
       double_MEMBER(textord_blshift_maxshift, 0.00, "Max baseline shift",
                     ccstruct_->params()),
       double_MEMBER(textord_blshift_xfraction, 9.99,
                     "Min size of baseline shift",
                     ccstruct_->params()) {
 }

tesseract::Textord::~Textord ( )

Definition at line 264 of file textord.cpp.

264 {

265 }

Member Function Documentation

void tesseract::Textord::CleanupSingleRowResult	(	PageSegMode	pageseg_mode,
		PAGE_RES *	page_res
	)

Definition at line 359 of file textord.cpp.

                                                          {
   if (PSM_LINE_FIND_ENABLED(pageseg_mode) || PSM_SPARSE(pageseg_mode))
     return;  // No cleanup required.
   PAGE_RES_IT it(page_res);
   // Find the best row, being the greatest mean word conf.
   float row_total_conf = 0.0f;
   int row_word_count = 0;
   ROW_RES* best_row = NULL;
   float best_conf = 0.0f;
   for (it.restart_page(); it.word() != NULL; it.forward()) {
     WERD_RES* word = it.word();
     row_total_conf += word->best_choice->certainty();
     ++row_word_count;
     if (it.next_row() != it.row()) {
       row_total_conf /= row_word_count;
       if (best_row == NULL || best_conf < row_total_conf) {
         best_row = it.row();
         best_conf = row_total_conf;
       }
       row_total_conf = 0.0f;
       row_word_count = 0;
     }
   }
   // Now eliminate any word not in the best row.
   for (it.restart_page(); it.word() != NULL; it.forward()) {
     if (it.row() != best_row)
       it.DeleteCurrentWord();
   }
 }

void tesseract::Textord::compute_block_xheight	(	TO_BLOCK *	block,
		float	gradient
	)

Definition at line 1285 of file makerow.cpp.

                                                                    {
   TO_ROW *row;                          // current row
   float asc_frac_xheight = CCStruct::kAscenderFraction /
       CCStruct::kXHeightFraction;
   float desc_frac_xheight = CCStruct::kDescenderFraction /
       CCStruct::kXHeightFraction;
   inT32 min_height, max_height;         // limits on xheight
   TO_ROW_IT row_it = block->get_rows();
   if (row_it.empty()) return;  // no rows
 
   // Compute the best guess of xheight of each row individually.
   // Use xheight and ascrise values of the rows where ascenders were found.
   get_min_max_xheight(block->line_size, &min_height, &max_height);
   STATS row_asc_xheights(min_height, max_height + 1);
   STATS row_asc_ascrise(static_cast<int>(min_height * asc_frac_xheight),
                         static_cast<int>(max_height * asc_frac_xheight) + 1);
   int min_desc_height = static_cast<int>(min_height * desc_frac_xheight);
   int max_desc_height = static_cast<int>(max_height * desc_frac_xheight);
   STATS row_asc_descdrop(min_desc_height, max_desc_height + 1);
   STATS row_desc_xheights(min_height, max_height + 1);
   STATS row_desc_descdrop(min_desc_height, max_desc_height + 1);
   STATS row_cap_xheights(min_height, max_height + 1);
   STATS row_cap_floating_xheights(min_height, max_height + 1);
   for (row_it.mark_cycle_pt(); !row_it.cycled_list(); row_it.forward()) {
     row = row_it.data();
     // Compute the xheight of this row if it has not been computed before.
     if (row->xheight <= 0.0) {
       compute_row_xheight(row, block->block->classify_rotation(),
                           gradient, block->line_size);
     }
     ROW_CATEGORY row_category = get_row_category(row);
     if (row_category == ROW_ASCENDERS_FOUND) {
       row_asc_xheights.add(static_cast<inT32>(row->xheight),
                            row->xheight_evidence);
       row_asc_ascrise.add(static_cast<inT32>(row->ascrise),
                           row->xheight_evidence);
       row_asc_descdrop.add(static_cast<inT32>(-row->descdrop),
                            row->xheight_evidence);
     } else if (row_category == ROW_DESCENDERS_FOUND) {
       row_desc_xheights.add(static_cast<inT32>(row->xheight),
                             row->xheight_evidence);
       row_desc_descdrop.add(static_cast<inT32>(-row->descdrop),
                             row->xheight_evidence);
     } else if (row_category == ROW_UNKNOWN) {
       fill_heights(row, gradient, min_height, max_height,
                    &row_cap_xheights, &row_cap_floating_xheights);
     }
   }
 
   float xheight = 0.0;
   float ascrise = 0.0;
   float descdrop = 0.0;
   // Compute our best guess of xheight of this block.
   if (row_asc_xheights.get_total() > 0) {
     // Determine xheight from rows where ascenders were found.
     xheight = row_asc_xheights.median();
     ascrise = row_asc_ascrise.median();
     descdrop = -row_asc_descdrop.median();
   } else if (row_desc_xheights.get_total() > 0) {
     // Determine xheight from rows where descenders were found.
     xheight = row_desc_xheights.median();
     descdrop = -row_desc_descdrop.median();
   } else if (row_cap_xheights.get_total() > 0) {
     // All the rows in the block were (a/de)scenderless.
     // Try to search for two modes in row_cap_heights that could
     // be the xheight and the capheight (e.g. some of the rows
     // were lowercase, but did not have enough (a/de)scenders.
     // If such two modes can not be found, this block is most
     // likely all caps (or all small caps, in which case the code
     // still works as intended).
     compute_xheight_from_modes(&row_cap_xheights, &row_cap_floating_xheights,
                                textord_single_height_mode &&
                                block->block->classify_rotation().y() == 0.0,
                                min_height, max_height, &(xheight), &(ascrise));
     if (ascrise == 0) {  // assume only caps in the whole block
       xheight = row_cap_xheights.median() * CCStruct::kXHeightCapRatio;
     }
   } else {  // default block sizes
     xheight = block->line_size * CCStruct::kXHeightFraction;
   }
   // Correct xheight, ascrise and descdrop if necessary.
   bool corrected_xheight = false;
   if (xheight < textord_min_xheight) {
     xheight = static_cast<float>(textord_min_xheight);
     corrected_xheight = true;
   }
   if (corrected_xheight || ascrise <= 0.0) {
     ascrise = xheight * asc_frac_xheight;
   }
   if (corrected_xheight || descdrop >= 0.0) {
     descdrop = -(xheight * desc_frac_xheight);
   }
   block->xheight = xheight;
 
   if (textord_debug_xheights) {
     tprintf("Block average xheight=%.4f, ascrise=%.4f, descdrop=%.4f\n",
             xheight, ascrise, descdrop);
   }
   // Correct xheight, ascrise, descdrop of rows based on block averages.
   for (row_it.mark_cycle_pt(); !row_it.cycled_list(); row_it.forward()) {
     correct_row_xheight(row_it.data(), xheight, ascrise, descdrop);
   }
 }

void tesseract::Textord::compute_row_xheight	(	TO_ROW *	row,
		const FCOORD &	rotation,
		float	gradient,
		int	block_line_size
	)

Definition at line 1397 of file makerow.cpp.

                                                        {
   // Find blobs representing repeated characters in rows and mark them.
   // This information is used for computing row xheight and at a later
   // stage when words are formed by make_words.
   if (!row->rep_chars_marked()) {
     mark_repeated_chars(row);
   }
 
   int min_height, max_height;
   get_min_max_xheight(block_line_size, &min_height, &max_height);
   STATS heights(min_height, max_height + 1);
   STATS floating_heights(min_height, max_height + 1);
   fill_heights(row, gradient, min_height, max_height,
                &heights, &floating_heights);
   row->ascrise = 0.0f;
   row->xheight = 0.0f;
   row->xheight_evidence =
     compute_xheight_from_modes(&heights, &floating_heights,
                                textord_single_height_mode &&
                                rotation.y() == 0.0,
                                min_height, max_height,
                                &(row->xheight), &(row->ascrise));
   row->descdrop = 0.0f;
   if (row->xheight > 0.0) {
     row->descdrop = static_cast<float>(
         compute_row_descdrop(row, gradient, row->xheight_evidence, &heights));
   }
 }

void tesseract::Textord::filter_blobs	(	ICOORD	page_tr,
		TO_BLOCK_LIST *	blocks,
		BOOL8	testing_on
	)

Definition at line 239 of file tordmain.cpp.

                                              {     // for plotting
   TO_BLOCK_IT block_it = blocks;          // destination iterator
   TO_BLOCK *block;                        // created block
 
   #ifndef GRAPHICS_DISABLED
   if (to_win != NULL)
     to_win->Clear();
   #endif  // GRAPHICS_DISABLED
 
   for (block_it.mark_cycle_pt(); !block_it.cycled_list();
        block_it.forward()) {
     block = block_it.data();
     block->line_size = filter_noise_blobs(&block->blobs,
       &block->noise_blobs,
       &block->small_blobs,
       &block->large_blobs);
     block->line_spacing = block->line_size *
         (tesseract::CCStruct::kDescenderFraction +
          tesseract::CCStruct::kXHeightFraction +
          2 * tesseract::CCStruct::kAscenderFraction) /
          tesseract::CCStruct::kXHeightFraction;
     block->line_size *= textord_min_linesize;
     block->max_blob_size = block->line_size * textord_excess_blobsize;
 
     #ifndef GRAPHICS_DISABLED
     if (textord_show_blobs && testing_on) {
       if (to_win == NULL)
         create_to_win(page_tr);
       block->plot_graded_blobs(to_win);
     }
     if (textord_show_boxes && testing_on) {
       if (to_win == NULL)
         create_to_win(page_tr);
       plot_box_list(to_win, &block->noise_blobs, ScrollView::WHITE);
       plot_box_list(to_win, &block->small_blobs, ScrollView::WHITE);
       plot_box_list(to_win, &block->large_blobs, ScrollView::WHITE);
       plot_box_list(to_win, &block->blobs, ScrollView::WHITE);
     }
     #endif  // GRAPHICS_DISABLED
   }
 }

void tesseract::Textord::find_components	(	Pix *	pix,
		BLOCK_LIST *	blocks,
		TO_BLOCK_LIST *	to_blocks
	)

Definition at line 208 of file tordmain.cpp.

                                                         {
   int width = pixGetWidth(pix);
   int height = pixGetHeight(pix);
   if (width > MAX_INT16 || height > MAX_INT16) {
     tprintf("Input image too large! (%d, %d)\n", width, height);
     return;  // Can't handle it.
   }
 
   set_global_loc_code(LOC_EDGE_PROG);
 
   BLOCK_IT block_it(blocks);    // iterator
   for (block_it.mark_cycle_pt(); !block_it.cycled_list();
        block_it.forward()) {
     BLOCK* block = block_it.data();
     if (block->poly_block() == NULL || block->poly_block()->IsText()) {
       extract_edges(pix, block);
     }
   }
 
   assign_blobs_to_blocks2(pix, blocks, to_blocks);
   ICOORD page_tr(width, height);
   filter_blobs(page_tr, to_blocks, !textord_test_landscape);
 }

ROW * tesseract::Textord::make_blob_words	(	TO_ROW *	row,
		FCOORD	rotation
	)

Definition at line 1177 of file tospace.cpp.

                                 {
   bool bol;                      // start of line
   ROW *real_row;                 // output row
   C_OUTLINE_IT cout_it;
   C_BLOB_LIST cblobs;
   C_BLOB_IT cblob_it = &cblobs;
   WERD_LIST words;
   WERD_IT word_it;               // new words
   WERD *word;                    // new word
   BLOBNBOX *bblob;               // current blob
   TBOX blob_box;                 // bounding box
   BLOBNBOX_IT box_it;            // iterator
   inT16 word_count = 0;
 
   cblob_it.set_to_list(&cblobs);
   box_it.set_to_list(row->blob_list());
   word_it.set_to_list(&words);
   bol = TRUE;
   if (!box_it.empty()) {
 
     do {
       bblob = box_it.data();
       blob_box = bblob->bounding_box();
       if (bblob->joined_to_prev()) {
         if (bblob->cblob() != NULL) {
           cout_it.set_to_list(cblob_it.data()->out_list());
           cout_it.move_to_last();
           cout_it.add_list_after(bblob->cblob()->out_list());
           delete bblob->cblob();
         }
       } else {
         if (bblob->cblob() != NULL)
           cblob_it.add_after_then_move(bblob->cblob());
       }
       box_it.forward();         // next one
       bblob = box_it.data();
       blob_box = bblob->bounding_box();
 
       if (!bblob->joined_to_prev() && !cblobs.empty()) {
         word = new WERD(&cblobs, 1, NULL);
         word_count++;
         word_it.add_after_then_move(word);
         if (bol) {
           word->set_flag(W_BOL, TRUE);
           bol = FALSE;
         }
         if (box_it.at_first()) { // at end of line
           word->set_flag(W_EOL, TRUE);
         }
       }
     }
     while (!box_it.at_first()); // until back at start
     /* Setup the row with created words. */
     real_row = new ROW(row, (inT16) row->kern_size, (inT16) row->space_size);
     word_it.set_to_list(real_row->word_list());
                                  //put words in row
     word_it.add_list_after(&words);
     real_row->recalc_bounding_box();
     if (tosp_debug_level > 4) {
       tprintf ("Row:Made %d words in row ((%d,%d)(%d,%d))\n",
         word_count,
         real_row->bounding_box().left(),
         real_row->bounding_box().bottom(),
         real_row->bounding_box().right(),
         real_row->bounding_box().top());
     }
     return real_row;
   }
   return NULL;
 }

ROW * tesseract::Textord::make_prop_words	(	TO_ROW *	row,
		FCOORD	rotation
	)

Definition at line 884 of file tospace.cpp.

                                 {
   BOOL8 bol;                     // start of line
   /* prev_ values are for start of word being built. non prev_ values are for
   the gap between the word being built and the next one. */
   BOOL8 prev_fuzzy_sp;           // probably space
   BOOL8 prev_fuzzy_non;          // probably not
   uinT8 prev_blanks;             // in front of word
   BOOL8 fuzzy_sp = false;        // probably space
   BOOL8 fuzzy_non = false;       // probably not
   uinT8 blanks = 0;              // in front of word
   BOOL8 prev_gap_was_a_space = FALSE;
   BOOL8 break_at_next_gap = FALSE;
   ROW *real_row;                 // output row
   C_OUTLINE_IT cout_it;
   C_BLOB_LIST cblobs;
   C_BLOB_IT cblob_it = &cblobs;
   WERD_LIST words;
   WERD_IT word_it;               // new words
   WERD *word;                    // new word
   WERD_IT rep_char_it;           // repeated char words
   inT32 next_rep_char_word_right = MAX_INT32;
   float repetition_spacing;      // gap between repetitions
   inT32 xstarts[2];              // row ends
   inT32 prev_x;                  // end of prev blob
   BLOBNBOX *bblob;               // current blob
   TBOX blob_box;                 // bounding box
   BLOBNBOX_IT box_it;            // iterator
   TBOX prev_blob_box;
   TBOX next_blob_box;
   inT16 prev_gap = MAX_INT16;
   inT16 current_gap = MAX_INT16;
   inT16 next_gap = MAX_INT16;
   inT16 prev_within_xht_gap = MAX_INT16;
   inT16 current_within_xht_gap = MAX_INT16;
   inT16 next_within_xht_gap = MAX_INT16;
   inT16 word_count = 0;
 
   rep_char_it.set_to_list (&(row->rep_words));
   if (!rep_char_it.empty ()) {
     next_rep_char_word_right =
       rep_char_it.data ()->bounding_box ().right ();
   }
 
   prev_x = -MAX_INT16;
   cblob_it.set_to_list (&cblobs);
   box_it.set_to_list (row->blob_list ());
   word_it.set_to_list (&words);
   bol = TRUE;
   prev_blanks = 0;
   prev_fuzzy_sp = FALSE;
   prev_fuzzy_non = FALSE;
   if (!box_it.empty ()) {
     xstarts[0] = box_it.data ()->bounding_box ().left ();
     if (xstarts[0] > next_rep_char_word_right) {
       /* We need to insert a repeated char word at the start of the row */
       word = rep_char_it.extract ();
       word_it.add_after_then_move (word);
       /* Set spaces before repeated char word */
       word->set_flag (W_BOL, TRUE);
       bol = FALSE;
       word->set_blanks (0);
                                  //NO uncertainty
       word->set_flag (W_FUZZY_SP, FALSE);
       word->set_flag (W_FUZZY_NON, FALSE);
       xstarts[0] = word->bounding_box ().left ();
       /* Set spaces after repeated char word (and leave current word set) */
       repetition_spacing = find_mean_blob_spacing (word);
       current_gap = box_it.data ()->bounding_box ().left () -
         next_rep_char_word_right;
       current_within_xht_gap = current_gap;
       if (current_gap > tosp_rep_space * repetition_spacing) {
         prev_blanks = (uinT8) floor (current_gap / row->space_size);
         if (prev_blanks < 1)
           prev_blanks = 1;
       }
       else
         prev_blanks = 0;
       if (tosp_debug_level > 5)
         tprintf ("Repch wd at BOL(%d, %d). rep spacing %5.2f;  Rgap:%d  ",
           box_it.data ()->bounding_box ().left (),
           box_it.data ()->bounding_box ().bottom (),
           repetition_spacing, current_gap);
       prev_fuzzy_sp = FALSE;
       prev_fuzzy_non = FALSE;
       if (rep_char_it.empty ()) {
         next_rep_char_word_right = MAX_INT32;
       }
       else {
         rep_char_it.forward ();
         next_rep_char_word_right =
           rep_char_it.data ()->bounding_box ().right ();
       }
     }
 
     peek_at_next_gap(row,
                      box_it,
                      next_blob_box,
                      next_gap,
                      next_within_xht_gap);
     do {
       bblob = box_it.data ();
       blob_box = bblob->bounding_box ();
       if (bblob->joined_to_prev ()) {
         if (bblob->cblob () != NULL) {
           cout_it.set_to_list (cblob_it.data ()->out_list ());
           cout_it.move_to_last ();
           cout_it.add_list_after (bblob->cblob ()->out_list ());
           delete bblob->cblob ();
         }
       } else {
         if (bblob->cblob() != NULL)
           cblob_it.add_after_then_move (bblob->cblob ());
         prev_x = blob_box.right ();
       }
       box_it.forward ();         //next one
       bblob = box_it.data ();
       blob_box = bblob->bounding_box ();
 
       if (!bblob->joined_to_prev() && bblob->cblob() != NULL) {
         /* Real Blob - not multiple outlines or pre-chopped */
         prev_gap = current_gap;
         prev_within_xht_gap = current_within_xht_gap;
         prev_blob_box = next_blob_box;
         current_gap = next_gap;
         current_within_xht_gap = next_within_xht_gap;
         peek_at_next_gap(row,
                          box_it,
                          next_blob_box,
                          next_gap,
                          next_within_xht_gap);
 
         inT16 prev_gap_arg = prev_gap;
         inT16 next_gap_arg = next_gap;
         if (tosp_only_use_xht_gaps) {
           prev_gap_arg = prev_within_xht_gap;
           next_gap_arg = next_within_xht_gap;
         }
         // Decide if a word-break should be inserted
         if (blob_box.left () > next_rep_char_word_right ||
             make_a_word_break(row, blob_box, prev_gap_arg, prev_blob_box,
                               current_gap, current_within_xht_gap,
                               next_blob_box, next_gap_arg,
                               blanks, fuzzy_sp, fuzzy_non,
                               prev_gap_was_a_space,
                               break_at_next_gap) ||
             box_it.at_first()) {
           /* Form a new word out of the blobs collected */
           word = new WERD (&cblobs, prev_blanks, NULL);
           word_count++;
           word_it.add_after_then_move (word);
           if (bol) {
             word->set_flag (W_BOL, TRUE);
             bol = FALSE;
           }
           if (prev_fuzzy_sp)
                                  //probably space
             word->set_flag (W_FUZZY_SP, TRUE);
           else if (prev_fuzzy_non)
             word->set_flag (W_FUZZY_NON, TRUE);
           //probably not
 
           if (blob_box.left () > next_rep_char_word_right) {
             /* We need to insert a repeated char word */
             word = rep_char_it.extract ();
             word_it.add_after_then_move (word);
 
             /* Set spaces before repeated char word */
             repetition_spacing = find_mean_blob_spacing (word);
             current_gap = word->bounding_box ().left () - prev_x;
             current_within_xht_gap = current_gap;
             if (current_gap > tosp_rep_space * repetition_spacing) {
               blanks =
                 (uinT8) floor (current_gap / row->space_size);
               if (blanks < 1)
                 blanks = 1;
             }
             else
               blanks = 0;
             if (tosp_debug_level > 5)
               tprintf
                 ("Repch wd (%d,%d) rep gap %5.2f;  Lgap:%d (%d blanks);",
                 word->bounding_box ().left (),
                 word->bounding_box ().bottom (),
                 repetition_spacing, current_gap, blanks);
             word->set_blanks (blanks);
                                  //NO uncertainty
             word->set_flag (W_FUZZY_SP, FALSE);
             word->set_flag (W_FUZZY_NON, FALSE);
 
             /* Set spaces after repeated char word (and leave current word set) */
             current_gap =
               blob_box.left () - next_rep_char_word_right;
             if (current_gap > tosp_rep_space * repetition_spacing) {
               blanks = (uinT8) (current_gap / row->space_size);
               if (blanks < 1)
                 blanks = 1;
             }
             else
               blanks = 0;
             if (tosp_debug_level > 5)
               tprintf (" Rgap:%d (%d blanks)\n",
                 current_gap, blanks);
             fuzzy_sp = FALSE;
             fuzzy_non = FALSE;
 
             if (rep_char_it.empty ()) {
               next_rep_char_word_right = MAX_INT32;
             }
             else {
               rep_char_it.forward ();
               next_rep_char_word_right =
                 rep_char_it.data ()->bounding_box ().right ();
             }
           }
 
           if (box_it.at_first () && rep_char_it.empty ()) {
                                  //at end of line
             word->set_flag (W_EOL, TRUE);
             xstarts[1] = prev_x;
           }
           else {
             prev_blanks = blanks;
             prev_fuzzy_sp = fuzzy_sp;
             prev_fuzzy_non = fuzzy_non;
           }
         }
       }
     }
     while (!box_it.at_first ()); //until back at start
 
     /* Insert any further repeated char words */
     while (!rep_char_it.empty ()) {
       word = rep_char_it.extract ();
       word_it.add_after_then_move (word);
 
       /* Set spaces before repeated char word */
       repetition_spacing = find_mean_blob_spacing (word);
       current_gap = word->bounding_box ().left () - prev_x;
       if (current_gap > tosp_rep_space * repetition_spacing) {
         blanks = (uinT8) floor (current_gap / row->space_size);
         if (blanks < 1)
           blanks = 1;
       }
       else
         blanks = 0;
       if (tosp_debug_level > 5)
         tprintf
           ("Repch wd at EOL (%d,%d). rep spacing %d; Lgap:%d (%d blanks)\n",
           word->bounding_box ().left (), word->bounding_box ().bottom (),
           repetition_spacing, current_gap, blanks);
       word->set_blanks (blanks);
                                  //NO uncertainty
       word->set_flag (W_FUZZY_SP, FALSE);
       word->set_flag (W_FUZZY_NON, FALSE);
       prev_x = word->bounding_box ().right ();
       if (rep_char_it.empty ()) {
                                  //at end of line
         word->set_flag (W_EOL, TRUE);
         xstarts[1] = prev_x;
       }
       else {
         rep_char_it.forward ();
       }
     }
     real_row = new ROW (row,
       (inT16) row->kern_size, (inT16) row->space_size);
     word_it.set_to_list (real_row->word_list ());
                                  //put words in row
     word_it.add_list_after (&words);
     real_row->recalc_bounding_box ();
 
     if (tosp_debug_level > 4) {
       tprintf ("Row: Made %d words in row ((%d,%d)(%d,%d))\n",
         word_count,
         real_row->bounding_box ().left (),
         real_row->bounding_box ().bottom (),
         real_row->bounding_box ().right (),
         real_row->bounding_box ().top ());
     }
     return real_row;
   }
   return NULL;
 }

void tesseract::Textord::make_spline_rows	(	TO_BLOCK *	block,
		float	gradient,
		BOOL8	testing_on
	)

Definition at line 2034 of file makerow.cpp.

                                                  {
 #ifndef GRAPHICS_DISABLED
   ScrollView::Color colour;       //of row
 #endif
   TO_ROW_IT row_it = block->get_rows ();
 
   row_it.move_to_first ();
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
     if (row_it.data ()->blob_list ()->empty ())
       delete row_it.extract ();  //nothing in it
     else
       make_baseline_spline (row_it.data (), block);
   }
   if (textord_old_baselines) {
 #ifndef GRAPHICS_DISABLED
     if (testing_on) {
       colour = ScrollView::RED;
       for (row_it.mark_cycle_pt (); !row_it.cycled_list ();
       row_it.forward ()) {
         row_it.data ()->baseline.plot (to_win, colour);
         colour = (ScrollView::Color) (colour + 1);
         if (colour > ScrollView::MAGENTA)
           colour = ScrollView::RED;
       }
     }
 #endif
     make_old_baselines(block, testing_on, gradient);
   }
 #ifndef GRAPHICS_DISABLED
   if (testing_on) {
     colour = ScrollView::RED;
     for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
       row_it.data ()->baseline.plot (to_win, colour);
       colour = (ScrollView::Color) (colour + 1);
       if (colour > ScrollView::MAGENTA)
         colour = ScrollView::RED;
     }
   }
 #endif
 }

void tesseract::Textord::set_use_cjk_fp_model ( bool flag )

inline

Definition at line 95 of file textord.h.

                                        {
     use_cjk_fp_model_ = flag;
   }

void tesseract::Textord::TextordPage	(	PageSegMode	pageseg_mode,
		const FCOORD &	reskew,
		int	width,
		int	height,
		Pix *	binary_pix,
		Pix *	thresholds_pix,
		Pix *	grey_pix,
		bool	use_box_bottoms,
		BLOBNBOX_LIST *	diacritic_blobs,
		BLOCK_LIST *	blocks,
		TO_BLOCK_LIST *	to_blocks
	)

Definition at line 268 of file textord.cpp.

                                                                         {
   page_tr_.set_x(width);
   page_tr_.set_y(height);
   if (to_blocks->empty()) {
     // AutoPageSeg was not used, so we need to find_components first.
     find_components(binary_pix, blocks, to_blocks);
     TO_BLOCK_IT it(to_blocks);
     for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
       TO_BLOCK* to_block = it.data();
       // Compute the edge offsets whether or not there is a grey_pix.
       // We have by-passed auto page seg, so we have to run it here.
       // By page segmentation mode there is no non-text to avoid running on.
       to_block->ComputeEdgeOffsets(thresholds_pix, grey_pix);
     }
   } else if (!PSM_SPARSE(pageseg_mode)) {
     // AutoPageSeg does not need to find_components as it did that already.
     // Filter_blobs sets up the TO_BLOCKs the same as find_components does.
     filter_blobs(page_tr_, to_blocks, true);
   }
 
   ASSERT_HOST(!to_blocks->empty());
   if (pageseg_mode == PSM_SINGLE_BLOCK_VERT_TEXT) {
     const FCOORD anticlockwise90(0.0f, 1.0f);
     const FCOORD clockwise90(0.0f, -1.0f);
     TO_BLOCK_IT it(to_blocks);
     for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
       TO_BLOCK* to_block = it.data();
       BLOCK* block = to_block->block;
       // Create a fake poly_block in block from its bounding box.
       block->set_poly_block(new POLY_BLOCK(block->bounding_box(),
                                            PT_VERTICAL_TEXT));
       // Rotate the to_block along with its contained block and blobnbox lists.
       to_block->rotate(anticlockwise90);
       // Set the block's rotation values to obey the convention followed in
       // layout analysis for vertical text.
       block->set_re_rotation(clockwise90);
       block->set_classify_rotation(clockwise90);
     }
   }
 
   TO_BLOCK_IT to_block_it(to_blocks);
   TO_BLOCK* to_block = to_block_it.data();
   // Make the rows in the block.
   float gradient;
   // Do it the old fashioned way.
   if (PSM_LINE_FIND_ENABLED(pageseg_mode)) {
     gradient = make_rows(page_tr_, to_blocks);
   } else if (!PSM_SPARSE(pageseg_mode)) {
     // RAW_LINE, SINGLE_LINE, SINGLE_WORD and SINGLE_CHAR all need a single row.
     gradient = make_single_row(page_tr_, pageseg_mode != PSM_RAW_LINE,
                                to_block, to_blocks);
   }
   BaselineDetect baseline_detector(textord_baseline_debug,
                                    reskew, to_blocks);
   baseline_detector.ComputeStraightBaselines(use_box_bottoms);
   baseline_detector.ComputeBaselineSplinesAndXheights(page_tr_, true,
                                                       textord_heavy_nr,
                                                       textord_show_final_rows,
                                                       this);
   // Now make the words in the lines.
   if (PSM_WORD_FIND_ENABLED(pageseg_mode)) {
     // SINGLE_LINE uses the old word maker on the single line.
     make_words(this, page_tr_, gradient, blocks, to_blocks);
   } else {
     // SINGLE_WORD and SINGLE_CHAR cram all the blobs into a
     // single word, and in SINGLE_CHAR mode, all the outlines
     // go in a single blob.
     TO_BLOCK* to_block = to_block_it.data();
     make_single_word(pageseg_mode == PSM_SINGLE_CHAR,
                      to_block->get_rows(), to_block->block->row_list());
   }
   // Remove empties.
   cleanup_blocks(PSM_WORD_FIND_ENABLED(pageseg_mode), blocks);
   TransferDiacriticsToBlockGroups(diacritic_blobs, blocks);
   // Compute the margins for each row in the block, to be used later for
   // paragraph detection.
   BLOCK_IT b_it(blocks);
   for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
     b_it.data()->compute_row_margins();
   }
 #ifndef GRAPHICS_DISABLED
   close_to_win();
 #endif
 }

void tesseract::Textord::to_spacing	(	ICOORD	page_tr,
		TO_BLOCK_LIST *	blocks
	)

Definition at line 33 of file tospace.cpp.

                            {
   TO_BLOCK_IT block_it;          //iterator
   TO_BLOCK *block;               //current block;
   TO_ROW_IT row_it;              //row iterator
   TO_ROW *row;                   //current row
   int block_index;               //block number
   int row_index;                 //row number
   //estimated width of real spaces for whole block
   inT16 block_space_gap_width;
   //estimated width of non space gaps for whole block
   inT16 block_non_space_gap_width;
   BOOL8 old_text_ord_proportional;//old fixed/prop result
   GAPMAP *gapmap = NULL;          //map of big vert gaps in blk
 
   block_it.set_to_list (blocks);
   block_index = 1;
   for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
   block_it.forward ()) {
     block = block_it.data ();
     gapmap = new GAPMAP (block);
     block_spacing_stats(block,
                         gapmap,
                         old_text_ord_proportional,
                         block_space_gap_width,
                         block_non_space_gap_width);
     // Make sure relative values of block-level space and non-space gap
     // widths are reasonable. The ratio of 1:3 is also used in
     // block_spacing_stats, to corrrect the block_space_gap_width
     // Useful for arabic and hindi, when the non-space gap width is
     // often over-estimated and should not be trusted. A similar ratio
     // is found in block_spacing_stats.
     if (tosp_old_to_method && tosp_old_to_constrain_sp_kn &&
         (float) block_space_gap_width / block_non_space_gap_width < 3.0) {
       block_non_space_gap_width = (inT16) floor (block_space_gap_width / 3.0);
     }
     row_it.set_to_list (block->get_rows ());
     row_index = 1;
     for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
       row = row_it.data ();
       if ((row->pitch_decision == PITCH_DEF_PROP) ||
       (row->pitch_decision == PITCH_CORR_PROP)) {
         if ((tosp_debug_level > 0) && !old_text_ord_proportional)
           tprintf ("Block %d Row %d: Now Proportional\n",
             block_index, row_index);
         row_spacing_stats(row,
                           gapmap,
                           block_index,
                           row_index,
                           block_space_gap_width,
                           block_non_space_gap_width);
       }
       else {
         if ((tosp_debug_level > 0) && old_text_ord_proportional)
           tprintf
             ("Block %d Row %d: Now Fixed Pitch Decision:%d fp flag:%f\n",
             block_index, row_index, row->pitch_decision,
             row->fixed_pitch);
       }
 #ifndef GRAPHICS_DISABLED
       if (textord_show_initial_words)
         plot_word_decisions (to_win, (inT16) row->fixed_pitch, row);
 #endif
       row_index++;
     }
     delete gapmap;
     block_index++;
   }
 }

bool tesseract::Textord::use_cjk_fp_model ( ) const

inline

Definition at line 92 of file textord.h.

                                 {
     return use_cjk_fp_model_;
   }

Member Data Documentation

int tesseract::Textord::textord_baseline_debug = 0

"Baseline debug level"

Definition at line 377 of file textord.h.

double tesseract::Textord::textord_blob_size_bigile = 95

"Percentile for large blobs"

Definition at line 378 of file textord.h.

double tesseract::Textord::textord_blob_size_smallile = 20

"Percentile for small blobs"

Definition at line 381 of file textord.h.

double tesseract::Textord::textord_blshift_maxshift = 0.00

"Max baseline shift"

Definition at line 398 of file textord.h.

double tesseract::Textord::textord_blshift_xfraction = 9.99

"Min size of baseline shift"

Definition at line 399 of file textord.h.

double tesseract::Textord::textord_initialasc_ile = 0.90

"Ile of sizes for xheight guess"

Definition at line 383 of file textord.h.

double tesseract::Textord::textord_initialx_ile = 0.75

"Ile of sizes for xheight guess"

Definition at line 382 of file textord.h.

int tesseract::Textord::textord_max_noise_size = 7

"Pixel size of noise"

Definition at line 376 of file textord.h.

bool tesseract::Textord::textord_no_rejects = false

"Don't remove noise blobs"

Definition at line 373 of file textord.h.

double tesseract::Textord::textord_noise_area_ratio = 0.7

"Fraction of bounding box for noise"

Definition at line 380 of file textord.h.

bool tesseract::Textord::textord_noise_debug = FALSE

"Debug row garbage detector"

Definition at line 397 of file textord.h.

double tesseract::Textord::textord_noise_hfract = 1.0/64

"Height fraction to discard outlines as speckle noise"

Definition at line 394 of file textord.h.

double tesseract::Textord::textord_noise_normratio = 2.0

"Dot to norm ratio for deletion"

Definition at line 387 of file textord.h.

bool tesseract::Textord::textord_noise_rejrows = true

"Reject noise-like rows"

Definition at line 389 of file textord.h.

bool tesseract::Textord::textord_noise_rejwords = true

"Reject noise-like words"

Definition at line 388 of file textord.h.

double tesseract::Textord::textord_noise_rowratio = 6.0

"Dot to norm ratio for deletion"

Definition at line 396 of file textord.h.

int tesseract::Textord::textord_noise_sizefraction = 10

"Fraction of size for maxima"

Definition at line 384 of file textord.h.

double tesseract::Textord::textord_noise_sizelimit = 0.5

"Fraction of x for big t count"

Definition at line 385 of file textord.h.

int tesseract::Textord::textord_noise_sncount = 1

"super norm blobs to save row"

Definition at line 395 of file textord.h.

double tesseract::Textord::textord_noise_sxfract = 0.4

"xh fract width error for norm blobs"

Definition at line 392 of file textord.h.

double tesseract::Textord::textord_noise_syfract = 0.2

"xh fract error for norm blobs"

Definition at line 390 of file textord.h.

int tesseract::Textord::textord_noise_translimit = 16

"Transitions for normal blob"

Definition at line 386 of file textord.h.

bool tesseract::Textord::textord_show_blobs = false

"Display unsorted blobs"

Definition at line 374 of file textord.h.

bool tesseract::Textord::textord_show_boxes = false

"Display boxes"

Definition at line 375 of file textord.h.

bool tesseract::Textord::textord_single_height_mode = false

"Script has no xheight, so use a single mode for horizontal text"

Definition at line 261 of file textord.h.

bool tesseract::Textord::tosp_all_flips_fuzzy = false

"Pass ANY flip to context?"

Definition at line 287 of file textord.h.

bool tesseract::Textord::tosp_block_use_cert_spaces = true

"Only stat OBVIOUS spaces"

Definition at line 277 of file textord.h.

int tesseract::Textord::tosp_debug_level = 0

"Debug data"

Definition at line 302 of file textord.h.

double tesseract::Textord::tosp_dont_fool_with_small_kerns = -1

"Limit use of xht gap with odd small kns"

Definition at line 365 of file textord.h.

double tesseract::Textord::tosp_enough_small_gaps = 0.65

"Fract of kerns reqd for isolated row stats"

Definition at line 343 of file textord.h.

int tesseract::Textord::tosp_enough_space_samples_for_median = 3

"or should we use mean"

Definition at line 304 of file textord.h.

int tesseract::Textord::tosp_few_samples = 40

"No.gaps reqd with 1 large gap to treat as a table"

Definition at line 308 of file textord.h.

double tesseract::Textord::tosp_flip_caution = 0.0

"Dont autoflip kn to sp when large separation"

Definition at line 361 of file textord.h.

bool tesseract::Textord::tosp_flip_fuzz_kn_to_sp = true

"Default flip"

Definition at line 298 of file textord.h.

bool tesseract::Textord::tosp_flip_fuzz_sp_to_kn = true

"Default flip"

Definition at line 299 of file textord.h.

bool tesseract::Textord::tosp_force_wordbreak_on_punct = false

"Force word breaks on punct to break long lines in non-space " "delimited langs"

Definition at line 271 of file textord.h.

double tesseract::Textord::tosp_fuzzy_kn_fraction = 0.5

"New fuzzy kn alg"

Definition at line 350 of file textord.h.

bool tesseract::Textord::tosp_fuzzy_limit_all = true

"Dont restrict kn->sp fuzzy limit to tables"

Definition at line 289 of file textord.h.

double tesseract::Textord::tosp_fuzzy_sp_fraction = 0.5

"New fuzzy sp alg"

Definition at line 351 of file textord.h.

double tesseract::Textord::tosp_fuzzy_space_factor = 0.6

"Fract of xheight for fuzz sp"

Definition at line 327 of file textord.h.

double tesseract::Textord::tosp_fuzzy_space_factor1 = 0.5

"Fract of xheight for fuzz sp"

Definition at line 329 of file textord.h.

double tesseract::Textord::tosp_fuzzy_space_factor2 = 0.72

"Fract of xheight for fuzz sp"

Definition at line 331 of file textord.h.

double tesseract::Textord::tosp_gap_factor = 0.83

"gap ratio to flip sp->kern"

Definition at line 332 of file textord.h.

double tesseract::Textord::tosp_ignore_big_gaps = -1

"xht multiplier"

Definition at line 339 of file textord.h.

double tesseract::Textord::tosp_ignore_very_big_gaps = 3.5

"xht multiplier"

Definition at line 340 of file textord.h.

bool tesseract::Textord::tosp_improve_thresh = false

"Enable improvement heuristic"

Definition at line 301 of file textord.h.

double tesseract::Textord::tosp_init_guess_kn_mult = 2.2

"Thresh guess - mult kn by this"

Definition at line 355 of file textord.h.

double tesseract::Textord::tosp_init_guess_xht_mult = 0.28

"Thresh guess - mult xht by this"

Definition at line 357 of file textord.h.

double tesseract::Textord::tosp_kern_gap_factor1 = 2.0

"gap ratio to flip kern->sp"

Definition at line 334 of file textord.h.

double tesseract::Textord::tosp_kern_gap_factor2 = 1.3

"gap ratio to flip kern->sp"

Definition at line 336 of file textord.h.

double tesseract::Textord::tosp_kern_gap_factor3 = 2.5

"gap ratio to flip kern->sp"

Definition at line 338 of file textord.h.

double tesseract::Textord::tosp_large_kerning = 0.19

"Limit use of xht gap with large kns"

Definition at line 363 of file textord.h.

double tesseract::Textord::tosp_max_sane_kn_thresh = 5.0

"Multiplier on kn to limit thresh"

Definition at line 359 of file textord.h.

double tesseract::Textord::tosp_min_sane_kn_sp = 1.5

"Dont trust spaces less than this time kn"

Definition at line 353 of file textord.h.

double tesseract::Textord::tosp_narrow_aspect_ratio = 0.48

"narrow if w/h less than this"

Definition at line 322 of file textord.h.

bool tesseract::Textord::tosp_narrow_blobs_not_cert = true

"Only stat OBVIOUS spaces"

Definition at line 281 of file textord.h.

double tesseract::Textord::tosp_narrow_fraction = 0.3

"Fract of xheight for narrow"

Definition at line 320 of file textord.h.

double tesseract::Textord::tosp_near_lh_edge = 0

"Dont reduce box if the top left is non blank"

Definition at line 367 of file textord.h.

double tesseract::Textord::tosp_old_sp_kn_th_factor = 2.0

"Factor for defining space threshold in terms of space and " "kern sizes"

Definition at line 314 of file textord.h.

bool tesseract::Textord::tosp_old_to_bug_fix = false

"Fix suspected bug in old code"

Definition at line 275 of file textord.h.

bool tesseract::Textord::tosp_old_to_constrain_sp_kn = false

"Constrain relative values of inter and intra-word gaps for " "old_to_method."

Definition at line 266 of file textord.h.

bool tesseract::Textord::tosp_old_to_method = false

"Space stats use prechopping?"

Definition at line 263 of file textord.h.

bool tesseract::Textord::tosp_only_small_gaps_for_kern = false

"Better guess"

Definition at line 286 of file textord.h.

bool tesseract::Textord::tosp_only_use_prop_rows = true

"Block stats to use fixed pitch rows?"

Definition at line 268 of file textord.h.

bool tesseract::Textord::tosp_only_use_xht_gaps = false

"Only use within xht gap for wd breaks"

Definition at line 295 of file textord.h.

double tesseract::Textord::tosp_pass_wide_fuzz_sp_to_context = 0.75

"How wide fuzzies need context"

Definition at line 371 of file textord.h.

bool tesseract::Textord::tosp_recovery_isolated_row_stats = true

"Use row alone when inadequate cert spaces"

Definition at line 285 of file textord.h.

int tesseract::Textord::tosp_redo_kern_limit = 10

"No.samples reqd to reestimate for row"

Definition at line 306 of file textord.h.

double tesseract::Textord::tosp_rep_space = 1.6

"rep gap multiplier for space"

Definition at line 341 of file textord.h.

bool tesseract::Textord::tosp_row_use_cert_spaces = true

"Only stat OBVIOUS spaces"

Definition at line 279 of file textord.h.

bool tesseract::Textord::tosp_row_use_cert_spaces1 = true

"Only stat OBVIOUS spaces"

Definition at line 283 of file textord.h.

bool tesseract::Textord::tosp_rule_9_test_punct = false

"Dont chng kn to space next to punct"

Definition at line 297 of file textord.h.

int tesseract::Textord::tosp_sanity_method = 1

"How to avoid being silly"

Definition at line 311 of file textord.h.

int tesseract::Textord::tosp_short_row = 20

"No.gaps reqd with few cert spaces to use certs"

Definition at line 310 of file textord.h.

double tesseract::Textord::tosp_silly_kn_sp_gap = 0.2

"Dont let sp minus kn get too small"

Definition at line 369 of file textord.h.

bool tesseract::Textord::tosp_stats_use_xht_gaps = true

"Use within xht gap for wd breaks"

Definition at line 291 of file textord.h.

double tesseract::Textord::tosp_table_fuzzy_kn_sp_ratio = 3.0

"Fuzzy if less than this"

Definition at line 349 of file textord.h.

double tesseract::Textord::tosp_table_kn_sp_ratio = 2.25

"Min difference of kn & sp in table"

Definition at line 345 of file textord.h.

double tesseract::Textord::tosp_table_xht_sp_ratio = 0.33

"Expect spaces bigger than this"

Definition at line 347 of file textord.h.

double tesseract::Textord::tosp_threshold_bias1 = 0

"how far between kern and space?"

Definition at line 316 of file textord.h.

double tesseract::Textord::tosp_threshold_bias2 = 0

"how far between kern and space?"

Definition at line 318 of file textord.h.

bool tesseract::Textord::tosp_use_pre_chopping = false

"Space stats use prechopping?"

Definition at line 273 of file textord.h.

bool tesseract::Textord::tosp_use_xht_gaps = true

"Use within xht gap for wd breaks"

Definition at line 293 of file textord.h.

double tesseract::Textord::tosp_wide_aspect_ratio = 0.0

"wide if w/h less than this"

Definition at line 325 of file textord.h.

double tesseract::Textord::tosp_wide_fraction = 0.52

"Fract of xheight for wide"

Definition at line 323 of file textord.h.

The documentation for this class was generated from the following files:

textord/textord.h
textord/makerow.cpp
textord/oldbasel.cpp
textord/textord.cpp
textord/tordmain.cpp
textord/tospace.cpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation