Tesseract  3.02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PAGE_RES_IT Class Reference

#include <pageres.h>

List of all members.

Public Member Functions

 PAGE_RES_IT ()
 PAGE_RES_IT (PAGE_RES *the_page_res)
bool operator== (const PAGE_RES_IT &other) const
bool operator!= (const PAGE_RES_IT &other) const
int cmp (const PAGE_RES_IT &other) const
WERD_RESrestart_page ()
WERD_RESrestart_page_with_empties ()
WERD_RESstart_page (bool empty_ok)
WERD_RESrestart_row ()
WERD_RESInsertSimpleCloneWord (const WERD_RES &clone_res, WERD *new_word)
void DeleteCurrentWord ()
WERD_RESforward ()
WERD_RESforward_with_empties ()
WERD_RESforward_paragraph ()
WERD_RESforward_block ()
WERD_RESprev_word () const
ROW_RESprev_row () const
BLOCK_RESprev_block () const
WERD_RESword () const
ROW_RESrow () const
BLOCK_RESblock () const
WERD_RESnext_word () const
ROW_RESnext_row () const
BLOCK_RESnext_block () const
void rej_stat_word ()

Public Attributes

PAGE_RESpage_res

Detailed Description

Definition at line 689 of file pageres.h.


Constructor & Destructor Documentation

PAGE_RES_IT::PAGE_RES_IT ( )
inline

Definition at line 693 of file pageres.h.

{
} // empty contructor
PAGE_RES_IT::PAGE_RES_IT ( PAGE_RES the_page_res)
inline

Definition at line 696 of file pageres.h.

{ // page result
page_res = the_page_res;
restart_page(); // ready to scan
}

Member Function Documentation

BLOCK_RES* PAGE_RES_IT::block ( ) const
inline

Definition at line 763 of file pageres.h.

{ // block of cur. word
return block_res;
}
int PAGE_RES_IT::cmp ( const PAGE_RES_IT other) const

Definition at line 851 of file pageres.cpp.

{
if (other.block_res == NULL) {
// other points to the end of the page.
if (block_res == NULL)
return 0;
return -1;
}
if (block_res == NULL) {
return 1; // we point to the end of the page.
}
if (block_res == other.block_res) {
if (other.row_res == NULL || row_res == NULL) {
// this should only happen if we hit an image block.
return 0;
}
if (row_res == other.row_res) {
// we point to the same block and row.
ASSERT_HOST(other.word_res != NULL && word_res != NULL);
if (word_res == other.word_res) {
// we point to the same word!
return 0;
}
WERD_RES_IT word_res_it(&row_res->word_res_list);
for (word_res_it.mark_cycle_pt(); !word_res_it.cycled_list();
word_res_it.forward()) {
if (word_res_it.data() == word_res) {
return -1;
} else if (word_res_it.data() == other.word_res) {
return 1;
}
}
ASSERT_HOST("Error: Incomparable PAGE_RES_ITs" == NULL);
}
// we both point to the same block, but different rows.
ROW_RES_IT row_res_it(&block_res->row_res_list);
for (row_res_it.mark_cycle_pt(); !row_res_it.cycled_list();
row_res_it.forward()) {
if (row_res_it.data() == row_res) {
return -1;
} else if (row_res_it.data() == other.row_res) {
return 1;
}
}
ASSERT_HOST("Error: Incomparable PAGE_RES_ITs" == NULL);
}
// We point to different blocks.
BLOCK_RES_IT block_res_it(&page_res->block_res_list);
for (block_res_it.mark_cycle_pt();
!block_res_it.cycled_list(); block_res_it.forward()) {
if (block_res_it.data() == block_res) {
return -1;
} else if (block_res_it.data() == other.block_res) {
return 1;
}
}
// Shouldn't happen...
ASSERT_HOST("Error: Incomparable PAGE_RES_ITs" == NULL);
return 0;
}
void PAGE_RES_IT::DeleteCurrentWord ( )

Definition at line 950 of file pageres.cpp.

{
// Check that this word is as we expect. part_of_combos are NEVER iterated
// by the normal iterator, so we should never be trying to delete them.
if (!word_res->combination) {
// Combinations own their own word, so we won't find the word on the
// row's word_list, but it is legitimate to try to delete them.
// Delete word from the ROW when not a combination.
WERD_IT w_it(row()->row->word_list());
for (w_it.mark_cycle_pt(); !w_it.cycled_list(); w_it.forward()) {
if (w_it.data() == word_res->word) {
break;
}
}
ASSERT_HOST(!w_it.cycled_list());
delete w_it.extract();
}
// Remove the WERD_RES for the new_word.
// Remove the WORD_RES from the ROW_RES.
WERD_RES_IT wr_it(&row()->word_res_list);
for (wr_it.mark_cycle_pt(); !wr_it.cycled_list(); wr_it.forward()) {
if (wr_it.data() == word_res) {
word_res = NULL;
break;
}
}
ASSERT_HOST(!wr_it.cycled_list());
delete wr_it.extract();
ResetWordIterator();
}
WERD_RES* PAGE_RES_IT::forward ( )
inline

Definition at line 737 of file pageres.h.

{ // Get next word.
return internal_forward(false, false);
}
WERD_RES * PAGE_RES_IT::forward_block ( )

Definition at line 1130 of file pageres.cpp.

{
while (block_res == next_block_res) {
internal_forward(false, true);
}
return internal_forward(false, true);
}
WERD_RES * PAGE_RES_IT::forward_paragraph ( )

