pagewalk.cpp

一ＯＣＲ的相关资料。．希望对研究ＯＣＲ的朋友有所帮助．

void
process_selected_words (         //process words
BLOCK_LIST * block_list,         //blocks to check
                                 //function to call
BOX & selection_box, BOOL8 word_processor (
BLOCK *,
ROW *,
WERD *)) {
  BLOCK_IT block_it(block_list); 
  BLOCK *block;
  ROW_IT row_it;
  ROW *row;
  WERD_IT word_it;
  WERD *word;

  for (block_it.mark_cycle_pt ();
  !block_it.cycled_list (); block_it.forward ()) {
    block = block_it.data ();
    if (block->bounding_box ().overlap (selection_box)) {
      row_it.set_to_list (block->row_list ());
      for (row_it.mark_cycle_pt ();
      !row_it.cycled_list (); row_it.forward ()) {
        row = row_it.data ();
        if (row->bounding_box ().overlap (selection_box)) {
          word_it.set_to_list (row->word_list ());
          for (word_it.mark_cycle_pt ();
          !word_it.cycled_list (); word_it.forward ()) {
            word = word_it.data ();
            if (word->bounding_box ().overlap (selection_box)) {
              if (!word_processor (block, row, word) ||
                selection_quit)
                return;
            }
          }
        }
      }
    }
  }
}


/**********************************************************************
 * process_all_words_it()   PASS ITERATORS
 *
 * Walk the current block list applying the specified word processor function
 * to all words
 **********************************************************************/

void
process_all_words_it (           //process words
BLOCK_LIST * block_list,         //blocks to check
BOOL8 word_processor (           //function to call
BLOCK *,
ROW *,
WERD *,
BLOCK_IT &,
ROW_IT &, WERD_IT &)) {
  BLOCK_IT block_it(block_list); 
  BLOCK *block;
  ROW_IT row_it;
  ROW *row;
  WERD_IT word_it;
  WERD *word;

  for (block_it.mark_cycle_pt ();
  !block_it.cycled_list (); block_it.forward ()) {
    block = block_it.data ();
    row_it.set_to_list (block->row_list ());
    for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
      row = row_it.data ();
      word_it.set_to_list (row->word_list ());
      for (word_it.mark_cycle_pt ();
      !word_it.cycled_list (); word_it.forward ()) {
        word = word_it.data ();
        if (!word_processor
          (block, row, word, block_it, row_it, word_it)
          || selection_quit)
          return;
      }
    }
  }
}


/**********************************************************************
 * process_selected_words_it()   PASS ITERATORS
 *
 * Walk the current block list applying the specified word processor function
 * to each word selected.
 **********************************************************************/

void
process_selected_words_it (      //process words
BLOCK_LIST * block_list,         //blocks to check
                                 //function to call
BOX & selection_box, BOOL8 word_processor (
BLOCK
*,
ROW *,
WERD
*,
BLOCK_IT
&,
ROW_IT
&,
WERD_IT
&)) {
  BLOCK_IT block_it(block_list); 
  BLOCK *block;
  ROW_IT row_it;
  ROW *row;
  WERD_IT word_it;
  WERD *word;

  for (block_it.mark_cycle_pt ();
  !block_it.cycled_list (); block_it.forward ()) {
    block = block_it.data ();
    if (block->bounding_box ().overlap (selection_box)) {
      row_it.set_to_list (block->row_list ());
      for (row_it.mark_cycle_pt ();
      !row_it.cycled_list (); row_it.forward ()) {
        row = row_it.data ();
        if (row->bounding_box ().overlap (selection_box)) {
          word_it.set_to_list (row->word_list ());
          for (word_it.mark_cycle_pt ();
          !word_it.cycled_list (); word_it.forward ()) {
            word = word_it.data ();
            if (word->bounding_box ().overlap (selection_box)) {
              if (!word_processor (block, row, word,
                block_it, row_it, word_it) ||
                selection_quit)
                return;
            }
          }
        }
      }
    }
  }
}


/**********************************************************************
 * process_all_blocks()
 *
 * Walk the current block list applying the specified block processor function
 * to each block.
 **********************************************************************/

void
process_all_blocks (             //process blocks
BLOCK_LIST * block_list,         //blocks to check
BOOL8 block_processor (          //function to call
BLOCK *)) {
  BLOCK_IT block_it(block_list); 
  BLOCK *block;

  for (block_it.mark_cycle_pt ();
  !block_it.cycled_list (); block_it.forward ()) {
    block = block_it.data ();
    if (!block_processor (block) || selection_quit)
      return;
  }
}


/**********************************************************************
 * process_selected_blocks()
 *
 * Walk the current block list applying the specified block processor function
 * to each block selected.
 **********************************************************************/

void
process_selected_blocks (        //process blocks
BLOCK_LIST * block_list,         //blocks to check
                                 //function to call
BOX & selection_box, BOOL8 block_processor (
BLOCK
*)) {
  BLOCK_IT block_it(block_list); 
  BLOCK *block;

  for (block_it.mark_cycle_pt ();
  !block_it.cycled_list (); block_it.forward ()) {
    block = block_it.data ();
    if (block->bounding_box ().overlap (selection_box)) {
      if (!block_processor (block) || selection_quit)
        return;
    }
  }
}


/**********************************************************************
 * process_all_rows()
 *
 * Walk the current block list applying the specified row processor function
 * to all rows
 **********************************************************************/

void
process_all_rows (               //process words
BLOCK_LIST * block_list,         //blocks to check
BOOL8 row_processor (            //function to call
BLOCK *, ROW *)) {
  BLOCK_IT block_it(block_list); 
  BLOCK *block;
  ROW_IT row_it;
  ROW *row;

  for (block_it.mark_cycle_pt ();
  !block_it.cycled_list (); block_it.forward ()) {
    block = block_it.data ();
    row_it.set_to_list (block->row_list ());
    for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
      row = row_it.data ();
      if (!row_processor (block, row) || selection_quit)
        return;
    }
  }
}


/**********************************************************************
 * process_selected_rows()
 *
 * Walk the current block list applying the specified row processor function
 * to each row selected.
 **********************************************************************/

void
process_selected_rows (          //process rows
BLOCK_LIST * block_list,         //blocks to check
                                 //function to call
BOX & selection_box, BOOL8 row_processor (
BLOCK *,
ROW *)) {
  BLOCK_IT block_it(block_list); 
  BLOCK *block;
  ROW_IT row_it;
  ROW *row;

  for (block_it.mark_cycle_pt ();
  !block_it.cycled_list (); block_it.forward ()) {
    block = block_it.data ();
    if (block->bounding_box ().overlap (selection_box)) {
      row_it.set_to_list (block->row_list ());
      for (row_it.mark_cycle_pt ();
      !row_it.cycled_list (); row_it.forward ()) {
        row = row_it.data ();
        if (row->bounding_box ().overlap (selection_box)) {
          if (!row_processor (block, row) || selection_quit)
            return;
        }
      }
    }
  }
}


/**********************************************************************
 * process_all_rows_it()   PASS ITERATORS
 *
 * Walk the current block list applying the specified row processor function
 * to all rows
 **********************************************************************/

void
process_all_rows_it (            //process words
BLOCK_LIST * block_list,         //blocks to check
BOOL8 row_processor (            //function to call
BLOCK *,
ROW *, BLOCK_IT &, ROW_IT &)) {
  BLOCK_IT block_it(block_list); 
  BLOCK *block;
  ROW_IT row_it;
  ROW *row;

  for (block_it.mark_cycle_pt ();
  !block_it.cycled_list (); block_it.forward ()) {
    block = block_it.data ();
    row_it.set_to_list (block->row_list ());
    for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
      row = row_it.data ();
      if (!row_processor (block, row, block_it, row_it) || selection_quit)
        return;
    }
  }
}


/**********************************************************************
 * process_selected_rows_it()   PASS ITERATORS
 *
 * Walk the current block list applying the specified row processor function
 * to each row selected.
 **********************************************************************/

void
process_selected_rows_it (       //process rows
BLOCK_LIST * block_list,         //blocks to check
                                 //function to call
BOX & selection_box, BOOL8 row_processor (
BLOCK *,
ROW *,
BLOCK_IT
&,
ROW_IT
&)) {
  BLOCK_IT block_it(block_list); 
  BLOCK *block;
  ROW_IT row_it;
  ROW *row;

  for (block_it.mark_cycle_pt ();
  !block_it.cycled_list (); block_it.forward ()) {
    block = block_it.data ();
    if (block->bounding_box ().overlap (selection_box)) {
      row_it.set_to_list (block->row_list ());
      for (row_it.mark_cycle_pt ();
      !row_it.cycled_list (); row_it.forward ()) {
        row = row_it.data ();
        if (row->bounding_box ().overlap (selection_box)) {
          if (!row_processor (block, row, block_it, row_it) ||
            selection_quit)
            return;
        }
      }
    }
  }
}