tesseract
3.03
|
#include <blamer.h>
Public Member Functions | |
BlamerBundle () | |
BlamerBundle (const BlamerBundle &other) | |
~BlamerBundle () | |
STRING | TruthString () const |
IncorrectResultReason | incorrect_result_reason () const |
bool | NoTruth () const |
bool | HasDebugInfo () const |
const STRING & | debug () const |
const 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 STRING &msg, const WERD_CHOICE *choice, 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, STRING *debug_str, TessResultCallback2< bool, int, int > *pp_cb) |
bool | GuidedSegsearchStillGoing () const |
void | FinishSegSearch (const WERD_CHOICE *best_choice, bool debug, 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) |
BlamerBundle::BlamerBundle | ( | ) | [inline] |
Definition at line 90 of file blamer.h.
: truth_has_char_boxes_(false), incorrect_result_reason_(IRR_CORRECT), lattice_data_(NULL) { ClearResults(); }
BlamerBundle::BlamerBundle | ( | const BlamerBundle & | other | ) | [inline] |
Definition at line 93 of file blamer.h.
{ this->CopyTruth(other); this->CopyResults(other); }
BlamerBundle::~BlamerBundle | ( | ) | [inline] |
void BlamerBundle::AddHypothesis | ( | const tesseract::ParamsTrainingHypothesis & | hypo | ) | [inline] |
Definition at line 154 of file blamer.h.
{ params_training_bundle_.AddHypothesis(hypo); }
void BlamerBundle::BlameClassifier | ( | const UNICHARSET & | unicharset, |
const TBOX & | blob_box, | ||
const BLOB_CHOICE_LIST & | choices, | ||
bool | debug | ||
) |
Definition at line 257 of file blamer.cpp.
{ if (!truth_has_char_boxes_ || incorrect_result_reason_ != IRR_CORRECT) return; // Nothing to do here. for (int 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].string(); // 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) { STRING debug_str = "unichar "; debug_str += truth_str; debug_str += " not found in classification list"; SetBlame(IRR_CLASSIFIER, debug_str, NULL, debug); } else if (incorrect_adapted) { 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, NULL, debug); } break; } } // end iterating over blamer_bundle->norm_truth_word }
void BlamerBundle::BlameClassifierOrLangModel | ( | const WERD_RES * | word, |
const UNICHARSET & | unicharset, | ||
bool | valid_permuter, | ||
bool | debug | ||
) |
Definition at line 369 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 (int 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 = NULL; 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 != NULL); if (first_choice->unichar_id() != word->best_choice->unichar_id(i)) { best_choice_is_dict_and_top_choice_ = false; break; } } } 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); }
bool BlamerBundle::ChoiceIsCorrect | ( | const WERD_CHOICE * | word_choice | ) | const |
Definition at line 111 of file blamer.cpp.
{ if (word_choice == NULL) return false; const UNICHARSET* uni_set = word_choice->unicharset(); STRING normed_choice_str; for (int i = 0; i < word_choice->length(); ++i) { normed_choice_str += uni_set->get_normed_unichar(word_choice->unichar_id(i)); } STRING truth_str = TruthString(); return truth_str == normed_choice_str; }
void BlamerBundle::ClearResults | ( | ) | [inline] |
Definition at line 173 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_ = NULL; lattice_size_ = 0; }
void BlamerBundle::CopyResults | ( | const BlamerBundle & | other | ) | [inline] |
Definition at line 194 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_ != NULL) { lattice_data_ = new char[other.lattice_size_]; memcpy(lattice_data_, other.lattice_data_, other.lattice_size_); lattice_size_ = other.lattice_size_; } else { lattice_data_ = NULL; } }
void BlamerBundle::CopyTruth | ( | const BlamerBundle & | other | ) | [inline] |
Definition at line 187 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); }
int BlamerBundle::correct_segmentation_length | ( | ) | const [inline] |
const STRING& BlamerBundle::debug | ( | ) | const [inline] |
void BlamerBundle::FillDebugString | ( | const STRING & | msg, |
const WERD_CHOICE * | choice, | ||
STRING * | debug | ||
) |
Definition at line 123 of file blamer.cpp.
{ (*debug) += "Truth "; for (int i = 0; i < this->truth_text_.length(); ++i) { (*debug) += this->truth_text_[i]; } if (!this->truth_has_char_boxes_) (*debug) += " (no char boxes)"; if (choice != NULL) { (*debug) += " Choice "; STRING choice_str; choice->string_and_lengths(&choice_str, NULL); (*debug) += choice_str; } if (msg.length() > 0) { (*debug) += "\n"; (*debug) += msg; } (*debug) += "\n"; }
void BlamerBundle::FinishSegSearch | ( | const WERD_CHOICE * | best_choice, |
bool | debug, | ||
STRING * | debug_str | ||
) |
Definition at line 506 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->add_str_double("Best correct segmentation rating ", best_correctly_segmented_rating_); debug_str->add_str_double(" vs. best choice rating ", best_choice->rating()); } SetBlame(IRR_CLASS_LM_TRADEOFF, *debug_str, best_choice, debug); } } }
bool 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); }
bool BlamerBundle::GuidedSegsearchStillGoing | ( | ) | const |
Definition at line 501 of file blamer.cpp.
{
return segsearch_is_looking_for_blame_;
}
bool BlamerBundle::HasDebugInfo | ( | ) | const [inline] |
IncorrectResultReason BlamerBundle::incorrect_result_reason | ( | ) | const [inline] |
const char * BlamerBundle::IncorrectReason | ( | ) | const |
Definition at line 60 of file blamer.cpp.
{ return kIncorrectResultReasonNames[incorrect_result_reason_]; }
const char * BlamerBundle::IncorrectReasonName | ( | IncorrectResultReason | irr | ) | [static] |
Definition at line 56 of file blamer.cpp.
{ return kIncorrectResultReasonNames[irr]; }
void BlamerBundle::InitForSegSearch | ( | const WERD_CHOICE * | best_choice, |
MATRIX * | ratings, | ||
UNICHAR_ID | wildcard_id, | ||
bool | debug, | ||
STRING * | debug_str, | ||
TessResultCallback2< bool, int, int > * | pp_cb | ||
) |
Definition at line 473 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 (int idx = 0; idx < correct_segmentation_cols_.length(); ++idx) { debug_str->add_str_int("col=", correct_segmentation_cols_[idx]); debug_str->add_str_int(" row=", correct_segmentation_rows_[idx]); *debug_str += "\n"; if (!ratings->Classified(correct_segmentation_cols_[idx], correct_segmentation_rows_[idx], wildcard_id) && !cb->Run(correct_segmentation_cols_[idx], correct_segmentation_rows_[idx])) { 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 }
void BlamerBundle::JoinBlames | ( | const BlamerBundle & | bundle1, |
const BlamerBundle & | bundle2, | ||
bool | debug | ||
) |
Definition at line 225 of file blamer.cpp.
{ 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, NULL, debug); } }
void BlamerBundle::LastChanceBlame | ( | bool | debug, |
WERD_RES * | word | ||
) | [static] |
Definition at line 547 of file blamer.cpp.
{ if (word->blamer_bundle == NULL) { 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) { 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_.string()); } word->blamer_bundle->incorrect_result_reason_ = IRR_CORRECT; word->blamer_bundle->debug_ = ""; } } }
const char* BlamerBundle::lattice_data | ( | ) | const [inline] |
int BlamerBundle::lattice_size | ( | ) | const [inline] |
bool BlamerBundle::MatrixPositionCorrect | ( | int | index, |
const MATRIX_COORD & | coord | ||
) | [inline] |
const STRING& BlamerBundle::misadaption_debug | ( | ) | const [inline] |
bool BlamerBundle::NoTruth | ( | ) | const [inline] |
Definition at line 109 of file blamer.h.
{ return incorrect_result_reason_ == IRR_NO_TRUTH || incorrect_result_reason_ == IRR_PAGE_LAYOUT; }
const tesseract::ParamsTrainingBundle& BlamerBundle::params_training_bundle | ( | ) | const [inline] |
void BlamerBundle::set_best_choice_is_dict_and_top_choice | ( | bool | value | ) | [inline] |
void BlamerBundle::set_lattice_data | ( | const char * | data, |
int | size | ||
) | [inline] |
void BlamerBundle::SetChopperBlame | ( | const WERD_RES * | word, |
bool | debug | ||
) |
Definition at line 310 of file blamer.cpp.
{ if (NoTruth() || !truth_has_char_boxes_ || word->chopped_word->blobs.empty()) { return; } STRING debug_str; bool missing_chop = false; int num_blobs = word->chopped_word->blobs.size(); int box_index = 0; int blob_index = 0; inT16 truth_x; 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()) { STRING debug_str; if (missing_chop) { debug_str.add_str_int("Detected missing chop (tolerance=", 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.add_str_int("\nNo chop for truth at x=", truth_x); } else { debug_str.add_str_int("Missing chops for last ", 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); } }
void BlamerBundle::SetMisAdaptionDebug | ( | const WERD_CHOICE * | best_choice, |
bool | debug | ||
) |
Definition at line 574 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_.string()); } } }
void BlamerBundle::SetRejectedTruth | ( | ) |
Definition at line 105 of file blamer.cpp.
{ incorrect_result_reason_ = IRR_NO_TRUTH; truth_has_char_boxes_ = false; }
void BlamerBundle::SetSymbolTruth | ( | const UNICHARSET & | unicharset, |
const char * | char_str, | ||
const TBOX & | char_box | ||
) |
Definition at line 86 of file blamer.cpp.
{ STRING symbol_str(char_str); UNICHAR_ID id = unicharset.unichar_to_id(char_str); if (id != INVALID_UNICHAR_ID) { 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; }
void BlamerBundle::SetupCorrectSegmentation | ( | const TWERD * | word, |
bool | debug | ||
) |
Definition at line 407 of file blamer.cpp.
{ params_training_bundle_.StartHypothesisList(); if (incorrect_result_reason_ != IRR_CORRECT || !truth_has_char_boxes_) return; // Nothing to do here. STRING debug_str; 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 next_box_x = word->blobs[blob_index]->bounding_box().right(); for (int truth_idx = 0; blob_index < num_blobs && truth_idx < norm_truth_word_.length(); ++blob_index) { ++next_box_col; inT16 curr_box_x = next_box_x; if (blob_index + 1 < num_blobs) next_box_x = word->blobs[blob_index + 1]->bounding_box().right(); inT16 truth_x = norm_truth_word_.BlobBox(truth_idx).right(); debug_str.add_str_int("Box x coord vs. truth: ", curr_box_x); debug_str.add_str_int(" ", 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.add_str_int("col=", curr_box_col); debug_str.add_str_int(" row=", next_box_col-1); debug_str += "\n"; curr_box_col = next_box_col; } } if (blob_index < num_blobs || // trailing blobs correct_segmentation_cols_.length() != norm_truth_word_.length()) { debug_str.add_str_int("Blamer failed to find correct segmentation" " (tolerance=", norm_box_tolerance_); if (blob_index >= num_blobs) debug_str += " blob == NULL"; debug_str += ")\n"; debug_str.add_str_int(" path length ", correct_segmentation_cols_.length()); debug_str.add_str_int(" vs. truth ", norm_truth_word_.length()); debug_str += "\n"; SetBlame(IRR_UNKNOWN, debug_str, NULL, debug); correct_segmentation_cols_.clear(); correct_segmentation_rows_.clear(); } }
void BlamerBundle::SetupNormTruthWord | ( | const DENORM & | denorm | ) |
Definition at line 145 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 (int 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(NULL, topleft, &norm_topleft); denorm.NormTransform(NULL, 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); } }
void 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. GenericVector<UNICHAR_ID> encoding; GenericVector<char> lengths; unicharset.encode_string(truth_str, false, &encoding, &lengths, NULL); int total_length = 0; for (int i = 0; i < encoding.size(); total_length += lengths[i++]) { STRING uch(truth_str + total_length); uch.truncate_at(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); } }
void BlamerBundle::SplitBundle | ( | int | word1_right, |
int | word2_left, | ||
bool | debug, | ||
BlamerBundle * | bundle1, | ||
BlamerBundle * | bundle2 | ||
) | const |
Definition at line 169 of file blamer.cpp.
{ STRING debug_str; // Find truth boxes that correspond to the split in the blobs. int b; int begin2_truth_index = -1; if (incorrect_result_reason_ != IRR_NO_TRUTH && truth_has_char_boxes_) { debug_str = "Looking for truth split at"; debug_str.add_str_int(" end1_x ", word1_right); debug_str.add_str_int(" begin2_x ", 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 (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 (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, NULL, debug); bundle2->SetBlame(IRR_NO_TRUTH_SPLIT, debug_str, NULL, debug); } }
STRING BlamerBundle::TruthString | ( | ) | const [inline] |
void BlamerBundle::UpdateBestRating | ( | float | rating | ) | [inline] |