#include <pageres.h>

Inheritance diagram for WERD_RES:

Public Member Functions
	WERD_RES ()

	WERD_RES (WERD *the_word)

	WERD_RES (const WERD_RES &source)

	~WERD_RES ()

const char *	BestUTF8 (int blob_index, bool in_rtl_context) const

const char *	RawUTF8 (int blob_index) const

UNICHARSET::Direction	SymbolDirection (int blob_index) const

bool	AnyRtlCharsInWord () const

bool	AnyLtrCharsInWord () const

bool	UnicharsInReadingOrder () const

void	InitNonPointers ()

void	InitPointers ()

void	Clear ()

void	ClearResults ()

void	ClearWordChoices ()

void	ClearRatings ()

WERD_RES &	operator= (const WERD_RES &source)

void	CopySimpleFields (const WERD_RES &source)

void	InitForRetryRecognition (const WERD_RES &source)

bool	SetupForRecognition (const UNICHARSET &unicharset_in, tesseract::Tesseract tesseract, Pix pix, int norm_mode, const TBOX norm_box, bool numeric_mode, bool use_body_size, bool allow_detailed_fx, ROW row, const BLOCK *block)

void	SetupBasicsFromChoppedWord (const UNICHARSET &unicharset_in)

void	SetupFake (const UNICHARSET &uch)

void	SetupWordScript (const UNICHARSET &unicharset_in)

void	SetupBlamerBundle ()

void	SetupBlobWidthsAndGaps ()

void	InsertSeam (int blob_number, SEAM *seam)

bool	AlternativeChoiceAdjustmentsWorseThan (float threshold) const

bool	IsAmbiguous ()

bool	StatesAllValid ()

void	DebugWordChoices (bool debug, const char *word_to_debug)

void	DebugTopChoice (const char *msg) const

void	FilterWordChoices (int debug_level)

void	ComputeAdaptionThresholds (float certainty_scale, float min_rating, float max_rating, float rating_margin, float *thresholds)

bool	LogNewRawChoice (WERD_CHOICE *word_choice)

bool	LogNewCookedChoice (int max_num_choices, bool debug, WERD_CHOICE *word_choice)

void	PrintBestChoices () const

int	GetBlobsWidth (int start_blob, int last_blob)

int	GetBlobsGap (int blob_index)

BLOB_CHOICE *	GetBlobChoice (int index) const

BLOB_CHOICE_LIST *	GetBlobChoices (int index) const

void	ConsumeWordResults (WERD_RES *word)

void	ReplaceBestChoice (WERD_CHOICE *choice)

void	RebuildBestState ()

void	CloneChoppedToRebuild ()

void	SetupBoxWord ()

void	SetScriptPositions ()

void	SetAllScriptPositions (tesseract::ScriptPos position)

void	FakeClassifyWord (int blob_count, BLOB_CHOICE **choices)

void	FakeWordFromRatings (PermuterType permuter)

void	BestChoiceToCorrectText ()

bool	ConditionalBlobMerge (TessResultCallback2< UNICHAR_ID, UNICHAR_ID, UNICHAR_ID > class_cb, TessResultCallback2< bool, const TBOX &, const TBOX &> box_cb)

void	MergeAdjacentBlobs (int index)

UNICHAR_ID	BothQuotes (UNICHAR_ID id1, UNICHAR_ID id2)

void	fix_quotes ()

UNICHAR_ID	BothHyphens (UNICHAR_ID id1, UNICHAR_ID id2)

bool	HyphenBoxesOverlap (const TBOX &box1, const TBOX &box2)

void	fix_hyphens ()

UNICHAR_ID	BothSpaces (UNICHAR_ID id1, UNICHAR_ID id2)

void	merge_tess_fails ()

void	copy_on (WERD_RES *word_res)

bool	PiecesAllNatural (int start, int count) const

Public Member Functions inherited from ELIST_LINK
	ELIST_LINK ()

	ELIST_LINK (const ELIST_LINK &)

void	operator= (const ELIST_LINK &)

Static Public Member Functions
static WERD_RES *	deep_copy (const WERD_RES *src)

Public Attributes
WERD *	word

tesseract::BoxWord *	bln_boxes

ROW *	blob_row

DENORM	denorm

const UNICHARSET *	uch_set

TWERD *	chopped_word

GenericVector< SEAM * >	seam_array

GenericVector< int >	blob_widths

GenericVector< int >	blob_gaps

std::vector< std::vector< std::pair< const char *, float > > >	timesteps

MATRIX *	ratings

WERD_CHOICE *	best_choice

WERD_CHOICE *	raw_choice

WERD_CHOICE_LIST	best_choices

BlamerBundle *	blamer_bundle

TWERD *	rebuild_word

tesseract::BoxWord *	box_word

GenericVector< int >	best_state

GenericVector< STRING >	correct_text

tesseract::Tesseract *	tesseract

WERD_CHOICE *	ep_choice

REJMAP	reject_map

bool	tess_failed

bool	tess_accepted

bool	tess_would_adapt

bool	done

bool	small_caps

bool	odd_size

int8_t	italic

int8_t	bold

const FontInfo *	fontinfo

const FontInfo *	fontinfo2

int8_t	fontinfo_id_count

int8_t	fontinfo_id2_count

bool	guessed_x_ht

bool	guessed_caps_ht

CRUNCH_MODE	unlv_crunch_mode

float	x_height

float	caps_height

float	baseline_shift

float	space_certainty

bool	combination

bool	part_of_combo

bool	reject_spaces

Detailed Description

Definition at line 169 of file pageres.h.

Constructor & Destructor Documentation

◆ WERD_RES() [1/3]

WERD_RES::WERD_RES ( )

inline

Definition at line 338 of file pageres.h.

              {
     InitNonPointers();
     InitPointers();
   }

◆ WERD_RES() [2/3]

WERD_RES::WERD_RES ( WERD * the_word )

inline

Definition at line 342 of file pageres.h.

                            {
     InitNonPointers();
     InitPointers();
     word = the_word;
   }

◆ WERD_RES() [3/3]

WERD_RES::WERD_RES ( const WERD_RES & source )

inline

Definition at line 349 of file pageres.h.

                                    : ELIST_LINK(source) {
     InitPointers();
     *this = source;            // see operator=
   }

◆ ~WERD_RES()

WERD_RES::~WERD_RES ( )

Definition at line 1096 of file pageres.cpp.

                      {
   Clear();
 }

Member Function Documentation

◆ AlternativeChoiceAdjustmentsWorseThan()

bool WERD_RES::AlternativeChoiceAdjustmentsWorseThan ( float threshold ) const

Definition at line 445 of file pageres.cpp.

                                                                           {
   // The choices are not changed by this iteration.
   WERD_CHOICE_IT wc_it(const_cast<WERD_CHOICE_LIST*>(&best_choices));
   for (wc_it.forward(); !wc_it.at_first(); wc_it.forward()) {
     WERD_CHOICE* choice = wc_it.data();
     if (choice->adjust_factor() <= threshold)
       return false;
   }
   return true;
 }

