textord/topitch.cpp File Reference

#include "mfcpch.h"
#include "stderr.h"
#include "blobbox.h"
#include "lmedsq.h"
#include "statistc.h"
#include "drawtord.h"
#include "makerow.h"
#include "pitsync1.h"
#include "pithsync.h"
#include "blobcmpl.h"
#include "tovars.h"
#include "wordseg.h"
#include "topitch.h"
#include "secname.h"

Go to the source code of this file.

Defines

• #define BLOCK_STATS_CLUSTERS   10
• #define EXTERN
• #define FIXED_WIDTH_MULTIPLE   5
• #define MAX_ALLOWED_PITCH   100

Functions

• EXTERN BOOL_VAR (textord_all_prop, FALSE,"All doc is proportial text")
• void compute_block_pitch (TO_BLOCK *block, FCOORD rotation, INT32 block_index, BOOL8 testing_on)

  Process each block.
  

• void compute_fixed_pitch (ICOORD page_tr, TO_BLOCK_LIST *port_blocks, float gradient, FCOORD rotation, BOOL8 testing_on)

  Determine pitch.
  

• float compute_pitch_sd (TO_ROW *row, STATS *projection, INT16 projection_left, INT16 projection_right, float space_size, float initial_pitch, float &sp_sd, INT16 &mid_cuts, ICOORDELT_LIST *row_cells, BOOL8 testing_on, INT16 start, INT16 end)

  Find fp cells.
  

• float compute_pitch_sd2 (TO_ROW *row, STATS *projection, INT16 projection_left, INT16 projection_right, float initial_pitch, INT16 &occupation, INT16 &mid_cuts, ICOORDELT_LIST *row_cells, BOOL8 testing_on, INT16 start, INT16 end)

  Find fp cells.
  

• BOOL8 compute_rows_pitch (TO_BLOCK *block, INT32 block_index, BOOL8 testing_on)

  Find line stats.
  

• void count_block_votes (TO_BLOCK *block, INT32 &def_fixed, INT32 &def_prop, INT32 &maybe_fixed, INT32 &maybe_prop, INT32 &corr_fixed, INT32 &corr_prop, INT32 &dunno)

  Find line stats.
  

• BOOL8 count_pitch_stats (TO_ROW *row, STATS *gap_stats, STATS *pitch_stats, float initial_pitch, float min_space, BOOL8 ignore_outsize, BOOL8 split_outsize, INT32 dm_gap)

  Find lines.
  

• void find_repeated_chars (TO_BLOCK *block, BOOL8 testing_on)

  Search for equal chars.
  

• BOOL8 find_row_pitch (TO_ROW *row, INT32 maxwidth, INT32 dm_gap, TO_BLOCK *block, INT32 block_index, INT32 row_index, BOOL8 testing_on)

  Find lines.
  

• void fix_row_pitch (TO_ROW *bad_row, TO_BLOCK *bad_block, TO_BLOCK_LIST *blocks, INT32 row_target, INT32 block_target)

  Get some value.
  

• BOOL8 fixed_pitch_row (TO_ROW *row, INT32 block_index)

  Find lines.
  

• void plot_fp_word (TO_BLOCK *block, float pitch, float nonspace)

  Draw block of words.
  

• void print_block_counts (TO_BLOCK *block, INT32 block_index)

  Print line stats.
  

• void print_pitch_sd (TO_ROW *row, STATS *projection, INT16 projection_left, INT16 projection_right, float space_size, float initial_pitch)

  Print fp cells.
  

• BOOL8 row_pitch_stats (TO_ROW *row, INT32 maxwidth, BOOL8 testing_on)

  Find line stats.
  

• int sort_floats2 (const void *arg1, const void *arg2)

  qsort function to sort 2 floats.
  

• BOOL8 try_block_fixed (TO_BLOCK *block, INT32 block_index)

  Find line stats.
  

• BOOL8 try_doc_fixed (ICOORD page_tr, TO_BLOCK_LIST *port_blocks, float gradient)

  Determine pitch.
  

• BOOL8 try_rows_fixed (TO_BLOCK *block, INT32 block_index, BOOL8 testing_on)

  Find line stats.
  

• float tune_row_pitch (TO_ROW *row, STATS *projection, INT16 projection_left, INT16 projection_right, float space_size, float &initial_pitch, float &best_sp_sd, INT16 &best_mid_cuts, ICOORDELT_LIST *best_cells, BOOL8 testing_on)

  Find fp cells.
  

• float tune_row_pitch2 (TO_ROW *row, STATS *projection, INT16 projection_left, INT16 projection_right, float space_size, float &initial_pitch, float &best_sp_sd, INT16 &best_mid_cuts, ICOORDELT_LIST *best_cells, BOOL8 testing_on)

  Find fp cells.
  

---

Define Documentation

#define BLOCK_STATS_CLUSTERS   10

Definition at line 65 of file topitch.cpp.

Referenced by row_pitch_stats(), and row_words2().

#define EXTERN

Note:

File: topitch.cpp (Formerly to_pitch.c)
Code to determine fixed pitchness and the pitch if fixed.

Author:

Ray Smith

Date:

Aug 24 16:57:29 BST 1993

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

Definition at line 38 of file topitch.cpp.

#define FIXED_WIDTH_MULTIPLE   5

Definition at line 64 of file topitch.cpp.

#define MAX_ALLOWED_PITCH   100

Definition at line 66 of file topitch.cpp.

Referenced by try_doc_fixed().

---

Function Documentation

EXTERN BOOL_VAR	(	textord_all_prop	,
		FALSE	,
		"All doc is proportial text"
	)

void compute_block_pitch	(	TO_BLOCK *	block,
		FCOORD	rotation,
		INT32	block_index,
		BOOL8	testing_on
	)

Process each block.

Decide whether each block is fixed pitch individually.

Definition at line 337 of file topitch.cpp.

References ASSERT_HOST, BOX::bottom(), compute_rows_pitch(), find_repeated_chars(), BOX::left(), overlap_picture_ops, BOX::right(), BOX::top(), tprintf(), and TRUE.

Referenced by compute_fixed_pitch().

                          {
  BOX block_box;                 //bounding box

  block_box = block->block->bounding_box ();
  if (testing_on && textord_debug_pitch_test) {
    tprintf ("Block %d at (%d,%d)->(%d,%d)\n",
      block_index,
      block_box.left (), block_box.bottom (),
      block_box.right (), block_box.top ());
  }
  block->min_space = (INT32) floor (block->xheight
    * textord_words_default_minspace);
  block->max_nonspace = (INT32) ceil (block->xheight
    * textord_words_default_nonspace);
  block->fixed_pitch = 0.0f;
  block->space_size = (float) block->min_space;
  block->kern_size = (float) block->max_nonspace;
  block->pr_nonsp = block->xheight * words_default_prop_nonspace;
  block->pr_space = block->pr_nonsp * textord_spacesize_ratioprop;
  if (!block->get_rows ()->empty ()) {
    ASSERT_HOST (block->xheight > 0);
    if (textord_repeat_extraction)
      find_repeated_chars(block, textord_show_initial_words &&testing_on);
#ifndef GRAPHICS_DISABLED
    if (textord_show_initial_words && testing_on)
      overlap_picture_ops(TRUE);
#endif
    compute_rows_pitch(block,
                       block_index,
                       textord_debug_pitch_test &&testing_on);
  }
}

void compute_fixed_pitch	(	ICOORD	page_tr,
		TO_BLOCK_LIST *	port_blocks,
		float	gradient,
		FCOORD	rotation,
		BOOL8	testing_on
	)

Determine pitch.

Decide whether each row is fixed pitch individually. Correlate definite and uncertain results to obtain an individual result for each row in the TO_ROW class.

Definition at line 75 of file topitch.cpp.

References compute_block_pitch(), create_to_win(), fix_row_pitch(), NO_WINDOW, NULL, overlap_picture_ops, print_block_counts(), rotation, to_win, tprintf(), TRUE, try_block_fixed(), try_doc_fixed(), and try_rows_fixed().

Referenced by make_words().

                          {
  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

#ifndef GRAPHICS_DISABLED
  if (textord_show_initial_words && testing_on) {
    if (to_win == NO_WINDOW)
      create_to_win(page_tr);
  }
#endif

  block_it.set_to_list (port_blocks);
  block_index = 1;
  for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
  block_it.forward ()) {
    block = block_it.data ();
    compute_block_pitch(block, rotation, block_index, testing_on);
    block_index++;
  }

  if (!try_doc_fixed (page_tr, port_blocks, gradient)) {
    block_index = 1;
    for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
    block_it.forward ()) {
      block = block_it.data ();
      if (!try_block_fixed (block, block_index))
        try_rows_fixed(block, block_index, testing_on);
      block_index++;
    }
  }

  block_index = 1;
  for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
  block_it.forward ()) {
    block = block_it.data ();
    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 ();
      fix_row_pitch(row, block, port_blocks, row_index, block_index);
      row_index++;
    }
    if (testing_on
      && (textord_debug_pitch_test && block->block->text_region () != NULL
    || textord_blocksall_fixed || textord_blocksall_prop)) {
      tprintf ("Corr:");
      print_block_counts(block, block_index);
    }
    block_index++;
  }
#ifndef GRAPHICS_DISABLED
  if (textord_show_initial_words && testing_on) {
    overlap_picture_ops(TRUE);
  }
#endif
}

float compute_pitch_sd	(	TO_ROW *	row,
		STATS *	projection,
		INT16	projection_left,
		INT16	projection_right,
		float	space_size,
		float	initial_pitch,
		float &	sp_sd,
		INT16 &	mid_cuts,
		ICOORDELT_LIST *	row_cells,
		BOOL8	testing_on,
		INT16	start,
		INT16	end
	)

Find fp cells.

Use a dp algorithm to fit the character cells and return the sd of the cell size over the row.

Definition at line 1412 of file topitch.cpp.

References blob_count, TO_ROW::blob_list(), box_next(), check_pitch_sync(), check_pitch_sync2(), compute_pitch_sd2(), CORAL, GOLDENROD, TO_ROW::intercept(), BOX::left(), STATS::plot(), plot_fp_cells2(), projection, BOX::right(), seg_list, ICOORD::set_x(), to_win, BOX::top(), tprintf(), and TO_ROW::xheight.

