tesseract/ccmain/osdetect.cpp

///////////////////////////////////////////////////////////////////////
// File:        osdetect.cpp
// Description: Orientation and script detection.
// Author:      Samuel Charron
//
// (C) Copyright 2008, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///////////////////////////////////////////////////////////////////////

#include "osdetect.h"

#include "strngs.h"
#include "blobbox.h"
#include "blread.h"
#include "tordmain.h"
#include "ratngs.h"
#include "oldlist.h"
#include "adaptmatch.h"
#include "tstruct.h"
#include "expandblob.h"
#include "tesseractclass.h"
#include "qrsequence.h"

extern IMAGE page_image;

const int kMinCharactersToTry = 50;
const int kMaxCharactersToTry = 5 * kMinCharactersToTry;

const float kSizeRatioToReject = 2.0;

const float kOrientationAcceptRatio = 1.3;
const float kScriptAcceptRatio = 1.3;

const float kHanRatioInKorean = 0.7;
const float kHanRatioInJapanese = 0.3;

const float kLatinRationInFraktur = 0.7;

const float kNonAmbiguousMargin = 1.0;

// General scripts
static const char* han_script = "Han";
static const char* latin_script = "Latin";
static const char* katakana_script = "Katakana";
static const char* hiragana_script = "Hiragana";
static const char* hangul_script = "Hangul";

// Pseudo-scripts Name
const char* ScriptDetector::korean_script_ = "Korean";
const char* ScriptDetector::japanese_script_ = "Japanese";
const char* ScriptDetector::fraktur_script_ = "Fraktur";

CLISTIZEH(BLOBNBOX);
CLISTIZE(BLOBNBOX);

// Find connected components in the page and process a subset until finished or
// a stopping criterion is met.
// Returns true if the page was successfully processed.
bool orientation_and_script_detection(STRING& filename,
                                      OSResults* osr,
                                      tesseract::Tesseract* tess) {
  STRING name = filename;        //truncated name
  const char *lastdot;           //of name
  TO_BLOCK_LIST land_blocks, port_blocks;
  BLOCK_LIST blocks;
  TBOX page_box;

  lastdot = strrchr (name.string (), '.');
  if (lastdot != NULL)
    name[lastdot-name.string()] = '\0';
  if (!read_unlv_file(name, page_image.get_xsize(), page_image.get_ysize(),
                     &blocks))
    FullPageBlock(page_image.get_xsize(), page_image.get_ysize(), &blocks);
  find_components(&blocks, &land_blocks, &port_blocks, &page_box);
  return os_detect(&port_blocks, osr, tess);
}

// Filter and sample the blobs.
// Returns true if the page was successfully processed, or false if the page had
// too few characters to be reliable
bool os_detect(TO_BLOCK_LIST* port_blocks, OSResults* osr,
               tesseract::Tesseract* tess) {
  int blobs_total = 0;
  OSResults osr_;
  if (osr == NULL)
    osr = &osr_;

  osr->unicharset = &tess->unicharset;
  OrientationDetector o(osr);
  ScriptDetector s(osr, tess);

  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* block = block_it.data();
    BLOBNBOX_IT bbox_it;
    bbox_it.set_to_list(&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;

      float y_x = fabs((box.height() * 1.0) / 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() < 10) continue;
      filtered_it.add_to_end(bbox);
    }
  }
  if (filtered_it.length() > 0)
    filtered_it.move_to_first();

  int real_max = MIN(filtered_it.length(), kMaxCharactersToTry);
   printf("Total blobs found = %d\n", blobs_total);
   printf("Number of blobs post-filtering = %d\n", filtered_it.length());
   printf("Number of blobs to try = %d\n", real_max);

  // If there are too few characters, skip this page entirely.
  if (real_max < kMinCharactersToTry / 2) {
    printf("Too few characters. Skipping this page\n");
    return false;
  }

  BLOBNBOX** 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++] = (BLOBNBOX*)filtered_it.data();
  }
  QRSequenceGenerator sequence(number_of_blobs);
  for (int i = 0; i < real_max; ++i) {
    if (os_detect_blob(blobs[sequence.GetVal()], &o, &s, osr, tess)
        && i > kMinCharactersToTry) {
      break;
    }
  }
  delete [] blobs;

  // Make sure the best_result is up-to-date
  int orientation = o.get_orientation();
  s.update_best_script(orientation);
  return true;
}

