|
Tesseract
3.02
|
|
Tesseract
3.02
|
The following methods break TesseractRect into pieces, so you can get hold of the thresholded image, get the text in different formats, get bounding boxes, confidences etc.
| bool tesseract::TessBaseAPI::AdaptToWordStr | ( | PageSegMode | mode, |
| const char * | wordstr | ||
| ) |
Applies the given word to the adaptive classifier if possible. The word must be SPACE-DELIMITED UTF-8 - l i k e t h i s , so it can tell the boundaries of the graphemes. Assumes that SetImage/SetRectangle have been used to set the image to the given word. The mode arg should be PSM_SINGLE_WORD or PSM_CIRCLE_WORD, as that will be used to control layout analysis. The currently set PageSegMode is preserved. Returns false if adaption was not possible for some reason.
Definition at line 1338 of file baseapi.cpp.
{
int debug = 0;
GetIntVariable("applybox_debug", &debug);
bool success = true;
PageSegMode current_psm = GetPageSegMode();
SetPageSegMode(mode);
SetVariable("classify_enable_learning", "0");
char* text = GetUTF8Text();
if (debug) {
tprintf("Trying to adapt \"%s\" to \"%s\"\n", text, wordstr);
}
if (text != NULL) {
PAGE_RES_IT it(page_res_);
WERD_RES* word_res = it.word();
if (word_res != NULL) {
word_res->word->set_text(wordstr);
} else {
success = false;
}
// Check to see if text matches wordstr.
int w = 0;
int t = 0;
for (t = 0; text[t] != '\0'; ++t) {
if (text[t] == '\n' || text[t] == ' ')
continue;
while (wordstr[w] != '\0' && wordstr[w] == ' ')
++w;
if (text[t] != wordstr[w])
break;
++w;
}
if (text[t] != '\0' || wordstr[w] != '\0') {
// No match.
delete page_res_;
GenericVector<TBOX> boxes;
page_res_ = tesseract_->SetupApplyBoxes(boxes, block_list_);
tesseract_->ReSegmentByClassification(page_res_);
tesseract_->TidyUp(page_res_);
PAGE_RES_IT pr_it(page_res_);
if (pr_it.word() == NULL)
success = false;
else
word_res = pr_it.word();
} else {
word_res->BestChoiceToCorrectText();
}
if (success) {
tesseract_->EnableLearning = true;
tesseract_->LearnWord(NULL, NULL, word_res);
}
delete [] text;
} else {
success = false;
}
SetPageSegMode(current_psm);
return success;
}
| int * tesseract::TessBaseAPI::AllWordConfidences | ( | ) |
Returns all word confidences (between 0 and 100) in an array, terminated by -1. The calling function must delete [] after use. The number of confidences should correspond to the number of space- delimited words in GetUTF8Text.
Returns an array of all word confidences, terminated by -1.
Definition at line 1304 of file baseapi.cpp.
{
if (tesseract_ == NULL ||
(!recognition_done_ && Recognize(NULL) < 0))
return NULL;
int n_word = 0;
PAGE_RES_IT res_it(page_res_);
for (res_it.restart_page(); res_it.word() != NULL; res_it.forward())
n_word++;
int* conf = new int[n_word+1];
n_word = 0;
for (res_it.restart_page(); res_it.word() != NULL; res_it.forward()) {
WERD_RES *word = res_it.word();
WERD_CHOICE* choice = word->best_choice;
int w_conf = static_cast<int>(100 + 5 * choice->certainty());
// This is the eq for converting Tesseract confidence to 1..100
if (w_conf < 0) w_conf = 0;
if (w_conf > 100) w_conf = 100;
conf[n_word++] = w_conf;
}
conf[n_word] = -1;
return conf;
}
| PageIterator * tesseract::TessBaseAPI::AnalyseLayout | ( | ) |
Runs page layout analysis in the mode set by SetPageSegMode. May optionally be called prior to Recognize to get access to just the page layout results. Returns an iterator to the results. Returns NULL on error. The returned iterator must be deleted after use. WARNING! This class points to data held within the TessBaseAPI class, and therefore can only be used while the TessBaseAPI class still exists and has not been subjected to a call of Init, SetImage, Recognize, Clear, End DetectOS, or anything else that changes the internal PAGE_RES.
Runs page layout analysis in the mode set by SetPageSegMode. May optionally be called prior to Recognize to get access to just the page layout results. Returns an iterator to the results. Returns NULL on error or an empty page. The returned iterator must be deleted after use. WARNING! This class points to data held within the TessBaseAPI class, and therefore can only be used while the TessBaseAPI class still exists and has not been subjected to a call of Init, SetImage, Recognize, Clear, End DetectOS, or anything else that changes the internal PAGE_RES.
Definition at line 630 of file baseapi.cpp.
{
if (FindLines() == 0) {
if (block_list_->empty())
return NULL; // The page was empty.
page_res_ = new PAGE_RES(block_list_, NULL);
return new PageIterator(page_res_, tesseract_,
thresholder_->GetScaleFactor(),
thresholder_->GetScaledYResolution(),
rect_left_, rect_top_, rect_width_, rect_height_);
}
return NULL;
}
| void tesseract::TessBaseAPI::Clear | ( | ) |
Free up recognition results and any stored image data, without actually freeing any recognition data that would be time-consuming to reload. Afterwards, you must call SetImage or TesseractRect before doing any Recognize or Get* operation.
Definition at line 1402 of file baseapi.cpp.
{
if (thresholder_ != NULL)
thresholder_->Clear();
ClearResults();
}
| void tesseract::TessBaseAPI::DeleteBlockList | ( | BLOCK_LIST * | block_list | ) | [static] |
Delete a block list. This is to keep BLOCK_LIST pointer opaque and let go of including the other headers.
Definition at line 1787 of file baseapi.cpp.
{
delete block_list;
}
| bool tesseract::TessBaseAPI::DetectOS | ( | OSResults * | osr | ) |
Estimates the Orientation And Script of the image.
Estimates the Orientation And Script of the image. Returns true if the image was processed successfully.
Definition at line 1698 of file baseapi.cpp.
{
if (tesseract_ == NULL)
return false;
ClearResults();
if (tesseract_->pix_binary() == NULL)
Threshold(tesseract_->mutable_pix_binary());
if (input_file_ == NULL)
input_file_ = new STRING(kInputFile);
return orientation_and_script_detection(*input_file_, osr, tesseract_);
}
| void tesseract::TessBaseAPI::DumpPGM | ( | const char * | filename | ) |
Dump the internal binary image to a PGM file.
Dump the internal binary image to a PGM file.
Definition at line 556 of file baseapi.cpp.
{
if (tesseract_ == NULL)
return;
FILE *fp = fopen(filename, "wb");
Pix* pix = tesseract_->pix_binary();
int width = pixGetWidth(pix);
int height = pixGetHeight(pix);
l_uint32* data = pixGetData(pix);
fprintf(fp, "P5 %d %d 255\n", width, height);
for (int y = 0; y < height; ++y, data += pixGetWpl(pix)) {
for (int x = 0; x < width; ++x) {
uinT8 b = GET_DATA_BIT(data, x) ? 0 : 255;
fwrite(&b, 1, 1, fp);
}
}
fclose(fp);
}
| void tesseract::TessBaseAPI::End | ( | ) |
Close down tesseract and free up all memory. End() is equivalent to destructing and reconstructing your TessBaseAPI. Once End() has been used, none of the other API functions may be used other than Init and anything declared above it in the class definition.
Definition at line 1414 of file baseapi.cpp.
{
if (thresholder_ != NULL) {
delete thresholder_;
thresholder_ = NULL;
}
if (page_res_ != NULL) {
delete page_res_;
page_res_ = NULL;
}
if (block_list_ != NULL) {
delete block_list_;
block_list_ = NULL;
}
if (paragraph_models_ != NULL) {
paragraph_models_->delete_data_pointers();
delete paragraph_models_;
paragraph_models_ = NULL;
}
if (tesseract_ != NULL) {
delete tesseract_;
if (osd_tesseract_ == tesseract_)
osd_tesseract_ = NULL;
tesseract_ = NULL;
}
if (osd_tesseract_ != NULL) {
delete osd_tesseract_;
osd_tesseract_ = NULL;
}
if (equ_detect_ != NULL) {
delete equ_detect_;
equ_detect_ = NULL;
}
if (input_file_ != NULL) {
delete input_file_;
input_file_ = NULL;
}
if (output_file_ != NULL) {
delete output_file_;
output_file_ = NULL;
}
if (datapath_ != NULL) {
delete datapath_;
datapath_ = NULL;
}
if (language_ != NULL) {
delete language_;
language_ = NULL;
}
}
| BLOCK_LIST * tesseract::TessBaseAPI::FindLinesCreateBlockList | ( | ) |
Find lines from the image making the BLOCK_LIST.
Definition at line 1775 of file baseapi.cpp.
{
FindLines();
BLOCK_LIST* result = block_list_;
block_list_ = NULL;
return result;
}
| ROW * tesseract::TessBaseAPI::FindRowForBox | ( | BLOCK_LIST * | blocks, |
| int | left, | ||
| int | top, | ||
| int | right, | ||
| int | bottom | ||
| ) | [static] |
This method returns the row to which a box of specified dimensions would belong. If no good match is found, it returns NULL.
Definition at line 2077 of file baseapi.cpp.
{
TBOX box(left, bottom, right, top);
BLOCK_IT b_it(blocks);
for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
BLOCK* block = b_it.data();
if (!box.major_overlap(block->bounding_box()))
continue;
ROW_IT r_it(block->row_list());
for (r_it.mark_cycle_pt(); !r_it.cycled_list(); r_it.forward()) {
ROW* row = r_it.data();
if (!box.major_overlap(row->bounding_box()))
continue;
WERD_IT w_it(row->word_list());
for (w_it.mark_cycle_pt(); !w_it.cycled_list(); w_it.forward()) {
WERD* word = w_it.data();
if (box.major_overlap(word->bounding_box()))
return row;
}
}
}
return NULL;
}
| void tesseract::TessBaseAPI::GetBlockTextOrientations | ( | int ** | block_orientation, |
| bool ** | vertical_writing | ||
| ) |
Return text orientation of each block as determined by an earlier run of layout analysis.
Return text orientation of each block as determined in an earlier page layout analysis operation. Orientation is returned as the number of ccw 90-degree rotations (in [0..3]) required to make the text in the block upright (readable). Note that this may not necessary be the block orientation preferred for recognition (such as the case of vertical CJK text).
Also returns whether the text in the block is believed to have vertical writing direction (when in an upright page orientation).
The returned array is of length equal to the number of text blocks, which may be less than the total number of blocks. The ordering is intended to be consistent with GetTextLines().
Definition at line 1727 of file baseapi.cpp.
{
delete[] *block_orientation;
*block_orientation = NULL;
delete[] *vertical_writing;
*vertical_writing = NULL;
BLOCK_IT block_it(block_list_);
block_it.move_to_first();
int num_blocks = 0;
for (block_it.mark_cycle_pt(); !block_it.cycled_list(); block_it.forward()) {
if (!block_it.data()->poly_block()->IsText()) {
continue;
}
++num_blocks;
}
if (!num_blocks) {
tprintf("WARNING: Found no blocks\n");
return;
}
*block_orientation = new int[num_blocks];
*vertical_writing = new bool[num_blocks];
block_it.move_to_first();
int i = 0;
for (block_it.mark_cycle_pt(); !block_it.cycled_list();
block_it.forward()) {
if (!block_it.data()->poly_block()->IsText()) {
continue;
}
FCOORD re_rotation = block_it.data()->re_rotation();
float re_theta = re_rotation.angle();
FCOORD classify_rotation = block_it.data()->classify_rotation();
float classify_theta = classify_rotation.angle();
double rot_theta = - (re_theta - classify_theta) * 2.0 / PI;
if (rot_theta < 0) rot_theta += 4;
int num_rotations = static_cast<int>(rot_theta + 0.5);
(*block_orientation)[i] = num_rotations;
// The classify_rotation is non-zero only if the text has vertical
// writing direction.
(*vertical_writing)[i] = classify_rotation.y() != 0.0f;
++i;
}
}
| char * tesseract::TessBaseAPI::GetBoxText | ( | int | page_number | ) |
The recognized text is returned as a char* which is coded in the same format as a box file used in training. Returned string must be freed with the delete [] operator. Constructs coordinates in the original image - not just the rectangle. page_number is a 0-based page index that will appear in the box file.
The recognized text is returned as a char* which is coded as a UTF8 box file and must be freed with the delete [] operator. page_number is a 0-base page index that will appear in the box file.
Definition at line 1136 of file baseapi.cpp.
{
if (tesseract_ == NULL ||
(!recognition_done_ && Recognize(NULL) < 0))
return NULL;
int blob_count;
int utf8_length = TextLength(&blob_count);
int total_length = blob_count * kBytesPerBoxFileLine + utf8_length +
kMaxBytesPerLine;
char* result = new char[total_length];
int output_length = 0;
LTRResultIterator* it = GetLTRIterator();
do {
int left, top, right, bottom;
if (it->BoundingBox(RIL_SYMBOL, &left, &top, &right, &bottom)) {
char* text = it->GetUTF8Text(RIL_SYMBOL);
// Tesseract uses space for recognition failure. Fix to a reject
// character, kTesseractReject so we don't create illegal box files.
for (int i = 0; text[i] != '\0'; ++i) {
if (text[i] == ' ')
text[i] = kTesseractReject;
}
snprintf(result + output_length, total_length - output_length,
"%s %d %d %d %d %d\n",
text, left, image_height_ - bottom,
right, image_height_ - top, page_number);
output_length += strlen(result + output_length);
delete [] text;
// Just in case...
if (output_length + kMaxBytesPerLine > total_length)
break;
}
} while (it->Next(RIL_SYMBOL));
delete it;
return result;
}
| Boxa * tesseract::TessBaseAPI::GetComponentImages | ( | PageIteratorLevel | level, |
| bool | text_only, | ||
| Pixa ** | pixa, | ||
| int ** | blockids | ||
| ) |
Get the given level kind of components (block, textline, word etc.) as a leptonica-style Boxa, Pixa pair, in reading order. Can be called before or after Recognize. If blockids is not NULL, the block-id of each component is also returned as an array of one element per component. delete [] after use. If text_only is true, then only text components are returned.
Definition at line 499 of file baseapi.cpp.
{
PageIterator* page_it = GetIterator();
if (page_it == NULL)
page_it = AnalyseLayout();
if (page_it == NULL)
return NULL; // Failed.
// Count the components to get a size for the arrays.
int component_count = 0;
int left, top, right, bottom;
do {
if (page_it->BoundingBoxInternal(level, &left, &top, &right, &bottom) &&
(!text_only || PTIsTextType(page_it->BlockType())))
++component_count;
} while (page_it->Next(level));
Boxa* boxa = boxaCreate(component_count);
if (pixa != NULL)
*pixa = pixaCreate(component_count);
if (blockids != NULL)
*blockids = new int[component_count];
int blockid = 0;
int component_index = 0;
page_it->Begin();
do {
if (page_it->BoundingBoxInternal(level, &left, &top, &right, &bottom) &&
(!text_only || PTIsTextType(page_it->BlockType()))) {
Box* lbox = boxCreate(left, top, right - left, bottom - top);
boxaAddBox(boxa, lbox, L_INSERT);
if (pixa != NULL) {
Pix* pix = page_it->GetBinaryImage(level);
pixaAddPix(*pixa, pix, L_INSERT);
pixaAddBox(*pixa, lbox, L_CLONE);
}
if (blockids != NULL) {
(*blockids)[component_index] = blockid;
if (page_it->IsAtFinalElement(RIL_BLOCK, level))
++blockid;
}
++component_index;
}
} while (page_it->Next(level));
delete page_it;
return boxa;
}
| Boxa * tesseract::TessBaseAPI::GetConnectedComponents | ( | Pixa ** | pixa | ) |
Gets the individual connected (text) components (created after pages segmentation step, but before recognition) as a leptonica-style Boxa, Pixa pair, in reading order. Can be called before or after Recognize. Note: the caller is responsible for calling boxaDestroy() on the returned Boxa array and pixaDestroy() on cc array.
Gets the individual connected (text) components (created after pages segmentation step, but before recognition) as a leptonica-style Boxa, Pixa pair, in reading order. Can be called before or after Recognize.
Definition at line 487 of file baseapi.cpp.
{
return GetComponentImages(RIL_SYMBOL, true, pixa, NULL);
}
| CubeRecoContext * tesseract::TessBaseAPI::GetCubeRecoContext | ( | ) | const |
Return a pointer to underlying CubeRecoContext object if present.
Definition at line 2141 of file baseapi.cpp.
{
return (tesseract_ == NULL) ? NULL : tesseract_->GetCubeRecoContext();
}
| const Dawg * tesseract::TessBaseAPI::GetDawg | ( | int | i | ) | const |
Return the pointer to the i-th dawg loaded into tesseract_ object.
Definition at line 2130 of file baseapi.cpp.
{
if (tesseract_ == NULL || i >= NumDawgs()) return NULL;
return tesseract_->getDict().GetDawg(i);
}
| void tesseract::TessBaseAPI::GetFeaturesForBlob | ( | TBLOB * | blob, |
| const DENORM & | denorm, | ||
| INT_FEATURE_ARRAY | int_features, | ||
| int * | num_features, | ||
| int * | FeatureOutlineIndex | ||
| ) |
This method returns the features associated with the input image.
This method returns the features associated with the input blob.
Definition at line 2058 of file baseapi.cpp.
{
if (tesseract_) {
tesseract_->ResetFeaturesHaveBeenExtracted();
}
uinT8* norm_array = new uinT8[MAX_NUM_CLASSES];
inT32 len;
*num_features = tesseract_->GetCharNormFeatures(
blob, denorm, tesseract_->PreTrainedTemplates,
int_features, norm_array, norm_array, &len, FeatureOutlineIndex);
delete [] norm_array;
}
| char * tesseract::TessBaseAPI::GetHOCRText | ( | int | page_number | ) |
Make a HTML-formatted string with hOCR markup from the internal data structures. page_number is 0-based but will appear in the output as 1-based.
Make a HTML-formatted string with hOCR markup from the internal data structures. page_number is 0-based but will appear in the output as 1-based. Image name/input_file_ can be set by SetInputName before calling GetHOCRText STL removed from original patch submission and refactored by rays.
Definition at line 999 of file baseapi.cpp.
{
if (tesseract_ == NULL ||
(page_res_ == NULL && Recognize(NULL) < 0))
return NULL;
int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1;
int page_id = page_number + 1; // hOCR uses 1-based page numbers.
STRING hocr_str("");
if (input_file_ == NULL)
SetInputName(NULL);
hocr_str.add_str_int("<div class='ocr_page' id='page_", page_id);
hocr_str += "' title='image \"";
hocr_str += input_file_ ? *input_file_ : "unknown";
hocr_str.add_str_int("\"; bbox ", rect_left_);
hocr_str.add_str_int(" ", rect_top_);
hocr_str.add_str_int(" ", rect_width_);
hocr_str.add_str_int(" ", rect_height_);
hocr_str += "'>\n";
ResultIterator *res_it = GetIterator();
for (; !res_it->Empty(RIL_BLOCK); wcnt++) {
if (res_it->Empty(RIL_WORD)) {
res_it->Next(RIL_WORD);
continue;
}
// Open any new block/paragraph/textline.
if (res_it->IsAtBeginningOf(RIL_BLOCK)) {
hocr_str.add_str_int("<div class='ocr_carea' id='block_", bcnt);
hocr_str.add_str_int("_", bcnt);
AddBoxTohOCR(res_it, RIL_BLOCK, &hocr_str);
}
if (res_it->IsAtBeginningOf(RIL_PARA)) {
if (res_it->ParagraphIsLtr()) {
hocr_str.add_str_int("\n<p class='ocr_par' dir='ltr' id='par_", pcnt);
} else {
hocr_str.add_str_int("\n<p class='ocr_par' dir='rtl' id='par_", pcnt);
}
AddBoxTohOCR(res_it, RIL_PARA, &hocr_str);
}
if (res_it->IsAtBeginningOf(RIL_TEXTLINE)) {
hocr_str.add_str_int("<span class='ocr_line' id='line_", lcnt);
AddBoxTohOCR(res_it, RIL_TEXTLINE, &hocr_str);
}
// Now, process the word...
hocr_str.add_str_int("<span class='ocr_word' id='word_", wcnt);
AddBoxTohOCR(res_it, RIL_WORD, &hocr_str);
const char *font_name;
bool bold, italic, underlined, monospace, serif, smallcaps;
int pointsize, font_id;
font_name = res_it->WordFontAttributes(&bold, &italic, &underlined,
&monospace, &serif, &smallcaps,
&pointsize, &font_id);
bool last_word_in_line = res_it->IsAtFinalElement(RIL_TEXTLINE, RIL_WORD);
bool last_word_in_para = res_it->IsAtFinalElement(RIL_PARA, RIL_WORD);
bool last_word_in_block = res_it->IsAtFinalElement(RIL_BLOCK, RIL_WORD);
if (bold) hocr_str += "<strong>";
if (italic) hocr_str += "<em>";
do {
const char *grapheme = res_it->GetUTF8Text(RIL_SYMBOL);
if (grapheme && grapheme[0] != 0) {
if (grapheme[1] == 0) {
switch (grapheme[0]) {
case '<': hocr_str += "<"; break;
case '>': hocr_str += ">"; break;
case '&': hocr_str += "&"; break;
case '"': hocr_str += """; break;
case '\'': hocr_str += "'"; break;
default: hocr_str += grapheme;
}
} else {
hocr_str += grapheme;
}
}
delete []grapheme;
res_it->Next(RIL_SYMBOL);
} while (!res_it->Empty(RIL_BLOCK) && !res_it->IsAtBeginningOf(RIL_WORD));
if (italic) hocr_str += "</em>";
if (bold) hocr_str += "</strong>";
hocr_str += "</span> ";
wcnt++;
// Close any ending block/paragraph/textline.
if (last_word_in_line) {
hocr_str += "</span>\n";
lcnt++;
}
if (last_word_in_para) {
hocr_str += "</p>\n";
pcnt++;
}
if (last_word_in_block) {
hocr_str += "</div>\n";
bcnt++;
}
}
hocr_str += "</div>\n";
char *ret = new char[hocr_str.length() + 1];
strcpy(ret, hocr_str.string());
delete res_it;
return ret;
}
| ResultIterator * tesseract::TessBaseAPI::GetIterator | ( | ) |
Get a reading-order iterator to the results of LayoutAnalysis and/or Recognize. The returned iterator must be deleted after use. WARNING! This class points to data held within the TessBaseAPI class, and therefore can only be used while the TessBaseAPI class still exists and has not been subjected to a call of Init, SetImage, Recognize, Clear, End DetectOS, or anything else that changes the internal PAGE_RES.
Definition at line 934 of file baseapi.cpp.
{
if (tesseract_ == NULL || page_res_ == NULL)
return NULL;
return ResultIterator::StartOfParagraph(LTRResultIterator(
page_res_, tesseract_,
thresholder_->GetScaleFactor(), thresholder_->GetScaledYResolution(),
rect_left_, rect_top_, rect_width_, rect_height_));
}
| MutableIterator * tesseract::TessBaseAPI::GetMutableIterator | ( | ) |
Get a mutable iterator to the results of LayoutAnalysis and/or Recognize. The returned iterator must be deleted after use. WARNING! This class points to data held within the TessBaseAPI class, and therefore can only be used while the TessBaseAPI class still exists and has not been subjected to a call of Init, SetImage, Recognize, Clear, End DetectOS, or anything else that changes the internal PAGE_RES.
Definition at line 951 of file baseapi.cpp.
{
if (tesseract_ == NULL || page_res_ == NULL)
return NULL;
return new MutableIterator(page_res_, tesseract_,
thresholder_->GetScaleFactor(),
thresholder_->GetScaledYResolution(),
rect_left_, rect_top_, rect_width_, rect_height_);
}
| Boxa * tesseract::TessBaseAPI::GetRegions | ( | Pixa ** | pixa | ) |
Get the result of page layout analysis as a leptonica-style Boxa, Pixa pair, in reading order. Can be called before or after Recognize.
Definition at line 446 of file baseapi.cpp.
{
return GetComponentImages(RIL_BLOCK, false, pixa, NULL);
}
| Boxa * tesseract::TessBaseAPI::GetStrips | ( | Pixa ** | pixa, |
| int ** | blockids | ||
| ) |
Get textlines and strips of image regions as a leptonica-style Boxa, Pixa pair, in reading order. Enables downstream handling of non-rectangular regions. Can be called before or after Recognize. If blockids is not NULL, the block-id of each line is also returned as an array of one element per line. delete [] after use.
Definition at line 468 of file baseapi.cpp.
{
return GetComponentImages(RIL_TEXTLINE, false, pixa, blockids);
}
| bool tesseract::TessBaseAPI::GetTextDirection | ( | int * | out_offset, |
| float * | out_slope | ||
| ) |
Definition at line 1473 of file baseapi.cpp.
{
if (page_res_ == NULL)
FindLines();
if (block_list_->length() < 1) {
return false;
}
// Get first block
BLOCK_IT block_it(block_list_);
block_it.move_to_first();
ROW_LIST* rows = block_it.data()->row_list();
if (rows->length() < 1) {
return false;
}
// Get first line of block
ROW_IT row_it(rows);
row_it.move_to_first();
ROW* row = row_it.data();
// Calculate offset and slope (NOTE: Kind of ugly)
*out_offset = static_cast<int>(row->base_line(0.0));
*out_slope = row->base_line(1.0) - row->base_line(0.0);
return true;
}
| Boxa * tesseract::TessBaseAPI::GetTextlines | ( | Pixa ** | pixa, |
| int ** | blockids | ||
| ) |
Get the textlines as a leptonica-style Boxa, Pixa pair, in reading order. Can be called before or after Recognize. If blockids is not NULL, the block-id of each line is also returned as an array of one element per line. delete [] after use.
Definition at line 456 of file baseapi.cpp.
{
return GetComponentImages(RIL_TEXTLINE, true, pixa, blockids);
}
| Pix * tesseract::TessBaseAPI::GetThresholdedImage | ( | ) |
Get a copy of the internal thresholded image from Tesseract. Caller takes ownership of the Pix and must pixDestroy it. May be called any time after SetImage, or after TesseractRect.
ONLY available if you have Leptonica installed. Get a copy of the internal thresholded image from Tesseract.
Definition at line 433 of file baseapi.cpp.
{
if (tesseract_ == NULL)
return NULL;
if (tesseract_->pix_binary() == NULL)
Threshold(tesseract_->mutable_pix_binary());
return pixClone(tesseract_->pix_binary());
}
| int tesseract::TessBaseAPI::GetThresholdedImageScaleFactor | ( | ) | const |
Returns the scale factor of the thresholded image that would be returned by GetThresholdedImage() and the various GetX() methods that call GetComponentImages(). Returns 0 if no thresholder has been set.
Definition at line 548 of file baseapi.cpp.
{
if (thresholder_ == NULL) {
return 0;
}
return thresholder_->GetScaleFactor();
}
| const char * tesseract::TessBaseAPI::GetUnichar | ( | int | unichar_id | ) |
This method returns the string form of the specified unichar.
Definition at line 2125 of file baseapi.cpp.
{
return tesseract_->unicharset.id_to_unichar(unichar_id);
}
| char * tesseract::TessBaseAPI::GetUNLVText | ( | ) |
The recognized text is returned as a char* which is coded as UNLV format Latin-1 with specific reject and suspect codes and must be freed with the delete [] operator.
Definition at line 1190 of file baseapi.cpp.
{
if (tesseract_ == NULL ||
(!recognition_done_ && Recognize(NULL) < 0))
return NULL;
bool tilde_crunch_written = false;
bool last_char_was_newline = true;
bool last_char_was_tilde = false;
int total_length = TextLength(NULL);
PAGE_RES_IT page_res_it(page_res_);
char* result = new char[total_length];
char* ptr = result;
for (page_res_it.restart_page(); page_res_it.word () != NULL;
page_res_it.forward()) {
WERD_RES *word = page_res_it.word();
// Process the current word.
if (word->unlv_crunch_mode != CR_NONE) {
if (word->unlv_crunch_mode != CR_DELETE &&
(!tilde_crunch_written ||
(word->unlv_crunch_mode == CR_KEEP_SPACE &&
word->word->space() > 0 &&
!word->word->flag(W_FUZZY_NON) &&
!word->word->flag(W_FUZZY_SP)))) {
if (!word->word->flag(W_BOL) &&
word->word->space() > 0 &&
!word->word->flag(W_FUZZY_NON) &&
!word->word->flag(W_FUZZY_SP)) {
/* Write a space to separate from preceeding good text */
*ptr++ = ' ';
last_char_was_tilde = false;
}
if (!last_char_was_tilde) {
// Write a reject char.
last_char_was_tilde = true;
*ptr++ = kUNLVReject;
tilde_crunch_written = true;
last_char_was_newline = false;
}
}
} else {
// NORMAL PROCESSING of non tilde crunched words.
tilde_crunch_written = false;
tesseract_->set_unlv_suspects(word);
const char* wordstr = word->best_choice->unichar_string().string();
const STRING& lengths = word->best_choice->unichar_lengths();
int length = lengths.length();
int i = 0;
int offset = 0;
if (last_char_was_tilde &&
word->word->space() == 0 && wordstr[offset] == ' ') {
// Prevent adjacent tilde across words - we know that adjacent tildes
// within words have been removed.
// Skip the first character.
offset = lengths[i++];
}
if (i < length && wordstr[offset] != 0) {
if (!last_char_was_newline)
*ptr++ = ' ';
else
last_char_was_newline = false;
for (; i < length; offset += lengths[i++]) {
if (wordstr[offset] == ' ' ||
wordstr[offset] == kTesseractReject) {
*ptr++ = kUNLVReject;
last_char_was_tilde = true;
} else {
if (word->reject_map[i].rejected())
*ptr++ = kUNLVSuspect;
UNICHAR ch(wordstr + offset, lengths[i]);
int uni_ch = ch.first_uni();
for (int j = 0; kUniChs[j] != 0; ++j) {
if (kUniChs[j] == uni_ch) {
uni_ch = kLatinChs[j];
break;
}
}
if (uni_ch <= 0xff) {
*ptr++ = static_cast<char>(uni_ch);
last_char_was_tilde = false;
} else {
*ptr++ = kUNLVReject;
last_char_was_tilde = true;
}
}
}
}
}
if (word->word->flag(W_EOL) && !last_char_was_newline) {
/* Add a new line output */
*ptr++ = '\n';
tilde_crunch_written = false;
last_char_was_newline = true;
last_char_was_tilde = false;
}
}
*ptr++ = '\n';
*ptr = '\0';
return result;
}
| char * tesseract::TessBaseAPI::GetUTF8Text | ( | ) |
The recognized text is returned as a char* which is coded as UTF8 and must be freed with the delete [] operator.
Make a text string from the internal data structures.
Definition at line 961 of file baseapi.cpp.
{
if (tesseract_ == NULL ||
(!recognition_done_ && Recognize(NULL) < 0))
return NULL;
STRING text("");
ResultIterator *it = GetIterator();
do {
if (it->Empty(RIL_PARA)) continue;
char *para_text = it->GetUTF8Text(RIL_PARA);
text += para_text;
delete []para_text;
} while (it->Next(RIL_PARA));
char* result = new char[text.length() + 1];
strncpy(result, text.string(), text.length() + 1);
delete it;
return result;
}
| Boxa * tesseract::TessBaseAPI::GetWords | ( | Pixa ** | pixa | ) |
Get the words as a leptonica-style Boxa, Pixa pair, in reading order. Can be called before or after Recognize.
Definition at line 477 of file baseapi.cpp.
{
return GetComponentImages(RIL_WORD, true, pixa, NULL);
}
| void tesseract::TessBaseAPI::InitTruthCallback | ( | TruthCallback * | cb | ) | [inline] |
| int tesseract::TessBaseAPI::IsValidWord | ( | const char * | word | ) |
Check whether a word is valid according to Tesseract's language model
Check whether a word is valid according to Tesseract's language model returns 0 if the word is invalid, non-zero if valid
Definition at line 1468 of file baseapi.cpp.
{
return tesseract_->getDict().valid_word(word);
}
| TBLOB * tesseract::TessBaseAPI::MakeTBLOB | ( | Pix * | pix | ) | [static] |
Returns a TBLOB corresponding to the entire input image.
Creates a TBLOB* from the whole pix.
Definition at line 1809 of file baseapi.cpp.
{
int width = pixGetWidth(pix);
int height = pixGetHeight(pix);
BLOCK block("a character", TRUE, 0, 0, 0, 0, width, height);
// Create C_BLOBs from the page
extract_edges(pix, &block);
// Merge all C_BLOBs
C_BLOB_LIST *list = block.blob_list();
C_BLOB_IT c_blob_it(list);
if (c_blob_it.empty())
return NULL;
// Move all the outlines to the first blob.
C_OUTLINE_IT ol_it(c_blob_it.data()->out_list());
for (c_blob_it.forward();
!c_blob_it.at_first();
c_blob_it.forward()) {
C_BLOB *c_blob = c_blob_it.data();
ol_it.add_list_after(c_blob->out_list());
}
// Convert the first blob to the output TBLOB.
return TBLOB::PolygonalCopy(c_blob_it.data());
}
| ROW * tesseract::TessBaseAPI::MakeTessOCRRow | ( | float | baseline, |
| float | xheight, | ||
| float | descender, | ||
| float | ascender | ||
| ) | [static] |
| int tesseract::TessBaseAPI::MeanTextConf | ( | ) |
Returns the (average) confidence value between 0 and 100.
Returns the average word confidence for Tesseract page result.
Definition at line 1292 of file baseapi.cpp.
{
int* conf = AllWordConfidences();
if (!conf) return 0;
int sum = 0;
int *pt = conf;
while (*pt >= 0) sum += *pt++;
if (pt != conf) sum /= pt - conf;
delete [] conf;
return sum;
}
| void tesseract::TessBaseAPI::NormalizeTBLOB | ( | TBLOB * | tblob, |
| ROW * | row, | ||
| bool | numeric_mode, | ||
| DENORM * | denorm | ||
| ) | [static] |
This method baseline normalizes a TBLOB in-place. The input row is used for normalization. The denorm is an optional parameter in which the normalization-antidote is returned.
Definition at line 1839 of file baseapi.cpp.
| int tesseract::TessBaseAPI::NumDawgs | ( | ) | const |
Return the number of dawgs loaded into tesseract_ object.
Definition at line 2136 of file baseapi.cpp.
{
return tesseract_ == NULL ? 0 : tesseract_->getDict().NumDawgs();
}
| OcrEngineMode const tesseract::TessBaseAPI::oem | ( | ) | const [inline] |
Definition at line 652 of file baseapi.h.
{
return last_oem_requested_;
}
| bool tesseract::TessBaseAPI::ProcessPage | ( | Pix * | pix, |
| int | page_index, | ||
| const char * | filename, | ||
| const char * | retry_config, | ||
| int | timeout_millisec, | ||
| STRING * | text_out | ||
| ) |
Recognizes a single page for ProcessPages, appending the text to text_out. The pix is the image processed - filename and page_index are metadata used by side-effect processes, such as reading a box file or formatting as hOCR. If non-zero timeout_millisec terminates processing after the timeout. If non-NULL and non-empty, and some page fails for some reason, the page is reprocessed with the retry_config config file. Useful for interactively debugging a bad page. The text is returned in text_out. Returns false on error.
Definition at line 849 of file baseapi.cpp.
{
SetInputName(filename);
SetImage(pix);
bool failed = false;
if (timeout_millisec > 0) {
// Running with a timeout.
ETEXT_DESC monitor;
monitor.cancel = NULL;
monitor.cancel_this = NULL;
monitor.set_deadline_msecs(timeout_millisec);
// Now run the main recognition.
failed = Recognize(&monitor) < 0;
} else if (tesseract_->tessedit_pageseg_mode == PSM_OSD_ONLY ||
tesseract_->tessedit_pageseg_mode == PSM_AUTO_ONLY) {
// Disabled character recognition.
PageIterator* it = AnalyseLayout();
if (it == NULL) {
failed = true;
} else {
delete it;
return true;
}
} else {
// Normal layout and character recognition with no timeout.
failed = Recognize(NULL) < 0;
}
if (tesseract_->tessedit_write_images) {
Pix* page_pix = GetThresholdedImage();
pixWrite("tessinput.tif", page_pix, IFF_TIFF_G4);
}
if (failed && retry_config != NULL && retry_config[0] != '\0') {
// Save current config variables before switching modes.
FILE* fp = fopen(kOldVarsFile, "wb");
PrintVariables(fp);
fclose(fp);
// Switch to alternate mode for retry.
ReadConfigFile(retry_config);
SetImage(pix);
Recognize(NULL);
// Restore saved config variables.
ReadConfigFile(kOldVarsFile);
}
// Get text only if successful.
if (!failed) {
char* text;
if (tesseract_->tessedit_create_boxfile ||
tesseract_->tessedit_make_boxes_from_boxes) {
text = GetBoxText(page_index);
} else if (tesseract_->tessedit_write_unlv) {
text = GetUNLVText();
} else if (tesseract_->tessedit_create_hocr) {
text = GetHOCRText(page_index);
} else {
text = GetUTF8Text();
}
*text_out += text;
delete [] text;
return true;
}
return false;
}
| bool tesseract::TessBaseAPI::ProcessPages | ( | const char * | filename, |
| const char * | retry_config, | ||
| int | timeout_millisec, | ||
| STRING * | text_out | ||
| ) |
Recognizes all the pages in the named file, as a multi-page tiff or list of filenames, or single image, and gets the appropriate kind of text according to parameters: tessedit_create_boxfile, tessedit_make_boxes_from_boxes, tessedit_write_unlv, tessedit_create_hocr. Calls ProcessPage on each page in the input file, which may be a multi-page tiff, single-page other file format, or a plain text list of images to read. If tessedit_page_number is non-negative, processing begins at that page of a multi-page tiff file, or filelist. The text is returned in text_out. Returns false on error. If non-zero timeout_millisec terminates processing after the timeout on a single page. If non-NULL and non-empty, and some page fails for some reason, the page is reprocessed with the retry_config config file. Useful for interactively debugging a bad page.
Definition at line 752 of file baseapi.cpp.
{
int page = tesseract_->tessedit_page_number;
if (page < 0)
page = 0;
FILE* fp = fopen(filename, "rb");
if (fp == NULL) {
tprintf(_("Image file %s cannot be opened!\n"), filename);
return false;
}
// Find the number of pages if a tiff file, or zero otherwise.
int npages = CountTiffPages(fp);
fclose(fp);
if (tesseract_->tessedit_create_hocr) {
*text_out =
"<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\""
" \"http://www.w3.org/TR/html4/loose.dtd\">\n"
"<html>\n<head>\n<title></title>\n"
"<meta http-equiv=\"Content-Type\" content=\"text/html;"
"charset=utf-8\" />\n<meta name='ocr-system' content='tesseract'/>\n"
"</head>\n<body>\n";
} else {
*text_out = "";
}
bool success = true;
Pix *pix;
if (npages > 0) {
for (; page < npages && (pix = pixReadTiff(filename, page)) != NULL;
++page) {
if ((page >= 0) && (npages > 1))
tprintf(_("Page %d of %d\n"), page + 1, npages);
char page_str[kMaxIntSize];
snprintf(page_str, kMaxIntSize - 1, "%d", page);
SetVariable("applybox_page", page_str);
success &= ProcessPage(pix, page, filename, retry_config,
timeout_millisec, text_out);
pixDestroy(&pix);
if (tesseract_->tessedit_page_number >= 0 || npages == 1) {
break;
}
}
} else {
// The file is not a tiff file, so use the general pixRead function.
pix = pixRead(filename);
if (pix != NULL) {
success &= ProcessPage(pix, 0, filename, retry_config,
timeout_millisec, text_out);
pixDestroy(&pix);
} else {
// The file is not an image file, so try it as a list of filenames.
FILE* fimg = fopen(filename, "rb");
if (fimg == NULL) {
tprintf(_("File %s cannot be opened!\n"), filename);
return false;
}
tprintf(_("Reading %s as a list of filenames...\n"), filename);
char pagename[MAX_PATH];
// Skip to the requested page number.
for (int i = 0; i < page &&
fgets(pagename, sizeof(pagename), fimg) != NULL;
++i);
while (fgets(pagename, sizeof(pagename), fimg) != NULL) {
chomp_string(pagename);
pix = pixRead(pagename);
if (pix == NULL) {
tprintf(_("Image file %s cannot be read!\n"), pagename);
fclose(fimg);
return false;
}
tprintf(_("Page %d : %s\n"), page, pagename);
success &= ProcessPage(pix, page, pagename, retry_config,
timeout_millisec, text_out);
pixDestroy(&pix);
++page;
}
fclose(fimg);
}
}
if (tesseract_->tessedit_create_hocr)
*text_out += "</body>\n</html>\n";
return success;
}
| int tesseract::TessBaseAPI::Recognize | ( | ETEXT_DESC * | monitor | ) |
Recognize the image from SetAndThresholdImage, generating Tesseract internal structures. Returns 0 on success. Optional. The Get*Text functions below will call Recognize if needed. After Recognize, the output is kept internally until the next SetImage.
Recognize the tesseract global image and return the result as Tesseract internal structures.
Definition at line 647 of file baseapi.cpp.
{
if (tesseract_ == NULL)
return -1;
if (FindLines() != 0)
return -1;
if (page_res_ != NULL)
delete page_res_;
tesseract_->SetBlackAndWhitelist();
recognition_done_ = true;
if (tesseract_->tessedit_resegment_from_line_boxes)
page_res_ = tesseract_->ApplyBoxes(*input_file_, true, block_list_);
else if (tesseract_->tessedit_resegment_from_boxes)
page_res_ = tesseract_->ApplyBoxes(*input_file_, false, block_list_);
else
page_res_ = new PAGE_RES(block_list_, &tesseract_->prev_word_best_choice_);
if (tesseract_->tessedit_make_boxes_from_boxes) {
tesseract_->CorrectClassifyWords(page_res_);
return 0;
}
if (truth_cb_ != NULL) {
tesseract_->wordrec_run_blamer.set_value(true);
truth_cb_->Run(tesseract_->getDict().getUnicharset(),
image_height_, page_res_);
}
int result = 0;
if (tesseract_->interactive_display_mode) {
#ifndef GRAPHICS_DISABLED
tesseract_->pgeditor_main(rect_width_, rect_height_, page_res_);
#endif // GRAPHICS_DISABLED
// The page_res is invalid after an interactive session, so cleanup
// in a way that lets us continue to the next page without crashing.
delete page_res_;
page_res_ = NULL;
return -1;
} else if (tesseract_->tessedit_train_from_boxes) {
tesseract_->ApplyBoxTraining(*output_file_, page_res_);
} else if (tesseract_->tessedit_ambigs_training) {
FILE *training_output_file = tesseract_->init_recog_training(*input_file_);
// OCR the page segmented into words by tesseract.
tesseract_->recog_training_segmented(
*input_file_, page_res_, monitor, training_output_file);
fclose(training_output_file);
} else {
// Now run the main recognition.
if (tesseract_->recog_all_words(page_res_, monitor, NULL, NULL, 0)) {
int paragraph_debug_level = 0;
GetIntVariable("paragraph_debug_level", ¶graph_debug_level);
DetectParagraphs(paragraph_debug_level);
} else {
result = -1;
}
}
return result;
}
| int tesseract::TessBaseAPI::RecognizeForChopTest | ( | ETEXT_DESC * | monitor | ) |
Methods to retrieve information after SetAndThresholdImage(), Recognize() or TesseractRect(). (Recognize is called implicitly if needed.) Variant on Recognize used for testing chopper.
Tests the chopper by exhaustively running chop_one_blob.
Definition at line 706 of file baseapi.cpp.
{
if (tesseract_ == NULL)
return -1;
if (thresholder_ == NULL || thresholder_->IsEmpty()) {
tprintf("Please call SetImage before attempting recognition.");
return -1;
}
if (page_res_ != NULL)
ClearResults();
if (FindLines() != 0)
return -1;
// Additional conditions under which chopper test cannot be run
if (tesseract_->interactive_display_mode) return -1;
recognition_done_ = true;
page_res_ = new PAGE_RES(block_list_, &(tesseract_->prev_word_best_choice_));
PAGE_RES_IT page_res_it(page_res_);
while (page_res_it.word() != NULL) {
WERD_RES *word_res = page_res_it.word();
GenericVector<TBOX> boxes;
tesseract_->MaximallyChopWord(boxes, page_res_it.block()->block,
page_res_it.row()->row, word_res);
page_res_it.forward();
}
return 0;
}
| void tesseract::TessBaseAPI::RunAdaptiveClassifier | ( | TBLOB * | blob, |
| const DENORM & | denorm, | ||
| int | num_max_matches, | ||
| int * | unichar_ids, | ||
| float * | ratings, | ||
| int * | num_matches_returned | ||
| ) |
Method to run adaptive classifier on a blob. It returns at max num_max_matches results.
Method to run adaptive classifier on a blob.
Definition at line 2102 of file baseapi.cpp.
{
BLOB_CHOICE_LIST* choices = new BLOB_CHOICE_LIST;
tesseract_->AdaptiveClassifier(blob, denorm, choices, NULL);
BLOB_CHOICE_IT choices_it(choices);
int& index = *num_matches_returned;
index = 0;
for (choices_it.mark_cycle_pt();
!choices_it.cycled_list() && index < num_max_matches;
choices_it.forward()) {
BLOB_CHOICE* choice = choices_it.data();
unichar_ids[index] = choice->unichar_id();
ratings[index] = choice->rating();
++index;
}
*num_matches_returned = index;
delete choices;
}
| void tesseract::TessBaseAPI::set_min_orientation_margin | ( | double | margin | ) |
Definition at line 1709 of file baseapi.cpp.
{
tesseract_->min_orientation_margin.set_value(margin);
}
| void tesseract::TessBaseAPI::SetDictFunc | ( | DictFunc | f | ) |
Sets Dict::letter_is_okay_ function to point to the given function.
Definition at line 1501 of file baseapi.cpp.
{
if (tesseract_ != NULL) {
tesseract_->getDict().letter_is_okay_ = f;
}
}
| void tesseract::TessBaseAPI::SetFillLatticeFunc | ( | FillLatticeFunc | f | ) |
Sets Wordrec::fill_lattice_ function to point to the given function.
Definition at line 1523 of file baseapi.cpp.
{
if (tesseract_ != NULL) tesseract_->fill_lattice_ = f;
}
| void tesseract::TessBaseAPI::SetImage | ( | const unsigned char * | imagedata, |
| int | width, | ||
| int | height, | ||
| int | bytes_per_pixel, | ||
| int | bytes_per_line | ||
| ) |
Provide an image for Tesseract to recognize. Format is as TesseractRect above. Does not copy the image buffer, or take ownership. The source image may be destroyed after Recognize is called, either explicitly or implicitly via one of the Get*Text functions. SetImage clears all recognition results, and sets the rectangle to the full image, so it may be followed immediately by a GetUTF8Text, and it will automatically perform recognition.
Definition at line 387 of file baseapi.cpp.
{
if (InternalSetImage())
thresholder_->SetImage(imagedata, width, height,
bytes_per_pixel, bytes_per_line);
}
| void tesseract::TessBaseAPI::SetImage | ( | const Pix * | pix | ) |
Provide an image for Tesseract to recognize. As with SetImage above, Tesseract doesn't take a copy or ownership or pixDestroy the image, so it must persist until after Recognize. Pix vs raw, which to use? Use Pix where possible. A future version of Tesseract may choose to use Pix as its internal representation and discard IMAGE altogether. Because of that, an implementation that sources and targets Pix may end up with less copies than an implementation that does not.
Definition at line 412 of file baseapi.cpp.
{
if (InternalSetImage())
thresholder_->SetImage(pix);
}
| void tesseract::TessBaseAPI::SetProbabilityInContextFunc | ( | ProbabilityInContextFunc | f | ) |
Sets Dict::probability_in_context_ function to point to the given function.
Definition at line 1511 of file baseapi.cpp.
{
if (tesseract_ != NULL) {
tesseract_->getDict().probability_in_context_ = f;
// Set it for the sublangs too.
int num_subs = tesseract_->num_sub_langs();
for (int i = 0; i < num_subs; ++i) {
tesseract_->get_sub_lang(i)->getDict().probability_in_context_ = f;
}
}
}
| void tesseract::TessBaseAPI::SetRectangle | ( | int | left, |
| int | top, | ||
| int | width, | ||
| int | height | ||
| ) |
Restrict recognition to a sub-rectangle of the image. Call after SetImage. Each SetRectangle clears the recogntion results so multiple rectangles can be recognized with the same image.
Definition at line 422 of file baseapi.cpp.
{
if (thresholder_ == NULL)
return;
thresholder_->SetRectangle(left, top, width, height);
ClearResults();
}
| void tesseract::TessBaseAPI::SetSourceResolution | ( | int | ppi | ) |
Set the resolution of the source image in pixels per inch so font size information can be calculated in results. Call this after SetImage().
Definition at line 395 of file baseapi.cpp.
{
if (thresholder_)
thresholder_->SetSourceYResolution(ppi);
else
tprintf("Please call SetImage before SetSourceResolution.\n");
}
| void tesseract::TessBaseAPI::SetThresholder | ( | ImageThresholder * | thresholder | ) | [inline] |
In extreme cases only, usually with a subclass of Thresholder, it is possible to provide a different Thresholder. The Thresholder may be preloaded with an image, settings etc, or they may be set after. Note that Tesseract takes ownership of the Thresholder and will delete it when it it is replaced or the API is destructed.
Definition at line 343 of file baseapi.h.
{
if (thresholder_ != NULL)
delete thresholder_;
thresholder_ = thresholder;
ClearResults();
}
| Tesseract* const tesseract::TessBaseAPI::tesseract | ( | ) | const [inline] |
Definition at line 648 of file baseapi.h.
{
return tesseract_;
}
1.7.5.1