#include <baseapi.h>

Public Member Functions
	TessBaseAPI ()

virtual	~TessBaseAPI ()

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	PrintVariables (FILE *fp) const

bool	GetVariableAsString (const char name, STRING val)

int	Init (const char datapath, const char language, OcrEngineMode mode, char *configs, int configs_size, const GenericVector< STRING > vars_vec, const GenericVector< 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 GenericVector< STRING > vars_vec, const GenericVector< STRING > *vars_values, bool set_only_non_debug_params, FileReader reader)

const char *	GetInitLanguagesAsString () const

void	GetLoadedLanguagesAsVector (GenericVector< STRING > *langs) const

void	GetAvailableLanguagesAsVector (GenericVector< STRING > *langs) const

int	InitLangMod (const char datapath, const char language)

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)

void	SetThresholder (ImageThresholder *thresholder)

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)

int	RecognizeForChopTest (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)

bool	IsValidCharacter (const char *utf8_character)

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)

void	SetFillLatticeFunc (FillLatticeFunc f)

BLOCK_LIST *	FindLinesCreateBlockList ()

void	GetFeaturesForBlob (TBLOB blob, INT_FEATURE_STRUCT int_features, int num_features, int feature_outline_index)

void	RunAdaptiveClassifier (TBLOB blob, int num_max_matches, int unichar_ids, float ratings, int num_matches_returned)

const char *	GetUnichar (int unichar_id)

const Dawg *	GetDawg (int i) const

int	NumDawgs () const

Tesseract *	tesseract () const

OcrEngineMode	oem () const

void	InitTruthCallback (TruthCallback *cb)

void	set_min_orientation_margin (double margin)

Static Public Member Functions
static const char *	Version ()

static size_t	getOpenCLDevice (void **device)

static void	CatchSignals ()

static void	ClearPersistentCache ()

static void	DeleteBlockList (BLOCK_LIST *block_list)

static ROW *	MakeTessOCRRow (float baseline, float xheight, float descender, float ascender)

static TBLOB *	MakeTBLOB (Pix *pix)

static void	NormalizeTBLOB (TBLOB tblob, ROW row, bool numeric_mode)

static ROW *	FindRowForBox (BLOCK_LIST *blocks, int left, int top, int right, int bottom)

Protected Member Functions
TESS_LOCAL bool	InternalSetImage ()

virtual TESS_LOCAL bool	Threshold (Pix **pix)

TESS_LOCAL int	FindLines ()

void	ClearResults ()

TESS_LOCAL LTRResultIterator *	GetLTRIterator ()

TESS_LOCAL int	TextLength (int *blob_count)

TESS_LOCAL void	DetectParagraphs (bool after_text_recognition)

TESS_LOCAL void	AdaptToCharacter (const char *unichar_repr, int length, float baseline, float xheight, float descender, float ascender)

TESS_LOCAL PAGE_RES *	RecognitionPass1 (BLOCK_LIST *block_list)

TESS_LOCAL PAGE_RES *	RecognitionPass2 (BLOCK_LIST block_list, PAGE_RES pass1_result)

TESS_LOCAL const PAGE_RES *	GetPageRes () const

Static Protected Member Functions
static TESS_LOCAL int	TesseractExtractResult (char text, int lengths, float costs, int x0, int y0, int x1, int *y1, PAGE_RES page_res)

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...

GenericVector< ParagraphModel * > *	paragraph_models_

BLOCK_LIST *	block_list_
	The page layout. More...

PAGE_RES *	page_res_
	The page-level data. More...

STRING *	input_file_
	Name used by training code. More...

STRING *	output_file_
	Name used by debug code. More...

STRING *	datapath_
	Current location of tessdata. More...

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...

TruthCallback *	truth_cb_

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 91 of file baseapi.h.

Constructor & Destructor Documentation

tesseract::TessBaseAPI::TessBaseAPI ( )

Definition at line 183 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,  SetThresholder(), or
       // created implicitly when used in InternalSetImage.
       thresholder_(nullptr),
       paragraph_models_(nullptr),
       block_list_(nullptr),
       page_res_(nullptr),
       input_file_(nullptr),
       output_file_(nullptr),
       datapath_(nullptr),
       language_(nullptr),
       last_oem_requested_(OEM_DEFAULT),
       recognition_done_(false),
       truth_cb_(nullptr),
       rect_left_(0),
       rect_top_(0),
       rect_width_(0),
       rect_height_(0),
       image_width_(0),
       image_height_(0) {
 #if defined(DEBUG)
   // The Tesseract executables would use the "C" locale by default,
   // but other software which is linked against the Tesseract library
   // typically uses the locale from the user's environment.
   // Here the default is overridden to allow debugging of potential
   // problems caused by the locale settings.
 
   // Use the current locale if building debug code.
   std::locale::global(std::locale(""));
 #endif
 }