◆ AnyLtrCharsInWord()

bool WERD_RES::AnyLtrCharsInWord ( ) const

inline

Definition at line 408 of file pageres.h.

                                  {
     if (uch_set == nullptr || best_choice == nullptr || best_choice->length() < 1)
       return false;
     for (int id = 0; id < best_choice->length(); id++) {
       int unichar_id = best_choice->unichar_id(id);
       if (unichar_id < 0 || unichar_id >= uch_set->size())
         continue;  // Ignore illegal chars.
       UNICHARSET::Direction dir = uch_set->get_direction(unichar_id);
       if (dir == UNICHARSET::U_LEFT_TO_RIGHT)
         return true;
     }
     return false;
   }

◆ AnyRtlCharsInWord()

bool WERD_RES::AnyRtlCharsInWord ( ) const

inline

Definition at line 391 of file pageres.h.

                                  {
     if (uch_set == nullptr || best_choice == nullptr || best_choice->length() < 1)
       return false;
     for (int id = 0; id < best_choice->length(); id++) {
       int unichar_id = best_choice->unichar_id(id);
       if (unichar_id < 0 || unichar_id >= uch_set->size())
         continue;  // Ignore illegal chars.
       UNICHARSET::Direction dir =
           uch_set->get_direction(unichar_id);
       if (dir == UNICHARSET::U_RIGHT_TO_LEFT ||
           dir == UNICHARSET::U_RIGHT_TO_LEFT_ARABIC ||
           dir == UNICHARSET::U_ARABIC_NUMBER)
         return true;
     }
     return false;
   }

◆ BestChoiceToCorrectText()

void WERD_RES::BestChoiceToCorrectText ( )

Definition at line 929 of file pageres.cpp.

                                        {
   correct_text.clear();
   ASSERT_HOST(best_choice != nullptr);
   for (int i = 0; i < best_choice->length(); ++i) {
     UNICHAR_ID choice_id = best_choice->unichar_id(i);
     const char* blob_choice = uch_set->id_to_unichar(choice_id);
     correct_text.push_back(STRING(blob_choice));
   }
 }

◆ BestUTF8()

const char* WERD_RES::BestUTF8	(	int	blob_index,
		bool	in_rtl_context
	)		const

inline

Definition at line 361 of file pageres.h.

                                                                   {
     if (blob_index < 0 || best_choice == nullptr ||
         blob_index >= best_choice->length())
       return nullptr;
     UNICHAR_ID id = best_choice->unichar_id(blob_index);
     if (id < 0 || id >= uch_set->size())
       return nullptr;
     UNICHAR_ID mirrored = uch_set->get_mirror(id);
     if (in_rtl_context && mirrored > 0)
       id = mirrored;
     return uch_set->id_to_unichar_ext(id);
   }

◆ BothHyphens()

UNICHAR_ID WERD_RES::BothHyphens	(	UNICHAR_ID	id1,
		UNICHAR_ID	id2
	)

Definition at line 1036 of file pageres.cpp.

                                                                {
   const char *ch = uch_set->id_to_unichar(id1);
   const char *next_ch = uch_set->id_to_unichar(id2);
   if (strlen(ch) == 1 && strlen(next_ch) == 1 &&
       (*ch == '-' || *ch == '~') && (*next_ch == '-' || *next_ch == '~'))
     return uch_set->unichar_to_id("-");
   return INVALID_UNICHAR_ID;
 }

◆ BothQuotes()

UNICHAR_ID WERD_RES::BothQuotes	(	UNICHAR_ID	id1,
		UNICHAR_ID	id2
	)

Definition at line 1014 of file pageres.cpp.

                                                               {
   const char *ch = uch_set->id_to_unichar(id1);
   const char *next_ch = uch_set->id_to_unichar(id2);
   if (is_simple_quote(ch, strlen(ch)) &&
       is_simple_quote(next_ch, strlen(next_ch)))
     return uch_set->unichar_to_id("\"");
   return INVALID_UNICHAR_ID;
 }

◆ BothSpaces()

UNICHAR_ID WERD_RES::BothSpaces	(	UNICHAR_ID	id1,
		UNICHAR_ID	id2
	)

Definition at line 1065 of file pageres.cpp.

                                                               {
   if (id1 == id2 && id1 == uch_set->unichar_to_id(" "))
     return id1;
   else
     return INVALID_UNICHAR_ID;
 }

◆ Clear()

void WERD_RES::Clear ( )

Definition at line 1143 of file pageres.cpp.

                      {
   if (combination) {
     delete word;
   }
   word = nullptr;
   delete blamer_bundle;
   blamer_bundle = nullptr;
   ClearResults();
 }

◆ ClearRatings()

void WERD_RES::ClearRatings ( )

Definition at line 1186 of file pageres.cpp.

                             {
   if (ratings != nullptr) {
     ratings->delete_matrix_pointers();
     delete ratings;
     ratings = nullptr;
   }
 }

◆ ClearResults()

void WERD_RES::ClearResults ( )

Definition at line 1153 of file pageres.cpp.

                             {
   done = false;
   fontinfo = nullptr;
   fontinfo2 = nullptr;
   fontinfo_id_count = 0;
   fontinfo_id2_count = 0;
   delete bln_boxes;
   bln_boxes = nullptr;
   blob_row = nullptr;
   delete chopped_word;
   chopped_word = nullptr;
   delete rebuild_word;
   rebuild_word = nullptr;
   delete box_word;
   box_word = nullptr;
   best_state.clear();
   correct_text.clear();
   seam_array.delete_data_pointers();
   seam_array.clear();
   blob_widths.clear();
   blob_gaps.clear();
   ClearRatings();
   ClearWordChoices();
   if (blamer_bundle != nullptr) blamer_bundle->ClearResults();
 }

◆ ClearWordChoices()

void WERD_RES::ClearWordChoices ( )

Definition at line 1178 of file pageres.cpp.

                                 {
   best_choice = nullptr;
   delete raw_choice;
   raw_choice = nullptr;
   best_choices.clear();
   delete ep_choice;
   ep_choice = nullptr;
 }

◆ CloneChoppedToRebuild()

void WERD_RES::CloneChoppedToRebuild ( )

Definition at line 841 of file pageres.cpp.

                                      {
   delete rebuild_word;
   rebuild_word = new TWERD(*chopped_word);
   SetupBoxWord();
   int word_len = box_word->length();
   best_state.reserve(word_len);
   correct_text.reserve(word_len);
   for (int i = 0; i < word_len; ++i) {
     best_state.push_back(1);
     correct_text.push_back(STRING(""));
   }
 }

◆ ComputeAdaptionThresholds()

void WERD_RES::ComputeAdaptionThresholds	(	float	certainty_scale,
		float	min_rating,
		float	max_rating,
		float	rating_margin,
		float *	thresholds
	)

