tesseract::BlamerBundle Struct Reference

#include <blamer.h>

Public Member Functions
	BlamerBundle ()
	BlamerBundle (const BlamerBundle &other)
	~BlamerBundle ()
std::string	TruthString () const
IncorrectResultReason	incorrect_result_reason () const
bool	NoTruth () const
bool	HasDebugInfo () const
const std::string &	debug () const
const std::string &	misadaption_debug () const
void	UpdateBestRating (float rating)
int	correct_segmentation_length () const
bool	MatrixPositionCorrect (int index, const MATRIX_COORD &coord)
void	set_best_choice_is_dict_and_top_choice (bool value)
const char *	lattice_data () const
int	lattice_size () const
void	set_lattice_data (const char *data, int size)
const tesseract::ParamsTrainingBundle &	params_training_bundle () const
void	AddHypothesis (const tesseract::ParamsTrainingHypothesis &hypo)
void	SetWordTruth (const UNICHARSET &unicharset, const char *truth_str, const TBOX &word_box)
void	SetSymbolTruth (const UNICHARSET &unicharset, const char *char_str, const TBOX &char_box)
void	SetRejectedTruth ()
bool	ChoiceIsCorrect (const WERD_CHOICE *word_choice) const
void	ClearResults ()
void	CopyTruth (const BlamerBundle &other)
void	CopyResults (const BlamerBundle &other)
const char *	IncorrectReason () const
void	FillDebugString (const std::string &msg, const WERD_CHOICE *choice, std::string &debug)
void	SetupNormTruthWord (const DENORM &denorm)
void	SplitBundle (int word1_right, int word2_left, bool debug, BlamerBundle *bundle1, BlamerBundle *bundle2) const
void	JoinBlames (const BlamerBundle &bundle1, const BlamerBundle &bundle2, bool debug)
void	BlameClassifier (const UNICHARSET &unicharset, const TBOX &blob_box, const BLOB_CHOICE_LIST &choices, bool debug)
void	SetChopperBlame (const WERD_RES *word, bool debug)
void	BlameClassifierOrLangModel (const WERD_RES *word, const UNICHARSET &unicharset, bool valid_permuter, bool debug)
void	SetupCorrectSegmentation (const TWERD *word, bool debug)
bool	GuidedSegsearchNeeded (const WERD_CHOICE *best_choice) const
void	InitForSegSearch (const WERD_CHOICE *best_choice, MATRIX *ratings, UNICHAR_ID wildcard_id, bool debug, std::string &debug_str, tesseract::LMPainPoints *pain_points, double max_char_wh_ratio, WERD_RES *word_res)
bool	GuidedSegsearchStillGoing () const
void	FinishSegSearch (const WERD_CHOICE *best_choice, bool debug, std::string &debug_str)
void	SetMisAdaptionDebug (const WERD_CHOICE *best_choice, bool debug)

Static Public Member Functions
static const char *	IncorrectReasonName (IncorrectResultReason irr)
static void	LastChanceBlame (bool debug, WERD_RES *word)

Detailed Description

Definition at line 107 of file blamer.h.

Constructor & Destructor Documentation

BlamerBundle() [1/2]

tesseract::BlamerBundle::BlamerBundle ( )

inline

Definition at line 109 of file blamer.h.

      : truth_has_char_boxes_(false)
      , incorrect_result_reason_(IRR_CORRECT)
      , lattice_data_(nullptr) {
    ClearResults();
  }

BlamerBundle() [2/2]

tesseract::BlamerBundle::BlamerBundle ( const BlamerBundle &  other )

inline

Definition at line 115 of file blamer.h.

                                          {
    this->CopyTruth(other);
    this->CopyResults(other);
  }

~BlamerBundle()

tesseract::BlamerBundle::~BlamerBundle ( )

inline

Definition at line 119 of file blamer.h.

                  {
    delete[] lattice_data_;
  }

Member Function Documentation

AddHypothesis()

void tesseract::BlamerBundle::AddHypothesis ( const tesseract::ParamsTrainingHypothesis &  hypo )

inline

Definition at line 180 of file blamer.h.

                                                                    {
    params_training_bundle_.AddHypothesis(hypo);
  }

BlameClassifier()

void tesseract::BlamerBundle::BlameClassifier	(	const UNICHARSET &	unicharset,
		const TBOX &	blob_box,
		const BLOB_CHOICE_LIST &	choices,
		bool	debug
	)