// Processes a single blob to estimate script and orientation.
// Return true if estimate of orientation and script satisfies stopping
// criteria.
bool os_detect_blob(BLOBNBOX* bbox, OrientationDetector* o,
                    ScriptDetector* s, OSResults* osr,
                    tesseract::Tesseract* tess) {
  C_BLOB*   blob = bbox->cblob();
  TBOX      box = blob->bounding_box();

  int       x_mid = (box.left() + box.right()) / 2.0f;
  int       y_mid = (box.bottom() + box.top()) / 2.0f;

  PBLOB     pblob(blob, box.height());

  BLOB_CHOICE_LIST ratings[4];
  // Test the 4 orientations
  for (int i = 0; i < 4; ++i) {
    // normalize the blob
    pblob.move(FCOORD(-x_mid, -box.bottom()));
    pblob.scale(static_cast<float>(bln_x_height) / box.height());
    pblob.move(FCOORD(0.0f, bln_baseline_offset));

    {
      // List of choices given by the classifier
      TBLOB *tessblob;               //converted blob
      TEXTROW tessrow;               //dummy row

      tess_cn_matching.set_value(true); // turn it on
      tess_bn_matching.set_value(false);
      //convert blob
      tessblob = make_tess_blob (&pblob, TRUE);
      //make dummy row
      make_tess_row(NULL, &tessrow);
      //classify
      tess->AdaptiveClassifier (tessblob, NULL, &tessrow, ratings + i, NULL);
      free_blob(tessblob);
    }
    // undo normalize
    pblob.move(FCOORD(0.0f, -bln_baseline_offset));
    pblob.scale(1.0f / (static_cast<float>(bln_x_height) / box.height()));
    pblob.move(FCOORD(x_mid, box.bottom()));

    // center the blob
    pblob.move(FCOORD(-x_mid, -y_mid));

    // Rotate it
    pblob.rotate();

    // Re-compute the mid
    box = pblob.bounding_box();
    x_mid = (box.left() + box.right()) / 2;
    y_mid = (box.top() + box.bottom()) / 2;

    // re-center in the new mid
    pblob.move(FCOORD(x_mid, y_mid));
  }

  bool stop = o->detect_blob(ratings);
  s->detect_blob(ratings);
  int orientation = o->get_orientation();
  stop = s->must_stop(orientation) && stop;
  return stop;
}


OrientationDetector::OrientationDetector(OSResults* osr) {
  osr_ = osr;
}

// Score the given blob and return true if it is now sure of the orientation
// after adding this block.
bool OrientationDetector::detect_blob(BLOB_CHOICE_LIST* scores) {
  for (int i = 0; i < 4; ++i) {
    BLOB_CHOICE_IT choice_it;
    choice_it.set_to_list(scores + i);

    if (!choice_it.empty()) {
      osr_->orientations[i] += (100 + choice_it.data()->certainty());
    }
  }

  float first = -1;
  float second = -1;

  int idx = -1;
  for (int i = 0; i < 4; ++i) {
    if (osr_->orientations[i] > first) {
      idx = i;
      second = first;
      first = osr_->orientations[i];
    } else if (osr_->orientations[i] > second) {
      second = osr_->orientations[i];
    }
  }

  return first / second > kOrientationAcceptRatio;
}

void OrientationDetector::update_best_orientation() {
  float first = osr_->orientations[0];
  float second = osr_->orientations[1];

  if (first < second) {
    second = first;
    first = osr_->orientations[1];
  }

  osr_->best_result.orientation = 0;
  osr_->best_result.oconfidence = 0;

  for (int i = 0; i < 4; ++i) {
    if (osr_->orientations[i] > first) {
      second = first;
      first = osr_->orientations[i];
      osr_->best_result.orientation = i;
    } else if (osr_->orientations[i] > second) {
      second = osr_->orientations[i];
    }
  }

  osr_->best_result.oconfidence =
      (first / second - 1.0) / (kOrientationAcceptRatio - 1.0);
}

int OrientationDetector::get_orientation() {
  update_best_orientation();
  return osr_->best_result.orientation;
}


ScriptDetector::ScriptDetector(OSResults* osr, tesseract::Tesseract* tess) {
  osr_ = osr;
  tess_ = tess;
  katakana_id_ = tess_->unicharset.add_script(katakana_script);
  hiragana_id_ = tess_->unicharset.add_script(hiragana_script);
  han_id_ = tess_->unicharset.add_script(han_script);
  hangul_id_ = tess_->unicharset.add_script(hangul_script);
  japanese_id_ = tess_->unicharset.add_script(japanese_script_);
  korean_id_ = tess_->unicharset.add_script(korean_script_);
  latin_id_ = tess_->unicharset.add_script(latin_script);
  fraktur_id_ = tess_->unicharset.add_script(fraktur_script_);
}