Definition at line 567 of file pageres.cpp.

                                                             {
   int chunk = 0;
   int end_chunk = best_choice->state(0);
   int end_raw_chunk = raw_choice->state(0);
   int raw_blob = 0;
   for (int i = 0; i < best_choice->length(); i++, thresholds++) {
     float avg_rating = 0.0f;
     int num_error_chunks = 0;
 
     // For each chunk in best choice blob i, count non-matching raw results.
     while (chunk < end_chunk) {
       if (chunk >= end_raw_chunk) {
         ++raw_blob;
         end_raw_chunk += raw_choice->state(raw_blob);
       }
       if (best_choice->unichar_id(i) !=
           raw_choice->unichar_id(raw_blob)) {
         avg_rating += raw_choice->certainty(raw_blob);
         ++num_error_chunks;
       }
       ++chunk;
     }
 
     if (num_error_chunks > 0) {
       avg_rating /= num_error_chunks;
       *thresholds = (avg_rating / -certainty_scale) * (1.0 - rating_margin);
     } else {
       *thresholds = max_rating;
     }
 
     if (*thresholds > max_rating)
       *thresholds = max_rating;
     if (*thresholds < min_rating)
       *thresholds = min_rating;
   }
 }

◆ ConditionalBlobMerge()

bool WERD_RES::ConditionalBlobMerge	(	TessResultCallback2< UNICHAR_ID, UNICHAR_ID, UNICHAR_ID > *	class_cb,
		TessResultCallback2< bool, const TBOX &, const TBOX &> *	box_cb
	)

Definition at line 944 of file pageres.cpp.

                                                                  {
   ASSERT_HOST(best_choice->length() == 0 || ratings != nullptr);
   bool modified = false;
   for (int i = 0; i + 1 < best_choice->length(); ++i) {
     UNICHAR_ID new_id = class_cb->Run(best_choice->unichar_id(i),
                                       best_choice->unichar_id(i+1));
     if (new_id != INVALID_UNICHAR_ID &&
         (box_cb == nullptr || box_cb->Run(box_word->BlobBox(i),
                                        box_word->BlobBox(i + 1)))) {
       // Raw choice should not be fixed.
       best_choice->set_unichar_id(new_id, i);
       modified = true;
       MergeAdjacentBlobs(i);
       const MATRIX_COORD& coord = best_choice->MatrixCoord(i);
       if (!coord.Valid(*ratings)) {
         ratings->IncreaseBandSize(coord.row + 1 - coord.col);
       }
       BLOB_CHOICE_LIST* blob_choices = GetBlobChoices(i);
       if (FindMatchingChoice(new_id, blob_choices) == nullptr) {
         // Insert a fake result.
         BLOB_CHOICE* blob_choice = new BLOB_CHOICE;
         blob_choice->set_unichar_id(new_id);
         BLOB_CHOICE_IT bc_it(blob_choices);
         bc_it.add_before_then_move(blob_choice);
       }
     }
   }
   delete class_cb;
   delete box_cb;
   return modified;
 }

◆ ConsumeWordResults()

void WERD_RES::ConsumeWordResults ( WERD_RES * word )

Definition at line 771 of file pageres.cpp.

                                                 {
   denorm = word->denorm;
   blob_row = word->blob_row;
   MovePointerData(&chopped_word, &word->chopped_word);
   MovePointerData(&rebuild_word, &word->rebuild_word);
   MovePointerData(&box_word, &word->box_word);
   seam_array.delete_data_pointers();
   seam_array = word->seam_array;
   word->seam_array.clear();
   best_state.move(&word->best_state);
   correct_text.move(&word->correct_text);
   blob_widths.move(&word->blob_widths);
   blob_gaps.move(&word->blob_gaps);
   if (ratings != nullptr) ratings->delete_matrix_pointers();
   MovePointerData(&ratings, &word->ratings);
   best_choice = word->best_choice;
   MovePointerData(&raw_choice, &word->raw_choice);
   best_choices.clear();
   WERD_CHOICE_IT wc_it(&best_choices);
   wc_it.add_list_after(&word->best_choices);
   reject_map = word->reject_map;
   if (word->blamer_bundle != nullptr) {
     assert(blamer_bundle != nullptr);
     blamer_bundle->CopyResults(*(word->blamer_bundle));
   }
   CopySimpleFields(*word);
 }

◆ copy_on()

void WERD_RES::copy_on ( WERD_RES * word_res )

inline

Definition at line 660 of file pageres.h.

                                    {  //from this word
     word->set_flag(W_BOL, word->flag(W_BOL) || word_res->word->flag(W_BOL));
     word->set_flag(W_EOL, word->flag(W_EOL) || word_res->word->flag(W_EOL));
     word->copy_on(word_res->word);
   }

◆ CopySimpleFields()

void WERD_RES::CopySimpleFields ( const WERD_RES & source )

Definition at line 255 of file pageres.cpp.

                                                       {
   tess_failed = source.tess_failed;
   tess_accepted = source.tess_accepted;
   tess_would_adapt = source.tess_would_adapt;
   done = source.done;
   unlv_crunch_mode = source.unlv_crunch_mode;
   small_caps = source.small_caps;
   odd_size = source.odd_size;
   italic = source.italic;
   bold = source.bold;
   fontinfo = source.fontinfo;
   fontinfo2 = source.fontinfo2;
   fontinfo_id_count = source.fontinfo_id_count;
   fontinfo_id2_count = source.fontinfo_id2_count;
   x_height = source.x_height;
   caps_height = source.caps_height;
   baseline_shift = source.baseline_shift;
   guessed_x_ht = source.guessed_x_ht;
   guessed_caps_ht = source.guessed_caps_ht;
   reject_spaces = source.reject_spaces;
   uch_set = source.uch_set;
   tesseract = source.tesseract;
 }

◆ DebugTopChoice()

void WERD_RES::DebugTopChoice ( const char * msg ) const

Definition at line 505 of file pageres.cpp.

                                                    {
   tprintf("Best choice: accepted=%d, adaptable=%d, done=%d : ",
           tess_accepted, tess_would_adapt, done);
   if (best_choice == nullptr)
     tprintf("<Null choice>\n");
   else
     best_choice->print(msg);
 }

◆ DebugWordChoices()

void WERD_RES::DebugWordChoices	(	bool	debug,
		const char *	word_to_debug
	)

Definition at line 486 of file pageres.cpp.

                                                                      {
   if (debug ||
       (word_to_debug != nullptr && *word_to_debug != '\0' && best_choice != nullptr &&
        best_choice->unichar_string() == STRING(word_to_debug))) {
     if (raw_choice != nullptr)
       raw_choice->print("\nBest Raw Choice");
 
     WERD_CHOICE_IT it(&best_choices);
     int index = 0;
     for (it.mark_cycle_pt(); !it.cycled_list(); it.forward(), ++index) {
       WERD_CHOICE* choice = it.data();
       STRING label;
       label.add_str_int("\nCooked Choice #", index);
       choice->print(label.string());
     }
   }
 }

◆ deep_copy()

static WERD_RES* WERD_RES::deep_copy ( const WERD_RES * src )

inlinestatic

Definition at line 649 of file pageres.h.

                                                   {
     WERD_RES* result = new WERD_RES(*src);
     // That didn't copy the ratings, but we want a copy if there is one to
     // begin with.
     if (src->ratings != nullptr)
       result->ratings = src->ratings->DeepCopy();
     return result;
   }

◆ FakeClassifyWord()

void WERD_RES::FakeClassifyWord	(	int	blob_count,
		BLOB_CHOICE **	choices
	)

Definition at line 883 of file pageres.cpp.

                                                                      {
   // Setup the WERD_RES.
   ASSERT_HOST(box_word != nullptr);
   ASSERT_HOST(blob_count == box_word->length());
   ClearWordChoices();
   ClearRatings();
   ratings = new MATRIX(blob_count, 1);
   for (int c = 0; c < blob_count; ++c) {
     BLOB_CHOICE_LIST* choice_list = new BLOB_CHOICE_LIST;
     BLOB_CHOICE_IT choice_it(choice_list);
     choice_it.add_after_then_move(choices[c]);
     ratings->put(c, c, choice_list);
   }
   FakeWordFromRatings(TOP_CHOICE_PERM);
   reject_map.initialise(blob_count);
   best_state.init_to_size(blob_count, 1);
   done = true;
 }

◆ FakeWordFromRatings()

void WERD_RES::FakeWordFromRatings ( PermuterType permuter )

Definition at line 904 of file pageres.cpp.

                                                         {
   int num_blobs = ratings->dimension();
   WERD_CHOICE* word_choice = new WERD_CHOICE(uch_set, num_blobs);
   word_choice->set_permuter(permuter);
   for (int b = 0; b < num_blobs; ++b) {
     UNICHAR_ID unichar_id = UNICHAR_SPACE;
     float rating = INT32_MAX;
     float certainty = -INT32_MAX;
     BLOB_CHOICE_LIST* choices = ratings->get(b, b);
     if (choices != nullptr && !choices->empty()) {
       BLOB_CHOICE_IT bc_it(choices);
       BLOB_CHOICE* choice = bc_it.data();
       unichar_id = choice->unichar_id();
       rating = choice->rating();
       certainty = choice->certainty();
     }
     word_choice->append_unichar_id_space_allocated(unichar_id, 1, rating,
                                                    certainty);
   }
   LogNewRawChoice(word_choice);
   // Ownership of word_choice taken by word here.
   LogNewCookedChoice(1, false, word_choice);
 }

◆ FilterWordChoices()

void WERD_RES::FilterWordChoices ( int debug_level )

Definition at line 519 of file pageres.cpp.

                                                 {
   if (best_choice == nullptr || best_choices.singleton())
     return;
 
   if (debug_level >= 2)
     best_choice->print("\nFiltering against best choice");
   WERD_CHOICE_IT it(&best_choices);
   int index = 0;
   for (it.forward(); !it.at_first(); it.forward(), ++index) {
     WERD_CHOICE* choice = it.data();
     float threshold = StopperAmbigThreshold(best_choice->adjust_factor(),
                                             choice->adjust_factor());
     // i, j index the blob choice in choice, best_choice.
     // chunk is an index into the chopped_word blobs (AKA chunks).
     // Since the two words may use different segmentations of the chunks, we
     // iterate over the chunks to find out whether a comparable blob
     // classification is much worse than the best result.
     int i = 0, j = 0, chunk = 0;
     // Each iteration of the while deals with 1 chunk. On entry choice_chunk
     // and best_chunk are the indices of the first chunk in the NEXT blob,
     // i.e. we don't have to increment i, j while chunk < choice_chunk and
     // best_chunk respectively.
     int choice_chunk = choice->state(0), best_chunk = best_choice->state(0);
     while (i < choice->length() && j < best_choice->length()) {
       if (choice->unichar_id(i) != best_choice->unichar_id(j) &&
           choice->certainty(i) - best_choice->certainty(j) < threshold) {
         if (debug_level >= 2) {
           choice->print("WorstCertaintyDiffWorseThan");
           tprintf(
               "i %d j %d Choice->Blob[i].Certainty %.4g"
               " WorstOtherChoiceCertainty %g Threshold %g\n",
               i, j, choice->certainty(i), best_choice->certainty(j), threshold);
           tprintf("Discarding bad choice #%d\n", index);
         }
         delete it.extract();
         break;
       }
       ++chunk;
       // If needed, advance choice_chunk to keep up with chunk.
       while (choice_chunk < chunk && ++i < choice->length())
         choice_chunk += choice->state(i);
       // If needed, advance best_chunk to keep up with chunk.
       while (best_chunk < chunk && ++j < best_choice->length())
         best_chunk += best_choice->state(j);
     }
   }
 }

◆ fix_hyphens()

void WERD_RES::fix_hyphens ( )

Definition at line 1053 of file pageres.cpp.

                            {
   if (!uch_set->contains_unichar("-") ||
       !uch_set->get_enabled(uch_set->unichar_to_id("-")))
     return;  // Don't create it if it is disallowed.
 
   ConditionalBlobMerge(
       NewPermanentTessCallback(this, &WERD_RES::BothHyphens),
       NewPermanentTessCallback(this, &WERD_RES::HyphenBoxesOverlap));
 }

◆ fix_quotes()

void WERD_RES::fix_quotes ( )

Definition at line 1024 of file pageres.cpp.

                           {
   if (!uch_set->contains_unichar("\"") ||
       !uch_set->get_enabled(uch_set->unichar_to_id("\"")))
     return;  // Don't create it if it is disallowed.
 
   ConditionalBlobMerge(
       NewPermanentTessCallback(this, &WERD_RES::BothQuotes),
       nullptr);
 }

◆ GetBlobChoice()

BLOB_CHOICE * WERD_RES::GetBlobChoice ( int index ) const

Definition at line 756 of file pageres.cpp.

                                                     {
   if (index < 0 || index >= best_choice->length()) return nullptr;
   BLOB_CHOICE_LIST* choices = GetBlobChoices(index);
   return FindMatchingChoice(best_choice->unichar_id(index), choices);
 }

◆ GetBlobChoices()

BLOB_CHOICE_LIST * WERD_RES::GetBlobChoices ( int index ) const

Definition at line 765 of file pageres.cpp.

                                                           {
   return best_choice->blob_choices(index, ratings);
 }

◆ GetBlobsGap()

int WERD_RES::GetBlobsGap ( int blob_index )

Definition at line 746 of file pageres.cpp.

                                         {
   if (blob_index < 0 || blob_index >= blob_gaps.size())
     return 0;
   return blob_gaps[blob_index];
 }

◆ GetBlobsWidth()

int WERD_RES::GetBlobsWidth	(	int	start_blob,
		int	last_blob
	)

Definition at line 736 of file pageres.cpp.

                                                          {
   int result = 0;
   for (int b = start_blob; b <= last_blob; ++b) {
     result += blob_widths[b];
     if (b < last_blob)
       result += blob_gaps[b];
   }
   return result;
 }

◆ HyphenBoxesOverlap()

bool WERD_RES::HyphenBoxesOverlap	(	const TBOX &	box1,
		const TBOX &	box2
	)

