| /********************************************************************** |
| * File: tfacepp.cpp (Formerly tface++.c) |
| * Description: C++ side of the C/C++ Tess/Editor interface. |
| * Author: Ray Smith |
| * Created: Thu Apr 23 15:39:23 BST 1992 |
| * |
| * (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 "errcode.h" |
| #include "ratngs.h" |
| #include "reject.h" |
| #include "werd.h" |
| #include "tfacep.h" |
| #include "tstruct.h" |
| #include "tfacepp.h" |
| #include "tessvars.h" |
| #include "globals.h" |
| #include "reject.h" |
| #include "tesseractclass.h" |
| |
| #define EXTERN |
| |
| EXTERN BOOL_VAR (tessedit_override_permuter, TRUE, "According to dict_word"); |
| |
| |
| #define MAX_UNDIVIDED_LENGTH 24 |
| |
| |
| |
| /********************************************************************** |
| * recog_word |
| * |
| * Convert the word to tess form and pass it to the tess segmenter. |
| * Convert the output back to editor form. |
| **********************************************************************/ |
| namespace tesseract { |
| WERD_CHOICE *Tesseract::recog_word( //recog one owrd |
| WERD *word, //word to do |
| DENORM *denorm, //de-normaliser |
| //matcher function |
| POLY_MATCHER matcher, |
| POLY_TESTER tester, //tester function |
| POLY_TESTER trainer, //trainer function |
| BOOL8 testing, //true if answer driven |
| //raw result |
| WERD_CHOICE *&raw_choice, |
| //list of blob lists |
| BLOB_CHOICE_LIST_CLIST *blob_choices, |
| WERD *&outword //bln word output |
| ) { |
| WERD_CHOICE *word_choice; |
| uinT8 perm_type; |
| uinT8 real_dict_perm_type; |
| |
| if (word->blob_list ()->empty ()) { |
| word_choice = new WERD_CHOICE("", NULL, 10.0f, -1.0f, |
| TOP_CHOICE_PERM, unicharset); |
| raw_choice = new WERD_CHOICE("", NULL, 10.0f, -1.0f, |
| TOP_CHOICE_PERM, unicharset); |
| outword = word->poly_copy (denorm->row ()->x_height ()); |
| } |
| else |
| word_choice = recog_word_recursive (word, denorm, matcher, tester, |
| trainer, testing, raw_choice, |
| blob_choices, outword); |
| if ((word_choice->length() != outword->blob_list()->length()) || |
| (word_choice->length() != blob_choices->length())) { |
| tprintf |
| ("recog_word ASSERT FAIL String:\"%s\"; Strlen=%d; #Blobs=%d; #Choices=%d\n", |
| word_choice->debug_string(unicharset).string(), |
| word_choice->length(), outword->blob_list()->length(), |
| blob_choices->length()); |
| } |
| ASSERT_HOST(word_choice->length() == outword->blob_list()->length()); |
| ASSERT_HOST(word_choice->length() == blob_choices->length()); |
| |
| /* Copy any reject blobs into the outword */ |
| outword->rej_blob_list()->deep_copy(word->rej_blob_list(), &PBLOB::deep_copy); |
| |
| if (tessedit_override_permuter) { |
| /* Override the permuter type if a straight dictionary check disagrees. */ |
| perm_type = word_choice->permuter(); |
| if ((perm_type != SYSTEM_DAWG_PERM) && |
| (perm_type != FREQ_DAWG_PERM) && (perm_type != USER_DAWG_PERM)) { |
| real_dict_perm_type = dict_word(*word_choice); |
| if (((real_dict_perm_type == SYSTEM_DAWG_PERM) || |
| (real_dict_perm_type == FREQ_DAWG_PERM) || |
| (real_dict_perm_type == USER_DAWG_PERM)) && |
| (alpha_count(word_choice->unichar_string().string(), |
| word_choice->unichar_lengths().string()) > 0)) { |
| word_choice->set_permuter (real_dict_perm_type); // use dict perm |
| } |
| } |
| if (tessedit_rejection_debug && perm_type != word_choice->permuter ()) { |
| tprintf ("Permuter Type Flipped from %d to %d\n", |
| perm_type, word_choice->permuter ()); |
| } |
| } |
| assert ((word_choice == NULL) == (raw_choice == NULL)); |
| return word_choice; |
| } |
| |
| |
| /********************************************************************** |
| * recog_word_recursive |
| * |
| * Convert the word to tess form and pass it to the tess segmenter. |
| * Convert the output back to editor form. |
| **********************************************************************/ |
| WERD_CHOICE * |
| Tesseract::recog_word_recursive( |
| WERD *word, // word to do |
| DENORM *denorm, // de-normaliser |
| POLY_MATCHER matcher, // matcher function |
| POLY_TESTER tester, // tester function |
| POLY_TESTER trainer, // trainer function |
| BOOL8 testing, // true if answer driven |
| WERD_CHOICE *&raw_choice, // raw result |
| BLOB_CHOICE_LIST_CLIST *blob_choices, // list of blob lists |
| WERD *&outword // bln word output |
| ) { |
| inT32 initial_blob_choice_len; |
| inT32 word_length; // no of blobs |
| STRING word_string; // converted from tess |
| STRING word_string_lengths; |
| BLOB_CHOICE_LIST_VECTOR *tess_ratings; // tess results |
| TWERD *tessword; // tess format |
| BLOB_CHOICE_LIST_C_IT blob_choices_it; // iterator |
| |
| tess_matcher = matcher; // install matcher |
| tess_tester = testing ? tester : NULL; |
| tess_trainer = testing ? trainer : NULL; |
| tess_denorm = denorm; |
| tess_word = word; |
| // blob_matchers[1]=call_matcher; |
| if (word->blob_list ()->length () > MAX_UNDIVIDED_LENGTH) { |
| return split_and_recog_word (word, denorm, matcher, tester, trainer, |
| testing, raw_choice, blob_choices, |
| outword); |
| } else { |
| UNICHAR_ID space_id = unicharset.unichar_to_id(" "); |
| WERD_CHOICE *best_choice = new WERD_CHOICE(); |
| raw_choice = new WERD_CHOICE(); |
| initial_blob_choice_len = blob_choices->length(); |
| tessword = make_tess_word (word, NULL); |
| tess_ratings = cc_recog(tessword, best_choice, raw_choice, |
| testing && tester != NULL, |
| testing && trainer != NULL, |
| word->flag(W_EOL)); |
| |
| outword = make_ed_word (tessword, word); // convert word |
| if (outword == NULL) { |
| outword = word->poly_copy (denorm->row ()->x_height ()); |
| } |
| delete_word(tessword); // get rid of it |
| word_length = outword->blob_list()->length(); // no of blobs |
| |
| // Put BLOB_CHOICE_LISTs from tess_ratings into blob_choices. |
| blob_choices_it.set_to_list(blob_choices); |
| for (int i = 0; i < tess_ratings->length(); ++i) { |
| blob_choices_it.add_to_end(tess_ratings->get(i)); |
| } |
| delete tess_ratings; |
| |
| // Pad raw_choice with spaces if needed. |
| if (raw_choice->length() < word_length) { |
| while (raw_choice->length() < word_length) { |
| raw_choice->append_unichar_id(space_id, 1, 0.0, |
| raw_choice->certainty()); |
| } |
| raw_choice->populate_unichars(unicharset); |
| } |
| |
| // Do sanity checks and minor fixes on best_choice. |
| if (best_choice->length() > word_length) { |
| tprintf("recog_word: Discarded long string \"%s\"" |
| " (%d characters vs %d blobs)\n", |
| best_choice->unichar_string().string (), |
| best_choice->length(), word_length); |
| best_choice->make_bad(); // should never happen |
| tprintf("Word is at (%g,%g)\n", |
| denorm->origin(), |
| denorm->y(word->bounding_box().bottom(), 0.0)); |
| } |
| if (blob_choices->length() - initial_blob_choice_len != word_length) { |
| best_choice->make_bad(); // force rejection |
| tprintf ("recog_word: Choices list len:%d; blob lists len:%d\n", |
| blob_choices->length(), word_length); |
| blob_choices_it.set_to_list(blob_choices); // list of lists |
| while (blob_choices->length() - initial_blob_choice_len < word_length) { |
| blob_choices_it.add_to_end(new BLOB_CHOICE_LIST()); // add a fake one |
| tprintf("recog_word: Added dummy choice list\n"); |
| } |
| while (blob_choices->length() - initial_blob_choice_len > word_length) { |
| blob_choices_it.move_to_last(); // should never happen |
| delete blob_choices_it.extract(); |
| tprintf("recog_word: Deleted choice list\n"); |
| } |
| } |
| if (best_choice->length() < word_length) { |
| while (best_choice->length() < word_length) { |
| best_choice->append_unichar_id(space_id, 1, 0.0, |
| best_choice->certainty()); |
| } |
| best_choice->populate_unichars(unicharset); |
| } |
| |
| return best_choice; |
| } |
| } |
| |
| |
| /********************************************************************** |
| * split_and_recog_word |
| * |
| * Convert the word to tess form and pass it to the tess segmenter. |
| * Convert the output back to editor form. |
| **********************************************************************/ |
| |
| WERD_CHOICE * |
| Tesseract::split_and_recog_word( //recog one owrd |
| WERD *word, //word to do |
| DENORM *denorm, //de-normaliser |
| POLY_MATCHER matcher, //matcher function |
| POLY_TESTER tester, //tester function |
| POLY_TESTER trainer, //trainer function |
| BOOL8 testing, //true if answer driven |
| //raw result |
| WERD_CHOICE *&raw_choice, |
| //list of blob lists |
| BLOB_CHOICE_LIST_CLIST *blob_choices, |
| WERD *&outword //bln word output |
| ) { |
| // inT32 outword1_len; |
| // inT32 outword2_len; |
| WERD *first_word; //poly copy of word |
| WERD *second_word; //fabricated word |
| WERD *outword2; //2nd output word |
| PBLOB *blob; |
| WERD_CHOICE *result; //return value |
| WERD_CHOICE *result2; //output of 2nd word |
| WERD_CHOICE *raw_choice2; //raw version of 2nd |
| float gap; //blob gap |
| float bestgap; //biggest gap |
| PBLOB_LIST new_blobs; //list of gathered blobs |
| PBLOB_IT blob_it; |
| //iterator |
| PBLOB_IT new_blob_it = &new_blobs; |
| |
| first_word = word->poly_copy (denorm->row ()->x_height ()); |
| blob_it.set_to_list (first_word->blob_list ()); |
| bestgap = -MAX_INT32; |
| while (!blob_it.at_last ()) { |
| blob = blob_it.data (); |
| //gap to next |
| gap = blob_it.data_relative(1)->bounding_box().left() - |
| blob->bounding_box().right(); |
| blob_it.forward (); |
| if (gap > bestgap) { |
| bestgap = gap; //find biggest |
| new_blob_it = blob_it; //save position |
| } |
| } |
| //take 2nd half |
| new_blobs.assign_to_sublist (&new_blob_it, &blob_it); |
| //make it a word |
| second_word = new WERD (&new_blobs, 1, NULL); |
| ASSERT_HOST (word->blob_list ()->length () == |
| first_word->blob_list ()->length () + |
| second_word->blob_list ()->length ()); |
| |
| result = recog_word_recursive (first_word, denorm, matcher, |
| tester, trainer, testing, raw_choice, |
| blob_choices, outword); |
| delete first_word; //done that one |
| result2 = recog_word_recursive (second_word, denorm, matcher, |
| tester, trainer, testing, raw_choice2, |
| blob_choices, outword2); |
| delete second_word; //done that too |
| *result += *result2; //combine ratings |
| delete result2; |
| *raw_choice += *raw_choice2; |
| delete raw_choice2; //finished with it |
| // outword1_len= outword->blob_list()->length(); |
| // outword2_len= outword2->blob_list()->length(); |
| outword->join_on (outword2); //join words |
| delete outword2; |
| // if ( outword->blob_list()->length() != outword1_len + outword2_len ) |
| // tprintf( "Split&Recog: part1len=%d; part2len=%d; combinedlen=%d\n", |
| // outword1_len, outword2_len, outword->blob_list()->length() ); |
| // ASSERT_HOST( outword->blob_list()->length() == outword1_len + outword2_len ); |
| return result; |
| } |
| |
| } // namespace tesseract |
| |
| /********************************************************************** |
| * call_tester |
| * |
| * Called from Tess with a blob in tess form. |
| * Convert the blob to editor form. |
| * Call the tester setup by the segmenter in tess_tester. |
| **********************************************************************/ |
| #if 0 // dead code |
| void call_tester( //call a tester |
| const STRING& filename, |
| TBLOB *tessblob, //blob to test |
| BOOL8 correct_blob, //true if good |
| char *text, //source text |
| inT32 count, //chars in text |
| LIST result //output of matcher |
| ) { |
| PBLOB *blob; //converted blob |
| BLOB_CHOICE_LIST ratings; //matcher result |
| |
| blob = make_ed_blob (tessblob);//convert blob |
| if (blob == NULL) |
| return; |
| //make it right type |
| convert_choice_list(result, ratings); |
| if (tess_tester != NULL) |
| (*tess_tester) (filename, blob, tess_denorm, correct_blob, text, count, &ratings); |
| delete blob; //don't need that now |
| } |
| #endif |
| |
| /********************************************************************** |
| * call_train_tester |
| * |
| * Called from Tess with a blob in tess form. |
| * Convert the blob to editor form. |
| * Call the trainer setup by the segmenter in tess_trainer. |
| **********************************************************************/ |
| #if 0 // dead code |
| void call_train_tester( //call a tester |
| const STRING& filename, |
| TBLOB *tessblob, //blob to test |
| BOOL8 correct_blob, //true if good |
| char *text, //source text |
| inT32 count, //chars in text |
| LIST result //output of matcher |
| ) { |
| PBLOB *blob; //converted blob |
| BLOB_CHOICE_LIST ratings; //matcher result |
| |
| blob = make_ed_blob (tessblob);//convert blob |
| if (blob == NULL) |
| return; |
| //make it right type |
| convert_choice_list(result, ratings); |
| if (tess_trainer != NULL) |
| (*tess_trainer) (filename, blob, tess_denorm, correct_blob, text, count, &ratings); |
| delete blob; //don't need that now |
| } |
| #endif |
