Tesseract  3.02
Public Member Functions | Public Attributes
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_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.

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

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