tesseract::TessBaseAPI Class Reference

#include <baseapi.h>

Inheritance diagram for tesseract::TessBaseAPI:

Public Member Functions
	TessBaseAPI ()
virtual	~TessBaseAPI ()
	TessBaseAPI (TessBaseAPI const &)=delete
TessBaseAPI &	operator= (TessBaseAPI const &)=delete
void	SetInputName (const char *name)
const char *	GetInputName ()
void	SetInputImage (Pix *pix)
Pix *	GetInputImage ()
int	GetSourceYResolution ()
const char *	GetDatapath ()
void	SetOutputName (const char *name)
bool	SetVariable (const char *name, const char *value)
bool	SetDebugVariable (const char *name, const char *value)
bool	GetIntVariable (const char *name, int *value) const
bool	GetBoolVariable (const char *name, bool *value) const
bool	GetDoubleVariable (const char *name, double *value) const
const char *	GetStringVariable (const char *name) const
void	PrintFontsTable (FILE *fp) const
void	PrintVariables (FILE *fp) const
bool	GetVariableAsString (const char *name, std::string *val) const
int	Init (const char *datapath, const char *language, OcrEngineMode mode, char **configs, int configs_size, const std::vector< std::string > *vars_vec, const std::vector< std::string > *vars_values, bool set_only_non_debug_params)
int	Init (const char *datapath, const char *language, OcrEngineMode oem)
int	Init (const char *datapath, const char *language)
int	Init (const char *data, int data_size, const char *language, OcrEngineMode mode, char **configs, int configs_size, const std::vector< std::string > *vars_vec, const std::vector< std::string > *vars_values, bool set_only_non_debug_params, FileReader reader)
const char *	GetInitLanguagesAsString () const
void	GetLoadedLanguagesAsVector (std::vector< std::string > *langs) const
void	GetAvailableLanguagesAsVector (std::vector< std::string > *langs) const
void	InitForAnalysePage ()
void	ReadConfigFile (const char *filename)
void	ReadDebugConfigFile (const char *filename)
void	SetPageSegMode (PageSegMode mode)
PageSegMode	GetPageSegMode () const
char *	TesseractRect (const unsigned char *imagedata, int bytes_per_pixel, int bytes_per_line, int left, int top, int width, int height)
void	ClearAdaptiveClassifier ()
void	SetImage (const unsigned char *imagedata, int width, int height, int bytes_per_pixel, int bytes_per_line)
void	SetImage (Pix *pix)
void	SetSourceResolution (int ppi)
void	SetRectangle (int left, int top, int width, int height)
Pix *	GetThresholdedImage ()
Boxa *	GetRegions (Pixa **pixa)
Boxa *	GetTextlines (bool raw_image, int raw_padding, Pixa **pixa, int **blockids, int **paraids)
Boxa *	GetTextlines (Pixa **pixa, int **blockids)
Boxa *	GetStrips (Pixa **pixa, int **blockids)
Boxa *	GetWords (Pixa **pixa)
Boxa *	GetConnectedComponents (Pixa **cc)
Boxa *	GetComponentImages (PageIteratorLevel level, bool text_only, bool raw_image, int raw_padding, Pixa **pixa, int **blockids, int **paraids)
Boxa *	GetComponentImages (const PageIteratorLevel level, const bool text_only, Pixa **pixa, int **blockids)
int	GetThresholdedImageScaleFactor () const
PageIterator *	AnalyseLayout ()
PageIterator *	AnalyseLayout (bool merge_similar_words)
int	Recognize (ETEXT_DESC *monitor)
bool	ProcessPages (const char *filename, const char *retry_config, int timeout_millisec, TessResultRenderer *renderer)
bool	ProcessPagesInternal (const char *filename, const char *retry_config, int timeout_millisec, TessResultRenderer *renderer)
bool	ProcessPage (Pix *pix, int page_index, const char *filename, const char *retry_config, int timeout_millisec, TessResultRenderer *renderer)
ResultIterator *	GetIterator ()
MutableIterator *	GetMutableIterator ()
char *	GetUTF8Text ()
char *	GetHOCRText (ETEXT_DESC *monitor, int page_number)
char *	GetHOCRText (int page_number)
char *	GetAltoText (ETEXT_DESC *monitor, int page_number)
char *	GetAltoText (int page_number)
char *	GetTSVText (int page_number)
char *	GetLSTMBoxText (int page_number)
char *	GetBoxText (int page_number)
char *	GetWordStrBoxText (int page_number)
char *	GetUNLVText ()
bool	DetectOrientationScript (int *orient_deg, float *orient_conf, const char **script_name, float *script_conf)
char *	GetOsdText (int page_number)
int	MeanTextConf ()
int *	AllWordConfidences ()
bool	AdaptToWordStr (PageSegMode mode, const char *wordstr)
void	Clear ()
void	End ()
int	IsValidWord (const char *word) const
bool	IsValidCharacter (const char *utf8_character) const
bool	GetTextDirection (int *out_offset, float *out_slope)
void	SetDictFunc (DictFunc f)
void	SetProbabilityInContextFunc (ProbabilityInContextFunc f)
bool	DetectOS (OSResults *)
void	GetBlockTextOrientations (int **block_orientation, bool **vertical_writing)
const char *	GetUnichar (int unichar_id) const
const Dawg *	GetDawg (int i) const
int	NumDawgs () const
Tesseract *	tesseract () const
OcrEngineMode	oem () const
void	set_min_orientation_margin (double margin)

Static Public Member Functions
static const char *	Version ()
static size_t	getOpenCLDevice (void **device)
static void	ClearPersistentCache ()

Protected Member Functions
bool	InternalSetImage ()
virtual bool	Threshold (Pix **pix)
int	FindLines ()
void	ClearResults ()
LTRResultIterator *	GetLTRIterator ()
int	TextLength (int *blob_count) const
void	DetectParagraphs (bool after_text_recognition)
const PAGE_RES *	GetPageRes () const

Protected Attributes
Tesseract *	tesseract_
	The underlying data object. More...
Tesseract *	osd_tesseract_
	For orientation & script detection. More...
EquationDetect *	equ_detect_
	The equation detector. More...
FileReader	reader_
	Reads files from any filesystem. More...
ImageThresholder *	thresholder_
	Image thresholding module. More...
std::vector< ParagraphModel * > *	paragraph_models_
BLOCK_LIST *	block_list_
	The page layout. More...
PAGE_RES *	page_res_
	The page-level data. More...
std::string	input_file_
	Name used by training code. More...
std::string	output_file_
	Name used by debug code. More...
std::string	datapath_
	Current location of tessdata. More...
std::string	language_
	Last initialized language. More...
OcrEngineMode	last_oem_requested_
	Last ocr language mode requested. More...
bool	recognition_done_
	page_res_ contains recognition data. More...
int	rect_left_
int	rect_top_
int	rect_width_
int	rect_height_
int	image_width_
int	image_height_

Detailed Description

Base class for all tesseract APIs. Specific classes can add ability to work on different inputs or produce different outputs. This class is mostly an interface layer on top of the Tesseract instance class to hide the data types so that users of this class don't have to include any other Tesseract headers.

Definition at line 76 of file baseapi.h.

Constructor & Destructor Documentation

TessBaseAPI() [1/2]

tesseract::TessBaseAPI::TessBaseAPI

(

)

Definition at line 211 of file baseapi.cpp.

    : tesseract_(nullptr)
    , osd_tesseract_(nullptr)
    , equ_detect_(nullptr)
    , reader_(nullptr)
    ,
    // thresholder_ is initialized to nullptr here, but will be set before use
    // by: A constructor of a derived API or created
    // implicitly when used in InternalSetImage.
    thresholder_(nullptr)
    , paragraph_models_(nullptr)
    , block_list_(nullptr)
    , page_res_(nullptr)
    , last_oem_requested_(OEM_DEFAULT)
    , recognition_done_(false)
    , rect_left_(0)
    , rect_top_(0)
    , rect_width_(0)
    , rect_height_(0)
    , image_width_(0)
    , image_height_(0) {
}

~TessBaseAPI()

tesseract::TessBaseAPI::~TessBaseAPI ( )

virtual

Definition at line 234 of file baseapi.cpp.

                          {
  End();
}

TessBaseAPI() [2/2]

tesseract::TessBaseAPI::TessBaseAPI ( TessBaseAPI const &  )

delete

Member Function Documentation

AdaptToWordStr()

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 1835 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");
  const std::unique_ptr<const char[]> text(GetUTF8Text());
  if (debug) {
    tprintf("Trying to adapt \"%s\" to \"%s\"\n", text.get(), wordstr);
  }
  if (text != nullptr) {
    PAGE_RES_IT it(page_res_);
    WERD_RES *word_res = it.word();
    if (word_res != nullptr) {
      word_res->word->set_text(wordstr);
      // Check to see if text matches wordstr.
      int w = 0;
      int t;
      for (t = 0; text[t] != '\0'; ++t) {
        if (text[t] == '\n' || text[t] == ' ') {
          continue;
        }
        while (wordstr[w] == ' ') {
          ++w;
        }
        if (text[t] != wordstr[w]) {
          break;
        }
        ++w;
      }
      if (text[t] != '\0' || wordstr[w] != '\0') {
        // No match.
        delete page_res_;
        std::vector<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() == nullptr) {
          success = false;
        } else {
          word_res = pr_it.word();
        }
      } else {
        word_res->BestChoiceToCorrectText();
      }
      if (success) {
        tesseract_->EnableLearning = true;
        tesseract_->LearnWord(nullptr, word_res);
      }
    } else {
      success = false;
    }
  } else {
    success = false;
  }
  SetPageSegMode(current_psm);
  return success;
}