Definition at line 260 of file blamer.cpp.

                                                                                {
  if (!truth_has_char_boxes_ || incorrect_result_reason_ != IRR_CORRECT) {
    return; // Nothing to do here.
  }
 
  for (unsigned b = 0; b < norm_truth_word_.length(); ++b) {
    const TBOX &truth_box = norm_truth_word_.BlobBox(b);
    // Note that we are more strict on the bounding box boundaries here
    // than in other places (chopper, segmentation search), since we do
    // not have the ability to check the previous and next bounding box.
    if (blob_box.x_almost_equal(truth_box, norm_box_tolerance_ / 2)) {
      bool found = false;
      bool incorrect_adapted = false;
      UNICHAR_ID incorrect_adapted_id = INVALID_UNICHAR_ID;
      const char *truth_str = truth_text_[b].c_str();
      // We promise not to modify the list or its contents, using a
      // const BLOB_CHOICE* below.
      BLOB_CHOICE_IT choices_it(const_cast<BLOB_CHOICE_LIST *>(&choices));
      for (choices_it.mark_cycle_pt(); !choices_it.cycled_list(); choices_it.forward()) {
        const BLOB_CHOICE *choice = choices_it.data();
        if (strcmp(truth_str, unicharset.get_normed_unichar(choice->unichar_id())) == 0) {
          found = true;
          break;
        } else if (choice->IsAdapted()) {
          incorrect_adapted = true;
          incorrect_adapted_id = choice->unichar_id();
        }
      } // end choices_it for loop
      if (!found) {
        std::string debug_str = "unichar ";
        debug_str += truth_str;
        debug_str += " not found in classification list";
        SetBlame(IRR_CLASSIFIER, debug_str, nullptr, debug);
      } else if (incorrect_adapted) {
        std::string debug_str = "better rating for adapted ";
        debug_str += unicharset.id_to_unichar(incorrect_adapted_id);
        debug_str += " than for correct ";
        debug_str += truth_str;
        SetBlame(IRR_ADAPTION, debug_str, nullptr, debug);
      }
      break;
    }
  } // end iterating over blamer_bundle->norm_truth_word
}

BlameClassifierOrLangModel()

void tesseract::BlamerBundle::BlameClassifierOrLangModel	(	const WERD_RES *	word,
		const UNICHARSET &	unicharset,
		bool	valid_permuter,
		bool	debug
	)

Definition at line 363 of file blamer.cpp.

                                                                               {
  if (valid_permuter) {
    // Find out whether best choice is a top choice.
    best_choice_is_dict_and_top_choice_ = true;
    for (unsigned i = 0; i < word->best_choice->length(); ++i) {
      BLOB_CHOICE_IT blob_choice_it(word->GetBlobChoices(i));
      ASSERT_HOST(!blob_choice_it.empty());
      BLOB_CHOICE *first_choice = nullptr;
      for (blob_choice_it.mark_cycle_pt(); !blob_choice_it.cycled_list();
           blob_choice_it.forward()) { // find first non-fragment choice
        if (!(unicharset.get_fragment(blob_choice_it.data()->unichar_id()))) {
          first_choice = blob_choice_it.data();
          break;
        }
      }
      ASSERT_HOST(first_choice != nullptr);
      if (first_choice->unichar_id() != word->best_choice->unichar_id(i)) {
        best_choice_is_dict_and_top_choice_ = false;
        break;
      }
    }
  }
  std::string debug_str;
  if (best_choice_is_dict_and_top_choice_) {
    debug_str = "Best choice is: incorrect, top choice, dictionary word";
    debug_str += " with permuter ";
    debug_str += word->best_choice->permuter_name();
  } else {
    debug_str = "Classifier/Old LM tradeoff is to blame";
  }
  SetBlame(best_choice_is_dict_and_top_choice_ ? IRR_CLASSIFIER : IRR_CLASS_OLD_LM_TRADEOFF,
           debug_str, word->best_choice, debug);
}

ChoiceIsCorrect()

bool tesseract::BlamerBundle::ChoiceIsCorrect

(

const WERD_CHOICE *

word_choice

)

const

Definition at line 116 of file blamer.cpp.

                                                                       {
  if (word_choice == nullptr) {
    return false;
  }
  const UNICHARSET *uni_set = word_choice->unicharset();
  std::string normed_choice_str;
  for (unsigned i = 0; i < word_choice->length(); ++i) {
    normed_choice_str += uni_set->get_normed_unichar(word_choice->unichar_id(i));
  }
  std::string truth_str = TruthString();
  return truth_str == normed_choice_str;
}

