tesseract  5.0.0
tesseract::UnicharAmbigs Class Reference

#include <ambigs.h>

Public Member Functions

 UnicharAmbigs ()=default
 
 ~UnicharAmbigs ()
 
const UnicharAmbigsVectordang_ambigs () const
 
const UnicharAmbigsVectorreplace_ambigs () const
 
void InitUnicharAmbigs (const UNICHARSET &unicharset, bool use_ambigs_for_adaption)
 
void LoadUniversal (const UNICHARSET &encoder_set, UNICHARSET *unicharset)
 
void LoadUnicharAmbigs (const UNICHARSET &encoder_set, TFile *ambigs_file, int debug_level, bool use_ambigs_for_adaption, UNICHARSET *unicharset)
 
const UnicharIdVectorOneToOneDefiniteAmbigs (UNICHAR_ID unichar_id) const
 
const UnicharIdVectorAmbigsForAdaption (UNICHAR_ID unichar_id) const
 
const UnicharIdVectorReverseAmbigsForAdaption (UNICHAR_ID unichar_id) const
 

Detailed Description

Definition at line 142 of file ambigs.h.

Constructor & Destructor Documentation

◆ UnicharAmbigs()

tesseract::UnicharAmbigs::UnicharAmbigs ( )
default

◆ ~UnicharAmbigs()

tesseract::UnicharAmbigs::~UnicharAmbigs ( )
inline

Definition at line 145 of file ambigs.h.

145  {
146  for (auto data : replace_ambigs_) {
147  delete data;
148  }
149  for (auto data : dang_ambigs_) {
150  delete data;
151  }
152  for (auto data : one_to_one_definite_ambigs_) {
153  delete data;
154  }
155  }

Member Function Documentation

◆ AmbigsForAdaption()

const UnicharIdVector* tesseract::UnicharAmbigs::AmbigsForAdaption ( UNICHAR_ID  unichar_id) const
inline

Definition at line 198 of file ambigs.h.

198  {
199  if (ambigs_for_adaption_.empty()) {
200  return nullptr;
201  }
202  return ambigs_for_adaption_[unichar_id];
203  }

◆ dang_ambigs()

const UnicharAmbigsVector& tesseract::UnicharAmbigs::dang_ambigs ( ) const
inline

Definition at line 157 of file ambigs.h.

157  {
158  return dang_ambigs_;
159  }

◆ InitUnicharAmbigs()

void tesseract::UnicharAmbigs::InitUnicharAmbigs ( const UNICHARSET unicharset,
bool  use_ambigs_for_adaption 
)

Definition at line 51 of file ambigs.cpp.

51  {
52  for (unsigned i = 0; i < unicharset.size(); ++i) {
53  replace_ambigs_.push_back(nullptr);
54  dang_ambigs_.push_back(nullptr);
55  one_to_one_definite_ambigs_.push_back(nullptr);
56  if (use_ambigs_for_adaption) {
57  ambigs_for_adaption_.push_back(nullptr);
58  reverse_ambigs_for_adaption_.push_back(nullptr);
59  }
60  }
61 }

◆ LoadUnicharAmbigs()

void tesseract::UnicharAmbigs::LoadUnicharAmbigs ( const UNICHARSET encoder_set,
TFile ambigs_file,
int  debug_level,
bool  use_ambigs_for_adaption,
UNICHARSET unicharset 
)

Definition at line 72 of file ambigs.cpp.

