Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/tesseract/src/api/capi.cpp @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 ///////////////////////////////////////////////////////////////////////
2 // File: capi.cpp
3 // Description: C-API TessBaseAPI
4 //
5 // (C) Copyright 2012, Google Inc.
6 // Licensed under the Apache License, Version 2.0 (the "License");
7 // you may not use this file except in compliance with the License.
8 // You may obtain a copy of the License at
9 // http://www.apache.org/licenses/LICENSE-2.0
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 ///////////////////////////////////////////////////////////////////////
17
18 #include <tesseract/capi.h>
19
20 const char *TessVersion() {
21 return TessBaseAPI::Version();
22 }
23
24 static char *MakeText(const std::string& srcText) {
25 auto *text = new char[srcText.size() + 1];
26 srcText.copy(text, srcText.size());
27 text[srcText.size()] = 0;
28 return text;
29 }
30
31 void TessDeleteText(const char *text) {
32 delete[] text;
33 }
34
35 static char **MakeTextArray(const std::vector<std::string>& srcArr) {
36 auto **arr = new char *[srcArr.size() + 1];
37 for (size_t i = 0; i < srcArr.size(); ++i) {
38 arr[i] = MakeText(srcArr[i]);
39 }
40 arr[srcArr.size()] = nullptr;
41 return arr;
42 }
43
44 void TessDeleteTextArray(char **arr) {
45 for (char **pos = arr; *pos != nullptr; ++pos) {
46 delete[] * pos;
47 }
48 delete[] arr;
49 }
50
51 void TessDeleteIntArray(const int *arr) {
52 delete[] arr;
53 }
54
55 TessResultRenderer *TessTextRendererCreate(const char *outputbase) {
56 return new tesseract::TessTextRenderer(outputbase);
57 }
58
59 TessResultRenderer *TessHOcrRendererCreate(const char *outputbase) {
60 return new tesseract::TessHOcrRenderer(outputbase);
61 }
62
63 TessResultRenderer *TessHOcrRendererCreate2(const char *outputbase, BOOL font_info) {
64 return new tesseract::TessHOcrRenderer(outputbase, font_info != 0);
65 }
66
67 TessResultRenderer *TessAltoRendererCreate(const char *outputbase) {
68 return new tesseract::TessAltoRenderer(outputbase);
69 }
70
71 TessResultRenderer *TessPAGERendererCreate(const char *outputbase) {
72 return new tesseract::TessPAGERenderer(outputbase);
73 }
74
75 TessResultRenderer *TessTsvRendererCreate(const char *outputbase) {
76 return new tesseract::TessTsvRenderer(outputbase);
77 }
78
79 TessResultRenderer *TessPDFRendererCreate(const char *outputbase, const char *datadir,
80 BOOL textonly) {
81 return new tesseract::TessPDFRenderer(outputbase, datadir, textonly != 0);
82 }
83
84 TessResultRenderer *TessUnlvRendererCreate(const char *outputbase) {
85 return new tesseract::TessUnlvRenderer(outputbase);
86 }
87
88 TessResultRenderer *TessBoxTextRendererCreate(const char *outputbase) {
89 return new tesseract::TessBoxTextRenderer(outputbase);
90 }
91
92 TessResultRenderer *TessWordStrBoxRendererCreate(const char *outputbase) {
93 return new tesseract::TessWordStrBoxRenderer(outputbase);
94 }
95
96 TessResultRenderer *TessLSTMBoxRendererCreate(const char *outputbase) {
97 return new tesseract::TessLSTMBoxRenderer(outputbase);
98 }
99
100 void TessDeleteResultRenderer(TessResultRenderer *renderer) {
101 delete renderer;
102 }
103
104 void TessResultRendererInsert(TessResultRenderer *renderer, TessResultRenderer *next) {
105 renderer->insert(next);
106 }
107
108 TessResultRenderer *TessResultRendererNext(TessResultRenderer *renderer) {
109 return renderer->next();
110 }
111
112 BOOL TessResultRendererBeginDocument(TessResultRenderer *renderer, const char *title) {
113 return static_cast<int>(renderer->BeginDocument(title));
114 }
115
116 BOOL TessResultRendererAddImage(TessResultRenderer *renderer, TessBaseAPI *api) {
117 return static_cast<int>(renderer->AddImage(api));
118 }
119
120 BOOL TessResultRendererEndDocument(TessResultRenderer *renderer) {
121 return static_cast<int>(renderer->EndDocument());
122 }
123
124 const char *TessResultRendererExtention(TessResultRenderer *renderer) {
125 return renderer->file_extension();
126 }
127
128 const char *TessResultRendererTitle(TessResultRenderer *renderer) {
129 return renderer->title();
130 }
131
132 int TessResultRendererImageNum(TessResultRenderer *renderer) {
133 return renderer->imagenum();
134 }
135
136 TessBaseAPI *TessBaseAPICreate() {
137 return new TessBaseAPI;
138 }
139
140 void TessBaseAPIDelete(TessBaseAPI *handle) {
141 delete handle;
142 }
143
144 void TessBaseAPISetInputName(TessBaseAPI *handle, const char *name) {
145 handle->SetInputName(name);
146 }
147
148 const char *TessBaseAPIGetInputName(TessBaseAPI *handle) {
149 return handle->GetInputName();
150 }
151
152 void TessBaseAPISetInputImage(TessBaseAPI *handle, Pix *pix) {
153 handle->SetInputImage(pix);
154 }
155
156 Pix *TessBaseAPIGetInputImage(TessBaseAPI *handle) {
157 return handle->GetInputImage();
158 }
159
160 int TessBaseAPIGetSourceYResolution(TessBaseAPI *handle) {
161 return handle->GetSourceYResolution();
162 }
163
164 const char *TessBaseAPIGetDatapath(TessBaseAPI *handle) {
165 return handle->GetDatapath();
166 }
167
168 void TessBaseAPISetOutputName(TessBaseAPI *handle, const char *name) {
169 handle->SetOutputName(name);
170 }
171
172 BOOL TessBaseAPISetVariable(TessBaseAPI *handle, const char *name, const char *value) {
173 return static_cast<int>(handle->SetVariable(name, value));
174 }
175
176 BOOL TessBaseAPISetDebugVariable(TessBaseAPI *handle, const char *name, const char *value) {
177 return static_cast<int>(handle->SetDebugVariable(name, value));
178 }
179
180 BOOL TessBaseAPIGetIntVariable(const TessBaseAPI *handle, const char *name, int *value) {
181 return static_cast<int>(handle->GetIntVariable(name, value));
182 }
183
184 BOOL TessBaseAPIGetBoolVariable(const TessBaseAPI *handle, const char *name, BOOL *value) {
185 bool boolValue;
186 bool result = handle->GetBoolVariable(name, &boolValue);
187 if (result) {
188 *value = static_cast<int>(boolValue);
189 }
190 return static_cast<int>(result);
191 }
192
193 BOOL TessBaseAPIGetDoubleVariable(const TessBaseAPI *handle, const char *name, double *value) {
194 return static_cast<int>(handle->GetDoubleVariable(name, value));
195 }
196
197 const char *TessBaseAPIGetStringVariable(const TessBaseAPI *handle, const char *name) {
198 return handle->GetStringVariable(name);
199 }
200
201 void TessBaseAPIPrintVariables(const TessBaseAPI *handle, FILE *fp) {
202 handle->PrintVariables(fp);
203 }
204
205 BOOL TessBaseAPIPrintVariablesToFile(const TessBaseAPI *handle, const char *filename) {
206 FILE *fp = fopen(filename, "w");
207 if (fp != nullptr) {
208 handle->PrintVariables(fp);
209 fclose(fp);
210 return TRUE;
211 }
212 return FALSE;
213 }
214
215 int TessBaseAPIInit4(TessBaseAPI *handle, const char *datapath, const char *language,
216 TessOcrEngineMode mode, char **configs, int configs_size, char **vars_vec,
217 char **vars_values, size_t vars_vec_size, BOOL set_only_non_debug_params) {
218 std::vector<std::string> varNames;
219 std::vector<std::string> varValues;
220 if (vars_vec != nullptr && vars_values != nullptr) {
221 for (size_t i = 0; i < vars_vec_size; i++) {
222 varNames.emplace_back(vars_vec[i]);
223 varValues.emplace_back(vars_values[i]);
224 }
225 }
226
227 return handle->Init(datapath, language, mode, configs, configs_size, &varNames, &varValues,
228 set_only_non_debug_params != 0);
229 }
230
231 int TessBaseAPIInit1(TessBaseAPI *handle, const char *datapath, const char *language,
232 TessOcrEngineMode oem, char **configs, int configs_size) {
233 return handle->Init(datapath, language, oem, configs, configs_size, nullptr, nullptr, false);
234 }
235
236 int TessBaseAPIInit2(TessBaseAPI *handle, const char *datapath, const char *language,
237 TessOcrEngineMode oem) {
238 return handle->Init(datapath, language, oem);
239 }
240
241 int TessBaseAPIInit3(TessBaseAPI *handle, const char *datapath, const char *language) {
242 return handle->Init(datapath, language);
243 }
244
245 int TessBaseAPIInit5(TessBaseAPI *handle, const char *data, int data_size, const char *language,
246 TessOcrEngineMode mode, char **configs, int configs_size, char **vars_vec,
247 char **vars_values, size_t vars_vec_size, BOOL set_only_non_debug_params) {
248 std::vector<std::string> varNames;
249 std::vector<std::string> varValues;
250 if (vars_vec != nullptr && vars_values != nullptr) {
251 for (size_t i = 0; i < vars_vec_size; i++) {
252 varNames.emplace_back(vars_vec[i]);
253 varValues.emplace_back(vars_values[i]);
254 }
255 }
256
257 return handle->Init(data, data_size, language, mode, configs, configs_size, &varNames, &varValues,
258 set_only_non_debug_params != 0, nullptr);
259 }
260
261 const char *TessBaseAPIGetInitLanguagesAsString(const TessBaseAPI *handle) {
262 return handle->GetInitLanguagesAsString();
263 }
264
265 char **TessBaseAPIGetLoadedLanguagesAsVector(const TessBaseAPI *handle) {
266 std::vector<std::string> languages;
267 handle->GetLoadedLanguagesAsVector(&languages);
268 return MakeTextArray(languages);
269 }
270
271 char **TessBaseAPIGetAvailableLanguagesAsVector(const TessBaseAPI *handle) {
272 std::vector<std::string> languages;
273 handle->GetAvailableLanguagesAsVector(&languages);
274 return MakeTextArray(languages);
275 }
276
277 void TessBaseAPIInitForAnalysePage(TessBaseAPI *handle) {
278 handle->InitForAnalysePage();
279 }
280
281 void TessBaseAPIReadConfigFile(TessBaseAPI *handle, const char *filename) {
282 handle->ReadConfigFile(filename);
283 }
284
285 void TessBaseAPIReadDebugConfigFile(TessBaseAPI *handle, const char *filename) {
286 handle->ReadDebugConfigFile(filename);
287 }
288
289 void TessBaseAPISetPageSegMode(TessBaseAPI *handle, TessPageSegMode mode) {
290 handle->SetPageSegMode(mode);
291 }
292
293 TessPageSegMode TessBaseAPIGetPageSegMode(const TessBaseAPI *handle) {
294 return handle->GetPageSegMode();
295 }
296
297 char *TessBaseAPIRect(TessBaseAPI *handle, const unsigned char *imagedata, int bytes_per_pixel,
298 int bytes_per_line, int left, int top, int width, int height) {
299 return handle->TesseractRect(imagedata, bytes_per_pixel, bytes_per_line, left, top, width,
300 height);
301 }
302
303 #ifndef DISABLED_LEGACY_ENGINE
304 void TessBaseAPIClearAdaptiveClassifier(TessBaseAPI *handle) {
305 handle->ClearAdaptiveClassifier();
306 }
307 #endif
308
309 void TessBaseAPISetImage(TessBaseAPI *handle, const unsigned char *imagedata, int width, int height,
310 int bytes_per_pixel, int bytes_per_line) {
311 handle->SetImage(imagedata, width, height, bytes_per_pixel, bytes_per_line);
312 }
313
314 void TessBaseAPISetImage2(TessBaseAPI *handle, struct Pix *pix) {
315 return handle->SetImage(pix);
316 }
317
318 void TessBaseAPISetSourceResolution(TessBaseAPI *handle, int ppi) {
319 handle->SetSourceResolution(ppi);
320 }
321
322 void TessBaseAPISetRectangle(TessBaseAPI *handle, int left, int top, int width, int height) {
323 handle->SetRectangle(left, top, width, height);
324 }
325
326 struct Pix *TessBaseAPIGetThresholdedImage(TessBaseAPI *handle) {
327 return handle->GetThresholdedImage();
328 }
329
330 float TessBaseAPIGetGradient(TessBaseAPI *handle) {
331 return handle->GetGradient();
332 }
333
334 void TessBaseAPIClearPersistentCache(TessBaseAPI * /*handle*/) {
335 TessBaseAPI::ClearPersistentCache();
336 }
337
338 #ifndef DISABLED_LEGACY_ENGINE
339
340 BOOL TessBaseAPIDetectOrientationScript(TessBaseAPI *handle, int *orient_deg, float *orient_conf,
341 const char **script_name, float *script_conf) {
342 auto success = handle->DetectOrientationScript(orient_deg, orient_conf, script_name, script_conf);
343 return static_cast<BOOL>(success);
344 }
345
346 #endif
347
348 struct Boxa *TessBaseAPIGetRegions(TessBaseAPI *handle, struct Pixa **pixa) {
349 return handle->GetRegions(pixa);
350 }
351
352 struct Boxa *TessBaseAPIGetTextlines(TessBaseAPI *handle, struct Pixa **pixa, int **blockids) {
353 return handle->GetTextlines(pixa, blockids);
354 }
355
356 struct Boxa *TessBaseAPIGetTextlines1(TessBaseAPI *handle, const BOOL raw_image,
357 const int raw_padding, struct Pixa **pixa, int **blockids,
358 int **paraids) {
359 return handle->GetTextlines(raw_image != 0, raw_padding, pixa, blockids, paraids);
360 }
361
362 struct Boxa *TessBaseAPIGetStrips(TessBaseAPI *handle, struct Pixa **pixa, int **blockids) {
363 return handle->GetStrips(pixa, blockids);
364 }
365
366 struct Boxa *TessBaseAPIGetWords(TessBaseAPI *handle, struct Pixa **pixa) {
367 return handle->GetWords(pixa);
368 }
369
370 struct Boxa *TessBaseAPIGetConnectedComponents(TessBaseAPI *handle, struct Pixa **cc) {
371 return handle->GetConnectedComponents(cc);
372 }
373
374 struct Boxa *TessBaseAPIGetComponentImages(TessBaseAPI *handle, TessPageIteratorLevel level,
375 BOOL text_only, struct Pixa **pixa, int **blockids) {
376 return handle->GetComponentImages(level, static_cast<bool>(text_only), pixa, blockids);
377 }
378
379 struct Boxa *TessBaseAPIGetComponentImages1(TessBaseAPI *handle, const TessPageIteratorLevel level,
380 const BOOL text_only, const BOOL raw_image,
381 const int raw_padding, struct Pixa **pixa,
382 int **blockids, int **paraids) {
383 return handle->GetComponentImages(level, static_cast<bool>(text_only), raw_image != 0,
384 raw_padding, pixa, blockids, paraids);
385 }
386
387 int TessBaseAPIGetThresholdedImageScaleFactor(const TessBaseAPI *handle) {
388 return handle->GetThresholdedImageScaleFactor();
389 }
390
391 TessPageIterator *TessBaseAPIAnalyseLayout(TessBaseAPI *handle) {
392 return handle->AnalyseLayout();
393 }
394
395 int TessBaseAPIRecognize(TessBaseAPI *handle, ETEXT_DESC *monitor) {
396 return handle->Recognize(monitor);
397 }
398
399 BOOL TessBaseAPIProcessPages(TessBaseAPI *handle, const char *filename, const char *retry_config,
400 int timeout_millisec, TessResultRenderer *renderer) {
401 return static_cast<int>(handle->ProcessPages(filename, retry_config, timeout_millisec, renderer));
402 }
403
404 BOOL TessBaseAPIProcessPage(TessBaseAPI *handle, struct Pix *pix, int page_index,
405 const char *filename, const char *retry_config, int timeout_millisec,
406 TessResultRenderer *renderer) {
407 return static_cast<int>(
408 handle->ProcessPage(pix, page_index, filename, retry_config, timeout_millisec, renderer));
409 }
410
411 TessResultIterator *TessBaseAPIGetIterator(TessBaseAPI *handle) {
412 return handle->GetIterator();
413 }
414
415 TessMutableIterator *TessBaseAPIGetMutableIterator(TessBaseAPI *handle) {
416 return handle->GetMutableIterator();
417 }
418
419 char *TessBaseAPIGetUTF8Text(TessBaseAPI *handle) {
420 return handle->GetUTF8Text();
421 }
422
423 char *TessBaseAPIGetHOCRText(TessBaseAPI *handle, int page_number) {
424 return handle->GetHOCRText(nullptr, page_number);
425 }
426
427 char *TessBaseAPIGetAltoText(TessBaseAPI *handle, int page_number) {
428 return handle->GetAltoText(page_number);
429 }
430
431 char *TessBaseAPIGetPAGEText(TessBaseAPI *handle, int page_number) {
432 return handle->GetPAGEText(page_number);
433 }
434
435 char *TessBaseAPIGetTsvText(TessBaseAPI *handle, int page_number) {
436 return handle->GetTSVText(page_number);
437 }
438
439 char *TessBaseAPIGetBoxText(TessBaseAPI *handle, int page_number) {
440 return handle->GetBoxText(page_number);
441 }
442
443 char *TessBaseAPIGetWordStrBoxText(TessBaseAPI *handle, int page_number) {
444 return handle->GetWordStrBoxText(page_number);
445 }
446
447 char *TessBaseAPIGetLSTMBoxText(TessBaseAPI *handle, int page_number) {
448 return handle->GetLSTMBoxText(page_number);
449 }
450
451 char *TessBaseAPIGetUNLVText(TessBaseAPI *handle) {
452 return handle->GetUNLVText();
453 }
454
455 int TessBaseAPIMeanTextConf(TessBaseAPI *handle) {
456 return handle->MeanTextConf();
457 }
458
459 int *TessBaseAPIAllWordConfidences(TessBaseAPI *handle) {
460 return handle->AllWordConfidences();
461 }
462
463 #ifndef DISABLED_LEGACY_ENGINE
464 BOOL TessBaseAPIAdaptToWordStr(TessBaseAPI *handle, TessPageSegMode mode, const char *wordstr) {
465 return static_cast<int>(handle->AdaptToWordStr(mode, wordstr));
466 }
467 #endif
468
469 void TessBaseAPIClear(TessBaseAPI *handle) {
470 handle->Clear();
471 }
472
473 void TessBaseAPIEnd(TessBaseAPI *handle) {
474 handle->End();
475 }
476
477 int TessBaseAPIIsValidWord(TessBaseAPI *handle, const char *word) {
478 return handle->IsValidWord(word);
479 }
480
481 BOOL TessBaseAPIGetTextDirection(TessBaseAPI *handle, int *out_offset, float *out_slope) {
482 return static_cast<int>(handle->GetTextDirection(out_offset, out_slope));
483 }
484
485 const char *TessBaseAPIGetUnichar(TessBaseAPI *handle, int unichar_id) {
486 return handle->GetUnichar(unichar_id);
487 }
488
489 void TessBaseAPISetMinOrientationMargin(TessBaseAPI *handle, double margin) {
490 handle->set_min_orientation_margin(margin);
491 }
492
493 int TessBaseAPINumDawgs(const TessBaseAPI *handle) {
494 return handle->NumDawgs();
495 }
496
497 TessOcrEngineMode TessBaseAPIOem(const TessBaseAPI *handle) {
498 return handle->oem();
499 }
500
501 void TessBaseGetBlockTextOrientations(TessBaseAPI *handle, int **block_orientation,
502 bool **vertical_writing) {
503 handle->GetBlockTextOrientations(block_orientation, vertical_writing);
504 }
505
506 void TessPageIteratorDelete(TessPageIterator *handle) {
507 delete handle;
508 }
509
510 TessPageIterator *TessPageIteratorCopy(const TessPageIterator *handle) {
511 return new TessPageIterator(*handle);
512 }
513
514 void TessPageIteratorBegin(TessPageIterator *handle) {
515 handle->Begin();
516 }
517
518 BOOL TessPageIteratorNext(TessPageIterator *handle, TessPageIteratorLevel level) {
519 return static_cast<int>(handle->Next(level));
520 }
521
522 BOOL TessPageIteratorIsAtBeginningOf(const TessPageIterator *handle, TessPageIteratorLevel level) {
523 return static_cast<int>(handle->IsAtBeginningOf(level));
524 }
525
526 BOOL TessPageIteratorIsAtFinalElement(const TessPageIterator *handle, TessPageIteratorLevel level,
527 TessPageIteratorLevel element) {
528 return static_cast<int>(handle->IsAtFinalElement(level, element));
529 }
530
531 BOOL TessPageIteratorBoundingBox(const TessPageIterator *handle, TessPageIteratorLevel level,
532 int *left, int *top, int *right, int *bottom) {
533 return static_cast<int>(handle->BoundingBox(level, left, top, right, bottom));
534 }
535
536 TessPolyBlockType TessPageIteratorBlockType(const TessPageIterator *handle) {
537 return handle->BlockType();
538 }
539
540 struct Pix *TessPageIteratorGetBinaryImage(const TessPageIterator *handle,
541 TessPageIteratorLevel level) {
542 return handle->GetBinaryImage(level);
543 }
544
545 struct Pix *TessPageIteratorGetImage(const TessPageIterator *handle, TessPageIteratorLevel level,
546 int padding, struct Pix *original_image, int *left, int *top) {
547 return handle->GetImage(level, padding, original_image, left, top);
548 }
549
550 BOOL TessPageIteratorBaseline(const TessPageIterator *handle, TessPageIteratorLevel level, int *x1,
551 int *y1, int *x2, int *y2) {
552 return static_cast<int>(handle->Baseline(level, x1, y1, x2, y2));
553 }
554
555 void TessPageIteratorOrientation(TessPageIterator *handle, TessOrientation *orientation,
556 TessWritingDirection *writing_direction,
557 TessTextlineOrder *textline_order, float *deskew_angle) {
558 handle->Orientation(orientation, writing_direction, textline_order, deskew_angle);
559 }
560
561 void TessPageIteratorParagraphInfo(TessPageIterator *handle,
562 TessParagraphJustification *justification, BOOL *is_list_item,
563 BOOL *is_crown, int *first_line_indent) {
564 bool bool_is_list_item;
565 bool bool_is_crown;
566 handle->ParagraphInfo(justification, &bool_is_list_item, &bool_is_crown, first_line_indent);
567 if (is_list_item != nullptr) {
568 *is_list_item = static_cast<int>(bool_is_list_item);
569 }
570 if (is_crown != nullptr) {
571 *is_crown = static_cast<int>(bool_is_crown);
572 }
573 }
574
575 void TessResultIteratorDelete(TessResultIterator *handle) {
576 delete handle;
577 }
578
579 TessResultIterator *TessResultIteratorCopy(const TessResultIterator *handle) {
580 return new TessResultIterator(*handle);
581 }
582
583 TessPageIterator *TessResultIteratorGetPageIterator(TessResultIterator *handle) {
584 return handle;
585 }
586
587 const TessPageIterator *TessResultIteratorGetPageIteratorConst(const TessResultIterator *handle) {
588 return handle;
589 }
590
591 TessChoiceIterator *TessResultIteratorGetChoiceIterator(const TessResultIterator *handle) {
592 return new TessChoiceIterator(*handle);
593 }
594
595 BOOL TessResultIteratorNext(TessResultIterator *handle, TessPageIteratorLevel level) {
596 return static_cast<int>(handle->Next(level));
597 }
598
599 char *TessResultIteratorGetUTF8Text(const TessResultIterator *handle, TessPageIteratorLevel level) {
600 return handle->GetUTF8Text(level);
601 }
602
603 float TessResultIteratorConfidence(const TessResultIterator *handle, TessPageIteratorLevel level) {
604 return handle->Confidence(level);
605 }
606
607 const char *TessResultIteratorWordRecognitionLanguage(const TessResultIterator *handle) {
608 return handle->WordRecognitionLanguage();
609 }
610
611 const char *TessResultIteratorWordFontAttributes(const TessResultIterator *handle, BOOL *is_bold,
612 BOOL *is_italic, BOOL *is_underlined,
613 BOOL *is_monospace, BOOL *is_serif,
614 BOOL *is_smallcaps, int *pointsize, int *font_id) {
615 bool bool_is_bold;
616 bool bool_is_italic;
617 bool bool_is_underlined;
618 bool bool_is_monospace;
619 bool bool_is_serif;
620 bool bool_is_smallcaps;
621 const char *ret = handle->WordFontAttributes(&bool_is_bold, &bool_is_italic, &bool_is_underlined,
622 &bool_is_monospace, &bool_is_serif,
623 &bool_is_smallcaps, pointsize, font_id);
624 if (is_bold != nullptr) {
625 *is_bold = static_cast<int>(bool_is_bold);
626 }
627 if (is_italic != nullptr) {
628 *is_italic = static_cast<int>(bool_is_italic);
629 }
630 if (is_underlined != nullptr) {
631 *is_underlined = static_cast<int>(bool_is_underlined);
632 }
633 if (is_monospace != nullptr) {
634 *is_monospace = static_cast<int>(bool_is_monospace);
635 }
636 if (is_serif != nullptr) {
637 *is_serif = static_cast<int>(bool_is_serif);
638 }
639 if (is_smallcaps != nullptr) {
640 *is_smallcaps = static_cast<int>(bool_is_smallcaps);
641 }
642 return ret;
643 }
644
645 BOOL TessResultIteratorWordIsFromDictionary(const TessResultIterator *handle) {
646 return static_cast<int>(handle->WordIsFromDictionary());
647 }
648
649 BOOL TessResultIteratorWordIsNumeric(const TessResultIterator *handle) {
650 return static_cast<int>(handle->WordIsNumeric());
651 }
652
653 BOOL TessResultIteratorSymbolIsSuperscript(const TessResultIterator *handle) {
654 return static_cast<int>(handle->SymbolIsSuperscript());
655 }
656
657 BOOL TessResultIteratorSymbolIsSubscript(const TessResultIterator *handle) {
658 return static_cast<int>(handle->SymbolIsSubscript());
659 }
660
661 BOOL TessResultIteratorSymbolIsDropcap(const TessResultIterator *handle) {
662 return static_cast<int>(handle->SymbolIsDropcap());
663 }
664
665 void TessChoiceIteratorDelete(TessChoiceIterator *handle) {
666 delete handle;
667 }
668
669 BOOL TessChoiceIteratorNext(TessChoiceIterator *handle) {
670 return static_cast<int>(handle->Next());
671 }
672
673 const char *TessChoiceIteratorGetUTF8Text(const TessChoiceIterator *handle) {
674 return handle->GetUTF8Text();
675 }
676
677 float TessChoiceIteratorConfidence(const TessChoiceIterator *handle) {
678 return handle->Confidence();
679 }
680
681 ETEXT_DESC *TessMonitorCreate() {
682 return new ETEXT_DESC();
683 }
684
685 void TessMonitorDelete(ETEXT_DESC *monitor) {
686 delete monitor;
687 }
688
689 void TessMonitorSetCancelFunc(ETEXT_DESC *monitor, TessCancelFunc cancelFunc) {
690 monitor->cancel = cancelFunc;
691 }
692
693 void TessMonitorSetCancelThis(ETEXT_DESC *monitor, void *cancelThis) {
694 monitor->cancel_this = cancelThis;
695 }
696
697 void *TessMonitorGetCancelThis(ETEXT_DESC *monitor) {
698 return monitor->cancel_this;
699 }
700
701 void TessMonitorSetProgressFunc(ETEXT_DESC *monitor, TessProgressFunc progressFunc) {
702 monitor->progress_callback2 = progressFunc;
703 }
704
705 int TessMonitorGetProgress(ETEXT_DESC *monitor) {
706 return monitor->progress;
707 }
708
709 void TessMonitorSetDeadlineMSecs(ETEXT_DESC *monitor, int deadline) {
710 monitor->set_deadline_msecs(deadline);
711 }