Definition at line 1047 of file pageres.cpp.

                                                                     {
   return box1.right() >= box2.left();
 }

◆ InitForRetryRecognition()

void WERD_RES::InitForRetryRecognition ( const WERD_RES & source )

Definition at line 283 of file pageres.cpp.

                                                              {
   word = source.word;
   CopySimpleFields(source);
   if (source.blamer_bundle != nullptr) {
     blamer_bundle = new BlamerBundle();
     blamer_bundle->CopyTruth(*source.blamer_bundle);
   }
 }

◆ InitNonPointers()

void WERD_RES::InitNonPointers ( )

Definition at line 1100 of file pageres.cpp.

                                {
   tess_failed = false;
   tess_accepted = false;
   tess_would_adapt = false;
   done = false;
   unlv_crunch_mode = CR_NONE;
   small_caps = false;
   odd_size = false;
   italic = FALSE;
   bold = FALSE;
   // The fontinfos and tesseract count as non-pointers as they point to
   // data owned elsewhere.
   fontinfo = nullptr;
   fontinfo2 = nullptr;
   tesseract = nullptr;
   fontinfo_id_count = 0;
   fontinfo_id2_count = 0;
   x_height = 0.0;
   caps_height = 0.0;
   baseline_shift = 0.0f;
   space_certainty = 0.0f;
   guessed_x_ht = true;
   guessed_caps_ht = true;
   combination = false;
   part_of_combo = false;
   reject_spaces = false;
 }

◆ InitPointers()

void WERD_RES::InitPointers ( )

Definition at line 1128 of file pageres.cpp.

                             {
   word = nullptr;
   bln_boxes = nullptr;
   blob_row = nullptr;
   uch_set = nullptr;
   chopped_word = nullptr;
   rebuild_word = nullptr;
   box_word = nullptr;
   ratings = nullptr;
   best_choice = nullptr;
   raw_choice = nullptr;
   ep_choice = nullptr;
   blamer_bundle = nullptr;
 }

◆ InsertSeam()

void WERD_RES::InsertSeam	(	int	blob_number,
		SEAM *	seam
	)

Definition at line 424 of file pageres.cpp.

                                                      {
   // Insert the seam into the SEAMS array.
   seam->PrepareToInsertSeam(seam_array, chopped_word->blobs, blob_number, true);
   seam_array.insert(seam, blob_number);
   if (ratings != nullptr) {
     // Expand the ratings matrix.
     ratings = ratings->ConsumeAndMakeBigger(blob_number);
     // Fix all the segmentation states.
     if (raw_choice != nullptr)
       raw_choice->UpdateStateForSplit(blob_number);
     WERD_CHOICE_IT wc_it(&best_choices);
     for (wc_it.mark_cycle_pt(); !wc_it.cycled_list(); wc_it.forward()) {
       WERD_CHOICE* choice = wc_it.data();
       choice->UpdateStateForSplit(blob_number);
     }
     SetupBlobWidthsAndGaps();
   }
 }

◆ IsAmbiguous()

bool WERD_RES::IsAmbiguous ( )

Definition at line 458 of file pageres.cpp.

                            {
   return !best_choices.singleton() || best_choice->dangerous_ambig_found();
 }

◆ LogNewCookedChoice()

bool WERD_RES::LogNewCookedChoice	(	int	max_num_choices,
		bool	debug,
		WERD_CHOICE *	word_choice
	)

Definition at line 626 of file pageres.cpp.

                                                             {
   if (best_choice != nullptr) {
     // Throw out obviously bad choices to save some work.
     // TODO(rays) Get rid of this! This piece of code produces different
     // results according to the order in which words are found, which is an
     // undesirable behavior. It would be better to keep all the choices and
     // prune them later when more information is available.
     float max_certainty_delta =
         StopperAmbigThreshold(best_choice->adjust_factor(),
                               word_choice->adjust_factor());
     if (max_certainty_delta > -kStopperAmbiguityThresholdOffset)
       max_certainty_delta = -kStopperAmbiguityThresholdOffset;
     if (word_choice->certainty() - best_choice->certainty() <
         max_certainty_delta) {
       if (debug) {
         STRING bad_string;
         word_choice->string_and_lengths(&bad_string, nullptr);
         tprintf("Discarding choice \"%s\" with an overly low certainty"
                 " %.3f vs best choice certainty %.3f (Threshold: %.3f)\n",
                 bad_string.string(), word_choice->certainty(),
                 best_choice->certainty(),
                 max_certainty_delta + best_choice->certainty());
       }
       delete word_choice;
       return false;
     }
   }
 
   // Insert in the list in order of increasing rating, but knock out worse
   // string duplicates.
   WERD_CHOICE_IT it(&best_choices);
   const STRING& new_str = word_choice->unichar_string();
   bool inserted = false;
   int num_choices = 0;
   if (!it.empty()) {
     do {
       WERD_CHOICE* choice = it.data();
       if (choice->rating() > word_choice->rating() && !inserted) {
         // Time to insert.
         it.add_before_stay_put(word_choice);
         inserted = true;
         if (num_choices == 0)
           best_choice = word_choice;  // This is the new best.
         ++num_choices;
       }
       if (choice->unichar_string() == new_str) {
         if (inserted) {
           // New is better.
           delete it.extract();
         } else {
           // Old is better.
           if (debug) {
             tprintf("Discarding duplicate choice \"%s\", rating %g vs %g\n",
                     new_str.string(), word_choice->rating(), choice->rating());
           }
           delete word_choice;
           return false;
         }
       } else {
         ++num_choices;
         if (num_choices > max_num_choices)
           delete it.extract();
       }
       it.forward();
     } while (!it.at_first());
   }
   if (!inserted && num_choices < max_num_choices) {
     it.add_to_end(word_choice);
     inserted = true;
     if (num_choices == 0)
       best_choice = word_choice;  // This is the new best.
   }
   if (debug) {
     if (inserted)
       tprintf("New %s", best_choice == word_choice ? "Best" : "Secondary");
     else
       tprintf("Poor");
     word_choice->print(" Word Choice");
   }
   if (!inserted) {
     delete word_choice;
     return false;
   }
   return true;
 }

◆ LogNewRawChoice()

bool WERD_RES::LogNewRawChoice ( WERD_CHOICE * word_choice )

Definition at line 610 of file pageres.cpp.

                                                        {
   if (raw_choice == nullptr || word_choice->rating() < raw_choice->rating()) {
     delete raw_choice;
     raw_choice = new WERD_CHOICE(*word_choice);
     raw_choice->set_permuter(TOP_CHOICE_PERM);
     return true;
   }
   return false;
 }

◆ merge_tess_fails()

void WERD_RES::merge_tess_fails ( )

Definition at line 1073 of file pageres.cpp.

                                 {
   if (ConditionalBlobMerge(
       NewPermanentTessCallback(this, &WERD_RES::BothSpaces), nullptr)) {
     int len = best_choice->length();
     ASSERT_HOST(reject_map.length() == len);
     ASSERT_HOST(box_word->length() == len);
   }
 }

