osdetect.cpp File Reference

#include <algorithm>
#include <cmath>
#include <memory>
#include <tesseract/osdetect.h>
#include "blobbox.h"
#include "blread.h"
#include "colfind.h"
#include "fontinfo.h"
#include "imagefind.h"
#include "linefind.h"
#include "oldlist.h"
#include "qrsequence.h"
#include "ratngs.h"
#include <tesseract/strngs.h>
#include "tabvector.h"
#include "tesseractclass.h"
#include "textord.h"

Go to the source code of this file.

Functions
int	orientation_and_script_detection (STRING &filename, OSResults *osr, tesseract::Tesseract *tess)
int	os_detect (TO_BLOCK_LIST *port_blocks, OSResults *osr, tesseract::Tesseract *tess)
int	os_detect_blobs (const GenericVector< int > *allowed_scripts, BLOBNBOX_CLIST *blob_list, OSResults *osr, tesseract::Tesseract *tess)
bool	os_detect_blob (BLOBNBOX *bbox, OrientationDetector *o, ScriptDetector *s, OSResults *osr, tesseract::Tesseract *tess)
int	OrientationIdToValue (const int &id)

Variables
const float	kSizeRatioToReject = 2.0
const int	kMinAcceptableBlobHeight = 10
const float	kScriptAcceptRatio = 1.3
const float	kHanRatioInKorean = 0.7
const float	kHanRatioInJapanese = 0.3
const float	kNonAmbiguousMargin = 1.0

Function Documentation

orientation_and_script_detection()

int orientation_and_script_detection	(	STRING &	filename,
		OSResults *	osr,
		tesseract::Tesseract *	tess
	)

Definition at line 190 of file osdetect.cpp.

                                                               {
  STRING name = filename;        //truncated name
  const char *lastdot;           //of name
  TBOX page_box;
 
  lastdot = strrchr(name.c_str(), '.');
  if (lastdot != nullptr)
    name[lastdot-name.c_str()] = '\0';
 
  ASSERT_HOST(tess->pix_binary() != nullptr);
  int width = pixGetWidth(tess->pix_binary());
  int height = pixGetHeight(tess->pix_binary());
 
  BLOCK_LIST blocks;
  if (!read_unlv_file(name, width, height, &blocks))
    FullPageBlock(width, height, &blocks);
 
  // Try to remove non-text regions from consideration.
  TO_BLOCK_LIST land_blocks, port_blocks;
  remove_nontext_regions(tess, &blocks, &port_blocks);
 
  if (port_blocks.empty()) {
    // page segmentation did not succeed, so we need to find_components first.
    tess->mutable_textord()->find_components(tess->pix_binary(),
                                             &blocks, &port_blocks);
  } else {
    page_box.set_left(0);
    page_box.set_bottom(0);
    page_box.set_right(width);
    page_box.set_top(height);
    // Filter_blobs sets up the TO_BLOCKs the same as find_components does.
    tess->mutable_textord()->filter_blobs(page_box.topright(),
                                          &port_blocks, true);
  }
 
  return os_detect(&port_blocks, osr, tess);
}

OrientationIdToValue()

int OrientationIdToValue

(

const int &

id

)

Definition at line 566 of file osdetect.cpp.

                                        {
  switch (id) {
    case 0:
      return 0;
    case 1:
      return 270;
    case 2:
      return 180;
    case 3:
      return 90;
    default:
      return -1;
  }
}

os_detect()

int os_detect	(	TO_BLOCK_LIST *	port_blocks,
		OSResults *	osr,
		tesseract::Tesseract *	tess
	)

Definition at line 233 of file osdetect.cpp.

                                        {
  int blobs_total = 0;
  TO_BLOCK_IT block_it;
  block_it.set_to_list(port_blocks);
 
  BLOBNBOX_CLIST filtered_list;
  BLOBNBOX_C_IT filtered_it(&filtered_list);
 
  for (block_it.mark_cycle_pt(); !block_it.cycled_list();
       block_it.forward ()) {
    TO_BLOCK* to_block = block_it.data();
    if (to_block->block->pdblk.poly_block() &&
        !to_block->block->pdblk.poly_block()->IsText()) continue;
    BLOBNBOX_IT bbox_it;
    bbox_it.set_to_list(&to_block->blobs);
    for (bbox_it.mark_cycle_pt (); !bbox_it.cycled_list ();
         bbox_it.forward ()) {
      BLOBNBOX* bbox = bbox_it.data();
      C_BLOB*   blob = bbox->cblob();
      TBOX      box = blob->bounding_box();
      ++blobs_total;
 
      // Catch illegal value of box width and avoid division by zero.
      if (box.width() == 0) continue;
      // TODO: Can height and width be negative? If not, remove fabs.
      float y_x = std::fabs((box.height() * 1.0f) / box.width());
      float x_y = 1.0f / y_x;
      // Select a >= 1.0 ratio
      float ratio = x_y > y_x ? x_y : y_x;
      // Blob is ambiguous
      if (ratio > kSizeRatioToReject) continue;
      if (box.height() < kMinAcceptableBlobHeight) continue;
      filtered_it.add_to_end(bbox);
    }
  }
  return os_detect_blobs(nullptr, &filtered_list, osr, tess);
}

os_detect_blob()

bool os_detect_blob	(	BLOBNBOX *	bbox,
		OrientationDetector *	o,
		ScriptDetector *	s,
		OSResults *	osr,
		tesseract::Tesseract *	tess
	)

Definition at line 329 of file osdetect.cpp.

                                              {
  tess->tess_cn_matching.set_value(true); // turn it on
  tess->tess_bn_matching.set_value(false);
  C_BLOB* blob = bbox->cblob();
  TBLOB* tblob = TBLOB::PolygonalCopy(tess->poly_allow_detailed_fx, blob);
  TBOX box = tblob->bounding_box();
  FCOORD current_rotation(1.0f, 0.0f);
  FCOORD rotation90(0.0f, 1.0f);
  BLOB_CHOICE_LIST ratings[4];
  // Test the 4 orientations
  for (int i = 0; i < 4; ++i) {
    // Normalize the blob. Set the origin to the place we want to be the
    // bottom-middle after rotation.
    // Scaling is to make the rotated height the x-height.
    float scaling = static_cast<float>(kBlnXHeight) / box.height();
    float x_origin = (box.left() + box.right()) / 2.0f;
    float y_origin = (box.bottom() + box.top()) / 2.0f;
    if (i == 0 || i == 2) {
      // Rotation is 0 or 180.
      y_origin = i == 0 ? box.bottom() : box.top();
    } else {
      // Rotation is 90 or 270.
      scaling = static_cast<float>(kBlnXHeight) / box.width();
      x_origin = i == 1 ? box.left() : box.right();
    }
    std::unique_ptr<TBLOB> rotated_blob(new TBLOB(*tblob));
    rotated_blob->Normalize(nullptr, &current_rotation, nullptr,
                            x_origin, y_origin, scaling, scaling,
                            0.0f, static_cast<float>(kBlnBaselineOffset),
                            false, nullptr);
    tess->AdaptiveClassifier(rotated_blob.get(), ratings + i);
    current_rotation.rotate(rotation90);
  }
  delete tblob;
 
  bool stop = o->detect_blob(ratings);
  s->detect_blob(ratings);
  int orientation = o->get_orientation();
  stop = s->must_stop(orientation) && stop;
  return stop;
}

os_detect_blobs()

int os_detect_blobs	(	const GenericVector< int > *	allowed_scripts,
		BLOBNBOX_CLIST *	blob_list,
		OSResults *	osr,
		tesseract::Tesseract *	tess
	)

Definition at line 278 of file osdetect.cpp.

                                              {
  OSResults osr_;
  int minCharactersToTry = tess->min_characters_to_try;
  int maxCharactersToTry = 5 * minCharactersToTry;
  if (osr == nullptr)
    osr = &osr_;
 
  osr->unicharset = &tess->unicharset;
  OrientationDetector o(allowed_scripts, osr);
  ScriptDetector s(allowed_scripts, osr, tess);
 
  BLOBNBOX_C_IT filtered_it(blob_list);
  int real_max = std::min(filtered_it.length(), maxCharactersToTry);
  // tprintf("Total blobs found = %d\n", blobs_total);
  // tprintf("Number of blobs post-filtering = %d\n", filtered_it.length());
  // tprintf("Number of blobs to try = %d\n", real_max);
 
  // If there are too few characters, skip this page entirely.
  if (real_max < minCharactersToTry / 2) {
    tprintf("Too few characters. Skipping this page\n");
    return 0;
  }
 
  auto** blobs = new BLOBNBOX*[filtered_it.length()];
  int number_of_blobs = 0;
  for (filtered_it.mark_cycle_pt (); !filtered_it.cycled_list ();
       filtered_it.forward ()) {
    blobs[number_of_blobs++] = filtered_it.data();
  }
  QRSequenceGenerator sequence(number_of_blobs);
  int num_blobs_evaluated = 0;
  for (int i = 0; i < real_max; ++i) {
    if (os_detect_blob(blobs[sequence.GetVal()], &o, &s, osr, tess)
        && i > minCharactersToTry) {
      break;
    }
    ++num_blobs_evaluated;
  }
  delete [] blobs;
 
  // Make sure the best_result is up-to-date
  int orientation = o.get_orientation();
  osr->update_best_script(orientation);
  return num_blobs_evaluated;
}

Variable Documentation

kHanRatioInJapanese

const float kHanRatioInJapanese = 0.3

Definition at line 46 of file osdetect.cpp.

kHanRatioInKorean

const float kHanRatioInKorean = 0.7

Definition at line 45 of file osdetect.cpp.

kMinAcceptableBlobHeight

const int kMinAcceptableBlobHeight = 10

Definition at line 41 of file osdetect.cpp.

kNonAmbiguousMargin

const float kNonAmbiguousMargin = 1.0

Definition at line 48 of file osdetect.cpp.

kScriptAcceptRatio

const float kScriptAcceptRatio = 1.3

Definition at line 43 of file osdetect.cpp.

kSizeRatioToReject

const float kSizeRatioToReject = 2.0

Definition at line 40 of file osdetect.cpp.