Referenced by tune_row_pitch(), and tune_row_pitch2().

                        {
  INT16 occupation;              //no of cells in word.
                                 //blobs
  BLOBNBOX_IT blob_it = row->blob_list ();
  BLOBNBOX_IT start_it;          //start of word
  BLOBNBOX_IT plot_it;           //for plotting
  INT16 blob_count;              //no of blobs
  BOX blob_box;                  //bounding box
  BOX prev_box;                  //of super blob
  INT32 prev_right;              //of word sync
  int scale_factor;              //on scores for big words
  INT32 sp_count;                //spaces
  FPSEGPT_LIST seg_list;         //char cells
  FPSEGPT_IT seg_it;             //iterator
  INT16 segpos;                  //position of segment
  INT16 cellpos;                 //previous cell boundary
                                 //iterator
  ICOORDELT_IT cell_it = row_cells;
  ICOORDELT *cell;               //new cell
  double sqsum;                  //sum of squares
  double spsum;                  //of spaces
  double sp_var;                 //space error
  double word_sync;              //result for word
  INT32 total_count;             //total blobs

  if ((pitsync_linear_version & 3) > 1) {
    word_sync = compute_pitch_sd2 (row, projection, projection_left,
      projection_right, initial_pitch,
      occupation, mid_cuts, row_cells,
      testing_on, start, end);
    sp_sd = occupation;
    return word_sync;
  }
  mid_cuts = 0;
  cellpos = 0;
  total_count = 0;
  sqsum = 0;
  sp_count = 0;
  spsum = 0;
  prev_right = -1;
  if (blob_it.empty ())
    return space_size * 10;
#ifndef GRAPHICS_DISABLED
  if (testing_on && to_win > 0) {
    blob_box = blob_it.data ()->bounding_box ();
    projection->plot (to_win, projection_left,
      row->intercept (), 1.0f, -1.0f, CORAL);
  }
#endif
  start_it = blob_it;
  blob_count = 0;
  blob_box = box_next (&blob_it);//first blob
  blob_it.mark_cycle_pt ();
  do {
    for (; blob_count > 0; blob_count--)
      box_next(&start_it);
    do {
      prev_box = blob_box;
      blob_count++;
      blob_box = box_next (&blob_it);
    }
    while (!blob_it.cycled_list ()
      && blob_box.left () - prev_box.right () < space_size);
    plot_it = start_it;
    if (pitsync_linear_version & 3)
      word_sync =
        check_pitch_sync2 (&start_it, blob_count, (INT16) initial_pitch, 2,
        projection, projection_left, projection_right,
        row->xheight * textord_projection_scale,
        occupation, &seg_list, start, end);
    else
      word_sync =
        check_pitch_sync (&start_it, blob_count, (INT16) initial_pitch, 2,
        projection, &seg_list);
    if (testing_on) {
      tprintf ("Word ending at (%d,%d), len=%d, sync rating=%g, ",
        prev_box.right (), prev_box.top (),
        seg_list.length () - 1, word_sync);
      seg_it.set_to_list (&seg_list);
      for (seg_it.mark_cycle_pt (); !seg_it.cycled_list ();
      seg_it.forward ()) {
        if (seg_it.data ()->faked)
          tprintf ("(F)");
        tprintf ("%d, ", seg_it.data ()->position ());
        //          tprintf("C=%g, s=%g, sq=%g\n",
        //                  seg_it.data()->cost_function(),
        //                  seg_it.data()->sum(),
        //                  seg_it.data()->squares());
      }
      tprintf ("\n");
    }
#ifndef GRAPHICS_DISABLED
    if (textord_show_fixed_cuts && blob_count > 0 && to_win > 0)
      plot_fp_cells2(to_win, GOLDENROD, row, &seg_list);
#endif
    seg_it.set_to_list (&seg_list);
    if (prev_right >= 0) {
      sp_var = seg_it.data ()->position () - prev_right;
      sp_var -= floor (sp_var / initial_pitch + 0.5) * initial_pitch;
      sp_var *= sp_var;
      spsum += sp_var;
      sp_count++;
    }
    for (seg_it.mark_cycle_pt (); !seg_it.cycled_list (); seg_it.forward ()) {
      segpos = seg_it.data ()->position ();
      if (cell_it.empty () || segpos > cellpos + initial_pitch / 2) {
                                 //big gap
        while (!cell_it.empty () && segpos > cellpos + initial_pitch * 3 / 2) {
          cell = new ICOORDELT (cellpos + (INT16) initial_pitch, 0);
          cell_it.add_after_then_move (cell);
          cellpos += (INT16) initial_pitch;
        }
                                 //make new one
        cell = new ICOORDELT (segpos, 0);
        cell_it.add_after_then_move (cell);
        cellpos = segpos;
      }
      else if (segpos > cellpos - initial_pitch / 2) {
        cell = cell_it.data ();
                                 //average positions
        cell->set_x ((cellpos + segpos) / 2);
        cellpos = cell->x ();
      }
    }
    seg_it.move_to_last ();
    prev_right = seg_it.data ()->position ();
    if (textord_pitch_scalebigwords) {
      scale_factor = (seg_list.length () - 2) / 2;
      if (scale_factor < 1)
        scale_factor = 1;
    }
    else
      scale_factor = 1;
    sqsum += word_sync * scale_factor;
    total_count += (seg_list.length () - 1) * scale_factor;
    seg_list.clear ();
  }
  while (!blob_it.cycled_list ());
  sp_sd = sp_count > 0 ? sqrt (spsum / sp_count) : 0;
  return total_count > 0 ? sqrt (sqsum / total_count) : space_size * 10;
}

float compute_pitch_sd2	(	TO_ROW *	row,
		STATS *	projection,
		INT16	projection_left,
		INT16	projection_right,
		float	initial_pitch,
		INT16 &	occupation,
		INT16 &	mid_cuts,
		ICOORDELT_LIST *	row_cells,
		BOOL8	testing_on,
		INT16	start,
		INT16	end
	)

Find fp cells.

Use a dp algorithm to fit the character cells and return the sd of the cell size over the row.

Definition at line 1574 of file topitch.cpp.

References blob_count, TO_ROW::blob_list(), box_next(), check_pitch_sync2(), CORAL, GOLDENROD, TO_ROW::intercept(), STATS::plot(), plot_fp_cells2(), projection, BOX::right(), seg_list, to_win, BOX::top(), tprintf(), and TO_ROW::xheight.

Referenced by compute_pitch_sd().

                         {
                                 //blobs
  BLOBNBOX_IT blob_it = row->blob_list ();
  BLOBNBOX_IT plot_it;
  INT16 blob_count;              //no of blobs
  BOX blob_box;                  //bounding box
  FPSEGPT_LIST seg_list;         //char cells
  FPSEGPT_IT seg_it;             //iterator
  INT16 segpos;                  //position of segment
                                 //iterator
  ICOORDELT_IT cell_it = row_cells;
  ICOORDELT *cell;               //new cell
  double word_sync;              //result for word

  mid_cuts = 0;
  if (blob_it.empty ()) {
    occupation = 0;
    return initial_pitch * 10;
  }
#ifndef GRAPHICS_DISABLED
  if (testing_on && to_win > 0) {
    projection->plot (to_win, projection_left,
      row->intercept (), 1.0f, -1.0f, CORAL);
  }
#endif
  blob_count = 0;
  blob_it.mark_cycle_pt ();
  do {
                                 //first blob
    blob_box = box_next (&blob_it);
    blob_count++;
  }
  while (!blob_it.cycled_list ());
  plot_it = blob_it;
  word_sync = check_pitch_sync2 (&blob_it, blob_count, (INT16) initial_pitch,
    2, projection, projection_left,
    projection_right,
    row->xheight * textord_projection_scale,
    occupation, &seg_list, start, end);
  if (testing_on) {
    tprintf ("Row ending at (%d,%d), len=%d, sync rating=%g, ",
      blob_box.right (), blob_box.top (),
      seg_list.length () - 1, word_sync);
    seg_it.set_to_list (&seg_list);
    for (seg_it.mark_cycle_pt (); !seg_it.cycled_list (); seg_it.forward ()) {
      if (seg_it.data ()->faked)
        tprintf ("(F)");
      tprintf ("%d, ", seg_it.data ()->position ());
      //     tprintf("C=%g, s=%g, sq=%g\n",
      //             seg_it.data()->cost_function(),
      //             seg_it.data()->sum(),
      //             seg_it.data()->squares());
    }
    tprintf ("\n");
  }
#ifndef GRAPHICS_DISABLED
  if (textord_show_fixed_cuts && blob_count > 0 && to_win > 0)
    plot_fp_cells2(to_win, GOLDENROD, row, &seg_list);
#endif
  seg_it.set_to_list (&seg_list);
  for (seg_it.mark_cycle_pt (); !seg_it.cycled_list (); seg_it.forward ()) {
    segpos = seg_it.data ()->position ();
                                 //make new one
    cell = new ICOORDELT (segpos, 0);
    cell_it.add_after_then_move (cell);
    if (seg_it.at_last ())
      mid_cuts = seg_it.data ()->cheap_cuts ();
  }
  seg_list.clear ();
  return occupation > 0 ? sqrt (word_sync / occupation) : initial_pitch * 10;
}

BOOL8 compute_rows_pitch	(	TO_BLOCK *	block,
		INT32	block_index,
		BOOL8	testing_on
	)

Find line stats.

Decide whether each row is fixed pitch individually.

Definition at line 381 of file topitch.cpp.

References ASSERT_HOST, TO_ROW::compute_vertical_projection(), FALSE, find_row_pitch(), PITCH_DUNNO, row_pitch_stats(), and TO_ROW::xheight.