AllWordConfidences()

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 1795 of file baseapi.cpp.

                                     {
  if (tesseract_ == nullptr || (!recognition_done_ && Recognize(nullptr) < 0)) {
    return nullptr;
  }
  int n_word = 0;
  PAGE_RES_IT res_it(page_res_);
  for (res_it.restart_page(); res_it.word() != nullptr; res_it.forward()) {
    n_word++;
  }
 
  int *conf = new int[n_word + 1];
  n_word = 0;
  for (res_it.restart_page(); res_it.word() != nullptr; 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;
}

AnalyseLayout() [1/2]

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. If merge_similar_words is true, words are combined where suitable for use with a line recognizer. Use if you want to use AnalyseLayout to find the textlines, and then want to process textline fragments with an external line recognizer. Returns nullptr 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 812 of file baseapi.cpp.

                                         {
  return AnalyseLayout(false);
}

AnalyseLayout() [2/2]

PageIterator * tesseract::TessBaseAPI::AnalyseLayout

(

bool

merge_similar_words

)

Definition at line 816 of file baseapi.cpp.

                                                                 {
  if (FindLines() == 0) {
    if (block_list_->empty()) {
      return nullptr; // The page was empty.
    }
    page_res_ = new PAGE_RES(merge_similar_words, block_list_, nullptr);
    DetectParagraphs(false);
    return new PageIterator(page_res_, tesseract_, thresholder_->GetScaleFactor(),
                            thresholder_->GetScaledYResolution(), rect_left_, rect_top_,
                            rect_width_, rect_height_);
  }
  return nullptr;
}

Clear()

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 1903 of file baseapi.cpp.

                        {
  if (thresholder_ != nullptr) {
    thresholder_->Clear();
  }
  ClearResults();
  if (tesseract_ != nullptr) {
    SetInputImage(nullptr);
  }
}

ClearAdaptiveClassifier()

void tesseract::TessBaseAPI::ClearAdaptiveClassifier

(

)

Call between pages or documents etc to free up memory and forget adaptive data.

Definition at line 560 of file baseapi.cpp.

                                          {
  if (tesseract_ == nullptr) {
    return;
  }
  tesseract_->ResetAdaptiveClassifier();
  tesseract_->ResetDocumentDictionary();
}

ClearPersistentCache()

void tesseract::TessBaseAPI::ClearPersistentCache ( )

static

Clear any library-level memory caches. There are a variety of expensive-to-load constant data structures (mostly language dictionaries) that are cached globally – surviving the Init() and End() of individual TessBaseAPI's. This function allows the clearing of these caches.

Definition at line 1956 of file baseapi.cpp.

                                       {
  Dict::GlobalDawgCache()->DeleteUnusedDawgs();
}

ClearResults()

void tesseract::TessBaseAPI::ClearResults ( )

protected

Delete the pageres and block list ready for a new page.

Delete the pageres and clear the block list ready for a new page.

Definition at line 2205 of file baseapi.cpp.

                               {
  if (tesseract_ != nullptr) {
    tesseract_->Clear();
  }
  delete page_res_;
  page_res_ = nullptr;
  recognition_done_ = false;
  if (block_list_ == nullptr) {
    block_list_ = new BLOCK_LIST;
  } else {
    block_list_->clear();
  }
  if (paragraph_models_ != nullptr) {
    for (auto model : *paragraph_models_) {
      delete model;
    }
    delete paragraph_models_;
    paragraph_models_ = nullptr;
  }
}

DetectOrientationScript()

bool tesseract::TessBaseAPI::DetectOrientationScript	(	int *	orient_deg,
		float *	orient_conf,
		const char **	script_name,
		float *	script_conf
	)

Detect the orientation of the input image and apparent script (alphabet). orient_deg is the detected clockwise rotation of the input image in degrees (0, 90, 180, 270) orient_conf is the confidence (15.0 is reasonably confident) script_name is an ASCII string, the name of the script, e.g. "Latin" script_conf is confidence level in the script Returns true on success and writes values to each parameter as an output

Definition at line 1708 of file baseapi.cpp.

                                                                                        {
  OSResults osr;
 
  bool osd = DetectOS(&osr);
  if (!osd) {
    return false;
  }
 
  int orient_id = osr.best_result.orientation_id;
  int script_id = osr.get_best_script(orient_id);
  if (orient_conf) {
    *orient_conf = osr.best_result.oconfidence;
  }
  if (orient_deg) {
    *orient_deg = orient_id * 90; // convert quadrant to degrees
  }
 
  if (script_name) {
    const char *script = osr.unicharset->get_script_from_script_id(script_id);
 
    *script_name = script;
  }
 
  if (script_conf) {
    *script_conf = osr.best_result.sconfidence;
  }
 
  return true;
}

DetectOS()

bool tesseract::TessBaseAPI::DetectOS

(

OSResults *

osr

)

Estimates the Orientation And Script of the image.

Returns

true if the image was processed successfully.

Estimates the Orientation And Script of the image. Returns true if the image was processed successfully.

Definition at line 2266 of file baseapi.cpp.

                                         {
  if (tesseract_ == nullptr) {
    return false;
  }
  ClearResults();
  if (tesseract_->pix_binary() == nullptr && !Threshold(&tesseract_->mutable_pix_binary()->pix_)) {
    return false;
  }
 
  if (input_file_.empty()) {
    input_file_ = kInputFile;
  }
  return orientation_and_script_detection(input_file_.c_str(), osr, tesseract_) > 0;
}

DetectParagraphs()

void tesseract::TessBaseAPI::DetectParagraphs ( bool  after_text_recognition )

protected

Definition at line 2344 of file baseapi.cpp.

                                                              {
  int debug_level = 0;
  GetIntVariable("paragraph_debug_level", &debug_level);
  if (paragraph_models_ == nullptr) {
    paragraph_models_ = new std::vector<ParagraphModel *>;
  }
  MutableIterator *result_it = GetMutableIterator();
  do { // Detect paragraphs for this block
    std::vector<ParagraphModel *> models;
    ::tesseract::DetectParagraphs(debug_level, after_text_recognition, result_it, &models);
    paragraph_models_->insert(paragraph_models_->end(), models.begin(), models.end());
  } while (result_it->Next(RIL_BLOCK));
  delete result_it;
}

End()

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 1919 of file baseapi.cpp.

                      {
  Clear();
  delete thresholder_;
  thresholder_ = nullptr;
  delete page_res_;
  page_res_ = nullptr;
  delete block_list_;
  block_list_ = nullptr;
  if (paragraph_models_ != nullptr) {
    for (auto model : *paragraph_models_) {
      delete model;
    }
    delete paragraph_models_;
    paragraph_models_ = nullptr;
  }
#ifndef DISABLED_LEGACY_ENGINE
  if (osd_tesseract_ == tesseract_) {
    osd_tesseract_ = nullptr;
  }
  delete osd_tesseract_;
  osd_tesseract_ = nullptr;
  delete equ_detect_;
  equ_detect_ = nullptr;
#endif // ndef DISABLED_LEGACY_ENGINE
  delete tesseract_;
  tesseract_ = nullptr;
  input_file_.clear();
  output_file_.clear();
  datapath_.clear();
  language_.clear();
}

FindLines()

int tesseract::TessBaseAPI::FindLines ( )

protected

Find lines from the image making the BLOCK_LIST.

Returns

0 on success.

Find lines from the image making the BLOCK_LIST.

Definition at line 2128 of file baseapi.cpp.

                           {
  if (thresholder_ == nullptr || thresholder_->IsEmpty()) {
    tprintf("Please call SetImage before attempting recognition.\n");
    return -1;
  }
  if (recognition_done_) {
    ClearResults();
  }
  if (!block_list_->empty()) {
    return 0;
  }
  if (tesseract_ == nullptr) {
    tesseract_ = new Tesseract;
#ifndef DISABLED_LEGACY_ENGINE
    tesseract_->InitAdaptiveClassifier(nullptr);
#endif
  }
  if (tesseract_->pix_binary() == nullptr && !Threshold(&tesseract_->mutable_pix_binary()->pix_)) {
    return -1;
  }
 
  tesseract_->PrepareForPageseg();
 
#ifndef DISABLED_LEGACY_ENGINE
  if (tesseract_->textord_equation_detect) {
    if (equ_detect_ == nullptr && !datapath_.empty()) {
      equ_detect_ = new EquationDetect(datapath_.c_str(), nullptr);
    }
    if (equ_detect_ == nullptr) {
      tprintf("Warning: Could not set equation detector\n");
    } else {
      tesseract_->SetEquationDetect(equ_detect_);
    }
  }
#endif // ndef DISABLED_LEGACY_ENGINE
 
  Tesseract *osd_tess = osd_tesseract_;
  OSResults osr;
#ifndef DISABLED_LEGACY_ENGINE
  if (PSM_OSD_ENABLED(tesseract_->tessedit_pageseg_mode) && osd_tess == nullptr) {
    if (strcmp(language_.c_str(), "osd") == 0) {
      osd_tess = tesseract_;
    } else {
      osd_tesseract_ = new Tesseract;
      TessdataManager mgr(reader_);
      if (datapath_.empty()) {
        tprintf(
            "Warning: Auto orientation and script detection requested,"
            " but data path is undefined\n");
        delete osd_tesseract_;
        osd_tesseract_ = nullptr;
      } else if (osd_tesseract_->init_tesseract(datapath_, "", "osd", OEM_TESSERACT_ONLY,
                                                nullptr, 0, nullptr, nullptr, false, &mgr) == 0) {
        osd_tess = osd_tesseract_;
        osd_tesseract_->set_source_resolution(thresholder_->GetSourceYResolution());
      } else {
        tprintf(
            "Warning: Auto orientation and script detection requested,"
            " but osd language failed to load\n");
        delete osd_tesseract_;
        osd_tesseract_ = nullptr;
      }
    }
  }
#endif // ndef DISABLED_LEGACY_ENGINE
 
  if (tesseract_->SegmentPage(input_file_.c_str(), block_list_, osd_tess, &osr) < 0) {
    return -1;
  }
 
  // If Devanagari is being recognized, we use different images for page seg
  // and for OCR.
  tesseract_->PrepareForTessOCR(block_list_, osd_tess, &osr);
  return 0;
}

GetAltoText() [1/2]

char * tesseract::TessBaseAPI::GetAltoText	(	ETEXT_DESC *	monitor,
		int	page_number
	)

Make an XML-formatted string with Alto markup from the internal data structures.

Make an XML-formatted string with ALTO markup from the internal data structures.

Definition at line 137 of file altorenderer.cpp.

                                                                   {
  if (tesseract_ == nullptr || (page_res_ == nullptr && Recognize(monitor) < 0)) {
    return nullptr;
  }
 
  int lcnt = 0, tcnt = 0, bcnt = 0, wcnt = 0;
 
  if (input_file_.empty()) {
    SetInputName(nullptr);
  }
 
#ifdef _WIN32
  // convert input name from ANSI encoding to utf-8
  int str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_.c_str(), -1, nullptr, 0);
  wchar_t *uni16_str = new WCHAR[str16_len];
  str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_.c_str(), -1, uni16_str, str16_len);
  int utf8_len =
      WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, nullptr, 0, nullptr, nullptr);
  char *utf8_str = new char[utf8_len];
  WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, utf8_str, utf8_len, nullptr, nullptr);
  input_file_ = utf8_str;
  delete[] uni16_str;
  delete[] utf8_str;
#endif
 
  std::stringstream alto_str;
  // Use "C" locale (needed for int values larger than 999).
  alto_str.imbue(std::locale::classic());
  alto_str << "\t\t<Page WIDTH=\"" << rect_width_ << "\" HEIGHT=\"" << rect_height_
           << "\" PHYSICAL_IMG_NR=\"" << page_number << "\""
           << " ID=\"page_" << page_number << "\">\n"
           << "\t\t\t<PrintSpace HPOS=\"0\" VPOS=\"0\""
           << " WIDTH=\"" << rect_width_ << "\""
           << " HEIGHT=\"" << rect_height_ << "\">\n";
 
  ResultIterator *res_it = GetIterator();
  while (!res_it->Empty(RIL_BLOCK)) {
    if (res_it->Empty(RIL_WORD)) {
      res_it->Next(RIL_WORD);
      continue;
    }
 
    int left, top, right, bottom;
    auto block_type = res_it->BlockType();
 
    switch (block_type) {
      case PT_FLOWING_IMAGE:
      case PT_HEADING_IMAGE:
      case PT_PULLOUT_IMAGE: {
        // Handle all kinds of images.
        // TODO: optionally add TYPE, for example TYPE="photo".
        alto_str << "\t\t\t\t<Illustration ID=\"cblock_" << bcnt++ << "\"";
        AddBoxToAlto(res_it, RIL_BLOCK, alto_str);
        alto_str << "</Illustration>\n";
        res_it->Next(RIL_BLOCK);
        continue;
      }
      case PT_HORZ_LINE:
      case PT_VERT_LINE:
        // Handle horizontal and vertical lines.
        alto_str << "\t\t\t\t<GraphicalElement ID=\"cblock_" << bcnt++ << "\"";
        AddBoxToAlto(res_it, RIL_BLOCK, alto_str);
        alto_str << "</GraphicalElement >\n";
        res_it->Next(RIL_BLOCK);
        continue;
      case PT_NOISE:
        tprintf("TODO: Please report image which triggers the noise case.\n");
        ASSERT_HOST(false);
      default:
        break;
    }
 
    if (res_it->IsAtBeginningOf(RIL_BLOCK)) {
      alto_str << "\t\t\t\t<ComposedBlock ID=\"cblock_" << bcnt << "\"";
      AddBoxToAlto(res_it, RIL_BLOCK, alto_str);
      alto_str << "\n";
    }
 
    if (res_it->IsAtBeginningOf(RIL_PARA)) {
      alto_str << "\t\t\t\t\t<TextBlock ID=\"block_" << tcnt << "\"";
      AddBoxToAlto(res_it, RIL_PARA, alto_str);
      alto_str << "\n";
    }
 
    if (res_it->IsAtBeginningOf(RIL_TEXTLINE)) {
      alto_str << "\t\t\t\t\t\t<TextLine ID=\"line_" << lcnt << "\"";
      AddBoxToAlto(res_it, RIL_TEXTLINE, alto_str);
      alto_str << "\n";
    }
 
    alto_str << "\t\t\t\t\t\t\t<String ID=\"string_" << wcnt << "\"";
    AddBoxToAlto(res_it, RIL_WORD, alto_str);
    alto_str << " CONTENT=\"";
 
    bool last_word_in_line = res_it->IsAtFinalElement(RIL_TEXTLINE, RIL_WORD);
    bool last_word_in_tblock = res_it->IsAtFinalElement(RIL_PARA, RIL_WORD);
    bool last_word_in_cblock = res_it->IsAtFinalElement(RIL_BLOCK, RIL_WORD);
 
    res_it->BoundingBox(RIL_WORD, &left, &top, &right, &bottom);
 
    do {
      const std::unique_ptr<const char[]> grapheme(res_it->GetUTF8Text(RIL_SYMBOL));
      if (grapheme && grapheme[0] != 0) {
        alto_str << HOcrEscape(grapheme.get()).c_str();
      }
      res_it->Next(RIL_SYMBOL);
    } while (!res_it->Empty(RIL_BLOCK) && !res_it->IsAtBeginningOf(RIL_WORD));
 
    alto_str << "\"/>";
 
    wcnt++;
 
    if (last_word_in_line) {
      alto_str << "\n\t\t\t\t\t\t</TextLine>\n";
      lcnt++;
    } else {
      int hpos = right;
      int vpos = top;
      res_it->BoundingBox(RIL_WORD, &left, &top, &right, &bottom);
      int width = left - hpos;
      alto_str << "<SP WIDTH=\"" << width << "\" VPOS=\"" << vpos << "\" HPOS=\"" << hpos
               << "\"/>\n";
    }
 
    if (last_word_in_tblock) {
      alto_str << "\t\t\t\t\t</TextBlock>\n";
      tcnt++;
    }
 
    if (last_word_in_cblock) {
      alto_str << "\t\t\t\t</ComposedBlock>\n";
      bcnt++;
    }
  }
 
  alto_str << "\t\t\t</PrintSpace>\n"
           << "\t\t</Page>\n";
  const std::string &text = alto_str.str();
 
  char *result = new char[text.length() + 1];
  strcpy(result, text.c_str());
  delete res_it;
  return result;
}

GetAltoText() [2/2]

char * tesseract::TessBaseAPI::GetAltoText

(

int

page_number

)

Make an XML-formatted string with Alto markup from the internal data structures.

Make an XML-formatted string with ALTO markup from the internal data structures.

Definition at line 129 of file altorenderer.cpp.

                                              {
  return GetAltoText(nullptr, page_number);
}

GetAvailableLanguagesAsVector()

void tesseract::TessBaseAPI::GetAvailableLanguagesAsVector

(

std::vector< std::string > *

langs

)

const

Returns the available languages in the sorted vector of std::string.

Definition at line 471 of file baseapi.cpp.

                                                                                 {
  langs->clear();
  if (tesseract_ != nullptr) {
    addAvailableLanguages(tesseract_->datadir, "", langs);
    std::sort(langs->begin(), langs->end());
  }
}

GetBlockTextOrientations()

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 2300 of file baseapi.cpp.

                                                                                           {
  delete[] * block_orientation;
  *block_orientation = nullptr;
  delete[] * vertical_writing;
  *vertical_writing = nullptr;
  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()->pdblk.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()->pdblk.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 / M_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;
  }
}

GetBoolVariable()

bool tesseract::TessBaseAPI::GetBoolVariable	(	const char *	name,
		bool *	value
	)		const

Definition at line 304 of file baseapi.cpp.

                                                                     {
  auto *p = ParamUtils::FindParam<BoolParam>(name, GlobalParams()->bool_params,
                                             tesseract_->params()->bool_params);
  if (p == nullptr) {
    return false;
  }
  *value = bool(*p);
  return true;
}

GetBoxText()

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. 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. Returned string must be freed with the delete [] operator.

The recognized text is returned as a char* which is coded as a UTF8 box file. page_number is a 0-base page index that will appear in the box file. Returned string must be freed with the delete [] operator.

Definition at line 1552 of file baseapi.cpp.

                                             {
  if (tesseract_ == nullptr || (!recognition_done_ && Recognize(nullptr) < 0)) {
    return nullptr;
  }
  int blob_count;
  int utf8_length = TextLength(&blob_count);
  int total_length = blob_count * kBytesPerBoxFileLine + utf8_length + kMaxBytesPerLine;
  char *result = new char[total_length];
  result[0] = '\0';
  int output_length = 0;
  LTRResultIterator *it = GetLTRIterator();
  do {
    int left, top, right, bottom;
    if (it->BoundingBox(RIL_SYMBOL, &left, &top, &right, &bottom)) {
      const std::unique_ptr</*non-const*/ 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.get(), left, image_height_ - bottom, right, image_height_ - top, page_number);
      output_length += strlen(result + output_length);
      // Just in case...
      if (output_length + kMaxBytesPerLine > total_length) {
        break;
      }
    }
  } while (it->Next(RIL_SYMBOL));
  delete it;
  return result;
}

GetComponentImages() [1/2]

Boxa * tesseract::TessBaseAPI::GetComponentImages ( const PageIteratorLevel  level, const bool  text_only, Pixa **  pixa, int **  blockids  )

inline

Definition at line 419 of file baseapi.h.

                                                        {
    return GetComponentImages(level, text_only, false, 0, pixa, blockids,
                              nullptr);
  }

GetComponentImages() [2/2]

Boxa * tesseract::TessBaseAPI::GetComponentImages	(	PageIteratorLevel	level,
		bool	text_only,
		bool	raw_image,
		int	raw_padding,
		Pixa **	pixa,
		int **	blockids,
		int **	paraids
	)

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 nullptr, the block-id of each component is also returned as an array of one element per component. delete [] after use. If blockids is not nullptr, the paragraph-id of each component with its block is also returned as an array of one element per component. delete [] after use. If raw_image is true, then portions of the original image are extracted instead of the thresholded image and padded with raw_padding. If text_only is true, then only text components are returned.

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 nullptr, 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 702 of file baseapi.cpp.

                                                     {
  /*non-const*/ std::unique_ptr</*non-const*/ PageIterator> page_it(GetIterator());
  if (page_it == nullptr) {
    page_it.reset(AnalyseLayout());
  }
  if (page_it == nullptr) {
    return nullptr; // Failed.
  }
 
  // Count the components to get a size for the arrays.
  int component_count = 0;
  int left, top, right, bottom;
 
  if (raw_image) {
    // Get bounding box in original raw image with padding.
    do {
      if (page_it->BoundingBox(level, raw_padding, &left, &top, &right, &bottom) &&
          (!text_only || PTIsTextType(page_it->BlockType()))) {
        ++component_count;
      }
    } while (page_it->Next(level));
  } else {
    // Get bounding box from binarized imaged. Note that this could be
    // differently scaled from the original image.
    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 != nullptr) {
    *pixa = pixaCreate(component_count);
  }
  if (blockids != nullptr) {
    *blockids = new int[component_count];
  }
  if (paraids != nullptr) {
    *paraids = new int[component_count];
  }
 
  int blockid = 0;
  int paraid = 0;
  int component_index = 0;
  page_it->Begin();
  do {
    bool got_bounding_box;
    if (raw_image) {
      got_bounding_box = page_it->BoundingBox(level, raw_padding, &left, &top, &right, &bottom);
    } else {
      got_bounding_box = page_it->BoundingBoxInternal(level, &left, &top, &right, &bottom);
    }
    if (got_bounding_box && (!text_only || PTIsTextType(page_it->BlockType()))) {
      Box *lbox = boxCreate(left, top, right - left, bottom - top);
      boxaAddBox(boxa, lbox, L_INSERT);
      if (pixa != nullptr) {
        Pix *pix = nullptr;
        if (raw_image) {
          pix = page_it->GetImage(level, raw_padding, GetInputImage(), &left, &top);
        } else {
          pix = page_it->GetBinaryImage(level);
        }
        pixaAddPix(*pixa, pix, L_INSERT);
        pixaAddBox(*pixa, lbox, L_CLONE);
      }
      if (paraids != nullptr) {
        (*paraids)[component_index] = paraid;
        if (page_it->IsAtFinalElement(RIL_PARA, level)) {
          ++paraid;
        }
      }
      if (blockids != nullptr) {
        (*blockids)[component_index] = blockid;
        if (page_it->IsAtFinalElement(RIL_BLOCK, level)) {
          ++blockid;
          paraid = 0;
        }
      }
      ++component_index;
    }
  } while (page_it->Next(level));
  return boxa;
}

GetConnectedComponents()

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 690 of file baseapi.cpp.

                                                     {
  return GetComponentImages(RIL_SYMBOL, true, pixa, nullptr);
}

GetDatapath()

const char * tesseract::TessBaseAPI::GetDatapath

(

)

Definition at line 935 of file baseapi.cpp.

                                     {
  return tesseract_->datadir.c_str();
}

GetDawg()

const Dawg * tesseract::TessBaseAPI::GetDawg

(

int

i

)

const

Return the pointer to the i-th dawg loaded into tesseract_ object.

Definition at line 2365 of file baseapi.cpp.

                                            {
  if (tesseract_ == nullptr || i >= NumDawgs()) {
    return nullptr;
  }
  return tesseract_->getDict().GetDawg(i);
}

GetDoubleVariable()

bool tesseract::TessBaseAPI::GetDoubleVariable	(	const char *	name,
		double *	value
	)		const

Definition at line 320 of file baseapi.cpp.

                                                                         {
  auto *p = ParamUtils::FindParam<DoubleParam>(name, GlobalParams()->double_params,
                                               tesseract_->params()->double_params);
  if (p == nullptr) {
    return false;
  }
  *value = (double)(*p);
  return true;
}

GetHOCRText() [1/2]

char * tesseract::TessBaseAPI::GetHOCRText	(	ETEXT_DESC *	monitor,
		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. monitor can be used to cancel the recognition receive progress callbacks Returned string must be freed with the delete [] operator.

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. Returned string must be freed with the delete [] operator.

Definition at line 134 of file hocrrenderer.cpp.

                                                                   {
  if (tesseract_ == nullptr ||
      (page_res_ == nullptr && Recognize(monitor) < 0)) {
    return nullptr;
  }
 
  int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1, scnt = 1, tcnt = 1, ccnt = 1;
  int page_id = page_number + 1; // hOCR uses 1-based page numbers.
  bool para_is_ltr = true;       // Default direction is LTR
  const char *paragraph_lang = nullptr;
  bool font_info = false;
  bool hocr_boxes = false;
  GetBoolVariable("hocr_font_info", &font_info);
  GetBoolVariable("hocr_char_boxes", &hocr_boxes);
 
  if (input_file_.empty()) {
    SetInputName(nullptr);
  }
 
#ifdef _WIN32
  // convert input name from ANSI encoding to utf-8
  int str16_len =
      MultiByteToWideChar(CP_ACP, 0, input_file_.c_str(), -1, nullptr, 0);
  wchar_t *uni16_str = new WCHAR[str16_len];
  str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_.c_str(), -1, uni16_str,
                                  str16_len);
  int utf8_len = WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, nullptr,
                                     0, nullptr, nullptr);
  char *utf8_str = new char[utf8_len];
  WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, utf8_str, utf8_len,
                      nullptr, nullptr);
  input_file_ = utf8_str;
  delete[] uni16_str;
  delete[] utf8_str;
#endif
 
  std::stringstream hocr_str;
  // Use "C" locale (needed for double values x_size and x_descenders).
  hocr_str.imbue(std::locale::classic());
  // Use 8 digits for double values.
  hocr_str.precision(8);
  hocr_str << "  <div class='ocr_page'"
           << " id='"
           << "page_" << page_id << "'"
           << " title='image \"";
  if (!input_file_.empty()) {
    hocr_str << HOcrEscape(input_file_.c_str());
  } else {
    hocr_str << "unknown";
  }
 
  hocr_str << "\"; bbox " << rect_left_ << " " << rect_top_ << " "
           << rect_width_ << " " << rect_height_ << "; ppageno " << page_number
           << "; scan_res " << GetSourceYResolution() << " "
           << GetSourceYResolution() << "'>\n";
 
  std::unique_ptr<ResultIterator> res_it(GetIterator());
  while (!res_it->Empty(RIL_BLOCK)) {
    int left, top, right, bottom;
    auto block_type = res_it->BlockType();
    switch (block_type) {
      case PT_FLOWING_IMAGE:
      case PT_HEADING_IMAGE:
      case PT_PULLOUT_IMAGE: {
        // Handle all kinds of images.
        res_it.get()->BoundingBox(RIL_TEXTLINE, &left, &top, &right, &bottom);
        hocr_str << "   <div class='ocr_photo' id='block_" << page_id << '_'
                 << bcnt++ << "' title=\"bbox " << left << " " << top << " "
                 << right << " " << bottom << "\"></div>\n";
        res_it->Next(RIL_BLOCK);
        continue;
      }
      case PT_HORZ_LINE:
      case PT_VERT_LINE:
        // Handle horizontal and vertical lines.
        res_it.get()->BoundingBox(RIL_TEXTLINE, &left, &top, &right, &bottom);
        hocr_str << "   <div class='ocr_separator' id='block_" << page_id << '_'
                 << bcnt++ << "' title=\"bbox " << left << " " << top << " "
                 << right << " " << bottom << "\"></div>\n";
        res_it->Next(RIL_BLOCK);
        continue;
      case PT_NOISE:
        tprintf("TODO: Please report image which triggers the noise case.\n");
        ASSERT_HOST(false);
      default:
        break;
    }
 
    if (res_it->Empty(RIL_WORD)) {
      res_it->Next(RIL_WORD);
      continue;
    }
 
    // Open any new block/paragraph/textline.
    if (res_it->IsAtBeginningOf(RIL_BLOCK)) {
      para_is_ltr = true; // reset to default direction
      hocr_str << "   <div class='ocr_carea'"
               << " id='"
               << "block_" << page_id << "_" << bcnt << "'";
      AddBoxTohOCR(res_it.get(), RIL_BLOCK, hocr_str);
    }
    if (res_it->IsAtBeginningOf(RIL_PARA)) {
      hocr_str << "\n    <p class='ocr_par'";
      para_is_ltr = res_it->ParagraphIsLtr();
      if (!para_is_ltr) {
        hocr_str << " dir='rtl'";
      }
      hocr_str << " id='"
               << "par_" << page_id << "_" << pcnt << "'";
      paragraph_lang = res_it->WordRecognitionLanguage();
      if (paragraph_lang) {
        hocr_str << " lang='" << paragraph_lang << "'";
      }
      AddBoxTohOCR(res_it.get(), RIL_PARA, hocr_str);
    }
    if (res_it->IsAtBeginningOf(RIL_TEXTLINE)) {
      hocr_str << "\n     <span class='";
      switch (block_type) {
        case PT_HEADING_TEXT:
          hocr_str << "ocr_header";
          break;
        case PT_PULLOUT_TEXT:
          hocr_str << "ocr_textfloat";
          break;
        case PT_CAPTION_TEXT:
          hocr_str << "ocr_caption";
          break;
        case PT_FLOWING_IMAGE:
        case PT_HEADING_IMAGE:
        case PT_PULLOUT_IMAGE:
          ASSERT_HOST(false);
          break;
        default:
          hocr_str << "ocr_line";
      }
      hocr_str << "' id='"
               << "line_" << page_id << "_" << lcnt << "'";
      AddBoxTohOCR(res_it.get(), RIL_TEXTLINE, hocr_str);
    }
 
    // Now, process the word...
    int32_t lstm_choice_mode = tesseract_->lstm_choice_mode;
    std::vector<std::vector<std::vector<std::pair<const char *, float>>>>
        *rawTimestepMap = nullptr;
    std::vector<std::vector<std::pair<const char *, float>>> *CTCMap = nullptr;
    if (lstm_choice_mode) {
      CTCMap = res_it->GetBestLSTMSymbolChoices();
      rawTimestepMap = res_it->GetRawLSTMTimesteps();
    }
    hocr_str << "\n      <span class='ocrx_word'"
             << " id='"
             << "word_" << page_id << "_" << wcnt << "'";
    bool bold, italic, underlined, monospace, serif, smallcaps;
    int pointsize, font_id;
    res_it->BoundingBox(RIL_WORD, &left, &top, &right, &bottom);
    const char *font_name =
        res_it->WordFontAttributes(&bold, &italic, &underlined, &monospace,
                                   &serif, &smallcaps, &pointsize, &font_id);
    hocr_str << " title='bbox " << left << " " << top << " " << right << " "
             << bottom << "; x_wconf "
             << static_cast<int>(res_it->Confidence(RIL_WORD));
    if (font_info) {
      if (font_name) {
        hocr_str << "; x_font " << HOcrEscape(font_name).c_str();
      }
      hocr_str << "; x_fsize " << pointsize;
    }
    hocr_str << "'";
    const char *lang = res_it->WordRecognitionLanguage();
    if (lang && (!paragraph_lang || strcmp(lang, paragraph_lang))) {
      hocr_str << " lang='" << lang << "'";
    }
    switch (res_it->WordDirection()) {
      // Only emit direction if different from current paragraph direction
      case DIR_LEFT_TO_RIGHT:
        if (!para_is_ltr) {
          hocr_str << " dir='ltr'";
        }
        break;
      case DIR_RIGHT_TO_LEFT:
        if (para_is_ltr) {
          hocr_str << " dir='rtl'";
        }
        break;
      case DIR_MIX:
      case DIR_NEUTRAL:
      default: // Do nothing.
        break;
    }
    hocr_str << ">";
    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 std::unique_ptr<const char[]> grapheme(
          res_it->GetUTF8Text(RIL_SYMBOL));
      if (grapheme && grapheme[0] != 0) {
        if (hocr_boxes) {
          res_it->BoundingBox(RIL_SYMBOL, &left, &top, &right, &bottom);
          hocr_str << "\n       <span class='ocrx_cinfo' title='x_bboxes "
                   << left << " " << top << " " << right << " " << bottom
                   << "; x_conf " << res_it->Confidence(RIL_SYMBOL) << "'>";
        }
        hocr_str << HOcrEscape(grapheme.get()).c_str();
        if (hocr_boxes) {
          hocr_str << "</span>";
          tesseract::ChoiceIterator ci(*res_it);
          if (lstm_choice_mode == 1 && ci.Timesteps() != nullptr) {
            std::vector<std::vector<std::pair<const char *, float>>> *symbol =
                ci.Timesteps();
            hocr_str << "\n        <span class='ocr_symbol'"
                     << " id='"
                     << "symbol_" << page_id << "_" << wcnt << "_" << scnt
                     << "'>";
            for (const auto &timestep : *symbol) {
              hocr_str << "\n         <span class='ocrx_cinfo'"
                       << " id='"
                       << "timestep" << page_id << "_" << wcnt << "_" << tcnt
                       << "'>";
              for (auto conf : timestep) {
                hocr_str << "\n          <span class='ocrx_cinfo'"
                         << " id='"
                         << "choice_" << page_id << "_" << wcnt << "_" << ccnt
                         << "'"
                         << " title='x_confs " << int(conf.second * 100) << "'>"
                         << HOcrEscape(conf.first).c_str() << "</span>";
                ++ccnt;
              }
              hocr_str << "</span>";
              ++tcnt;
            }
            hocr_str << "\n        </span>";
            ++scnt;
          } else if (lstm_choice_mode == 2) {
            hocr_str << "\n        <span class='ocrx_cinfo'"
                     << " id='"
                     << "lstm_choices_" << page_id << "_" << wcnt << "_" << tcnt
                     << "'>";
            do {
              const char *choice = ci.GetUTF8Text();
              float choiceconf = ci.Confidence();
              if (choice != nullptr) {
                hocr_str << "\n         <span class='ocrx_cinfo'"
                         << " id='"
                         << "choice_" << page_id << "_" << wcnt << "_" << ccnt
                         << "'"
                         << " title='x_confs " << choiceconf << "'>"
                         << HOcrEscape(choice).c_str() << "</span>";
                ccnt++;
              }
            } while (ci.Next());
            hocr_str << "\n        </span>";
            tcnt++;
          }
        }
      }
      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>";
    }
    // If the lstm choice mode is required it is added here
    if (lstm_choice_mode == 1 && !hocr_boxes && rawTimestepMap != nullptr) {
      for (const auto &symbol : *rawTimestepMap) {
        hocr_str << "\n       <span class='ocr_symbol'"
                 << " id='"
                 << "symbol_" << page_id << "_" << wcnt << "_" << scnt << "'>";
        for (const auto &timestep : symbol) {
          hocr_str << "\n        <span class='ocrx_cinfo'"
                   << " id='"
                   << "timestep" << page_id << "_" << wcnt << "_" << tcnt
                   << "'>";
          for (auto &&conf : timestep) {
            hocr_str << "\n         <span class='ocrx_cinfo'"
                     << " id='"
                     << "choice_" << page_id << "_" << wcnt << "_" << ccnt
                     << "'"
                     << " title='x_confs " << int(conf.second * 100) << "'>"
                     << HOcrEscape(conf.first).c_str() << "</span>";
            ++ccnt;
          }
          hocr_str << "</span>";
          ++tcnt;
        }
        hocr_str << "</span>";
        ++scnt;
      }
    } else if (lstm_choice_mode == 2 && !hocr_boxes && CTCMap != nullptr) {
      for (const auto &timestep : *CTCMap) {
        if (timestep.size() > 0) {
          hocr_str << "\n       <span class='ocrx_cinfo'"
                   << " id='"
                   << "lstm_choices_" << page_id << "_" << wcnt << "_" << tcnt
                   << "'>";
          for (auto &j : timestep) {
            float conf = 100 - tesseract_->lstm_rating_coefficient * j.second;
            if (conf < 0.0f) {
              conf = 0.0f;
            }
            if (conf > 100.0f) {
              conf = 100.0f;
            }
            hocr_str << "\n        <span class='ocrx_cinfo'"
                     << " id='"
                     << "choice_" << page_id << "_" << wcnt << "_" << ccnt
                     << "'"
                     << " title='x_confs " << conf << "'>"
                     << HOcrEscape(j.first).c_str() << "</span>";
            ccnt++;
          }
          hocr_str << "</span>";
          tcnt++;
        }
      }
    }
    // Close ocrx_word.
    if (hocr_boxes || lstm_choice_mode > 0) {
      hocr_str << "\n      ";
    }
    hocr_str << "</span>";
    tcnt = 1;
    ccnt = 1;
    wcnt++;
    // Close any ending block/paragraph/textline.
    if (last_word_in_line) {
      hocr_str << "\n     </span>";
      lcnt++;
    }
    if (last_word_in_para) {
      hocr_str << "\n    </p>\n";
      pcnt++;
      para_is_ltr = true; // back to default direction
    }
    if (last_word_in_block) {
      hocr_str << "   </div>\n";
      bcnt++;
    }
  }
  hocr_str << "  </div>\n";
 
  const std::string &text = hocr_str.str();
  char *result = new char[text.length() + 1];
  strcpy(result, text.c_str());
  return result;
}

GetHOCRText() [2/2]

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. Returned string must be freed with the delete [] operator.

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. Returned string must be freed with the delete [] operator.

Definition at line 121 of file hocrrenderer.cpp.

                                              {
  return GetHOCRText(nullptr, page_number);
}

GetInitLanguagesAsString()

const char * tesseract::TessBaseAPI::GetInitLanguagesAsString

(

)

const

Returns the languages string used in the last valid initialization. If the last initialization specified "deu+hin" then that will be returned. If hin loaded eng automatically as well, then that will not be included in this list. To find the languages actually loaded use GetLoadedLanguagesAsVector. The returned string should NOT be deleted.

Definition at line 448 of file baseapi.cpp.

                                                        {
  return language_.c_str();
}

GetInputImage()

Pix * tesseract::TessBaseAPI::GetInputImage

(

)

Definition at line 924 of file baseapi.cpp.

                                {
  return tesseract_->pix_original();
}

GetInputName()

const char * tesseract::TessBaseAPI::GetInputName

(

)

These functions are required for searchable PDF output. We need our hands on the input file so that we can include it in the PDF without transcoding. If that is not possible, we need the original image. Finally, resolution metadata is stored in the PDF so we need that as well.

Definition at line 928 of file baseapi.cpp.

                                      {
  if (!input_file_.empty()) {
    return input_file_.c_str();
  }
  return nullptr;
}

GetIntVariable()

bool tesseract::TessBaseAPI::GetIntVariable	(	const char *	name,
		int *	value
	)		const

Returns true if the parameter was found among Tesseract parameters. Fills in value with the value of the parameter.

Definition at line 294 of file baseapi.cpp.

                                                                   {
  auto *p = ParamUtils::FindParam<IntParam>(name, GlobalParams()->int_params,
                                            tesseract_->params()->int_params);
  if (p == nullptr) {
    return false;
  }
  *value = (int32_t)(*p);
  return true;
}

GetIterator()

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 1337 of file baseapi.cpp.

                                         {
  if (tesseract_ == nullptr || page_res_ == nullptr) {
    return nullptr;
  }
  return ResultIterator::StartOfParagraph(LTRResultIterator(
      page_res_, tesseract_, thresholder_->GetScaleFactor(), thresholder_->GetScaledYResolution(),
      rect_left_, rect_top_, rect_width_, rect_height_));
}

GetLoadedLanguagesAsVector()

void tesseract::TessBaseAPI::GetLoadedLanguagesAsVector

(

std::vector< std::string > *

langs

)

const

Returns the loaded languages in the vector of std::string. Includes all languages loaded by the last Init, including those loaded as dependencies of other loaded languages.

Definition at line 457 of file baseapi.cpp.

                                                                              {
  langs->clear();
  if (tesseract_ != nullptr) {
    langs->push_back(tesseract_->lang);
    int num_subs = tesseract_->num_sub_langs();
    for (int i = 0; i < num_subs; ++i) {
      langs->push_back(tesseract_->get_sub_lang(i)->lang);
    }
  }
}

GetLSTMBoxText()

char * tesseract::TessBaseAPI::GetLSTMBoxText

(

int

page_number = 0

)

Make a box file for LSTM training from the internal data structures. 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. Returned string must be freed with the delete [] operator.

Definition at line 38 of file lstmboxrenderer.cpp.

                                                     {
  if (tesseract_ == nullptr || (page_res_ == nullptr && Recognize(nullptr) < 0)) {
    return nullptr;
  }
 
  std::string lstm_box_str;
  bool first_word = true;
  int left = 0, top = 0, right = 0, bottom = 0;
 
  LTRResultIterator *res_it = GetLTRIterator();
  while (!res_it->Empty(RIL_BLOCK)) {
    if (res_it->Empty(RIL_SYMBOL)) {
      res_it->Next(RIL_SYMBOL);
      continue;
    }
    if (!first_word) {
      if (!(res_it->IsAtBeginningOf(RIL_TEXTLINE))) {
        if (res_it->IsAtBeginningOf(RIL_WORD)) {
          lstm_box_str += "  " + std::to_string(left);
          AddBoxToLSTM(right, bottom, top, image_height_, page_number, lstm_box_str);
          lstm_box_str += "\n"; // end of row for word
        }                       // word
      } else {
        if (res_it->IsAtBeginningOf(RIL_TEXTLINE)) {
          lstm_box_str += "\t " + std::to_string(left);
          AddBoxToLSTM(right, bottom, top, image_height_, page_number, lstm_box_str);
          lstm_box_str += "\n"; // end of row for line
        }                       // line
      }
    } // not first word
    first_word = false;
    // Use bounding box for whole line for everything
    res_it->BoundingBox(RIL_TEXTLINE, &left, &top, &right, &bottom);
    do {
      lstm_box_str += std::unique_ptr<const char[]>(res_it->GetUTF8Text(RIL_SYMBOL)).get();
      res_it->Next(RIL_SYMBOL);
    } while (!res_it->Empty(RIL_BLOCK) && !res_it->IsAtBeginningOf(RIL_SYMBOL));
    lstm_box_str += " " + std::to_string(left);
    AddBoxToLSTM(right, bottom, top, image_height_, page_number, lstm_box_str);
    lstm_box_str += "\n"; // end of row for symbol
  }
  if (!first_word) { // if first_word is true  => empty page
    lstm_box_str += "\t " + std::to_string(left);
    AddBoxToLSTM(right, bottom, top, image_height_, page_number, lstm_box_str);
    lstm_box_str += "\n"; // end of PAGE
  }
  char *ret = new char[lstm_box_str.length() + 1];
  strcpy(ret, lstm_box_str.c_str());
  delete res_it;
  return ret;
}

GetLTRIterator()

LTRResultIterator * tesseract::TessBaseAPI::GetLTRIterator ( )

protected

Return an LTR Result Iterator – used only for training, as we really want to ignore all BiDi smarts at that point. delete once you're done with it.

Get a left-to-right iterator to the results of LayoutAnalysis and/or Recognize. The returned iterator must be deleted after use.

Definition at line 1320 of file baseapi.cpp.

                                               {
  if (tesseract_ == nullptr || page_res_ == nullptr) {
    return nullptr;
  }
  return new LTRResultIterator(page_res_, tesseract_, thresholder_->GetScaleFactor(),
                               thresholder_->GetScaledYResolution(), rect_left_, rect_top_,
                               rect_width_, rect_height_);
}

GetMutableIterator()

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 1354 of file baseapi.cpp.

                                                 {
  if (tesseract_ == nullptr || page_res_ == nullptr) {
    return nullptr;
  }
  return new MutableIterator(page_res_, tesseract_, thresholder_->GetScaleFactor(),
                             thresholder_->GetScaledYResolution(), rect_left_, rect_top_,
                             rect_width_, rect_height_);
}

getOpenCLDevice()

size_t tesseract::TessBaseAPI::getOpenCLDevice ( void **  data )

static

If compiled with OpenCL AND an available OpenCL device is deemed faster than serial code, then "device" is populated with the cl_device_id and returns sizeof(cl_device_id) otherwise *device=nullptr and returns 0.

Definition at line 252 of file baseapi.cpp.

                                               {
#ifdef USE_OPENCL
  ds_device device = OpenclDevice::getDeviceSelection();
  if (device.type == DS_DEVICE_OPENCL_DEVICE) {
    *data = new cl_device_id;
    memcpy(*data, &device.oclDeviceID, sizeof(cl_device_id));
    return sizeof(cl_device_id);
  }
#endif
 
  *data = nullptr;
  return 0;
}

GetOsdText()

char * tesseract::TessBaseAPI::GetOsdText

(

int

page_number

)

The recognized text is returned as a char* which is coded as UTF8 and must be freed with the delete [] operator. page_number is a 0-based page index that will appear in the osd file.

Definition at line 1744 of file baseapi.cpp.

                                             {
  int orient_deg;
  float orient_conf;
  const char *script_name;
  float script_conf;
 
  if (!DetectOrientationScript(&orient_deg, &orient_conf, &script_name, &script_conf)) {
    return nullptr;
  }
 
  // clockwise rotation needed to make the page upright
  int rotate = OrientationIdToValue(orient_deg / 90);
 
  std::stringstream stream;
  // Use "C" locale (needed for float values orient_conf and script_conf).
  stream.imbue(std::locale::classic());
  // Use fixed notation with 2 digits after the decimal point for float values.
  stream.precision(2);
  stream << std::fixed << "Page number: " << page_number << "\n"
         << "Orientation in degrees: " << orient_deg << "\n"
         << "Rotate: " << rotate << "\n"
         << "Orientation confidence: " << orient_conf << "\n"
         << "Script: " << script_name << "\n"
         << "Script confidence: " << script_conf << "\n";
  const std::string &text = stream.str();
  char *result = new char[text.length() + 1];
  strcpy(result, text.c_str());
  return result;
}

GetPageRes()

const PAGE_RES * tesseract::TessBaseAPI::GetPageRes ( ) const

inlineprotected

Definition at line 760 of file baseapi.h.

                                     {
    return page_res_;
  }

GetPageSegMode()

PageSegMode tesseract::TessBaseAPI::GetPageSegMode

(

)

const

Return the current page segmentation mode.

Definition at line 519 of file baseapi.cpp.

                                              {
  if (tesseract_ == nullptr) {
    return PSM_SINGLE_BLOCK;
  }
  return static_cast<PageSegMode>(static_cast<int>(tesseract_->tessedit_pageseg_mode));
}

GetRegions()

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 646 of file baseapi.cpp.

                                         {
  return GetComponentImages(RIL_BLOCK, false, pixa, nullptr);
}

GetSourceYResolution()

int tesseract::TessBaseAPI::GetSourceYResolution

(

)

Definition at line 939 of file baseapi.cpp.

                                      {
  if (thresholder_ == nullptr)
    return -1;
  return thresholder_->GetSourceYResolution();
}

GetStringVariable()

const char * tesseract::TessBaseAPI::GetStringVariable

(

const char *

name

)

const

Returns the pointer to the string that represents the value of the parameter if it was found among Tesseract parameters.

Definition at line 314 of file baseapi.cpp.

                                                                 {
  auto *p = ParamUtils::FindParam<StringParam>(name, GlobalParams()->string_params,
                                               tesseract_->params()->string_params);
  return (p != nullptr) ? p->c_str() : nullptr;
}

GetStrips()

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 nullptr, the block-id of each line is also returned as an array of one element per line. delete [] after use.

Definition at line 671 of file baseapi.cpp.

                                                        {
  return GetComponentImages(RIL_TEXTLINE, false, pixa, blockids);
}

GetTextDirection()

bool tesseract::TessBaseAPI::GetTextDirection	(	int *	out_offset,
		float *	out_slope
	)

Definition at line 1974 of file baseapi.cpp.

                                                                    {
  const std::unique_ptr<const PageIterator> it(AnalyseLayout());
  if (it == nullptr) {
    return false;
  }
  int x1, x2, y1, y2;
  it->Baseline(RIL_TEXTLINE, &x1, &y1, &x2, &y2);
  // Calculate offset and slope (NOTE: Kind of ugly)
  if (x2 <= x1) {
    x2 = x1 + 1;
  }
  // Convert the point pair to slope/offset of the baseline (in image coords.)
  *out_slope = static_cast<float>(y2 - y1) / (x2 - x1);
  *out_offset = static_cast<int>(y1 - *out_slope * x1);
  // Get the y-coord of the baseline at the left and right edges of the
  // textline's bounding box.
  int left, top, right, bottom;
  if (!it->BoundingBox(RIL_TEXTLINE, &left, &top, &right, &bottom)) {
    return false;
  }
  int left_y = IntCastRounded(*out_slope * left + *out_offset);
  int right_y = IntCastRounded(*out_slope * right + *out_offset);
  // Shift the baseline down so it passes through the nearest bottom-corner
  // of the textline's bounding box. This is the difference between the y
  // at the lowest (max) edge of the box and the actual box bottom.
  *out_offset += bottom - std::max(left_y, right_y);
  // Switch back to bottom-up tesseract coordinates. Requires negation of
  // the slope and height - offset for the offset.
  *out_slope = -*out_slope;
  *out_offset = rect_height_ - *out_offset;
 
  return true;
}

GetTextlines() [1/2]

Boxa * tesseract::TessBaseAPI::GetTextlines	(	bool	raw_image,
		int	raw_padding,
		Pixa **	pixa,
		int **	blockids,
		int **	paraids
	)

Get the textlines as a leptonica-style Boxa, Pixa pair, in reading order. Can be called before or after Recognize. If raw_image is true, then extract from the original image instead of the thresholded image and pad by raw_padding pixels. If blockids is not nullptr, the block-id of each line is also returned as an array of one element per line. delete [] after use. If paraids is not nullptr, the paragraph-id of each line within its block is also returned as an array of one element per line. delete [] after use.

Get the textlines as a leptonica-style Boxa, Pixa pair, in reading order. Can be called before or after Recognize. If blockids is not nullptr, the block-id of each line is also returned as an array of one element per line. delete [] after use. If paraids is not nullptr, the paragraph-id of each line within its block is also returned as an array of one element per line. delete [] after use.

Definition at line 658 of file baseapi.cpp.

                                                               {
  return GetComponentImages(RIL_TEXTLINE, true, raw_image, raw_padding, pixa, blockids, paraids);
}

GetTextlines() [2/2]

Boxa * tesseract::TessBaseAPI::GetTextlines ( Pixa **  pixa, int **  blockids  )

inline

Definition at line 372 of file baseapi.h.

                                                  {
    return GetTextlines(false, 0, pixa, blockids, nullptr);
  }

GetThresholdedImage()

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 after SetImage if you have Leptonica installed. Get a copy of the internal thresholded image from Tesseract.

Definition at line 631 of file baseapi.cpp.

                                      {
  if (tesseract_ == nullptr || thresholder_ == nullptr) {
    return nullptr;
  }
  if (tesseract_->pix_binary() == nullptr && !Threshold(&tesseract_->mutable_pix_binary()->pix_)) {
    return nullptr;
  }
  return tesseract_->pix_binary().clone();
}

GetThresholdedImageScaleFactor()

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 790 of file baseapi.cpp.

                                                      {
  if (thresholder_ == nullptr) {
    return 0;
  }
  return thresholder_->GetScaleFactor();
}

GetTSVText()

char * tesseract::TessBaseAPI::GetTSVText

(

int

page_number

)

Make a TSV-formatted string from the internal data structures. page_number is 0-based but will appear in the output as 1-based. Returned string must be freed with the delete [] operator.

Definition at line 1412 of file baseapi.cpp.

                                             {
  if (tesseract_ == nullptr || (page_res_ == nullptr && Recognize(nullptr) < 0)) {
    return nullptr;
  }
 
  int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1;
  int page_id = page_number + 1; // we use 1-based page numbers.
 
  int page_num = page_id;
  int block_num = 0;
  int par_num = 0;
  int line_num = 0;
  int word_num = 0;
 
  std::string tsv_str;
  tsv_str += "1\t" + std::to_string(page_num); // level 1 - page
  tsv_str += "\t" + std::to_string(block_num);
  tsv_str += "\t" + std::to_string(par_num);
  tsv_str += "\t" + std::to_string(line_num);
  tsv_str += "\t" + std::to_string(word_num);
  tsv_str += "\t" + std::to_string(rect_left_);
  tsv_str += "\t" + std::to_string(rect_top_);
  tsv_str += "\t" + std::to_string(rect_width_);
  tsv_str += "\t" + std::to_string(rect_height_);
  tsv_str += "\t-1\t\n";
 
  const std::unique_ptr</*non-const*/ ResultIterator> res_it(GetIterator());
  while (!res_it->Empty(RIL_BLOCK)) {
    if (res_it->Empty(RIL_WORD)) {
      res_it->Next(RIL_WORD);
      continue;
    }
 
    // Add rows for any new block/paragraph/textline.
    if (res_it->IsAtBeginningOf(RIL_BLOCK)) {
      block_num++;
      par_num = 0;
      line_num = 0;
      word_num = 0;
      tsv_str += "2\t" + std::to_string(page_num); // level 2 - block
      tsv_str += "\t" + std::to_string(block_num);
      tsv_str += "\t" + std::to_string(par_num);
      tsv_str += "\t" + std::to_string(line_num);
      tsv_str += "\t" + std::to_string(word_num);
      AddBoxToTSV(res_it.get(), RIL_BLOCK, tsv_str);
      tsv_str += "\t-1\t\n"; // end of row for block
    }
    if (res_it->IsAtBeginningOf(RIL_PARA)) {
      par_num++;
      line_num = 0;
      word_num = 0;
      tsv_str += "3\t" + std::to_string(page_num); // level 3 - paragraph
      tsv_str += "\t" + std::to_string(block_num);
      tsv_str += "\t" + std::to_string(par_num);
      tsv_str += "\t" + std::to_string(line_num);
      tsv_str += "\t" + std::to_string(word_num);
      AddBoxToTSV(res_it.get(), RIL_PARA, tsv_str);
      tsv_str += "\t-1\t\n"; // end of row for para
    }
    if (res_it->IsAtBeginningOf(RIL_TEXTLINE)) {
      line_num++;
      word_num = 0;
      tsv_str += "4\t" + std::to_string(page_num); // level 4 - line
      tsv_str += "\t" + std::to_string(block_num);
      tsv_str += "\t" + std::to_string(par_num);
      tsv_str += "\t" + std::to_string(line_num);
      tsv_str += "\t" + std::to_string(word_num);
      AddBoxToTSV(res_it.get(), RIL_TEXTLINE, tsv_str);
      tsv_str += "\t-1\t\n"; // end of row for line
    }
 
    // Now, process the word...
    int left, top, right, bottom;
    res_it->BoundingBox(RIL_WORD, &left, &top, &right, &bottom);
    word_num++;
    tsv_str += "5\t" + std::to_string(page_num); // level 5 - word
    tsv_str += "\t" + std::to_string(block_num);
    tsv_str += "\t" + std::to_string(par_num);
    tsv_str += "\t" + std::to_string(line_num);
    tsv_str += "\t" + std::to_string(word_num);
    tsv_str += "\t" + std::to_string(left);
    tsv_str += "\t" + std::to_string(top);
    tsv_str += "\t" + std::to_string(right - left);
    tsv_str += "\t" + std::to_string(bottom - top);
    tsv_str += "\t" + std::to_string(res_it->Confidence(RIL_WORD));
    tsv_str += "\t";
 
    // Increment counts if at end of block/paragraph/textline.
    if (res_it->IsAtFinalElement(RIL_TEXTLINE, RIL_WORD)) {
      lcnt++;
    }
    if (res_it->IsAtFinalElement(RIL_PARA, RIL_WORD)) {
      pcnt++;
    }
    if (res_it->IsAtFinalElement(RIL_BLOCK, RIL_WORD)) {
      bcnt++;
    }
 
    do {
      tsv_str += std::unique_ptr<const char[]>(res_it->GetUTF8Text(RIL_SYMBOL)).get();
      res_it->Next(RIL_SYMBOL);
    } while (!res_it->Empty(RIL_BLOCK) && !res_it->IsAtBeginningOf(RIL_WORD));
    tsv_str += "\n"; // end of row
    wcnt++;
  }
 
  char *ret = new char[tsv_str.length() + 1];
  strcpy(ret, tsv_str.c_str());
  return ret;
}

GetUnichar()

const char * tesseract::TessBaseAPI::GetUnichar

(

int

unichar_id

)

const

This method returns the string form of the specified unichar.

Definition at line 2360 of file baseapi.cpp.

                                                        {
  return tesseract_->unicharset.id_to_unichar(unichar_id);
}

GetUNLVText()

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. Returned string must be freed with the delete [] operator.

Definition at line 1601 of file baseapi.cpp.

                               {
  if (tesseract_ == nullptr || (!recognition_done_ && Recognize(nullptr) < 0)) {
    return nullptr;
  }
  bool tilde_crunch_written = false;
  bool last_char_was_newline = true;
  bool last_char_was_tilde = false;
 
  int total_length = TextLength(nullptr);
  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() != nullptr; 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 preceding 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().c_str();
      const auto &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;
}

GetUTF8Text()

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 1364 of file baseapi.cpp.

                               {
  if (tesseract_ == nullptr || (!recognition_done_ && Recognize(nullptr) < 0)) {
    return nullptr;
  }
  std::string text("");
  const std::unique_ptr</*non-const*/ ResultIterator> it(GetIterator());
  do {
    if (it->Empty(RIL_PARA)) {
      continue;
    }
    auto block_type = it->BlockType();
    switch (block_type) {
      case PT_FLOWING_IMAGE:
      case PT_HEADING_IMAGE:
      case PT_PULLOUT_IMAGE:
      case PT_HORZ_LINE:
      case PT_VERT_LINE:
        // Ignore images and lines for text output.
        continue;
      case PT_NOISE:
        tprintf("TODO: Please report image which triggers the noise case.\n");
        ASSERT_HOST(false);
      default:
        break;
    }
 
    const std::unique_ptr<const char[]> para_text(it->GetUTF8Text(RIL_PARA));
    text += para_text.get();
  } while (it->Next(RIL_PARA));
  char *result = new char[text.length() + 1];
  strncpy(result, text.c_str(), text.length() + 1);
  return result;
}

