tesseract  5.0.0-alpha-619-ge9db
tesseract::ResultIterator Class Reference

#include <resultiterator.h>

Inheritance diagram for tesseract::ResultIterator:
tesseract::LTRResultIterator tesseract::PageIterator tesseract::MutableIterator

Public Member Functions

 ~ResultIterator () override=default
 
void Begin () override
 
bool Next (PageIteratorLevel level) override
 
bool IsAtBeginningOf (PageIteratorLevel level) const override
 
bool IsAtFinalElement (PageIteratorLevel level, PageIteratorLevel element) const override
 
int BlanksBeforeWord () const
 
virtual char * GetUTF8Text (PageIteratorLevel level) const
 
virtual std::vector< std::vector< std::vector< std::pair< const char *, float > > > > * GetRawLSTMTimesteps () const
 
virtual std::vector< std::vector< std::pair< const char *, float > > > * GetBestLSTMSymbolChoices () const
 
bool ParagraphIsLtr () const
 
- Public Member Functions inherited from 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)
 
 ~LTRResultIterator () override
 
char * GetUTF8Text (PageIteratorLevel level) const
 
void SetLineSeparator (const char *new_line)
 
void SetParagraphSeparator (const char *new_para)
 
float Confidence (PageIteratorLevel level) const
 
void RowAttributes (float *row_height, float *descenders, float *ascenders) 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 PageIteratoroperator= (const PageIterator &src)
 
bool PositionedAtSameWord (const PAGE_RES_IT *other) const
 
virtual void RestartParagraph ()
 
bool IsWithinFirstTextlineOfParagraph () const
 
virtual void RestartRow ()
 
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 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)
 

Static Public Member Functions

static ResultIteratorStartOfParagraph (const LTRResultIterator &resit)
 
static void CalculateTextlineOrder (bool paragraph_is_ltr, const GenericVector< StrongScriptDirection > &word_dirs, GenericVectorEqEq< int > *reading_order)
 

Static Public Attributes

static const int kMinorRunStart = -1
 
static const int kMinorRunEnd = -2
 
static const int kComplexWord = -3
 

Protected Member Functions

TESS_LOCAL ResultIterator (const LTRResultIterator &resit)
 
- Protected Member Functions inherited from tesseract::PageIterator
TESS_LOCAL void BeginWord (int offset)
 

Additional Inherited Members

- Protected Attributes inherited from tesseract::LTRResultIterator
const char * line_separator_
 
const char * paragraph_separator_
 
- Protected Attributes inherited from tesseract::PageIterator
PAGE_RESpage_res_
 
Tesseracttesseract_
 
PAGE_RES_ITit_
 
WERDword_
 
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_
 

Detailed Description

Definition at line 44 of file resultiterator.h.

Constructor & Destructor Documentation

◆ ~ResultIterator()

tesseract::ResultIterator::~ResultIterator ( )
overridedefault

ResultIterator is copy constructible! The default copy constructor works just fine for us.

◆ ResultIterator()

tesseract::ResultIterator::ResultIterator ( const LTRResultIterator resit)
explicitprotected

We presume the data associated with the given iterator will outlive us. NB: This is private because it does something that is non-obvious: it resets to the beginning of the paragraph instead of staying wherever resit might have pointed.

Definition at line 34 of file resultiterator.cpp.