Referenced by compute_block_pitch().

                          {
  INT32 maxwidth;                //of spaces
  TO_ROW *row;                   //current row
  INT32 row_index;               //row number.
  float lower, upper;            //cluster thresholds
  TO_ROW_IT row_it = block->get_rows ();

  row_index = 1;
  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
    row = row_it.data ();
    ASSERT_HOST (row->xheight > 0);
    row->compute_vertical_projection ();
    maxwidth = (INT32) ceil (row->xheight * textord_words_maxspace);
    if (row_pitch_stats (row, maxwidth, testing_on)
      && find_row_pitch (row, maxwidth,
      textord_dotmatrix_gap + 1, block, block_index,
    row_index, testing_on)) {
      if (row->fixed_pitch == 0) {
        lower = row->pr_nonsp;
        upper = row->pr_space;
        row->space_size = upper;
        row->kern_size = lower;
      }
    }
    else {
      row->fixed_pitch = 0.0f;   //insufficient data
      row->pitch_decision = PITCH_DUNNO;
    }
    row_index++;
  }
  return FALSE;
}

void count_block_votes	(	TO_BLOCK *	block,
		INT32 &	def_fixed,
		INT32 &	def_prop,
		INT32 &	maybe_fixed,
		INT32 &	maybe_prop,
		INT32 &	corr_fixed,
		INT32 &	corr_prop,
		INT32 &	dunno
	)

Find line stats.

Count the number of rows in the block with each kind of pitch_decision.

Definition at line 694 of file topitch.cpp.

References PITCH_CORR_FIXED, PITCH_CORR_PROP, TO_ROW::pitch_decision, PITCH_DEF_FIXED, PITCH_DEF_PROP, PITCH_DUNNO, PITCH_MAYBE_FIXED, and PITCH_MAYBE_PROP.

Referenced by print_block_counts(), and try_rows_fixed().

                                     {
  TO_ROW *row;                   //current row
  TO_ROW_IT row_it = block->get_rows ();

  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
    row = row_it.data ();
    switch (row->pitch_decision) {
      case PITCH_DUNNO:
        dunno++;
        break;
      case PITCH_DEF_PROP:
        def_prop++;
        break;
      case PITCH_MAYBE_PROP:
        maybe_prop++;
        break;
      case PITCH_DEF_FIXED:
        def_fixed++;
        break;
      case PITCH_MAYBE_FIXED:
        maybe_fixed++;
        break;
      case PITCH_CORR_PROP:
        corr_prop++;
        break;
      case PITCH_CORR_FIXED:
        corr_fixed++;
        break;
    }
  }
}

BOOL8 count_pitch_stats	(	TO_ROW *	row,
		STATS *	gap_stats,
		STATS *	pitch_stats,
		float	initial_pitch,
		float	min_space,
		BOOL8	ignore_outsize,
		BOOL8	split_outsize,
		INT32	dm_gap
	)

Find lines.

Returns:

TRUE if there were any decent values to use.

Count up the gap and pitch stats on the block to see if it is fixed pitch. Blobs with gaps smaller than the lower threshold are assumed to be one. The larger threshold is the word gap threshold.

Definition at line 1098 of file topitch.cpp.

References STATS::add(), TO_ROW::blob_list(), STATS::clear(), FALSE, STATS::get_total(), BOX::left(), NULL, BOX::right(), and BOX::width().

Referenced by find_row_pitch().

                         {
  BOOL8 prev_valid;              //not word broken
  BLOBNBOX *blob;                //current blob
                                 //blobs
  BLOBNBOX_IT blob_it = row->blob_list ();
  INT32 prev_right;              //end of prev blob
  INT32 prev_centre;             //centre of previous blob
  INT32 x_centre;                //centre of this blob
  INT32 blob_width;              //width of blob
  INT32 width_units;             //no of widths in blob
  float width;                   //blob width
  BOX blob_box;                  //bounding box
  BOX joined_box;                //of super blob

  gap_stats->clear ();
  pitch_stats->clear ();
  if (blob_it.empty ())
    return FALSE;
  prev_valid = FALSE;
  prev_centre = 0;
  prev_right = 0;                //stop complier warning
  joined_box = blob_it.data ()->bounding_box ();
  do {
    blob_it.forward ();
    blob = blob_it.data ();
    if (!blob->joined_to_prev ()) {
      blob_box = blob->bounding_box ();
      if (blob_box.left () - joined_box.right () < dm_gap
        && !blob_it.at_first ()
        || blob->cblob () == NULL && blob->blob () == NULL)
        joined_box += blob_box;  //merge blobs
      else {
        blob_width = joined_box.width ();
        if (split_outsize) {
          width_units =
            (INT32) floor ((float) blob_width / initial_pitch + 0.5);
          if (width_units < 1)
            width_units = 1;
          width_units--;
        }
        else if (ignore_outsize) {
          width = (float) blob_width / initial_pitch;
          width_units = width < 1 + words_default_fixed_limit
            && width > 1 - words_default_fixed_limit ? 0 : -1;
        }
        else
          width_units = 0;       //everything in
        x_centre = (INT32) (joined_box.left ()
          + (blob_width -
          width_units * initial_pitch) / 2);
        if (prev_valid && width_units >= 0) {
          // if (width_units>0)
          // {
          //   tprintf("wu=%d, width=%d, xc=%d, adding %d\n",
          //         width_units,blob_width,x_centre,x_centre-prev_centre);
          // }
          gap_stats->add (joined_box.left () - prev_right, 1);
          pitch_stats->add (x_centre - prev_centre, 1);
        }
        prev_centre = (INT32) (x_centre + width_units * initial_pitch);
        prev_right = joined_box.right ();
        prev_valid = blob_box.left () - joined_box.right () < min_space;
        prev_valid = prev_valid && width_units >= 0;
        joined_box = blob_box;
      }
    }
  }
  while (!blob_it.at_first ());
  return gap_stats->get_total () >= 3;
}

void find_repeated_chars	(	TO_BLOCK *	block,
		BOOL8	testing_on
	)

Search for equal chars.

Find 4 or more adjacent chars which are the same and put them into words in advance of fixed pitch checking and word generation.

Definition at line 1812 of file topitch.cpp.

References TO_ROW::blob_list(), BOX::bottom(), WERD::bounding_box(), compare_blobs(), FALSE, INT_HOLLOW, interior_style, BOX::left(), make_real_word(), MAX_INT16, NULL, perimeter_color_index, rectangle, RED, TO_ROW::rep_words, BOX::right(), WERD::set_flag(), to_win, BOX::top(), tprintf(), TRUE, W_DONT_CHOP, and W_REP_CHAR.

Referenced by compute_block_pitch().

                          {
  BOOL8 bol;                     //start of line
  TO_ROW *row;                   //current row
  TO_ROW_IT row_it = block->get_rows ();
  ROW *real_row;                 //output row
  WERD_IT word_it;               //new words
  WERD *word;                    //new word
  BLOBNBOX *bblob;               //current blob
  BLOBNBOX *nextblob;            //neighbour to compare
  BLOBNBOX_IT box_it;            //iterator
  BLOBNBOX_IT search_it;         //forward search
  INT32 blobcount;               //no of neighbours
  INT32 matched_blobcount;       //no of matches
  INT32 blobindex;               //in row
  INT32 row_length;              //blobs in row
  INT32 width_change;            //max width change
  INT32 blob_width;              //required blob width
  INT32 space_width;             //required gap width
  INT32 prev_right;              //right edge of last blob
  float rating;                  //match rating
  PBLOB *pblob1;                 //polygonal blob
  PBLOB *pblob2;                 //second blob
  BOX word_box;                  //for plotting

  if (row_it.empty ())
    return;                      //empty block
  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
    row = row_it.data ();
    box_it.set_to_list (row->blob_list ());
    row_length = row->blob_list ()->length ();
    blobindex = 0;
    word_it.set_to_list (&row->rep_words);
    bol = TRUE;
    if (!box_it.empty ()) {
      real_row = new ROW (row,
        (INT16) block->kern_size,
        (INT16) block->space_size);
      do {
        bblob = box_it.data ();
        blobcount = 1;
        search_it = box_it;
        search_it.forward ();
        matched_blobcount = 1;
        width_change = MAX_INT16;
        blob_width = 0;
        space_width = 0;
        prev_right = bblob->bounding_box ().right ();
        if (bblob->bounding_box ().height () * 2 < row->xheight
          && !bblob->joined_to_prev ()
        && (bblob->blob () != NULL || bblob->cblob () != NULL)) {
          if (bblob->cblob () != NULL)
            pblob1 = new PBLOB (bblob->cblob (), row->xheight);
          else
            pblob1 = bblob->blob ();

          rating = 0.0f;
          while (rating < textord_repeat_rating
            && blobindex + blobcount < row_length
            && ((nextblob = search_it.data ())->blob () != NULL
            || nextblob->cblob () != NULL)
            && nextblob->bounding_box ().height () * 2 <
          row->xheight) {
            if (blobcount == 1) {
              space_width = nextblob->bounding_box ().left ()
                - bblob->bounding_box ().right ();
              blob_width = bblob->bounding_box ().width ();
              width_change =
                blob_width >
                space_width ? blob_width : space_width;
              width_change =
                (INT32) (width_change *
                textord_repch_width_variance);
              if (width_change < 3)
                width_change = 3;
            }
            if (nextblob->bounding_box ().width () >
              blob_width + width_change
              || nextblob->bounding_box ().width () <
              blob_width - width_change
              || nextblob->bounding_box ().left () - prev_right >
              space_width + width_change
              || nextblob->bounding_box ().left () - prev_right <
            space_width - width_change) {
              if (testing_on)
                tprintf
                  ("Repch terminated:bw=%d, sw=%d, wc=%d, pr=%d, nb=(%d,%d)\n",
                  blob_width, space_width, width_change,
                  prev_right, nextblob->bounding_box ().left (),
                  nextblob->bounding_box ().right ());
              break;             //not good enough
            }
            if (nextblob->blob () != NULL)
              rating = compare_blobs (pblob1, real_row,
                nextblob->blob (), real_row);
            else {
              pblob2 =
                new PBLOB (nextblob->cblob (), row->xheight);
              rating =
                compare_blobs(pblob1, real_row, pblob2, real_row);
              delete pblob2;
            }
            if (rating < textord_repeat_rating) {
              //    if (testing_on)
              //       tprintf("Blob at (%d,%d)->(%d,%d) had rating %g\n",
              //               nextblob->bounding_box().left(),
              //               nextblob->bounding_box().bottom(),
              //               nextblob->bounding_box().right(),
              //               nextblob->bounding_box().top(),
              //               rating);
              blobcount++;
              search_it.forward ();
              matched_blobcount++;
              while (blobindex + blobcount < row_length
              && search_it.data ()->joined_to_prev ()) {
                search_it.forward ();
                blobcount++;     //suck in joined bits
              }
            }
            prev_right = nextblob->bounding_box ().right ();
          }
          if (bblob->cblob () != NULL)
            delete pblob1;

          if (matched_blobcount >= textord_repeat_threshold) {
            word =
              make_real_word (&box_it, blobcount, bol, FALSE, FALSE,
              1);
#ifndef GRAPHICS_DISABLED
            if (testing_on) {
              word_box = word->bounding_box ();
              tprintf
                ("Found repeated word of %d blobs (%d matched) from (%d,%d)->(%d,%d)\n",
                blobcount, matched_blobcount, word_box.left (),
                word_box.bottom (), word_box.right (),
                word_box.top ());
              perimeter_color_index(to_win, RED);
              interior_style(to_win, INT_HOLLOW, TRUE);
              rectangle (to_win, word_box.left (),
                word_box.bottom (), word_box.right (),
                word_box.top ());
            }
#endif
            word->set_flag (W_REP_CHAR, TRUE);
            word->set_flag (W_DONT_CHOP, TRUE);
            word_it.add_after_then_move (word);
            blobindex += blobcount;
          }
        }
        bol = FALSE;
        box_it.forward ();       //next one
        blobindex++;
      }
                                 //until all done
      while (!box_it.at_first ());
      delete real_row;
    }
  }
}

