#include <ltrresultiterator.h>

Inheritance diagram for tesseract::LTRResultIterator:

Public Member Functions
	LTRResultIterator (PAGE_RES page_res, Tesseract tesseract, int scale, int scaled_yres, int rect_left, int rect_top, int rect_width, int rect_height)

	~LTRResultIterator () override

char *	GetUTF8Text (PageIteratorLevel level) const

void	SetLineSeparator (const char *new_line)

void	SetParagraphSeparator (const char *new_para)

float	Confidence (PageIteratorLevel level) const

const char *	WordFontAttributes (bool is_bold, bool is_italic, bool is_underlined, bool is_monospace, bool is_serif, bool is_smallcaps, int pointsize, int font_id) const

const char *	WordRecognitionLanguage () const

StrongScriptDirection	WordDirection () const

bool	WordIsFromDictionary () const

int	BlanksBeforeWord () const

bool	WordIsNumeric () const

bool	HasBlamerInfo () const

const void *	GetParamsTrainingBundle () const

const char *	GetBlamerDebug () const

const char *	GetBlamerMisadaptionDebug () const

bool	HasTruthString () const

bool	EquivalentToTruth (const char *str) const

char *	WordTruthUTF8Text () const

char *	WordNormedUTF8Text () const

const char *	WordLattice (int *lattice_size) const

bool	SymbolIsSuperscript () const

bool	SymbolIsSubscript () const

bool	SymbolIsDropcap () const

Public Member Functions inherited from tesseract::PageIterator
	PageIterator (PAGE_RES page_res, Tesseract tesseract, int scale, int scaled_yres, int rect_left, int rect_top, int rect_width, int rect_height)

virtual	~PageIterator ()

	PageIterator (const PageIterator &src)

const PageIterator &	operator= (const PageIterator &src)

bool	PositionedAtSameWord (const PAGE_RES_IT *other) const

virtual void	Begin ()

virtual void	RestartParagraph ()

bool	IsWithinFirstTextlineOfParagraph () const

virtual void	RestartRow ()

virtual bool	Next (PageIteratorLevel level)

virtual bool	IsAtBeginningOf (PageIteratorLevel level) const

virtual bool	IsAtFinalElement (PageIteratorLevel level, PageIteratorLevel element) const

int	Cmp (const PageIterator &other) const

void	SetBoundingBoxComponents (bool include_upper_dots, bool include_lower_dots)

bool	BoundingBox (PageIteratorLevel level, int left, int top, int right, int bottom) const

bool	BoundingBox (PageIteratorLevel level, int padding, int left, int top, int right, int bottom) const

bool	BoundingBoxInternal (PageIteratorLevel level, int left, int top, int right, int bottom) const

bool	Empty (PageIteratorLevel level) const

PolyBlockType	BlockType () const

Pta *	BlockPolygon () const

Pix *	GetBinaryImage (PageIteratorLevel level) const

Pix *	GetImage (PageIteratorLevel level, int padding, Pix original_img, int left, int *top) const

bool	Baseline (PageIteratorLevel level, int x1, int y1, int x2, int y2) const

void	RowAttributes (float row_height, float descenders, float *ascenders) const

void	Orientation (tesseract::Orientation orientation, tesseract::WritingDirection writing_direction, tesseract::TextlineOrder textline_order, float deskew_angle) const

void	ParagraphInfo (tesseract::ParagraphJustification justification, bool is_list_item, bool is_crown, int first_line_indent) const

bool	SetWordBlamerBundle (BlamerBundle *blamer_bundle)

Protected Attributes
const char *	line_separator_

const char *	paragraph_separator_

Protected Attributes inherited from tesseract::PageIterator
PAGE_RES *	page_res_

Tesseract *	tesseract_

PAGE_RES_IT *	it_

WERD *	word_

int	word_length_

int	blob_index_

C_BLOB_IT *	cblob_it_

bool	include_upper_dots_

bool	include_lower_dots_

int	scale_

int	scaled_yres_

int	rect_left_

int	rect_top_

int	rect_width_

int	rect_height_

Friends
class	ChoiceIterator

Additional Inherited Members
Protected Member Functions inherited from tesseract::PageIterator
void	BeginWord (int offset)

Detailed Description

Definition at line 45 of file ltrresultiterator.h.

Constructor & Destructor Documentation

◆ LTRResultIterator()

tesseract::LTRResultIterator::LTRResultIterator	(	PAGE_RES *	page_res,
		Tesseract *	tesseract,
		int	scale,
		int	scaled_yres,
		int	rect_left,
		int	rect_top,
		int	rect_width,
		int	rect_height
	)