tesseract::TessBaseAPI::~TessBaseAPI ( )

virtual

Definition at line 220 of file baseapi.cpp.

                           {
   End();
 }

Member Function Documentation

void tesseract::TessBaseAPI::CatchSignals ( )

static

Writes the thresholded image to stderr as a PBM file on receipt of a SIGSEGV, SIGFPE, or SIGBUS signal. (Linux/Unix only).

This method used to write the thresholded image to stderr as a PBM file on receipt of a SIGSEGV, SIGFPE, or SIGBUS signal. (Linux/Unix only).

Definition at line 256 of file baseapi.cpp.

                                {
   // Warn API users that an implementation is needed.
   tprintf("Deprecated method CatchSignals has only a dummy implementation!\n");
 }

void tesseract::TessBaseAPI::ClearAdaptiveClassifier ( )

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

Definition at line 559 of file baseapi.cpp.

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

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 2102 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) {
     paragraph_models_->delete_data_pointers();
     delete paragraph_models_;
     paragraph_models_ = nullptr;
   }
 }

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

protected

Definition at line 2236 of file baseapi.cpp.

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

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 2026 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())) {
     return -1;
   }
 
   tesseract_->PrepareForPageseg();
 
 #ifndef DISABLED_LEGACY_ENGINE
   if (tesseract_->textord_equation_detect) {
     if (equ_detect_ == nullptr && datapath_ != nullptr) {
       equ_detect_ = new EquationDetect(datapath_->string(), 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;
   if (PSM_OSD_ENABLED(tesseract_->tessedit_pageseg_mode) &&
       osd_tess == nullptr) {
     if (strcmp(language_->string(), "osd") == 0) {
       osd_tess = tesseract_;
     } else {
       osd_tesseract_ = new Tesseract;
       TessdataManager mgr(reader_);
       if (datapath_ == nullptr) {
         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_->string(), nullptr,
                                                 "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;
       }
     }
   }
 
   if (tesseract_->SegmentPage(input_file_, 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;
 }

void tesseract::TessBaseAPI::GetAvailableLanguagesAsVector ( GenericVector< STRING > * langs ) const

Returns the available languages in the sorted vector of STRINGs.

Definition at line 450 of file baseapi.cpp.

                                         {
   langs->clear();
   if (tesseract_ != nullptr) {
     addAvailableLanguages(tesseract_->datadir, "", langs);
     langs->sort(CompareSTRING);
   }
 }

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

Definition at line 300 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;
 }

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

Definition at line 958 of file baseapi.cpp.

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

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

Definition at line 314 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;
 }

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

                                                         {
   return (language_ == nullptr || language_->string() == nullptr) ?
       "" : language_->string();
 }

Pix * tesseract::TessBaseAPI::GetInputImage ( )

Definition at line 950 of file baseapi.cpp.

950 { return tesseract_->pix_original(); }

tesseract::Tesseract::pix_original

Pix * pix_original() const

Definition: tesseractclass.h:212

tesseract::TessBaseAPI::tesseract_

Tesseract * tesseract_

The underlying data object.

Definition: baseapi.h:888

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

                                        {
   if (input_file_)
     return input_file_->c_str();
   return nullptr;
 }

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

void tesseract::TessBaseAPI::GetLoadedLanguagesAsVector ( GenericVector< STRING > * langs ) const

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

Definition at line 436 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);
   }
 }

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 1265 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_);
 }

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

PageSegMode tesseract::TessBaseAPI::GetPageSegMode ( ) const

Return the current page segmentation mode.

Definition at line 516 of file baseapi.cpp.

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

int tesseract::TessBaseAPI::GetSourceYResolution ( )

Definition at line 962 of file baseapi.cpp.

                                       {
   return thresholder_->GetSourceYResolution();
 }

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

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

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

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

Definition at line 323 of file baseapi.cpp.

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

