tesseract v5.3.3.20231005
Public Member Functions | List of all members
tesseract::UnicharAmbigs Class Reference

#include <ambigs.h>

Public Member Functions

 UnicharAmbigs ()=default
 
 ~UnicharAmbigs ()
 
const UnicharAmbigsVector & dang_ambigs () const
 
const UnicharAmbigsVector & replace_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 UnicharIdVector * OneToOneDefiniteAmbigs (UNICHAR_ID unichar_id) const
 
const UnicharIdVector * AmbigsForAdaption (UNICHAR_ID unichar_id) const
 
const UnicharIdVector * ReverseAmbigsForAdaption (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 if (j < adaption_ambigs_entry->size()) {
147 if ((*adaption_ambigs_entry)[j] != id_to_insert) {
148 adaption_ambigs_entry->insert(adaption_ambigs_entry->begin() + j, id_to_insert);
149 }
150 } else {
151 adaption_ambigs_entry->push_back(id_to_insert);
152 }
153 }
154 }
155 }
156 }
157 }
158 delete[] buffer;
159
160 // Fill in reverse_ambigs_for_adaption from ambigs_for_adaption vector.
161 if (use_ambigs_for_adaption) {
162 for (size_t i = 0; i < ambigs_for_adaption_.size(); ++i) {
163 adaption_ambigs_entry = ambigs_for_adaption_[i];
164 if (adaption_ambigs_entry == nullptr) {
165 continue;
166 }
167 for (size_t j = 0; j < adaption_ambigs_entry->size(); ++j) {
168 UNICHAR_ID ambig_id = (*adaption_ambigs_entry)[j];
169 if (reverse_ambigs_for_adaption_[ambig_id] == nullptr) {
170 reverse_ambigs_for_adaption_[ambig_id] = new UnicharIdVector();
171 }
172 reverse_ambigs_for_adaption_[ambig_id]->push_back(i);
173 }
174 }
175 }
176
177 // Print what was read from the input file.
178 if (debug_level > 1) {
179 for (int tbl = 0; tbl < 2; ++tbl) {
180 const UnicharAmbigsVector &print_table = (tbl == 0) ? replace_ambigs_ : dang_ambigs_;
181 for (size_t i = 0; i < print_table.size(); ++i) {
182 AmbigSpec_LIST *lst = print_table[i];
183 if (lst == nullptr) {
184 continue;
185 }
186 if (!lst->empty()) {
187 tprintf("%s Ambiguities for %s:\n", (tbl == 0) ? "Replaceable" : "Dangerous",
188 unicharset->debug_str(i).c_str());
189 }
190 AmbigSpec_IT lst_it(lst);
191 for (lst_it.mark_cycle_pt(); !lst_it.cycled_list(); lst_it.forward()) {
192 AmbigSpec *ambig_spec = lst_it.data();
193 tprintf("wrong_ngram:");
194 UnicharIdArrayUtils::print(ambig_spec->wrong_ngram, *unicharset);
195 tprintf("correct_fragments:");
196 UnicharIdArrayUtils::print(ambig_spec->correct_fragments, *unicharset);
197 }
198 }
199 }
200 if (use_ambigs_for_adaption) {
201 for (int vec_id = 0; vec_id < 2; ++vec_id) {
202 const std::vector<UnicharIdVector *> &vec =
203 (vec_id == 0) ? ambigs_for_adaption_ : reverse_ambigs_for_adaption_;
204 for (size_t i = 0; i < vec.size(); ++i) {
205 adaption_ambigs_entry = vec[i];
206 if (adaption_ambigs_entry != nullptr) {
207 tprintf("%sAmbigs for adaption for %s:\n", (vec_id == 0) ? "" : "Reverse ",
208 unicharset->debug_str(i).c_str());
209 for (size_t j = 0; j < adaption_ambigs_entry->size(); ++j) {
210 tprintf("%s ", unicharset->debug_str((*adaption_ambigs_entry)[j]).c_str());
211 }
212 tprintf("\n");
213 }
214 }
215 }
216 }
217 }
218}
MAX_AMBIG_SIZE
#define MAX_AMBIG_SIZE
Definition: ambigs.h:34
ASSERT_HOST
#define ASSERT_HOST(x)
Definition: errcode.h:54
tesseract::UnicharAmbigsVector
std::vector< AmbigSpec_LIST * > UnicharAmbigsVector
Definition: ambigs.h:140
tesseract::tprintf
void tprintf(const char *format,...)
Definition: tprintf.cpp:41
tesseract::chomp_string
void chomp_string(char *str)
Definition: helpers.h:91
tesseract::UNICHAR_ID
int UNICHAR_ID
Definition: unichar.h:34
tesseract::DEFINITE_AMBIG
@ DEFINITE_AMBIG
Definition: ambigs.h:43
tesseract::REPLACE_AMBIG
@ REPLACE_AMBIG
Definition: ambigs.h:42
tesseract::NOT_AMBIG
@ NOT_AMBIG
Definition: ambigs.h:41
tesseract::kMaxAmbigStringSize
const int kMaxAmbigStringSize
Definition: ambigs.cpp:40
tesseract::UnicharIdVector
std::vector< UNICHAR_ID > UnicharIdVector
Definition: ambigs.h:38
upload.type
type
Definition: upload.py:458
tesseract::UnicharIdArrayUtils::print
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;
66 if (!file.Open(kUniversalAmbigsFile, ksizeofUniversalAmbigsFile)) {
67 return;
68 }
69 LoadUnicharAmbigs(encoder_set, &file, 0, false, unicharset);
70}
tesseract::kUniversalAmbigsFile
const char kUniversalAmbigsFile[]
Definition: universalambigs.h:27
tesseract::ksizeofUniversalAmbigsFile
const int ksizeofUniversalAmbigsFile
Definition: universalambigs.h:19040
tesseract::UnicharAmbigs::LoadUnicharAmbigs
void LoadUnicharAmbigs(const UNICHARSET &encoder_set, TFile *ambigs_file, int debug_level, bool use_ambigs_for_adaption, UNICHARSET *unicharset)
Definition: ambigs.cpp:72
tesseract::File::Open
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: