tesseract::ChoiceIterator Class Reference

#include <ltrresultiterator.h>

Public Member Functions
	ChoiceIterator (const LTRResultIterator &result_it)
	~ChoiceIterator ()
bool	Next ()
const char *	GetUTF8Text () const
float	Confidence () const
std::vector< std::vector< std::pair< const char *, float > > > *	Timesteps () const

Detailed Description

Definition at line 186 of file ltrresultiterator.h.

Constructor & Destructor Documentation

ChoiceIterator()

tesseract::ChoiceIterator::ChoiceIterator ( const LTRResultIterator &  result_it )

explicit

Definition at line 376 of file ltrresultiterator.cpp.

                                                                 {
  ASSERT_HOST(result_it.it_->word() != nullptr);
  word_res_ = result_it.it_->word();
  oemLSTM_ = word_res_->tesseract->AnyLSTMLang();
  // Is there legacy engine related trained data?
  bool oemLegacy = word_res_->tesseract->AnyTessLang();
  // Is lstm_choice_mode activated?
  bool lstm_choice_mode = word_res_->tesseract->lstm_choice_mode;
  rating_coefficient_ = word_res_->tesseract->lstm_rating_coefficient;
  blanks_before_word_ = result_it.BlanksBeforeWord();
  BLOB_CHOICE_LIST* choices = nullptr; 
  tstep_index_ = &result_it.blob_index_;
  if (oemLSTM_ && !word_res_->CTC_symbol_choices.empty()) {
    if (!word_res_->CTC_symbol_choices[0].empty() &&
        strcmp(word_res_->CTC_symbol_choices[0][0].first, " ")) {
      blanks_before_word_ = 0;
    }
    auto index = *tstep_index_;
    index += blanks_before_word_;
    if (index < word_res_->CTC_symbol_choices.size()) {
      LSTM_choices_ = &word_res_->CTC_symbol_choices[index];
      filterSpaces();
    }
  }
  if ((oemLegacy || !lstm_choice_mode) && word_res_->ratings != nullptr)
    choices = word_res_->GetBlobChoices(result_it.blob_index_);
  if (choices != nullptr && !choices->empty()) {
    choice_it_ = new BLOB_CHOICE_IT(choices);
    choice_it_->mark_cycle_pt();
  } else {
    choice_it_ = nullptr;
  }
  if (LSTM_choices_ != nullptr && !LSTM_choices_->empty()) {
    LSTM_choice_it_ = LSTM_choices_->begin();
  }
}

~ChoiceIterator()

tesseract::ChoiceIterator::~ChoiceIterator

(

)

Definition at line 412 of file ltrresultiterator.cpp.

                                {
  delete choice_it_;
}

Member Function Documentation

Confidence()

float tesseract::ChoiceIterator::Confidence

(

)

const

Definition at line 455 of file ltrresultiterator.cpp.

                                       {
  float confidence;
  if (oemLSTM_ && LSTM_choices_ != nullptr && !LSTM_choices_->empty()) {
    std::pair<const char*, float> choice = *LSTM_choice_it_;
    confidence = 100 - rating_coefficient_ * choice.second;
  } else {
    if (choice_it_ == nullptr)
      return 0.0f;
    confidence = 100 + 5 * choice_it_->data()->certainty();
  }
  return ClipToRange(confidence, 0.0f, 100.0f);
}

GetUTF8Text()

const char * tesseract::ChoiceIterator::GetUTF8Text

(

)

const

Definition at line 437 of file ltrresultiterator.cpp.

                                              {
  if (oemLSTM_ && LSTM_choices_ != nullptr && !LSTM_choices_->empty()) {
    std::pair<const char*, float> choice = *LSTM_choice_it_;
    return choice.first;
  } else {
    if (choice_it_ == nullptr)
      return nullptr;
    UNICHAR_ID id = choice_it_->data()->unichar_id();
    return word_res_->uch_set->id_to_unichar_ext(id);
  }
}

Next()

bool tesseract::ChoiceIterator::Next

(

)

Definition at line 418 of file ltrresultiterator.cpp.

                          {
  if (oemLSTM_ && LSTM_choices_ != nullptr && !LSTM_choices_->empty()) {
    if (LSTM_choice_it_ != LSTM_choices_->end() &&
        next(LSTM_choice_it_) == LSTM_choices_->end()) {
      return false;
    } else {
      ++LSTM_choice_it_;
      return true;
    }
  } else {
    if (choice_it_ == nullptr)
      return false;
    choice_it_->forward();
    return !choice_it_->cycled_list();
  }
}

Timesteps()

std::vector< std::vector< std::pair< const char *, float > > > * tesseract::ChoiceIterator::Timesteps

(

)

const

Definition at line 470 of file ltrresultiterator.cpp.

                                {
  int offset = *tstep_index_ + blanks_before_word_;
  if (offset >= word_res_->segmented_timesteps.size() || !oemLSTM_) {
    return nullptr;
  }
  return &word_res_->segmented_timesteps[offset];
}

---

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

• /tesseract/include/tesseract/ltrresultiterator.h
• /tesseract/src/ccmain/ltrresultiterator.cpp