GetVariableAsString()

bool tesseract::TessBaseAPI::GetVariableAsString	(	const char *	name,
		std::string *	val
	)		const

Get value of named variable as a string, if it exists.

Definition at line 331 of file baseapi.cpp.

                                                                            {
  return ParamUtils::GetParamAsString(name, tesseract_->params(), val);
}

GetWords()

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 680 of file baseapi.cpp.

                                       {
  return GetComponentImages(RIL_WORD, true, pixa, nullptr);
}

GetWordStrBoxText()

char * tesseract::TessBaseAPI::GetWordStrBoxText

(

int

page_number = 0

)

The recognized text is returned as a char* which is coded in the same format as a WordStr box file used in training. page_number is a 0-based page index that will appear in the box file. Returned string must be freed with the delete [] operator.

Create a UTF8 box file with WordStr strings from the internal data structures. page_number is a 0-base page index that will appear in the box file. Returned string must be freed with the delete [] operator.

Definition at line 31 of file wordstrboxrenderer.cpp.

                                                        {
  if (tesseract_ == nullptr || (page_res_ == nullptr && Recognize(nullptr) < 0)) {
    return nullptr;
  }
 
  std::string wordstr_box_str;
  int left = 0, top = 0, right = 0, bottom = 0;
 
  bool first_line = true;
 
  LTRResultIterator *res_it = GetLTRIterator();
  while (!res_it->Empty(RIL_BLOCK)) {
    if (res_it->Empty(RIL_WORD)) {
      res_it->Next(RIL_WORD);
      continue;
    }
 
    if (res_it->IsAtBeginningOf(RIL_TEXTLINE)) {
      if (!first_line) {
        wordstr_box_str += "\n\t " + std::to_string(right + 1);
        wordstr_box_str += " " + std::to_string(image_height_ - bottom);
        wordstr_box_str += " " + std::to_string(right + 5);
        wordstr_box_str += " " + std::to_string(image_height_ - top);
        wordstr_box_str += " " + std::to_string(page_number); // row for tab for EOL
        wordstr_box_str += "\n";
      } else {
        first_line = false;
      }
      // Use bounding box for whole line for WordStr
      res_it->BoundingBox(RIL_TEXTLINE, &left, &top, &right, &bottom);
      wordstr_box_str += "WordStr " + std::to_string(left);
      wordstr_box_str += " " + std::to_string(image_height_ - bottom);
      wordstr_box_str += " " + std::to_string(right);
      wordstr_box_str += " " + std::to_string(image_height_ - top);
      wordstr_box_str += " " + std::to_string(page_number); // word
      wordstr_box_str += " #";
    }
    do {
      wordstr_box_str += std::unique_ptr<const char[]>(res_it->GetUTF8Text(RIL_WORD)).get();
      wordstr_box_str += " ";
      res_it->Next(RIL_WORD);
    } while (!res_it->Empty(RIL_BLOCK) && !res_it->IsAtBeginningOf(RIL_WORD));
  }
 
  if (left != 0 && top != 0 && right != 0 && bottom != 0) {
    wordstr_box_str += "\n\t " + std::to_string(right + 1);
    wordstr_box_str += " " + std::to_string(image_height_ - bottom);
    wordstr_box_str += " " + std::to_string(right + 5);
    wordstr_box_str += " " + std::to_string(image_height_ - top);
    wordstr_box_str += " " + std::to_string(page_number); // row for tab for EOL
    wordstr_box_str += "\n";
  }
  char *ret = new char[wordstr_box_str.length() + 1];
  strcpy(ret, wordstr_box_str.c_str());
  delete res_it;
  return ret;
}

Init() [1/4]

int tesseract::TessBaseAPI::Init	(	const char *	data,
		int	data_size,
		const char *	language,
		OcrEngineMode	mode,
		char **	configs,
		int	configs_size,
		const std::vector< std::string > *	vars_vec,
		const std::vector< std::string > *	vars_values,
		bool	set_only_non_debug_params,
		FileReader	reader
	)

Definition at line 378 of file baseapi.cpp.

                                         {
  if (language == nullptr) {
    language = "";
  }
  if (data == nullptr) {
    data = "";
  }
  std::string datapath = data_size == 0 ? data : language;
  // If the datapath, OcrEngineMode or the language have changed - start again.
  // Note that the language_ field stores the last requested language that was
  // initialized successfully, while tesseract_->lang stores the language
  // actually used. They differ only if the requested language was nullptr, in
  // which case tesseract_->lang is set to the Tesseract default ("eng").
  if (tesseract_ != nullptr &&
      (datapath_.empty() || language_.empty() || datapath_ != datapath ||
       last_oem_requested_ != oem || (language_ != language && tesseract_->lang != language))) {
    delete tesseract_;
    tesseract_ = nullptr;
  }
#ifdef USE_OPENCL
  OpenclDevice od;
  od.InitEnv();
#endif
  bool reset_classifier = true;
  if (tesseract_ == nullptr) {
    reset_classifier = false;
    tesseract_ = new Tesseract;
    if (reader != nullptr) {
      reader_ = reader;
    }
    TessdataManager mgr(reader_);
    if (data_size != 0) {
      mgr.LoadMemBuffer(language, data, data_size);
    }
    if (tesseract_->init_tesseract(datapath, output_file_, language, oem, configs,
                                   configs_size, vars_vec, vars_values, set_only_non_debug_params,
                                   &mgr) != 0) {
      return -1;
    }
  }
 
  // Update datapath and language requested for the last valid initialization.
  datapath_ = datapath;
  if (datapath_.empty() && !tesseract_->datadir.empty()) {
    datapath_ = tesseract_->datadir;
  }
 
  language_ = language;
  last_oem_requested_ = oem;
 
#ifndef DISABLED_LEGACY_ENGINE
  // For same language and datapath, just reset the adaptive classifier.
  if (reset_classifier) {
    tesseract_->ResetAdaptiveClassifier();
  }
#endif // ndef DISABLED_LEGACY_ENGINE
  return 0;
}

Init() [2/4]

int tesseract::TessBaseAPI::Init ( const char *  datapath, const char *  language  )

inline

Definition at line 214 of file baseapi.h.

                                                       {
    return Init(datapath, language, OEM_DEFAULT, nullptr, 0, nullptr, nullptr,
                false);
  }

Init() [3/4]

int tesseract::TessBaseAPI::Init	(	const char *	datapath,
		const char *	language,
		OcrEngineMode	oem,
		char **	configs,
		int	configs_size,
		const std::vector< std::string > *	vars_vec,
		const std::vector< std::string > *	vars_values,
		bool	set_only_non_debug_params
	)

Instances are now mostly thread-safe and totally independent, but some global parameters remain. Basically it is safe to use multiple TessBaseAPIs in different threads in parallel, UNLESS: you use SetVariable on some of the Params in classify and textord. If you do, then the effect will be to change it for all your instances.

Start tesseract. Returns zero on success and -1 on failure. NOTE that the only members that may be called before Init are those listed above here in the class definition.

The datapath must be the name of the tessdata directory. The language is (usually) an ISO 639-3 string or nullptr will default to eng. It is entirely safe (and eventually will be efficient too) to call Init multiple times on the same instance to change language, or just to reset the classifier. The language may be a string of the form [~]<lang>[+[~]<lang>]* indicating that multiple languages are to be loaded. Eg hin+eng will load Hindi and English. Languages may specify internally that they want to be loaded with one or more other languages, so the ~ sign is available to override that. Eg if hin were set to load eng by default, then hin+~eng would force loading only hin. The number of loaded languages is limited only by memory, with the caveat that loading additional languages will impact both speed and accuracy, as there is more work to do to decide on the applicable language, and there is more chance of hallucinating incorrect words. WARNING: On changing languages, all Tesseract parameters are reset back to their default values. (Which may vary between languages.) If you have a rare need to set a Variable that controls initialization for a second call to Init you should explicitly call End() and then use SetVariable before Init. This is only a very rare use case, since there are very few uses that require any parameters to be set before Init.

If set_only_non_debug_params is true, only params that do not contain "debug" in the name will be set.

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 language is (usually) an ISO 639-3 string or nullptr will default to eng. If numeric_mode is true, then only digits and Roman numerals will be returned.

Returns

: 0 on success and -1 on initialization failure.

Definition at line 368 of file baseapi.cpp.

                                                                                               {
  return Init(datapath, 0, language, oem, configs, configs_size, vars_vec, vars_values,
              set_only_non_debug_params, nullptr);
}

Init() [4/4]

int tesseract::TessBaseAPI::Init ( const char *  datapath, const char *  language, OcrEngineMode  oem  )

inline

Definition at line 211 of file baseapi.h.

                                                                          {
    return Init(datapath, language, oem, nullptr, 0, nullptr, nullptr, false);
  }

InitForAnalysePage()

void tesseract::TessBaseAPI::InitForAnalysePage

(

)

Init only for page layout analysis. Use only for calls to SetImage and AnalysePage. Calls that attempt recognition will generate an error.

Definition at line 483 of file baseapi.cpp.

                                     {
  if (tesseract_ == nullptr) {
    tesseract_ = new Tesseract;
#ifndef DISABLED_LEGACY_ENGINE
    tesseract_->InitAdaptiveClassifier(nullptr);
#endif
  }
}

InternalSetImage()

bool tesseract::TessBaseAPI::InternalSetImage ( )

protected

Common code for setting the image. Returns true if Init has been called.

Common code for setting the image.

Definition at line 2035 of file baseapi.cpp.

                                   {
  if (tesseract_ == nullptr) {
    tprintf("Please call Init before attempting to set an image.\n");
    return false;
  }
  if (thresholder_ == nullptr) {
    thresholder_ = new ImageThresholder;
  }
  ClearResults();
  return true;
}

IsValidCharacter()

bool tesseract::TessBaseAPI::IsValidCharacter

(

const char *

utf8_character

)

const

Definition at line 1968 of file baseapi.cpp.

                                                                   {
  return tesseract_->unicharset.contains_unichar(utf8_character);
}

IsValidWord()

int tesseract::TessBaseAPI::IsValidWord

(

const char *

word

)

const

Check whether a word is valid according to Tesseract's language model

Returns

0 if the word is invalid, non-zero if valid.

Warning

temporary! This function will be removed from here and placed in a separate API at some future time.

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 1964 of file baseapi.cpp.

                                                   {
  return tesseract_->getDict().valid_word(word);
}

MeanTextConf()

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 1777 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;
}

NumDawgs()

int tesseract::TessBaseAPI::NumDawgs

(

)

const

Return the number of dawgs loaded into tesseract_ object.

Definition at line 2373 of file baseapi.cpp.

                                {
  return tesseract_ == nullptr ? 0 : tesseract_->getDict().NumDawgs();
}

oem()

OcrEngineMode tesseract::TessBaseAPI::oem ( ) const

inline

Definition at line 715 of file baseapi.h.

                            {
    return last_oem_requested_;
  }

operator=()

TessBaseAPI & tesseract::TessBaseAPI::operator= ( TessBaseAPI const &  )

delete

PrintFontsTable()

void tesseract::TessBaseAPI::PrintFontsTable

(

FILE *

fp

)

const

Print Tesseract fonts table to the given file.

Definition at line 338 of file baseapi.cpp.

                                                {
  const int fontinfo_size = tesseract_->get_fontinfo_table().size();
  for (int font_index = 1; font_index < fontinfo_size; ++font_index) {
    FontInfo font = tesseract_->get_fontinfo_table().at(font_index);
    fprintf(fp, "ID=%3d: %s is_italic=%s is_bold=%s"
                " is_fixed_pitch=%s is_serif=%s is_fraktur=%s\n",
                font_index, font.name,
                font.is_italic() ? "true" : "false",
                font.is_bold() ? "true" : "false",
                font.is_fixed_pitch() ? "true" : "false",
                font.is_serif() ? "true" : "false",
                font.is_fraktur() ? "true" : "false");
  }
}

PrintVariables()

void tesseract::TessBaseAPI::PrintVariables

(

FILE *

fp

)

const

Print Tesseract parameters to the given file.

Definition at line 356 of file baseapi.cpp.

                                               {
  ParamUtils::PrintParams(fp, tesseract_->params());
}

ProcessPage()

bool tesseract::TessBaseAPI::ProcessPage	(	Pix *	pix,
		int	page_index,
		const char *	filename,
		const char *	retry_config,
		int	timeout_millisec,
		TessResultRenderer *	renderer
	)

Turn a single image into symbolic text.

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.

See ProcessPages for descriptions of other parameters.