ClearResults()

void tesseract::BlamerBundle::ClearResults ( )

inline

Definition at line 198 of file blamer.h.

                      {
    norm_truth_word_.DeleteAllBoxes();
    norm_box_tolerance_ = 0;
    if (!NoTruth()) {
      incorrect_result_reason_ = IRR_CORRECT;
    }
    debug_ = "";
    segsearch_is_looking_for_blame_ = false;
    best_correctly_segmented_rating_ = WERD_CHOICE::kBadRating;
    correct_segmentation_cols_.clear();
    correct_segmentation_rows_.clear();
    best_choice_is_dict_and_top_choice_ = false;
    delete[] lattice_data_;
    lattice_data_ = nullptr;
    lattice_size_ = 0;
  }

CopyResults()

void tesseract::BlamerBundle::CopyResults ( const BlamerBundle &  other )

inline

Definition at line 220 of file blamer.h.

                                              {
    norm_truth_word_ = other.norm_truth_word_;
    norm_box_tolerance_ = other.norm_box_tolerance_;
    incorrect_result_reason_ = other.incorrect_result_reason_;
    segsearch_is_looking_for_blame_ = other.segsearch_is_looking_for_blame_;
    best_correctly_segmented_rating_ = other.best_correctly_segmented_rating_;
    correct_segmentation_cols_ = other.correct_segmentation_cols_;
    correct_segmentation_rows_ = other.correct_segmentation_rows_;
    best_choice_is_dict_and_top_choice_ = other.best_choice_is_dict_and_top_choice_;
    if (other.lattice_data_ != nullptr) {
      lattice_data_ = new char[other.lattice_size_];
      memcpy(lattice_data_, other.lattice_data_, other.lattice_size_);
      lattice_size_ = other.lattice_size_;
    } else {
      lattice_data_ = nullptr;
    }
  }

CopyTruth()

void tesseract::BlamerBundle::CopyTruth ( const BlamerBundle &  other )

inline

Definition at line 214 of file blamer.h.

                                            {
    truth_has_char_boxes_ = other.truth_has_char_boxes_;
    truth_word_ = other.truth_word_;
    truth_text_ = other.truth_text_;
    incorrect_result_reason_ = (other.NoTruth() ? other.incorrect_result_reason_ : IRR_CORRECT);
  }

correct_segmentation_length()

int tesseract::BlamerBundle::correct_segmentation_length ( ) const

inline

Definition at line 151 of file blamer.h.

                                          {
    return correct_segmentation_cols_.size();
  }

debug()

const std::string & tesseract::BlamerBundle::debug ( ) const

inline

Definition at line 140 of file blamer.h.

                                 {
    return debug_;
  }

FillDebugString()

void tesseract::BlamerBundle::FillDebugString	(	const std::string &	msg,
		const WERD_CHOICE *	choice,
		std::string &	debug
	)

Definition at line 129 of file blamer.cpp.

                                                                                                    {
  debug += "Truth ";
  for (auto &text : this->truth_text_) {
    debug += text;
  }
  if (!this->truth_has_char_boxes_) {
    debug += " (no char boxes)";
  }
  if (choice != nullptr) {
    debug += " Choice ";
    std::string choice_str;
    choice->string_and_lengths(&choice_str, nullptr);
    debug += choice_str;
  }
  if (msg.length() > 0) {
    debug += "\n";
    debug += msg;
  }
  debug += "\n";
}

FinishSegSearch()

void tesseract::BlamerBundle::FinishSegSearch	(	const WERD_CHOICE *	best_choice,
		bool	debug,
		std::string &	debug_str
	)