35  : LTRResultIterator(resit) {
36  in_minor_direction_ = false;
37  at_beginning_of_minor_run_ = false;
38  preserve_interword_spaces_ = false;
39 
40  auto* p = ParamUtils::FindParam<BoolParam>("preserve_interword_spaces",
41  GlobalParams()->bool_params,
43  if (p != nullptr)
44  preserve_interword_spaces_ = (bool)(*p);
45 
46  current_paragraph_is_ltr_ = CurrentParagraphIsLtr();
47  MoveToLogicalStartOfTextline();
48 }

Member Function Documentation

◆ Begin()

void tesseract::ResultIterator::Begin ( )
overridevirtual

Moves the iterator to point to the start of the page to begin an iteration.

Reimplemented from tesseract::PageIterator.

Definition at line 441 of file resultiterator.cpp.

441  {
443  current_paragraph_is_ltr_ = CurrentParagraphIsLtr();
444  in_minor_direction_ = false;
445  at_beginning_of_minor_run_ = false;
446  MoveToLogicalStartOfTextline();
447 }

◆ BlanksBeforeWord()

int tesseract::ResultIterator::BlanksBeforeWord ( ) const

Definition at line 593 of file resultiterator.cpp.

593  {
594  if (CurrentParagraphIsLtr())
596  return IsAtBeginningOf(RIL_TEXTLINE) ? 0 : 1;
597 }

◆ CalculateTextlineOrder()

void tesseract::ResultIterator::CalculateTextlineOrder ( bool  paragraph_is_ltr,
const GenericVector< StrongScriptDirection > &  word_dirs,
GenericVectorEqEq< int > *  reading_order 
)
static

Yields the reading order as a sequence of indices and (optional) meta-marks for a set of words (given left-to-right). The meta marks are passed as negative values: kMinorRunStart Start of minor direction text. kMinorRunEnd End of minor direction text. kComplexWord The next indexed word contains both left-to-right and right-to-left characters and was treated as neutral.

For example, suppose we have five words in a text line, indexed [0,1,2,3,4] from the leftmost side of the text line. The following are all believable reading_orders:

Left-to-Right (in ltr paragraph): { 0, 1, 2, 3, 4 } Left-to-Right (in rtl paragraph): { kMinorRunStart, 0, 1, 2, 3, 4, kMinorRunEnd } Right-to-Left (in rtl paragraph): { 4, 3, 2, 1, 0 } Left-to-Right except for an RTL phrase in words 2, 3 in an ltr paragraph: { 0, 1, kMinorRunStart, 3, 2, kMinorRunEnd, 4 }

Definition at line 272 of file resultiterator.cpp.

275  {
276  reading_order->truncate(0);
277  if (word_dirs.size() == 0)
278  return;
279 
280  // Take all of the runs of minor direction words and insert them
281  // in reverse order.
282  int minor_direction, major_direction, major_step, start, end;
283  if (paragraph_is_ltr) {
284  start = 0;
285  end = word_dirs.size();
286  major_step = 1;
287  major_direction = DIR_LEFT_TO_RIGHT;
288  minor_direction = DIR_RIGHT_TO_LEFT;
289  } else {
290  start = word_dirs.size() - 1;
291  end = -1;
292  major_step = -1;
293  major_direction = DIR_RIGHT_TO_LEFT;
294  minor_direction = DIR_LEFT_TO_RIGHT;
295  // Special rule: if there are neutral words at the right most side
296  // of a line adjacent to a left-to-right word in the middle of the
297  // line, we interpret the end of the line as a single LTR sequence.
298  if (word_dirs[start] == DIR_NEUTRAL) {
299  int neutral_end = start;
300  while (neutral_end > 0 && word_dirs[neutral_end] == DIR_NEUTRAL) {
301  neutral_end--;
302  }
303  if (neutral_end >= 0 && word_dirs[neutral_end] == DIR_LEFT_TO_RIGHT) {
304  // LTR followed by neutrals.
305  // Scan for the beginning of the minor left-to-right run.
306  int left = neutral_end;
307  for (int i = left; i >= 0 && word_dirs[i] != DIR_RIGHT_TO_LEFT; i--) {
308  if (word_dirs[i] == DIR_LEFT_TO_RIGHT)
309  left = i;
310  }
311  reading_order->push_back(kMinorRunStart);
312  for (int i = left; i < word_dirs.size(); i++) {
313  reading_order->push_back(i);
314  if (word_dirs[i] == DIR_MIX)
315  reading_order->push_back(kComplexWord);
316  }
317  reading_order->push_back(kMinorRunEnd);
318  start = left - 1;
319  }
320  }
321  }
322  for (int i = start; i != end;) {
323  if (word_dirs[i] == minor_direction) {
324  int j = i;
325  while (j != end && word_dirs[j] != major_direction) j += major_step;
326  if (j == end)
327  j -= major_step;
328  while (j != i && word_dirs[j] != minor_direction) j -= major_step;
329  // [j..i] is a minor direction run.
330  reading_order->push_back(kMinorRunStart);
331  for (int k = j; k != i; k -= major_step) {
332  reading_order->push_back(k);
333  }
334  reading_order->push_back(i);
335  reading_order->push_back(kMinorRunEnd);
336  i = j + major_step;
337  } else {
338  reading_order->push_back(i);
339  if (word_dirs[i] == DIR_MIX)
340  reading_order->push_back(kComplexWord);
341  i += major_step;
342  }
343  }
344 }

◆ GetBestLSTMSymbolChoices()

std::vector< std::vector< std::pair< const char *, float > > > * tesseract::ResultIterator::GetBestLSTMSymbolChoices ( ) const
virtual

Definition at line 651 of file resultiterator.cpp.

651  {
652  if (it_->word() != nullptr) {
653  return &it_->word()->CTC_symbol_choices;
654  } else {
655  return nullptr;
656  }
657 }

◆ GetRawLSTMTimesteps()

std::vector< std::vector< std::vector< std::pair< const char *, float > > > > * tesseract::ResultIterator::GetRawLSTMTimesteps ( ) const
virtual

Returns the LSTM choices for every LSTM timestep for the current word.

Definition at line 642 of file resultiterator.cpp.

642  {
643  if (it_->word() != nullptr) {
644  return &it_->word()->segmented_timesteps;
645  } else {
646  return nullptr;
647  }
648 }

◆ GetUTF8Text()

char * tesseract::ResultIterator::GetUTF8Text ( PageIteratorLevel  level) const
virtual

Returns the null terminated UTF-8 encoded text string for the current object at the given level. Use delete [] to free after use.

Definition at line 603 of file resultiterator.cpp.

603  {
604  if (it_->word() == nullptr)
605  return nullptr; // Already at the end!
606  STRING text;
607  switch (level) {
608  case RIL_BLOCK: {
609  ResultIterator pp(*this);
610  do {
611  pp.AppendUTF8ParagraphText(&text);
612  } while (pp.Next(RIL_PARA) && pp.it_->block() == it_->block());
613  } break;
614  case RIL_PARA:
615  AppendUTF8ParagraphText(&text);
616  break;
617  case RIL_TEXTLINE: {
618  ResultIterator it(*this);
619  it.MoveToLogicalStartOfTextline();
620  it.IterateAndAppendUTF8TextlineText(&text);
621  } break;
622  case RIL_WORD:
623  AppendUTF8WordText(&text);
624  break;
625  case RIL_SYMBOL: {
626  bool reading_direction_is_ltr =
627  current_paragraph_is_ltr_ ^ in_minor_direction_;
628  if (at_beginning_of_minor_run_) {
629  text += reading_direction_is_ltr ? kLRM : kRLM;
630  }
631  text = it_->word()->BestUTF8(blob_index_, false);
632  if (IsAtFinalSymbolOfWord())
633  AppendSuffixMarks(&text);
634  } break;
635  }
636  int length = text.length() + 1;
637  char* result = new char[length];
638  strncpy(result, text.c_str(), length);
639  return result;
640 }

◆ IsAtBeginningOf()

bool tesseract::ResultIterator::IsAtBeginningOf ( PageIteratorLevel  level) const
overridevirtual

IsAtBeginningOf() returns whether we're at the logical beginning of the given level. (as opposed to ResultIterator's left-to-right top-to-bottom order). Otherwise, this acts the same as PageIterator::IsAtBeginningOf(). For a full description, see pageiterator.h

Reimplemented from tesseract::PageIterator.

Definition at line 527 of file resultiterator.cpp.

527  {
528  if (it_->block() == nullptr)
529  return false; // Already at the end!
530  if (it_->word() == nullptr)
531  return true; // In an image block.
532  if (level == RIL_SYMBOL)
533  return true; // Always at beginning of a symbol.
534 
535  bool at_word_start = IsAtFirstSymbolOfWord();
536  if (level == RIL_WORD)
537  return at_word_start;
538 
539  ResultIterator line_start(*this);
540  // move to the first word in the line...
541  line_start.MoveToLogicalStartOfTextline();
542 
543  bool at_textline_start = at_word_start && *line_start.it_ == *it_;
544  if (level == RIL_TEXTLINE)
545  return at_textline_start;
546 
547  // now we move to the left-most word...
548  line_start.RestartRow();
549  bool at_block_start = at_textline_start &&
550  line_start.it_->block() != line_start.it_->prev_block();
551  if (level == RIL_BLOCK)
552  return at_block_start;
553 
554  bool at_para_start =
555  at_block_start ||
556  (at_textline_start && line_start.it_->row()->row->para() !=
557  line_start.it_->prev_row()->row->para());
558  if (level == RIL_PARA)
559  return at_para_start;
560 
561  ASSERT_HOST(false); // shouldn't happen.
562  return false;
563 }

