#include <pageres.h>

Inheritance diagram for tesseract::WERD_RES:

Public Member Functions
	WERD_RES ()=default

	WERD_RES (WERD *the_word)

	WERD_RES (const WERD_RES &source)

	~WERD_RES ()

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

const char *	RawUTF8 (unsigned blob_index) const

UNICHARSET::Direction	SymbolDirection (unsigned blob_index) const

bool	AnyRtlCharsInWord () const

bool	AnyLtrCharsInWord () const

bool	UnicharsInReadingOrder () const

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, Image 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) const

int	GetBlobsGap (unsigned blob_index) const

BLOB_CHOICE *	GetBlobChoice (unsigned 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 (unsigned blob_count, BLOB_CHOICE **choices)

void	FakeWordFromRatings (PermuterType permuter)

void	BestChoiceToCorrectText ()

bool	ConditionalBlobMerge (const std::function< UNICHAR_ID(UNICHAR_ID, UNICHAR_ID)> &class_cb, const std::function< bool(const TBOX &, const TBOX &)> &box_cb)

void	MergeAdjacentBlobs (unsigned 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 tesseract::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 = nullptr

tesseract::BoxWord *	bln_boxes = nullptr

ROW *	blob_row = nullptr

DENORM	denorm

const UNICHARSET *	uch_set = nullptr

TWERD *	chopped_word = nullptr

std::vector< SEAM * >	seam_array

std::vector< int >	blob_widths

std::vector< int >	blob_gaps

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

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

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

bool	leading_space = false

int	end = 0

MATRIX *	ratings = nullptr

WERD_CHOICE *	best_choice = nullptr

WERD_CHOICE *	raw_choice = nullptr

WERD_CHOICE_LIST	best_choices

BlamerBundle *	blamer_bundle = nullptr

TWERD *	rebuild_word = nullptr

tesseract::BoxWord *	box_word = nullptr

tesseract::Tesseract *	tesseract = nullptr

std::vector< int >	best_state

std::vector< std::string >	correct_text

WERD_CHOICE *	ep_choice = nullptr

REJMAP	reject_map

bool	tess_failed = false

bool	tess_accepted = false

bool	tess_would_adapt = false

bool	done = false

bool	small_caps = false

bool	odd_size = false

const FontInfo *	fontinfo = nullptr

const FontInfo *	fontinfo2 = nullptr

int8_t	fontinfo_id_count = 0

int8_t	fontinfo_id2_count = 0

bool	guessed_x_ht = true

bool	guessed_caps_ht = true

CRUNCH_MODE	unlv_crunch_mode = CR_NONE

float	x_height = 0.0f

float	caps_height = 0.0f

float	baseline_shift = 0.0f

float	space_certainty = 0.0f

bool	combination = false

bool	part_of_combo = false

bool	reject_spaces = false

Detailed Description

Definition at line 164 of file pageres.h.

Constructor & Destructor Documentation

◆ WERD_RES() [1/3]

tesseract::WERD_RES::WERD_RES ( )

default

◆ WERD_RES() [2/3]

tesseract::WERD_RES::WERD_RES ( WERD * the_word )

inline

Definition at line 343 of file pageres.h.

                           {
    word = the_word;
  }

◆ WERD_RES() [3/3]

tesseract::WERD_RES::WERD_RES ( const WERD_RES & source )

inline

Definition at line 348 of file pageres.h.

                                   : ELIST_LINK(source) {
    // combination is used in function Clear which is called from operator=.
    combination = false;
    *this = source; // see operator=
  }

◆ ~WERD_RES()

tesseract::WERD_RES::~WERD_RES ( )

Definition at line 1124 of file pageres.cpp.

                    {
  Clear();
}

Member Function Documentation

◆ AlternativeChoiceAdjustmentsWorseThan()

bool tesseract::WERD_RES::AlternativeChoiceAdjustmentsWorseThan ( float threshold ) const

Definition at line 441 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 tesseract::WERD_RES::AnyLtrCharsInWord ( ) const

inline

Definition at line 413 of file pageres.h.

                                 {
    if (uch_set == nullptr || best_choice == nullptr ||
        best_choice->length() < 1) {
      return false;
    }
    for (unsigned id = 0; id < best_choice->length(); id++) {
      unsigned unichar_id = best_choice->unichar_id(id);
      if (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 ||
          dir == UNICHARSET::U_ARABIC_NUMBER) {
        return true;
      }
    }
    return false;
  }

◆ AnyRtlCharsInWord()

bool tesseract::WERD_RES::AnyRtlCharsInWord ( ) const

inline

Definition at line 394 of file pageres.h.

                                 {
    if (uch_set == nullptr || best_choice == nullptr ||
        best_choice->length() < 1) {
      return false;
    }
    for (unsigned id = 0; id < best_choice->length(); id++) {
      unsigned unichar_id = best_choice->unichar_id(id);
      if (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) {
        return true;
      }
    }
    return false;
  }

◆ BestChoiceToCorrectText()

void tesseract::WERD_RES::BestChoiceToCorrectText ( )

Definition at line 956 of file pageres.cpp.

                                       {
  correct_text.clear();
  ASSERT_HOST(best_choice != nullptr);
  for (unsigned 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.emplace_back(blob_choice);
  }
}

◆ BestUTF8()

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

inline

Definition at line 361 of file pageres.h.

                                                                       {
    if (best_choice == nullptr || blob_index >= best_choice->length()) {
      return nullptr;
    }
    UNICHAR_ID id = best_choice->unichar_id(blob_index);
    if (static_cast<unsigned>(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 tesseract::WERD_RES::BothHyphens	(	UNICHAR_ID	id1,
		UNICHAR_ID	id2
	)

Definition at line 1059 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 tesseract::WERD_RES::BothQuotes	(	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 (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 tesseract::WERD_RES::BothSpaces	(	UNICHAR_ID	id1,
		UNICHAR_ID	id2
	)

Definition at line 1090 of file pageres.cpp.

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

◆ Clear()

void tesseract::WERD_RES::Clear ( )

Definition at line 1128 of file pageres.cpp.

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

◆ ClearRatings()

void tesseract::WERD_RES::ClearRatings ( )

Definition at line 1175 of file pageres.cpp.

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

◆ ClearResults()

void tesseract::WERD_RES::ClearResults ( )

Definition at line 1138 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();
  for (auto data : seam_array) {
    delete data;
  }
  seam_array.clear();
  blob_widths.clear();
  blob_gaps.clear();
  ClearRatings();
  ClearWordChoices();
  if (blamer_bundle != nullptr) {
    blamer_bundle->ClearResults();
  }
}

◆ ClearWordChoices()

void tesseract::WERD_RES::ClearWordChoices ( )

Definition at line 1167 of file pageres.cpp.

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

◆ CloneChoppedToRebuild()

void tesseract::WERD_RES::CloneChoppedToRebuild ( )

Definition at line 865 of file pageres.cpp.

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

◆ ComputeAdaptionThresholds()

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

Definition at line 570 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 (unsigned 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 tesseract::WERD_RES::ConditionalBlobMerge	(	const std::function< UNICHAR_ID(UNICHAR_ID, UNICHAR_ID)> &	class_cb,
		const std::function< bool(const TBOX &, const TBOX &)> &	box_cb
	)

Definition at line 971 of file pageres.cpp.

                                                                 {
  ASSERT_HOST(best_choice->empty() || ratings != nullptr);
  bool modified = false;
  for (unsigned i = 0; i + 1 < best_choice->length(); ++i) {
    UNICHAR_ID new_id =
        class_cb(best_choice->unichar_id(i), best_choice->unichar_id(i + 1));
    if (new_id != INVALID_UNICHAR_ID &&
        (box_cb == nullptr ||
         box_cb(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.
        auto *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);
      }
    }
  }
  return modified;
}

◆ ConsumeWordResults()

void tesseract::WERD_RES::ConsumeWordResults ( WERD_RES * word )

Definition at line 785 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);
  for (auto data : seam_array) {
    delete data;
  }
  seam_array = word->seam_array;
  word->seam_array.clear();
  // TODO: optimize moves.
  best_state = word->best_state;
  word->best_state.clear();
  correct_text = word->correct_text;
  word->correct_text.clear();
  blob_widths = word->blob_widths;
  word->blob_widths.clear();
  blob_gaps = word->blob_gaps;
  word->blob_gaps.clear();
  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 tesseract::WERD_RES::copy_on ( WERD_RES * word_res )

inline

Definition at line 667 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 tesseract::WERD_RES::CopySimpleFields ( const WERD_RES & source )

Definition at line 253 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;
  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 tesseract::WERD_RES::DebugTopChoice ( const char * msg ) const

Definition at line 503 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 tesseract::WERD_RES::DebugWordChoices	(	bool	debug,
		const char *	word_to_debug
	)

Definition at line 483 of file pageres.cpp.

                                                                     {
  if (debug || (word_to_debug != nullptr && *word_to_debug != '\0' &&
                best_choice != nullptr &&
                best_choice->unichar_string() == std::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();
      std::string label;
      label += "\nCooked Choice #" + std::to_string(index);
      choice->print(label.c_str());
    }
  }
}

◆ deep_copy()

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

inlinestatic

Definition at line 655 of file pageres.h.

                                                  {
    auto *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 tesseract::WERD_RES::FakeClassifyWord	(	unsigned	blob_count,
		BLOB_CHOICE **	choices
	)

Definition at line 908 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 (unsigned c = 0; c < blob_count; ++c) {
    auto *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.clear();
  best_state.resize(blob_count, 1);
  done = true;
}

◆ FakeWordFromRatings()

void tesseract::WERD_RES::FakeWordFromRatings ( PermuterType permuter )

Definition at line 930 of file pageres.cpp.

                                                        {
  int num_blobs = ratings->dimension();
  auto *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;
    // Initialize rating and certainty like in WERD_CHOICE::make_bad().
    float rating = WERD_CHOICE::kBadRating;
    float certainty = -FLT_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 tesseract::WERD_RES::FilterWordChoices ( int debug_level )

Definition at line 518 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.
    unsigned 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.
    auto 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 %u j %u 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 tesseract::WERD_RES::fix_hyphens ( )

Definition at line 1077 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.
  }
 
  using namespace std::placeholders; // for _1, _2
  ConditionalBlobMerge(std::bind(&WERD_RES::BothHyphens, this, _1, _2),
                       std::bind(&WERD_RES::HyphenBoxesOverlap, this, _1, _2));
}

◆ fix_quotes()

void tesseract::WERD_RES::fix_quotes ( )

Definition at line 1047 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.
  }
 
  using namespace std::placeholders; // for _1, _2
  ConditionalBlobMerge(std::bind(&WERD_RES::BothQuotes, this, _1, _2), nullptr);
}

◆ GetBlobChoice()

BLOB_CHOICE * tesseract::WERD_RES::GetBlobChoice ( unsigned index ) const

Definition at line 768 of file pageres.cpp.

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

◆ GetBlobChoices()

BLOB_CHOICE_LIST * tesseract::WERD_RES::GetBlobChoices ( int index ) const

Definition at line 779 of file pageres.cpp.

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

◆ GetBlobsGap()

int tesseract::WERD_RES::GetBlobsGap ( unsigned blob_index ) const

Definition at line 757 of file pageres.cpp.

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

◆ GetBlobsWidth()

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

Definition at line 746 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 tesseract::WERD_RES::HyphenBoxesOverlap	(	const TBOX &	box1,
		const TBOX &	box2
	)

Definition at line 1071 of file pageres.cpp.

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

◆ InitForRetryRecognition()

void tesseract::WERD_RES::InitForRetryRecognition ( const WERD_RES & source )

Definition at line 279 of file pageres.cpp.

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

◆ InsertSeam()

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

Definition at line 419 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_array.begin() + blob_number, seam);
  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 tesseract::WERD_RES::IsAmbiguous ( )

Definition at line 455 of file pageres.cpp.

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

◆ LogNewCookedChoice()

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

Definition at line 629 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) {
        std::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.c_str(), 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 std::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.c_str(), 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 tesseract::WERD_RES::LogNewRawChoice ( WERD_CHOICE * word_choice )

Definition at line 613 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 tesseract::WERD_RES::merge_tess_fails ( )

Definition at line 1099 of file pageres.cpp.

                                {
  using namespace std::placeholders; // for _1, _2
  if (ConditionalBlobMerge(std::bind(&WERD_RES::BothSpaces, this, _1, _2),
                           nullptr)) {
    unsigned len = best_choice->length();
    ASSERT_HOST(reject_map.length() == len);
    ASSERT_HOST(box_word->length() == len);
  }
}

◆ MergeAdjacentBlobs()

void tesseract::WERD_RES::MergeAdjacentBlobs ( unsigned index )

Definition at line 1005 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.size()) {
    best_state[index] += best_state[index + 1];
    best_state.erase(best_state.begin() + index + 1);
  }
}

◆ operator=()

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

Definition at line 186 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 tesseract::WERD_RES::PiecesAllNatural	(	int	start,
		int	count
	)		const

Definition at line 1111 of file pageres.cpp.

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

◆ PrintBestChoices()

void tesseract::WERD_RES::PrintBestChoices ( ) const

Definition at line 731 of file pageres.cpp.

                                      {
  std::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().c_str(), alternates_str.c_str());
}

◆ RawUTF8()

const char * tesseract::WERD_RES::RawUTF8 ( unsigned blob_index ) const

inline

Definition at line 376 of file pageres.h.

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

◆ RebuildBestState()

void tesseract::WERD_RES::RebuildBestState ( )

Definition at line 837 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.clear();
  int start = 0;
  for (unsigned 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 tesseract::WERD_RES::ReplaceBestChoice ( WERD_CHOICE * choice )

Definition at line 824 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.size());
  done = tess_accepted = tess_would_adapt = true;
  SetScriptPositions();
}

◆ SetAllScriptPositions()

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

Definition at line 895 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 tesseract::WERD_RES::SetScriptPositions ( )

Definition at line 888 of file pageres.cpp.

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

◆ SetupBasicsFromChoppedWord()

void tesseract::WERD_RES::SetupBasicsFromChoppedWord ( const UNICHARSET & unicharset_in )

Definition at line 344 of file pageres.cpp.

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

◆ SetupBlamerBundle()

void tesseract::WERD_RES::SetupBlamerBundle ( )

Definition at line 394 of file pageres.cpp.

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

◆ SetupBlobWidthsAndGaps()

void tesseract::WERD_RES::SetupBlobWidthsAndGaps ( )

Definition at line 401 of file pageres.cpp.

                                      {
  blob_widths.clear();
  blob_gaps.clear();
  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 tesseract::WERD_RES::SetupBoxWord ( )

Definition at line 879 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 tesseract::WERD_RES::SetupFake ( const UNICHARSET & uch )

Definition at line 353 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) {
    auto **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 {
    auto *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 tesseract::WERD_RES::SetupForRecognition	(	const UNICHARSET &	unicharset_in,
		tesseract::Tesseract *	tesseract,
		Image	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 304 of file pageres.cpp.

                                                       {
  auto 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 tesseract::WERD_RES::SetupWordScript ( const UNICHARSET & unicharset_in )

Definition at line 385 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 tesseract::WERD_RES::StatesAllValid ( )

Definition at line 461 of file pageres.cpp.

                              {
  unsigned ratings_dim = ratings->dimension();
  if (raw_choice->TotalOfStates() != ratings_dim) {
    tprintf("raw_choice has total of states = %u vs ratings dim of %u\n",
            raw_choice->TotalOfStates(), ratings_dim);
    return false;
  }
  WERD_CHOICE_IT it(&best_choices);
  unsigned 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 #%u has total of states = %u vs ratings dim of %u\n",
              index, choice->TotalOfStates(), ratings_dim);
      return false;
    }
  }
  return true;
}

◆ SymbolDirection()

UNICHARSET::Direction tesseract::WERD_RES::SymbolDirection ( unsigned blob_index ) const

inline

Definition at line 387 of file pageres.h.

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

◆ UnicharsInReadingOrder()

bool tesseract::WERD_RES::UnicharsInReadingOrder ( ) const

inline

Definition at line 435 of file pageres.h.

                                      {
    return best_choice->unichars_in_script_order();
  }

Member Data Documentation

◆ baseline_shift

float tesseract::WERD_RES::baseline_shift = 0.0f

Definition at line 316 of file pageres.h.

◆ best_choice

WERD_CHOICE* tesseract::WERD_RES::best_choice = nullptr

Definition at line 239 of file pageres.h.

◆ best_choices

WERD_CHOICE_LIST tesseract::WERD_RES::best_choices

Definition at line 247 of file pageres.h.

◆ best_state

std::vector<int> tesseract::WERD_RES::best_state

Definition at line 283 of file pageres.h.

◆ blamer_bundle

BlamerBundle* tesseract::WERD_RES::blamer_bundle = nullptr

Definition at line 250 of file pageres.h.

◆ bln_boxes

tesseract::BoxWord* tesseract::WERD_RES::bln_boxes = nullptr

Definition at line 193 of file pageres.h.

◆ blob_gaps

std::vector<int> tesseract::WERD_RES::blob_gaps

Definition at line 217 of file pageres.h.

◆ blob_row

ROW* tesseract::WERD_RES::blob_row = nullptr

Definition at line 195 of file pageres.h.

◆ blob_widths

std::vector<int> tesseract::WERD_RES::blob_widths

Definition at line 214 of file pageres.h.

◆ box_word

tesseract::BoxWord* tesseract::WERD_RES::box_word = nullptr

Definition at line 270 of file pageres.h.

◆ caps_height

float tesseract::WERD_RES::caps_height = 0.0f

Definition at line 315 of file pageres.h.

◆ chopped_word

TWERD* tesseract::WERD_RES::chopped_word = nullptr

Definition at line 210 of file pageres.h.

◆ combination

bool tesseract::WERD_RES::combination = false

Definition at line 337 of file pageres.h.

◆ correct_text

std::vector<std::string> tesseract::WERD_RES::correct_text

Definition at line 287 of file pageres.h.

◆ CTC_symbol_choices

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

Definition at line 224 of file pageres.h.

◆ denorm

DENORM tesseract::WERD_RES::denorm

Definition at line 199 of file pageres.h.

◆ done

bool tesseract::WERD_RES::done = false

Definition at line 303 of file pageres.h.

◆ end

int tesseract::WERD_RES::end = 0

Definition at line 228 of file pageres.h.

◆ ep_choice

WERD_CHOICE* tesseract::WERD_RES::ep_choice = nullptr

Definition at line 291 of file pageres.h.

◆ fontinfo

const FontInfo* tesseract::WERD_RES::fontinfo = nullptr

Definition at line 307 of file pageres.h.

◆ fontinfo2

const FontInfo* tesseract::WERD_RES::fontinfo2 = nullptr

Definition at line 308 of file pageres.h.

◆ fontinfo_id2_count

int8_t tesseract::WERD_RES::fontinfo_id2_count = 0

Definition at line 310 of file pageres.h.

◆ fontinfo_id_count

int8_t tesseract::WERD_RES::fontinfo_id_count = 0

Definition at line 309 of file pageres.h.

◆ guessed_caps_ht

bool tesseract::WERD_RES::guessed_caps_ht = true

Definition at line 312 of file pageres.h.

◆ guessed_x_ht

bool tesseract::WERD_RES::guessed_x_ht = true

Definition at line 311 of file pageres.h.

◆ leading_space

bool tesseract::WERD_RES::leading_space = false

Definition at line 226 of file pageres.h.

◆ odd_size

bool tesseract::WERD_RES::odd_size = false

Definition at line 305 of file pageres.h.

◆ part_of_combo

bool tesseract::WERD_RES::part_of_combo = false

Definition at line 338 of file pageres.h.

◆ ratings

MATRIX* tesseract::WERD_RES::ratings = nullptr

Definition at line 235 of file pageres.h.

◆ raw_choice

WERD_CHOICE* tesseract::WERD_RES::raw_choice = nullptr

Definition at line 244 of file pageres.h.

◆ rebuild_word

TWERD* tesseract::WERD_RES::rebuild_word = nullptr

Definition at line 264 of file pageres.h.

◆ reject_map

REJMAP tesseract::WERD_RES::reject_map

Definition at line 292 of file pageres.h.

◆ reject_spaces

bool tesseract::WERD_RES::reject_spaces = false

Definition at line 339 of file pageres.h.

◆ seam_array

std::vector<SEAM *> tesseract::WERD_RES::seam_array

Definition at line 212 of file pageres.h.

◆ segmented_timesteps

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

Definition at line 222 of file pageres.h.

◆ small_caps

bool tesseract::WERD_RES::small_caps = false

Definition at line 304 of file pageres.h.

◆ space_certainty

float tesseract::WERD_RES::space_certainty = 0.0f

Definition at line 319 of file pageres.h.

◆ tess_accepted

bool tesseract::WERD_RES::tess_accepted = false

Definition at line 301 of file pageres.h.

◆ tess_failed

bool tesseract::WERD_RES::tess_failed = false

Definition at line 293 of file pageres.h.

◆ tess_would_adapt

bool tesseract::WERD_RES::tess_would_adapt = false

Definition at line 302 of file pageres.h.

◆ tesseract

tesseract::Tesseract* tesseract::WERD_RES::tesseract = nullptr

Definition at line 278 of file pageres.h.

◆ timesteps

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

Definition at line 219 of file pageres.h.

◆ uch_set

const UNICHARSET* tesseract::WERD_RES::uch_set = nullptr

Definition at line 201 of file pageres.h.

◆ unlv_crunch_mode

CRUNCH_MODE tesseract::WERD_RES::unlv_crunch_mode = CR_NONE

Definition at line 313 of file pageres.h.

◆ word

WERD* tesseract::WERD_RES::word = nullptr

Definition at line 184 of file pageres.h.

◆ x_height

float tesseract::WERD_RES::x_height = 0.0f

Definition at line 314 of file pageres.h.

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

/media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/pageres.h
/media/home/debian/src/github/tesseract-ocr/tesseract/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()

◆ 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

◆ box_word

◆ caps_height

◆ chopped_word

◆ combination