BOOL8 find_row_pitch	(	TO_ROW *	row,
		INT32	maxwidth,
		INT32	dm_gap,
		TO_BLOCK *	block,
		INT32	block_index,
		INT32	row_index,
		BOOL8	testing_on
	)

Find lines.

Check to see if this row could be fixed pitch using the given spacings. Blobs with gaps smaller than the lower threshold are assumed to be one. The larger threshold is the word gap threshold.

Definition at line 872 of file topitch.cpp.

References STATS::clear(), count_pitch_stats(), FALSE, TO_ROW::fixed_pitch, TO_ROW::fp_nonsp, TO_ROW::fp_space, STATS::ile(), NULL, pitch, PITCH_DUNNO, PITCH_MAYBE_FIXED, PITCH_MAYBE_PROP, tprintf(), TRUE, and TO_ROW::xheight.

Referenced by compute_rows_pitch().

                      {
  BOOL8 used_dm_model;           //looks lik dot matrix
  float min_space;               //estimate threshold
  float non_space;               //gap size
  float gap_iqr;                 //interquartile range
  float pitch_iqr;
  float dm_gap_iqr;              //interquartile range
  float dm_pitch_iqr;
  float dm_pitch;                //pitch with dm on
  float pitch;                   //revised estimate
  float initial_pitch;           //guess at pitch
  STATS gap_stats (0, maxwidth);
                                 //centre-centre
  STATS pitch_stats (0, maxwidth);

  row->fixed_pitch = 0.0f;
  initial_pitch = row->fp_space;
  if (initial_pitch > row->xheight * (1 + words_default_fixed_limit))
    initial_pitch = row->xheight;//keep pitch decent
  non_space = row->fp_nonsp;
  if (non_space > initial_pitch)
    non_space = initial_pitch;
  min_space = (initial_pitch + non_space) / 2;

  if (!count_pitch_stats (row, &gap_stats, &pitch_stats,
  initial_pitch, min_space, TRUE, FALSE, dm_gap)) {
    dm_gap_iqr = 0.0001;
    dm_pitch_iqr = maxwidth * 2.0f;
    dm_pitch = initial_pitch;
  }
  else {
    dm_gap_iqr = gap_stats.ile (0.75) - gap_stats.ile (0.25);
    dm_pitch_iqr = pitch_stats.ile (0.75) - pitch_stats.ile (0.25);
    dm_pitch = pitch_stats.ile (0.5);
  }
  gap_stats.clear ();
  pitch_stats.clear ();
  if (!count_pitch_stats (row, &gap_stats, &pitch_stats,
  initial_pitch, min_space, TRUE, FALSE, 0)) {
    gap_iqr = 0.0001;
    pitch_iqr = maxwidth * 3.0f;
  }
  else {
    gap_iqr = gap_stats.ile (0.75) - gap_stats.ile (0.25);
    pitch_iqr = pitch_stats.ile (0.75) - pitch_stats.ile (0.25);
    if (testing_on)
      tprintf
        ("First fp iteration:initial_pitch=%g, gap_iqr=%g, pitch_iqr=%g, pitch=%g\n",
        initial_pitch, gap_iqr, pitch_iqr, pitch_stats.ile (0.5));
    initial_pitch = pitch_stats.ile (0.5);
    if (min_space > initial_pitch
      && count_pitch_stats (row, &gap_stats, &pitch_stats,
    initial_pitch, initial_pitch, TRUE, FALSE, 0)) {
      min_space = initial_pitch;
      gap_iqr = gap_stats.ile (0.75) - gap_stats.ile (0.25);
      pitch_iqr = pitch_stats.ile (0.75) - pitch_stats.ile (0.25);
      if (testing_on)
        tprintf
          ("Revised fp iteration:initial_pitch=%g, gap_iqr=%g, pitch_iqr=%g, pitch=%g\n",
          initial_pitch, gap_iqr, pitch_iqr, pitch_stats.ile (0.5));
      initial_pitch = pitch_stats.ile (0.5);
    }
  }
  if (textord_debug_pitch_metric)
    tprintf ("Blk=%d:Row=%d:%c:p_iqr=%g:g_iqr=%g:dm_p_iqr=%g:dm_g_iqr=%g:%c:",
      block_index, row_index,
      block->block->text_region () != NULL ?
      (block->block->text_region ()->is_prop ()? 'P' : 'F') : 'X',
    pitch_iqr, gap_iqr, dm_pitch_iqr, dm_gap_iqr,
    pitch_iqr > maxwidth && dm_pitch_iqr > maxwidth ? 'D'
    : (pitch_iqr * dm_gap_iqr <=
    dm_pitch_iqr * gap_iqr ? 'S' : 'M'));
  if (pitch_iqr > maxwidth && dm_pitch_iqr > maxwidth) {
    row->pitch_decision = PITCH_DUNNO;
    if (textord_debug_pitch_metric)
      tprintf ("\n");
    return FALSE;                //insufficient data
  }
  if (pitch_iqr * dm_gap_iqr <= dm_pitch_iqr * gap_iqr) {
    if (testing_on)
      tprintf
        ("Choosing non dm version:pitch_iqr=%g, gap_iqr=%g, dm_pitch_iqr=%g, dm_gap_iqr=%g\n",
        pitch_iqr, gap_iqr, dm_pitch_iqr, dm_gap_iqr);
    gap_iqr = gap_stats.ile (0.75) - gap_stats.ile (0.25);
    pitch_iqr = pitch_stats.ile (0.75) - pitch_stats.ile (0.25);
    pitch = pitch_stats.ile (0.5);
    used_dm_model = FALSE;
  }
  else {
    if (testing_on)
      tprintf
        ("Choosing dm version:pitch_iqr=%g, gap_iqr=%g, dm_pitch_iqr=%g, dm_gap_iqr=%g\n",
        pitch_iqr, gap_iqr, dm_pitch_iqr, dm_gap_iqr);
    gap_iqr = dm_gap_iqr;
    pitch_iqr = dm_pitch_iqr;
    pitch = dm_pitch;
    used_dm_model = TRUE;
  }
  if (textord_debug_pitch_metric) {
    tprintf ("rev_p_iqr=%g:rev_g_iqr=%g:pitch=%g:",
      pitch_iqr, gap_iqr, pitch);
    tprintf ("p_iqr/g=%g:p_iqr/x=%g:iqr_res=%c:",
      pitch_iqr / gap_iqr, pitch_iqr / block->xheight,
      pitch_iqr < gap_iqr * textord_fpiqr_ratio
      && pitch_iqr < block->xheight * textord_max_pitch_iqr
      && pitch < block->xheight * textord_words_default_maxspace
      ? 'F' : 'P');
  }
  if (pitch_iqr < gap_iqr * textord_fpiqr_ratio
    && pitch_iqr < block->xheight * textord_max_pitch_iqr
    && pitch < block->xheight * textord_words_default_maxspace)
    row->pitch_decision = PITCH_MAYBE_FIXED;
  else
    row->pitch_decision = PITCH_MAYBE_PROP;
  row->fixed_pitch = pitch;
  row->kern_size = gap_stats.ile (0.5);
  row->min_space = (INT32) (row->fixed_pitch + non_space) / 2;
  if (row->min_space > row->fixed_pitch)
    row->min_space = (INT32) row->fixed_pitch;
  row->max_nonspace = row->min_space;
  row->space_size = row->fixed_pitch;
  row->space_threshold = (row->max_nonspace + row->min_space) / 2;
  row->used_dm_model = used_dm_model;
  return TRUE;
}

void fix_row_pitch	(	TO_ROW *	bad_row,
		TO_BLOCK *	bad_block,
		TO_BLOCK_LIST *	blocks,
		INT32	row_target,
		INT32	block_target
	)

Get some value.

Get a pitch_decision for this row by voting among similar rows in the block, then similar rows over all the page, or any other rows at all.

Definition at line 149 of file topitch.cpp.

References STATS::add(), TO_ROW::all_caps, TO_ROW::ascrise, TO_ROW::char_cells, FALSE, TO_ROW::fixed_pitch, STATS::ile(), TO_ROW::kern_size, TO_ROW::max_nonspace, TO_ROW::min_space, NULL, PITCH_CORR_FIXED, PITCH_CORR_PROP, TO_ROW::pitch_decision, PITCH_DEF_FIXED, PITCH_DEF_PROP, PITCH_MAYBE_FIXED, PITCH_MAYBE_PROP, TO_ROW::projection, STATS::set_range(), TO_ROW::space_size, TO_ROW::space_threshold, tprintf(), tune_row_pitch(), and TO_ROW::xheight.

Referenced by compute_fixed_pitch().

                    {
  const char *res_string;        //decision on line
  INT16 mid_cuts;
  int block_votes;               //votes in block
  int like_votes;                //votes over page
  int other_votes;               //votes of unlike blocks
  int block_index;               //number of block
  int row_index;                 //number of row
  int maxwidth;                  //max pitch
  TO_BLOCK_IT block_it = blocks; //block iterator
  TO_ROW_IT row_it;
  TO_BLOCK *block;               //current block
  TO_ROW *row;                   //current row
  float sp_sd;                   //space deviation
  STATS block_stats;             //pitches in block
  STATS like_stats;              //pitches in page

  block_votes = like_votes = other_votes = 0;
  maxwidth = (INT32) ceil (bad_row->xheight * textord_words_maxspace);
  if (bad_row->pitch_decision != PITCH_DEF_FIXED
  && bad_row->pitch_decision != PITCH_DEF_PROP) {
    block_stats.set_range (0, maxwidth);
    like_stats.set_range (0, maxwidth);
    block_index = 1;
    for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
    block_it.forward ()) {
      block = block_it.data ();
      row_index = 1;
      row_it.set_to_list (block->get_rows ());
      for (row_it.mark_cycle_pt (); !row_it.cycled_list ();
      row_it.forward ()) {
        row = row_it.data ();
        if (bad_row->all_caps
          && row->xheight + row->ascrise
          <
          (bad_row->xheight + bad_row->ascrise) * (1 +
          textord_pitch_rowsimilarity)
          && row->xheight + row->ascrise >
          (bad_row->xheight + bad_row->ascrise) * (1 -
          textord_pitch_rowsimilarity)
          || !bad_row->all_caps
          && row->xheight <
          bad_row->xheight * (1 + textord_pitch_rowsimilarity)
          && row->xheight >
        bad_row->xheight * (1 - textord_pitch_rowsimilarity)) {
          if (block_index == block_target) {
            if (row->pitch_decision == PITCH_DEF_FIXED) {
              block_votes += textord_words_veto_power;
              block_stats.add ((INT32) row->fixed_pitch,
                textord_words_veto_power);
            }
            else if (row->pitch_decision == PITCH_MAYBE_FIXED
            || row->pitch_decision == PITCH_CORR_FIXED) {
              block_votes++;
              block_stats.add ((INT32) row->fixed_pitch, 1);
            }
            else if (row->pitch_decision == PITCH_DEF_PROP)
              block_votes -= textord_words_veto_power;
            else if (row->pitch_decision == PITCH_MAYBE_PROP
              || row->pitch_decision == PITCH_CORR_PROP)
              block_votes--;
          }
          else {
            if (row->pitch_decision == PITCH_DEF_FIXED) {
              like_votes += textord_words_veto_power;
              like_stats.add ((INT32) row->fixed_pitch,
                textord_words_veto_power);
            }
            else if (row->pitch_decision == PITCH_MAYBE_FIXED
            || row->pitch_decision == PITCH_CORR_FIXED) {
              like_votes++;
              like_stats.add ((INT32) row->fixed_pitch, 1);
            }
            else if (row->pitch_decision == PITCH_DEF_PROP)
              like_votes -= textord_words_veto_power;
            else if (row->pitch_decision == PITCH_MAYBE_PROP
              || row->pitch_decision == PITCH_CORR_PROP)
              like_votes--;
          }
        }
        else {
          if (row->pitch_decision == PITCH_DEF_FIXED)
            other_votes += textord_words_veto_power;
          else if (row->pitch_decision == PITCH_MAYBE_FIXED
            || row->pitch_decision == PITCH_CORR_FIXED)
            other_votes++;
          else if (row->pitch_decision == PITCH_DEF_PROP)
            other_votes -= textord_words_veto_power;
          else if (row->pitch_decision == PITCH_MAYBE_PROP
            || row->pitch_decision == PITCH_CORR_PROP)
            other_votes--;
        }
        row_index++;
      }
      block_index++;
    }
    if (block_votes > textord_words_veto_power) {
      bad_row->fixed_pitch = block_stats.ile (0.5);
      bad_row->pitch_decision = PITCH_CORR_FIXED;
    }
    else if (block_votes <= textord_words_veto_power && like_votes > 0) {
      bad_row->fixed_pitch = like_stats.ile (0.5);
      bad_row->pitch_decision = PITCH_CORR_FIXED;
    }
    else {
      bad_row->pitch_decision = PITCH_CORR_PROP;
      #ifndef SECURE_NAMES
      if (block_votes == 0 && like_votes == 0 && other_votes > 0
        && (textord_debug_pitch_test || textord_debug_pitch_metric))
        tprintf
          ("Warning:row %d of block %d set prop with no like rows against trend\n",
          row_target, block_target);
      #endif
    }
  }
  if (textord_debug_pitch_metric) {
    tprintf (":b_votes=%d:l_votes=%d:o_votes=%d",
      block_votes, like_votes, other_votes);
    if (bad_row->pitch_decision == PITCH_CORR_PROP
    || bad_row->pitch_decision == PITCH_DEF_PROP) {
      res_string = bad_block->block->text_region () != NULL ?
        (bad_block->block->text_region ()->
        is_prop ()? "CP" : "WP") : "XP";
    }
    else {
      res_string = bad_block->block->text_region () != NULL ?
        (bad_block->block->text_region ()->
        is_prop ()? "WF" : "CF") : "XF";
    }
    tprintf (":Blk=%d:Row=%d:%c:",
      block_target, row_target,
      bad_block->block->text_region () != NULL ?
      (bad_block->block->text_region ()->
      is_prop ()? 'P' : 'F') : 'X');
    tprintf ("x=%g:asc=%g:corr_res=%s\n", bad_row->xheight,
      bad_row->ascrise, res_string);
  }
  if (textord_pitch_cheat && bad_block->block->text_region () != NULL)
    bad_row->pitch_decision =
      bad_block->block->text_region ()->
      is_prop ()? PITCH_CORR_PROP : PITCH_CORR_FIXED;
  if (bad_row->pitch_decision == PITCH_CORR_FIXED) {
    if (bad_row->fixed_pitch < textord_min_xheight) {
      if (block_votes > 0)
        bad_row->fixed_pitch = block_stats.ile (0.5);
      else if (block_votes == 0 && like_votes > 0)
        bad_row->fixed_pitch = like_stats.ile (0.5);
      else {
        tprintf
          ("Warning:guessing pitch as xheight on row %d, block %d\n",
          row_target, block_target);
        bad_row->fixed_pitch = bad_row->xheight;
      }
    }
    if (bad_row->fixed_pitch < textord_min_xheight)
      bad_row->fixed_pitch = (float) textord_min_xheight;
    bad_row->kern_size = bad_row->fixed_pitch / 4;
    bad_row->min_space = (INT32) (bad_row->fixed_pitch * 0.6);
    bad_row->max_nonspace = (INT32) (bad_row->fixed_pitch * 0.4);
    bad_row->space_threshold =
      (bad_row->min_space + bad_row->max_nonspace) / 2;
    bad_row->space_size = bad_row->fixed_pitch;
    if (bad_row->char_cells.empty ())
      tune_row_pitch (bad_row, &bad_row->projection,
        bad_row->projection_left, bad_row->projection_right,
        (bad_row->fixed_pitch +
        bad_row->max_nonspace * 3) / 4, bad_row->fixed_pitch,
        sp_sd, mid_cuts, &bad_row->char_cells, FALSE);
  }
  else if (bad_row->pitch_decision == PITCH_CORR_PROP
  || bad_row->pitch_decision == PITCH_DEF_PROP) {
    bad_row->fixed_pitch = 0.0f;
    bad_row->char_cells.clear ();
  }
}

BOOL8 fixed_pitch_row	(	TO_ROW *	row,
		INT32	block_index
	)

Find lines.

Check to see if this row could be fixed pitch using the given spacings. Blobs with gaps smaller than the lower threshold are assumed to be one. The larger threshold is the word gap threshold.

Note:

Major changes for v1.03

Definition at line 1015 of file topitch.cpp.

References TO_ROW::all_caps, TO_ROW::char_cells, TO_ROW::fixed_pitch, TO_ROW::fp_nonsp, TO_ROW::pitch_decision, PITCH_DEF_FIXED, PITCH_DEF_PROP, PITCH_DUNNO, PITCH_MAYBE_FIXED, PITCH_MAYBE_PROP, TO_ROW::projection, TO_ROW::projection_left, TO_ROW::projection_right, tprintf(), TRUE, tune_row_pitch(), and TO_ROW::used_dm_model.

Referenced by try_rows_fixed().

                       {
  const char *res_string;        //pitch result
  INT16 mid_cuts;                //no of cheap cuts
  float non_space;               //gap size
  float pitch_sd;                //error on pitch
  float sp_sd;                   //space sd

  non_space = row->fp_nonsp;
  if (non_space > row->fixed_pitch)
    non_space = row->fixed_pitch;
  if (textord_all_prop) {
    // Set the decision to definitely proportional.
    pitch_sd = textord_words_def_prop * row->fixed_pitch;
    row->pitch_decision = PITCH_DEF_PROP;
  } else {
    pitch_sd = tune_row_pitch (row, &row->projection, row->projection_left,
                               row->projection_right,
                               (row->fixed_pitch + non_space * 3) / 4,
                               row->fixed_pitch, sp_sd, mid_cuts,
                               &row->char_cells,
                               block_index == textord_debug_block);
    if (pitch_sd < textord_words_pitchsd_threshold * row->fixed_pitch
      && ((pitsync_linear_version & 3) < 3
      || (pitsync_linear_version & 3) >= 3 && (row->used_dm_model
      || sp_sd > 20
      || pitch_sd == 0
    && sp_sd > 10))) {
      if (pitch_sd < textord_words_def_fixed * row->fixed_pitch
        && !row->all_caps
        && ((pitsync_linear_version & 3) < 3 || sp_sd > 20))
        row->pitch_decision = PITCH_DEF_FIXED;
      else
        row->pitch_decision = PITCH_MAYBE_FIXED;
    }
    else if ((pitsync_linear_version & 3) < 3
      || sp_sd > 20
      || mid_cuts > 0
      || pitch_sd >= textord_words_pitchsd_threshold * row->fixed_pitch) {
      if (pitch_sd < textord_words_def_prop * row->fixed_pitch)
        row->pitch_decision = PITCH_MAYBE_PROP;
      else
        row->pitch_decision = PITCH_DEF_PROP;
    }
    else
      row->pitch_decision = PITCH_DUNNO;
  }

  if (textord_debug_pitch_metric) {
    res_string = "??";
    switch (row->pitch_decision) {
      case PITCH_DEF_PROP:
        res_string = "DP";
        break;
      case PITCH_MAYBE_PROP:
        res_string = "MP";
        break;
      case PITCH_DEF_FIXED:
        res_string = "DF";
        break;
      case PITCH_MAYBE_FIXED:
        res_string = "MF";
      default:
        res_string = "??";
    }
    tprintf (":sd/p=%g:occ=%g:init_res=%s\n",
      pitch_sd / row->fixed_pitch, sp_sd, res_string);
  }
  return TRUE;
}

