Advanced API

Functions
void	tesseract::TessBaseAPI::SetImage (const unsigned char *imagedata, int width, int height, int bytes_per_pixel, int bytes_per_line)
void	tesseract::TessBaseAPI::SetImage (Pix *pix)
void	tesseract::TessBaseAPI::SetSourceResolution (int ppi)
void	tesseract::TessBaseAPI::SetRectangle (int left, int top, int width, int height)
void	tesseract::TessBaseAPI::SetThresholder (ImageThresholder *thresholder)
Pix *	tesseract::TessBaseAPI::GetThresholdedImage ()
Boxa *	tesseract::TessBaseAPI::GetRegions (Pixa **pixa)
Boxa *	tesseract::TessBaseAPI::GetTextlines (const bool raw_image, const int raw_padding, Pixa **pixa, int **blockids, int **paraids)
Boxa *	tesseract::TessBaseAPI::GetTextlines (Pixa **pixa, int **blockids)
Boxa *	tesseract::TessBaseAPI::GetStrips (Pixa **pixa, int **blockids)
Boxa *	tesseract::TessBaseAPI::GetWords (Pixa **pixa)
Boxa *	tesseract::TessBaseAPI::GetConnectedComponents (Pixa **cc)
Boxa *	tesseract::TessBaseAPI::GetComponentImages (const PageIteratorLevel level, const bool text_only, const bool raw_image, const int raw_padding, Pixa **pixa, int **blockids, int **paraids)
Boxa *	tesseract::TessBaseAPI::GetComponentImages (const PageIteratorLevel level, const bool text_only, Pixa **pixa, int **blockids)
int	tesseract::TessBaseAPI::GetThresholdedImageScaleFactor () const
void	tesseract::TessBaseAPI::DumpPGM (const char *filename)
PageIterator *	tesseract::TessBaseAPI::AnalyseLayout ()
PageIterator *	tesseract::TessBaseAPI::AnalyseLayout (bool merge_similar_words)
int	tesseract::TessBaseAPI::Recognize (ETEXT_DESC *monitor)
int	tesseract::TessBaseAPI::RecognizeForChopTest (ETEXT_DESC *monitor)
bool	tesseract::TessBaseAPI::ProcessPages (const char *filename, const char *retry_config, int timeout_millisec, TessResultRenderer *renderer)
bool	tesseract::TessBaseAPI::ProcessPagesInternal (const char *filename, const char *retry_config, int timeout_millisec, TessResultRenderer *renderer)
bool	tesseract::TessBaseAPI::ProcessPage (Pix *pix, int page_index, const char *filename, const char *retry_config, int timeout_millisec, TessResultRenderer *renderer)
ResultIterator *	tesseract::TessBaseAPI::GetIterator ()
MutableIterator *	tesseract::TessBaseAPI::GetMutableIterator ()
char *	tesseract::TessBaseAPI::GetUTF8Text ()
char *	tesseract::TessBaseAPI::GetHOCRText (ETEXT_DESC *monitor, int page_number)
char *	tesseract::TessBaseAPI::GetHOCRText (int page_number)
char *	tesseract::TessBaseAPI::GetTSVText (int page_number)
char *	tesseract::TessBaseAPI::GetBoxText (int page_number)
char *	tesseract::TessBaseAPI::GetUNLVText ()
bool	tesseract::TessBaseAPI::DetectOrientationScript (int *orient_deg, float *orient_conf, const char **script_name, float *script_conf)
char *	tesseract::TessBaseAPI::GetOsdText (int page_number)
int	tesseract::TessBaseAPI::MeanTextConf ()
int *	tesseract::TessBaseAPI::AllWordConfidences ()
bool	tesseract::TessBaseAPI::AdaptToWordStr (PageSegMode mode, const char *wordstr)
void	tesseract::TessBaseAPI::Clear ()
void	tesseract::TessBaseAPI::End ()
static void	tesseract::TessBaseAPI::ClearPersistentCache ()
int	tesseract::TessBaseAPI::IsValidWord (const char *word)
bool	tesseract::TessBaseAPI::IsValidCharacter (const char *utf8_character)
bool	tesseract::TessBaseAPI::GetTextDirection (int *out_offset, float *out_slope)
void	tesseract::TessBaseAPI::SetDictFunc (DictFunc f)
void	tesseract::TessBaseAPI::SetProbabilityInContextFunc (ProbabilityInContextFunc f)
void	tesseract::TessBaseAPI::SetFillLatticeFunc (FillLatticeFunc f)
bool	tesseract::TessBaseAPI::DetectOS (OSResults *)
void	tesseract::TessBaseAPI::GetFeaturesForBlob (TBLOB *blob, INT_FEATURE_STRUCT *int_features, int *num_features, int *feature_outline_index)
static ROW *	tesseract::TessBaseAPI::FindRowForBox (BLOCK_LIST *blocks, int left, int top, int right, int bottom)
void	tesseract::TessBaseAPI::RunAdaptiveClassifier (TBLOB *blob, int num_max_matches, int *unichar_ids, float *ratings, int *num_matches_returned)
const char *	tesseract::TessBaseAPI::GetUnichar (int unichar_id)
const Dawg *	tesseract::TessBaseAPI::GetDawg (int i) const
int	tesseract::TessBaseAPI::NumDawgs () const
static ROW *	tesseract::TessBaseAPI::MakeTessOCRRow (float baseline, float xheight, float descender, float ascender)
static TBLOB *	tesseract::TessBaseAPI::MakeTBLOB (Pix *pix)
static void	tesseract::TessBaseAPI::NormalizeTBLOB (TBLOB *tblob, ROW *row, bool numeric_mode)
Tesseract *	tesseract::TessBaseAPI::tesseract () const
OcrEngineMode	tesseract::TessBaseAPI::oem () const
void	tesseract::TessBaseAPI::InitTruthCallback (TruthCallback *cb)
void	tesseract::TessBaseAPI::set_min_orientation_margin (double margin)
void	tesseract::TessBaseAPI::GetBlockTextOrientations (int **block_orientation, bool **vertical_writing)
BLOCK_LIST *	tesseract::TessBaseAPI::FindLinesCreateBlockList ()
static void	tesseract::TessBaseAPI::DeleteBlockList (BLOCK_LIST *block_list)