Definition at line 503 of file blamer.cpp.

                                                                                                   {
  // If we are still looking for blame (i.e. best_choice is incorrect, but a
  // path representing the correct segmentation could be constructed), we can
  // blame segmentation search pain point prioritization if the rating of the
  // path corresponding to the correct segmentation is better than that of
  // best_choice (i.e. language model would have done the correct thing, but
  // because of poor pain point prioritization the correct segmentation was
  // never explored). Otherwise we blame the tradeoff between the language model
  // and the classifier, since even after exploring the path corresponding to
  // the correct segmentation incorrect best_choice would have been chosen.
  // One special case when we blame the classifier instead is when best choice
  // is incorrect, but it is a dictionary word and it classifier's top choice.
  if (segsearch_is_looking_for_blame_) {
    segsearch_is_looking_for_blame_ = false;
    if (best_choice_is_dict_and_top_choice_) {
      debug_str = "Best choice is: incorrect, top choice, dictionary word";
      debug_str += " with permuter ";
      debug_str += best_choice->permuter_name();
      SetBlame(IRR_CLASSIFIER, debug_str, best_choice, debug);
    } else if (best_correctly_segmented_rating_ < best_choice->rating()) {
      debug_str += "Correct segmentation state was not explored";
      SetBlame(IRR_SEGSEARCH_PP, debug_str, best_choice, debug);
    } else {
      if (best_correctly_segmented_rating_ >= WERD_CHOICE::kBadRating) {
        debug_str += "Correct segmentation paths were pruned by LM\n";
      } else {
        debug_str += "Best correct segmentation rating " +
                                  std::to_string(best_correctly_segmented_rating_);
        debug_str += " vs. best choice rating " + std::to_string(best_choice->rating());
      }
      SetBlame(IRR_CLASS_LM_TRADEOFF, debug_str, best_choice, debug);
    }
  }
}

GuidedSegsearchNeeded()

bool tesseract::BlamerBundle::GuidedSegsearchNeeded

(

const WERD_CHOICE *

best_choice

)

const

Definition at line 461 of file blamer.cpp.

                                                                             {
  return incorrect_result_reason_ == IRR_CORRECT && !segsearch_is_looking_for_blame_ &&
         truth_has_char_boxes_ && !ChoiceIsCorrect(best_choice);
}

GuidedSegsearchStillGoing()

bool tesseract::BlamerBundle::GuidedSegsearchStillGoing

(

)

const

Definition at line 498 of file blamer.cpp.

                                                   {
  return segsearch_is_looking_for_blame_;
}

HasDebugInfo()

bool tesseract::BlamerBundle::HasDebugInfo ( ) const

inline

Definition at line 137 of file blamer.h.

                            {
    return debug_.length() > 0 || misadaption_debug_.length() > 0;
  }

incorrect_result_reason()

IncorrectResultReason tesseract::BlamerBundle::incorrect_result_reason ( ) const

inline

Definition at line 131 of file blamer.h.

                                                        {
    return incorrect_result_reason_;
  }

IncorrectReason()

const char * tesseract::BlamerBundle::IncorrectReason

(

)

const

Definition at line 60 of file blamer.cpp.

                                                {
  return kIncorrectResultReasonNames[incorrect_result_reason_];
}

IncorrectReasonName()

const char * tesseract::BlamerBundle::IncorrectReasonName ( IncorrectResultReason  irr )

static

Definition at line 56 of file blamer.cpp.

                                                                       {
  return kIncorrectResultReasonNames[irr];
}

InitForSegSearch()

void tesseract::BlamerBundle::InitForSegSearch	(	const WERD_CHOICE *	best_choice,
		MATRIX *	ratings,
		UNICHAR_ID	wildcard_id,
		bool	debug,
		std::string &	debug_str,
		tesseract::LMPainPoints *	pain_points,
		double	max_char_wh_ratio,
		WERD_RES *	word_res
	)

Definition at line 468 of file blamer.cpp.

                                                        {
  segsearch_is_looking_for_blame_ = true;
  if (debug) {
    tprintf("segsearch starting to look for blame\n");
  }
  // Fill pain points for any unclassifed blob corresponding to the
  // correct segmentation state.
  debug_str += "Correct segmentation:\n";
  for (unsigned idx = 0; idx < correct_segmentation_cols_.size(); ++idx) {
    debug_str += "col=" + std::to_string(correct_segmentation_cols_[idx]);
    debug_str += " row=" + std::to_string(correct_segmentation_rows_[idx]);
    debug_str += "\n";
    if (!ratings->Classified(correct_segmentation_cols_[idx], correct_segmentation_rows_[idx],
                             wildcard_id) &&
        !pain_points->GeneratePainPoint(
            correct_segmentation_cols_[idx], correct_segmentation_rows_[idx],
            tesseract::LM_PPTYPE_BLAMER, 0.0, false, max_char_wh_ratio, word_res)) {
      segsearch_is_looking_for_blame_ = false;
      debug_str += "\nFailed to insert pain point\n";
      SetBlame(IRR_SEGSEARCH_HEUR, debug_str, best_choice, debug);
      break;
    }
  } // end for blamer_bundle->correct_segmentation_cols/rows
}

JoinBlames()

void tesseract::BlamerBundle::JoinBlames	(	const BlamerBundle &	bundle1,
		const BlamerBundle &	bundle2,
		bool	debug
	)

Definition at line 226 of file blamer.cpp.

                                          {
  std::string debug_str;
  IncorrectResultReason irr = incorrect_result_reason_;
  if (irr != IRR_NO_TRUTH_SPLIT) {
    debug_str = "";
  }
  if (bundle1.incorrect_result_reason_ != IRR_CORRECT &&
      bundle1.incorrect_result_reason_ != IRR_NO_TRUTH &&
      bundle1.incorrect_result_reason_ != IRR_NO_TRUTH_SPLIT) {
    debug_str += "Blame from part 1: ";
    debug_str += bundle1.debug_;
    irr = bundle1.incorrect_result_reason_;
  }
  if (bundle2.incorrect_result_reason_ != IRR_CORRECT &&
      bundle2.incorrect_result_reason_ != IRR_NO_TRUTH &&
      bundle2.incorrect_result_reason_ != IRR_NO_TRUTH_SPLIT) {
    debug_str += "Blame from part 2: ";
    debug_str += bundle2.debug_;
    if (irr == IRR_CORRECT) {
      irr = bundle2.incorrect_result_reason_;
    } else if (irr != bundle2.incorrect_result_reason_) {
      irr = IRR_UNKNOWN;
    }
  }
  incorrect_result_reason_ = irr;
  if (irr != IRR_CORRECT && irr != IRR_NO_TRUTH) {
    SetBlame(irr, debug_str, nullptr, debug);
  }
}

LastChanceBlame()

void tesseract::BlamerBundle::LastChanceBlame ( bool  debug, WERD_RES *  word  )

static

Definition at line 540 of file blamer.cpp.

                                                             {
  if (word->blamer_bundle == nullptr) {
    word->blamer_bundle = new BlamerBundle();
    word->blamer_bundle->SetBlame(IRR_PAGE_LAYOUT, "LastChanceBlame", word->best_choice, debug);
  } else if (word->blamer_bundle->incorrect_result_reason_ == IRR_NO_TRUTH) {
    word->blamer_bundle->SetBlame(IRR_NO_TRUTH, "Rejected truth", word->best_choice, debug);
  } else {
    bool correct = word->blamer_bundle->ChoiceIsCorrect(word->best_choice);
    IncorrectResultReason irr = word->blamer_bundle->incorrect_result_reason_;
    if (irr == IRR_CORRECT && !correct) {
      std::string debug_str = "Choice is incorrect after recognition";
      word->blamer_bundle->SetBlame(IRR_UNKNOWN, debug_str, word->best_choice, debug);
    } else if (irr != IRR_CORRECT && correct) {
      if (debug) {
        tprintf("Corrected %s\n", word->blamer_bundle->debug_.c_str());
      }
      word->blamer_bundle->incorrect_result_reason_ = IRR_CORRECT;
      word->blamer_bundle->debug_ = "";
    }
  }
}

lattice_data()

const char * tesseract::BlamerBundle::lattice_data ( ) const

inline

Definition at line 163 of file blamer.h.

                                   {
    return lattice_data_;
  }

lattice_size()

int tesseract::BlamerBundle::lattice_size ( ) const

inline

Definition at line 166 of file blamer.h.

                           {
    return lattice_size_; // size of lattice_data in bytes
  }

MatrixPositionCorrect()

bool tesseract::BlamerBundle::MatrixPositionCorrect ( int  index, const MATRIX_COORD &  coord  )

inline

Definition at line 156 of file blamer.h.

                                                                   {
    return correct_segmentation_cols_[index] == coord.col &&
           correct_segmentation_rows_[index] == coord.row;
  }

misadaption_debug()

const std::string & tesseract::BlamerBundle::misadaption_debug ( ) const

inline

Definition at line 143 of file blamer.h.

                                             {
    return misadaption_debug_;
  }

NoTruth()

bool tesseract::BlamerBundle::NoTruth ( ) const

inline

Definition at line 134 of file blamer.h.

                       {
    return incorrect_result_reason_ == IRR_NO_TRUTH || incorrect_result_reason_ == IRR_PAGE_LAYOUT;
  }

params_training_bundle()

const tesseract::ParamsTrainingBundle & tesseract::BlamerBundle::params_training_bundle ( ) const

inline

Definition at line 176 of file blamer.h.

                                                                      {
    return params_training_bundle_;
  }

set_best_choice_is_dict_and_top_choice()

