#include "params.h"
#include "ocrblock.h"
#include "blobs.h"
#include "blobbox.h"
#include "statistc.h"

Enumerations
enum	OVERLAP_STATE { ASSIGN, REJECT, NEW_ROW }

enum	ROW_CATEGORY { ROW_ASCENDERS_FOUND, ROW_DESCENDERS_FOUND, ROW_UNKNOWN, ROW_INVALID }

Functions
void	get_min_max_xheight (int block_linesize, int min_height, int max_height)

ROW_CATEGORY	get_row_category (const TO_ROW *row)

bool	within_error_margin (float test, float num, float margin)

void	fill_heights (TO_ROW row, float gradient, int min_height, int max_height, STATS heights, STATS *floating_heights)

float	make_single_row (ICOORD page_tr, bool allow_sub_blobs, TO_BLOCK block, TO_BLOCK_LIST blocks)

float	make_rows (ICOORD page_tr, TO_BLOCK_LIST *port_blocks)

void	make_initial_textrows (ICOORD page_tr, TO_BLOCK *block, FCOORD rotation, BOOL8 testing_on)

void	fit_lms_line (TO_ROW *row)

void	compute_page_skew (TO_BLOCK_LIST *blocks, float &page_m, float &page_err)

void	vigorous_noise_removal (TO_BLOCK *block)

void	cleanup_rows_making (ICOORD page_tr, TO_BLOCK *block, float gradient, FCOORD rotation, inT32 block_edge, BOOL8 testing_on)

void	delete_non_dropout_rows (TO_BLOCK *block, float gradient, FCOORD rotation, inT32 block_edge, BOOL8 testing_on)

BOOL8	find_best_dropout_row (TO_ROW row, inT32 distance, float dist_limit, inT32 line_index, TO_ROW_IT row_it, BOOL8 testing_on)

TBOX	deskew_block_coords (TO_BLOCK *block, float gradient)

void	compute_line_occupation (TO_BLOCK block, float gradient, inT32 min_y, inT32 max_y, inT32 occupation, inT32 *deltas)

void	compute_occupation_threshold (inT32 low_window, inT32 high_window, inT32 line_count, inT32 occupation, inT32 thresholds)

void	compute_dropout_distances (inT32 occupation, inT32 thresholds, inT32 line_count)

void	expand_rows (ICOORD page_tr, TO_BLOCK *block, float gradient, FCOORD rotation, inT32 block_edge, BOOL8 testing_on)

void	adjust_row_limits (TO_BLOCK *block)

void	compute_row_stats (TO_BLOCK *block, BOOL8 testing_on)

float	median_block_xheight (TO_BLOCK *block, float gradient)

int	compute_xheight_from_modes (STATS heights, STATS floating_heights, bool cap_only, int min_height, int max_height, float xheight, float ascrise)

inT32	compute_row_descdrop (TO_ROW row, float gradient, int xheight_blob_count, STATS heights)

inT32	compute_height_modes (STATS heights, inT32 min_height, inT32 max_height, inT32 modes, inT32 maxmodes)

void	correct_row_xheight (TO_ROW *row, float xheight, float ascrise, float descdrop)

void	separate_underlines (TO_BLOCK *block, float gradient, FCOORD rotation, BOOL8 testing_on)

void	pre_associate_blobs (ICOORD page_tr, TO_BLOCK *block, FCOORD rotation, BOOL8 testing_on)

void	fit_parallel_rows (TO_BLOCK *block, float gradient, FCOORD rotation, inT32 block_edge, BOOL8 testing_on)

void	fit_parallel_lms (float gradient, TO_ROW *row)

void	make_baseline_spline (TO_ROW row, TO_BLOCK block)

BOOL8	segment_baseline (TO_ROW row, TO_BLOCK block, inT32 &segments, inT32 xstarts[])

double *	linear_spline_baseline (TO_ROW row, TO_BLOCK block, inT32 &segments, inT32 xstarts[])

void	assign_blobs_to_rows (TO_BLOCK block, float gradient, int pass, BOOL8 reject_misses, BOOL8 make_new_rows, BOOL8 drawing_skew)

OVERLAP_STATE	most_overlapping_row (TO_ROW_IT row_it, TO_ROW &best_row, float top, float bottom, float rowsize, BOOL8 testing_blob)

int	blob_x_order (const void item1, const void item2)

int	row_y_order (const void item1, const void item2)

int	row_spacing_order (const void item1, const void item2)

void	mark_repeated_chars (TO_ROW *row)

Variables
bool	textord_heavy_nr = FALSE

bool	textord_show_initial_rows = FALSE

bool	textord_show_parallel_rows = FALSE

bool	textord_show_expanded_rows = FALSE

bool	textord_show_final_rows = FALSE

bool	textord_show_final_blobs = FALSE

bool	textord_test_landscape = FALSE

bool	textord_parallel_baselines = TRUE

bool	textord_straight_baselines = FALSE

bool	textord_quadratic_baselines = FALSE

bool	textord_old_baselines = TRUE

bool	textord_old_xheight = TRUE

bool	textord_fix_xheight_bug = TRUE

bool	textord_fix_makerow_bug = TRUE

bool	textord_cblob_blockocc = TRUE

bool	textord_debug_xheights = FALSE

int	textord_test_x = -MAX_INT32

int	textord_test_y = -MAX_INT32

int	textord_min_blobs_in_row = 4

int	textord_spline_minblobs = 8

int	textord_spline_medianwin = 6

int	textord_min_xheight = 10

double	textord_spline_shift_fraction = 0.02

double	textord_spline_outlier_fraction = 0.1

double	textord_skew_ile = 0.5

double	textord_skew_lag = 0.75

double	textord_linespace_iqrlimit = 0.2

double	textord_width_limit = 8

double	textord_chop_width = 1.5

double	textord_minxh = 0.25

double	textord_min_linesize = 1.25

double	textord_excess_blobsize = 1.3

double	textord_occupancy_threshold = 0.4

double	textord_underline_width = 2.0

double	textord_min_blob_height_fraction = 0.75

double	textord_xheight_mode_fraction = 0.4

double	textord_ascheight_mode_fraction = 0.15

double	textord_ascx_ratio_min = 1.2

double	textord_ascx_ratio_max = 1.7

double	textord_descx_ratio_min = 0.15

double	textord_descx_ratio_max = 0.6

double	textord_xheight_error_margin = 0.1

int	textord_lms_line_trials = 12

bool	textord_new_initial_xheight = TRUE

bool	textord_debug_blob = FALSE

Enumeration Type Documentation

enum OVERLAP_STATE

Enumerator
ASSIGN
REJECT
NEW_ROW

Definition at line 29 of file makerow.h.

 {
   ASSIGN,                        //assign it to row
   REJECT,                        //reject it - dual overlap
   NEW_ROW
 };

enum ROW_CATEGORY

Enumerator
ROW_ASCENDERS_FOUND
ROW_DESCENDERS_FOUND
ROW_UNKNOWN
ROW_INVALID

Definition at line 36 of file makerow.h.

                   {
   ROW_ASCENDERS_FOUND,
   ROW_DESCENDERS_FOUND,
   ROW_UNKNOWN,
   ROW_INVALID,
 };

Function Documentation

void adjust_row_limits ( TO_BLOCK * block )

adjust_row_limits

Change the limits of rows to suit the default fractions.

Definition at line 1133 of file makerow.cpp.

                         {
   TO_ROW *row;                   //current row
   float size;                    //size of row
   float ymax;                    //top of row
   float ymin;                    //bottom of row
   TO_ROW_IT row_it = block->get_rows ();
 
   if (textord_show_expanded_rows)
     tprintf("Adjusting row limits for block(%d,%d)\n",
             block->block->bounding_box().left(),
             block->block->bounding_box().top());
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
     row = row_it.data ();
     size = row->max_y () - row->min_y ();
     if (textord_show_expanded_rows)
       tprintf("Row at %f has min %f, max %f, size %f\n",
               row->intercept(), row->min_y(), row->max_y(), size);
     size /= tesseract::CCStruct::kXHeightFraction +
         tesseract::CCStruct::kAscenderFraction +
         tesseract::CCStruct::kDescenderFraction;
     ymax = size * (tesseract::CCStruct::kXHeightFraction +
                    tesseract::CCStruct::kAscenderFraction);
     ymin = -size * tesseract::CCStruct::kDescenderFraction;
     row->set_limits (row->intercept () + ymin, row->intercept () + ymax);
     row->merged = FALSE;
   }
 }

void assign_blobs_to_rows	(	TO_BLOCK *	block,
		float *	gradient,
		int	pass,
		BOOL8	reject_misses,
		BOOL8	make_new_rows,
		BOOL8	drawing_skew
	)