Detailed Description

The following methods break TesseractRect into pieces, so you can get hold of the thresholded image, get the text in different formats, get bounding boxes, confidences etc.

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 1979 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 != NULL) {
    PAGE_RES_IT it(page_res_);
    WERD_RES* word_res = it.word();
    if (word_res != NULL) {
      word_res->word->set_text(wordstr);
    } else {
      success = false;
    }
    // Check to see if text matches wordstr.
    int w = 0;
    int t = 0;
    for (t = 0; text[t] != '\0'; ++t) {
      if (text[t] == '\n' || text[t] == ' ')
        continue;
      while (wordstr[w] == ' ') ++w;
      if (text[t] != wordstr[w])
        break;
      ++w;
    }
    if (text[t] != '\0' || wordstr[w] != '\0') {
      // No match.
      delete page_res_;
      GenericVector<TBOX> boxes;
      page_res_ = tesseract_->SetupApplyBoxes(boxes, block_list_);
      tesseract_->ReSegmentByClassification(page_res_);
      tesseract_->TidyUp(page_res_);
      PAGE_RES_IT pr_it(page_res_);
      if (pr_it.word() == NULL)
        success = false;
      else
        word_res = pr_it.word();
    } else {
      word_res->BestChoiceToCorrectText();
    }
    if (success) {
      tesseract_->EnableLearning = true;
      tesseract_->LearnWord(NULL, word_res);
    }
  } 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 1945 of file baseapi.cpp.

                                     {
  if (tesseract_ == NULL ||
      (!recognition_done_ && Recognize(NULL) < 0))
    return NULL;
  int n_word = 0;
  PAGE_RES_IT res_it(page_res_);
  for (res_it.restart_page(); res_it.word() != NULL; res_it.forward())
    n_word++;

  int* conf = new int[n_word+1];
  n_word = 0;
  for (res_it.restart_page(); res_it.word() != NULL; res_it.forward()) {
    WERD_RES *word = res_it.word();
    WERD_CHOICE* choice = word->best_choice;
    int w_conf = static_cast<int>(100 + 5 * choice->certainty());
                 // This is the eq for converting Tesseract confidence to 1..100
    if (w_conf < 0) w_conf = 0;
    if (w_conf > 100) w_conf = 100;
    conf[n_word++] = w_conf;
  }
  conf[n_word] = -1;
  return conf;
}

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 NULL on error or an empty page. The returned iterator must be deleted after use. WARNING! This class points to data held within the TessBaseAPI class, and therefore can only be used while the TessBaseAPI class still exists and has not been subjected to a call of Init, SetImage, Recognize, Clear, End DetectOS, or anything else that changes the internal PAGE_RES.

Definition at line 787 of file baseapi.cpp.

{ return AnalyseLayout(false); }

AnalyseLayout() [2/2]

PageIterator * tesseract::TessBaseAPI::AnalyseLayout

(

bool

merge_similar_words

)

Definition at line 789 of file baseapi.cpp.

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

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

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

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

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

DeleteBlockList()

void tesseract::TessBaseAPI::DeleteBlockList ( BLOCK_LIST *  block_list )

static

Delete a block list. This is to keep BLOCK_LIST pointer opaque and let go of including the other headers.

Definition at line 2446 of file baseapi.cpp.

                                                        {
  delete block_list;
}

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

                                         {
  if (tesseract_ == NULL)
    return false;
  ClearResults();
  if (tesseract_->pix_binary() == NULL &&
      !Threshold(tesseract_->mutable_pix_binary())) {
    return false;
  }
  if (input_file_ == NULL)
    input_file_ = new STRING(kInputFile);
  return orientation_and_script_detection(*input_file_, osr, tesseract_) > 0;
}

DumpPGM()

void tesseract::TessBaseAPI::DumpPGM

(

const char *

filename

)

Dump the internal binary image to a PGM file.

Deprecated:

Use GetThresholdedImage and write the image using pixWrite instead if possible.

Dump the internal binary image to a PGM file.

Definition at line 754 of file baseapi.cpp.

                                              {
  if (tesseract_ == NULL)
    return;
  FILE *fp = fopen(filename, "wb");
  Pix* pix = tesseract_->pix_binary();
  int width = pixGetWidth(pix);
  int height = pixGetHeight(pix);
  l_uint32* data = pixGetData(pix);
  fprintf(fp, "P5 %d %d 255\n", width, height);
  for (int y = 0; y < height; ++y, data += pixGetWpl(pix)) {
    for (int x = 0; x < width; ++x) {
      uint8_t b = GET_DATA_BIT(data, x) ? 0 : 255;
      fwrite(&b, 1, 1, fp);
    }
  }
  fclose(fp);
}

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

                      {
  Clear();
  delete thresholder_;
  thresholder_ = NULL;
  delete page_res_;
  page_res_ = NULL;
  delete block_list_;
  block_list_ = NULL;
  if (paragraph_models_ != NULL) {
    paragraph_models_->delete_data_pointers();
    delete paragraph_models_;
    paragraph_models_ = NULL;
  }
  if (osd_tesseract_ == tesseract_)
    osd_tesseract_ = nullptr;
  delete tesseract_;
  tesseract_ = nullptr;
  delete osd_tesseract_;
  osd_tesseract_ = NULL;
  delete equ_detect_;
  equ_detect_ = NULL;
  delete input_file_;
  input_file_ = NULL;
  delete output_file_;
  output_file_ = NULL;
  delete datapath_;
  datapath_ = NULL;
  delete language_;
  language_ = NULL;
}

