| /********************************************************************** |
| * 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; |
| } |
| } |
| } |
| } |
| } |