Definition at line 2309 of file makerow.cpp.

                            {
   OVERLAP_STATE overlap_result;  //what to do with it
   float ycoord;                  //current y
   float top, bottom;             //of blob
   float g_length = 1.0f;         //from gradient
   inT16 row_count;               //no of rows
   inT16 left_x;                  //left edge
   inT16 last_x;                  //previous edge
   float block_skew;              //y delta
   float smooth_factor;           //for new coords
   float near_dist;               //dist to nearest row
   ICOORD testpt;                 //testing only
   BLOBNBOX *blob;                //current blob
   TO_ROW *row;                   //current row
   TO_ROW *dest_row = NULL;       //row to put blob in
                                  //iterators
   BLOBNBOX_IT blob_it = &block->blobs;
   TO_ROW_IT row_it = block->get_rows ();
 
   ycoord =
     (block->block->bounding_box ().bottom () +
     block->block->bounding_box ().top ()) / 2.0f;
   if (gradient != NULL)
     g_length = sqrt (1 + *gradient * *gradient);
 #ifndef GRAPHICS_DISABLED
   if (drawing_skew)
     to_win->SetCursor(block->block->bounding_box ().left (), ycoord);
 #endif
   testpt = ICOORD (textord_test_x, textord_test_y);
   blob_it.sort (blob_x_order);
   smooth_factor = 1.0;
   block_skew = 0.0f;
   row_count = row_it.length ();  //might have rows
   if (!blob_it.empty ()) {
     left_x = blob_it.data ()->bounding_box ().left ();
   }
   else {
     left_x = block->block->bounding_box ().left ();
   }
   last_x = left_x;
   for (blob_it.mark_cycle_pt (); !blob_it.cycled_list (); blob_it.forward ()) {
     blob = blob_it.data ();
     if (gradient != NULL) {
       block_skew = (1 - 1 / g_length) * blob->bounding_box ().bottom ()
         + *gradient / g_length * blob->bounding_box ().left ();
     }
     else if (blob->bounding_box ().left () - last_x > block->line_size / 2
       && last_x - left_x > block->line_size * 2
     && textord_interpolating_skew) {
       //                      tprintf("Interpolating skew from %g",block_skew);
       block_skew *= (float) (blob->bounding_box ().left () - left_x)
         / (last_x - left_x);
       //                      tprintf("to %g\n",block_skew);
     }
     last_x = blob->bounding_box ().left ();
     top = blob->bounding_box ().top () - block_skew;
     bottom = blob->bounding_box ().bottom () - block_skew;
 #ifndef GRAPHICS_DISABLED
     if (drawing_skew)
       to_win->DrawTo(blob->bounding_box ().left (), ycoord + block_skew);
 #endif
     if (!row_it.empty ()) {
       for (row_it.move_to_first ();
         !row_it.at_last () && row_it.data ()->min_y () > top;
         row_it.forward ());
       row = row_it.data ();
       if (row->min_y () <= top && row->max_y () >= bottom) {
       //any overlap
         dest_row = row;
         overlap_result = most_overlapping_row (&row_it, dest_row,
           top, bottom,
           block->line_size,
           blob->bounding_box ().
           contains (testpt));
         if (overlap_result == NEW_ROW && !reject_misses)
           overlap_result = ASSIGN;
       }
       else {
         overlap_result = NEW_ROW;
         if (!make_new_rows) {
           near_dist = row_it.data_relative (-1)->min_y () - top;
                                  //below bottom
           if (bottom < row->min_y ()) {
             if (row->min_y () - bottom <=
               (block->line_spacing -
             block->line_size) * tesseract::CCStruct::kDescenderFraction) {
                                  //done it
               overlap_result = ASSIGN;
               dest_row = row;
             }
           }
           else if (near_dist > 0
           && near_dist < bottom - row->max_y ()) {
             row_it.backward ();
             dest_row = row_it.data ();
             if (dest_row->min_y () - bottom <=
               (block->line_spacing -
             block->line_size) * tesseract::CCStruct::kDescenderFraction) {
                                  //done it
               overlap_result = ASSIGN;
             }
           }
           else {
             if (top - row->max_y () <=
               (block->line_spacing -
               block->line_size) * (textord_overlap_x +
             tesseract::CCStruct::kAscenderFraction)) {
                                  //done it
               overlap_result = ASSIGN;
               dest_row = row;
             }
           }
         }
       }
       if (overlap_result == ASSIGN)
         dest_row->add_blob (blob_it.extract (), top, bottom,
           block->line_size);
       if (overlap_result == NEW_ROW) {
         if (make_new_rows && top - bottom < block->max_blob_size) {
           dest_row =
             new TO_ROW (blob_it.extract (), top, bottom,
             block->line_size);
           row_count++;
           if (bottom > row_it.data ()->min_y ())
             row_it.add_before_then_move (dest_row);
           //insert in right place
           else
             row_it.add_after_then_move (dest_row);
           smooth_factor =
             1.0 / (row_count * textord_skew_lag +
             textord_skewsmooth_offset);
         }
         else
           overlap_result = REJECT;
       }
     }
     else if (make_new_rows && top - bottom < block->max_blob_size) {
       overlap_result = NEW_ROW;
       dest_row =
         new TO_ROW(blob_it.extract(), top, bottom, block->line_size);
       row_count++;
       row_it.add_after_then_move(dest_row);
       smooth_factor = 1.0 / (row_count * textord_skew_lag +
                              textord_skewsmooth_offset2);
     }
     else
       overlap_result = REJECT;
     if (blob->bounding_box ().contains(testpt) && textord_debug_blob) {
       if (overlap_result != REJECT) {
         tprintf("Test blob assigned to row at (%g,%g) on pass %d\n",
           dest_row->min_y(), dest_row->max_y(), pass);
       }
       else {
         tprintf("Test blob assigned to no row on pass %d\n", pass);
       }
     }
     if (overlap_result != REJECT) {
       while (!row_it.at_first() &&
              row_it.data()->min_y() > row_it.data_relative(-1)->min_y()) {
         row = row_it.extract();
         row_it.backward();
         row_it.add_before_then_move(row);
       }
       while (!row_it.at_last() &&
              row_it.data ()->min_y() < row_it.data_relative (1)->min_y()) {
         row = row_it.extract();
         row_it.forward();
                                  // Keep rows in order.
         row_it.add_after_then_move(row);
       }
       BLOBNBOX_IT added_blob_it(dest_row->blob_list());
       added_blob_it.move_to_last();
       TBOX prev_box = added_blob_it.data_relative(-1)->bounding_box();
       if (dest_row->blob_list()->singleton() ||
           !prev_box.major_x_overlap(blob->bounding_box())) {
         block_skew = (1 - smooth_factor) * block_skew
             + smooth_factor * (blob->bounding_box().bottom() -
             dest_row->initial_min_y());
       }
     }
   }
   for (row_it.mark_cycle_pt(); !row_it.cycled_list(); row_it.forward()) {
     if (row_it.data()->blob_list()->empty())
       delete row_it.extract();  // Discard empty rows.
   }
 }

int blob_x_order	(	const void *	item1,
		const void *	item2
	)

Definition at line 2604 of file makerow.cpp.

                                     {
                                  //converted ptr
   BLOBNBOX *blob1 = *(BLOBNBOX **) item1;
                                  //converted ptr
   BLOBNBOX *blob2 = *(BLOBNBOX **) item2;
 
   if (blob1->bounding_box ().left () < blob2->bounding_box ().left ())
     return -1;
   else if (blob1->bounding_box ().left () > blob2->bounding_box ().left ())
     return 1;
   else
     return 0;
 }

void cleanup_rows_making	(	ICOORD	page_tr,
		TO_BLOCK *	block,
		float	gradient,
		FCOORD	rotation,
		inT32	block_edge,
		BOOL8	testing_on
	)

cleanup_rows_making

Remove overlapping rows and fit all the blobs to what's left.

Definition at line 524 of file makerow.cpp.

                    {
                                  //iterators
   BLOBNBOX_IT blob_it = &block->blobs;
   TO_ROW_IT row_it = block->get_rows ();
 
 #ifndef GRAPHICS_DISABLED
   if (textord_show_parallel_rows && testing_on) {
     if (to_win == NULL)
       create_to_win(page_tr);
   }
 #endif
                                  //get row coords
   fit_parallel_rows(block,
                     gradient,
                     rotation,
                     block_edge,
                     textord_show_parallel_rows &&testing_on);
   delete_non_dropout_rows(block,
                           gradient,
                           rotation,
                           block_edge,
                           textord_show_parallel_rows &&testing_on);
   expand_rows(page_tr, block, gradient, rotation, block_edge, testing_on);
   blob_it.set_to_list (&block->blobs);
   row_it.set_to_list (block->get_rows ());
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ())
     blob_it.add_list_after (row_it.data ()->blob_list ());
   //give blobs back
   assign_blobs_to_rows (block, &gradient, 1, FALSE, FALSE, FALSE);
   //now new rows must be genuine
   blob_it.set_to_list (&block->blobs);
   blob_it.add_list_after (&block->large_blobs);
   assign_blobs_to_rows (block, &gradient, 2, TRUE, TRUE, FALSE);
   //safe to use big ones now
   blob_it.set_to_list (&block->blobs);
                                  //throw all blobs in
   blob_it.add_list_after (&block->noise_blobs);
   blob_it.add_list_after (&block->small_blobs);
   assign_blobs_to_rows (block, &gradient, 3, FALSE, FALSE, FALSE);
 }

void compute_dropout_distances	(	inT32 *	occupation,
		inT32 *	thresholds,
		inT32	line_count
	)

Definition at line 928 of file makerow.cpp.

                                 {
   inT32 line_index;              //of thresholds line
   inT32 distance;                //from prev dropout
   inT32 next_dist;               //to next dropout
   inT32 back_index;              //for back filling
   inT32 prev_threshold;          //before overwrite
 
   distance = -line_count;
   line_index = 0;
   do {
     do {
       distance--;
       prev_threshold = thresholds[line_index];
                                  //distance from prev
       thresholds[line_index] = distance;
       line_index++;
     }
     while (line_index < line_count
       && (occupation[line_index] < thresholds[line_index]
       || occupation[line_index - 1] >= prev_threshold));
     if (line_index < line_count) {
       back_index = line_index - 1;
       next_dist = 1;
       while (next_dist < -distance && back_index >= 0) {
         thresholds[back_index] = next_dist;
         back_index--;
         next_dist++;
         distance++;
       }
       distance = 1;
     }
   }
   while (line_index < line_count);
 }

inT32 compute_height_modes	(	STATS *	heights,
		inT32	min_height,
		inT32	max_height,
		inT32 *	modes,
		inT32	maxmodes
	)

Definition at line 1653 of file makerow.cpp.

                                            {  // size of modes
   inT32 pile_count;              // no in source pile
   inT32 src_count;               // no of source entries
   inT32 src_index;               // current entry
   inT32 least_count;             // height of smalllest
   inT32 least_index;             // index of least
   inT32 dest_count;              // index in modes
 
   src_count = max_height + 1 - min_height;
   dest_count = 0;
   least_count = MAX_INT32;
   least_index = -1;
   for (src_index = 0; src_index < src_count; src_index++) {
     pile_count = heights->pile_count(min_height + src_index);
     if (pile_count > 0) {
       if (dest_count < maxmodes) {
         if (pile_count < least_count) {
           // find smallest in array
           least_count = pile_count;
           least_index = dest_count;
         }
         modes[dest_count++] = min_height + src_index;
       } else if (pile_count >= least_count) {
         while (least_index < maxmodes - 1) {
           modes[least_index] = modes[least_index + 1];
           // shuffle up
           least_index++;
         }
         // new one on end
         modes[maxmodes - 1] = min_height + src_index;
         if (pile_count == least_count) {
           // new smallest
           least_index = maxmodes - 1;
         } else {
           least_count = heights->pile_count(modes[0]);
           least_index = 0;
           for (dest_count = 1; dest_count < maxmodes; dest_count++) {
             pile_count = heights->pile_count(modes[dest_count]);
             if (pile_count < least_count) {
               // find smallest
               least_count = pile_count;
               least_index = dest_count;
             }
           }
         }
       }
     }
   }
   return dest_count;
 }

void compute_line_occupation	(	TO_BLOCK *	block,
		float	gradient,
		inT32	min_y,
		inT32	max_y,
		inT32 *	occupation,
		inT32 *	deltas
	)