FindLinesCreateBlockList()

BLOCK_LIST * tesseract::TessBaseAPI::FindLinesCreateBlockList

(

)

Find lines from the image making the BLOCK_LIST.

Definition at line 2434 of file baseapi.cpp.

                                                  {
  FindLines();
  BLOCK_LIST* result = block_list_;
  block_list_ = NULL;
  return result;
}

FindRowForBox()

ROW * tesseract::TessBaseAPI::FindRowForBox ( BLOCK_LIST *  blocks, int  left, int  top, int  right, int  bottom  )

static

This method returns the row to which a box of specified dimensions would belong. If no good match is found, it returns NULL.

Definition at line 2746 of file baseapi.cpp.

                                                                          {
  TBOX box(left, bottom, right, top);
  BLOCK_IT b_it(blocks);
  for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
    BLOCK* block = b_it.data();
    if (!box.major_overlap(block->bounding_box()))
      continue;
    ROW_IT r_it(block->row_list());
    for (r_it.mark_cycle_pt(); !r_it.cycled_list(); r_it.forward()) {
      ROW* row = r_it.data();
      if (!box.major_overlap(row->bounding_box()))
        continue;
      WERD_IT w_it(row->word_list());
      for (w_it.mark_cycle_pt(); !w_it.cycled_list(); w_it.forward()) {
        WERD* word = w_it.data();
        if (box.major_overlap(word->bounding_box()))
          return row;
      }
    }
  }
  return NULL;
}

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

                                                                    {
  delete[] *block_orientation;
  *block_orientation = NULL;
  delete[] *vertical_writing;
  *vertical_writing = NULL;
  BLOCK_IT block_it(block_list_);

  block_it.move_to_first();
  int num_blocks = 0;
  for (block_it.mark_cycle_pt(); !block_it.cycled_list(); block_it.forward()) {
    if (!block_it.data()->poly_block()->IsText()) {
      continue;
    }
    ++num_blocks;
  }
  if (!num_blocks) {
    tprintf("WARNING: Found no blocks\n");
    return;
  }
  *block_orientation = new int[num_blocks];
  *vertical_writing = new bool[num_blocks];
  block_it.move_to_first();
  int i = 0;
  for (block_it.mark_cycle_pt(); !block_it.cycled_list();
       block_it.forward()) {
    if (!block_it.data()->poly_block()->IsText()) {
      continue;
    }
    FCOORD re_rotation = block_it.data()->re_rotation();
    float re_theta = re_rotation.angle();
    FCOORD classify_rotation = block_it.data()->classify_rotation();
    float classify_theta = classify_rotation.angle();
    double rot_theta = - (re_theta - classify_theta) * 2.0 / PI;
    if (rot_theta < 0) rot_theta += 4;
    int num_rotations = static_cast<int>(rot_theta + 0.5);
    (*block_orientation)[i] = num_rotations;
    // The classify_rotation is non-zero only if the text has vertical
    // writing direction.
    (*vertical_writing)[i] = classify_rotation.y() != 0.0f;
    ++i;
  }
}

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

                                             {
  if (tesseract_ == NULL ||
      (!recognition_done_ && Recognize(NULL) < 0))
    return NULL;
  int blob_count;
  int utf8_length = TextLength(&blob_count);
  int total_length = blob_count * kBytesPerBoxFileLine + utf8_length +
      kMaxBytesPerLine;
  char* result = new char[total_length];
  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,
		const bool	raw_image,
		const 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 NULL, the block-id of each component is also returned as an array of one element per component. delete [] after use. If blockids is not NULL, 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 NULL, the block-id of each component is also returned as an array of one element per component. delete [] after use. If text_only is true, then only text components are returned.

Definition at line 664 of file baseapi.cpp.

                                                     {
  PageIterator* page_it = GetIterator();
  if (page_it == NULL)
    page_it = AnalyseLayout();
  if (page_it == NULL)
    return NULL;  // Failed.

  // Count the components to get a size for the arrays.
  int component_count = 0;
  int left, top, right, bottom;

  TessResultCallback<bool>* get_bbox = NULL;
  if (raw_image) {
    // Get bounding box in original raw image with padding.
    get_bbox = NewPermanentTessCallback(page_it, &PageIterator::BoundingBox,
                                        level, raw_padding,
                                        &left, &top, &right, &bottom);
  } else {
    // Get bounding box from binarized imaged. Note that this could be
    // differently scaled from the original image.
    get_bbox = NewPermanentTessCallback(page_it,
                                        &PageIterator::BoundingBoxInternal,
                                        level, &left, &top, &right, &bottom);
  }
  do {
    if (get_bbox->Run() &&
        (!text_only || PTIsTextType(page_it->BlockType())))
      ++component_count;
  } while (page_it->Next(level));

  Boxa* boxa = boxaCreate(component_count);
  if (pixa != NULL)
    *pixa = pixaCreate(component_count);
  if (blockids != NULL)
    *blockids = new int[component_count];
  if (paraids != NULL)
    *paraids = new int[component_count];

  int blockid = 0;
  int paraid = 0;
  int component_index = 0;
  page_it->Begin();
  do {
    if (get_bbox->Run() &&
        (!text_only || PTIsTextType(page_it->BlockType()))) {
      Box* lbox = boxCreate(left, top, right - left, bottom - top);
      boxaAddBox(boxa, lbox, L_INSERT);
      if (pixa != NULL) {
        Pix* pix = NULL;
        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 != NULL) {
        (*paraids)[component_index] = paraid;
        if (page_it->IsAtFinalElement(RIL_PARA, level))
          ++paraid;
      }
      if (blockids != NULL) {
        (*blockids)[component_index] = blockid;
        if (page_it->IsAtFinalElement(RIL_BLOCK, level)) {
          ++blockid;
          paraid = 0;
        }
      }
      ++component_index;
    }
  } while (page_it->Next(level));
  delete page_it;
  delete get_bbox;
  return boxa;
}

GetComponentImages() [2/2]

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

inline

Definition at line 465 of file baseapi.h.

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

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

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

GetDawg()

const Dawg * tesseract::TessBaseAPI::GetDawg

(

int

i

)

const

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

Definition at line 2799 of file baseapi.cpp.

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

GetFeaturesForBlob()

void tesseract::TessBaseAPI::GetFeaturesForBlob	(	TBLOB *	blob,
		INT_FEATURE_STRUCT *	int_features,
		int *	num_features,
		int *	feature_outline_index
	)

This method returns the features associated with the input image.

This method returns the features associated with the input blob.

Definition at line 2718 of file baseapi.cpp.

                                                                 {
  GenericVector<int> outline_counts;
  GenericVector<INT_FEATURE_STRUCT> bl_features;
  GenericVector<INT_FEATURE_STRUCT> cn_features;
  INT_FX_RESULT_STRUCT fx_info;
  tesseract_->ExtractFeatures(*blob, false, &bl_features,
                              &cn_features, &fx_info, &outline_counts);
  if (cn_features.empty() || cn_features.size() > MAX_NUM_INT_FEATURES) {
    *num_features = 0;
    return;  // Feature extraction failed.
  }
  *num_features = cn_features.size();
  memcpy(int_features, &cn_features[0], *num_features * sizeof(cn_features[0]));
  // TODO(rays) Pass outline_counts back and simplify the calling code.
  if (feature_outline_index != NULL) {
    int f = 0;
    for (int i = 0; i < outline_counts.size(); ++i) {
      while (f < outline_counts[i])
        feature_outline_index[f++] = i;
    }
  }
}

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

                                                                   {
  if (tesseract_ == NULL || (page_res_ == NULL && Recognize(monitor) < 0))
    return NULL;

  int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 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 = NULL;
  bool font_info = false;
  GetBoolVariable("hocr_font_info", &font_info);

  STRING hocr_str("");

  if (input_file_ == NULL)
      SetInputName(NULL);

#ifdef _WIN32
  // convert input name from ANSI encoding to utf-8
  int str16_len =
      MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1, NULL, 0);
  wchar_t *uni16_str = new WCHAR[str16_len];
  str16_len = MultiByteToWideChar(CP_ACP, 0, input_file_->string(), -1,
                                  uni16_str, str16_len);
  int utf8_len = WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, NULL, 0,
                                     NULL, NULL);
  char *utf8_str = new char[utf8_len];
  WideCharToMultiByte(CP_UTF8, 0, uni16_str, str16_len, utf8_str,
                      utf8_len, NULL, NULL);
  *input_file_ = utf8_str;
  delete[] uni16_str;
  delete[] utf8_str;