Definition at line 29 of file ltrresultiterator.cpp.

    : PageIterator(page_res, tesseract, scale, scaled_yres, rect_left, rect_top, rect_width,
                   rect_height)
    , line_separator_("\n")
    , paragraph_separator_("\n") {}

◆ ~LTRResultIterator()

tesseract::LTRResultIterator::~LTRResultIterator ( )

overridedefault

Member Function Documentation

◆ BlanksBeforeWord()

int tesseract::LTRResultIterator::BlanksBeforeWord ( ) const

Definition at line 241 of file ltrresultiterator.cpp.

                                              {
  if (it_->word() == nullptr) {
    return 1;
  }
  return it_->word()->word->space();
}

◆ Confidence()

float tesseract::LTRResultIterator::Confidence ( PageIteratorLevel level ) const

Definition at line 97 of file ltrresultiterator.cpp.

                                                                 {
  if (it_->word() == nullptr) {
    return 0.0f; // Already at the end!
  }
  float mean_certainty = 0.0f;
  int certainty_count = 0;
  PAGE_RES_IT res_it(*it_);
  WERD_CHOICE *best_choice = res_it.word()->best_choice;
  ASSERT_HOST(best_choice != nullptr);
  switch (level) {
    case RIL_BLOCK:
      do {
        best_choice = res_it.word()->best_choice;
        ASSERT_HOST(best_choice != nullptr);
        mean_certainty += best_choice->certainty();
        ++certainty_count;
        res_it.forward();
      } while (res_it.block() == res_it.prev_block());
      break;
    case RIL_PARA:
      do {
        best_choice = res_it.word()->best_choice;
        ASSERT_HOST(best_choice != nullptr);
        mean_certainty += best_choice->certainty();
        ++certainty_count;
        res_it.forward();
      } while (res_it.block() == res_it.prev_block() &&
               res_it.row()->row->para() == res_it.prev_row()->row->para());
      break;
    case RIL_TEXTLINE:
      do {
        best_choice = res_it.word()->best_choice;
        ASSERT_HOST(best_choice != nullptr);
        mean_certainty += best_choice->certainty();
        ++certainty_count;
        res_it.forward();
      } while (res_it.row() == res_it.prev_row());
      break;
    case RIL_WORD:
      mean_certainty += best_choice->certainty();
      ++certainty_count;
      break;
    case RIL_SYMBOL:
      mean_certainty += best_choice->certainty(blob_index_);
      ++certainty_count;
  }
  if (certainty_count > 0) {
    mean_certainty /= certainty_count;
    return ClipToRange(100 + 5 * mean_certainty, 0.0f, 100.0f);
  }
  return 0.0f;
}

◆ EquivalentToTruth()

bool tesseract::LTRResultIterator::EquivalentToTruth ( const char * str ) const

Definition at line 298 of file ltrresultiterator.cpp.

                                                               {
  if (!HasTruthString()) {
    return false;
  }
  ASSERT_HOST(it_->word()->uch_set != nullptr);
  WERD_CHOICE str_wd(str, *(it_->word()->uch_set));
  return it_->word()->blamer_bundle->ChoiceIsCorrect(&str_wd);
}

◆ GetBlamerDebug()

const char * tesseract::LTRResultIterator::GetBlamerDebug ( ) const

Definition at line 275 of file ltrresultiterator.cpp.

                                                    {
  return it_->word()->blamer_bundle->debug().c_str();
}

◆ GetBlamerMisadaptionDebug()

const char * tesseract::LTRResultIterator::GetBlamerMisadaptionDebug ( ) const

Definition at line 281 of file ltrresultiterator.cpp.

                                                               {
  return it_->word()->blamer_bundle->misadaption_debug().c_str();
}

◆ GetParamsTrainingBundle()

const void * tesseract::LTRResultIterator::GetParamsTrainingBundle ( ) const

Definition at line 266 of file ltrresultiterator.cpp.

                                                             {
  return (it_->word() != nullptr && it_->word()->blamer_bundle != nullptr)
             ? &(it_->word()->blamer_bundle->params_training_bundle())
             : nullptr;
}

◆ GetUTF8Text()

char * tesseract::LTRResultIterator::GetUTF8Text ( PageIteratorLevel level ) const