Definition at line 781 of file makerow.cpp.

                               {
   inT32 line_count;              //maxy-miny+1
   inT32 line_index;              //of scan line
   int index;                     //array index for daft compilers
   float top, bottom;             //coords of blob
   inT32 width;                   //of blob
   TO_ROW *row;                   //current row
   TO_ROW_IT row_it = block->get_rows ();
   BLOBNBOX *blob;                //current blob
   BLOBNBOX_IT blob_it;           //iterator
   float length;                  //of skew vector
   TBOX blob_box;                  //bounding box
   FCOORD rotation;               //inverse of skew
 
   line_count = max_y - min_y + 1;
   length = sqrt (gradient * gradient + 1);
   rotation = FCOORD (1 / length, -gradient / length);
   for (line_index = 0; line_index < line_count; line_index++)
     deltas[line_index] = 0;
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
     row = row_it.data ();
     blob_it.set_to_list (row->blob_list ());
     for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
     blob_it.forward ()) {
       blob = blob_it.data ();
       blob_box = blob->bounding_box ();
       blob_box.rotate (rotation);//de-skew it
       top = blob_box.top ();
       bottom = blob_box.bottom ();
       width =
         (inT32) floor ((FLOAT32) (blob_box.right () - blob_box.left ()));
       if ((inT32) floor (bottom) < min_y
         || (inT32) floor (bottom) - min_y >= line_count)
         fprintf (stderr,
           "Bad y coord of bottom, " INT32FORMAT "(" INT32FORMAT ","
           INT32FORMAT ")\n", (inT32) floor (bottom), min_y, max_y);
                                  //count transitions
       index = (inT32) floor (bottom) - min_y;
       deltas[index] += width;
       if ((inT32) floor (top) < min_y
         || (inT32) floor (top) - min_y >= line_count)
         fprintf (stderr,
           "Bad y coord of top, " INT32FORMAT "(" INT32FORMAT ","
           INT32FORMAT ")\n", (inT32) floor (top), min_y, max_y);
       index = (inT32) floor (top) - min_y;
       deltas[index] -= width;
     }
   }
   occupation[0] = deltas[0];
   for (line_index = 1; line_index < line_count; line_index++)
     occupation[line_index] = occupation[line_index - 1] + deltas[line_index];
 }

void compute_occupation_threshold	(	inT32	low_window,
		inT32	high_window,
		inT32	line_count,
		inT32 *	occupation,
		inT32 *	thresholds
	)

compute_occupation_threshold

Compute thresholds for textline or not for the occupation array.

Definition at line 847 of file makerow.cpp.

                                    {
   inT32 line_index;              //of thresholds line
   inT32 low_index;               //in occupation
   inT32 high_index;              //in occupation
   inT32 sum;                     //current average
   inT32 divisor;                 //to get thresholds
   inT32 min_index;               //of min occ
   inT32 min_occ;                 //min in locality
   inT32 test_index;              //for finding min
 
   divisor =
     (inT32) ceil ((low_window + high_window) / textord_occupancy_threshold);
   if (low_window + high_window < line_count) {
     for (sum = 0, high_index = 0; high_index < low_window; high_index++)
       sum += occupation[high_index];
     for (low_index = 0; low_index < high_window; low_index++, high_index++)
       sum += occupation[high_index];
     min_occ = occupation[0];
     min_index = 0;
     for (test_index = 1; test_index < high_index; test_index++) {
       if (occupation[test_index] <= min_occ) {
         min_occ = occupation[test_index];
         min_index = test_index;  //find min in region
       }
     }
     for (line_index = 0; line_index < low_window; line_index++)
       thresholds[line_index] = (sum - min_occ) / divisor + min_occ;
     //same out to end
     for (low_index = 0; high_index < line_count; low_index++, high_index++) {
       sum -= occupation[low_index];
       sum += occupation[high_index];
       if (occupation[high_index] <= min_occ) {
                                  //find min in region
         min_occ = occupation[high_index];
         min_index = high_index;
       }
                                  //lost min from region
       if (min_index <= low_index) {
         min_occ = occupation[low_index + 1];
         min_index = low_index + 1;
         for (test_index = low_index + 2; test_index <= high_index;
         test_index++) {
           if (occupation[test_index] <= min_occ) {
             min_occ = occupation[test_index];
                                  //find min in region
             min_index = test_index;
           }
         }
       }
       thresholds[line_index++] = (sum - min_occ) / divisor + min_occ;
     }
   }
   else {
     min_occ = occupation[0];
     min_index = 0;
     for (sum = 0, low_index = 0; low_index < line_count; low_index++) {
       if (occupation[low_index] < min_occ) {
         min_occ = occupation[low_index];
         min_index = low_index;
       }
       sum += occupation[low_index];
     }
     line_index = 0;
   }
   for (; line_index < line_count; line_index++)
     thresholds[line_index] = (sum - min_occ) / divisor + min_occ;
   //same out to end
 }

void compute_page_skew	(	TO_BLOCK_LIST *	blocks,
		float &	page_m,
		float &	page_err
	)

Definition at line 287 of file makerow.cpp.

                         {
   inT32 row_count;               //total rows
   inT32 blob_count;              //total_blobs
   inT32 row_err;                 //integer error
   float *gradients;              //of rows
   float *errors;                 //of rows
   inT32 row_index;               //of total
   TO_ROW *row;                   //current row
   TO_BLOCK_IT block_it = blocks; //iterator
   TO_ROW_IT row_it;
 
   row_count = 0;
   blob_count = 0;
   for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
        block_it.forward ()) {
     POLY_BLOCK* pb = block_it.data()->block->poly_block();
     if (pb != NULL && !pb->IsText())
       continue;  // Pretend non-text blocks don't exist.
     row_count += block_it.data ()->get_rows ()->length ();
     //count up rows
     row_it.set_to_list (block_it.data ()->get_rows ());
     for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ())
       blob_count += row_it.data ()->blob_list ()->length ();
   }
   if (row_count == 0) {
     page_m = 0.0f;
     page_err = 0.0f;
     return;
   }
   gradients = (float *) alloc_mem (blob_count * sizeof (float));
   //get mem
   errors = (float *) alloc_mem (blob_count * sizeof (float));
   if (gradients == NULL || errors == NULL)
     MEMORY_OUT.error ("compute_page_skew", ABORT, NULL);
 
   row_index = 0;
   for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
        block_it.forward ()) {
     POLY_BLOCK* pb = block_it.data()->block->poly_block();
     if (pb != NULL && !pb->IsText())
       continue;  // Pretend non-text blocks don't exist.
     row_it.set_to_list (block_it.data ()->get_rows ());
     for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
       row = row_it.data ();
       blob_count = row->blob_list ()->length ();
       row_err = (inT32) ceil (row->line_error ());
       if (row_err <= 0)
         row_err = 1;
       if (textord_biased_skewcalc) {
         blob_count /= row_err;
         for (blob_count /= row_err; blob_count > 0; blob_count--) {
           gradients[row_index] = row->line_m ();
           errors[row_index] = row->line_error ();
           row_index++;
         }
       }
       else if (blob_count >= textord_min_blobs_in_row) {
                                  //get gradient
         gradients[row_index] = row->line_m ();
         errors[row_index] = row->line_error ();
         row_index++;
       }
     }
   }
   if (row_index == 0) {
                                  //desperate
     for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
          block_it.forward ()) {
       POLY_BLOCK* pb = block_it.data()->block->poly_block();
       if (pb != NULL && !pb->IsText())
         continue;  // Pretend non-text blocks don't exist.
       row_it.set_to_list (block_it.data ()->get_rows ());
       for (row_it.mark_cycle_pt (); !row_it.cycled_list ();
            row_it.forward ()) {
         row = row_it.data ();
         gradients[row_index] = row->line_m ();
         errors[row_index] = row->line_error ();
         row_index++;
       }
     }
   }
   row_count = row_index;
   row_index = choose_nth_item ((inT32) (row_count * textord_skew_ile),
     gradients, row_count);
   page_m = gradients[row_index];
   row_index = choose_nth_item ((inT32) (row_count * textord_skew_ile),
     errors, row_count);
   page_err = errors[row_index];
   free_mem(gradients);
   free_mem(errors);
 }

inT32 compute_row_descdrop	(	TO_ROW *	row,
		float	gradient,
		int	xheight_blob_count,
		STATS *	heights
	)

Definition at line 1593 of file makerow.cpp.

                                                                        {
   // Count how many potential ascenders are in this row.
   int i_min = asc_heights->min_bucket();
   if ((i_min / row->xheight) < textord_ascx_ratio_min) {
     i_min = static_cast<int>(
         floor(row->xheight * textord_ascx_ratio_min + 0.5));
   }
   int i_max = asc_heights->max_bucket();
   if ((i_max / row->xheight) > textord_ascx_ratio_max) {
     i_max = static_cast<int>(floor(row->xheight * textord_ascx_ratio_max));
   }
   int num_potential_asc = 0;
   for (int i = i_min; i <= i_max; ++i) {
     num_potential_asc += asc_heights->pile_count(i);
   }
   inT32 min_height =
     static_cast<inT32>(floor(row->xheight * textord_descx_ratio_min + 0.5));
   inT32 max_height =
     static_cast<inT32>(floor(row->xheight * textord_descx_ratio_max));
   float xcentre;                 // centre of blob
   float height;                  // height of blob
   BLOBNBOX_IT blob_it = row->blob_list();
   BLOBNBOX *blob;                // current blob
   STATS heights (min_height, max_height + 1);
   for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) {
     blob = blob_it.data();
     if (!blob->joined_to_prev()) {
       xcentre = (blob->bounding_box().left() +
                  blob->bounding_box().right()) / 2.0f;
       height = (gradient * xcentre + row->parallel_c() -
                 blob->bounding_box().bottom());
       if (height >= min_height && height <= max_height)
         heights.add(static_cast<int>(floor(height + 0.5)), 1);
     }
   }
   int blob_index = heights.mode();  // find mode
   int blob_count = heights.pile_count(blob_index);  // get count of mode
   float total_fraction =
     (textord_descheight_mode_fraction + textord_ascheight_mode_fraction);
   if (static_cast<float>(blob_count + num_potential_asc) <
       xheight_blob_count * total_fraction) {
     blob_count = 0;
   }
   int descdrop = blob_count > 0 ? -blob_index : 0;
   if (textord_debug_xheights) {
     tprintf("Descdrop: %d (potential ascenders %d, descenders %d)\n",
             descdrop, num_potential_asc, blob_count);
     heights.print();
   }
   return descdrop;
 }

void compute_row_stats	(	TO_BLOCK *	block,
		BOOL8	testing_on
	)