Definition at line 1253 of file baseapi.cpp.

                                                            {
  SetInputName(filename);
  SetImage(pix);
  bool failed = false;
 
  if (tesseract_->tessedit_pageseg_mode == PSM_AUTO_ONLY) {
    // Disabled character recognition
    if (! std::unique_ptr<const PageIterator>(AnalyseLayout())) {
      failed = true;
    }
  } else if (tesseract_->tessedit_pageseg_mode == PSM_OSD_ONLY) {
    failed = FindLines() != 0;
  } else if (timeout_millisec > 0) {
    // Running with a timeout.
    ETEXT_DESC monitor;
    monitor.cancel = nullptr;
    monitor.cancel_this = nullptr;
    monitor.set_deadline_msecs(timeout_millisec);
 
    // Now run the main recognition.
    failed = Recognize(&monitor) < 0;
  } else {
    // Normal layout and character recognition with no timeout.
    failed = Recognize(nullptr) < 0;
  }
 
  if (tesseract_->tessedit_write_images) {
    Pix *page_pix = GetThresholdedImage();
    std::string output_filename = output_file_ + ".processed";
    if (page_index > 0) {
      output_filename += std::to_string(page_index);
    }
    output_filename += ".tif";
    pixWrite(output_filename.c_str(), page_pix, IFF_TIFF_G4);
    pixDestroy(&page_pix);
  }
 
  if (failed && retry_config != nullptr && retry_config[0] != '\0') {
    // Save current config variables before switching modes.
    FILE *fp = fopen(kOldVarsFile, "wb");
    if (fp == nullptr) {
      tprintf("Error, failed to open file \"%s\"\n", kOldVarsFile);
    } else {
      PrintVariables(fp);
      fclose(fp);
    }
    // Switch to alternate mode for retry.
    ReadConfigFile(retry_config);
    SetImage(pix);
    Recognize(nullptr);
    // Restore saved config variables.
    ReadConfigFile(kOldVarsFile);
  }
 
  if (renderer && !failed) {
    failed = !renderer->AddImage(this);
  }
 
  return !failed;
}

ProcessPages()

bool tesseract::TessBaseAPI::ProcessPages	(	const char *	filename,
		const char *	retry_config,
		int	timeout_millisec,
		TessResultRenderer *	renderer
	)

Methods to retrieve information after SetAndThresholdImage(), Recognize() or TesseractRect(). (Recognize is called implicitly if needed.) Turns images into symbolic text.

filename can point to a single image, a multi-page TIFF, or a plain text list of image filenames.

retry_config is useful for debugging. If not nullptr, you can fall back to an alternate configuration if a page fails for some reason.

timeout_millisec terminates processing if any single page takes too long. Set to 0 for unlimited time.

renderer is responible for creating the output. For example, use the TessTextRenderer if you want plaintext output, or the TessPDFRender to produce searchable PDF.

If tessedit_page_number is non-negative, will only process that single page. Works for multi-page tiff file, or filelist.

Returns true if successful, false on error.

Definition at line 1071 of file baseapi.cpp.

                                                             {
  bool result = ProcessPagesInternal(filename, retry_config, timeout_millisec, renderer);
#ifndef DISABLED_LEGACY_ENGINE
  if (result) {
    if (tesseract_->tessedit_train_from_boxes && !tesseract_->WriteTRFile(output_file_.c_str())) {
      tprintf("Write of TR file failed: %s\n", output_file_.c_str());
      return false;
    }
  }
#endif // ndef DISABLED_LEGACY_ENGINE
  return result;
}

ProcessPagesInternal()

bool tesseract::TessBaseAPI::ProcessPagesInternal	(	const char *	filename,
		const char *	retry_config,
		int	timeout_millisec,
		TessResultRenderer *	renderer
	)

Definition at line 1105 of file baseapi.cpp.

                                                                                           {
  bool stdInput = !strcmp(filename, "stdin") || !strcmp(filename, "-");
  if (stdInput) {
#ifdef WIN32
    if (_setmode(_fileno(stdin), _O_BINARY) == -1)
      tprintf("ERROR: cin to binary: %s", strerror(errno));
#endif // WIN32
  }
 
  if (stream_filelist) {
    return ProcessPagesFileList(stdin, nullptr, retry_config, timeout_millisec, renderer,
                                tesseract_->tessedit_page_number);
  }
 
  // At this point we are officially in autodection territory.
  // That means any data in stdin must be buffered, to make it
  // seekable.
  std::string buf;
  const l_uint8 *data = nullptr;
  if (stdInput) {
    buf.assign((std::istreambuf_iterator<char>(std::cin)), (std::istreambuf_iterator<char>()));
    data = reinterpret_cast<const l_uint8 *>(buf.data());
  } else if (strstr(filename, "://") != nullptr) {
    // Get image or image list by URL.
#ifdef HAVE_LIBCURL
    CURL *curl = curl_easy_init();
    if (curl == nullptr) {
      fprintf(stderr, "Error, curl_easy_init failed\n");
      return false;
    } else {
      CURLcode curlcode;
      auto error = [curl, &curlcode](const char *function) {
        fprintf(stderr, "Error, %s failed with error %s\n", function, curl_easy_strerror(curlcode));
        curl_easy_cleanup(curl);
        return false;
      };
      curlcode = curl_easy_setopt(curl, CURLOPT_URL, filename);
      if (curlcode != CURLE_OK) {
        return error("curl_easy_setopt");
      }
      // Follow HTTP, HTTPS, FTP and FTPS redirects.
      curlcode = curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
      if (curlcode != CURLE_OK) {
        return error("curl_easy_setopt");
      }
      // Allow no more than 8 redirections to prevent endless loops.
      curlcode = curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 8);
      if (curlcode != CURLE_OK) {
        return error("curl_easy_setopt");
      }
      int timeout = curl_timeout;
      if (timeout > 0) {
        curlcode = curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
        if (curlcode != CURLE_OK) {
          return error("curl_easy_setopt");
        }
        curlcode = curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
        if (curlcode != CURLE_OK) {
          return error("curl_easy_setopt");
        }
      }
      curlcode = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
      if (curlcode != CURLE_OK) {
        return error("curl_easy_setopt");
      }
      curlcode = curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buf);
      if (curlcode != CURLE_OK) {
        return error("curl_easy_setopt");
      }
      curlcode = curl_easy_perform(curl);
      if (curlcode != CURLE_OK) {
        return error("curl_easy_perform");
      }
      curl_easy_cleanup(curl);
      data = reinterpret_cast<const l_uint8 *>(buf.data());
    }
#else
    fprintf(stderr, "Error, this tesseract has no URL support\n");
    return false;
#endif
  } else {
    // Check whether the input file can be read.
    if (FILE *file = fopen(filename, "rb")) {
      fclose(file);
    } else {
      fprintf(stderr, "Error, cannot read input file %s: %s\n", filename, strerror(errno));
      return false;
    }
  }
 
  // Here is our autodetection
  int format;
  int r =
      (data != nullptr) ? findFileFormatBuffer(data, &format) : findFileFormat(filename, &format);
 
  // Maybe we have a filelist
  if (r != 0 || format == IFF_UNKNOWN) {
    std::string s;
    if (data != nullptr) {
      s = buf.c_str();
    } else {
      std::ifstream t(filename);
      std::string u((std::istreambuf_iterator<char>(t)), std::istreambuf_iterator<char>());
      s = u.c_str();
    }
    return ProcessPagesFileList(nullptr, &s, retry_config, timeout_millisec, renderer,
                                tesseract_->tessedit_page_number);
  }
 
  // Maybe we have a TIFF which is potentially multipage
  bool tiff = (format == IFF_TIFF || format == IFF_TIFF_PACKBITS || format == IFF_TIFF_RLE ||
               format == IFF_TIFF_G3 || format == IFF_TIFF_G4 || format == IFF_TIFF_LZW ||
#if LIBLEPT_MAJOR_VERSION > 1 || LIBLEPT_MINOR_VERSION > 76
               format == IFF_TIFF_JPEG ||
#endif
               format == IFF_TIFF_ZIP);
 
  // Fail early if we can, before producing any output
  Pix *pix = nullptr;
  if (!tiff) {
    pix = (data != nullptr) ? pixReadMem(data, buf.size()) : pixRead(filename);
    if (pix == nullptr) {
      return false;
    }
  }
 
  // Begin the output
  if (renderer && !renderer->BeginDocument(document_title.c_str())) {
    pixDestroy(&pix);
    return false;
  }
 
  // Produce output
  r = (tiff) ? ProcessPagesMultipageTiff(data, buf.size(), filename, retry_config, timeout_millisec,
                                         renderer, tesseract_->tessedit_page_number)
             : ProcessPage(pix, 0, filename, retry_config, timeout_millisec, renderer);
 
  // Clean up memory as needed
  pixDestroy(&pix);
 
  // End the output
  if (!r || (renderer && !renderer->EndDocument())) {
    return false;
  }
  return true;
}

ReadConfigFile()

void tesseract::TessBaseAPI::ReadConfigFile

(

const char *

filename

)

Read a "config" file containing a set of param, value pairs. Searches the standard places: tessdata/configs, tessdata/tessconfigs and also accepts a relative or absolute path name. Note: only non-init params will be set (init params are set by Init()).

Read a "config" file containing a set of parameter name, value pairs. Searches the standard places: tessdata/configs, tessdata/tessconfigs and also accepts a relative or absolute path name.

Definition at line 497 of file baseapi.cpp.

                                                     {
  tesseract_->read_config_file(filename, SET_PARAM_CONSTRAINT_NON_INIT_ONLY);
}

ReadDebugConfigFile()

void tesseract::TessBaseAPI::ReadDebugConfigFile

(

const char *

filename

)

Same as above, but only set debug params from the given config file.

Definition at line 502 of file baseapi.cpp.

                                                          {
  tesseract_->read_config_file(filename, SET_PARAM_CONSTRAINT_DEBUG_ONLY);
}

Recognize()

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 834 of file baseapi.cpp.

                                              {
  if (tesseract_ == nullptr) {
    return -1;
  }
  if (FindLines() != 0) {
    return -1;
  }
  delete page_res_;
  if (block_list_->empty()) {
    page_res_ = new PAGE_RES(false, block_list_, &tesseract_->prev_word_best_choice_);
    return 0; // Empty page.
  }
 
  tesseract_->SetBlackAndWhitelist();
  recognition_done_ = true;
#ifndef DISABLED_LEGACY_ENGINE
  if (tesseract_->tessedit_resegment_from_line_boxes) {
    page_res_ = tesseract_->ApplyBoxes(input_file_.c_str(), true, block_list_);
  } else if (tesseract_->tessedit_resegment_from_boxes) {
    page_res_ = tesseract_->ApplyBoxes(input_file_.c_str(), false, block_list_);
  } else
#endif // ndef DISABLED_LEGACY_ENGINE
  {
    page_res_ =
        new PAGE_RES(tesseract_->AnyLSTMLang(), block_list_, &tesseract_->prev_word_best_choice_);
  }
 
  if (page_res_ == nullptr) {
    return -1;
  }
 
  if (tesseract_->tessedit_train_line_recognizer) {
    if (!tesseract_->TrainLineRecognizer(input_file_.c_str(), output_file_, block_list_)) {
      return -1;
    }
    tesseract_->CorrectClassifyWords(page_res_);
    return 0;
  }
#ifndef DISABLED_LEGACY_ENGINE
  if (tesseract_->tessedit_make_boxes_from_boxes) {
    tesseract_->CorrectClassifyWords(page_res_);
    return 0;
  }
#endif // ndef DISABLED_LEGACY_ENGINE
 
  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_ = nullptr;
    return -1;
#ifndef DISABLED_LEGACY_ENGINE
  } else if (tesseract_->tessedit_train_from_boxes) {
    std::string fontname;
    ExtractFontName(output_file_.c_str(), &fontname);
    tesseract_->ApplyBoxTraining(fontname, page_res_);
  } else if (tesseract_->tessedit_ambigs_training) {
    FILE *training_output_file = tesseract_->init_recog_training(input_file_.c_str());
    // OCR the page segmented into words by tesseract.
    tesseract_->recog_training_segmented(input_file_.c_str(), page_res_, monitor,
                                         training_output_file);
    fclose(training_output_file);
#endif // ndef DISABLED_LEGACY_ENGINE
  } else {
    // Now run the main recognition.
    bool wait_for_text = true;
    GetBoolVariable("paragraph_text_based", &wait_for_text);
    if (!wait_for_text) {
      DetectParagraphs(false);
    }
    if (tesseract_->recog_all_words(page_res_, monitor, nullptr, nullptr, 0)) {
      if (wait_for_text) {
        DetectParagraphs(true);
      }
    } else {
      result = -1;
    }
  }
  return result;
}

set_min_orientation_margin()

void tesseract::TessBaseAPI::set_min_orientation_margin

(

double

margin

)

Definition at line 2282 of file baseapi.cpp.

                                                          {
  tesseract_->min_orientation_margin.set_value(margin);
}

SetDebugVariable()

bool tesseract::TessBaseAPI::SetDebugVariable	(	const char *	name,
		const char *	value
	)

Definition at line 287 of file baseapi.cpp.

                                                                      {
  if (tesseract_ == nullptr) {
    tesseract_ = new Tesseract;
  }
  return ParamUtils::SetParam(name, value, SET_PARAM_CONSTRAINT_DEBUG_ONLY, tesseract_->params());
}

SetDictFunc()

void tesseract::TessBaseAPI::SetDictFunc

(

DictFunc

f

)

Sets Dict::letter_is_okay_ function to point to the given function.

Definition at line 2009 of file baseapi.cpp.

                                        {
  if (tesseract_ != nullptr) {
    tesseract_->getDict().letter_is_okay_ = f;
  }
}

SetImage() [1/2]

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. Copies the image buffer and converts to Pix. 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 576 of file baseapi.cpp.

                                                                    {
  if (InternalSetImage()) {
    thresholder_->SetImage(imagedata, width, height, bytes_per_pixel, bytes_per_line);
    SetInputImage(thresholder_->GetPixRect());
  }
}

SetImage() [2/2]

void tesseract::TessBaseAPI::SetImage

(

Pix *

pix

)

Provide an image for Tesseract to recognize. As with SetImage above, Tesseract takes its own copy of the image, so it need not persist until after Recognize. Pix vs raw, which to use? Use Pix where possible. Tesseract uses Pix as its internal representation and it is therefore more efficient to provide a Pix directly.

