ccmain/osdetect.cpp - platform/external/tesseract - Git at Google

 ///////////////////////////////////////////////////////////////////////
 // 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);
 }
	///////////////////////////////////////////////////////////////////////
	// 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);
	}