Definition at line 1169 of file makerow.cpp.

                         {
   inT32 row_index;               //of median
   TO_ROW *row;                   //current row
   TO_ROW *prev_row;              //previous row
   float iqr;                     //inter quartile range
   TO_ROW_IT row_it = block->get_rows ();
                                  //number of rows
   inT16 rowcount = row_it.length ();
   TO_ROW **rows;                 //for choose nth
 
   rows = (TO_ROW **) alloc_mem (rowcount * sizeof (TO_ROW *));
   if (rows == NULL)
     MEMORY_OUT.error ("compute_row_stats", ABORT, NULL);
   rowcount = 0;
   prev_row = NULL;
   row_it.move_to_last ();        //start at bottom
   do {
     row = row_it.data ();
     if (prev_row != NULL) {
       rows[rowcount++] = prev_row;
       prev_row->spacing = row->intercept () - prev_row->intercept ();
       if (testing_on)
         tprintf ("Row at %g yields spacing of %g\n",
           row->intercept (), prev_row->spacing);
     }
     prev_row = row;
     row_it.backward ();
   }
   while (!row_it.at_last ());
   block->key_row = prev_row;
   block->baseline_offset =
     fmod (prev_row->parallel_c (), block->line_spacing);
   if (testing_on)
     tprintf ("Blob based spacing=(%g,%g), offset=%g",
       block->line_size, block->line_spacing, block->baseline_offset);
   if (rowcount > 0) {
     row_index = choose_nth_item (rowcount * 3 / 4, rows, rowcount,
       sizeof (TO_ROW *), row_spacing_order);
     iqr = rows[row_index]->spacing;
     row_index = choose_nth_item (rowcount / 4, rows, rowcount,
       sizeof (TO_ROW *), row_spacing_order);
     iqr -= rows[row_index]->spacing;
     row_index = choose_nth_item (rowcount / 2, rows, rowcount,
       sizeof (TO_ROW *), row_spacing_order);
     block->key_row = rows[row_index];
     if (testing_on)
       tprintf (" row based=%g(%g)", rows[row_index]->spacing, iqr);
     if (rowcount > 2
     && iqr < rows[row_index]->spacing * textord_linespace_iqrlimit) {
       if (!textord_new_initial_xheight) {
         if (rows[row_index]->spacing < block->line_spacing
           && rows[row_index]->spacing > block->line_size)
           //within range
           block->line_size = rows[row_index]->spacing;
         //spacing=size
         else if (rows[row_index]->spacing > block->line_spacing)
           block->line_size = block->line_spacing;
         //too big so use max
       }
       else {
         if (rows[row_index]->spacing < block->line_spacing)
           block->line_size = rows[row_index]->spacing;
         else
           block->line_size = block->line_spacing;
         //too big so use max
       }
       if (block->line_size < textord_min_xheight)
         block->line_size = (float) textord_min_xheight;
       block->line_spacing = rows[row_index]->spacing;
       block->max_blob_size =
         block->line_spacing * textord_excess_blobsize;
     }
     block->baseline_offset = fmod (rows[row_index]->intercept (),
       block->line_spacing);
   }
   if (testing_on)
     tprintf ("\nEstimate line size=%g, spacing=%g, offset=%g\n",
       block->line_size, block->line_spacing, block->baseline_offset);
   free_mem(rows);
 }

int compute_xheight_from_modes	(	STATS *	heights,
		STATS *	floating_heights,
		bool	cap_only,
		int	min_height,
		int	max_height,
		float *	xheight,
		float *	ascrise
	)

Definition at line 1497 of file makerow.cpp.

                                                     {
   int blob_index = heights->mode();  // find mode
   int blob_count = heights->pile_count(blob_index);  // get count of mode
   if (textord_debug_xheights) {
     tprintf("min_height=%d, max_height=%d, mode=%d, count=%d, total=%d\n",
             min_height, max_height, blob_index, blob_count,
             heights->get_total());
     heights->print();
     floating_heights->print();
   }
   if (blob_count == 0) return 0;
   int modes[MAX_HEIGHT_MODES];  // biggest piles
   bool in_best_pile = FALSE;
   int prev_size = -MAX_INT32;
   int best_count = 0;
   int mode_count = compute_height_modes(heights, min_height, max_height,
                                         modes, MAX_HEIGHT_MODES);
   if (cap_only && mode_count > 1)
     mode_count = 1;
   int x;
   if (textord_debug_xheights) {
     tprintf("found %d modes: ", mode_count);
     for (x = 0; x < mode_count; x++) tprintf("%d ", modes[x]);
     tprintf("\n");
   }
 
   for (x = 0; x < mode_count - 1; x++) {
     if (modes[x] != prev_size + 1)
       in_best_pile = FALSE;    // had empty height
     int modes_x_count = heights->pile_count(modes[x]) -
       floating_heights->pile_count(modes[x]);
     if ((modes_x_count >= blob_count * textord_xheight_mode_fraction) &&
         (in_best_pile || modes_x_count > best_count)) {
       for (int asc = x + 1; asc < mode_count; asc++) {
         float ratio =
           static_cast<float>(modes[asc]) / static_cast<float>(modes[x]);
         if (textord_ascx_ratio_min < ratio &&
             ratio < textord_ascx_ratio_max &&
             (heights->pile_count(modes[asc]) >=
              blob_count * textord_ascheight_mode_fraction)) {
           if (modes_x_count > best_count) {
             in_best_pile = true;
             best_count = modes_x_count;
           }
           if (textord_debug_xheights) {
             tprintf("X=%d, asc=%d, count=%d, ratio=%g\n",
                     modes[x], modes[asc]-modes[x], modes_x_count, ratio);
           }
           prev_size = modes[x];
           *xheight = static_cast<float>(modes[x]);
           *ascrise = static_cast<float>(modes[asc] - modes[x]);
         }
       }
     }
   }
   if (*xheight == 0) {  // single mode
     // Remove counts of the "floating" blobs (the one whose height is too
     // small in relation to it's top end of the bounding box) from heights
     // before computing the single-mode xheight.
     // Restore the counts in heights after the mode is found, since
     // floating blobs might be useful for determining potential ascenders
     // in compute_row_descdrop().
     if (floating_heights->get_total() > 0) {
       for (x = min_height; x < max_height; ++x) {
         heights->add(x, -(floating_heights->pile_count(x)));
       }
       blob_index = heights->mode();  // find the modified mode
       for (x = min_height; x < max_height; ++x) {
         heights->add(x, floating_heights->pile_count(x));
       }
     }
     *xheight = static_cast<float>(blob_index);
     *ascrise = 0.0f;
     best_count = heights->pile_count(blob_index);
     if (textord_debug_xheights)
       tprintf("Single mode xheight set to %g\n", *xheight);
   } else if (textord_debug_xheights) {
     tprintf("Multi-mode xheight set to %g, asc=%g\n", *xheight, *ascrise);
   }
   return best_count;
 }

void correct_row_xheight	(	TO_ROW *	row,
		float	xheight,
		float	ascrise,
		float	descdrop
	)

Definition at line 1715 of file makerow.cpp.

                                                         {
   ROW_CATEGORY row_category = get_row_category(row);
   if (textord_debug_xheights) {
     tprintf("correcting row xheight: row->xheight %.4f"
             ", row->acrise %.4f row->descdrop %.4f\n",
             row->xheight, row->ascrise, row->descdrop);
   }
   bool normal_xheight =
     within_error_margin(row->xheight, xheight, textord_xheight_error_margin);
   bool cap_xheight =
     within_error_margin(row->xheight, xheight + ascrise,
                         textord_xheight_error_margin);
   // Use the average xheight/ascrise for the following cases:
   // -- the xheight of the row could not be determined at all
   // -- the row has descenders (e.g. "many groups", "ISBN 12345 p.3")
   //    and its xheight is close to either cap height or average xheight
   // -- the row does not have ascenders or descenders, but its xheight
   //    is close to the average block xheight (e.g. row with "www.mmm.com")
   if (row_category == ROW_ASCENDERS_FOUND) {
     if (row->descdrop >= 0.0) {
       row->descdrop = row->xheight * (descdrop / xheight);
     }
   } else if (row_category == ROW_INVALID ||
              (row_category == ROW_DESCENDERS_FOUND &&
               (normal_xheight || cap_xheight)) ||
               (row_category == ROW_UNKNOWN && normal_xheight)) {
     if (textord_debug_xheights) tprintf("using average xheight\n");
     row->xheight = xheight;
     row->ascrise = ascrise;
     row->descdrop = descdrop;
   } else if (row_category == ROW_DESCENDERS_FOUND) {
     // Assume this is a row with mostly lowercase letters and it's xheight
     // is computed correctly (unfortunately there is no way to distinguish
     // this from the case when descenders are found, but the most common
     // height is capheight).
     if (textord_debug_xheights) tprintf("lowercase, corrected ascrise\n");
     row->ascrise = row->xheight * (ascrise / xheight);
   } else if (row_category == ROW_UNKNOWN) {
   // Otherwise assume this row is an all-caps or small-caps row
   // and adjust xheight and ascrise of the row.
 
     row->all_caps = true;
     if (cap_xheight) { // regular all caps
       if (textord_debug_xheights) tprintf("all caps\n");
       row->xheight = xheight;
       row->ascrise = ascrise;
       row->descdrop = descdrop;
     } else {  // small caps or caps with an odd xheight
       if (textord_debug_xheights) {
         if (row->xheight < xheight + ascrise && row->xheight > xheight) {
           tprintf("small caps\n");
         } else {
           tprintf("all caps with irregular xheight\n");
         }
       }
       row->ascrise = row->xheight * (ascrise / (xheight + ascrise));
       row->xheight -= row->ascrise;
       row->descdrop = row->xheight * (descdrop / xheight);
     }
   }
   if (textord_debug_xheights) {
     tprintf("corrected row->xheight = %.4f, row->acrise = %.4f, row->descdrop"
             " = %.4f\n", row->xheight, row->ascrise, row->descdrop);
   }
 }

void delete_non_dropout_rows	(	TO_BLOCK *	block,
		float	gradient,
		FCOORD	rotation,
		inT32	block_edge,
		BOOL8	testing_on
	)

delete_non_dropout_rows

Compute the linespacing and offset.

Definition at line 577 of file makerow.cpp.

                               {
   TBOX block_box;                 //deskewed block
   inT32 *deltas;                 //change in occupation
   inT32 *occupation;             //of pixel coords
   inT32 max_y;                   //in block
   inT32 min_y;
   inT32 line_index;              //of scan line
   inT32 line_count;              //no of scan lines
   inT32 distance;                //to drop-out
   inT32 xleft;                   //of block
   inT32 ybottom;                 //of block
   TO_ROW *row;                   //current row
   TO_ROW_IT row_it = block->get_rows ();
   BLOBNBOX_IT blob_it = &block->blobs;
 
   if (row_it.length () == 0)
     return;                      //empty block
   block_box = deskew_block_coords (block, gradient);
   xleft = block->block->bounding_box ().left ();
   ybottom = block->block->bounding_box ().bottom ();
   min_y = block_box.bottom () - 1;
   max_y = block_box.top () + 1;
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
     line_index = (inT32) floor (row_it.data ()->intercept ());
     if (line_index <= min_y)
       min_y = line_index - 1;
     if (line_index >= max_y)
       max_y = line_index + 1;
   }
   line_count = max_y - min_y + 1;
   if (line_count <= 0)
     return;                      //empty block
   deltas = (inT32 *) alloc_mem (line_count * sizeof (inT32));
   occupation = (inT32 *) alloc_mem (line_count * sizeof (inT32));
   if (deltas == NULL || occupation == NULL)
     MEMORY_OUT.error ("compute_line_spacing", ABORT, NULL);
 
   compute_line_occupation(block, gradient, min_y, max_y, occupation, deltas);
   compute_occupation_threshold ((inT32)
     ceil (block->line_spacing *
     (tesseract::CCStruct::kDescenderFraction +
     tesseract::CCStruct::kAscenderFraction)),
     (inT32) ceil (block->line_spacing *
     (tesseract::CCStruct::kXHeightFraction +
     tesseract::CCStruct::kAscenderFraction)),
     max_y - min_y + 1, occupation, deltas);
 #ifndef GRAPHICS_DISABLED
   if (testing_on) {
     draw_occupation(xleft, ybottom, min_y, max_y, occupation, deltas);
   }
 #endif
   compute_dropout_distances(occupation, deltas, line_count);
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
     row = row_it.data ();
     line_index = (inT32) floor (row->intercept ());
     distance = deltas[line_index - min_y];
     if (find_best_dropout_row (row, distance, block->line_spacing / 2,
     line_index, &row_it, testing_on)) {
 #ifndef GRAPHICS_DISABLED
       if (testing_on)
         plot_parallel_row(row, gradient, block_edge,
                           ScrollView::WHITE, rotation);
 #endif
       blob_it.add_list_after (row_it.data ()->blob_list ());
       delete row_it.extract ();  //too far away
     }
   }
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
     blob_it.add_list_after (row_it.data ()->blob_list ());
   }
 
   free_mem(deltas);
   free_mem(occupation);
 }