◆ MergeAdjacentBlobs()

void WERD_RES::MergeAdjacentBlobs ( int index )

Definition at line 980 of file pageres.cpp.

                                            {
   if (reject_map.length() == best_choice->length())
     reject_map.remove_pos(index);
   best_choice->remove_unichar_id(index + 1);
   rebuild_word->MergeBlobs(index, index + 2);
   box_word->MergeBoxes(index, index + 2);
   if (index + 1 < best_state.length()) {
     best_state[index] += best_state[index + 1];
     best_state.remove(index + 1);
   }
 }

◆ operator=()

WERD_RES & WERD_RES::operator= ( const WERD_RES & source )

Definition at line 192 of file pageres.cpp.

                                                      {
   this->ELIST_LINK::operator=(source);
   Clear();
   if (source.combination) {
     word = new WERD;
     *word = *(source.word);      // deep copy
   } else {
     word = source.word;          // pt to same word
   }
   if (source.bln_boxes != nullptr)
     bln_boxes = new tesseract::BoxWord(*source.bln_boxes);
   if (source.chopped_word != nullptr)
     chopped_word = new TWERD(*source.chopped_word);
   if (source.rebuild_word != nullptr)
     rebuild_word = new TWERD(*source.rebuild_word);
   // TODO(rays) Do we ever need to copy the seam_array?
   blob_row = source.blob_row;
   denorm = source.denorm;
   if (source.box_word != nullptr)
     box_word = new tesseract::BoxWord(*source.box_word);
   best_state = source.best_state;
   correct_text = source.correct_text;
   blob_widths = source.blob_widths;
   blob_gaps = source.blob_gaps;
   // None of the uses of operator= require the ratings matrix to be copied,
   // so don't as it would be really slow.
 
   // Copy the cooked choices.
   WERD_CHOICE_IT wc_it(const_cast<WERD_CHOICE_LIST*>(&source.best_choices));
   WERD_CHOICE_IT wc_dest_it(&best_choices);
   for (wc_it.mark_cycle_pt(); !wc_it.cycled_list(); wc_it.forward()) {
     const WERD_CHOICE *choice = wc_it.data();
     wc_dest_it.add_after_then_move(new WERD_CHOICE(*choice));
   }
   if (!wc_dest_it.empty()) {
     wc_dest_it.move_to_first();
     best_choice = wc_dest_it.data();
   } else {
     best_choice = nullptr;
   }
 
   if (source.raw_choice != nullptr) {
     raw_choice = new WERD_CHOICE(*source.raw_choice);
   } else {
     raw_choice = nullptr;
   }
   if (source.ep_choice != nullptr) {
     ep_choice = new WERD_CHOICE(*source.ep_choice);
   } else {
     ep_choice = nullptr;
   }
   reject_map = source.reject_map;
   combination = source.combination;
   part_of_combo = source.part_of_combo;
   CopySimpleFields(source);
   if (source.blamer_bundle != nullptr) {
     blamer_bundle =  new BlamerBundle(*(source.blamer_bundle));
   }
   return *this;
 }

◆ PiecesAllNatural()

bool WERD_RES::PiecesAllNatural	(	int	start,
		int	count
	)		const

Definition at line 1084 of file pageres.cpp.

                                                           {
   // all seams must have no splits.
   for (int index = start; index < start + count - 1; ++index) {
     if (index >= 0 && index < seam_array.size()) {
       SEAM* seam = seam_array[index];
       if (seam != nullptr && seam->HasAnySplits()) return false;
     }
   }
   return true;
 }

◆ PrintBestChoices()

void WERD_RES::PrintBestChoices ( ) const

Definition at line 723 of file pageres.cpp.

                                       {
   STRING alternates_str;
   WERD_CHOICE_IT it(const_cast<WERD_CHOICE_LIST*>(&best_choices));
   for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
     if (!it.at_first()) alternates_str += "\", \"";
     alternates_str += it.data()->unichar_string();
   }
   tprintf("Alternates for \"%s\": {\"%s\"}\n",
           best_choice->unichar_string().string(), alternates_str.string());
 }

◆ RawUTF8()

const char* WERD_RES::RawUTF8 ( int blob_index ) const

inline

Definition at line 374 of file pageres.h.

                                             {
     if (blob_index < 0 || blob_index >= raw_choice->length())
       return nullptr;
     UNICHAR_ID id = raw_choice->unichar_id(blob_index);
     if (id < 0 || id >= uch_set->size())
       return nullptr;
     return uch_set->id_to_unichar(id);
   }

◆ RebuildBestState()

void WERD_RES::RebuildBestState ( )

Definition at line 814 of file pageres.cpp.

                                 {
   ASSERT_HOST(best_choice != nullptr);
   delete rebuild_word;
   rebuild_word = new TWERD;
   if (seam_array.empty())
     start_seam_list(chopped_word, &seam_array);
   best_state.truncate(0);
   int start = 0;
   for (int i = 0; i < best_choice->length(); ++i) {
     int length = best_choice->state(i);
     best_state.push_back(length);
     if (length > 1) {
       SEAM::JoinPieces(seam_array, chopped_word->blobs, start,
                        start + length - 1);
     }
     TBLOB* blob = chopped_word->blobs[start];
     rebuild_word->blobs.push_back(new TBLOB(*blob));
     if (length > 1) {
       SEAM::BreakPieces(seam_array, chopped_word->blobs, start,
                         start + length - 1);
     }
     start += length;
   }
 }

◆ ReplaceBestChoice()

void WERD_RES::ReplaceBestChoice ( WERD_CHOICE * choice )

Definition at line 801 of file pageres.cpp.

                                                     {
   best_choice = choice;
   RebuildBestState();
   SetupBoxWord();
   // Make up a fake reject map of the right length to keep the
   // rejection pass happy.
   reject_map.initialise(best_state.length());
   done = tess_accepted = tess_would_adapt = true;
   SetScriptPositions();
 }

◆ SetAllScriptPositions()

void WERD_RES::SetAllScriptPositions ( tesseract::ScriptPos position )

Definition at line 871 of file pageres.cpp.

                                                                 {
   raw_choice->SetAllScriptPositions(position);
   WERD_CHOICE_IT wc_it(&best_choices);
   for (wc_it.mark_cycle_pt(); !wc_it.cycled_list(); wc_it.forward())
     wc_it.data()->SetAllScriptPositions(position);
 }

◆ SetScriptPositions()

void WERD_RES::SetScriptPositions ( )

Definition at line 864 of file pageres.cpp.

                                   {
   best_choice->SetScriptPositions(small_caps, chopped_word);
 }

◆ SetupBasicsFromChoppedWord()

void WERD_RES::SetupBasicsFromChoppedWord ( const UNICHARSET & unicharset_in )

Definition at line 349 of file pageres.cpp.

                                                                          {
   bln_boxes = tesseract::BoxWord::CopyFromNormalized(chopped_word);
   start_seam_list(chopped_word, &seam_array);
   SetupBlobWidthsAndGaps();
   ClearWordChoices();
 }