74  {
75  UnicharIdVector *adaption_ambigs_entry;
76  if (debug_level) {
77  tprintf("Reading ambiguities\n");
78  }
79 
80  int test_ambig_part_size;
81  int replacement_ambig_part_size;
82  // The space for buffer is allocated on the heap to avoid
83  // GCC frame size warning.
84  const int kBufferSize = 10 + 2 * kMaxAmbigStringSize;
85  char *buffer = new char[kBufferSize];
86  char replacement_string[kMaxAmbigStringSize];
87  UNICHAR_ID test_unichar_ids[MAX_AMBIG_SIZE + 1];
88  int line_num = 0;
89  int type = NOT_AMBIG;
90 
91  // Determine the version of the ambigs file.
92  int version = 0;
93  ASSERT_HOST(ambig_file->FGets(buffer, kBufferSize) != nullptr && buffer[0] != '\0');
94  if (*buffer == 'v') {
95  version = static_cast<int>(strtol(buffer + 1, nullptr, 10));
96  ++line_num;
97  } else {
98  ambig_file->Rewind();
99  }
100  while (ambig_file->FGets(buffer, kBufferSize) != nullptr) {
101  chomp_string(buffer);
102  if (debug_level > 2) {
103  tprintf("read line %s\n", buffer);
104  }
105  ++line_num;
106  if (!ParseAmbiguityLine(line_num, version, debug_level, encoder_set, buffer,
107  &test_ambig_part_size, test_unichar_ids, &replacement_ambig_part_size,
108  replacement_string, &type)) {
109  continue;
110  }
111  // Construct AmbigSpec and add it to the appropriate AmbigSpec_LIST.
112  auto *ambig_spec = new AmbigSpec();
113  if (!InsertIntoTable((type == REPLACE_AMBIG) ? replace_ambigs_ : dang_ambigs_,
114  test_ambig_part_size, test_unichar_ids, replacement_ambig_part_size,
115  replacement_string, type, ambig_spec, unicharset)) {
116  continue;
117  }
118 
119  // Update one_to_one_definite_ambigs_.
120  if (test_ambig_part_size == 1 && replacement_ambig_part_size == 1 && type == DEFINITE_AMBIG) {
121  if (one_to_one_definite_ambigs_[test_unichar_ids[0]] == nullptr) {
122  one_to_one_definite_ambigs_[test_unichar_ids[0]] = new UnicharIdVector();
123  }
124  one_to_one_definite_ambigs_[test_unichar_ids[0]]->push_back(ambig_spec->correct_ngram_id);
125  }
126  // Update ambigs_for_adaption_.
127  if (use_ambigs_for_adaption) {
128  std::vector<UNICHAR_ID> encoding;
129  // Silently ignore invalid strings, as before, so it is safe to use a
130  // universal ambigs file.
131  if (unicharset->encode_string(replacement_string, true, &encoding, nullptr, nullptr)) {
132  for (int i = 0; i < test_ambig_part_size; ++i) {
133  if (ambigs_for_adaption_[test_unichar_ids[i]] == nullptr) {
134  ambigs_for_adaption_[test_unichar_ids[i]] = new UnicharIdVector();
135  }
136  adaption_ambigs_entry = ambigs_for_adaption_[test_unichar_ids[i]];
137  for (int id_to_insert : encoding) {
138  ASSERT_HOST(id_to_insert != INVALID_UNICHAR_ID);
139  // Add the new unichar id to adaption_ambigs_entry (only if the
140  // vector does not already contain it) keeping it in sorted order.
141  size_t j;
142  for (j = 0;
143  j < adaption_ambigs_entry->size() && (*adaption_ambigs_entry)[j] > id_to_insert;
144  ++j) {
145  ;
146  }
147  if (j < adaption_ambigs_entry->size()) {
148  if ((*adaption_ambigs_entry)[j] != id_to_insert) {
149  adaption_ambigs_entry->insert(adaption_ambigs_entry->begin() + j, id_to_insert);
150  }
151  } else {
152  adaption_ambigs_entry->push_back(id_to_insert);
153  }
154  }
155  }
156  }
157  }
158  }
159  delete[] buffer;
160 
161  // Fill in reverse_ambigs_for_adaption from ambigs_for_adaption vector.
162  if (use_ambigs_for_adaption) {
163  for (size_t i = 0; i < ambigs_for_adaption_.size(); ++i) {
164  adaption_ambigs_entry = ambigs_for_adaption_[i];
165  if (adaption_ambigs_entry == nullptr) {
166  continue;
167  }
168  for (size_t j = 0; j < adaption_ambigs_entry->size(); ++j) {
169  UNICHAR_ID ambig_id = (*adaption_ambigs_entry)[j];
170  if (reverse_ambigs_for_adaption_[ambig_id] == nullptr) {
171  reverse_ambigs_for_adaption_[ambig_id] = new UnicharIdVector();
172  }
173  reverse_ambigs_for_adaption_[ambig_id]->push_back(i);
174  }
175  }
176  }
177 
178  // Print what was read from the input file.
179  if (debug_level > 1) {
180  for (int tbl = 0; tbl < 2; ++tbl) {
181  const UnicharAmbigsVector &print_table = (tbl == 0) ? replace_ambigs_ : dang_ambigs_;
182  for (size_t i = 0; i < print_table.size(); ++i) {
183  AmbigSpec_LIST *lst = print_table[i];
184  if (lst == nullptr) {
185  continue;
186  }
187  if (!lst->empty()) {
188  tprintf("%s Ambiguities for %s:\n", (tbl == 0) ? "Replaceable" : "Dangerous",
189  unicharset->debug_str(i).c_str());
190  }
191  AmbigSpec_IT lst_it(lst);
192  for (lst_it.mark_cycle_pt(); !lst_it.cycled_list(); lst_it.forward()) {
193  AmbigSpec *ambig_spec = lst_it.data();
194  tprintf("wrong_ngram:");
195  UnicharIdArrayUtils::print(ambig_spec->wrong_ngram, *unicharset);
196  tprintf("correct_fragments:");
197  UnicharIdArrayUtils::print(ambig_spec->correct_fragments, *unicharset);
198  }
199  }
200  }
201  if (use_ambigs_for_adaption) {
202  for (int vec_id = 0; vec_id < 2; ++vec_id) {
203  const std::vector<UnicharIdVector *> &vec =
204  (vec_id == 0) ? ambigs_for_adaption_ : reverse_ambigs_for_adaption_;
205  for (size_t i = 0; i < vec.size(); ++i) {
206  adaption_ambigs_entry = vec[i];
207  if (adaption_ambigs_entry != nullptr) {
208  tprintf("%sAmbigs for adaption for %s:\n", (vec_id == 0) ? "" : "Reverse ",
209  unicharset->debug_str(i).c_str());
210  for (size_t j = 0; j < adaption_ambigs_entry->size(); ++j) {
211  tprintf("%s ", unicharset->debug_str((*adaption_ambigs_entry)[j]).c_str());
212  }
213  tprintf("\n");
214  }
215  }
216  }
217  }
218  }
219 }
#define MAX_AMBIG_SIZE
Definition: ambigs.h:34
#define ASSERT_HOST(x)
Definition: errcode.h:59
std::vector< AmbigSpec_LIST * > UnicharAmbigsVector
Definition: ambigs.h:140
void tprintf(const char *format,...)
Definition: tprintf.cpp:41
void chomp_string(char *str)
Definition: helpers.h:89
int UNICHAR_ID
Definition: unichar.h:36
@ DEFINITE_AMBIG
Definition: ambigs.h:43
@ REPLACE_AMBIG
Definition: ambigs.h:42
@ NOT_AMBIG
Definition: ambigs.h:41
const int kMaxAmbigStringSize
Definition: ambigs.cpp:40
std::vector< UNICHAR_ID > UnicharIdVector
Definition: ambigs.h:38
static void print(const UNICHAR_ID array[], const UNICHARSET &unicharset)
Definition: ambigs.h:93

◆ LoadUniversal()

void tesseract::UnicharAmbigs::LoadUniversal ( const UNICHARSET encoder_set,
UNICHARSET unicharset 
)

Definition at line 64 of file ambigs.cpp.

64  {
65  TFile file;
67  return;
68  }
69  LoadUnicharAmbigs(encoder_set, &file, 0, false, unicharset);
70 }
const char kUniversalAmbigsFile[]
const int ksizeofUniversalAmbigsFile
void LoadUnicharAmbigs(const UNICHARSET &encoder_set, TFile *ambigs_file, int debug_level, bool use_ambigs_for_adaption, UNICHARSET *unicharset)
Definition: ambigs.cpp:72
static FILE * Open(const std::string &filename, const std::string &mode)
Definition: fileio.cpp:41

◆ OneToOneDefiniteAmbigs()

const UnicharIdVector* tesseract::UnicharAmbigs::OneToOneDefiniteAmbigs ( UNICHAR_ID  unichar_id) const
inline

Definition at line 186 of file ambigs.h.

186  {
187  if (one_to_one_definite_ambigs_.empty()) {
188  return nullptr;
189  }
190  return one_to_one_definite_ambigs_[unichar_id];
191  }

◆ replace_ambigs()

const UnicharAmbigsVector& tesseract::UnicharAmbigs::replace_ambigs ( ) const
inline

Definition at line 160 of file ambigs.h.

160  {
161  return replace_ambigs_;
162  }

◆ ReverseAmbigsForAdaption()

const UnicharIdVector* tesseract::UnicharAmbigs::ReverseAmbigsForAdaption ( UNICHAR_ID  unichar_id) const
inline

Definition at line 208 of file ambigs.h.

208  {
209  if (reverse_ambigs_for_adaption_.empty()) {
210  return nullptr;
211  }
212  return reverse_ambigs_for_adaption_[unichar_id];
213  }

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