#include <pageres.h>

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_RES *	restart_page ()

WERD_RES *	restart_page_with_empties ()

WERD_RES *	start_page (bool empty_ok)

WERD_RES *	restart_row ()

WERD_RES *	InsertSimpleCloneWord (const WERD_RES &clone_res, WERD *new_word)

void	DeleteCurrentWord ()

WERD_RES *	forward ()

WERD_RES *	forward_with_empties ()

WERD_RES *	forward_paragraph ()

WERD_RES *	forward_block ()

WERD_RES *	prev_word () const

ROW_RES *	prev_row () const

BLOCK_RES *	prev_block () const

WERD_RES *	word () const

ROW_RES *	row () const

BLOCK_RES *	block () const

WERD_RES *	next_word () const

ROW_RES *	next_row () const

BLOCK_RES *	next_block () const

void	rej_stat_word ()

Public Attributes
PAGE_RES *	page_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.

693 {

694 } // 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.

                                                    {
   ASSERT_HOST(page_res == other.page_res);
   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.
   ASSERT_HOST(!word_res->part_of_combo);
   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.

705 {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:

/home/abuild/rpmbuild/BUILD/tesseract-ocr-3.02.02/ccstruct/pageres.h
/home/abuild/rpmbuild/BUILD/tesseract-ocr-3.02.02/ccstruct/pageres.cpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation