mirror/tesseract
1
0
Fork 0
mirror of https://github.com/tesseract-ocr/tesseract.git synced 2024-12-18 11:28:51 +08:00
Code Issues Actions 10 Packages Projects Releases Wiki Activity
328177c30a
tesseract/ccmain/baseapi.cpp
mezhirov 3f218cd158 Bugfix (usage of bounding_union() changed) 
git-svn-id: https://tesseract-ocr.googlecode.com/svn/trunk@169 d0cd1f9f-072b-0410-8dd7-cf729c803f20
2008-04-29 16:54:43 +00:00

1096 lines
38 KiB
C++
Raw Blame History

/**********************************************************************
* File: baseapi.cpp
* Description: Simple API for calling tesseract.
* Author: Ray Smith
* Created: Fri Oct 06 15:35:01 PDT 2006
*
* (C) Copyright 2006, Google Inc.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#include "baseapi.h"
// Include automatically generated configuration file if running autoconf.
#ifdef HAVE_CONFIG_H
#include "config_auto.h"
#endif
#ifdef HAVE_LIBLEPT
// Include leptonica library only if autoconf (or makefile etc) tell us to.
#include "allheaders.h"
#endif
#include "tessedit.h"
#include "ocrclass.h"
#include "pageres.h"
#include "tessvars.h"
#include "control.h"
#include "applybox.h"
#include "pgedit.h"
#include "varabled.h"
#include "variables.h"
#include "output.h"
#include "globals.h"
#include "adaptmatch.h"
#include "edgblob.h"
#include "tessbox.h"
#include "tordvars.h"
#include "imgs.h"
#include "makerow.h"
#include "tstruct.h"
#include "tessout.h"
#include "tface.h"
#include "permute.h"
BOOL_VAR(tessedit_resegment_from_boxes, FALSE,
"Take segmentation and labeling from box file");
BOOL_VAR(tessedit_train_from_boxes, FALSE,
"Generate training data from boxed chars");
// Minimum sensible image size to be worth running tesseract.
const int kMinRectSize = 10;
static STRING input_file = "noname.tif";
// Set the value of an internal "variable" (of either old or new types).
// Supply the name of the variable and the value as a string, just as
// you would in a config file.
// Returns false if the name lookup failed.
bool TessBaseAPI::SetVariable(const char* variable, const char* value) {
if (set_new_style_variable(variable, value))
return true;
return set_old_style_variable(variable, value);
}
void TessBaseAPI::SimpleInit(const char* datapath,
const char* language,
bool numeric_mode) {
InitWithLanguage(datapath, NULL, language, NULL, numeric_mode, 0, NULL);
}
// Start tesseract.
// The datapath must be the name of the data directory or some other file
// in which the data directory resides (for instance argv[0].)
// The configfile is the name of a file in the tessconfigs directory
// (eg batch) or NULL to run on defaults.
// Outputbase may also be NULL, and is the basename of various output files.
// If the output of any of these files is enabled, then a name nmust be given.
// If numeric_mode is true, only possible digits and roman numbers are
// returned. Returns 0 if successful. Crashes if not.
// The argc and argv may be 0 and NULL respectively. They are used for
// providing config files for debug/display purposes.
// TODO(rays) get the facts straight. Is it OK to call
// it more than once? Make it properly check for errors and return them.
int TessBaseAPI::Init(const char* datapath, const char* outputbase,
const char* configfile, bool numeric_mode,
int argc, char* argv[]) {
return InitWithLanguage(datapath, outputbase, NULL, configfile,
numeric_mode, argc, argv);
}
// Start tesseract.
// Similar to Init() except that it is possible to specify the language.
// Language is the code of the language for which the data will be loaded.
// (Codes follow ISO 639-3.) If it is NULL, english (eng) will be loaded.
int TessBaseAPI::InitWithLanguage(const char* datapath, const char* outputbase,
const char* language, const char* configfile,
bool numeric_mode, int argc, char* argv[]) {
int result = init_tesseract(datapath, outputbase, language,
configfile, argc, argv);
bln_numericmode.set_value(numeric_mode);
return result;
}
// Init the lang model component of Tesseract
int TessBaseAPI::InitLangMod(const char* datapath, const char* outputbase,
const char* language, const char* configfile,
bool numeric_mode, int argc, char* argv[]) {
return init_tesseract_lm(datapath, outputbase, language,
configfile, argc, argv);
}
// Set the name of the input file. Needed only for training and
// loading a UNLV zone file.
void TessBaseAPI::SetInputName(const char* name) {
input_file = name;
}
// Recognize a rectangle from an image and return the result as a string.
// May be called many times for a single Init.
// Currently has no error checking.
// Greyscale of 8 and color of 24 or 32 bits per pixel may be given.
// Palette color images will not work properly and must be converted to
// 24 bit.
// Binary images of 1 bit per pixel may also be given but they must be
// byte packed with the MSB of the first byte being the first pixel, and a
// one pixel is WHITE. For binary images set bytes_per_pixel=0.
// The recognized text is returned as a char* which (in future will be coded
// as UTF8 and) must be freed with the delete [] operator.
char* TessBaseAPI::TesseractRect(const unsigned char* imagedata,
int bytes_per_pixel,
int bytes_per_line,
int left, int top,
int width, int height) {
if (width < kMinRectSize || height < kMinRectSize)
return NULL; // Nothing worth doing.
// Copy/Threshold the image to the tesseract global page_image.
CopyImageToTesseract(imagedata, bytes_per_pixel, bytes_per_line,
left, top, width, height);
return RecognizeToString();
}
// As TesseractRect but produces a box file as output.
char* TessBaseAPI::TesseractRectBoxes(const unsigned char* imagedata,
int bytes_per_pixel,
int bytes_per_line,
int left, int top,
int width, int height,
int imageheight) {
if (width < kMinRectSize || height < kMinRectSize)
return NULL; // Nothing worth doing.
// Copy/Threshold the image to the tesseract global page_image.
CopyImageToTesseract(imagedata, bytes_per_pixel, bytes_per_line,
left, top, width, height);
BLOCK_LIST block_list;
FindLines(&block_list);
// Now run the main recognition.
PAGE_RES* page_res = Recognize(&block_list, NULL);
return TesseractToBoxText(page_res, left, imageheight - (top + height));
}
char* TessBaseAPI::TesseractRectUNLV(const unsigned char* imagedata,
int bytes_per_pixel,
int bytes_per_line,
int left, int top,
int width, int height) {
if (width < kMinRectSize || height < kMinRectSize)
return NULL; // Nothing worth doing.
// Copy/Threshold the image to the tesseract global page_image.
CopyImageToTesseract(imagedata, bytes_per_pixel, bytes_per_line,
left, top, width, height);
BLOCK_LIST block_list;
FindLines(&block_list);
// Now run the main recognition.
PAGE_RES* page_res = Recognize(&block_list, NULL);
return TesseractToUNLV(page_res);
}
// Call between pages or documents etc to free up memory and forget
// adaptive data.
void TessBaseAPI::ClearAdaptiveClassifier() {
ResetAdaptiveClassifier();
}
// Close down tesseract and free up memory.
void TessBaseAPI::End() {
ResetAdaptiveClassifier();
end_tesseract();
}
// Dump the internal binary image to a PGM file.
void TessBaseAPI::DumpPGM(const char* filename) {
IMAGELINE line;
line.init(page_image.get_xsize());
FILE *fp = fopen(filename, "w");
fprintf(fp, "P5 " INT32FORMAT " " INT32FORMAT " 255\n", page_image.get_xsize(),
page_image.get_ysize());
for (int j = page_image.get_ysize()-1; j >= 0 ; --j) {
page_image.get_line(0, j, page_image.get_xsize(), &line, 0);
for (int i = 0; i < page_image.get_xsize(); ++i) {
uinT8 b = line.pixels[i] ? 255 : 0;
fwrite(&b, 1, 1, fp);
}
}
fclose(fp);
}
#ifdef HAVE_LIBLEPT
// ONLY available if you have Leptonica installed.
// Get a copy of the thresholded global image from Tesseract.
Pix* TessBaseAPI::GetTesseractImage() {
return page_image.ToPix();
}
#endif // HAVE_LIBLEPT
// Copy the given image rectangle to Tesseract, with adaptive thresholding
// if the image is not already binary.
void TessBaseAPI::CopyImageToTesseract(const unsigned char* imagedata,
int bytes_per_pixel,
int bytes_per_line,
int left, int top,
int width, int height) {
if (bytes_per_pixel > 0) {
// Threshold grey or color.
int* thresholds = new int[bytes_per_pixel];
int* hi_values = new int[bytes_per_pixel];
// Compute the thresholds.
OtsuThreshold(imagedata, bytes_per_pixel, bytes_per_line,
left, top, left + width, top + height,
thresholds, hi_values);
// Threshold the image to the tesseract global page_image.
ThresholdRect(imagedata, bytes_per_pixel, bytes_per_line,
left, top, width, height,
thresholds, hi_values);
delete [] thresholds;
delete [] hi_values;
} else {
CopyBinaryRect(imagedata, bytes_per_line, left, top, width, height);
}
}
// Compute the Otsu threshold(s) for the given image rectangle, making one
// for each channel. Each channel is always one byte per pixel.
// Returns an array of threshold values and an array of hi_values, such
// that a pixel value >threshold[channel] is considered foreground if
// hi_values[channel] is 0 or background if 1. A hi_value of -1 indicates
// that there is no apparent foreground. At least one hi_value will not be -1.
// thresholds and hi_values are assumed to be of bytes_per_pixel size.
void TessBaseAPI::OtsuThreshold(const unsigned char* imagedata,
int bytes_per_pixel,
int bytes_per_line,
int left, int top, int right, int bottom,
int* thresholds,
int* hi_values) {
// Of all channels with no good hi_value, keep the best so we can always
// produce at least one answer.
int best_hi_value = 0;
int best_hi_index = 0;
bool any_good_hivalue = false;
double best_hi_dist = 0.0;
for (int ch = 0; ch < bytes_per_pixel; ++ch) {
thresholds[ch] = 0;
hi_values[ch] = -1;
// Compute the histogram of the image rectangle.
int histogram[256];
HistogramRect(imagedata + ch, bytes_per_pixel, bytes_per_line,
left, top, right, bottom, histogram);
int H;
int best_omega_0;
int best_t = OtsuStats(histogram, &H, &best_omega_0);
if (best_omega_0 == 0 || best_omega_0 == H) {
// This channel is empty.
continue;
}
// To be a convincing foreground we must have a small fraction of H
// or to be a convincing background we must have a large fraction of H.
// In between we assume this channel contains no thresholding information.
int hi_value = best_omega_0 < H * 0.5;
thresholds[ch] = best_t;
if (best_omega_0 > H * 0.75) {
any_good_hivalue = true;
hi_values[ch] = 0;
}
else if (best_omega_0 < H * 0.25) {
any_good_hivalue = true;
hi_values[ch] = 1;
}
else {
// In case all channels are like this, keep the best of the bad lot.
double hi_dist = hi_value ? (H - best_omega_0) : best_omega_0;
if (hi_dist > best_hi_dist) {
best_hi_dist = hi_dist;
best_hi_value = hi_value;
best_hi_index = ch;
}
}
}
if (!any_good_hivalue) {
// Use the best of the ones that were not good enough.
hi_values[best_hi_index] = best_hi_value;
}
}
// Compute the histogram for the given image rectangle, and the given
// channel. (Channel pointed to by imagedata.) Each channel is always
// one byte per pixel.
// Bytes per pixel is used to skip channels not being
// counted with this call in a multi-channel (pixel-major) image.
// Histogram is always a 256 element array to count occurrences of
// each pixel value.
void TessBaseAPI::HistogramRect(const unsigned char* imagedata,
int bytes_per_pixel,
int bytes_per_line,
int left, int top, int right, int bottom,
int* histogram) {
int width = right - left;
memset(histogram, 0, sizeof(*histogram) * 256);
const unsigned char* pixels = imagedata +
top*bytes_per_line +
left*bytes_per_pixel;
for (int y = top; y < bottom; ++y) {
for (int x = 0; x < width; ++x) {
++histogram[pixels[x * bytes_per_pixel]];
}
pixels += bytes_per_line;
}
}
// Compute the Otsu threshold(s) for the given histogram.
// Also returns H = total count in histogram, and
// omega0 = count of histogram below threshold.
int TessBaseAPI::OtsuStats(const int* histogram,
int* H_out,
int* omega0_out) {
int H = 0;
double mu_T = 0.0;
for (int i = 0; i < 256; ++i) {
H += histogram[i];
mu_T += i * histogram[i];
}
// Now maximize sig_sq_B over t.
// http://www.ctie.monash.edu.au/hargreave/Cornall_Terry_328.pdf
int best_t = -1;
int omega_0, omega_1;
int best_omega_0 = 0;
double best_sig_sq_B = 0.0;
double mu_0, mu_1, mu_t;
omega_0 = 0;
mu_t = 0.0;
for (int t = 0; t < 255; ++t) {
omega_0 += histogram[t];
mu_t += t * static_cast<double>(histogram[t]);
if (omega_0 == 0)
continue;
omega_1 = H - omega_0;
mu_0 = mu_t / omega_0;
mu_1 = (mu_T - mu_t) / omega_1;
double sig_sq_B = mu_1 - mu_0;
sig_sq_B *= sig_sq_B * omega_0 * omega_1;
if (best_t < 0 || sig_sq_B > best_sig_sq_B) {
best_sig_sq_B = sig_sq_B;
best_t = t;
best_omega_0 = omega_0;
}
}
if (H_out != NULL) *H_out = H;
if (omega0_out != NULL) *omega0_out = best_omega_0;
return best_t;
}
// Threshold the given grey or color image into the tesseract global
// image ready for recognition. Requires thresholds and hi_value
// produced by OtsuThreshold above.
void TessBaseAPI::ThresholdRect(const unsigned char* imagedata,
int bytes_per_pixel,
int bytes_per_line,
int left, int top,
int width, int height,
const int* thresholds,
const int* hi_values) {
IMAGELINE line;
page_image.create(width, height, 1);
line.init(width);
// For each line in the image, fill the IMAGELINE class and put it into the
// Tesseract global page_image. Note that Tesseract stores images with the
// bottom at y=0 and 0 is black, so we need 2 kinds of inversion.
const unsigned char* data = imagedata + top*bytes_per_line +
left*bytes_per_pixel;
for (int y = height - 1 ; y >= 0; --y) {
const unsigned char* pix = data;
for (int x = 0; x < width; ++x, pix += bytes_per_pixel) {
line.pixels[x] = 1;
for (int ch = 0; ch < bytes_per_pixel; ++ch) {
if (hi_values[ch] >= 0 &&
(pix[ch] > thresholds[ch]) == (hi_values[ch] == 0)) {
line.pixels[x] = 0;
break;
}
}
}
page_image.put_line(0, y, width, &line, 0);
data += bytes_per_line;
}
}
// Cut out the requested rectangle of the binary image to the
// tesseract global image ready for recognition.
void TessBaseAPI::CopyBinaryRect(const unsigned char* imagedata,
int bytes_per_line,
int left, int top,
int width, int height) {
// Copy binary image, cutting out the required rectangle.
IMAGE image;
image.capture(const_cast<unsigned char*>(imagedata),
bytes_per_line*8, top + height, 1);
page_image.create(width, height, 1);
copy_sub_image(&image, left, 0, width, height, &page_image, 0, 0, false);
}
// Low-level function to recognize the current global image to a string.
char* TessBaseAPI::RecognizeToString() {
BLOCK_LIST block_list;
FindLines(&block_list);
// Now run the main recognition.
PAGE_RES* page_res = Recognize(&block_list, NULL);
return TesseractToText(page_res);
}
// Find lines from the image making the BLOCK_LIST.
void TessBaseAPI::FindLines(BLOCK_LIST* block_list) {
// The following call creates a full-page block and then runs connected
// component analysis and text line creation.
pgeditor_read_file(input_file, block_list);
}
// Recognize the tesseract global image and return the result as Tesseract
// internal structures.
PAGE_RES* TessBaseAPI::Recognize(BLOCK_LIST* block_list, ETEXT_DESC* monitor) {
if (tessedit_resegment_from_boxes)
apply_boxes(block_list);
PAGE_RES* page_res = new PAGE_RES(block_list);
if (interactive_mode) {
pgeditor_main(block_list); //pgeditor user I/F
} else if (tessedit_train_from_boxes) {
apply_box_training(block_list);
} else {
// Now run the main recognition.
recog_all_words(page_res, monitor);
}
return page_res;
}
// Return the maximum length that the output text string might occupy.
int TessBaseAPI::TextLength(PAGE_RES* page_res) {
PAGE_RES_IT page_res_it(page_res);
int total_length = 2;
// Iterate over the data structures to extract the recognition result.
for (page_res_it.restart_page(); page_res_it.word () != NULL;
page_res_it.forward()) {
WERD_RES *word = page_res_it.word();
WERD_CHOICE* choice = word->best_choice;
if (choice != NULL) {
total_length += choice->string().length() + 1;
for (int i = 0; i < word->reject_map.length(); ++i) {
if (word->reject_map[i].rejected())
++total_length;
}
}
}
return total_length;
}
// Returns an array of all word confidences, terminated by -1.
int* TessBaseAPI::AllTextConfidences(PAGE_RES* page_res) {
if (!page_res) 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;
}
// Returns the average word confidence for Tesseract page result.
int TessBaseAPI::TextConf(PAGE_RES* page_res) {
int* conf = AllTextConfidences(page_res);
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;
}
// Make a text string from the internal data structures.
// The input page_res is deleted.
char* TessBaseAPI::TesseractToText(PAGE_RES* page_res) {
if (page_res != NULL) {
int total_length = TextLength(page_res);
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();
WERD_CHOICE* choice = word->best_choice;
if (choice != NULL) {
strcpy(ptr, choice->string().string());
ptr += strlen(ptr);
if (word->word->flag(W_EOL))
*ptr++ = '\n';
else
*ptr++ = ' ';
}
}
*ptr++ = '\n';
*ptr = '\0';
delete page_res;
return result;
}
return NULL;
}
static int ConvertWordToBoxText(WERD_RES *word,
ROW_RES* row,
int left,
int bottom,
char* word_str) {
// Copy the output word and denormalize it back to image coords.
WERD copy_outword;
copy_outword = *(word->outword);
copy_outword.baseline_denormalise(&word->denorm);
PBLOB_IT blob_it;
blob_it.set_to_list(copy_outword.blob_list());
int length = copy_outword.blob_list()->length();
int output_size = 0;
if (length > 0) {
for (int index = 0, offset = 0; index < length;
offset += word->best_choice->lengths()[index++], blob_it.forward()) {
PBLOB* blob = blob_it.data();
TBOX blob_box = blob->bounding_box();
if (word->tess_failed ||
blob_box.left() < 0 ||
blob_box.right() > page_image.get_xsize() ||
blob_box.bottom() < 0 ||
blob_box.top() > page_image.get_ysize()) {
// Bounding boxes can be illegal when tess fails on a word.
blob_box = word->word->bounding_box(); // Use original word as backup.
tprintf("Using substitute bounding box at (%d,%d)->(%d,%d)\n",
blob_box.left(), blob_box.bottom(),
blob_box.right(), blob_box.top());
}
// A single classification unit can be composed of several UTF-8
// characters. Append each of them to the result.
for (int sub = 0; sub < word->best_choice->lengths()[index]; ++sub) {
char ch = word->best_choice->string()[offset + sub];
// Tesseract uses space for recognition failure. Fix to a reject
// character, '~' so we don't create illegal box files.
if (ch == ' ')
ch = '~';
word_str[output_size++] = ch;
}
sprintf(word_str + output_size, " %d %d %d %d\n",
blob_box.left() + left, blob_box.bottom() + bottom,
blob_box.right() + left, blob_box.top() + bottom);
output_size += strlen(word_str + output_size);
}
}
return output_size;
}
// Multiplier for textlength assumes 4 numbers @ 5 digits and a space
// plus the newline and the orginial character = 4*(5+1)+2
const int kMaxCharsPerChar = 26;
// Make a text string from the internal data structures.
// The input page_res is deleted.
// The text string takes the form of a box file as needed for training.
char* TessBaseAPI::TesseractToBoxText(PAGE_RES* page_res,
int left, int bottom) {
if (page_res != NULL) {
int total_length = TextLength(page_res) * kMaxCharsPerChar;
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();
ptr += ConvertWordToBoxText(word,page_res_it.row(),left, bottom, ptr);
}
*ptr = '\0';
delete page_res;
return result;
}
return NULL;
}
// Make a text string from the internal data structures.
// The input page_res is deleted. The text string is converted
// to UNLV-format: Latin-1 with specific reject and suspect codes.
const char kUnrecognized = '~';
// Conversion table for non-latin characters.
// Maps characters out of the latin set into the latin set.
// TODO(rays) incorporate this translation into unicharset.
const int kUniChs[] = {
0x20ac, 0x201c, 0x201d, 0x2018, 0x2019, 0x2022, 0x2014, 0
};
// Latin chars corresponding to the unicode chars above.
const int kLatinChs[] = {
0x00a2, 0x0022, 0x0022, 0x0027, 0x0027, 0x00b7, 0x002d, 0
};
char* TessBaseAPI::TesseractToUNLV(PAGE_RES* page_res) {
bool tilde_crunch_written = false;
bool last_char_was_newline = true;
bool last_char_was_tilde = false;
if (page_res != NULL) {
int total_length = TextLength(page_res);
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++ = kUnrecognized;
tilde_crunch_written = true;
last_char_was_newline = false;
}
}
} else {
// NORMAL PROCESSING of non tilde crunched words.
tilde_crunch_written = false;
if (last_char_was_tilde &&
word->word->space () == 0 &&
(word->best_choice->string ()[0] == ' ')) {
/* Prevent adjacent tilde across words - we know that adjacent tildes within
words have been removed */
char* p = (char *) word->best_choice->string().string ();
strcpy (p, p + 1); //shuffle up
p = (char *) word->best_choice->lengths().string ();
strcpy (p, p + 1); //shuffle up
word->reject_map.remove_pos (0);
PBLOB_IT blob_it = word->outword->blob_list ();
delete blob_it.extract (); //get rid of reject blob
}
if (word->word->flag(W_REP_CHAR) && tessedit_consistent_reps)
ensure_rep_chars_are_consistent(word);
set_unlv_suspects(word);
const char* wordstr = word->best_choice->string().string();
if (wordstr[0] != 0) {
if (!last_char_was_newline)
*ptr++ = ' ';
else
last_char_was_newline = false;
int offset = 0;
const STRING& lengths = word->best_choice->lengths();
int length = lengths.length();
for (int i = 0; i < length; offset += lengths[i++]) {
if (wordstr[offset] == ' ' ||
wordstr[offset] == '~' ||
wordstr[offset] == '|') {
*ptr++ = kUnrecognized;
last_char_was_tilde = true;
} else {
if (word->reject_map[i].rejected())
*ptr++ = '^';
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++ = kUnrecognized;
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';
delete page_res;
return result;
}
return NULL;
}
// ____________________________________________________________________________
// Ocropus add-ons.
// Find lines from the image making the BLOCK_LIST.
BLOCK_LIST* TessBaseAPI::FindLinesCreateBlockList() {
BLOCK_LIST *block_list = new BLOCK_LIST();
FindLines(block_list);
return block_list;
}
// Delete a block list.
// This is to keep BLOCK_LIST pointer opaque
// and let go of including the other headers.
void TessBaseAPI::DeleteBlockList(BLOCK_LIST *block_list) {
delete block_list;
}
static ROW *make_tess_ocrrow(float baseline,
float xheight,
float descender,
float ascender) {
inT32 xstarts[] = {-32000};
double quad_coeffs[] = {0,0,baseline};
return new ROW(1,
xstarts,
quad_coeffs,
xheight,
ascender - (baseline + xheight),
descender - baseline,
0,
0);
}
// Almost a copy of make_tess_row() from ccmain/tstruct.cpp.
static void fill_dummy_row(float baseline, float xheight,
float descender, float ascender,
TEXTROW* tessrow) {
tessrow->baseline.segments = 1;
tessrow->baseline.xstarts[0] = -32767;
tessrow->baseline.xstarts[1] = 32767;
tessrow->baseline.quads[0].a = 0;
tessrow->baseline.quads[0].b = 0;
tessrow->baseline.quads[0].c = bln_baseline_offset;
tessrow->xheight.segments = 1;
tessrow->xheight.xstarts[0] = -32767;
tessrow->xheight.xstarts[1] = 32767;
tessrow->xheight.quads[0].a = 0;
tessrow->xheight.quads[0].b = 0;
tessrow->xheight.quads[0].c = bln_baseline_offset + bln_x_height;
tessrow->lineheight = bln_x_height;
tessrow->ascrise = bln_x_height * (ascender - (xheight + baseline)) / xheight;
tessrow->descdrop = bln_x_height * (descender - baseline) / xheight;
}
/// Return a TBLOB * from the whole page_image.
/// To be freed later with free_blob().
TBLOB *make_tesseract_blob(float baseline, float xheight, float descender, float ascender) {
BLOCK *block = new BLOCK ("a character",
TRUE,
0, 0,
0, 0,
page_image.get_xsize(),
page_image.get_ysize());
// Create C_BLOBs from the page
extract_edges(NULL, &page_image, &page_image,
ICOORD(page_image.get_xsize(), page_image.get_ysize()),
block);
// Create one PBLOB from all C_BLOBs
C_BLOB_LIST *list = block->blob_list();
C_BLOB_IT c_blob_it(list);
PBLOB *pblob = new PBLOB; // will be (hopefully) deleted by the pblob_list
for (c_blob_it.mark_cycle_pt();
!c_blob_it.cycled_list();
c_blob_it.forward()) {
C_BLOB *c_blob = c_blob_it.data();
PBLOB c_as_p(c_blob, baseline + xheight);
merge_blobs(pblob, &c_as_p);
}
PBLOB_LIST *pblob_list = new PBLOB_LIST; // will be deleted by the word
PBLOB_IT pblob_it(pblob_list);
pblob_it.add_after_then_move(pblob);
// Normalize PBLOB
WERD word(pblob_list, 0, " ");
ROW *row = make_tess_ocrrow(baseline, xheight, descender, ascender);
word.baseline_normalise(row);
delete row;
// Create a TBLOB from PBLOB
return make_tess_blob(pblob, /* flatten: */ TRUE);
}
// Adapt to recognize the current image as the given character.
// The image must be preloaded and be just an image of a single character.
void TessBaseAPI::AdaptToCharacter(const char *unichar_repr,
int length,
float baseline,
float xheight,
float descender,
float ascender) {
UNICHAR_ID id = unicharset.unichar_to_id(unichar_repr, length);
LINE_STATS LineStats;
TEXTROW row;
fill_dummy_row(baseline, xheight, descender, ascender, &row);
GetLineStatsFromRow(&row, &LineStats);
TBLOB *blob = make_tesseract_blob(baseline, xheight, descender, ascender);
float threshold;
int best_class = 0;
float best_rating = -100;
// Classify to get a raw choice.
LIST result = AdaptiveClassifier(blob, NULL, &row);
LIST p;
for (p = result; p != NULL; p = p->next) {
A_CHOICE *tesschoice = (A_CHOICE *) p->node;
if (tesschoice->rating > best_rating) {
best_rating = tesschoice->rating;
best_class = tesschoice->string[0];
}
}
FLOAT32 GetBestRatingFor(TBLOB *Blob, LINE_STATS *LineStats, CLASS_ID ClassId);
// We have to use char-level adaptation because otherwise
// someone should do forced alignment somewhere.
void AdaptToChar(TBLOB *Blob,
LINE_STATS *LineStats,
CLASS_ID ClassId,
FLOAT32 Threshold);
if (id == best_class)
threshold = GoodAdaptiveMatch;
else {
/* the blob was incorrectly classified - find the rating threshold
needed to create a template which will correct the error with
some margin. However, don't waste time trying to make
templates which are too tight. */
threshold = GetBestRatingFor(blob, &LineStats, id);
threshold *= .9;
const float max_threshold = .125;
const float min_threshold = .02;
if (threshold > max_threshold)
threshold = max_threshold;
// I have cuddled the following line to set it out of the strike
// of the coverage testing tool. I have no idea how to trigger
// this situation nor I have any necessity to do it. --mezhirov
if (threshold < min_threshold) threshold = min_threshold;
}
if (blob->outlines)
AdaptToChar(blob, &LineStats, id, threshold);
free_blob(blob);
}
PAGE_RES* TessBaseAPI::RecognitionPass1(BLOCK_LIST* block_list) {
PAGE_RES *page_res = new PAGE_RES(block_list);
recog_all_words(page_res, NULL, NULL, 1);
return page_res;
}
PAGE_RES* TessBaseAPI::RecognitionPass2(BLOCK_LIST* block_list,
PAGE_RES* pass1_result) {
if (!pass1_result)
pass1_result = new PAGE_RES(block_list);
recog_all_words(pass1_result, NULL, NULL, 2);
return pass1_result;
}
struct TESS_CHAR : ELIST_LINK {
char *unicode_repr;
int length; // of unicode_repr
float cost;
TBOX box;
TESS_CHAR(float _cost, const char *repr, int len = -1) : cost(_cost) {
length = (len == -1 ? strlen(repr) : len);
unicode_repr = new char[length + 1];
strncpy(unicode_repr, repr, length);
}
~TESS_CHAR() {
delete unicode_repr;
}
};
static void add_space(ELIST_ITERATOR *it) {
TESS_CHAR *t = new TESS_CHAR(0, " ");
it->add_after_then_move(t);
}
static float rating_to_cost(float rating) {
rating = 100 + rating;
// cuddled that to save from coverage profiler
// (I have never seen ratings worse than -100,
// but the check won't hurt)
if (rating < 0) rating = 0;
return rating;
}
// Extract the OCR results, costs (penalty points for uncertainty),
// and the bounding boxes of the characters.
static void extract_result(ELIST_ITERATOR *out,
PAGE_RES* page_res) {
PAGE_RES_IT page_res_it(page_res);
int word_count = 0;
while (page_res_it.word() != NULL) {
WERD_RES *word = page_res_it.word();
const char *str = word->best_choice->string().string();
const char *len = word->best_choice->lengths().string();
if (word_count)
add_space(out);
TBOX bln_rect;
PBLOB_LIST *blobs = word->outword->blob_list();
PBLOB_IT it(blobs);
int n = strlen(len);
TBOX** boxes_to_fix = new TBOX*[n];
for (int i = 0; i < n; i++) {
PBLOB *blob = it.data();
TBOX current = blob->bounding_box();
bln_rect = bln_rect.bounding_union(current);
TESS_CHAR *tc = new TESS_CHAR(rating_to_cost(word->best_choice->rating()),
str, *len);
tc->box = current;
boxes_to_fix[i] = &tc->box;
out->add_after_then_move(tc);
it.forward();
str += *len;
len++;
}
// Find the word bbox before normalization.
// Here we can't use the C_BLOB bboxes directly,
// since connected letters are not yet cut.
TBOX real_rect = word->word->bounding_box();
// Denormalize boxes by transforming the bbox of the whole bln word
// into the denorm bbox (`real_rect') of the whole word.
double x_stretch = double(real_rect.width()) / bln_rect.width();
double y_stretch = double(real_rect.height()) / bln_rect.height();
for (int j = 0; j < n; j++) {
TBOX *box = boxes_to_fix[j];
int x0 = int(real_rect.left() +
x_stretch * (box->left() - bln_rect.left()) + 0.5);
int x1 = int(real_rect.left() +
x_stretch * (box->right() - bln_rect.left()) + 0.5);
int y0 = int(real_rect.bottom() +
y_stretch * (box->bottom() - bln_rect.bottom()) + 0.5);
int y1 = int(real_rect.bottom() +
y_stretch * (box->top() - bln_rect.bottom()) + 0.5);
*box = TBOX(ICOORD(x0, y0), ICOORD(x1, y1));
}
delete [] boxes_to_fix;
page_res_it.forward();
word_count++;
}
}
// Extract the OCR results, costs (penalty points for uncertainty),
// and the bounding boxes of the characters.
int TessBaseAPI::TesseractExtractResult(char** string,
int** lengths,
float** costs,
int** x0,
int** y0,
int** x1,
int** y1,
PAGE_RES* page_res) {
ELIST tess_chars;
ELIST_ITERATOR tess_chars_it(&tess_chars);
extract_result(&tess_chars_it, page_res);
tess_chars_it.move_to_first();
int n = tess_chars.length();
int string_len = 0;
*lengths = new int[n];
*costs = new float[n];
*x0 = new int[n];
*y0 = new int[n];
*x1 = new int[n];
*y1 = new int[n];
int i = 0;
for (tess_chars_it.mark_cycle_pt();
!tess_chars_it.cycled_list();
tess_chars_it.forward(), i++) {
TESS_CHAR *tc = (TESS_CHAR *) tess_chars_it.data();
string_len += (*lengths)[i] = tc->length;
(*costs)[i] = tc->cost;
(*x0)[i] = tc->box.left();
(*y0)[i] = tc->box.bottom();
(*x1)[i] = tc->box.right();
(*y1)[i] = tc->box.top();
}
char *p = *string = new char[string_len];
tess_chars_it.move_to_first();
for (tess_chars_it.mark_cycle_pt();
!tess_chars_it.cycled_list();
tess_chars_it.forward()) {
TESS_CHAR *tc = (TESS_CHAR *) tess_chars_it.data();
strncpy(p, tc->unicode_repr, tc->length);
p += tc->length;
}
return n;
}
// Check whether a word is valid according to Tesseract's language model
// returns 0 if the string is invalid, non-zero if valid
int TessBaseAPI::IsValidWord(const char *string) {
return valid_word(string);
}
Reference in New Issue View Git Blame Copy Permalink