#endif

  hocr_str += "  <div class='ocr_page'";
  AddIdTohOCR(&hocr_str, "page", page_id, -1);
  hocr_str += " title='image \"";
  if (input_file_) {
    hocr_str += HOcrEscape(input_file_->string());
  } else {
    hocr_str += "unknown";
  }
  hocr_str.add_str_int("\"; bbox ", rect_left_);
  hocr_str.add_str_int(" ", rect_top_);
  hocr_str.add_str_int(" ", rect_width_);
  hocr_str.add_str_int(" ", rect_height_);
  hocr_str.add_str_int("; ppageno ", page_number);
  hocr_str += "'>\n";

  ResultIterator *res_it = GetIterator();
  while (!res_it->Empty(RIL_BLOCK)) {
    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'";
      AddIdTohOCR(&hocr_str, "block", page_id, bcnt);
      AddBoxTohOCR(res_it, 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'";
      }
      AddIdTohOCR(&hocr_str, "par", page_id, pcnt);
      paragraph_lang = res_it->WordRecognitionLanguage();
      if (paragraph_lang) {
        hocr_str += " lang='";
        hocr_str += paragraph_lang;
        hocr_str += "'";
      }
      AddBoxTohOCR(res_it, RIL_PARA, &hocr_str);
    }
    if (res_it->IsAtBeginningOf(RIL_TEXTLINE)) {
      hocr_str += "\n     <span class='ocr_line'";
      AddIdTohOCR(&hocr_str, "line", page_id, lcnt);
      AddBoxTohOCR(res_it, RIL_TEXTLINE, &hocr_str);
    }

    // Now, process the word...
    hocr_str += "<span class='ocrx_word'";
    AddIdTohOCR(&hocr_str, "word", page_id, wcnt);
    int left, top, right, bottom;
    bool bold, italic, underlined, monospace, serif, smallcaps;
    int pointsize, font_id;
    const char *font_name;
    res_it->BoundingBox(RIL_WORD, &left, &top, &right, &bottom);
    font_name = res_it->WordFontAttributes(&bold, &italic, &underlined,
                                           &monospace, &serif, &smallcaps,
                                           &pointsize, &font_id);
    hocr_str.add_str_int(" title='bbox ", left);
    hocr_str.add_str_int(" ", top);
    hocr_str.add_str_int(" ", right);
    hocr_str.add_str_int(" ", bottom);
    hocr_str.add_str_int("; x_wconf ", res_it->Confidence(RIL_WORD));
    if (font_info) {
      if (font_name) {
        hocr_str += "; x_font ";
        hocr_str += HOcrEscape(font_name);
      }
      hocr_str.add_str_int("; x_fsize ", pointsize);
    }
    hocr_str += "'";
    const char* lang = res_it->WordRecognitionLanguage();
    if (lang && (!paragraph_lang || strcmp(lang, paragraph_lang))) {
      hocr_str += " lang='";
      hocr_str += lang;
      hocr_str += "'";
    }
    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) {
        hocr_str += HOcrEscape(grapheme.get());
      }
      res_it->Next(RIL_SYMBOL);
    } while (!res_it->Empty(RIL_BLOCK) && !res_it->IsAtBeginningOf(RIL_WORD));
    if (italic) hocr_str += "</em>";
    if (bold) hocr_str += "</strong>";
    hocr_str += "</span> ";
    wcnt++;
    // Close any ending block/paragraph/textline.
    if (last_word_in_line) {
      hocr_str += "\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";

  char *ret = new char[hocr_str.length() + 1];
  strcpy(ret, hocr_str.string());
  delete res_it;
  return ret;
}

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

                                              {
  return GetHOCRText(NULL, page_number);
}

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

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

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

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

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 1904 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 NULL;

  // clockwise rotation needed to make the page upright
  int rotate = OrientationIdToValue(orient_deg / 90);

  const int kOsdBufsize = 255;
  char* osd_buf = new char[kOsdBufsize];
  snprintf(osd_buf, kOsdBufsize,
           "Page number: %d\n"
           "Orientation in degrees: %d\n"
           "Rotate: %d\n"
           "Orientation confidence: %.2f\n"
           "Script: %s\n"
           "Script confidence: %.2f\n",
           page_number, orient_deg, rotate, orient_conf, script_name,
           script_conf);

  return osd_buf;
}

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

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

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