void plot_fp_word	(	TO_BLOCK *	block,
		float	pitch,
		float	nonspace
	)

Draw block of words.

Plot a block of words as if fixed pitch.

Definition at line 1981 of file topitch.cpp.

References TO_ROW::max_nonspace, TO_ROW::min_space, plot_word_decisions(), TO_ROW::space_threshold, and to_win.

                   {
  TO_ROW *row;                   //current row
  TO_ROW_IT row_it = block->get_rows ();

  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
    row = row_it.data ();
    row->min_space = (INT32) ((pitch + nonspace) / 2);
    row->max_nonspace = row->min_space;
    row->space_threshold = row->min_space;
    plot_word_decisions (to_win, (INT16) pitch, row);
  }
}

void print_block_counts	(	TO_BLOCK *	block,
		INT32	block_index
	)

Print line stats.

Count up how many rows have what decision and print the results.

Definition at line 650 of file topitch.cpp.

References count_block_votes(), NULL, and tprintf().

Referenced by compute_fixed_pitch(), and try_rows_fixed().

                         {
  INT32 def_fixed = 0;           //counters
  INT32 def_prop = 0;
  INT32 maybe_fixed = 0;
  INT32 maybe_prop = 0;
  INT32 dunno = 0;
  INT32 corr_fixed = 0;
  INT32 corr_prop = 0;

  count_block_votes(block,
                    def_fixed,
                    def_prop,
                    maybe_fixed,
                    maybe_prop,
                    corr_fixed,
                    corr_prop,
                    dunno);
  tprintf ("Block %d has (%d,%d,%d)",
    block_index, def_fixed, maybe_fixed, corr_fixed);
  if ((textord_blocksall_prop
    || block->block->text_region () != NULL
    && block->block->text_region ()->is_prop ()) && (def_fixed
    || maybe_fixed
    || corr_fixed))
    tprintf (" (Wrongly)");
  tprintf (" fixed, (%d,%d,%d)", def_prop, maybe_prop, corr_prop);
  if ((textord_blocksall_fixed
    || block->block->text_region () != NULL
    && !block->block->text_region ()->is_prop ()) && (def_prop
    || maybe_prop
    || corr_prop))
    tprintf (" (Wrongly)");
  tprintf (" prop, %d dunno\n", dunno);
}

void print_pitch_sd	(	TO_ROW *	row,
		STATS *	projection,
		INT16	projection_left,
		INT16	projection_right,
		float	space_size,
		float	initial_pitch
	)

Print fp cells.

Use a dp algorithm to fit the character cells and return the sd of the cell size over the row.

Definition at line 1665 of file topitch.cpp.

References TO_ROW::all_caps, blob_count, TO_ROW::blob_list(), box_next(), check_pitch_sync2(), CORAL, TO_ROW::fixed_pitch, BOX::left(), NO_WINDOW, plot_fp_cells2(), projection, BOX::right(), seg_list, to_win, tprintf(), and TO_ROW::xheight.

Referenced by tune_row_pitch(), and tune_row_pitch2().

                     {
  const char *res2;              //pitch result
  INT16 occupation;              //used cells
  float sp_sd;                   //space sd
                                 //blobs
  BLOBNBOX_IT blob_it = row->blob_list ();
  BLOBNBOX_IT start_it;          //start of word
  BLOBNBOX_IT row_start;         //start of row
  INT16 blob_count;              //no of blobs
  INT16 total_blob_count;        //total blobs in line
  BOX blob_box;                  //bounding box
  BOX prev_box;                  //of super blob
  INT32 prev_right;              //of word sync
  int scale_factor;              //on scores for big words
  INT32 sp_count;                //spaces
  FPSEGPT_LIST seg_list;         //char cells
  FPSEGPT_IT seg_it;             //iterator
  double sqsum;                  //sum of squares
  double spsum;                  //of spaces
  double sp_var;                 //space error
  double word_sync;              //result for word
  double total_count;            //total cuts

  if (blob_it.empty ())
    return;
  row_start = blob_it;
  total_blob_count = 0;

  total_count = 0;
  sqsum = 0;
  sp_count = 0;
  spsum = 0;
  prev_right = -1;
  blob_it = row_start;
  start_it = blob_it;
  blob_count = 0;
  blob_box = box_next (&blob_it);//first blob
  blob_it.mark_cycle_pt ();
  do {
    for (; blob_count > 0; blob_count--)
      box_next(&start_it);
    do {
      prev_box = blob_box;
      blob_count++;
      blob_box = box_next (&blob_it);
    }
    while (!blob_it.cycled_list ()
      && blob_box.left () - prev_box.right () < space_size);
    word_sync =
      check_pitch_sync2 (&start_it, blob_count, (INT16) initial_pitch, 2,
      projection, projection_left, projection_right,
      row->xheight * textord_projection_scale,
      occupation, &seg_list, 0, 0);
    total_blob_count += blob_count;
    seg_it.set_to_list (&seg_list);
    if (prev_right >= 0) {
      sp_var = seg_it.data ()->position () - prev_right;
      sp_var -= floor (sp_var / initial_pitch + 0.5) * initial_pitch;
      sp_var *= sp_var;
      spsum += sp_var;
      sp_count++;
    }
    seg_it.move_to_last ();
    prev_right = seg_it.data ()->position ();
    if (textord_pitch_scalebigwords) {
      scale_factor = (seg_list.length () - 2) / 2;
      if (scale_factor < 1)
        scale_factor = 1;
    }
    else
      scale_factor = 1;
    sqsum += word_sync * scale_factor;
    total_count += (seg_list.length () - 1) * scale_factor;
    seg_list.clear ();
  }
  while (!blob_it.cycled_list ());
  sp_sd = sp_count > 0 ? sqrt (spsum / sp_count) : 0;
  word_sync = total_count > 0 ? sqrt (sqsum / total_count) : space_size * 10;
  tprintf ("new_sd=%g:sd/p=%g:new_sp_sd=%g:res=%c:",
    word_sync, word_sync / initial_pitch, sp_sd,
    word_sync < textord_words_pitchsd_threshold * initial_pitch
    ? 'F' : 'P');

  start_it = row_start;
  blob_it = row_start;
  word_sync =
    check_pitch_sync2 (&blob_it, total_blob_count, (INT16) initial_pitch, 2,
    projection, projection_left, projection_right,
    row->xheight * textord_projection_scale, occupation,
    &seg_list, 0, 0);
  if (occupation > 1)
    word_sync /= occupation;
  word_sync = sqrt (word_sync);

#ifndef GRAPHICS_DISABLED
  if (textord_show_row_cuts && to_win != NO_WINDOW)
    plot_fp_cells2(to_win, CORAL, row, &seg_list);
#endif
  seg_list.clear ();
  if (word_sync < textord_words_pitchsd_threshold * initial_pitch) {
    if (word_sync < textord_words_def_fixed * initial_pitch
      && !row->all_caps)
      res2 = "DF";
    else
      res2 = "MF";
  }
  else
    res2 = word_sync < textord_words_def_prop * initial_pitch ? "MP" : "DP";
  tprintf
    ("row_sd=%g:sd/p=%g:res=%c:N=%d:res2=%s,init pitch=%g, row_pitch=%g, all_caps=%d\n",
    word_sync, word_sync / initial_pitch,
    word_sync < textord_words_pitchsd_threshold * initial_pitch ? 'F' : 'P',
    occupation, res2, initial_pitch, row->fixed_pitch, row->all_caps);
}

BOOL8 row_pitch_stats	(	TO_ROW *	row,
		INT32	maxwidth,
		BOOL8	testing_on
	)

Find line stats.

Decide whether each row is fixed pitch individually.

Definition at line 740 of file topitch.cpp.

References STATS::add(), TO_ROW::blob_list(), BLOCK_STATS_CLUSTERS, STATS::cluster(), FALSE, TO_ROW::fp_nonsp, TO_ROW::fp_space, STATS::get_total(), BOX::left(), TO_ROW::pr_nonsp, TO_ROW::pr_space, BOX::right(), STATS::smooth(), sort_floats2(), tprintf(), TRUE, and TO_ROW::xheight.