◆ SetupBlamerBundle()

void WERD_RES::SetupBlamerBundle ( )

Definition at line 399 of file pageres.cpp.

                                  {
   if (blamer_bundle != nullptr) {
     blamer_bundle->SetupNormTruthWord(denorm);
   }
 }

◆ SetupBlobWidthsAndGaps()

void WERD_RES::SetupBlobWidthsAndGaps ( )

Definition at line 406 of file pageres.cpp.

                                       {
   blob_widths.truncate(0);
   blob_gaps.truncate(0);
   int num_blobs = chopped_word->NumBlobs();
   for (int b = 0; b < num_blobs; ++b) {
     TBLOB *blob = chopped_word->blobs[b];
     TBOX box = blob->bounding_box();
     blob_widths.push_back(box.width());
     if (b + 1 < num_blobs) {
       blob_gaps.push_back(
           chopped_word->blobs[b + 1]->bounding_box().left() - box.right());
     }
   }
 }

◆ SetupBoxWord()

void WERD_RES::SetupBoxWord ( )

Definition at line 855 of file pageres.cpp.

                             {
   delete box_word;
   rebuild_word->ComputeBoundingBoxes();
   box_word = tesseract::BoxWord::CopyFromNormalized(rebuild_word);
   box_word->ClipToOriginalWord(denorm.block(), word);
 }

◆ SetupFake()

void WERD_RES::SetupFake ( const UNICHARSET & uch )

Definition at line 358 of file pageres.cpp.

                                                         {
   ClearResults();
   SetupWordScript(unicharset_in);
   chopped_word = new TWERD;
   rebuild_word = new TWERD;
   bln_boxes = new tesseract::BoxWord;
   box_word = new tesseract::BoxWord;
   int blob_count = word->cblob_list()->length();
   if (blob_count > 0) {
     BLOB_CHOICE** fake_choices = new BLOB_CHOICE*[blob_count];
     // For non-text blocks, just pass any blobs through to the box_word
     // and call the word failed with a fake classification.
     C_BLOB_IT b_it(word->cblob_list());
     int blob_id = 0;
     for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
       TBOX box = b_it.data()->bounding_box();
       box_word->InsertBox(box_word->length(), box);
       fake_choices[blob_id++] = new BLOB_CHOICE;
     }
     FakeClassifyWord(blob_count, fake_choices);
     delete [] fake_choices;
   } else {
     WERD_CHOICE* word = new WERD_CHOICE(&unicharset_in);
     word->make_bad();
     LogNewRawChoice(word);
     // Ownership of word is taken by *this WERD_RES in LogNewCookedChoice.
     LogNewCookedChoice(1, false, word);
   }
   tess_failed = true;
   done = true;
 }

◆ SetupForRecognition()

bool WERD_RES::SetupForRecognition	(	const UNICHARSET &	unicharset_in,
		tesseract::Tesseract *	tesseract,
		Pix *	pix,
		int	norm_mode,
		const TBOX *	norm_box,
		bool	numeric_mode,
		bool	use_body_size,
		bool	allow_detailed_fx,
		ROW *	row,
		const BLOCK *	block
	)

Definition at line 308 of file pageres.cpp.

                                                                  {
   tesseract::OcrEngineMode norm_mode_hint =
       static_cast<tesseract::OcrEngineMode>(norm_mode);
   tesseract = tess;
   POLY_BLOCK* pb = block != nullptr ? block->pdblk.poly_block() : nullptr;
   if ((norm_mode_hint != tesseract::OEM_LSTM_ONLY &&
        word->cblob_list()->empty()) ||
       (pb != nullptr && !pb->IsText())) {
     // Empty words occur when all the blobs have been moved to the rej_blobs
     // list, which seems to occur frequently in junk.
     SetupFake(unicharset_in);
     word->set_flag(W_REP_CHAR, false);
     return false;
   }
   ClearResults();
   SetupWordScript(unicharset_in);
   chopped_word = TWERD::PolygonalCopy(allow_detailed_fx, word);
   float word_xheight = use_body_size && row != nullptr && row->body_size() > 0.0f
                      ? row->body_size() : x_height;
   chopped_word->BLNormalize(block, row, pix, word->flag(W_INVERSE),
                             word_xheight, baseline_shift, numeric_mode,
                             norm_mode_hint, norm_box, &denorm);
   blob_row = row;
   SetupBasicsFromChoppedWord(unicharset_in);
   SetupBlamerBundle();
   int num_blobs = chopped_word->NumBlobs();
   ratings = new MATRIX(num_blobs, kWordrecMaxNumJoinChunks);
   tess_failed = false;
   return true;
 }

◆ SetupWordScript()

void WERD_RES::SetupWordScript ( const UNICHARSET & unicharset_in )

Definition at line 390 of file pageres.cpp.

                                                     {
   uch_set = &uch;
   int script = uch.default_sid();
   word->set_script_id(script);
   word->set_flag(W_SCRIPT_HAS_XHEIGHT, uch.script_has_xheight());
   word->set_flag(W_SCRIPT_IS_LATIN, script == uch.latin_sid());
 }

◆ StatesAllValid()

bool WERD_RES::StatesAllValid ( )

Definition at line 464 of file pageres.cpp.

                               {
   int ratings_dim = ratings->dimension();
   if (raw_choice->TotalOfStates() != ratings_dim) {
     tprintf("raw_choice has total of states = %d vs ratings dim of %d\n",
             raw_choice->TotalOfStates(), ratings_dim);
     return false;
   }
   WERD_CHOICE_IT it(&best_choices);
   int index = 0;
   for (it.mark_cycle_pt(); !it.cycled_list(); it.forward(), ++index) {
     WERD_CHOICE* choice = it.data();
     if (choice->TotalOfStates() != ratings_dim) {
       tprintf("Cooked #%d has total of states = %d vs ratings dim of %d\n",
               index, choice->TotalOfStates(), ratings_dim);
       return false;
     }
   }
   return true;
 }

◆ SymbolDirection()

UNICHARSET::Direction WERD_RES::SymbolDirection ( int blob_index ) const

inline

Definition at line 383 of file pageres.h.

                                                             {
     if (best_choice == nullptr ||
         blob_index >= best_choice->length() ||
         blob_index < 0)
       return UNICHARSET::U_OTHER_NEUTRAL;
     return uch_set->get_direction(best_choice->unichar_id(blob_index));
   }

◆ UnicharsInReadingOrder()

bool WERD_RES::UnicharsInReadingOrder ( ) const

inline

Definition at line 425 of file pageres.h.

                                       {
     return best_choice->unichars_in_script_order();
   }

Member Data Documentation

◆ baseline_shift

float WERD_RES::baseline_shift

Definition at line 313 of file pageres.h.

◆ best_choice

WERD_CHOICE* WERD_RES::best_choice

Definition at line 235 of file pageres.h.

◆ best_choices

WERD_CHOICE_LIST WERD_RES::best_choices

Definition at line 243 of file pageres.h.

◆ best_state

GenericVector<int> WERD_RES::best_state