Definition at line 600 of file baseapi.cpp.

                                   {
  if (InternalSetImage()) {
    if (pixGetSpp(pix) == 4 && pixGetInputFormat(pix) == IFF_PNG) {
      // remove alpha channel from png
      Pix *p1 = pixRemoveAlpha(pix);
      pixSetSpp(p1, 3);
      (void)pixCopy(pix, p1);
      pixDestroy(&p1);
    }
    thresholder_->SetImage(pix);
    SetInputImage(thresholder_->GetPixRect());
  }
}

SetInputImage()

void tesseract::TessBaseAPI::SetInputImage

(

Pix *

pix

)

Definition at line 920 of file baseapi.cpp.

                                        {
  tesseract_->set_pix_original(pix);
}

SetInputName()

void tesseract::TessBaseAPI::SetInputName

(

const char *

name

)

Set the name of the input file. Needed for training and reading a UNLV zone file, and for searchable PDF output.

Set the name of the input file. Needed only for training and loading a UNLV zone file.

Definition at line 270 of file baseapi.cpp.

                                               {
  input_file_ = name ? name : "";
}

SetOutputName()

void tesseract::TessBaseAPI::SetOutputName

(

const char *

name

)

Set the name of the bonus output files. Needed only for debugging.

Set the name of the output files. Needed only for debugging.

Definition at line 275 of file baseapi.cpp.

                                                {
  output_file_ = name ? name : "";
}

SetPageSegMode()

void tesseract::TessBaseAPI::SetPageSegMode

(

PageSegMode

mode

)

Set the current page segmentation mode. Defaults to PSM_SINGLE_BLOCK. The mode is stored as an IntParam so it can also be modified by ReadConfigFile or SetVariable("tessedit_pageseg_mode", mode as string).

Set the current page segmentation mode. Defaults to PSM_AUTO. The mode is stored as an IntParam so it can also be modified by ReadConfigFile or SetVariable("tessedit_pageseg_mode", mode as string).

Definition at line 511 of file baseapi.cpp.

                                                 {
  if (tesseract_ == nullptr) {
    tesseract_ = new Tesseract;
  }
  tesseract_->tessedit_pageseg_mode.set_value(mode);
}

SetProbabilityInContextFunc()

void tesseract::TessBaseAPI::SetProbabilityInContextFunc

(

ProbabilityInContextFunc

f

)

Sets Dict::probability_in_context_ function to point to the given function.

Sets Dict::probability_in_context_ function to point to the given function.

Parameters

f	A single function that returns the probability of the current "character" (in general a utf-8 string), given the context of a previous utf-8 string.

Definition at line 2023 of file baseapi.cpp.

                                                                        {
  if (tesseract_ != nullptr) {
    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;
    }
  }
}

SetRectangle()

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.

Restrict recognition to a sub-rectangle of the image. Call after SetImage. Each SetRectangle clears the recognition results so multiple rectangles can be recognized with the same image.

Definition at line 619 of file baseapi.cpp.

                                                                       {
  if (thresholder_ == nullptr) {
    return;
  }
  thresholder_->SetRectangle(left, top, width, height);
  ClearResults();
}

SetSourceResolution()

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 584 of file baseapi.cpp.

                                             {
  if (thresholder_) {
    thresholder_->SetSourceYResolution(ppi);
  } else {
    tprintf("Please call SetImage before SetSourceResolution.\n");
  }
}

SetVariable()

bool tesseract::TessBaseAPI::SetVariable	(	const char *	name,
		const char *	value
	)

Set the value of an internal "parameter." Supply the name of the parameter and the value as a string, just as you would in a config file. Returns false if the name lookup failed. Eg SetVariable("tessedit_char_blacklist", "xyz"); to ignore x, y and z. Or SetVariable("classify_bln_numeric_mode", "1"); to set numeric-only mode. SetVariable may be used before Init, but settings will revert to defaults on End().

Note: Must be called after Init(). Only works for non-init variables (init variables should be passed to Init()).

Definition at line 279 of file baseapi.cpp.

                                                                 {
  if (tesseract_ == nullptr) {
    tesseract_ = new Tesseract;
  }
  return ParamUtils::SetParam(name, value, SET_PARAM_CONSTRAINT_NON_INIT_ONLY,
                              tesseract_->params());
}

tesseract()

Tesseract * tesseract::TessBaseAPI::tesseract ( ) const

inline

Definition at line 711 of file baseapi.h.

                               {
    return tesseract_;
  }

TesseractRect()

char * tesseract::TessBaseAPI::TesseractRect	(	const unsigned char *	imagedata,
		int	bytes_per_pixel,
		int	bytes_per_line,
		int	left,
		int	top,
		int	width,
		int	height
	)

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 1 represents WHITE. For binary images set bytes_per_pixel=0. The recognized text is returned as a char* which is coded as UTF8 and must be freed with the delete [] operator.

Note that TesseractRect is the simplified convenience interface. For advanced uses, use SetImage, (optionally) SetRectangle, Recognize, and one or more of the Get*Text functions below.

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 is coded as UTF8 and must be freed with the delete [] operator.

Definition at line 539 of file baseapi.cpp.

                                                                                               {
  if (tesseract_ == nullptr || width < kMinRectSize || height < kMinRectSize) {
    return nullptr; // Nothing worth doing.
  }
 
  // Since this original api didn't give the exact size of the image,
  // we have to invent a reasonable value.
  int bits_per_pixel = bytes_per_pixel == 0 ? 1 : bytes_per_pixel * 8;
  SetImage(imagedata, bytes_per_line * 8 / bits_per_pixel, height + top, bytes_per_pixel,
           bytes_per_line);
  SetRectangle(left, top, width, height);
 
  return GetUTF8Text();
}

TextLength()

int tesseract::TessBaseAPI::TextLength ( int *  blob_count ) const

protected

Return the length of the output text string, as UTF8, assuming one newline per line and one per block, with a terminator, and assuming a single character reject marker for each rejected character. Also return the number of recognized blobs in blob_count.

Return the length of the output text string, as UTF8, assuming liberally two spacing marks after each word (as paragraphs end with two newlines), and assuming a single character reject marker for each rejected character. Also return the number of recognized blobs in blob_count.

Definition at line 2233 of file baseapi.cpp.

                                                 {
  if (tesseract_ == nullptr || page_res_ == nullptr) {
    return 0;
  }
 
  PAGE_RES_IT page_res_it(page_res_);
  int total_length = 2;
  int total_blobs = 0;
  // Iterate over the data structures to extract the recognition result.
  for (page_res_it.restart_page(); page_res_it.word() != nullptr; page_res_it.forward()) {
    WERD_RES *word = page_res_it.word();
    WERD_CHOICE *choice = word->best_choice;
    if (choice != nullptr) {
      total_blobs += choice->length() + 2;
      total_length += choice->unichar_string().length() + 2;
      for (int i = 0; i < word->reject_map.length(); ++i) {
        if (word->reject_map[i].rejected()) {
          ++total_length;
        }
      }
    }
  }
  if (blob_count != nullptr) {
    *blob_count = total_blobs;
  }
  return total_length;
}

Threshold()

bool tesseract::TessBaseAPI::Threshold ( Pix **  pix )

protectedvirtual

Run the thresholder to make the thresholded image. If pix is not nullptr, the source is thresholded to pix instead of the internal IMAGE.

Run the thresholder to make the thresholded image, returned in pix, which must not be nullptr. *pix must be initialized to nullptr, or point to an existing pixDestroyable Pix. The usual argument to Threshold is Tesseract::mutable_pix_binary().

Definition at line 2053 of file baseapi.cpp.

                                     {
  ASSERT_HOST(pix != nullptr);
  if (*pix != nullptr) {
    pixDestroy(pix);
  }
  // Zero resolution messes up the algorithms, so make sure it is credible.
  int user_dpi = 0;
  GetIntVariable("user_defined_dpi", &user_dpi);
  int y_res = thresholder_->GetScaledYResolution();
  if (user_dpi && (user_dpi < kMinCredibleResolution || user_dpi > kMaxCredibleResolution)) {
    tprintf(
        "Warning: User defined image dpi is outside of expected range "
        "(%d - %d)!\n",
        kMinCredibleResolution, kMaxCredibleResolution);
  }
  // Always use user defined dpi
  if (user_dpi) {
    thresholder_->SetSourceYResolution(user_dpi);
  } else if (y_res < kMinCredibleResolution || y_res > kMaxCredibleResolution) {
    if (y_res != 0) {
      // Show warning only if a resolution was given.
      tprintf("Warning: Invalid resolution %d dpi. Using %d instead.\n",
              y_res, kMinCredibleResolution);
    }
    thresholder_->SetSourceYResolution(kMinCredibleResolution);
  }
 
  auto thresholding_method = static_cast<ThresholdMethod>(static_cast<int>(tesseract_->thresholding_method));
 
  if (thresholding_method == ThresholdMethod::Otsu) {
    Image pix_binary(*pix);
    if (!thresholder_->ThresholdToPix(&pix_binary)) {
      return false;
    }
    *pix = pix_binary;
 
    if (!thresholder_->IsBinary()) {
      tesseract_->set_pix_thresholds(thresholder_->GetPixRectThresholds());
      tesseract_->set_pix_grey(thresholder_->GetPixRectGrey());
    } else {
      tesseract_->set_pix_thresholds(nullptr);
      tesseract_->set_pix_grey(nullptr);
    }
  } else {
    auto [ok, pix_grey, pix_binary, pix_thresholds] = thresholder_->Threshold(this, thresholding_method);
 
    if (!ok) {
      return false;
    }
    *pix = pix_binary;
 
    tesseract_->set_pix_thresholds(pix_thresholds);
    tesseract_->set_pix_grey(pix_grey);
  }
 
  thresholder_->GetImageSizes(&rect_left_, &rect_top_, &rect_width_, &rect_height_, &image_width_,
                              &image_height_);
 
  // Set the internal resolution that is used for layout parameters from the
  // estimated resolution, rather than the image resolution, which may be
  // fabricated, but we will use the image resolution, if there is one, to
  // report output point sizes.
  int estimated_res = ClipToRange(thresholder_->GetScaledEstimatedResolution(),
                                  kMinCredibleResolution, kMaxCredibleResolution);
  if (estimated_res != thresholder_->GetScaledEstimatedResolution()) {
    tprintf(
        "Estimated internal resolution %d out of range! "
        "Corrected to %d.\n",
        thresholder_->GetScaledEstimatedResolution(), estimated_res);
  }
  tesseract_->set_source_resolution(estimated_res);
  return true;
}

Version()

const char * tesseract::TessBaseAPI::Version ( )

static

Returns the version identifier as a static string. Do not delete.

Definition at line 241 of file baseapi.cpp.

                                 {
  return TESSERACT_VERSION_STR;
}

Member Data Documentation

block_list_

BLOCK_LIST* tesseract::TessBaseAPI::block_list_

protected

The page layout.

Definition at line 771 of file baseapi.h.

datapath_

std::string tesseract::TessBaseAPI::datapath_

protected

Current location of tessdata.

Definition at line 775 of file baseapi.h.

equ_detect_

EquationDetect* tesseract::TessBaseAPI::equ_detect_

protected

The equation detector.

Definition at line 767 of file baseapi.h.

image_height_

int tesseract::TessBaseAPI::image_height_

protected

Definition at line 790 of file baseapi.h.

image_width_

int tesseract::TessBaseAPI::image_width_

protected

Definition at line 789 of file baseapi.h.

input_file_

std::string tesseract::TessBaseAPI::input_file_

protected

Name used by training code.

Definition at line 773 of file baseapi.h.

language_

std::string tesseract::TessBaseAPI::language_

protected

Last initialized language.

Definition at line 776 of file baseapi.h.

last_oem_requested_

OcrEngineMode tesseract::TessBaseAPI::last_oem_requested_

protected

Last ocr language mode requested.

Definition at line 777 of file baseapi.h.

osd_tesseract_

Tesseract* tesseract::TessBaseAPI::osd_tesseract_

protected

For orientation & script detection.

Definition at line 766 of file baseapi.h.

output_file_

std::string tesseract::TessBaseAPI::output_file_

protected

Name used by debug code.

Definition at line 774 of file baseapi.h.

page_res_

PAGE_RES* tesseract::TessBaseAPI::page_res_

protected

The page-level data.

Definition at line 772 of file baseapi.h.

paragraph_models_

std::vector<ParagraphModel *>* tesseract::TessBaseAPI::paragraph_models_

protected

Definition at line 770 of file baseapi.h.

reader_

FileReader tesseract::TessBaseAPI::reader_

protected

Reads files from any filesystem.

Definition at line 768 of file baseapi.h.

recognition_done_

bool tesseract::TessBaseAPI::recognition_done_

protected

page_res_ contains recognition data.

Definition at line 778 of file baseapi.h.

rect_height_

int tesseract::TessBaseAPI::rect_height_

protected

Definition at line 788 of file baseapi.h.

rect_left_

int tesseract::TessBaseAPI::rect_left_

protected

Definition at line 785 of file baseapi.h.

rect_top_

int tesseract::TessBaseAPI::rect_top_

protected

Definition at line 786 of file baseapi.h.

rect_width_

int tesseract::TessBaseAPI::rect_width_

protected

Definition at line 787 of file baseapi.h.

tesseract_

Tesseract* tesseract::TessBaseAPI::tesseract_

protected

The underlying data object.

Definition at line 765 of file baseapi.h.

thresholder_

ImageThresholder* tesseract::TessBaseAPI::thresholder_

protected

Image thresholding module.

Definition at line 769 of file baseapi.h.

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/include/tesseract/baseapi.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/api/altorenderer.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/api/baseapi.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/api/hocrrenderer.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/api/lstmboxrenderer.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/api/wordstrboxrenderer.cpp