/**********************************************************************
* File: adaptions.cpp (Formerly adaptions.c)
* Description: Functions used to adapt to blobs already confidently
* identified
* Author: Chris Newton
* Created: Thu Oct 7 10:17:28 BST 1993
*
* (C) Copyright 1992, Hewlett-Packard Ltd.
** 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 "mfcpch.h"
#ifdef __UNIX__
#include <assert.h>
#endif
#include <ctype.h>
#include <string.h>
#include "tessbox.h"
#include "tessvars.h"
#include "memry.h"
#include "mainblk.h"
#include "charcut.h"
#include "imgs.h"
#include "scaleimg.h"
#include "reject.h"
#include "control.h"
#include "adaptions.h"
#include "stopper.h"
#include "charsample.h"
#include "matmatch.h"
#include "secname.h"
#include "tesseractclass.h"
inT32 demo_word = 0;
#define WINDOWNAMESIZE 13 /*max size of name */
#define EXTERN
EXTERN BOOL_VAR (tessedit_reject_ems, FALSE, "Reject all m's");
EXTERN BOOL_VAR (tessedit_reject_suspect_ems, FALSE, "Reject suspect m's");
EXTERN double_VAR (tessedit_cluster_t1, 0.20,
"t1 threshold for clustering samples");
EXTERN double_VAR (tessedit_cluster_t2, 0.40,
"t2 threshold for clustering samples");
EXTERN double_VAR (tessedit_cluster_t3, 0.12,
"Extra threshold for clustering samples, only keep a new sample if best score greater than this value");
EXTERN double_VAR (tessedit_cluster_accept_fraction, 0.80,
"Largest fraction of characters in cluster for it to be used for adaption");
EXTERN INT_VAR (tessedit_cluster_min_size, 3,
"Smallest number of samples in a cluster for it to be used for adaption");
EXTERN BOOL_VAR (tessedit_cluster_debug, FALSE,
"Generate and print debug information for adaption by clustering");
EXTERN BOOL_VAR (tessedit_use_best_sample, FALSE,
"Use best sample from cluster when adapting");
EXTERN BOOL_VAR (tessedit_test_cluster_input, FALSE,
"Set reject map to enable cluster input to be measured");
EXTERN BOOL_VAR (tessedit_matrix_match, TRUE, "Use matrix matcher");
EXTERN BOOL_VAR (tessedit_mm_use_non_adaption_set, FALSE,
"Don't try to adapt to characters on this list");
EXTERN STRING_VAR (tessedit_non_adaption_set, ",.;:'~@*",
"Characters to be avoided when adapting");
EXTERN BOOL_VAR (tessedit_mm_adapt_using_prototypes, TRUE,
"Use prototypes when adapting");
EXTERN BOOL_VAR (tessedit_mm_use_prototypes, TRUE,
"Use prototypes as clusters are built");
EXTERN BOOL_VAR (tessedit_mm_use_rejmap, FALSE,
"Adapt to characters using reject map");
EXTERN BOOL_VAR (tessedit_mm_all_rejects, FALSE,
"Adapt to all characters using, matrix matcher");
EXTERN BOOL_VAR (tessedit_mm_only_match_same_char, FALSE,
"Only match samples against clusters for the same character");
EXTERN BOOL_VAR (tessedit_process_rns, FALSE, "Handle m - rn ambigs");
EXTERN BOOL_VAR (tessedit_demo_adaption, FALSE,
"Display cut images and matrix match for demo purposes");
EXTERN INT_VAR (tessedit_demo_word1, 62,
"Word number of first word to display");
EXTERN INT_VAR (tessedit_demo_word2, 64,
"Word number of second word to display");
EXTERN STRING_VAR (tessedit_demo_file, "academe",
"Name of document containing demo words");
EXTERN BOOL_VAR(tessedit_adapt_to_char_fragments, TRUE,
"Adapt to words that contain "
" a character composed form fragments");
namespace tesseract {
BOOL8 Tesseract::word_adaptable( //should we adapt?
WERD_RES *word,
uinT16 mode) {
if (tessedit_adaption_debug) {
tprintf("Running word_adaptable() for %s rating %.4f certainty %.4f\n",
word->best_choice == NULL ? "" :
word->best_choice->unichar_string().string(),
word->best_choice->rating(), word->best_choice->certainty());
}
BOOL8 status = FALSE;
BITS16 flags(mode);
enum MODES
{
ADAPTABLE_WERD,
ACCEPTABLE_WERD,
CHECK_DAWGS,
CHECK_SPACES,
CHECK_ONE_ELL_CONFLICT,
CHECK_AMBIG_WERD
};
/*
0: NO adaption
*/
if (mode == 0) {
if (tessedit_adaption_debug) tprintf("adaption disabled\n");
return FALSE;
}
if (flags.bit (ADAPTABLE_WERD)) {
status |= word->tess_would_adapt; // result of Classify::AdaptableWord()
if (tessedit_adaption_debug && !status) {
tprintf("tess_would_adapt bit is false\n");
}
}
if (flags.bit (ACCEPTABLE_WERD)) {
status |= word->tess_accepted;
if (tessedit_adaption_debug && !status) {
tprintf("tess_accepted bit is false\n");
}
}
if (!status) { // If not set then
return FALSE; // ignore other checks
}
if (flags.bit (CHECK_DAWGS) &&
(word->best_choice->permuter () != SYSTEM_DAWG_PERM) &&
(word->best_choice->permuter () != FREQ_DAWG_PERM) &&
(word->best_choice->permuter () != USER_DAWG_PERM) &&
(word->best_choice->permuter () != NUMBER_PERM)) {
if (tessedit_adaption_debug) tprintf("word not in dawgs\n");
return FALSE;
}
if (flags.bit (CHECK_ONE_ELL_CONFLICT) && one_ell_conflict (word, FALSE)) {
if (tessedit_adaption_debug) tprintf("word has ell conflict\n");
return FALSE;
}
if (flags.bit (CHECK_SPACES) &&
(strchr(word->best_choice->unichar_string().string(), ' ') != NULL)) {
if (tessedit_adaption_debug) tprintf("word contains spaces\n");
return FALSE;
}
// if (flags.bit (CHECK_AMBIG_WERD) && test_ambig_word (word))
if (flags.bit (CHECK_AMBIG_WERD) &&
!getDict().NoDangerousAmbig(word->best_choice, NULL, false, NULL, NULL)) {
if (tessedit_adaption_debug) tprintf("word is ambiguous\n");
return FALSE;
}
// Do not adapt to words that are composed from fragments if
// tessedit_adapt_to_char_fragments is false.
if (!tessedit_adapt_to_char_fragments) {
const char *fragment_lengths = word->best_choice->fragment_lengths();
if (fragment_lengths != NULL && *fragment_lengths != '\0') {
for (int i = 0; i < word->best_choice->length(); ++i) {
if (fragment_lengths[i] > 1) {
if (tessedit_adaption_debug) tprintf("won't adapt to fragments\n");
return false; // found a character composed from fragments
}
}
}
}
if (tessedit_adaption_debug) {
tprintf("returning status %d\n", status);
}
return status;
}
void Tesseract::collect_ems_for_adaption(WERD_RES *word,
CHAR_SAMPLES_LIST *char_clusters,
CHAR_SAMPLE_LIST *chars_waiting) {
PBLOB_LIST *blobs = word->outword->blob_list ();
PBLOB_IT blob_it(blobs);
inT16 i;
CHAR_SAMPLE *sample;
PIXROW_LIST *pixrow_list;
PIXROW_IT pixrow_it;
IMAGELINE *imlines; // lines of the image
TBOX pix_box; // box of imlines
// extent
WERD copy_outword; // copy to denorm
PBLOB_IT copy_blob_it;
OUTLINE_IT copy_outline_it;
inT32 resolution = page_image.get_res ();
if (tessedit_reject_ems || tessedit_reject_suspect_ems)
return; // Do nothing
if (word->word->bounding_box ().height () > resolution / 3)
return;
if (tessedit_demo_adaption)
// Make sure not set
tessedit_display_mm.set_value (FALSE);
if (word_adaptable (word, tessedit_em_adaption_mode)
&& word->reject_map.reject_count () == 0
&& (strchr (word->best_choice->unichar_string().string (), 'm') != NULL
|| (tessedit_process_rns
&& strstr (word->best_choice->unichar_string().string (),
"rn") != NULL))) {
if (tessedit_process_rns
&& strstr (word->best_choice->unichar_string().string (), "rn") != NULL) {
copy_outword = *(word->outword);
copy_blob_it.set_to_list (copy_outword.blob_list ());
i = 0;
while (word->best_choice->unichar_string()[i] != '\0') {
if (word->best_choice->unichar_string()[i] == 'r'
&& word->best_choice->unichar_string()[i + 1] == 'n') {
copy_outline_it.set_to_list (copy_blob_it.data ()->
out_list ());
copy_outline_it.add_list_after (copy_blob_it.
data_relative (1)->
out_list ());
copy_blob_it.forward ();
delete (copy_blob_it.extract ());
i++;
}
copy_blob_it.forward ();
i++;
}
}
else
copy_outword = *(word->outword);
copy_outword.baseline_denormalise (&word->denorm);
char_clip_word(©_outword, page_image, pixrow_list, imlines, pix_box);
pixrow_it.set_to_list (pixrow_list);
pixrow_it.move_to_first ();
blob_it.move_to_first ();
for (i = 0;
word->best_choice->unichar_string()[i] != '\0';
i++, pixrow_it.forward (), blob_it.forward ()) {
if (word->best_choice->unichar_string()[i] == 'm'
|| (word->best_choice->unichar_string()[i] == 'r'
&& word->best_choice->unichar_string()[i + 1] == 'n')) {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample %c for adaption found in %s, index %d\n",
word->best_choice->unichar_string()[i],
word->best_choice->unichar_string().string (), i);
#endif
if (tessedit_matrix_match) {
sample = clip_sample (pixrow_it.data (),
imlines,
pix_box,
copy_outword.flag (W_INVERSE),
word->best_choice->unichar_string()[i]);
if (sample == NULL) { //Clip failed
#ifndef SECURE_NAMES
tprintf ("Unable to clip sample from %s, index %d\n",
word->best_choice->unichar_string().string (), i);
#endif
if (word->best_choice->unichar_string()[i] == 'r')
i++;
continue;
}
}
else
sample = new CHAR_SAMPLE (blob_it.data (),
&word->denorm,
word->best_choice->unichar_string()[i]);
cluster_sample(sample, char_clusters, chars_waiting);
if (word->best_choice->unichar_string()[i] == 'r')
i++; // Skip next character
}
}
delete[]imlines; // Free array of imlines
delete pixrow_list;
}
}
void Tesseract::collect_characters_for_adaption(
WERD_RES *word,
CHAR_SAMPLES_LIST *char_clusters,
CHAR_SAMPLE_LIST *chars_waiting) {
PBLOB_LIST *blobs = word->outword->blob_list ();
PBLOB_IT blob_it(blobs);
inT16 i;
CHAR_SAMPLE *sample;
PIXROW_LIST *pixrow_list;
PIXROW_IT pixrow_it;
IMAGELINE *imlines; // lines of the image
TBOX pix_box; // box of imlines
// extent
WERD copy_outword; // copy to denorm
inT32 resolution = page_image.get_res ();
if (word->word->bounding_box ().height () > resolution / 3)
return;
if (tessedit_demo_adaption)
// Make sure not set
tessedit_display_mm.set_value (FALSE);
if ((word_adaptable (word, tessedit_cluster_adaption_mode)
&& word->reject_map.reject_count () == 0) || tessedit_mm_use_rejmap) {
if (tessedit_test_cluster_input && !tessedit_mm_use_rejmap)
return; // Reject map set to acceptable
/* Collect information about good matches */
copy_outword = *(word->outword);
copy_outword.baseline_denormalise (&word->denorm);
char_clip_word(©_outword, page_image, pixrow_list, imlines, pix_box);
pixrow_it.set_to_list (pixrow_list);
pixrow_it.move_to_first ();
blob_it.move_to_first ();
for (i = 0;
word->best_choice->unichar_string()[i] != '\0';
i++, pixrow_it.forward (), blob_it.forward ()) {
if (!(tessedit_mm_use_non_adaption_set
&& STRING(tessedit_non_adaption_set).contains(
word->best_choice->unichar_string()[i]))
|| (tessedit_mm_use_rejmap && word->reject_map[i].accepted ())) {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample %c for adaption found in %s, index %d\n",
word->best_choice->unichar_string()[i],
word->best_choice->unichar_string().string (), i);
#endif
sample = clip_sample (pixrow_it.data (),
imlines,
pix_box,
copy_outword.flag (W_INVERSE),
word->best_choice->unichar_string()[i]);
if (sample == NULL) { //Clip failed
#ifndef SECURE_NAMES
tprintf ("Unable to clip sample from %s, index %d\n",
word->best_choice->unichar_string().string (), i);
#endif
continue;
}
cluster_sample(sample, char_clusters, chars_waiting);
}
}
delete[]imlines; // Free array of imlines
delete pixrow_list;
}
else if (tessedit_test_cluster_input && !tessedit_mm_use_rejmap)
// Set word to all rejects
word->reject_map.rej_word_tess_failure ();
}
void Tesseract::cluster_sample(CHAR_SAMPLE *sample,
CHAR_SAMPLES_LIST *char_clusters,
CHAR_SAMPLE_LIST *chars_waiting) {
CHAR_SAMPLES *best_cluster = NULL;
CHAR_SAMPLES_IT c_it = char_clusters;
CHAR_SAMPLE_IT cw_it = chars_waiting;
float score;
float best_score = MAX_INT32;
if (c_it.empty ())
c_it.add_to_end (new CHAR_SAMPLES (sample));
else {
for (c_it.mark_cycle_pt (); !c_it.cycled_list (); c_it.forward ()) {
score = c_it.data ()->match_score (sample, this);
if (score < best_score) {
best_score = score;
best_cluster = c_it.data ();
}
}
if (tessedit_cluster_debug)
tprintf ("Sample's best score %f\n", best_score);
if (best_score < tessedit_cluster_t1) {
if (best_score > tessedit_cluster_t3 || tessedit_mm_use_prototypes) {
best_cluster->add_sample (sample, this);
check_wait_list(chars_waiting, sample, best_cluster);
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample added to an existing cluster\n");
#endif
}
else {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf
("Sample dropped, good match to an existing cluster\n");
#endif
}
}
else if (best_score > tessedit_cluster_t2) {
c_it.add_to_end (new CHAR_SAMPLES (sample));
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("New cluster created for this sample\n");
#endif
}
else {
cw_it.add_to_end (sample);
if (tessedit_cluster_debug)
tprintf ("Sample added to the wait list\n");
}
}
}
void Tesseract::check_wait_list(CHAR_SAMPLE_LIST *chars_waiting,
CHAR_SAMPLE *sample,
CHAR_SAMPLES *best_cluster) {
CHAR_SAMPLE *wait_sample;
CHAR_SAMPLE *test_sample = sample;
CHAR_SAMPLE_IT cw_it = chars_waiting;
CHAR_SAMPLE_LIST add_list; //Samples added to best cluster
CHAR_SAMPLE_IT add_it = &add_list;
float score;
add_list.clear ();
if (!cw_it.empty ()) {
do {
if (!add_list.empty ()) {
add_it.forward ();
test_sample = add_it.extract ();
best_cluster->add_sample (test_sample, this);
}
for (cw_it.mark_cycle_pt ();
!cw_it.cycled_list (); cw_it.forward ()) {
wait_sample = cw_it.data ();
if (tessedit_mm_use_prototypes)
score = best_cluster->match_score (wait_sample, this);
else
score = sample->match_sample (wait_sample, FALSE, this);
if (score < tessedit_cluster_t1) {
if (score > tessedit_cluster_t3
|| tessedit_mm_use_prototypes) {
add_it.add_after_stay_put (cw_it.extract ());
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf
("Wait sample added to an existing cluster\n");
#endif
}
else {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf
("Wait sample dropped, good match to an existing cluster\n");
#endif
}
}
}
}
while (!add_list.empty ());
}
}
void Tesseract::complete_clustering(CHAR_SAMPLES_LIST *char_clusters,
CHAR_SAMPLE_LIST *chars_waiting) {
CHAR_SAMPLES *best_cluster;
CHAR_SAMPLES_IT c_it = char_clusters;
CHAR_SAMPLE_IT cw_it = chars_waiting;
CHAR_SAMPLE *sample;
inT32 total_sample_count = 0;
while (!cw_it.empty ()) {
cw_it.move_to_first ();
sample = cw_it.extract ();
best_cluster = new CHAR_SAMPLES (sample);
c_it.add_to_end (best_cluster);
check_wait_list(chars_waiting, sample, best_cluster);
}
for (c_it.mark_cycle_pt (); !c_it.cycled_list (); c_it.forward ()) {
c_it.data ()->assign_to_char ();
if (tessedit_use_best_sample)
c_it.data ()->find_best_sample ();
else if (tessedit_mm_adapt_using_prototypes)
c_it.data ()->build_prototype ();
if (tessedit_cluster_debug)
total_sample_count += c_it.data ()->n_samples ();
}
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Clustering completed, %d samples in all\n", total_sample_count);
#endif
#ifndef GRAPHICS_DISABLED
if (tessedit_demo_adaption)
display_cluster_prototypes(char_clusters);
#endif
}
void Tesseract::adapt_to_good_ems(WERD_RES *word,
CHAR_SAMPLES_LIST *char_clusters,
CHAR_SAMPLE_LIST *chars_waiting) {
PBLOB_LIST *blobs = word->outword->blob_list ();
PBLOB_IT blob_it(blobs);
inT16 i;
CHAR_SAMPLE *sample;
CHAR_SAMPLES_IT c_it = char_clusters;
CHAR_SAMPLE_IT cw_it = chars_waiting;
float score;
float best_score;
char best_char;
CHAR_SAMPLES *best_cluster;
PIXROW_LIST *pixrow_list;
PIXROW_IT pixrow_it;
IMAGELINE *imlines; // lines of the image
TBOX pix_box; // box of imlines
// extent
WERD copy_outword; // copy to denorm
TBOX b_box;
PBLOB_IT copy_blob_it;
OUTLINE_IT copy_outline_it;
PIXROW *pixrow = NULL;
static inT32 word_number = 0;
#ifndef GRAPHICS_DISABLED
ScrollView* demo_win = NULL;
#endif
inT32 resolution = page_image.get_res ();
if (word->word->bounding_box ().height () > resolution / 3)
return;
word_number++;
if (strchr (word->best_choice->unichar_string().string (), 'm') == NULL
&& (tessedit_process_rns
&& strstr (word->best_choice->unichar_string().string (), "rn") == NULL))
return;
if (tessedit_reject_ems)
reject_all_ems(word);
else if (tessedit_reject_suspect_ems)
reject_suspect_ems(word);
else {
if (char_clusters->length () == 0) {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("No clusters to use for em adaption\n");
#endif
return;
}
if (!cw_it.empty ()) {
complete_clustering(char_clusters, chars_waiting);
print_em_stats(char_clusters, chars_waiting);
}
if ((!word_adaptable (word, tessedit_em_adaption_mode) ||
word->reject_map.reject_count () != 0)
&& (strchr (word->best_choice->unichar_string().string (), 'm') != NULL
|| (tessedit_process_rns
&& strstr (word->best_choice->unichar_string().string (),
"rn") != NULL))) {
if (tessedit_process_rns
&& strstr (word->best_choice->unichar_string().string (),
"rn") != NULL) {
copy_outword = *(word->outword);
copy_blob_it.set_to_list (copy_outword.blob_list ());
i = 0;
while (word->best_choice->unichar_string()[i] != '\0') {
if (word->best_choice->unichar_string()[i] == 'r'
&& word->best_choice->unichar_string()[i + 1] == 'n') {
copy_outline_it.set_to_list (copy_blob_it.data ()->
out_list ());
copy_outline_it.add_list_after (copy_blob_it.
data_relative (1)->
out_list ());
copy_blob_it.forward ();
delete (copy_blob_it.extract ());
i++;
}
copy_blob_it.forward ();
i++;
}
}
else
copy_outword = *(word->outword);
copy_outword.baseline_denormalise (&word->denorm);
copy_blob_it.set_to_list (copy_outword.blob_list ());
char_clip_word(©_outword, page_image, pixrow_list, imlines, pix_box);
pixrow_it.set_to_list (pixrow_list);
pixrow_it.move_to_first ();
// For debugging only
b_box = copy_outword.bounding_box ();
pixrow = pixrow_it.data ();
blob_it.move_to_first ();
copy_blob_it.move_to_first ();
for (i = 0;
word->best_choice->unichar_string()[i] != '\0';
i++, pixrow_it.forward (), blob_it.forward (),
copy_blob_it.forward ()) {
if ((word->best_choice->unichar_string()[i] == 'm'
|| (word->best_choice->unichar_string()[i] == 'r'
&& word->best_choice->unichar_string()[i + 1] == 'n'))
&& !word->reject_map[i].perm_rejected ()) {
if (tessedit_cluster_debug)
tprintf ("Sample %c to check found in %s, index %d\n",
word->best_choice->unichar_string()[i],
word->best_choice->unichar_string().string (), i);
if (tessedit_demo_adaption)
tprintf
("Sample %c to check found in %s (%d), index %d\n",
word->best_choice->unichar_string()[i],
word->best_choice->unichar_string().string (), word_number,
i);
if (tessedit_matrix_match) {
TBOX copy_box = copy_blob_it.data ()->bounding_box ();
sample = clip_sample (pixrow_it.data (),
imlines,
pix_box,
copy_outword.flag (W_INVERSE),
word->best_choice->unichar_string()[i]);
//Clip failed
if (sample == NULL) {
tprintf
("Unable to clip sample from %s, index %d\n",
word->best_choice->unichar_string().string (), i);
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample rejected (no sample)\n");
#endif
word->reject_map[i].setrej_mm_reject ();
if (word->best_choice->unichar_string()[i] == 'r') {
word->reject_map[i + 1].setrej_mm_reject ();
i++;
}
continue;
}
}
else
sample = new CHAR_SAMPLE(blob_it.data(),
&word->denorm,
word->best_choice->unichar_string()[i]);
best_score = MAX_INT32;
best_char = '\0';
best_cluster = NULL;
for (c_it.mark_cycle_pt ();
!c_it.cycled_list (); c_it.forward ()) {
if (c_it.data ()->character () != '\0') {
score = c_it.data ()->match_score (sample, this);
if (score < best_score) {
best_cluster = c_it.data ();
best_score = score;
best_char = c_it.data ()->character ();
}
}
}
if (best_score > tessedit_cluster_t1) {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample rejected (score %f)\n", best_score);
if (tessedit_demo_adaption)
tprintf ("Sample rejected (score %f)\n", best_score);
#endif
word->reject_map[i].setrej_mm_reject ();
if (word->best_choice->unichar_string()[i] == 'r')
word->reject_map[i + 1].setrej_mm_reject ();
}
else {
if (word->best_choice->unichar_string()[i] == best_char) {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample accepted (score %f)\n",
best_score);
if (tessedit_demo_adaption)
tprintf ("Sample accepted (score %f)\n",
best_score);
#endif
word->reject_map[i].setrej_mm_accept ();
if (word->best_choice->unichar_string()[i] == 'r')
word->reject_map[i + 1].setrej_mm_accept ();
}
else {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample rejected (char %c, score %f)\n",
best_char, best_score);
if (tessedit_demo_adaption)
tprintf ("Sample rejected (char %c, score %f)\n",
best_char, best_score);
#endif
word->reject_map[i].setrej_mm_reject ();
if (word->best_choice->unichar_string()[i] == 'r')
word->reject_map[i + 1].setrej_mm_reject ();
}
}
if (tessedit_demo_adaption) {
if (strcmp (imagebasename.string (),
tessedit_demo_file.string ()) != 0
|| word_number == tessedit_demo_word1
|| word_number == tessedit_demo_word2) {
#ifndef GRAPHICS_DISABLED
demo_win =
display_clip_image(©_outword,
page_image,
pixrow_list,
pix_box);
#endif
demo_word = word_number;
best_cluster->match_score (sample, this);
demo_word = 0;
}
}
if (word->best_choice->unichar_string()[i] == 'r')
i++; // Skip next character
}
}
delete[]imlines; // Free array of imlines
delete pixrow_list;
}
}
}
void Tesseract::adapt_to_good_samples(WERD_RES *word,
CHAR_SAMPLES_LIST *char_clusters,
CHAR_SAMPLE_LIST *chars_waiting) {
PBLOB_LIST *blobs = word->outword->blob_list ();
PBLOB_IT blob_it(blobs);
inT16 i;
CHAR_SAMPLE *sample;
CHAR_SAMPLES_IT c_it = char_clusters;
CHAR_SAMPLE_IT cw_it = chars_waiting;
float score;
float best_score;
char best_char;
CHAR_SAMPLES *best_cluster;
PIXROW_LIST *pixrow_list;
PIXROW_IT pixrow_it;
IMAGELINE *imlines; // lines of the image
TBOX pix_box; // box of imlines
// extent
WERD copy_outword; // copy to denorm
TBOX b_box;
PBLOB_IT copy_blob_it;
PIXROW *pixrow = NULL;
static inT32 word_number = 0;
#ifndef GRAPHICS_DISABLED
ScrollView* demo_win = NULL;
#endif
inT32 resolution = page_image.get_res ();
word_number++;
if (tessedit_test_cluster_input)
return;
if (word->word->bounding_box ().height () > resolution / 3)
return;
if (char_clusters->length () == 0) {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("No clusters to use for adaption\n");
#endif
return;
}
if (!cw_it.empty ()) {
complete_clustering(char_clusters, chars_waiting);
print_em_stats(char_clusters, chars_waiting);
}
if ((!word_adaptable (word, tessedit_cluster_adaption_mode)
&& word->reject_map.reject_count () != 0) || tessedit_mm_use_rejmap) {
if (tessedit_cluster_debug) {
tprintf ("\nChecking: \"%s\" MAP ",
word->best_choice->unichar_string().string ());
word->reject_map.print (debug_fp);
tprintf ("\n");
}
copy_outword = *(word->outword);
copy_outword.baseline_denormalise (&word->denorm);
copy_blob_it.set_to_list (copy_outword.blob_list ());
char_clip_word(©_outword, page_image, pixrow_list, imlines, pix_box);
pixrow_it.set_to_list (pixrow_list);
pixrow_it.move_to_first ();
// For debugging only
b_box = copy_outword.bounding_box ();
pixrow = pixrow_it.data ();
blob_it.move_to_first ();
copy_blob_it.move_to_first ();
for (i = 0;
word->best_choice->unichar_string()[i] != '\0';
i++, pixrow_it.forward (), blob_it.forward (),
copy_blob_it.forward ()) {
if (word->reject_map[i].recoverable ()
|| (tessedit_mm_all_rejects && word->reject_map[i].rejected ())) {
TBOX copy_box = copy_blob_it.data ()->bounding_box ();
if (tessedit_cluster_debug)
tprintf ("Sample %c to check found in %s, index %d\n",
word->best_choice->unichar_string()[i],
word->best_choice->unichar_string().string (), i);
if (tessedit_demo_adaption)
tprintf ("Sample %c to check found in %s (%d), index %d\n",
word->best_choice->unichar_string()[i],
word->best_choice->unichar_string().string (),
word_number, i);
sample = clip_sample (pixrow_it.data (),
imlines,
pix_box,
copy_outword.flag (W_INVERSE),
word->best_choice->unichar_string()[i]);
if (sample == NULL) { //Clip failed
tprintf ("Unable to clip sample from %s, index %d\n",
word->best_choice->unichar_string().string (), i);
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample rejected (no sample)\n");
#endif
word->reject_map[i].setrej_mm_reject ();
continue;
}
best_score = MAX_INT32;
best_char = '\0';
best_cluster = NULL;
for (c_it.mark_cycle_pt ();
!c_it.cycled_list (); c_it.forward ()) {
if (c_it.data ()->character () != '\0') {
score = c_it.data ()->match_score (sample, this);
if (score < best_score) {
best_cluster = c_it.data ();
best_score = score;
best_char = c_it.data ()->character ();
}
}
}
if (best_score > tessedit_cluster_t1) {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample rejected (score %f)\n", best_score);
if (tessedit_demo_adaption)
tprintf ("Sample rejected (score %f)\n", best_score);
#endif
word->reject_map[i].setrej_mm_reject ();
}
else {
if (word->best_choice->unichar_string()[i] == best_char) {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample accepted (score %f)\n", best_score);
if (tessedit_demo_adaption)
tprintf ("Sample accepted (score %f)\n", best_score);
#endif
if (tessedit_test_adaption)
word->reject_map[i].setrej_minimal_rej_accept ();
else
word->reject_map[i].setrej_mm_accept ();
}
else {
#ifndef SECURE_NAMES
if (tessedit_cluster_debug)
tprintf ("Sample rejected (char %c, score %f)\n",
best_char, best_score);
if (tessedit_demo_adaption)
tprintf ("Sample rejected (char %c, score %f)\n",
best_char, best_score);
#endif
word->reject_map[i].setrej_mm_reject ();
}
}
if (tessedit_demo_adaption) {
if (strcmp (imagebasename.string (),
tessedit_demo_file.string ()) != 0
|| word_number == tessedit_demo_word1
|| word_number == tessedit_demo_word2) {
#ifndef GRAPHICS_DISABLED
demo_win =
display_clip_image(©_outword,
page_image,
pixrow_list,
pix_box);
#endif
demo_word = word_number;
best_cluster->match_score (sample, this);
demo_word = 0;
}
}
}
}
delete[]imlines; // Free array of imlines
delete pixrow_list;
if (tessedit_cluster_debug) {
tprintf ("\nFinal: \"%s\" MAP ",
word->best_choice->unichar_string().string ());
word->reject_map.print (debug_fp);
tprintf ("\n");
}
}
}
} // namespace tesseract
void print_em_stats(CHAR_SAMPLES_LIST *char_clusters,
CHAR_SAMPLE_LIST *chars_waiting) {
CHAR_SAMPLES_IT c_it = char_clusters;
if (!tessedit_cluster_debug)
return;
#ifndef SECURE_NAMES
tprintf ("There are %d clusters and %d samples waiting\n",
char_clusters->length (), chars_waiting->length ());
for (c_it.mark_cycle_pt (); !c_it.cycled_list (); c_it.forward ())
c_it.data ()->print (debug_fp);
#endif
tprintf ("\n");
}
CHAR_SAMPLE *clip_sample( //lines of the image
PIXROW *pixrow,
IMAGELINE *imlines,
TBOX pix_box, //box of imlines extent
BOOL8 white_on_black,
char c) {
TBOX b_box = pixrow->bounding_box ();
float baseline_pos = 0;
inT32 resolution = page_image.get_res ();
if (!b_box.null_box ()) {
ASSERT_HOST (b_box.width () < page_image.get_xsize () &&
b_box.height () < page_image.get_ysize ());
if (b_box.width () > resolution || b_box.height () > resolution) {
tprintf ("clip sample: sample too big (%d x %d)\n",
b_box.width (), b_box.height ());
return NULL;
}
IMAGE *image = new (IMAGE);
if (image->create (b_box.width (), b_box.height (), 1) == -1) {
tprintf ("clip sample: create image failed (%d x %d)\n",
b_box.width (), b_box.height ());
delete image;
return NULL;
}
if (!white_on_black)
invert_image(image); // Set background to white
pixrow->char_clip_image (imlines, pix_box, NULL, *image, baseline_pos);
if (white_on_black)
invert_image(image); //invert white on black for scaling &NN
return new CHAR_SAMPLE (image, c);
}
else
return NULL;
}
#ifndef GRAPHICS_DISABLED
void display_cluster_prototypes(CHAR_SAMPLES_LIST *char_clusters) {
inT16 proto_number = 0;
CHAR_SAMPLES_IT c_it = char_clusters;
char title[WINDOWNAMESIZE];
for (c_it.mark_cycle_pt (); !c_it.cycled_list (); c_it.forward ()) {
proto_number++;
#ifndef SECURE_NAMES
tprintf ("Displaying proto number %d\n", proto_number);
#endif
if (c_it.data ()->prototype () != NULL) {
sprintf (title, "Proto - %d", proto_number);
display_image (c_it.data ()->prototype ()->make_image (),
title, (proto_number - 1) * 400, 0, FALSE);
}
}
}
#endif
// *********************************************************************
// Simplistic routines to test the effect of rejecting ems and fullstops
// *********************************************************************
void reject_all_ems(WERD_RES *word) {
inT16 i;
for (i = 0; word->best_choice->unichar_string()[i] != '\0'; i++) {
if (word->best_choice->unichar_string()[i] == 'm')
// reject all ems
word->reject_map[i].setrej_mm_reject ();
}
}
void reject_all_fullstops(WERD_RES *word) {
inT16 i;
for (i = 0; word->best_choice->unichar_string()[i] != '\0'; i++) {
if (word->best_choice->unichar_string()[i] == '.')
// reject all fullstops
word->reject_map[i].setrej_mm_reject ();
}
}
namespace tesseract {
void Tesseract::reject_suspect_ems(WERD_RES *word) {
inT16 i;
if (!word_adaptable (word, tessedit_cluster_adaption_mode))
for (i = 0; word->best_choice->unichar_string()[i] != '\0'; i++) {
if (word->best_choice->unichar_string()[i] == 'm' && suspect_em (word, i))
// reject all ems
word->reject_map[i].setrej_mm_reject ();
}
}
} // namespace tesseract
void reject_suspect_fullstops(WERD_RES *word) {
inT16 i;
for (i = 0; word->best_choice->unichar_string()[i] != '\0'; i++) {
if (word->best_choice->unichar_string()[i] == '.'
&& suspect_fullstop (word, i))
// reject all commas
word->reject_map[i].setrej_mm_reject ();
}
}
BOOL8 suspect_em(WERD_RES *word, inT16 index) {
PBLOB_LIST *blobs = word->outword->blob_list ();
PBLOB_IT blob_it(blobs);
inT16 j;
for (j = 0; j < index; j++)
blob_it.forward ();
return (blob_it.data ()->out_list ()->length () != 1);
}
BOOL8 suspect_fullstop(WERD_RES *word, inT16 i) {
float aspect_ratio;
PBLOB_LIST *blobs = word->outword->blob_list ();
PBLOB_IT blob_it(blobs);
inT16 j;
TBOX box;
inT16 width;
inT16 height;
for (j = 0; j < i; j++)
blob_it.forward ();
box = blob_it.data ()->bounding_box ();
width = box.width ();
height = box.height ();
aspect_ratio = ((width > height) ? ((float) width) / height :
((float) height) / width);
return (aspect_ratio > tessed_fullstop_aspect_ratio);
}