void tesseract::BlamerBundle::set_best_choice_is_dict_and_top_choice ( bool  value )

inline

Definition at line 160 of file blamer.h.

                                                          {
    best_choice_is_dict_and_top_choice_ = value;
  }

set_lattice_data()

void tesseract::BlamerBundle::set_lattice_data ( const char *  data, int  size  )

inline

Definition at line 169 of file blamer.h.

                                                    {
    lattice_size_ = size;
    delete[] lattice_data_;
    lattice_data_ = new char[lattice_size_];
    memcpy(lattice_data_, data, lattice_size_);
  }

SetChopperBlame()

void tesseract::BlamerBundle::SetChopperBlame	(	const WERD_RES *	word,
		bool	debug
	)

Definition at line 309 of file blamer.cpp.

                                                                   {
  if (NoTruth() || !truth_has_char_boxes_ || word->chopped_word->blobs.empty()) {
    return;
  }
  bool missing_chop = false;
  int num_blobs = word->chopped_word->blobs.size();
  unsigned box_index = 0;
  int blob_index = 0;
  int16_t truth_x = -1;
  while (box_index < truth_word_.length() && blob_index < num_blobs) {
    truth_x = norm_truth_word_.BlobBox(box_index).right();
    TBLOB *curr_blob = word->chopped_word->blobs[blob_index];
    if (curr_blob->bounding_box().right() < truth_x - norm_box_tolerance_) {
      ++blob_index;
      continue; // encountered an extra chop, keep looking
    } else if (curr_blob->bounding_box().right() > truth_x + norm_box_tolerance_) {
      missing_chop = true;
      break;
    } else {
      ++blob_index;
    }
  }
  if (missing_chop || box_index < norm_truth_word_.length()) {
    std::string debug_str;
    if (missing_chop) {
      debug_str += "Detected missing chop (tolerance=" + std::to_string(norm_box_tolerance_);
      debug_str += ") at Bounding Box=";
      TBLOB *curr_blob = word->chopped_word->blobs[blob_index];
      curr_blob->bounding_box().print_to_str(debug_str);
      debug_str += "\nNo chop for truth at x=" + std::to_string(truth_x);
    } else {
      debug_str += "Missing chops for last " + std::to_string(norm_truth_word_.length() - box_index);
      debug_str += " truth box(es)";
    }
    debug_str += "\nMaximally chopped word boxes:\n";
    for (blob_index = 0; blob_index < num_blobs; ++blob_index) {
      TBLOB *curr_blob = word->chopped_word->blobs[blob_index];
      curr_blob->bounding_box().print_to_str(debug_str);
      debug_str += '\n';
    }
    debug_str += "Truth  bounding  boxes:\n";
    for (box_index = 0; box_index < norm_truth_word_.length(); ++box_index) {
      norm_truth_word_.BlobBox(box_index).print_to_str(debug_str);
      debug_str += '\n';
    }
    SetBlame(IRR_CHOPPER, debug_str, word->best_choice, debug);
  }
}

SetMisAdaptionDebug()

void tesseract::BlamerBundle::SetMisAdaptionDebug	(	const WERD_CHOICE *	best_choice,
		bool	debug
	)

Definition at line 564 of file blamer.cpp.

                                                                                 {
  if (incorrect_result_reason_ != IRR_NO_TRUTH && !ChoiceIsCorrect(best_choice)) {
    misadaption_debug_ = "misadapt to word (";
    misadaption_debug_ += best_choice->permuter_name();
    misadaption_debug_ += "): ";
    FillDebugString("", best_choice, misadaption_debug_);
    if (debug) {
      tprintf("%s\n", misadaption_debug_.c_str());
    }
  }
}

SetRejectedTruth()

void tesseract::BlamerBundle::SetRejectedTruth

(

)

Definition at line 110 of file blamer.cpp.

                                    {
  incorrect_result_reason_ = IRR_NO_TRUTH;
  truth_has_char_boxes_ = false;
}

SetSymbolTruth()

void tesseract::BlamerBundle::SetSymbolTruth	(	const UNICHARSET &	unicharset,
		const char *	char_str,
		const TBOX &	char_box
	)

Definition at line 88 of file blamer.cpp.

                                                        {
  std::string symbol_str(char_str);
  UNICHAR_ID id = unicharset.unichar_to_id(char_str);
  if (id != INVALID_UNICHAR_ID) {
    std::string normed_uch(unicharset.get_normed_unichar(id));
    if (normed_uch.length() > 0) {
      symbol_str = normed_uch;
    }
  }
  int length = truth_word_.length();
  truth_text_.push_back(symbol_str);
  truth_word_.InsertBox(length, char_box);
  if (length == 0) {
    truth_has_char_boxes_ = true;
  } else if (truth_word_.BlobBox(length - 1) == char_box) {
    truth_has_char_boxes_ = false;
  }
}

SetupCorrectSegmentation()

void tesseract::BlamerBundle::SetupCorrectSegmentation	(	const TWERD *	word,
		bool	debug
	)

Definition at line 399 of file blamer.cpp.

                                                                         {
#ifndef DISABLED_LEGACY_ENGINE
  params_training_bundle_.StartHypothesisList();
#endif //  ndef DISABLED_LEGACY_ENGINE
  if (incorrect_result_reason_ != IRR_CORRECT || !truth_has_char_boxes_) {
    return; // Nothing to do here.
  }
 
  std::string debug_str = "Blamer computing correct_segmentation_cols\n";
  int curr_box_col = 0;
  int next_box_col = 0;
  int num_blobs = word->NumBlobs();
  if (num_blobs == 0) {
    return; // No blobs to play with.
  }
  int blob_index = 0;
  int16_t next_box_x = word->blobs[blob_index]->bounding_box().right();
  for (unsigned truth_idx = 0; blob_index < num_blobs && truth_idx < norm_truth_word_.length();
       ++blob_index) {
    ++next_box_col;
    int16_t curr_box_x = next_box_x;
    if (blob_index + 1 < num_blobs) {
      next_box_x = word->blobs[blob_index + 1]->bounding_box().right();
    }
    int16_t truth_x = norm_truth_word_.BlobBox(truth_idx).right();
    debug_str += "Box x coord vs. truth: " + std::to_string(curr_box_x);
    debug_str += " " + std::to_string(truth_x);
    debug_str += "\n";
    if (curr_box_x > (truth_x + norm_box_tolerance_)) {
      break;                                                  // failed to find a matching box
    } else if (curr_box_x >= truth_x - norm_box_tolerance_ && // matched
               (blob_index + 1 >= num_blobs ||                // next box can't be included
                next_box_x > truth_x + norm_box_tolerance_)) {
      correct_segmentation_cols_.push_back(curr_box_col);
      correct_segmentation_rows_.push_back(next_box_col - 1);
      ++truth_idx;
      debug_str += "col=" + std::to_string(curr_box_col);
      debug_str += " row=" + std::to_string(next_box_col - 1);
      debug_str += "\n";
      curr_box_col = next_box_col;
    }
  }
  if (blob_index < num_blobs || // trailing blobs
      correct_segmentation_cols_.size() != norm_truth_word_.length()) {
    debug_str +=
        "Blamer failed to find correct segmentation"
        " (tolerance=" +
        std::to_string(norm_box_tolerance_);
    if (blob_index >= num_blobs) {
      debug_str += " blob == nullptr";
    }
    debug_str += ")\n";
    debug_str += " path length " + std::to_string(correct_segmentation_cols_.size());
    debug_str += " vs. truth " + std::to_string(norm_truth_word_.length());
    debug_str += "\n";
    SetBlame(IRR_UNKNOWN, debug_str, nullptr, debug);
    correct_segmentation_cols_.clear();
    correct_segmentation_rows_.clear();
  }
}

SetupNormTruthWord()

void tesseract::BlamerBundle::SetupNormTruthWord

(

const DENORM &

denorm

)

Definition at line 151 of file blamer.cpp.

                                                          {
  // TODO(rays) Is this the last use of denorm in WERD_RES and can it go?
  norm_box_tolerance_ = kBlamerBoxTolerance * denorm.x_scale();
  TPOINT topleft;
  TPOINT botright;
  TPOINT norm_topleft;
  TPOINT norm_botright;
  for (unsigned b = 0; b < truth_word_.length(); ++b) {
    const TBOX &box = truth_word_.BlobBox(b);
    topleft.x = box.left();
    topleft.y = box.top();
    botright.x = box.right();
    botright.y = box.bottom();
    denorm.NormTransform(nullptr, topleft, &norm_topleft);
    denorm.NormTransform(nullptr, botright, &norm_botright);
    TBOX norm_box(norm_topleft.x, norm_botright.y, norm_botright.x, norm_topleft.y);
    norm_truth_word_.InsertBox(b, norm_box);
  }
}

SetWordTruth()