Definition at line 271 of file pageres.h.

◆ blamer_bundle

BlamerBundle* WERD_RES::blamer_bundle

Definition at line 246 of file pageres.h.

◆ bln_boxes

tesseract::BoxWord* WERD_RES::bln_boxes

Definition at line 198 of file pageres.h.

◆ blob_gaps

GenericVector<int> WERD_RES::blob_gaps

Definition at line 222 of file pageres.h.

◆ blob_row

ROW* WERD_RES::blob_row

Definition at line 200 of file pageres.h.

◆ blob_widths

GenericVector<int> WERD_RES::blob_widths

Definition at line 219 of file pageres.h.

◆ bold

int8_t WERD_RES::bold

Definition at line 302 of file pageres.h.

◆ box_word

tesseract::BoxWord* WERD_RES::box_word

Definition at line 266 of file pageres.h.

◆ caps_height

float WERD_RES::caps_height

Definition at line 312 of file pageres.h.

◆ chopped_word

TWERD* WERD_RES::chopped_word

Definition at line 215 of file pageres.h.

◆ combination

bool WERD_RES::combination

Definition at line 334 of file pageres.h.

◆ correct_text

GenericVector<STRING> WERD_RES::correct_text

Definition at line 275 of file pageres.h.

◆ denorm

DENORM WERD_RES::denorm

Definition at line 204 of file pageres.h.

◆ done

bool WERD_RES::done

Definition at line 298 of file pageres.h.

◆ ep_choice

WERD_CHOICE* WERD_RES::ep_choice

Definition at line 286 of file pageres.h.

◆ fontinfo

const FontInfo* WERD_RES::fontinfo

Definition at line 304 of file pageres.h.

◆ fontinfo2

const FontInfo* WERD_RES::fontinfo2

Definition at line 305 of file pageres.h.

◆ fontinfo_id2_count

int8_t WERD_RES::fontinfo_id2_count

Definition at line 307 of file pageres.h.

◆ fontinfo_id_count

int8_t WERD_RES::fontinfo_id_count

Definition at line 306 of file pageres.h.

◆ guessed_caps_ht

bool WERD_RES::guessed_caps_ht

Definition at line 309 of file pageres.h.

◆ guessed_x_ht

bool WERD_RES::guessed_x_ht

Definition at line 308 of file pageres.h.

◆ italic

int8_t WERD_RES::italic

Definition at line 301 of file pageres.h.

◆ odd_size

bool WERD_RES::odd_size

Definition at line 300 of file pageres.h.

◆ part_of_combo

bool WERD_RES::part_of_combo

Definition at line 335 of file pageres.h.

◆ ratings

MATRIX* WERD_RES::ratings

Definition at line 231 of file pageres.h.

◆ raw_choice

WERD_CHOICE* WERD_RES::raw_choice

Definition at line 240 of file pageres.h.

◆ rebuild_word

TWERD* WERD_RES::rebuild_word

Definition at line 260 of file pageres.h.

◆ reject_map

REJMAP WERD_RES::reject_map

Definition at line 287 of file pageres.h.

◆ reject_spaces

bool WERD_RES::reject_spaces

Definition at line 336 of file pageres.h.

◆ seam_array

GenericVector<SEAM*> WERD_RES::seam_array

Definition at line 217 of file pageres.h.

◆ small_caps

bool WERD_RES::small_caps

Definition at line 299 of file pageres.h.

◆ space_certainty

float WERD_RES::space_certainty

Definition at line 316 of file pageres.h.

◆ tess_accepted

bool WERD_RES::tess_accepted

Definition at line 296 of file pageres.h.

◆ tess_failed

bool WERD_RES::tess_failed

Definition at line 288 of file pageres.h.

◆ tess_would_adapt

bool WERD_RES::tess_would_adapt

Definition at line 297 of file pageres.h.

◆ tesseract

tesseract::Tesseract* WERD_RES::tesseract

Definition at line 282 of file pageres.h.

◆ timesteps

std::vector<std::vector<std::pair<const char*, float> > > WERD_RES::timesteps

Definition at line 224 of file pageres.h.

◆ uch_set

const UNICHARSET* WERD_RES::uch_set

Definition at line 206 of file pageres.h.

◆ unlv_crunch_mode

CRUNCH_MODE WERD_RES::unlv_crunch_mode

Definition at line 310 of file pageres.h.

◆ word

WERD* WERD_RES::word

Definition at line 189 of file pageres.h.

◆ x_height

float WERD_RES::x_height

Definition at line 311 of file pageres.h.

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

/usr/src/tesseract-ocr.master/src/ccstruct/pageres.h
/usr/src/tesseract-ocr.master/src/ccstruct/pageres.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ WERD_RES() [1/3]

◆ WERD_RES() [2/3]

◆ WERD_RES() [3/3]

◆ ~WERD_RES()

Member Function Documentation

◆ AlternativeChoiceAdjustmentsWorseThan()

◆ AnyLtrCharsInWord()

◆ AnyRtlCharsInWord()

◆ BestChoiceToCorrectText()

◆ BestUTF8()

◆ BothHyphens()

◆ BothQuotes()

◆ BothSpaces()

◆ Clear()

◆ ClearRatings()

◆ ClearResults()

◆ ClearWordChoices()

◆ CloneChoppedToRebuild()

◆ ComputeAdaptionThresholds()

◆ ConditionalBlobMerge()

◆ ConsumeWordResults()

◆ copy_on()

◆ CopySimpleFields()

◆ DebugTopChoice()

◆ DebugWordChoices()

◆ deep_copy()

◆ FakeClassifyWord()

◆ FakeWordFromRatings()

◆ FilterWordChoices()

◆ fix_hyphens()

◆ fix_quotes()

◆ GetBlobChoice()

◆ GetBlobChoices()

◆ GetBlobsGap()

◆ GetBlobsWidth()

◆ HyphenBoxesOverlap()

◆ InitForRetryRecognition()

◆ InitNonPointers()

◆ InitPointers()

◆ InsertSeam()

◆ IsAmbiguous()

◆ LogNewCookedChoice()

◆ LogNewRawChoice()

◆ merge_tess_fails()

◆ MergeAdjacentBlobs()

◆ operator=()

◆ PiecesAllNatural()

◆ PrintBestChoices()

◆ RawUTF8()

◆ RebuildBestState()

◆ ReplaceBestChoice()

◆ SetAllScriptPositions()

◆ SetScriptPositions()

◆ SetupBasicsFromChoppedWord()

◆ SetupBlamerBundle()

◆ SetupBlobWidthsAndGaps()

◆ SetupBoxWord()

◆ SetupFake()

◆ SetupForRecognition()

◆ SetupWordScript()

◆ StatesAllValid()

◆ SymbolDirection()

◆ UnicharsInReadingOrder()

Member Data Documentation

◆ baseline_shift

◆ best_choice

◆ best_choices

◆ best_state

◆ blamer_bundle

◆ bln_boxes

◆ blob_gaps

◆ blob_row

◆ blob_widths

◆ bold

◆ box_word