TBOX deskew_block_coords	(	TO_BLOCK *	block,
		float	gradient
	)

Definition at line 745 of file makerow.cpp.

                          {
   TBOX result;                    //block bounds
   TBOX blob_box;                  //of block
   FCOORD rotation;               //deskew vector
   float length;                  //of gradient vector
   TO_ROW_IT row_it = block->get_rows ();
   TO_ROW *row;                   //current row
   BLOBNBOX *blob;                //current blob
   BLOBNBOX_IT blob_it;           //iterator
 
   length = sqrt (gradient * gradient + 1);
   rotation = FCOORD (1 / length, -gradient / length);
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
     row = row_it.data ();
     blob_it.set_to_list (row->blob_list ());
     for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
     blob_it.forward ()) {
       blob = blob_it.data ();
       blob_box = blob->bounding_box ();
       blob_box.rotate (rotation);//de-skew it
       result += blob_box;
     }
   }
   return result;
 }

void expand_rows	(	ICOORD	page_tr,
		TO_BLOCK *	block,
		float	gradient,
		FCOORD	rotation,
		inT32	block_edge,
		BOOL8	testing_on
	)

Definition at line 975 of file makerow.cpp.

                   {
   BOOL8 swallowed_row;           //eaten a neighbour
   float y_max, y_min;            //new row limits
   float y_bottom, y_top;         //allowed limits
   TO_ROW *test_row;              //next row
   TO_ROW *row;                   //current row
                                  //iterators
   BLOBNBOX_IT blob_it = &block->blobs;
   TO_ROW_IT row_it = block->get_rows ();
 
 #ifndef GRAPHICS_DISABLED
   if (textord_show_expanded_rows && testing_on) {
     if (to_win == NULL)
       create_to_win(page_tr);
   }
 #endif
 
   adjust_row_limits(block);  //shift min,max.
   if (textord_new_initial_xheight) {
     if (block->get_rows ()->length () == 0)
       return;
     compute_row_stats(block, textord_show_expanded_rows &&testing_on);
   }
   assign_blobs_to_rows (block, &gradient, 4, TRUE, FALSE, FALSE);
   //get real membership
   if (block->get_rows ()->length () == 0)
     return;
   fit_parallel_rows(block,
                     gradient,
                     rotation,
                     block_edge,
                     textord_show_expanded_rows &&testing_on);
   if (!textord_new_initial_xheight)
     compute_row_stats(block, textord_show_expanded_rows &&testing_on);
   row_it.move_to_last ();
   do {
     row = row_it.data ();
     y_max = row->max_y ();       //get current limits
     y_min = row->min_y ();
     y_bottom = row->intercept () - block->line_size * textord_expansion_factor *
       tesseract::CCStruct::kDescenderFraction;
     y_top = row->intercept () + block->line_size * textord_expansion_factor *
         (tesseract::CCStruct::kXHeightFraction +
          tesseract::CCStruct::kAscenderFraction);
     if (y_min > y_bottom) {      //expansion allowed
       if (textord_show_expanded_rows && testing_on)
         tprintf("Expanding bottom of row at %f from %f to %f\n",
                 row->intercept(), y_min, y_bottom);
                                  //expandable
       swallowed_row = TRUE;
       while (swallowed_row && !row_it.at_last ()) {
         swallowed_row = FALSE;
                                  //get next one
         test_row = row_it.data_relative (1);
                                  //overlaps space
         if (test_row->max_y () > y_bottom) {
           if (test_row->min_y () > y_bottom) {
             if (textord_show_expanded_rows && testing_on)
               tprintf("Eating row below at %f\n", test_row->intercept());
             row_it.forward ();
 #ifndef GRAPHICS_DISABLED
             if (textord_show_expanded_rows && testing_on)
               plot_parallel_row(test_row,
                                 gradient,
                                 block_edge,
                                 ScrollView::WHITE,
                                 rotation);
 #endif
             blob_it.set_to_list (row->blob_list ());
             blob_it.add_list_after (test_row->blob_list ());
                                  //swallow complete row
             delete row_it.extract ();
             row_it.backward ();
             swallowed_row = TRUE;
           }
           else if (test_row->max_y () < y_min) {
                                  //shorter limit
             y_bottom = test_row->max_y ();
             if (textord_show_expanded_rows && testing_on)
               tprintf("Truncating limit to %f due to touching row at %f\n",
                       y_bottom, test_row->intercept());
           }
           else {
             y_bottom = y_min;    //can't expand it
             if (textord_show_expanded_rows && testing_on)
               tprintf("Not expanding limit beyond %f due to touching row at %f\n",
                       y_bottom, test_row->intercept());
           }
         }
       }
       y_min = y_bottom;          //expand it
     }
     if (y_max < y_top) {         //expansion allowed
       if (textord_show_expanded_rows && testing_on)
         tprintf("Expanding top of row at %f from %f to %f\n",
                 row->intercept(), y_max, y_top);
       swallowed_row = TRUE;
       while (swallowed_row && !row_it.at_first ()) {
         swallowed_row = FALSE;
                                  //get one above
         test_row = row_it.data_relative (-1);
         if (test_row->min_y () < y_top) {
           if (test_row->max_y () < y_top) {
             if (textord_show_expanded_rows && testing_on)
               tprintf("Eating row above at %f\n", test_row->intercept());
             row_it.backward ();
             blob_it.set_to_list (row->blob_list ());
 #ifndef GRAPHICS_DISABLED
             if (textord_show_expanded_rows && testing_on)
               plot_parallel_row(test_row,
                                 gradient,
                                 block_edge,
                                 ScrollView::WHITE,
                                 rotation);
 #endif
             blob_it.add_list_after (test_row->blob_list ());
                                  //swallow complete row
             delete row_it.extract ();
             row_it.forward ();
             swallowed_row = TRUE;
           }
           else if (test_row->min_y () < y_max) {
                                  //shorter limit
             y_top = test_row->min_y ();
             if (textord_show_expanded_rows && testing_on)
               tprintf("Truncating limit to %f due to touching row at %f\n",
                       y_top, test_row->intercept());
           }
           else {
             y_top = y_max;       //can't expand it
             if (textord_show_expanded_rows && testing_on)
               tprintf("Not expanding limit beyond %f due to touching row at %f\n",
                       y_top, test_row->intercept());
           }
         }
       }
       y_max = y_top;
     }
                                  //new limits
     row->set_limits (y_min, y_max);
     row_it.backward ();
   }
   while (!row_it.at_last ());
 }

void fill_heights	(	TO_ROW *	row,
		float	gradient,
		int	min_height,
		int	max_height,
		STATS *	heights,
		STATS *	floating_heights
	)

Definition at line 1436 of file makerow.cpp.

                                                                            {
   float xcentre;                 // centre of blob
   float top;                     // top y coord of blob
   float height;                  // height of blob
   BLOBNBOX *blob;                // current blob
   int repeated_set;
   BLOBNBOX_IT blob_it = row->blob_list();
   if (blob_it.empty()) return;  // no blobs in this row
   bool has_rep_chars =
     row->rep_chars_marked() && row->num_repeated_sets() > 0;
   do {
     blob = blob_it.data();
     if (!blob->joined_to_prev()) {
       xcentre = (blob->bounding_box().left() +
                  blob->bounding_box().right()) / 2.0f;
       top = blob->bounding_box().top();
       height = blob->bounding_box().height();
       if (textord_fix_xheight_bug)
         top -= row->baseline.y(xcentre);
       else
         top -= gradient * xcentre + row->parallel_c();
       if (top >= min_height && top <= max_height) {
         heights->add(static_cast<inT32>(floor(top + 0.5)), 1);
         if (height / top < textord_min_blob_height_fraction) {
           floating_heights->add(static_cast<inT32>(floor(top + 0.5)), 1);
         }
       }
     }
     // Skip repeated chars, since they are likely to skew the height stats.
     if (has_rep_chars && blob->repeated_set() != 0) {
       repeated_set = blob->repeated_set();
       blob_it.forward();
       while (!blob_it.at_first() &&
              blob_it.data()->repeated_set() == repeated_set) {
         blob_it.forward();
         if (textord_debug_xheights)
           tprintf("Skipping repeated char when computing xheight\n");
       }
     } else {
       blob_it.forward();
     }
   } while (!blob_it.at_first());
 }

BOOL8 find_best_dropout_row	(	TO_ROW *	row,
		inT32	distance,
		float	dist_limit,
		inT32	line_index,
		TO_ROW_IT *	row_it,
		BOOL8	testing_on
	)

Definition at line 665 of file makerow.cpp.

                              {
   inT32 next_index;              // of neighbouring row
   inT32 row_offset;              //from current row
   inT32 abs_dist;                //absolute distance
   inT8 row_inc;                  //increment to row_index
   TO_ROW *next_row;              //nextious row
 
   if (testing_on)
     tprintf ("Row at %g(%g), dropout dist=%d,",
       row->intercept (), row->parallel_c (), distance);
   if (distance < 0) {
     row_inc = 1;
     abs_dist = -distance;
   }
   else {
     row_inc = -1;
     abs_dist = distance;
   }
   if (abs_dist > dist_limit) {
     if (testing_on) {
       tprintf (" too far - deleting\n");
     }
     return TRUE;
   }
   if ((distance < 0 && !row_it->at_last ())
   || (distance >= 0 && !row_it->at_first ())) {
     row_offset = row_inc;
     do {
       next_row = row_it->data_relative (row_offset);
       next_index = (inT32) floor (next_row->intercept ());
       if ((distance < 0
         && next_index < line_index
         && next_index > line_index + distance + distance)
         || (distance >= 0
         && next_index > line_index
       && next_index < line_index + distance + distance)) {
         if (testing_on) {
           tprintf (" nearer neighbour (%d) at %g\n",
             line_index + distance - next_index,
             next_row->intercept ());
         }
         return TRUE;             //other is nearer
       }
       else if (next_index == line_index
       || next_index == line_index + distance + distance) {
         if (row->believability () <= next_row->believability ()) {
           if (testing_on) {
             tprintf (" equal but more believable at %g (%g/%g)\n",
               next_row->intercept (),
               row->believability (),
               next_row->believability ());
           }
           return TRUE;           //other is more believable
         }
       }
       row_offset += row_inc;
     }
     while ((next_index == line_index
       || next_index == line_index + distance + distance)
       && row_offset < row_it->length ());
     if (testing_on)
       tprintf (" keeping\n");
   }
   return FALSE;
 }

void fit_lms_line ( TO_ROW * row )

Definition at line 267 of file makerow.cpp.

                                {
   float m, c;                    // fitted line
   tesseract::DetLineFit lms;
   BLOBNBOX_IT blob_it = row->blob_list();
 
   for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) {
     const TBOX& box = blob_it.data()->bounding_box();
     lms.Add(ICOORD((box.left() + box.right()) / 2, box.bottom()));
   }
   double error = lms.Fit(&m, &c);
   row->set_line(m, c, error);
 }

void fit_parallel_lms	(	float	gradient,
		TO_ROW *	row
	)

Definition at line 2003 of file makerow.cpp.

                                                    {
   float c;                       // fitted line
   int blobcount;                 // no of blobs
    tesseract::DetLineFit lms;
   BLOBNBOX_IT blob_it = row->blob_list();
 
   blobcount = 0;
   for (blob_it.mark_cycle_pt(); !blob_it.cycled_list(); blob_it.forward()) {
     if (!blob_it.data()->joined_to_prev()) {
       const TBOX& box = blob_it.data()->bounding_box();
       lms.Add(ICOORD((box.left() + box.right()) / 2, box.bottom()));
       blobcount++;
     }
   }
   double error = lms.ConstrainedFit(gradient, &c);
   row->set_parallel_line(gradient, c, error);
   if (textord_straight_baselines && blobcount > textord_lms_line_trials) {
     error = lms.Fit(&gradient, &c);
   }
                                  //set the other too
   row->set_line(gradient, c, error);
 }

void fit_parallel_rows	(	TO_BLOCK *	block,
		float	gradient,
		FCOORD	rotation,
		inT32	block_edge,
		BOOL8	testing_on
	)

Definition at line 1961 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
       fit_parallel_lms (gradient, row_it.data ());
   }
 #ifndef GRAPHICS_DISABLED
   if (testing_on) {
     colour = ScrollView::RED;
     for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
       plot_parallel_row (row_it.data (), gradient,
         block_edge, colour, rotation);
       colour = (ScrollView::Color) (colour + 1);
       if (colour > ScrollView::MAGENTA)
         colour = ScrollView::RED;
     }
   }
 #endif
   row_it.sort (row_y_order);     //may have gone out of order
 }

void get_min_max_xheight	(	int	block_linesize,
		int *	min_height,
		int *	max_height
	)

inline

Definition at line 116 of file makerow.h.

                                                                   {
   *min_height = static_cast<inT32>(floor(block_linesize * textord_minxh));
   if (*min_height < textord_min_xheight) *min_height = textord_min_xheight;
   *max_height = static_cast<inT32>(ceil(block_linesize * 3.0));
 }

ROW_CATEGORY get_row_category ( const TO_ROW * row )

inline

Definition at line 123 of file makerow.h.

                                                         {
   if (row->xheight <= 0) return ROW_INVALID;
   return (row->ascrise > 0) ? ROW_ASCENDERS_FOUND :
     (row->descdrop != 0) ? ROW_DESCENDERS_FOUND : ROW_UNKNOWN;
 }

double* linear_spline_baseline	(	TO_ROW *	row,
		TO_BLOCK *	block,
		inT32 &	segments,
		inT32	xstarts[]
	)

Definition at line 2218 of file makerow.cpp.

   {
   int blobcount;                 //no of blobs
   int blobindex;                 //current blob
   int index1, index2;            //blob numbers
   int blobs_per_segment;         //blobs in each
   TBOX box;                       //blob box
   TBOX new_box;                   //new_it box
                                  //blobs
   BLOBNBOX_IT blob_it = row->blob_list ();
   BLOBNBOX_IT new_it = blob_it;  //front end
   float b, c;                    //fitted curve
   tesseract::DetLineFit lms;
   double *coeffs;                //quadratic coeffs
   inT32 segment;                 //current segment
 
   box = box_next_pre_chopped (&blob_it);
   xstarts[0] = box.left ();
   blobcount = 1;
   while (!blob_it.at_first ()) {
     blobcount++;
     box = box_next_pre_chopped (&blob_it);
   }
   segments = blobcount / textord_spline_medianwin;
   if (segments < 1)
     segments = 1;
   blobs_per_segment = blobcount / segments;
   coeffs = (double *) alloc_mem (segments * 3 * sizeof (double));
   if (textord_oldbl_debug)
     tprintf
       ("Linear splining baseline of %d blobs at (%d,%d), into %d segments of %d blobs\n",
       blobcount, box.left (), box.bottom (), segments, blobs_per_segment);
   segment = 1;
   for (index2 = 0; index2 < blobs_per_segment / 2; index2++)
     box_next_pre_chopped(&new_it);
   index1 = 0;
   blobindex = index2;
   do {
     blobindex += blobs_per_segment;
     lms.Clear();
     while (index1 < blobindex || (segment == segments && index1 < blobcount)) {
       box = box_next_pre_chopped (&blob_it);
       int middle = (box.left() + box.right()) / 2;
       lms.Add(ICOORD(middle, box.bottom()));
       index1++;
       if (index1 == blobindex - blobs_per_segment / 2
       || index1 == blobcount - 1) {
         xstarts[segment] = box.left ();
       }
     }
     lms.Fit(&b, &c);
     coeffs[segment * 3 - 3] = 0;
     coeffs[segment * 3 - 2] = b;
     coeffs[segment * 3 - 1] = c;
     segment++;
     if (segment > segments)
       break;
 
     blobindex += blobs_per_segment;
     lms.Clear();
     while (index2 < blobindex || (segment == segments && index2 < blobcount)) {
       new_box = box_next_pre_chopped (&new_it);
       int middle = (new_box.left() + new_box.right()) / 2;
       lms.Add(ICOORD (middle, new_box.bottom()));
       index2++;
       if (index2 == blobindex - blobs_per_segment / 2
       || index2 == blobcount - 1) {
         xstarts[segment] = new_box.left ();
       }
     }
     lms.Fit(&b, &c);
     coeffs[segment * 3 - 3] = 0;
     coeffs[segment * 3 - 2] = b;
     coeffs[segment * 3 - 1] = c;
     segment++;
   }
   while (segment <= segments);
   return coeffs;
 }

void make_baseline_spline	(	TO_ROW *	row,
		TO_BLOCK *	block
	)

Definition at line 2086 of file makerow.cpp.

                                            {
   inT32 *xstarts;                // spline boundaries
   double *coeffs;                // quadratic coeffs
   inT32 segments;                // no of segments
 
   xstarts =
     (inT32 *) alloc_mem((row->blob_list()->length() + 1) * sizeof(inT32));
   if (segment_baseline(row, block, segments, xstarts)
   && !textord_straight_baselines && !textord_parallel_baselines) {
     coeffs = linear_spline_baseline(row, block, segments, xstarts);
   } else {
     xstarts[1] = xstarts[segments];
     segments = 1;
     coeffs = (double *) alloc_mem (3 * sizeof (double));
     coeffs[0] = 0;
     coeffs[1] = row->line_m ();
     coeffs[2] = row->line_c ();
   }
   row->baseline = QSPLINE (segments, xstarts, coeffs);
   free_mem(coeffs);
   free_mem(xstarts);
 }

void make_initial_textrows	(	ICOORD	page_tr,
		TO_BLOCK *	block,
		FCOORD	rotation,
		BOOL8	testing_on
	)

Definition at line 227 of file makerow.cpp.

                             {
   TO_ROW_IT row_it = block->get_rows ();
 
 #ifndef GRAPHICS_DISABLED
   ScrollView::Color colour;                 //of row
 
   if (textord_show_initial_rows && testing_on) {
     if (to_win == NULL)
       create_to_win(page_tr);
   }
 #endif
                                  //guess skew
   assign_blobs_to_rows (block, NULL, 0, TRUE, TRUE, textord_show_initial_rows && testing_on);
   row_it.move_to_first ();
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ())
     fit_lms_line (row_it.data ());
 #ifndef GRAPHICS_DISABLED
   if (textord_show_initial_rows && testing_on) {
     colour = ScrollView::RED;
     for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
       plot_to_row (row_it.data (), colour, rotation);
       colour = (ScrollView::Color) (colour + 1);
       if (colour > ScrollView::MAGENTA)
         colour = ScrollView::RED;
     }
   }
 #endif
 }

float make_rows	(	ICOORD	page_tr,
		TO_BLOCK_LIST *	port_blocks
	)

Definition at line 201 of file makerow.cpp.

                                                             {
   float port_m;                  // global skew
   float port_err;                // global noise
   TO_BLOCK_IT block_it;          // iterator
 
   block_it.set_to_list(port_blocks);
   for (block_it.mark_cycle_pt(); !block_it.cycled_list();
        block_it.forward())
   make_initial_textrows(page_tr, block_it.data(), FCOORD(1.0f, 0.0f),
       !(BOOL8) textord_test_landscape);
                                  // compute globally
   compute_page_skew(port_blocks, port_m, port_err);
   block_it.set_to_list(port_blocks);
   for (block_it.mark_cycle_pt(); !block_it.cycled_list(); block_it.forward()) {
     cleanup_rows_making(page_tr, block_it.data(), port_m, FCOORD(1.0f, 0.0f),
                  block_it.data()->block->bounding_box().left(),
                  !(BOOL8)textord_test_landscape);
   }
   return port_m;                 // global skew
 }

float make_single_row	(	ICOORD	page_tr,
		bool	allow_sub_blobs,
		TO_BLOCK *	block,
		TO_BLOCK_LIST *	blocks
	)

Definition at line 164 of file makerow.cpp.

                                                               {
   BLOBNBOX_IT blob_it = &block->blobs;
   TO_ROW_IT row_it = block->get_rows();
 
   // Include all the small blobs and large blobs.
   blob_it.add_list_after(&block->small_blobs);
   blob_it.add_list_after(&block->noise_blobs);
   blob_it.add_list_after(&block->large_blobs);
   if (block->blobs.singleton() && allow_sub_blobs) {
     blob_it.move_to_first();
     float size = MakeRowFromSubBlobs(block, blob_it.data()->cblob(), &row_it);
     if (size > block->line_size)
       block->line_size = size;
   } else if (block->blobs.empty()) {
     // Make a fake blob.
     C_BLOB* blob = C_BLOB::FakeBlob(block->block->bounding_box());
     // The blobnbox owns the blob.
     BLOBNBOX* bblob = new BLOBNBOX(blob);
     blob_it.add_after_then_move(bblob);
   }
   MakeRowFromBlobs(block->line_size, &blob_it, &row_it);
   // Fit an LMS line to the rows.
   for (row_it.mark_cycle_pt(); !row_it.cycled_list(); row_it.forward())
     fit_lms_line(row_it.data());
   float gradient;
   float fit_error;
   // Compute the skew based on the fitted line.
   compute_page_skew(blocks, gradient, fit_error);
   return gradient;
 }