int tesseract::TessBaseAPI::Init	(	const char *	datapath,
		const char *	language,
		OcrEngineMode	oem,
		char **	configs,
		int	configs_size,
		const GenericVector< STRING > *	vars_vec,
		const GenericVector< 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 340 of file baseapi.cpp.

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

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

inline

Definition at line 220 of file baseapi.h.

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

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

inline

Definition at line 223 of file baseapi.h.

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

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

Definition at line 352 of file baseapi.cpp.

                                                                          {
   // Default language is "eng".
   if (language == nullptr) language = "eng";
   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_ == nullptr || language_ == nullptr || *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.string(),
             output_file_ != nullptr ? output_file_->string() : nullptr,
             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.
   if (datapath_ == nullptr)
     datapath_ = new STRING(datapath);
   else
     *datapath_ = datapath;
   if ((strcmp(datapath_->string(), "") == 0) &&
       (strcmp(tesseract_->datadir.string(), "") != 0))
      *datapath_ = tesseract_->datadir;
 
   if (language_ == nullptr)
     language_ = new STRING(language);
   else
     *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;
 }

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

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

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

Init only the lang model component of Tesseract. The only functions that work after this init are SetVariable and IsValidWord. WARNING: temporary! This function will be removed from here and placed in a separate API at some future time.

Definition at line 467 of file baseapi.cpp.

                                                                        {
   if (tesseract_ == nullptr)
     tesseract_ = new Tesseract;
   else
     ParamUtils::ResetToDefaults(tesseract_->params());
   TessdataManager mgr;
   return tesseract_->init_tesseract_lm(datapath, nullptr, language, &mgr);
 }

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

void tesseract::TessBaseAPI::PrintVariables ( FILE * fp ) const

Print Tesseract parameters to the given file.

Definition at line 328 of file baseapi.cpp.

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

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

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

void tesseract::TessBaseAPI::ReadDebugConfigFile ( const char * filename )

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

Definition at line 500 of file baseapi.cpp.

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

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

Definition at line 286 of file baseapi.cpp.

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

void tesseract::TessBaseAPI::SetInputImage ( Pix * pix )

Definition at line 948 of file baseapi.cpp.

948 { tesseract_->set_pix_original(pix); }

tesseract::Tesseract::set_pix_original

void set_pix_original(Pix *original_pix)

Definition: tesseractclass.h:216

tesseract::TessBaseAPI::tesseract_

Tesseract * tesseract_

The underlying data object.

Definition: baseapi.h:888

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

                                                {
   if (input_file_ == nullptr)
     input_file_ = new STRING(name);
   else
     *input_file_ = name;
 }

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

                                                 {
   if (output_file_ == nullptr)
     output_file_ = new STRING(name);
   else
     *output_file_ = name;
 }

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

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

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

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

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 536 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();
 }

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

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

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 1972 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) {
     tprintf("Warning: Invalid resolution %d dpi. Using %d instead.\n",
             y_res, kMinCredibleResolution);
     thresholder_->SetSourceYResolution(kMinCredibleResolution);
   }
   auto pageseg_mode =
       static_cast<PageSegMode>(
           static_cast<int>(tesseract_->tessedit_pageseg_mode));
   if (!thresholder_->ThresholdToPix(pageseg_mode, pix)) return false;
   thresholder_->GetImageSizes(&rect_left_, &rect_top_,
                               &rect_width_, &rect_height_,
                               &image_width_, &image_height_);
   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);
   }
   // 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;
 }

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

static

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

Definition at line 227 of file baseapi.cpp.

                                  {
   return PACKAGE_VERSION;
 }

Member Data Documentation

BLOCK_LIST* tesseract::TessBaseAPI::block_list_

protected

The page layout.

Definition at line 894 of file baseapi.h.

STRING* tesseract::TessBaseAPI::datapath_

protected

Current location of tessdata.

Definition at line 898 of file baseapi.h.

EquationDetect* tesseract::TessBaseAPI::equ_detect_

protected

The equation detector.

Definition at line 890 of file baseapi.h.

STRING* tesseract::TessBaseAPI::input_file_

protected

Name used by training code.

Definition at line 896 of file baseapi.h.

STRING* tesseract::TessBaseAPI::language_

protected

Last initialized language.

Definition at line 899 of file baseapi.h.

OcrEngineMode tesseract::TessBaseAPI::last_oem_requested_

protected

Last ocr language mode requested.

Definition at line 900 of file baseapi.h.

Tesseract* tesseract::TessBaseAPI::osd_tesseract_

protected

For orientation & script detection.

Definition at line 889 of file baseapi.h.

STRING* tesseract::TessBaseAPI::output_file_

protected

Name used by debug code.

Definition at line 897 of file baseapi.h.

PAGE_RES* tesseract::TessBaseAPI::page_res_

protected

The page-level data.

Definition at line 895 of file baseapi.h.

GenericVector<ParagraphModel *>* tesseract::TessBaseAPI::paragraph_models_

protected

Definition at line 893 of file baseapi.h.

FileReader tesseract::TessBaseAPI::reader_

protected

Reads files from any filesystem.

Definition at line 891 of file baseapi.h.

bool tesseract::TessBaseAPI::recognition_done_

protected

page_res_ contains recognition data.

Definition at line 901 of file baseapi.h.

Tesseract* tesseract::TessBaseAPI::tesseract_

protected

The underlying data object.

Definition at line 888 of file baseapi.h.

ImageThresholder* tesseract::TessBaseAPI::thresholder_

protected

Image thresholding module.

Definition at line 892 of file baseapi.h.

TruthCallback* tesseract::TessBaseAPI::truth_cb_

protected

Definition at line 902 of file baseapi.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation