/**********************************************************************
* File: pagewalk.cpp (Formerly walkers.c)
* Description: Block list processors
* Author: Phil Cheatle
* Created: Thu Oct 10 16:25:24 BST 1991
*
* (C) Copyright 1991, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#include "mfcpch.h"
#include "pagewalk.h"
#include "tesseractclass.h"
#define EXTERN
EXTERN BOOL_VAR (current_word_quit, FALSE, "Stop processing this word");
DLLSYM BOOL_VAR (selection_quit, FALSE, "Stop processing this selection");
/**********************************************************************
* block_list_bounding_box()
*
* Scan block list to find the bounding box of all blocks.
**********************************************************************/
TBOX block_list_bounding_box( //find bounding box
BLOCK_LIST *block_list //of this block list
) {
BLOCK_IT block_it(block_list);
TBOX enclosing_box;
for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
block_it.forward ())
enclosing_box += block_it.data ()->bounding_box ();
return enclosing_box;
}
/**********************************************************************
* block_list_compress()
*
* Pack a block list to occupy a smaller space by compressing each block and
* moving the compressed blocks one above the other.
* The compressed block list has the same top left point as the uncompressed
* first. Blocks are reordered so that the source names are in alphabetic
* order. (This gathers together, but does not combine, blocks from the same
* file.)
* The enclosing box of the compressed block list is returned.
**********************************************************************/
const TBOX block_list_compress( //shuffle up blocks
BLOCK_LIST *block_list) {
BLOCK_IT block_it(block_list);
BLOCK *block;
ICOORD initial_top_left;
ICOORD block_spacing (0, BLOCK_SPACING);
TBOX enclosing_box; //for full display
initial_top_left = block_it.data ()->bounding_box ().topleft ();
//group srcfile blks
block_it.sort (block_name_order);
/* Compress the target block list into an area starting from the top left of
the first block on the list */
enclosing_box = TBOX (initial_top_left, initial_top_left);
enclosing_box.move_bottom_edge (BLOCK_SPACING);
for (block_it.mark_cycle_pt ();
!block_it.cycled_list (); block_it.forward ()) {
block = block_it.data ();
block->compress (enclosing_box.botleft () - block_spacing -
block->bounding_box ().topleft ());
enclosing_box += block->bounding_box ();
}
return enclosing_box;
}
/**********************************************************************
* block_list_move()
*
* Move all the blocks in the list by a vector
**********************************************************************/
void block_list_move( //move
BLOCK_LIST *block_list, //this list
ICOORD vec //by this vector
) {
BLOCK_IT block_it(block_list);
for (block_it.mark_cycle_pt (); !block_it.cycled_list ();
block_it.forward ())
block_it.data ()->move (vec);
}
/**********************************************************************
* block_name_order()
*
* Block comparator used to sort a block list so that blocks from the same
* filename are located together, and blocks from the same file are ordered
* by vertical position.
**********************************************************************/
int block_name_order( //sort blocks
const void *block1p, //ptr to ptr to block1
const void *block2p //ptr to ptr to block2
) {
int result;
BLOCK *block1 = *(BLOCK **) block1p;
BLOCK *block2 = *(BLOCK **) block2p;
result = strcmp (block1->name (), block2->name ());
if (result == 0)
result = block2->bounding_box ().top () - block1->bounding_box ().top ();
return result;
}
/**********************************************************************
* process_all_blobs()
*
* Walk the current block list applying the specified blob processor function
* to all blobs
**********************************************************************/
void
process_all_blobs ( //process blobs
BLOCK_LIST * block_list, //blocks to check
BOOL8 blob_processor ( //function to call
//function to call
BLOCK *, ROW *, WERD *, PBLOB *), BOOL8 c_blob_processor (
BLOCK
*,
ROW
*,
WERD
*,
C_BLOB
*)) {
BLOCK_IT block_it(block_list);
BLOCK *block;
ROW_IT row_it;
ROW *row;
WERD_IT word_it;
WERD *word;
PBLOB_IT blob_it;
PBLOB *blob;
C_BLOB_IT c_blob_it;
C_BLOB *c_blob;
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->flag (W_POLYGON)) {
if (blob_processor != NULL) {
blob_it.set_to_list (word->blob_list ());
for (blob_it.mark_cycle_pt ();
!blob_it.cycled_list (); blob_it.forward ()) {
blob = blob_it.data ();
if (!blob_processor (block, row, word, blob) ||
selection_quit)
return;
}
}
}
else {
if (c_blob_processor != NULL) {
c_blob_it.set_to_list (word->cblob_list ());
for (c_blob_it.mark_cycle_pt ();
!c_blob_it.cycled_list (); c_blob_it.forward ()) {
c_blob = c_blob_it.data ();
if (!c_blob_processor (block, row, word, c_blob) ||
selection_quit)
return;
}
}
}
}
}
}
}
/**********************************************************************
* process_selected_blobs()
*
* Walk the current block list applying the specified blob processor function
* to each selected blob
**********************************************************************/
void
process_selected_blobs ( //process blobs
BLOCK_LIST * block_list, //blocks to check
//function to call
TBOX & selection_box, BOOL8 blob_processor (
//function to call
BLOCK *, ROW *, WERD *, PBLOB *), BOOL8 c_blob_processor (
BLOCK
*,
ROW
*,
WERD
*,
C_BLOB
*)) {
BLOCK_IT block_it(block_list);
BLOCK *block;
ROW_IT row_it;
ROW *row;
WERD_IT word_it;
WERD *word;
PBLOB_IT blob_it;
PBLOB *blob;
C_BLOB_IT c_blob_it;
C_BLOB *c_blob;
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->flag (W_POLYGON)) {
if (blob_processor != NULL) {
blob_it.set_to_list (word->blob_list ());
for (blob_it.mark_cycle_pt ();
!blob_it.cycled_list ();
blob_it.forward ()) {
blob = blob_it.data ();
if (blob->bounding_box ().
overlap (selection_box)) {
if (!blob_processor
(block, row, word, blob)
|| selection_quit)
return;
}
}
}
}
else {
if (c_blob_processor != NULL) {
c_blob_it.set_to_list (word->cblob_list ());
for (c_blob_it.mark_cycle_pt ();
!c_blob_it.cycled_list ();
c_blob_it.forward ()) {
c_blob = c_blob_it.data ();
if (c_blob->
bounding_box ().
overlap (selection_box)) {
if (!c_blob_processor
(block, row, word, c_blob)
|| selection_quit)
return;
}
}
}
}
}
}
}
}
}
}
}
/**********************************************************************
* process_all_words()
*
* Walk the current block list applying the specified word processor function
* to all words
**********************************************************************/
void
process_all_words ( //process words
BLOCK_LIST * block_list, //blocks to check
BOOL8 word_processor ( //function to call
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 ();
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) || selection_quit)
return;
}
}
}
}
/**********************************************************************
* process_selected_words()
*
* Walk the current block list applying the specified word processor function
* to each word selected.
**********************************************************************/
void
process_selected_words (
//process words
BLOCK_LIST * block_list, //blocks to check
//function to call
TBOX & 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;
}
}
}
}
}
}
}
namespace tesseract {
void
Tesseract::process_selected_words (
//process words
BLOCK_LIST * block_list, //blocks to check
//function to call
TBOX & selection_box,
BOOL8 (tesseract::Tesseract::*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 (!((this->*word_processor) (block, row, word)) ||
selection_quit)
return;
}
}
}
}
}
}
}
} // namespace tesseract
/**********************************************************************
* 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
TBOX & 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
TBOX & 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
TBOX & 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
TBOX & 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;
}
}
}
}
}