◆ IsAtFinalElement()

bool tesseract::ResultIterator::IsAtFinalElement ( PageIteratorLevel  level,
PageIteratorLevel  element 
) const
overridevirtual

Implement PageIterator's IsAtFinalElement correctly in a BiDi context. For instance, IsAtFinalElement(RIL_PARA, RIL_WORD) returns whether we point at the last word in a paragraph. See PageIterator for full comment.

NOTE! This is an exact copy of PageIterator::IsAtFinalElement with the change that the variable next is now a ResultIterator instead of a PageIterator.

Reimplemented from tesseract::PageIterator.

Definition at line 570 of file resultiterator.cpp.

571  {
572  if (Empty(element))
573  return true; // Already at the end!
574  // The result is true if we step forward by element and find we are
575  // at the the end of the page or at beginning of *all* levels in:
576  // [level, element).
577  // When there is more than one level difference between element and level,
578  // we could for instance move forward one symbol and still be at the first
579  // word on a line, so we also have to be at the first symbol in a word.
580  ResultIterator next(*this);
581  next.Next(element);
582  if (next.Empty(element))
583  return true; // Reached the end of the page.
584  while (element > level) {
585  element = static_cast<PageIteratorLevel>(element - 1);
586  if (!next.IsAtBeginningOf(element))
587  return false;
588  }
589  return true;
590 }

◆ Next()

bool tesseract::ResultIterator::Next ( PageIteratorLevel  level)
overridevirtual

Moves to the start of the next object at the given level in the page hierarchy in the appropriate reading order and returns false if the end of the page was reached. NOTE that RIL_SYMBOL will skip non-text blocks, but all other PageIteratorLevel level values will visit each non-text block once. Think of non text blocks as containing a single para, with a single line, with a single imaginary word. Calls to Next with different levels may be freely intermixed. This function iterates words in right-to-left scripts correctly, if the appropriate language has been loaded into Tesseract.

Reimplemented from tesseract::PageIterator.

Definition at line 449 of file resultiterator.cpp.

449  {
450  if (it_->block() == nullptr)
451  return false; // already at end!
452  switch (level) {
453  case RIL_BLOCK: // explicit fall-through
454  case RIL_PARA: // explicit fall-through
455  case RIL_TEXTLINE:
456  if (!PageIterator::Next(level))
457  return false;
459  // if we've advanced to a new paragraph,
460  // recalculate current_paragraph_is_ltr_
461  current_paragraph_is_ltr_ = CurrentParagraphIsLtr();
462  }
463  in_minor_direction_ = false;
464  MoveToLogicalStartOfTextline();
465  return it_->block() != nullptr;
466  case RIL_SYMBOL: {
467  GenericVector<int> blob_order;
468  CalculateBlobOrder(&blob_order);
469  int next_blob = 0;
470  while (next_blob < blob_order.size() &&
471  blob_index_ != blob_order[next_blob])
472  next_blob++;
473  next_blob++;
474  if (next_blob < blob_order.size()) {
475  // we're in the same word; simply advance one blob.
476  BeginWord(blob_order[next_blob]);
477  at_beginning_of_minor_run_ = false;
478  return true;
479  }
480  level = RIL_WORD; // we've fallen through to the next word.
481  }
482  // Fall through.
483  case RIL_WORD: // explicit fall-through.
484  {
485  if (it_->word() == nullptr)
486  return Next(RIL_BLOCK);
487  GenericVectorEqEq<int> word_indices;
488  int this_word_index = LTRWordIndex();
489  CalculateTextlineOrder(current_paragraph_is_ltr_, *this, &word_indices);
490  int final_real_index = word_indices.size() - 1;
491  while (final_real_index > 0 && word_indices[final_real_index] < 0)
492  final_real_index--;
493  for (int i = 0; i < final_real_index; i++) {
494  if (word_indices[i] == this_word_index) {
495  int j = i + 1;
496  for (; j < final_real_index && word_indices[j] < 0; j++) {
497  if (word_indices[j] == kMinorRunStart)
498  in_minor_direction_ = true;
499  if (word_indices[j] == kMinorRunEnd)
500  in_minor_direction_ = false;
501  }
502  at_beginning_of_minor_run_ = (word_indices[j - 1] == kMinorRunStart);
503  // awesome, we move to word_indices[j]
504  if (BidiDebug(3)) {
505  tprintf("Next(RIL_WORD): %d -> %d\n", this_word_index,
506  word_indices[j]);
507  }
509  for (int k = 0; k < word_indices[j]; k++) {
511  }
512  MoveToLogicalStartOfWord();
513  return true;
514  }
515  }
516  if (BidiDebug(3)) {
517  tprintf("Next(RIL_WORD): %d -> EOL\n", this_word_index);
518  }
519  // we're going off the end of the text line.
520  return Next(RIL_TEXTLINE);
521  }
522  }
523  ASSERT_HOST(false); // shouldn't happen.
524  return false;
525 }

◆ ParagraphIsLtr()

bool tesseract::ResultIterator::ParagraphIsLtr ( ) const

Return whether the current paragraph's dominant reading direction is left-to-right (as opposed to right-to-left).

Definition at line 55 of file resultiterator.cpp.

55  {
56  return current_paragraph_is_ltr_;
57 }

◆ StartOfParagraph()

ResultIterator * tesseract::ResultIterator::StartOfParagraph ( const LTRResultIterator resit)
static

Definition at line 50 of file resultiterator.cpp.

51  {
52  return new ResultIterator(resit);
53 }

Member Data Documentation

◆ kComplexWord

const int tesseract::ResultIterator::kComplexWord = -3
static

Definition at line 148 of file resultiterator.h.

◆ kMinorRunEnd

const int tesseract::ResultIterator::kMinorRunEnd = -2
static

Definition at line 147 of file resultiterator.h.

◆ kMinorRunStart

const int tesseract::ResultIterator::kMinorRunStart = -1
static

Definition at line 146 of file resultiterator.h.


The documentation for this class was generated from the following files:
tesseract::ResultIterator::ResultIterator
TESS_LOCAL ResultIterator(const LTRResultIterator &resit)
Definition: resultiterator.cpp:34
tesseract::kRLM
const char *const kRLM
Right-to-Left Mark.
Definition: unicodes.cpp:39
tesseract::RIL_WORD
Definition: publictypes.h:220
tesseract::PageIterator::RestartRow
virtual void RestartRow()
Definition: pageiterator.cpp:129
tesseract::ResultIterator::CalculateTextlineOrder
static void CalculateTextlineOrder(bool paragraph_is_ltr, const GenericVector< StrongScriptDirection > &word_dirs, GenericVectorEqEq< int > *reading_order)
Definition: resultiterator.cpp:272
tesseract::PageIterator::it_
PAGE_RES_IT * it_
Definition: pageiterator.h:332
ASSERT_HOST
#define ASSERT_HOST(x)
Definition: errcode.h:87
tesseract::RIL_BLOCK
Definition: publictypes.h:217
WERD_RES::BestUTF8
const char * BestUTF8(int blob_index, bool in_rtl_context) const
Definition: pageres.h:357
PAGE_RES_IT::block
BLOCK_RES * block() const
Definition: pageres.h:754
tesseract::ResultIterator::kMinorRunStart
static const int kMinorRunStart
Definition: resultiterator.h:146
STRING
Definition: strngs.h:45
tesseract::ResultIterator::IsAtBeginningOf
bool IsAtBeginningOf(PageIteratorLevel level) const override
Definition: resultiterator.cpp:527
tesseract::LTRResultIterator::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: ltrresultiterator.cpp:29
tesseract::PageIterator::IsWithinFirstTextlineOfParagraph
bool IsWithinFirstTextlineOfParagraph() const
Definition: pageiterator.cpp:123
DIR_LEFT_TO_RIGHT
Definition: unichar.h:45
tesseract::RIL_SYMBOL
Definition: publictypes.h:221
WERD_RES::segmented_timesteps
std::vector< std::vector< std::vector< std::pair< const char *, float > > > > segmented_timesteps
Definition: pageres.h:218
tesseract::kLRM
const char *const kLRM
Left-to-Right Mark.
Definition: unicodes.cpp:38
GenericVector::push_back
int push_back(T object)
Definition: genericvector.h:799
tesseract::PageIterator::Empty
bool Empty(PageIteratorLevel level) const
Definition: pageiterator.cpp:349
STRING::c_str
const char * c_str() const
Definition: strngs.cpp:192
tesseract::PageIterator::Next
virtual bool Next(PageIteratorLevel level)
Definition: pageiterator.cpp:147
tesseract::PageIterator::tesseract_
Tesseract * tesseract_
Definition: pageiterator.h:327
tesseract::ResultIterator::kComplexWord
static const int kComplexWord
Definition: resultiterator.h:148
WERD_RES::CTC_symbol_choices
std::vector< std::vector< std::pair< const char *, float > > > CTC_symbol_choices
Definition: pageres.h:220
tesseract::ResultIterator::kMinorRunEnd
static const int kMinorRunEnd
Definition: resultiterator.h:147
tesseract::LTRResultIterator::BlanksBeforeWord
int BlanksBeforeWord() const
Definition: ltrresultiterator.cpp:244
GlobalParams
tesseract::ParamsVectors * GlobalParams()
Definition: params.cpp:32
PAGE_RES_IT::word
WERD_RES * word() const
Definition: pageres.h:748
tesseract::CCUtil::params
ParamsVectors * params()
Definition: ccutil.h:51
GenericVectorEqEq< int >
tesseract::RIL_TEXTLINE
Definition: publictypes.h:219
tesseract::ResultIterator::Next
bool Next(PageIteratorLevel level) override
Definition: resultiterator.cpp:449
GenericVector< int >
DIR_NEUTRAL
Definition: unichar.h:44
tesseract::PageIterator::Begin
virtual void Begin()
Definition: pageiterator.cpp:105
STRING::length
int32_t length() const
Definition: strngs.cpp:187
GenericVector::truncate
void truncate(int size)
Definition: genericvector.h:132
tprintf
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:34
DIR_RIGHT_TO_LEFT
Definition: unichar.h:46
DIR_MIX
Definition: unichar.h:47
tesseract::PageIterator::BeginWord
TESS_LOCAL void BeginWord(int offset)
Definition: pageiterator.cpp:585
GenericVector::size
int size() const
Definition: genericvector.h:71
tesseract::RIL_PARA
Definition: publictypes.h:218
tesseract::ParamsVectors::bool_params
GenericVector< BoolParam * > bool_params
Definition: params.h:58
tesseract::PageIterator::blob_index_
int blob_index_
Definition: pageiterator.h:341