Definition at line 633 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 2109 of file baseapi.cpp.

                                                                    {
  PageIterator* it = AnalyseLayout();
  if (it == NULL) {
    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)) {
    delete it;
    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 - 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;
  delete it;

  return true;
}

GetTextlines() [1/2]

Boxa * tesseract::TessBaseAPI::GetTextlines	(	const bool	raw_image,
		const 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 NULL, the block-id of each line is also returned as an array of one element per line. delete [] after use. If paraids is not NULL, 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 NULL, the block-id of each line is also returned as an array of one element per line. delete [] after use. If paraids is not NULL, 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 619 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 416 of file baseapi.h.

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

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

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

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

                                                      {
  if (thresholder_ == NULL) {
    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 1582 of file baseapi.cpp.

                                             {
  if (tesseract_ == NULL || (page_res_ == NULL && Recognize(NULL) < 0))
    return NULL;

  int lcnt = 1, bcnt = 1, pcnt = 1, wcnt = 1;
  int page_id = page_number + 1;  // we use 1-based page numbers.

  STRING tsv_str("");

  int page_num = page_id, block_num = 0, par_num = 0, line_num = 0,
      word_num = 0;

  tsv_str.add_str_int("1\t", page_num);  // level 1 - page
  tsv_str.add_str_int("\t", block_num);
  tsv_str.add_str_int("\t", par_num);
  tsv_str.add_str_int("\t", line_num);
  tsv_str.add_str_int("\t", word_num);
  tsv_str.add_str_int("\t", rect_left_);
  tsv_str.add_str_int("\t", rect_top_);
  tsv_str.add_str_int("\t", rect_width_);
  tsv_str.add_str_int("\t", rect_height_);
  tsv_str += "\t-1\t\n";

  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.add_str_int("2\t", page_num);  // level 2 - block
      tsv_str.add_str_int("\t", block_num);
      tsv_str.add_str_int("\t", par_num);
      tsv_str.add_str_int("\t", line_num);
      tsv_str.add_str_int("\t", word_num);
      AddBoxToTSV(res_it, 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.add_str_int("3\t", page_num);  // level 3 - paragraph
      tsv_str.add_str_int("\t", block_num);
      tsv_str.add_str_int("\t", par_num);
      tsv_str.add_str_int("\t", line_num);
      tsv_str.add_str_int("\t", word_num);
      AddBoxToTSV(res_it, 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.add_str_int("4\t", page_num);  // level 4 - line
      tsv_str.add_str_int("\t", block_num);
      tsv_str.add_str_int("\t", par_num);
      tsv_str.add_str_int("\t", line_num);
      tsv_str.add_str_int("\t", word_num);
      AddBoxToTSV(res_it, 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.add_str_int("5\t", page_num);  // level 5 - word
    tsv_str.add_str_int("\t", block_num);
    tsv_str.add_str_int("\t", par_num);
    tsv_str.add_str_int("\t", line_num);
    tsv_str.add_str_int("\t", word_num);
    tsv_str.add_str_int("\t", left);
    tsv_str.add_str_int("\t", top);
    tsv_str.add_str_int("\t", right - left);
    tsv_str.add_str_int("\t", bottom - top);
    tsv_str.add_str_int("\t", 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.string());
  delete res_it;
  return ret;
}

GetUnichar()

const char * tesseract::TessBaseAPI::GetUnichar

(

int

unichar_id

)

This method returns the string form of the specified unichar.

Definition at line 2794 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 1763 of file baseapi.cpp.

                               {
  if (tesseract_ == NULL ||
      (!recognition_done_ && Recognize(NULL) < 0))
    return NULL;
  bool tilde_crunch_written = false;
  bool last_char_was_newline = true;
  bool last_char_was_tilde = false;

  int total_length = TextLength(NULL);
  PAGE_RES_IT   page_res_it(page_res_);
  char* result = new char[total_length];
  char* ptr = result;
  for (page_res_it.restart_page(); page_res_it.word () != NULL;
       page_res_it.forward()) {
    WERD_RES *word = page_res_it.word();
    // Process the current word.
    if (word->unlv_crunch_mode != CR_NONE) {
      if (word->unlv_crunch_mode != CR_DELETE &&
          (!tilde_crunch_written ||
           (word->unlv_crunch_mode == CR_KEEP_SPACE &&
            word->word->space() > 0 &&
            !word->word->flag(W_FUZZY_NON) &&
            !word->word->flag(W_FUZZY_SP)))) {
        if (!word->word->flag(W_BOL) &&
            word->word->space() > 0 &&
            !word->word->flag(W_FUZZY_NON) &&
            !word->word->flag(W_FUZZY_SP)) {
          /* Write a space to separate from 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().string();
      const STRING& lengths = word->best_choice->unichar_lengths();
      int length = lengths.length();
      int i = 0;
      int offset = 0;

      if (last_char_was_tilde &&
          word->word->space() == 0 && wordstr[offset] == ' ') {
        // Prevent adjacent tilde across words - we know that adjacent tildes
        // within words have been removed.
        // Skip the first character.
        offset = lengths[i++];
      }
      if (i < length && wordstr[offset] != 0) {
        if (!last_char_was_newline)
          *ptr++ = ' ';
        else
          last_char_was_newline = false;
        for (; i < length; offset += lengths[i++]) {
          if (wordstr[offset] == ' ' ||
              wordstr[offset] == kTesseractReject) {
            *ptr++ = kUNLVReject;
            last_char_was_tilde = true;
          } else {
            if (word->reject_map[i].rejected())
              *ptr++ = kUNLVSuspect;
            UNICHAR ch(wordstr + offset, lengths[i]);
            int uni_ch = ch.first_uni();
            for (int j = 0; kUniChs[j] != 0; ++j) {
              if (kUniChs[j] == uni_ch) {
                uni_ch = kLatinChs[j];
                break;
              }
            }
            if (uni_ch <= 0xff) {
              *ptr++ = static_cast<char>(uni_ch);
              last_char_was_tilde = false;
            } else {
              *ptr++ = kUNLVReject;
              last_char_was_tilde = true;
            }
          }
        }
      }
    }
    if (word->word->flag(W_EOL) && !last_char_was_newline) {
      /* Add a new line output */
      *ptr++ = '\n';
      tilde_crunch_written = false;
      last_char_was_newline = true;
      last_char_was_tilde = false;
    }
  }
  *ptr++ = '\n';
  *ptr = '\0';
  return result;
}

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

                               {
  if (tesseract_ == NULL ||
      (!recognition_done_ && Recognize(NULL) < 0))
    return NULL;
  STRING text("");
  ResultIterator *it = GetIterator();
  do {
    if (it->Empty(RIL_PARA)) continue;
    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.string(), text.length() + 1);
  delete it;
  return result;
}

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

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

InitTruthCallback()

void tesseract::TessBaseAPI::InitTruthCallback ( TruthCallback *  cb )

inline

Definition at line 773 of file baseapi.h.

{ truth_cb_ = cb; }

IsValidCharacter()

bool tesseract::TessBaseAPI::IsValidCharacter

(

const char *

utf8_character

)

Definition at line 2102 of file baseapi.cpp.

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

IsValidWord()

int tesseract::TessBaseAPI::IsValidWord

(

const char *

word

)

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

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

MakeTBLOB()

TBLOB * tesseract::TessBaseAPI::MakeTBLOB ( Pix *  pix )

static

Returns a TBLOB corresponding to the entire input image.

Creates a TBLOB* from the whole pix.

Definition at line 2468 of file baseapi.cpp.

                                      {
  int width = pixGetWidth(pix);
  int height = pixGetHeight(pix);
  BLOCK block("a character", TRUE, 0, 0, 0, 0, width, height);

  // Create C_BLOBs from the page
  extract_edges(pix, &block);

  // Merge all C_BLOBs
  C_BLOB_LIST *list = block.blob_list();
  C_BLOB_IT c_blob_it(list);
  if (c_blob_it.empty())
    return NULL;
  // Move all the outlines to the first blob.
  C_OUTLINE_IT ol_it(c_blob_it.data()->out_list());
  for (c_blob_it.forward();
       !c_blob_it.at_first();
       c_blob_it.forward()) {
      C_BLOB *c_blob = c_blob_it.data();
      ol_it.add_list_after(c_blob->out_list());
  }
  // Convert the first blob to the output TBLOB.
  return TBLOB::PolygonalCopy(false, c_blob_it.data());
}

MakeTessOCRRow()

ROW * tesseract::TessBaseAPI::MakeTessOCRRow ( float  baseline, float  xheight, float  descender, float  ascender  )

static

Returns a ROW object created from the input row specification.

Definition at line 2451 of file baseapi.cpp.

                                                 {
  inT32 xstarts[] = {-32000};
  double quad_coeffs[] = {0, 0, baseline};
  return new ROW(1,
                 xstarts,
                 quad_coeffs,
                 xheight,
                 ascender - (baseline + xheight),
                 descender - baseline,
                 0,
                 0);
}

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

NormalizeTBLOB()

void tesseract::TessBaseAPI::NormalizeTBLOB ( TBLOB *  tblob, ROW *  row, bool  numeric_mode  )

static

This method baseline normalizes a TBLOB in-place. The input row is used for normalization. The denorm is an optional parameter in which the normalization-antidote is returned.

Definition at line 2498 of file baseapi.cpp.

                                                                          {
  TBOX box = tblob->bounding_box();
  float x_center = (box.left() + box.right()) / 2.0f;
  float baseline = row->base_line(x_center);
  float scale = kBlnXHeight / row->x_height();
  tblob->Normalize(NULL, NULL, NULL, x_center, baseline, scale, scale,
                   0.0f, static_cast<float>(kBlnBaselineOffset), false, NULL);
}

NumDawgs()

int tesseract::TessBaseAPI::NumDawgs

(

)

const

Return the number of dawgs loaded into tesseract_ object.

Definition at line 2805 of file baseapi.cpp.

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

oem()

OcrEngineMode tesseract::TessBaseAPI::oem ( ) const

inline

Definition at line 771 of file baseapi.h.

{ return last_oem_requested_; }

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 desciptions of other parameters.

Definition at line 1154 of file baseapi.cpp.

                                                            {
  PERF_COUNT_START("ProcessPage")
  SetInputName(filename);
  SetImage(pix);
  bool failed = false;

  if (tesseract_->tessedit_pageseg_mode == PSM_AUTO_ONLY) {
    // Disabled character recognition
    PageIterator* it = AnalyseLayout();

    if (it == NULL) {
      failed = true;
    } else {
      delete it;
    }
  } 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 = NULL;
    monitor.cancel_this = NULL;
    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(NULL) < 0;
  }

  if (tesseract_->tessedit_write_images) {
#ifndef ANDROID_BUILD
    Pix* page_pix = GetThresholdedImage();
    pixWrite("tessinput.tif", page_pix, IFF_TIFF_G4);
#endif  // ANDROID_BUILD
  }

  if (failed && retry_config != NULL && retry_config[0] != '\0') {
    // Save current config variables before switching modes.
    FILE* fp = fopen(kOldVarsFile, "wb");
    PrintVariables(fp);
    fclose(fp);
    // Switch to alternate mode for retry.
    ReadConfigFile(retry_config);
    SetImage(pix);
    Recognize(NULL);
    // Restore saved config variables.
    ReadConfigFile(kOldVarsFile);
  }

  if (renderer && !failed) {
    failed = !renderer->AddImage(this);
  }

  PERF_COUNT_END
  return !failed;
}

ProcessPages()

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

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 NULL, 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 1036 of file baseapi.cpp.

                                                             {
  bool result =
      ProcessPagesInternal(filename, retry_config, timeout_millisec, renderer);
  if (result) {
    if (tesseract_->tessedit_train_from_boxes &&
        !tesseract_->WriteTRFile(*output_file_)) {
      tprintf("Write of TR file failed: %s\n", output_file_->string());
      return false;
    }
  }
  return result;
}

ProcessPagesInternal()

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

Definition at line 1062 of file baseapi.cpp.

                                                                     {
  PERF_COUNT_START("ProcessPages")
  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, NULL, 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 = NULL;
  if (stdInput) {
    buf.assign((std::istreambuf_iterator<char>(std::cin)),
               (std::istreambuf_iterator<char>()));
    data = reinterpret_cast<const l_uint8 *>(buf.data());
  }

  // Here is our autodetection
  int format;
  int r = (stdInput) ?
      findFileFormatBuffer(data, &format) :
      findFileFormat(filename, &format);

  // Maybe we have a filelist
  if (r != 0 || format == IFF_UNKNOWN) {
    STRING s;
    if (stdInput) {
      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(NULL, &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 ||
               format == IFF_TIFF_ZIP);

  // Fail early if we can, before producing any output
  Pix *pix = NULL;
  if (!tiff) {
    pix = (stdInput) ? pixReadMem(data, buf.size()) : pixRead(filename);
    if (pix == NULL) {
      return false;
    }
  }

  // Begin the output
  if (renderer && !renderer->BeginDocument(unknown_title_)) {
    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;
  }
  PERF_COUNT_END
  return true;
}

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

                                              {
  if (tesseract_ == NULL)
    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;
  if (tesseract_->tessedit_resegment_from_line_boxes) {
    page_res_ = tesseract_->ApplyBoxes(*input_file_, true, block_list_);
  } else if (tesseract_->tessedit_resegment_from_boxes) {
    page_res_ = tesseract_->ApplyBoxes(*input_file_, false, block_list_);
  } else {
    page_res_ = new PAGE_RES(tesseract_->AnyLSTMLang(),
                             block_list_, &tesseract_->prev_word_best_choice_);
  }
  if (page_res_ == NULL) {
    return -1;
  }
  if (tesseract_->tessedit_train_line_recognizer) {
    tesseract_->TrainLineRecognizer(*input_file_, *output_file_, block_list_);
    tesseract_->CorrectClassifyWords(page_res_);
    return 0;
  }
  if (tesseract_->tessedit_make_boxes_from_boxes) {
    tesseract_->CorrectClassifyWords(page_res_);
    return 0;
  }

  if (truth_cb_ != NULL) {
    tesseract_->wordrec_run_blamer.set_value(true);
    PageIterator *page_it = new PageIterator(
            page_res_, tesseract_, thresholder_->GetScaleFactor(),
            thresholder_->GetScaledYResolution(),
            rect_left_, rect_top_, rect_width_, rect_height_);
    truth_cb_->Run(tesseract_->getDict().getUnicharset(),
                   image_height_, page_it, this->tesseract()->pix_grey());
    delete page_it;
  }

  int result = 0;
  if (tesseract_->interactive_display_mode) {
    #ifndef GRAPHICS_DISABLED
    tesseract_->pgeditor_main(rect_width_, rect_height_, page_res_);
    #endif  // GRAPHICS_DISABLED
    // The page_res is invalid after an interactive session, so cleanup
    // in a way that lets us continue to the next page without crashing.
    delete page_res_;
    page_res_ = NULL;
    return -1;
  } else if (tesseract_->tessedit_train_from_boxes) {
    STRING fontname;
    ExtractFontName(*output_file_, &fontname);
    tesseract_->ApplyBoxTraining(fontname, page_res_);
  } else if (tesseract_->tessedit_ambigs_training) {
    FILE *training_output_file = tesseract_->init_recog_training(*input_file_);
    // OCR the page segmented into words by tesseract.
    tesseract_->recog_training_segmented(
        *input_file_, page_res_, monitor, training_output_file);
    fclose(training_output_file);
  } else {
    // Now run the main recognition.
    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, NULL, NULL, 0)) {
      if (wait_for_text) DetectParagraphs(true);
    } else {
      result = -1;
    }
  }
  return result;
}

RecognizeForChopTest()

int tesseract::TessBaseAPI::RecognizeForChopTest

(

ETEXT_DESC *

monitor

)

Methods to retrieve information after SetAndThresholdImage(), Recognize() or TesseractRect(). (Recognize is called implicitly if needed.)Variant on Recognize used for testing chopper.

Tests the chopper by exhaustively running chop_one_blob.

Definition at line 888 of file baseapi.cpp.

                                                         {
  if (tesseract_ == NULL)
    return -1;
  if (thresholder_ == NULL || thresholder_->IsEmpty()) {
    tprintf("Please call SetImage before attempting recognition.");
    return -1;
  }
  if (page_res_ != NULL)
    ClearResults();
  if (FindLines() != 0)
    return -1;
  // Additional conditions under which chopper test cannot be run
  if (tesseract_->interactive_display_mode) return -1;

  recognition_done_ = true;

  page_res_ = new PAGE_RES(false, block_list_,
                           &(tesseract_->prev_word_best_choice_));

  PAGE_RES_IT page_res_it(page_res_);

  while (page_res_it.word() != NULL) {
    WERD_RES *word_res = page_res_it.word();
    GenericVector<TBOX> boxes;
    tesseract_->MaximallyChopWord(boxes, page_res_it.block()->block,
                                  page_res_it.row()->row, word_res);
    page_res_it.forward();
  }
  return 0;
}

RunAdaptiveClassifier()

void tesseract::TessBaseAPI::RunAdaptiveClassifier	(	TBLOB *	blob,
		int	num_max_matches,
		int *	unichar_ids,
		float *	ratings,
		int *	num_matches_returned
	)

Method to run adaptive classifier on a blob. It returns at max num_max_matches results.

Method to run adaptive classifier on a blob.

Definition at line 2771 of file baseapi.cpp.

                                                                   {
  BLOB_CHOICE_LIST* choices = new BLOB_CHOICE_LIST;
  tesseract_->AdaptiveClassifier(blob, choices);
  BLOB_CHOICE_IT choices_it(choices);
  int& index = *num_matches_returned;
  index = 0;
  for (choices_it.mark_cycle_pt();
       !choices_it.cycled_list() && index < num_max_matches;
       choices_it.forward()) {
    BLOB_CHOICE* choice = choices_it.data();
    unichar_ids[index] = choice->unichar_id();
    ratings[index] = choice->rating();
    ++index;
  }
  *num_matches_returned = index;
  delete choices;
}

set_min_orientation_margin()

void tesseract::TessBaseAPI::set_min_orientation_margin

(

double

margin

)

Definition at line 2368 of file baseapi.cpp.

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

SetDictFunc()

void tesseract::TessBaseAPI::SetDictFunc

(

DictFunc

f

)

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

Definition at line 2144 of file baseapi.cpp.

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

SetFillLatticeFunc()

void tesseract::TessBaseAPI::SetFillLatticeFunc

(

FillLatticeFunc

f

)

Sets Wordrec::fill_lattice_ function to point to the given function.

Definition at line 2170 of file baseapi.cpp.

                                                      {
  if (tesseract_ != NULL) tesseract_->fill_lattice_ = 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 545 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 570 of file baseapi.cpp.

                                   {
  if (InternalSetImage()) {
    thresholder_->SetImage(pix);
    SetInputImage(thresholder_->GetPixRect());
  }
}

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

                                                                        {
  if (tesseract_ != NULL) {
    tesseract_->getDict().probability_in_context_ = f;
    // Set it for the sublangs too.
    int num_subs = tesseract_->num_sub_langs();
    for (int i = 0; i < num_subs; ++i) {
      tesseract_->get_sub_lang(i)->getDict().probability_in_context_ = f;
    }
  }
}

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.

Definition at line 582 of file baseapi.cpp.

                                                                       {
  if (thresholder_ == NULL)
    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 555 of file baseapi.cpp.

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

SetThresholder()

void tesseract::TessBaseAPI::SetThresholder ( ImageThresholder *  thresholder )

inline

In extreme cases only, usually with a subclass of Thresholder, it is possible to provide a different Thresholder. The Thresholder may be preloaded with an image, settings etc, or they may be set after. Note that Tesseract takes ownership of the Thresholder and will delete it when it it is replaced or the API is destructed.

Definition at line 380 of file baseapi.h.

                                                     {
    delete thresholder_;
    thresholder_ = thresholder;
    ClearResults();
  }

tesseract()

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

inline

Definition at line 769 of file baseapi.h.

{ return tesseract_; }