Referenced by compute_rows_pitch().

                       {
  BLOBNBOX *blob;                //current blob
  int gap_index;                 //current gap
  INT32 prev_x;                  //end of prev blob
  INT32 cluster_count;           //no of clusters
  INT32 prev_count;              //of clusters
  INT32 smooth_factor;           //for smoothing stats
  BOX blob_box;                  //bounding box
  float lower, upper;            //cluster thresholds
                                 //gap sizes
  float gaps[BLOCK_STATS_CLUSTERS];
                                 //blobs
  BLOBNBOX_IT blob_it = row->blob_list ();
  STATS gap_stats (0, maxwidth);
  STATS cluster_stats[BLOCK_STATS_CLUSTERS + 1];
  //clusters

  smooth_factor =
    (INT32) (row->xheight * textord_wordstats_smooth_factor + 1.5);
  if (!blob_it.empty ()) {
    prev_x = blob_it.data ()->bounding_box ().right ();
    blob_it.forward ();
    while (!blob_it.at_first ()) {
      blob = blob_it.data ();
      if (!blob->joined_to_prev ()) {
        blob_box = blob->bounding_box ();
        if (blob_box.left () - prev_x < maxwidth)
          gap_stats.add (blob_box.left () - prev_x, 1);
        prev_x = blob_box.right ();
      }
      blob_it.forward ();
    }
  }
  if (gap_stats.get_total () == 0) {
    return FALSE;
  }
  cluster_count = 0;
  lower = row->xheight * words_initial_lower;
  upper = row->xheight * words_initial_upper;
  gap_stats.smooth (smooth_factor);
  do {
    prev_count = cluster_count;
    cluster_count = gap_stats.cluster (lower, upper,
      textord_spacesize_ratioprop,
      BLOCK_STATS_CLUSTERS, cluster_stats);
  }
  while (cluster_count > prev_count && cluster_count < BLOCK_STATS_CLUSTERS);
  if (cluster_count < 1) {
    return FALSE;
  }
  for (gap_index = 0; gap_index < cluster_count; gap_index++)
    gaps[gap_index] = cluster_stats[gap_index + 1].ile (0.5);
  //get medians
  if (testing_on) {
    tprintf ("cluster_count=%d:", cluster_count);
    for (gap_index = 0; gap_index < cluster_count; gap_index++)
      tprintf (" %g(%d)", gaps[gap_index],
        cluster_stats[gap_index + 1].get_total ());
    tprintf ("\n");
  }
  qsort (gaps, cluster_count, sizeof (float), sort_floats2);

  //Try to find proportional non-space and space for row.
  lower = row->xheight * words_default_prop_nonspace;
  upper = row->xheight * textord_words_min_minspace;
  for (gap_index = 0; gap_index < cluster_count
    && gaps[gap_index] < lower; gap_index++);
  if (gap_index == 0) {
    if (testing_on)
      tprintf ("No clusters below nonspace threshold!!\n");
    if (cluster_count > 1) {
      row->pr_nonsp = gaps[0];
      row->pr_space = gaps[1];
    }
    else {
      row->pr_nonsp = lower;
      row->pr_space = gaps[0];
    }
  }
  else {
    row->pr_nonsp = gaps[gap_index - 1];
    while (gap_index < cluster_count && gaps[gap_index] < upper)
      gap_index++;
    if (gap_index == cluster_count) {
      if (testing_on)
        tprintf ("No clusters above nonspace threshold!!\n");
      row->pr_space = lower * textord_spacesize_ratioprop;
    }
    else
      row->pr_space = gaps[gap_index];
  }

  //Now try to find the fixed pitch space and non-space.
  upper = row->xheight * words_default_fixed_space;
  for (gap_index = 0; gap_index < cluster_count
    && gaps[gap_index] < upper; gap_index++);
  if (gap_index == 0) {
    if (testing_on)
      tprintf ("No clusters below space threshold!!\n");
    row->fp_nonsp = upper;
    row->fp_space = gaps[0];
  }
  else {
    row->fp_nonsp = gaps[gap_index - 1];
    if (gap_index == cluster_count) {
      if (testing_on)
        tprintf ("No clusters above space threshold!!\n");
      row->fp_space = row->xheight;
    }
    else
      row->fp_space = gaps[gap_index];
  }
  if (testing_on) {
    tprintf
      ("Initial estimates:pr_nonsp=%g, pr_space=%g, fp_nonsp=%g, fp_space=%g\n",
      row->pr_nonsp, row->pr_space, row->fp_nonsp, row->fp_space);
  }
  return TRUE;                   //computed some stats
}

int sort_floats2	(	const void *	arg1,
		const void *	arg2
	)

qsort function to sort 2 floats.

Definition at line 1791 of file topitch.cpp.

Referenced by row_pitch_stats().

                                   {
  float diff;                    //difference

  diff = *((float *) arg1) - *((float *) arg2);
  if (diff > 0)
    return 1;
  else if (diff < 0)
    return -1;
  else
    return 0;
}

BOOL8 try_block_fixed	(	TO_BLOCK *	block,
		INT32	block_index
	)

Find line stats.

Try to call the entire block fixed.

Definition at line 569 of file topitch.cpp.

References FALSE.

Referenced by compute_fixed_pitch().

                       {
  return FALSE;
}

BOOL8 try_doc_fixed	(	ICOORD	page_tr,
		TO_BLOCK_LIST *	port_blocks,
		float	gradient
	)

Determine pitch.

Attempt to call the entire document fixed pitch.

Definition at line 424 of file topitch.cpp.

References STATS::add(), TO_ROW::baseline, TO_ROW::char_cells, CORAL, FALSE, TO_ROW::fixed_pitch, STATS::get_total(), GOLDENROD, STATS::ile(), TO_ROW::intercept(), MAX_ALLOWED_PITCH, MAX_INT16, NO_WINDOW, NULL, STATS::pile_count(), pitch, STATS::plot(), plot_row_cells(), projection, TO_ROW::projection, TO_ROW::projection_left, TO_ROW::projection_right, STATS::set_range(), to_win, tprintf(), tune_row_pitch(), and QSPLINE::y().

Referenced by compute_fixed_pitch().

                     {
  INT16 master_x;                //uniform shifts
  INT16 pitch;                   //median pitch.
  int x;                         //profile coord
  int prop_blocks;               //correct counts
  int fixed_blocks;
  int total_row_count;           //total in page
                                 //iterator
  TO_BLOCK_IT block_it = port_blocks;
  TO_BLOCK *block;               //current block;
  TO_ROW_IT row_it;              //row iterator
  TO_ROW *row;                   //current row
  INT16 projection_left;         //edges
  INT16 projection_right;
  INT16 row_left;                //edges of row
  INT16 row_right;
  ICOORDELT_LIST *master_cells;  //cells for page
  float master_y;                //uniform shifts
  float shift_factor;            //page skew correction
  float row_shift;               //shift for row
  float final_pitch;             //output pitch
  float row_y;                   //baseline
  STATS projection;              //entire page
  STATS pitches (0, MAX_ALLOWED_PITCH);
  //for median
  float sp_sd;                   //space sd
  INT16 mid_cuts;                //no of cheap cuts
  float pitch_sd;                //sync rating

  if (block_it.empty ()
    //      || block_it.data()==block_it.data_relative(1)
    || !textord_blockndoc_fixed)
    return FALSE;
  shift_factor = gradient / (gradient * gradient + 1);
  row_it.set_to_list (block_it.data ()->get_rows ());
  master_x = row_it.data ()->projection_left;
  master_y = row_it.data ()->baseline.y (master_x);
  projection_left = MAX_INT16;
  projection_right = -MAX_INT16;
  prop_blocks = 0;
  fixed_blocks = 0;
  total_row_count = 0;

  for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
  block_it.forward ()) {
    block = block_it.data ();
    if (block->block->text_region () != NULL) {
      if (block->block->text_region ()->is_prop ())
        prop_blocks++;
      else
        fixed_blocks++;
    }
    row_it.set_to_list (block->get_rows ());
    for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
      row = row_it.data ();
      total_row_count++;
      if (row->fixed_pitch > 0)
        pitches.add ((INT32) (row->fixed_pitch), 1);
      //find median
      row_y = row->baseline.y (master_x);
      row_left =
        (INT16) (row->projection_left -
        shift_factor * (master_y - row_y));
      row_right =
        (INT16) (row->projection_right -
        shift_factor * (master_y - row_y));
      if (row_left < projection_left)
        projection_left = row_left;
      if (row_right > projection_right)
        projection_right = row_right;
    }
  }
  if (pitches.get_total () == 0)
    return FALSE;
  projection.set_range (projection_left, projection_right);

  for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
  block_it.forward ()) {
    block = block_it.data ();
    row_it.set_to_list (block->get_rows ());
    for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
      row = row_it.data ();
      row_y = row->baseline.y (master_x);
      row_left =
        (INT16) (row->projection_left -
        shift_factor * (master_y - row_y));
      for (x = row->projection_left; x < row->projection_right;
      x++, row_left++) {
        projection.add (row_left, row->projection.pile_count (x));
      }
    }
  }

  row_it.set_to_list (block_it.data ()->get_rows ());
  row = row_it.data ();
#ifndef GRAPHICS_DISABLED
  if (textord_show_page_cuts && to_win != NO_WINDOW)
    projection.plot (to_win, projection_left,
      row->intercept (), 1.0f, -1.0f, CORAL);
#endif
  final_pitch = pitches.ile (0.5);
  pitch = (INT16) final_pitch;
  pitch_sd =
    tune_row_pitch (row, &projection, projection_left, projection_right,
    pitch * 0.75, final_pitch, sp_sd, mid_cuts,
    &row->char_cells, FALSE);

  if (textord_debug_pitch_metric)
    tprintf
      ("try_doc:props=%d:fixed=%d:pitch=%d:final_pitch=%g:pitch_sd=%g:sp_sd=%g:sd/trc=%g:sd/p=%g:sd/trc/p=%g\n",
      prop_blocks, fixed_blocks, pitch, final_pitch, pitch_sd, sp_sd,
      pitch_sd / total_row_count, pitch_sd / pitch,
      pitch_sd / total_row_count / pitch);

#ifndef GRAPHICS_DISABLED
  if (textord_show_page_cuts && to_win != NO_WINDOW) {
    master_cells = &row->char_cells;
    for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
    block_it.forward ()) {
      block = block_it.data ();
      row_it.set_to_list (block->get_rows ());
      for (row_it.mark_cycle_pt (); !row_it.cycled_list ();
      row_it.forward ()) {
        row = row_it.data ();
        row_y = row->baseline.y (master_x);
        row_shift = shift_factor * (master_y - row_y);
        plot_row_cells(to_win, GOLDENROD, row, row_shift, master_cells);
      }
    }
  }
#endif
  row->char_cells.clear ();
  return FALSE;
}

BOOL8 try_rows_fixed	(	TO_BLOCK *	block,
		INT32	block_index,
		BOOL8	testing_on
	)

Find line stats.

Decide whether each row is fixed pitch individually.

Definition at line 582 of file topitch.cpp.