void tesseract::BlamerBundle::SetWordTruth	(	const UNICHARSET &	unicharset,
		const char *	truth_str,
		const TBOX &	word_box
	)

Definition at line 66 of file blamer.cpp.

                                                      {
  truth_word_.InsertBox(0, word_box);
  truth_has_char_boxes_ = false;
  // Encode the string as UNICHAR_IDs.
  std::vector<UNICHAR_ID> encoding;
  std::vector<char> lengths;
  unicharset.encode_string(truth_str, false, &encoding, &lengths, nullptr);
  int total_length = 0;
  for (size_t i = 0; i < encoding.size(); total_length += lengths[i++]) {
    std::string uch(truth_str + total_length);
    uch.resize(lengths[i] - total_length);
    UNICHAR_ID id = encoding[i];
    if (id != INVALID_UNICHAR_ID) {
      uch = unicharset.get_normed_unichar(id);
    }
    truth_text_.push_back(uch);
  }
}

SplitBundle()

void tesseract::BlamerBundle::SplitBundle	(	int	word1_right,
		int	word2_left,
		bool	debug,
		BlamerBundle *	bundle1,
		BlamerBundle *	bundle2
	)		const

Definition at line 174 of file blamer.cpp.

                                                            {
  std::string debug_str;
  // Find truth boxes that correspond to the split in the blobs.
  unsigned begin2_truth_index = 0;
  if (incorrect_result_reason_ != IRR_NO_TRUTH && truth_has_char_boxes_) {
    debug_str = "Looking for truth split at";
    debug_str += " end1_x " + std::to_string(word1_right);
    debug_str += " begin2_x " + std::to_string(word2_left);
    debug_str += "\nnorm_truth_word boxes:\n";
    if (norm_truth_word_.length() > 1) {
      norm_truth_word_.BlobBox(0).print_to_str(debug_str);
      for (unsigned b = 1; b < norm_truth_word_.length(); ++b) {
        norm_truth_word_.BlobBox(b).print_to_str(debug_str);
        if ((abs(word1_right - norm_truth_word_.BlobBox(b - 1).right()) < norm_box_tolerance_) &&
            (abs(word2_left - norm_truth_word_.BlobBox(b).left()) < norm_box_tolerance_)) {
          begin2_truth_index = b;
          debug_str += "Split found";
          break;
        }
      }
      debug_str += '\n';
    }
  }
  // Populate truth information in word and word2 with the first and second
  // part of the original truth.
  if (begin2_truth_index > 0) {
    bundle1->truth_has_char_boxes_ = true;
    bundle1->norm_box_tolerance_ = norm_box_tolerance_;
    bundle2->truth_has_char_boxes_ = true;
    bundle2->norm_box_tolerance_ = norm_box_tolerance_;
    BlamerBundle *curr_bb = bundle1;
    for (unsigned b = 0; b < norm_truth_word_.length(); ++b) {
      if (b == begin2_truth_index) {
        curr_bb = bundle2;
      }
      curr_bb->norm_truth_word_.InsertBox(b, norm_truth_word_.BlobBox(b));
      curr_bb->truth_word_.InsertBox(b, truth_word_.BlobBox(b));
      curr_bb->truth_text_.push_back(truth_text_[b]);
    }
  } else if (incorrect_result_reason_ == IRR_NO_TRUTH) {
    bundle1->incorrect_result_reason_ = IRR_NO_TRUTH;
    bundle2->incorrect_result_reason_ = IRR_NO_TRUTH;
  } else {
    debug_str += "Truth split not found";
    debug_str += truth_has_char_boxes_ ? "\n" : " (no truth char boxes)\n";
    bundle1->SetBlame(IRR_NO_TRUTH_SPLIT, debug_str, nullptr, debug);
    bundle2->SetBlame(IRR_NO_TRUTH_SPLIT, debug_str, nullptr, debug);
  }
}

TruthString()

std::string tesseract::BlamerBundle::TruthString ( ) const

inline

Definition at line 124 of file blamer.h.

                                {
    std::string truth_str;
    for (auto &text : truth_text_) {
      truth_str += text;
    }
    return truth_str;
  }

UpdateBestRating()

void tesseract::BlamerBundle::UpdateBestRating ( float  rating )

inline

Definition at line 146 of file blamer.h.

                                      {
    if (rating < best_correctly_segmented_rating_) {
      best_correctly_segmented_rating_ = rating;
    }
  }

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/blamer.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/blamer.cpp