void mark_repeated_chars ( TO_ROW * row )

Definition at line 2670 of file makerow.cpp.

                                       {
   BLOBNBOX_IT box_it(row->blob_list());            // Iterator.
   int num_repeated_sets = 0;
   if (!box_it.empty()) {
     do {
       BLOBNBOX* bblob = box_it.data();
       int repeat_length = 1;
       if (bblob->flow() == BTFT_LEADER &&
           !bblob->joined_to_prev() && bblob->cblob() != NULL) {
         BLOBNBOX_IT test_it(box_it);
         for (test_it.forward(); !test_it.at_first();) {
           bblob = test_it.data();
           if (bblob->flow() != BTFT_LEADER)
             break;
           test_it.forward();
           bblob = test_it.data();
           if (bblob->joined_to_prev() || bblob->cblob() == NULL) {
             repeat_length = 0;
             break;
           }
           ++repeat_length;
         }
       }
       if (repeat_length >= kMinLeaderCount) {
         num_repeated_sets++;
         for (; repeat_length > 0; box_it.forward(), --repeat_length) {
           bblob = box_it.data();
           bblob->set_repeated_set(num_repeated_sets);
         }
      } else {
         bblob->set_repeated_set(0);
         box_it.forward();
       }
     } while (!box_it.at_first());  // until all done
   }
   row->set_num_repeated_sets(num_repeated_sets);
 }

float median_block_xheight	(	TO_BLOCK *	block,
		float	gradient
	)

OVERLAP_STATE most_overlapping_row	(	TO_ROW_IT *	row_it,
		TO_ROW *&	best_row,
		float	top,
		float	bottom,
		float	rowsize,
		BOOL8	testing_blob
	)

Definition at line 2509 of file makerow.cpp.

                                     {
   OVERLAP_STATE result;          //result of tests
   float overlap;                 //of blob & row
   float bestover;                //nearest row
   float merge_top, merge_bottom; //size of merged row
   ICOORD testpt;                 //testing only
   TO_ROW *row;                   //current row
   TO_ROW *test_row;              //for multiple overlaps
   BLOBNBOX_IT blob_it;           //for merging rows
 
   result = ASSIGN;
   row = row_it->data ();
   bestover = top - bottom;
   if (top > row->max_y ())
     bestover -= top - row->max_y ();
   if (bottom < row->min_y ())
                                  //compute overlap
     bestover -= row->min_y () - bottom;
   if (testing_blob && textord_debug_blob) {
     tprintf("Test blob y=(%g,%g), row=(%f,%f), size=%g, overlap=%f\n",
             bottom, top, row->min_y(), row->max_y(), rowsize, bestover);
   }
   test_row = row;
   do {
     if (!row_it->at_last ()) {
       row_it->forward ();
       test_row = row_it->data ();
       if (test_row->min_y () <= top && test_row->max_y () >= bottom) {
         merge_top =
           test_row->max_y () >
           row->max_y ()? test_row->max_y () : row->max_y ();
         merge_bottom =
           test_row->min_y () <
           row->min_y ()? test_row->min_y () : row->min_y ();
         if (merge_top - merge_bottom <= rowsize) {
           if (testing_blob) {
             tprintf ("Merging rows at (%g,%g), (%g,%g)\n",
               row->min_y (), row->max_y (),
               test_row->min_y (), test_row->max_y ());
           }
           test_row->set_limits (merge_bottom, merge_top);
           blob_it.set_to_list (test_row->blob_list ());
           blob_it.add_list_after (row->blob_list ());
           blob_it.sort (blob_x_order);
           row_it->backward ();
           delete row_it->extract ();
           row_it->forward ();
           bestover = -1.0f;      //force replacement
         }
         overlap = top - bottom;
         if (top > test_row->max_y ())
           overlap -= top - test_row->max_y ();
         if (bottom < test_row->min_y ())
           overlap -= test_row->min_y () - bottom;
         if (bestover >= rowsize - 1 && overlap >= rowsize - 1) {
           result = REJECT;
         }
         if (overlap > bestover) {
           bestover = overlap;    //find biggest overlap
           row = test_row;
         }
         if (testing_blob && textord_debug_blob) {
           tprintf("Test blob y=(%g,%g), row=(%f,%f), size=%g, overlap=%f->%f\n",
                   bottom, top, test_row->min_y(), test_row->max_y(),
                   rowsize, overlap, bestover);
         }
       }
     }
   }
   while (!row_it->at_last ()
     && test_row->min_y () <= top && test_row->max_y () >= bottom);
   while (row_it->data () != row)
     row_it->backward ();         //make it point to row
                                  //doesn't overlap much
   if (top - bottom - bestover > rowsize * textord_overlap_x &&
       (!textord_fix_makerow_bug || bestover < rowsize * textord_overlap_x)
     && result == ASSIGN)
     result = NEW_ROW;            //doesn't overlap enough
   best_row = row;
   return result;
 }

void pre_associate_blobs	(	ICOORD	page_tr,
		TO_BLOCK *	block,
		FCOORD	rotation,
		BOOL8	testing_on
	)

Definition at line 1875 of file makerow.cpp.

                           {
 #ifndef GRAPHICS_DISABLED
   ScrollView::Color colour;                 //of boxes
 #endif
   BLOBNBOX *blob;                //current blob
   BLOBNBOX *nextblob;            //next in list
   TBOX blob_box;
   FCOORD blob_rotation;          //inverse of rotation
   BLOBNBOX_IT blob_it;           //iterator
   BLOBNBOX_IT start_it;          //iterator
   TO_ROW_IT row_it = block->get_rows ();
 
 #ifndef GRAPHICS_DISABLED
   colour = ScrollView::RED;
 #endif
 
   blob_rotation = FCOORD (rotation.x (), -rotation.y ());
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
                                  //get blobs
     blob_it.set_to_list (row_it.data ()->blob_list ());
     for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
     blob_it.forward ()) {
       blob = blob_it.data ();
       blob_box = blob->bounding_box ();
       start_it = blob_it;        //save start point
       //                      if (testing_on && textord_show_final_blobs)
       //                      {
       //                              tprintf("Blob at (%d,%d)->(%d,%d), addr=%x, count=%d\n",
       //                                      blob_box.left(),blob_box.bottom(),
       //                                      blob_box.right(),blob_box.top(),
       //                                      (void*)blob,blob_it.length());
       //                      }
       bool overlap;
       do {
         overlap = false;
         if (!blob_it.at_last ()) {
           nextblob = blob_it.data_relative(1);
           overlap = blob_box.major_x_overlap(nextblob->bounding_box());
           if (overlap) {
             blob->merge(nextblob); // merge new blob
             blob_box = blob->bounding_box(); // get bigger box
             blob_it.forward();
           }
         }
       }
       while (overlap);
       blob->chop (&start_it, &blob_it,
         blob_rotation,
         block->line_size * tesseract::CCStruct::kXHeightFraction *
         textord_chop_width);
       //attempt chop
     }
 #ifndef GRAPHICS_DISABLED
     if (testing_on && textord_show_final_blobs) {
       if (to_win == NULL)
         create_to_win(page_tr);
       to_win->Pen(colour);
       for (blob_it.mark_cycle_pt (); !blob_it.cycled_list ();
       blob_it.forward ()) {
         blob = blob_it.data ();
         blob_box = blob->bounding_box ();
         blob_box.rotate (rotation);
         if (!blob->joined_to_prev ()) {
           to_win->Rectangle (blob_box.left (), blob_box.bottom (),
             blob_box.right (), blob_box.top ());
         }
       }
       colour = (ScrollView::Color) (colour + 1);
       if (colour > ScrollView::MAGENTA)
         colour = ScrollView::RED;
     }
 #endif
   }
 }

int row_spacing_order	(	const void *	item1,
		const void *	item2
	)

Definition at line 2648 of file makerow.cpp.

                                          {
                                  //converted ptr
   TO_ROW *row1 = *(TO_ROW **) item1;
                                  //converted ptr
   TO_ROW *row2 = *(TO_ROW **) item2;
 
   if (row1->spacing < row2->spacing)
     return -1;
   else if (row1->spacing > row2->spacing)
     return 1;
   else
     return 0;
 }

int row_y_order	(	const void *	item1,
		const void *	item2
	)

Definition at line 2626 of file makerow.cpp.

                                    {
                                  //converted ptr
   TO_ROW *row1 = *(TO_ROW **) item1;
                                  //converted ptr
   TO_ROW *row2 = *(TO_ROW **) item2;
 
   if (row1->parallel_c () > row2->parallel_c ())
     return -1;
   else if (row1->parallel_c () < row2->parallel_c ())
     return 1;
   else
     return 0;
 }

BOOL8 segment_baseline	(	TO_ROW *	row,
		TO_BLOCK *	block,
		inT32 &	segments,
		inT32	xstarts[]
	)

Definition at line 2119 of file makerow.cpp.

   {
   BOOL8 needs_curve;             //needs curved line
   int blobcount;                 //no of blobs
   int blobindex;                 //current blob
   int last_state;                //above, on , below
   int state;                     //of current blob
   float yshift;                  //from baseline
   TBOX box;                       //blob box
   TBOX new_box;                   //new_it box
   float middle;                  //xcentre of blob
                                  //blobs
   BLOBNBOX_IT blob_it = row->blob_list ();
   BLOBNBOX_IT new_it = blob_it;  //front end
   SORTED_FLOATS yshifts;         //shifts from baseline
 
   needs_curve = FALSE;
   box = box_next_pre_chopped (&blob_it);
   xstarts[0] = box.left ();
   segments = 1;
   blobcount = row->blob_list ()->length ();
   if (textord_oldbl_debug)
     tprintf ("Segmenting baseline of %d blobs at (%d,%d)\n",
       blobcount, box.left (), box.bottom ());
   if (blobcount <= textord_spline_medianwin
   || blobcount < textord_spline_minblobs) {
     blob_it.move_to_last ();
     box = blob_it.data ()->bounding_box ();
     xstarts[1] = box.right ();
     return FALSE;
   }
   last_state = 0;
   new_it.mark_cycle_pt ();
   for (blobindex = 0; blobindex < textord_spline_medianwin; blobindex++) {
     new_box = box_next_pre_chopped (&new_it);
     middle = (new_box.left () + new_box.right ()) / 2.0;
     yshift = new_box.bottom () - row->line_m () * middle - row->line_c ();
                                  //record shift
     yshifts.add (yshift, blobindex);
     if (new_it.cycled_list ()) {
       xstarts[1] = new_box.right ();
       return FALSE;
     }
   }
   for (blobcount = 0; blobcount < textord_spline_medianwin / 2; blobcount++)
     box = box_next_pre_chopped (&blob_it);
   do {
     new_box = box_next_pre_chopped (&new_it);
                                  //get middle one
     yshift = yshifts[textord_spline_medianwin / 2];
     if (yshift > textord_spline_shift_fraction * block->line_size)
       state = 1;
     else if (-yshift > textord_spline_shift_fraction * block->line_size)
       state = -1;
     else
       state = 0;
     if (state != 0)
       needs_curve = TRUE;
     //              tprintf("State=%d, prev=%d, shift=%g\n",
     //                      state,last_state,yshift);
     if (state != last_state && blobcount > textord_spline_minblobs) {
       xstarts[segments++] = box.left ();
       blobcount = 0;
     }
     last_state = state;
     yshifts.remove (blobindex - textord_spline_medianwin);
     box = box_next_pre_chopped (&blob_it);
     middle = (new_box.left () + new_box.right ()) / 2.0;
     yshift = new_box.bottom () - row->line_m () * middle - row->line_c ();
     yshifts.add (yshift, blobindex);
     blobindex++;
     blobcount++;
   }
   while (!new_it.cycled_list ());
   if (blobcount > textord_spline_minblobs || segments == 1) {
     xstarts[segments] = new_box.right ();
   }
   else {
     xstarts[--segments] = new_box.right ();
   }
   if (textord_oldbl_debug)
     tprintf ("Made %d segments on row at (%d,%d)\n",
       segments, box.right (), box.bottom ());
   return needs_curve;
 }