References ASSERT_HOST, count_block_votes(), FALSE, TO_ROW::fixed_pitch, fixed_pitch_row(), TO_ROW::kern_size, PITCH_DEF_FIXED, PITCH_DEF_PROP, PITCH_DUNNO, PITCH_MAYBE_FIXED, PITCH_MAYBE_PROP, TO_ROW::pr_nonsp, TO_ROW::pr_space, print_block_counts(), TO_ROW::space_size, tprintf(), and TO_ROW::xheight.

Referenced by compute_fixed_pitch().

                      {
  INT32 maxwidth;                //of spaces
  TO_ROW *row;                   //current row
  INT32 row_index;               //row number.
  INT32 def_fixed = 0;           //counters
  INT32 def_prop = 0;
  INT32 maybe_fixed = 0;
  INT32 maybe_prop = 0;
  INT32 dunno = 0;
  INT32 corr_fixed = 0;
  INT32 corr_prop = 0;
  float lower, upper;            //cluster thresholds
  TO_ROW_IT row_it = block->get_rows ();

  row_index = 1;
  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
    row = row_it.data ();
    ASSERT_HOST (row->xheight > 0);
    maxwidth = (INT32) ceil (row->xheight * textord_words_maxspace);
    if (row->fixed_pitch > 0 && fixed_pitch_row (row, block_index)) {
      if (row->fixed_pitch == 0) {
        lower = row->pr_nonsp;
        upper = row->pr_space;
        row->space_size = upper;
        row->kern_size = lower;
      }
    }
    row_index++;
  }
  count_block_votes(block,
                    def_fixed,
                    def_prop,
                    maybe_fixed,
                    maybe_prop,
                    corr_fixed,
                    corr_prop,
                    dunno);
  if (testing_on
    && (textord_debug_pitch_test
  || textord_blocksall_prop || textord_blocksall_fixed)) {
    tprintf ("Initially:");
    print_block_counts(block, block_index);
  }
  if (def_fixed > def_prop * textord_words_veto_power)
    block->pitch_decision = PITCH_DEF_FIXED;
  else if (def_prop > def_fixed * textord_words_veto_power)
    block->pitch_decision = PITCH_DEF_PROP;
  else if (def_fixed > 0 || def_prop > 0)
    block->pitch_decision = PITCH_DUNNO;
  else if (maybe_fixed > maybe_prop * textord_words_veto_power)
    block->pitch_decision = PITCH_MAYBE_FIXED;
  else if (maybe_prop > maybe_fixed * textord_words_veto_power)
    block->pitch_decision = PITCH_MAYBE_PROP;
  else
    block->pitch_decision = PITCH_DUNNO;
  return FALSE;
}

float tune_row_pitch	(	TO_ROW *	row,
		STATS *	projection,
		INT16	projection_left,
		INT16	projection_right,
		float	space_size,
		float &	initial_pitch,
		float &	best_sp_sd,
		INT16 &	best_mid_cuts,
		ICOORDELT_LIST *	best_cells,
		BOOL8	testing_on
	)

Find fp cells.

Use a dp algorithm to fit the character cells and return the sd of the cell size over the row.

Definition at line 1185 of file topitch.cpp.

References compute_pitch_sd(), print_pitch_sd(), projection, tprintf(), and tune_row_pitch2().

Referenced by fix_row_pitch(), fixed_pitch_row(), and try_doc_fixed().

                      {
  int pitch_delta;               //offset pitch
  INT16 mid_cuts;                //cheap cuts
  float pitch_sd;                //current sd
  float best_sd;                 //best result
  float best_pitch;              //pitch for best result
  float initial_sd;              //starting error
  float sp_sd;                   //space sd
  ICOORDELT_LIST test_cells;     //row cells
  ICOORDELT_IT best_it;          //start of best list

  if (textord_fast_pitch_test)
    return tune_row_pitch2 (row, projection, projection_left,
      projection_right, space_size, initial_pitch,
      best_sp_sd,
    //space sd
      best_mid_cuts, best_cells, testing_on);
  if (textord_disable_pitch_test) {
    best_sp_sd = initial_pitch;
    return initial_pitch;
  }
  initial_sd =
    compute_pitch_sd(row,
                     projection,
                     projection_left,
                     projection_right,
                     space_size,
                     initial_pitch,
                     best_sp_sd,
                     best_mid_cuts,
                     best_cells,
                     testing_on);
  best_sd = initial_sd;
  best_pitch = initial_pitch;
  if (testing_on)
    tprintf ("tune_row_pitch:start pitch=%g, sd=%g\n", best_pitch, best_sd);
  for (pitch_delta = 1; pitch_delta <= textord_pitch_range; pitch_delta++) {
    pitch_sd =
      compute_pitch_sd (row, projection, projection_left, projection_right,
      space_size, initial_pitch + pitch_delta, sp_sd,
      mid_cuts, &test_cells, testing_on);
    if (testing_on)
      tprintf ("testing pitch at %g, sd=%g\n", initial_pitch + pitch_delta,
        pitch_sd);
    if (pitch_sd < best_sd) {
      best_sd = pitch_sd;
      best_mid_cuts = mid_cuts;
      best_sp_sd = sp_sd;
      best_pitch = initial_pitch + pitch_delta;
      best_cells->clear ();
      best_it.set_to_list (best_cells);
      best_it.add_list_after (&test_cells);
    }
    else
      test_cells.clear ();
    if (pitch_sd > initial_sd)
      break;                     //getting worse
  }
  for (pitch_delta = 1; pitch_delta <= textord_pitch_range; pitch_delta++) {
    pitch_sd =
      compute_pitch_sd (row, projection, projection_left, projection_right,
      space_size, initial_pitch - pitch_delta, sp_sd,
      mid_cuts, &test_cells, testing_on);
    if (testing_on)
      tprintf ("testing pitch at %g, sd=%g\n", initial_pitch - pitch_delta,
        pitch_sd);
    if (pitch_sd < best_sd) {
      best_sd = pitch_sd;
      best_mid_cuts = mid_cuts;
      best_sp_sd = sp_sd;
      best_pitch = initial_pitch - pitch_delta;
      best_cells->clear ();
      best_it.set_to_list (best_cells);
      best_it.add_list_after (&test_cells);
    }
    else
      test_cells.clear ();
    if (pitch_sd > initial_sd)
      break;
  }
  initial_pitch = best_pitch;

  if (textord_debug_pitch_metric)
    print_pitch_sd(row,
                   projection,
                   projection_left,
                   projection_right,
                   space_size,
                   best_pitch);

  return best_sd;
}

float tune_row_pitch2	(	TO_ROW *	row,
		STATS *	projection,
		INT16	projection_left,
		INT16	projection_right,
		float	space_size,
		float &	initial_pitch,
		float &	best_sp_sd,
		INT16 &	best_mid_cuts,
		ICOORDELT_LIST *	best_cells,
		BOOL8	testing_on
	)

Find fp cells.

Use a dp algorithm to fit the character cells and return the sd of the cell size over the row.

Definition at line 1296 of file topitch.cpp.

References compute_pitch_sd(), NULL, STATS::pile_count(), print_pitch_sd(), projection, and tprintf().

Referenced by tune_row_pitch().

                       {
  int pitch_delta;               //offset pitch
  INT16 pixel;                   //pixel coord
  INT16 best_pixel;              //pixel coord
  INT16 best_delta;              //best pitch
  INT16 best_pitch;              //best pitch
  INT16 start;                   //of good range
  INT16 end;                     //of good range
  INT32 best_count;              //lowest sum
  float best_sd;                 //best result
  STATS *sum_proj;               //summed projection

  best_sp_sd = initial_pitch;

  if (textord_disable_pitch_test) {
    return initial_pitch;
  }
  sum_proj = new STATS[textord_pitch_range * 2 + 1];
  if (sum_proj == NULL)
    return initial_pitch;
  best_pitch = (INT32) initial_pitch;

  for (pitch_delta = -textord_pitch_range; pitch_delta <= textord_pitch_range;
    pitch_delta++)
  sum_proj[textord_pitch_range + pitch_delta].set_range (0,
      best_pitch +
      pitch_delta + 1);
  for (pixel = projection_left; pixel <= projection_right; pixel++) {
    for (pitch_delta = -textord_pitch_range;
      pitch_delta <= textord_pitch_range; pitch_delta++)
    sum_proj[textord_pitch_range +
        pitch_delta].add ((pixel - projection_left) % (best_pitch +
        pitch_delta),
        projection->pile_count (pixel));
  }
  best_count = sum_proj[textord_pitch_range].pile_count (0);
  best_delta = 0;
  best_pixel = 0;
  for (pitch_delta = -textord_pitch_range; pitch_delta <= textord_pitch_range;
  pitch_delta++) {
    for (pixel = 0; pixel < best_pitch + pitch_delta; pixel++) {
      if (sum_proj[textord_pitch_range + pitch_delta].pile_count (pixel)
      < best_count) {
        best_count =
          sum_proj[textord_pitch_range +
          pitch_delta].pile_count (pixel);
        best_delta = pitch_delta;
        best_pixel = pixel;
      }
    }
  }
  if (testing_on)
    tprintf ("tune_row_pitch:start pitch=%g, best_delta=%d, count=%d\n",
      initial_pitch, best_delta, best_count);
  best_pitch += best_delta;
  initial_pitch = best_pitch;
  best_count++;
  best_count += best_count;
  for (start = best_pixel - 2; start > best_pixel - best_pitch
    && sum_proj[textord_pitch_range +
    best_delta].pile_count (start % best_pitch) <= best_count;
    start--);
  for (end = best_pixel + 2;
    end < best_pixel + best_pitch
    && sum_proj[textord_pitch_range +
    best_delta].pile_count (end % best_pitch) <= best_count;
    end++);

  best_sd =
    compute_pitch_sd(row,
                     projection,
                     projection_left,
                     projection_right,
                     space_size,
                     initial_pitch,
                     best_sp_sd,
                     best_mid_cuts,
                     best_cells,
                     testing_on,
                     start,
                     end);
  if (testing_on)
    tprintf ("tune_row_pitch:output pitch=%g, sd=%g\n", initial_pitch,
      best_sd);

  if (textord_debug_pitch_metric)
    print_pitch_sd(row,
                   projection,
                   projection_left,
                   projection_right,
                   space_size,
                   initial_pitch);

  delete[]sum_proj;

  return best_sd;
}

---