// Score the given blob and return true if it is now sure of the script after
// adding this blob.
void ScriptDetector::detect_blob(BLOB_CHOICE_LIST* scores) {
  bool done[kMaxNumberOfScripts];
  for (int i = 0; i < 4; ++i) {
    for (int j = 0; j < kMaxNumberOfScripts; ++j)
      done[j] = false;

    BLOB_CHOICE_IT choice_it;
    choice_it.set_to_list(scores + i);

    float prev_score = -1;
    int script_count = 0;
    int prev_id = -1;
    int prev_script;
    int prev_class_id = -1;
    int prev_config = -1;
    const char* prev_unichar = "";
    const char* unichar = "";
    float next_best_score = -1.0;
    int next_best_script_id = -1;
    const char* next_best_unichar = "";

    for (choice_it.mark_cycle_pt(); !choice_it.cycled_list();
         choice_it.forward()) {
      BLOB_CHOICE* choice = choice_it.data();
      int id = choice->script_id();
      // Script already processed before.
      if (done[id]) continue;
      done[id] = true;

      unichar = tess_->unicharset.id_to_unichar(choice->unichar_id());
      // Save data from the first match
      if (prev_score < 0) {
        prev_score = -choice->certainty();
        script_count = 1;
        prev_id = id;
        prev_script = choice->script_id();
        prev_unichar = unichar;
        prev_class_id = choice->unichar_id();
        prev_config = choice->config();
      } else if (-choice->certainty() < prev_score + kNonAmbiguousMargin) {
        script_count++;
        next_best_score = -choice->certainty();
        next_best_script_id = choice->script_id();
        next_best_unichar = tess_->unicharset.id_to_unichar(choice->unichar_id());
      }

      if (strlen(prev_unichar) == 1)
        if (unichar[0] >= '0' && unichar[0] <= '9')
          break;

      // if script_count is >= 2, character is ambiguous, skip other matches
      // since they are useless.
      if (script_count >= 2)
        break;
    }
    // Character is non ambiguous
    if (script_count == 1) {
      // Update the score of the winning script
      osr_->scripts_na[i][prev_id] += 1;

      // Workaround for Fraktur
      if (prev_id == latin_id_) {
        int font_set_id = tess_->PreTrainedTemplates->
            Class[prev_class_id]->font_set_id;
        if (font_set_id >= 0 && prev_config >= 0) {
          FontInfo fi = tess_->get_fontinfo_table().get(
              tess_->get_fontset_table().get(font_set_id).configs[prev_config]);
          //printf("Font: %s i:%i b:%i f:%i s:%i k:%i (%s)\n", fi.name,
          //       fi.is_italic(), fi.is_bold(), fi.is_fixed_pitch(),
          //       fi.is_serif(), fi.is_fraktur(),
          //       prev_unichar);
          if (fi.is_fraktur()) {
            osr_->scripts_na[i][prev_id] -= 1;
            osr_->scripts_na[i][fraktur_id_] += 1;
          }
        }
      }

      // Update Japanese / Korean pseudo-scripts
      if (prev_id == katakana_id_)
        osr_->scripts_na[i][japanese_id_] += 1;
      if (prev_id == hiragana_id_)
        osr_->scripts_na[i][japanese_id_] += 1;
      if (prev_id == hangul_id_)
        osr_->scripts_na[i][korean_id_] += 1;
      if (prev_id == han_id_)
        osr_->scripts_na[i][korean_id_] += kHanRatioInKorean;
      if (prev_id == han_id_)
        osr_->scripts_na[i][japanese_id_] += kHanRatioInJapanese;
    }
  }  // iterate over each orientation
}

bool ScriptDetector::must_stop(int orientation) {
  update_best_script(orientation);
  return osr_->best_result.sconfidence > 1;
}


void ScriptDetector::update_best_script(int orientation) {
  float first = -1;
  float second = -1;

  // i = 1 -> ignore Common scripts
  for (int i = 1; i < kMaxNumberOfScripts; ++i) {
    if (osr_->scripts_na[orientation][i] > first) {
      osr_->best_result.script =
          tess_->unicharset.get_script_from_script_id(i);
      second = first;
      first = osr_->scripts_na[orientation][i];
    } else if (osr_->scripts_na[orientation][i] > second) {
      second = osr_->scripts_na[orientation][i];
    }
  }

  osr_->best_result.sconfidence =
      (first / second - 1.0) / (kOrientationAcceptRatio - 1.0);
}