Definition at line 44 of file ltrresultiterator.cpp.

                                                                  {
  if (it_->word() == nullptr) {
    return nullptr; // Already at the end!
  }
  std::string text;
  PAGE_RES_IT res_it(*it_);
  WERD_CHOICE *best_choice = res_it.word()->best_choice;
  ASSERT_HOST(best_choice != nullptr);
  if (level == RIL_SYMBOL) {
    text = res_it.word()->BestUTF8(blob_index_, false);
  } else if (level == RIL_WORD) {
    text = best_choice->unichar_string();
  } else {
    bool eol = false; // end of line?
    bool eop = false; // end of paragraph?
    do {              // for each paragraph in a block
      do {            // for each text line in a paragraph
        do {          // for each word in a text line
          best_choice = res_it.word()->best_choice;
          ASSERT_HOST(best_choice != nullptr);
          text += best_choice->unichar_string();
          text += " ";
          res_it.forward();
          eol = res_it.row() != res_it.prev_row();
        } while (!eol);
        text.resize(text.length() - 1);
        text += line_separator_;
        eop = res_it.block() != res_it.prev_block() ||
              res_it.row()->row->para() != res_it.prev_row()->row->para();
      } while (level != RIL_TEXTLINE && !eop);
      if (eop) {
        text += paragraph_separator_;
      }
    } while (level == RIL_BLOCK && res_it.block() == res_it.prev_block());
  }
  int length = text.length() + 1;
  char *result = new char[length];
  strncpy(result, text.c_str(), length);
  return result;
}

◆ HasBlamerInfo()

bool tesseract::LTRResultIterator::HasBlamerInfo ( ) const

Definition at line 258 of file ltrresultiterator.cpp.

                                            {
  return it_->word() != nullptr && it_->word()->blamer_bundle != nullptr &&
         it_->word()->blamer_bundle->HasDebugInfo();
}

◆ HasTruthString()

bool tesseract::LTRResultIterator::HasTruthString ( ) const

Definition at line 286 of file ltrresultiterator.cpp.

                                             {
  if (it_->word() == nullptr) {
    return false; // Already at the end!
  }
  if (it_->word()->blamer_bundle == nullptr || it_->word()->blamer_bundle->NoTruth()) {
    return false; // no truth information for this word
  }
  return true;
}

◆ SetLineSeparator()

void tesseract::LTRResultIterator::SetLineSeparator ( const char * new_line )

Definition at line 86 of file ltrresultiterator.cpp.

                                                             {
  line_separator_ = new_line;
}

◆ SetParagraphSeparator()

void tesseract::LTRResultIterator::SetParagraphSeparator ( const char * new_para )

Definition at line 91 of file ltrresultiterator.cpp.

                                                                  {
  paragraph_separator_ = new_para;
}

◆ SymbolIsDropcap()

bool tesseract::LTRResultIterator::SymbolIsDropcap ( ) const

Definition at line 375 of file ltrresultiterator.cpp.

                                              {
  if (cblob_it_ == nullptr && it_->word() != nullptr) {
    return it_->word()->best_choice->BlobPosition(blob_index_) == SP_DROPCAP;
  }
  return false;
}

◆ SymbolIsSubscript()

bool tesseract::LTRResultIterator::SymbolIsSubscript ( ) const

Definition at line 365 of file ltrresultiterator.cpp.

                                                {
  if (cblob_it_ == nullptr && it_->word() != nullptr) {
    return it_->word()->best_choice->BlobPosition(blob_index_) == SP_SUBSCRIPT;
  }
  return false;
}

◆ SymbolIsSuperscript()

bool tesseract::LTRResultIterator::SymbolIsSuperscript ( ) const

Definition at line 355 of file ltrresultiterator.cpp.

                                                  {
  if (cblob_it_ == nullptr && it_->word() != nullptr) {
    return it_->word()->best_choice->BlobPosition(blob_index_) == SP_SUPERSCRIPT;
  }
  return false;
}

◆ WordDirection()

StrongScriptDirection tesseract::LTRResultIterator::WordDirection ( ) const

Definition at line 213 of file ltrresultiterator.cpp.

                                                             {
  if (it_->word() == nullptr) {
    return DIR_NEUTRAL;
  }
  bool has_rtl = it_->word()->AnyRtlCharsInWord();
  bool has_ltr = it_->word()->AnyLtrCharsInWord();
  if (has_rtl && !has_ltr) {
    return DIR_RIGHT_TO_LEFT;
  }
  if (has_ltr && !has_rtl) {
    return DIR_LEFT_TO_RIGHT;
  }
  if (!has_ltr && !has_rtl) {
    return DIR_NEUTRAL;
  }
  return DIR_MIX;
}

◆ WordFontAttributes()

const char * tesseract::LTRResultIterator::WordFontAttributes	(	bool *	is_bold,
		bool *	is_italic,
		bool *	is_underlined,
		bool *	is_monospace,
		bool *	is_serif,
		bool *	is_smallcaps,
		int *	pointsize,
		int *	font_id
	)		const

Definition at line 158 of file ltrresultiterator.cpp.

                                                                                      {
  const char *result = nullptr;
 
  if (it_->word() == nullptr) {
    // Already at the end!
    *pointsize = 0;
  } else {
    float row_height =
        it_->row()->row->x_height() + it_->row()->row->ascenders() - it_->row()->row->descenders();
    // Convert from pixels to printers points.
    *pointsize =
        scaled_yres_ > 0 ? static_cast<int>(row_height * kPointsPerInch / scaled_yres_ + 0.5) : 0;
 
#ifndef DISABLED_LEGACY_ENGINE
    const FontInfo *font_info = it_->word()->fontinfo;
    if (font_info) {
      // Font information available.
      *font_id = font_info->universal_id;
      *is_bold = font_info->is_bold();
      *is_italic = font_info->is_italic();
      *is_underlined = false; // TODO(rays) fix this!
      *is_monospace = font_info->is_fixed_pitch();
      *is_serif = font_info->is_serif();
      result = font_info->name;
    }
#endif // ndef DISABLED_LEGACY_ENGINE
 
    *is_smallcaps = it_->word()->small_caps;
  }
 
  if (!result) {
    *is_bold = false;
    *is_italic = false;
    *is_underlined = false;
    *is_monospace = false;
    *is_serif = false;
    *is_smallcaps = false;
    *font_id = -1;
  }
 
  return result;
}

◆ WordIsFromDictionary()

bool tesseract::LTRResultIterator::WordIsFromDictionary ( ) const

Definition at line 232 of file ltrresultiterator.cpp.

                                                   {
  if (it_->word() == nullptr) {
    return false; // Already at the end!
  }
  int permuter = it_->word()->best_choice->permuter();
  return permuter == SYSTEM_DAWG_PERM || permuter == FREQ_DAWG_PERM || permuter == USER_DAWG_PERM;
}

◆ WordIsNumeric()

bool tesseract::LTRResultIterator::WordIsNumeric ( ) const

Definition at line 249 of file ltrresultiterator.cpp.

                                            {
  if (it_->word() == nullptr) {
    return false; // Already at the end!
  }
  int permuter = it_->word()->best_choice->permuter();
  return permuter == NUMBER_PERM;
}

◆ WordLattice()

const char * tesseract::LTRResultIterator::WordLattice ( int * lattice_size ) const

Definition at line 341 of file ltrresultiterator.cpp.

                                                                  {
  if (it_->word() == nullptr) {
    return nullptr; // Already at the end!
  }
  if (it_->word()->blamer_bundle == nullptr) {
    return nullptr;
  }
  *lattice_size = it_->word()->blamer_bundle->lattice_size();
  return it_->word()->blamer_bundle->lattice_data();
}

◆ WordNormedUTF8Text()

char * tesseract::LTRResultIterator::WordNormedUTF8Text ( ) const

Definition at line 322 of file ltrresultiterator.cpp.

                                                  {
  if (it_->word() == nullptr) {
    return nullptr; // Already at the end!
  }
  std::string ocr_text;
  WERD_CHOICE *best_choice = it_->word()->best_choice;
  const UNICHARSET *unicharset = it_->word()->uch_set;
  ASSERT_HOST(best_choice != nullptr);
  for (unsigned i = 0; i < best_choice->length(); ++i) {
    ocr_text += unicharset->get_normed_unichar(best_choice->unichar_id(i));
  }
  auto length = ocr_text.length() + 1;
  char *result = new char[length];
  strncpy(result, ocr_text.c_str(), length);
  return result;
}

◆ WordRecognitionLanguage()

const char * tesseract::LTRResultIterator::WordRecognitionLanguage ( ) const

Definition at line 205 of file ltrresultiterator.cpp.

                                                             {
  if (it_->word() == nullptr || it_->word()->tesseract == nullptr) {
    return nullptr;
  }
  return it_->word()->tesseract->lang.c_str();
}

◆ WordTruthUTF8Text()

char * tesseract::LTRResultIterator::WordTruthUTF8Text ( ) const

Definition at line 309 of file ltrresultiterator.cpp.

                                                 {
  if (!HasTruthString()) {
    return nullptr;
  }
  std::string truth_text = it_->word()->blamer_bundle->TruthString();
  int length = truth_text.length() + 1;
  char *result = new char[length];
  strncpy(result, truth_text.c_str(), length);
  return result;
}

Friends And Related Function Documentation

◆ ChoiceIterator

friend class ChoiceIterator

friend

Definition at line 46 of file ltrresultiterator.h.

Member Data Documentation

◆ line_separator_

const char* tesseract::LTRResultIterator::line_separator_

protected

Definition at line 175 of file ltrresultiterator.h.

◆ paragraph_separator_

const char* tesseract::LTRResultIterator::paragraph_separator_