void separate_underlines	(	TO_BLOCK *	block,
		float	gradient,
		FCOORD	rotation,
		BOOL8	testing_on
	)

Definition at line 1802 of file makerow.cpp.

                                            {  // correct orientation
   BLOBNBOX *blob;                // current blob
   C_BLOB *rotated_blob;          // rotated blob
   TO_ROW *row;                   // current row
   float length;                  // of g_vec
   TBOX blob_box;
   FCOORD blob_rotation;          // inverse of rotation
   FCOORD g_vec;                  // skew rotation
   BLOBNBOX_IT blob_it;           // iterator
                                  // iterator
   BLOBNBOX_IT under_it = &block->underlines;
   BLOBNBOX_IT large_it = &block->large_blobs;
   TO_ROW_IT row_it = block->get_rows();
   int min_blob_height = static_cast<int>(textord_min_blob_height_fraction *
                                          block->line_size + 0.5);
 
                                  // length of vector
   length = sqrt(1 + gradient * gradient);
   g_vec = FCOORD(1 / length, -gradient / length);
   blob_rotation = FCOORD(rotation.x(), -rotation.y());
   blob_rotation.rotate(g_vec);  // undoing everything
   for (row_it.mark_cycle_pt(); !row_it.cycled_list(); row_it.forward()) {
     row = row_it.data();
                                  // get blobs
     blob_it.set_to_list(row->blob_list());
     for (blob_it.mark_cycle_pt(); !blob_it.cycled_list();
          blob_it.forward()) {
       blob = blob_it.data();
       blob_box = blob->bounding_box();
       if (blob_box.width() > block->line_size * textord_underline_width) {
         ASSERT_HOST(blob->cblob() != NULL);
         rotated_blob = crotate_cblob (blob->cblob(),
           blob_rotation);
         if (test_underline(
             testing_on && textord_show_final_rows,
             rotated_blob, static_cast<inT16>(row->intercept()),
             static_cast<inT16>(
                 block->line_size *
                 (tesseract::CCStruct::kXHeightFraction +
                  tesseract::CCStruct::kAscenderFraction / 2.0f)))) {
           under_it.add_after_then_move(blob_it.extract());
           if (testing_on && textord_show_final_rows) {
             tprintf("Underlined blob at:");
               rotated_blob->bounding_box().print();
             tprintf("Was:");
               blob_box.print();
           }
         } else if (CountOverlaps(blob->bounding_box(), min_blob_height,
                                  row->blob_list()) >
                    textord_max_blob_overlaps) {
           large_it.add_after_then_move(blob_it.extract());
           if (testing_on && textord_show_final_rows) {
             tprintf("Large blob overlaps %d blobs at:",
                     CountOverlaps(blob_box, min_blob_height,
                                   row->blob_list()));
             blob_box.print();
           }
         }
         delete rotated_blob;
       }
     }
   }
 }

void vigorous_noise_removal ( TO_BLOCK * block )

Definition at line 473 of file makerow.cpp.

                                              {
   TO_ROW_IT row_it = block->get_rows ();
   for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
     TO_ROW* row = row_it.data();
     BLOBNBOX_IT b_it = row->blob_list();
     // Estimate the xheight on the row.
     int max_height = 0;
     for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
       BLOBNBOX* blob = b_it.data();
       if (blob->bounding_box().height() > max_height)
         max_height = blob->bounding_box().height();
     }
     STATS hstats(0, max_height + 1);
     for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
       BLOBNBOX* blob = b_it.data();
       int height = blob->bounding_box().height();
       if (height >= kMinSize)
         hstats.add(blob->bounding_box().height(), 1);
     }
     float xheight = hstats.median();
     // Delete small objects.
     BLOBNBOX* prev = NULL;
     for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
       BLOBNBOX* blob = b_it.data();
       const TBOX& box = blob->bounding_box();
       if (box.height() < kNoiseSize * xheight) {
         // Small so delete unless it looks like an i dot.
         if (prev != NULL) {
           if (dot_of_i(blob, prev, row))
             continue;  // Looks OK.
         }
         if (!b_it.at_last()) {
           BLOBNBOX* next = b_it.data_relative(1);
           if (dot_of_i(blob, next, row))
             continue;  // Looks OK.
         }
         // It might be noise so get rid of it.
         delete blob->cblob();
         delete b_it.extract();
       } else {
         prev = blob;
       }
     }
   }
 }

bool within_error_margin	(	float	test,
		float	num,
		float	margin
	)

inline

Definition at line 129 of file makerow.h.

                                                                      {
   return (test >= num * (1 - margin) && test <= num * (1 + margin));
 }

Variable Documentation

double textord_ascheight_mode_fraction = 0.15

"Min pile height to make ascheight"

Definition at line 93 of file makerow.cpp.

double textord_ascx_ratio_max = 1.7

"Max cap/xheight"

Definition at line 97 of file makerow.cpp.

double textord_ascx_ratio_min = 1.2

"Min cap/xheight"

Definition at line 96 of file makerow.cpp.

bool textord_cblob_blockocc = TRUE

"Use new projection for underlines"

double textord_chop_width = 1.5

"Max width before chopping"

Definition at line 78 of file makerow.cpp.

bool textord_debug_blob = FALSE

"Print test blob information"

Definition at line 103 of file makerow.cpp.

bool textord_debug_xheights = FALSE

"Test xheight algorithms"

Definition at line 57 of file makerow.cpp.

double textord_descx_ratio_max = 0.6

"Max desc/xheight"

Definition at line 99 of file makerow.cpp.

double textord_descx_ratio_min = 0.15

"Min desc/xheight"

Definition at line 98 of file makerow.cpp.

double textord_excess_blobsize = 1.3

"New row made if blob makes row this big"

Definition at line 85 of file makerow.cpp.

bool textord_fix_makerow_bug = TRUE

"Prevent multiple baselines"

Definition at line 56 of file makerow.cpp.

bool textord_fix_xheight_bug = TRUE

"Use spline baseline"

Definition at line 55 of file makerow.cpp.

bool textord_heavy_nr = FALSE

"Vigorously remove noise"

Definition at line 44 of file makerow.cpp.

double textord_linespace_iqrlimit = 0.2

"Max iqr/median for linespace"

Definition at line 76 of file makerow.cpp.

int textord_lms_line_trials = 12

"Number of linew fits to do"

Definition at line 101 of file makerow.cpp.

double textord_min_blob_height_fraction = 0.75

"Min blob height/top to include blob top into xheight stats"

Definition at line 89 of file makerow.cpp.

int textord_min_blobs_in_row = 4

"Min blobs before gradient counted"

Definition at line 64 of file makerow.cpp.

double textord_min_linesize = 1.25

"* blob height for initial linesize"

Definition at line 83 of file makerow.cpp.

int textord_min_xheight = 10

"Min credible pixel xheight"

Definition at line 69 of file makerow.cpp.

double textord_minxh = 0.25

"fraction of linesize for min xheight"

Definition at line 82 of file makerow.cpp.

bool textord_new_initial_xheight = TRUE

"Use test xheight mechanism"

Definition at line 102 of file makerow.cpp.

double textord_occupancy_threshold = 0.4

"Fraction of neighbourhood"

Definition at line 86 of file makerow.cpp.

bool textord_old_baselines = TRUE

"Use old baseline algorithm"

Definition at line 53 of file makerow.cpp.

bool textord_old_xheight = TRUE

"Use old xheight algorithm"

Definition at line 54 of file makerow.cpp.

bool textord_parallel_baselines = TRUE

"Force parallel baselines"

Definition at line 51 of file makerow.cpp.

bool textord_quadratic_baselines = FALSE

"Use quadratic splines"

bool textord_show_expanded_rows = FALSE

"Display rows after expanding"

Definition at line 47 of file makerow.cpp.

bool textord_show_final_blobs = FALSE

"Display blob bounds after pre-ass"

Definition at line 49 of file makerow.cpp.

bool textord_show_final_rows = FALSE

"Display rows after final fitting"

Definition at line 48 of file makerow.cpp.

bool textord_show_initial_rows = FALSE

"Display row accumulation"

Definition at line 45 of file makerow.cpp.

bool textord_show_parallel_rows = FALSE

"Display page correlated rows"

Definition at line 46 of file makerow.cpp.

double textord_skew_ile = 0.5

"Ile of gradients for page skew"

Definition at line 74 of file makerow.cpp.

double textord_skew_lag = 0.75

"Lag for skew on row accumulation"

Definition at line 75 of file makerow.cpp.

int textord_spline_medianwin = 6

"Size of window for spline segmentation"

Definition at line 66 of file makerow.cpp.

int textord_spline_minblobs = 8

"Min blobs in each spline segment"

Definition at line 65 of file makerow.cpp.

double textord_spline_outlier_fraction = 0.1

"Fraction of line spacing for outlier"

Definition at line 73 of file makerow.cpp.

double textord_spline_shift_fraction = 0.02

"Fraction of line spacing for quad"

Definition at line 71 of file makerow.cpp.

bool textord_straight_baselines = FALSE

"Force straight baselines"

Definition at line 52 of file makerow.cpp.

bool textord_test_landscape = FALSE

"Tests refer to land/port"

Definition at line 50 of file makerow.cpp.

int textord_test_x = -MAX_INT32

"coord of test pt"

Definition at line 62 of file makerow.cpp.

int textord_test_y = -MAX_INT32

"coord of test pt"

Definition at line 63 of file makerow.cpp.

double textord_underline_width = 2.0

"Multiple of line_size for underline"

Definition at line 87 of file makerow.cpp.

double textord_width_limit = 8

"Max width of blobs to make rows"

Definition at line 77 of file makerow.cpp.

double textord_xheight_error_margin = 0.1

"Accepted variation"

Definition at line 100 of file makerow.cpp.

double textord_xheight_mode_fraction = 0.4

"Min pile height to make xheight"

Definition at line 91 of file makerow.cpp.

Enumerations

Functions

Variables

Enumeration Type Documentation

Function Documentation

Variable Documentation