Definition at line 1115 of file pageres.cpp.

{
while (block_res == next_block_res &&
(next_row_res != NULL && next_row_res->row != NULL &&
row_res->row->para() == next_row_res->row->para())) {
internal_forward(false, true);
}
return internal_forward(false, true);
}
WERD_RES* PAGE_RES_IT::forward_with_empties ( )
inline

Definition at line 741 of file pageres.h.

{
return internal_forward(false, true);
}
WERD_RES * PAGE_RES_IT::InsertSimpleCloneWord ( const WERD_RES clone_res,
WERD new_word 
)

Definition at line 918 of file pageres.cpp.

{
// Insert new_word into the ROW.
WERD_IT w_it(row()->row->word_list());
for (w_it.mark_cycle_pt(); !w_it.cycled_list(); w_it.forward()) {
WERD* word = w_it.data();
if (word == word_res->word)
break;
}
ASSERT_HOST(!w_it.cycled_list());
w_it.add_before_then_move(new_word);
// Make a WERD_RES for the new_word.
WERD_RES* new_res = new WERD_RES(new_word);
new_res->CopySimpleFields(clone_res);
// Insert into the appropriate place in the ROW_RES.
WERD_RES_IT wr_it(&row()->word_res_list);
for (wr_it.mark_cycle_pt(); !wr_it.cycled_list(); wr_it.forward()) {
WERD_RES* word = wr_it.data();
if (word == word_res)
break;
}
ASSERT_HOST(!wr_it.cycled_list());
wr_it.add_before_then_move(new_res);
if (wr_it.at_first()) {
// This is the new first word, so reset the member iterator so it
// detects the cycled_list state correctly.
ResetWordIterator();
}
return new_res;
}
BLOCK_RES* PAGE_RES_IT::next_block ( ) const
inline

Definition at line 772 of file pageres.h.

{ // block of next word
return next_block_res;
}
ROW_RES* PAGE_RES_IT::next_row ( ) const
inline

Definition at line 769 of file pageres.h.

{ // row of next word
return next_row_res;
}
WERD_RES* PAGE_RES_IT::next_word ( ) const
inline

Definition at line 766 of file pageres.h.

{ // next word
return next_word_res;
}
bool PAGE_RES_IT::operator!= ( const PAGE_RES_IT other) const
inline

Definition at line 705 of file pageres.h.

{return !(*this == other); }
bool PAGE_RES_IT::operator== ( const PAGE_RES_IT other) const

Definition at line 845 of file pageres.cpp.

{
return word_res == other.word_res &&
row_res == other.row_res &&
block_res == other.block_res;
}
BLOCK_RES* PAGE_RES_IT::prev_block ( ) const
inline

Definition at line 754 of file pageres.h.

{ // block of prev word
return prev_block_res;
}
ROW_RES* PAGE_RES_IT::prev_row ( ) const
inline

Definition at line 751 of file pageres.h.

{ // row of prev word
return prev_row_res;
}
WERD_RES* PAGE_RES_IT::prev_word ( ) const
inline

Definition at line 748 of file pageres.h.

{ // previous word
return prev_word_res;
}
void PAGE_RES_IT::rej_stat_word ( )

Definition at line 1137 of file pageres.cpp.

{
inT16 chars_in_word;
inT16 rejects_in_word = 0;
chars_in_word = word_res->reject_map.length ();
page_res->char_count += chars_in_word;
block_res->char_count += chars_in_word;
row_res->char_count += chars_in_word;
rejects_in_word = word_res->reject_map.reject_count ();
page_res->rej_count += rejects_in_word;
block_res->rej_count += rejects_in_word;
row_res->rej_count += rejects_in_word;
if (chars_in_word == rejects_in_word)
row_res->whole_word_rej_count += rejects_in_word;
}
WERD_RES* PAGE_RES_IT::restart_page ( )
inline

Definition at line 713 of file pageres.h.

{
return start_page(false); // Skip empty blocks.
}
WERD_RES* PAGE_RES_IT::restart_page_with_empties ( )
inline

Definition at line 716 of file pageres.h.

{
return start_page(true); // Allow empty blocks.
}
WERD_RES * PAGE_RES_IT::restart_row ( )

Definition at line 1100 of file pageres.cpp.

{
ROW_RES *row = this->row();
if (!row) return NULL;
for (restart_page(); this->row() != row; forward()) {
// pass
}
return word();
}
ROW_RES* PAGE_RES_IT::row ( ) const
inline

Definition at line 760 of file pageres.h.

{ // row of current word
return row_res;
}
WERD_RES * PAGE_RES_IT::start_page ( bool  empty_ok)

Definition at line 987 of file pageres.cpp.

{
block_res_it.set_to_list(&page_res->block_res_list);
block_res_it.mark_cycle_pt();
prev_block_res = NULL;
prev_row_res = NULL;
prev_word_res = NULL;
block_res = NULL;
row_res = NULL;
word_res = NULL;
next_block_res = NULL;
next_row_res = NULL;
next_word_res = NULL;
internal_forward(true, empty_ok);
return internal_forward(false, empty_ok);
}
WERD_RES* PAGE_RES_IT::word ( ) const
inline

Definition at line 757 of file pageres.h.

{ // current word
return word_res;
}

Member Data Documentation

PAGE_RES* PAGE_RES_IT::page_res

Definition at line 691 of file pageres.h.


The documentation for this class was generated from the following files: