| /////////////////////////////////////////////////////////////////////// |
| // File: genericvector.h |
| // Description: Functions for producing classifications |
| // for the input to ambigstraining. |
| // Author: Daria Antonova |
| // Created: Mon Jun 23 11:26:43 PDT 2008 |
| // |
| // (C) Copyright 2007, 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 "ambigs.h" |
| |
| #include "applybox.h" |
| #include "boxread.h" |
| #include "control.h" |
| #include "permute.h" |
| #include "ratngs.h" |
| #include "reject.h" |
| #include "stopper.h" |
| #include "tesseractclass.h" |
| |
| namespace tesseract { |
| |
| // Sets flags necessary for ambigs training mode. |
| // Opens and returns the pointer to the output file. |
| FILE *Tesseract::init_ambigs_training(const STRING &fname) { |
| permute_only_top = 1; // use only top choice permuter |
| tessedit_tess_adaption_mode.set_value(0); // turn off adaption |
| tessedit_ok_mode.set_value(0); // turn off context checking |
| tessedit_enable_doc_dict.set_value(0); // turn off document dictionary |
| save_best_choices.set_value(1); // save individual char choices |
| stopper_no_acceptable_choices.set_value(1); // explore all segmentations |
| save_raw_choices.set_value(1); // save raw choices |
| |
| // Open ambigs output file. |
| STRING output_fname = fname; |
| const char *lastdot = strrchr(output_fname.string(), '.'); |
| if (lastdot != NULL) { |
| output_fname[lastdot - output_fname.string()] = '\0'; |
| } |
| output_fname += ".txt"; |
| FILE *output_file; |
| if (!(output_file = fopen(output_fname.string(), "a+"))) { |
| CANTOPENFILE.error("ambigs_training", EXIT, |
| "Can't open box file %s\n", output_fname.string()); |
| } |
| return output_file; |
| } |
| |
| // This function takes tif/box pair of files and runs recognition on the image, |
| // while making sure that the word bounds that tesseract identified roughly |
| // match to those specified by the input box file. For each word (ngram in a |
| // single bounding box from the input box file) it outputs the ocred result, |
| // the correct label, rating and certainty. |
| void Tesseract::ambigs_training_segmented(const STRING &fname, |
| PAGE_RES *page_res, |
| volatile ETEXT_DESC *monitor, |
| FILE *output_file) { |
| STRING box_fname = fname; |
| const char *lastdot = strrchr(box_fname.string(), '.'); |
| if (lastdot != NULL) { |
| box_fname[lastdot - box_fname.string()] = '\0'; |
| } |
| box_fname += ".box"; |
| FILE *box_file; |
| if (!(box_file = fopen(box_fname.string(), "r"))) { |
| CANTOPENFILE.error("ambigs_training", EXIT, |
| "Can't open box file %s\n", box_fname.string()); |
| } |
| |
| static PAGE_RES_IT page_res_it; |
| page_res_it.page_res = page_res; |
| page_res_it.restart_page(); |
| int x_min, y_min, x_max, y_max; |
| char label[UNICHAR_LEN * 10]; |
| |
| // Process all the words on this page. |
| while (page_res_it.word() != NULL && |
| read_next_box(applybox_page, box_file, label, |
| &x_min, &y_min, &x_max, &y_max)) { |
| // Init bounding box of the current word bounding box and from box file. |
| TBOX box = TBOX(ICOORD(x_min, y_min), ICOORD(x_max, y_max)); |
| TBOX word_box(page_res_it.word()->word->bounding_box()); |
| bool one_word = true; |
| // Check whether the bounding box of the next word overlaps with the |
| // current box from box file. |
| while (page_res_it.next_word() != NULL && |
| box.x_overlap(page_res_it.next_word()->word->bounding_box())) { |
| word_box = word_box.bounding_union( |
| page_res_it.next_word()->word->bounding_box()); |
| page_res_it.forward(); |
| one_word = false; |
| } |
| if (!word_box.major_overlap(box)) { |
| if (!word_box.x_overlap(box)) { |
| // We must be looking at the word that belongs in the "next" bounding |
| // box from the box file. The ngram that was supposed to appear in |
| // the current box read from the box file must have been dropped by |
| // tesseract as noise. |
| tprintf("Word %s was dropped as noise.\n", label); |
| continue; // stay on this blob, but read next box from box file |
| } else { |
| tprintf("Error: Insufficient overlap for word box" |
| " and box from file for %s\n", label); |
| word_box.print(); |
| box.print(); |
| exit(1); |
| } |
| } |
| // Skip recognizing the ngram if tesseract is sure it's not |
| // one word, otherwise run one recognition pass on this word. |
| if (!one_word) { |
| tprintf("Tesseract segmented %s as multiple words\n", label); |
| } else { |
| ambigs_classify_and_output(&page_res_it, label, output_file); |
| } |
| page_res_it.forward(); |
| } |
| fclose(box_file); |
| } |
| |
| // Run classify_word_pass1() on the current word. Output tesseract's raw choice |
| // as a result of the classification. For words labeled with a single unichar |
| // also output all alternatives from blob_choices of the best choice. |
| void Tesseract::ambigs_classify_and_output(PAGE_RES_IT *page_res_it, |
| const char *label, |
| FILE *output_file) { |
| int offset; |
| // Classify word. |
| classify_word_pass1(page_res_it->word(), page_res_it->row()->row, |
| page_res_it->block()->block, |
| FALSE, NULL, NULL); |
| WERD_CHOICE *best_choice = page_res_it->word()->best_choice; |
| ASSERT_HOST(best_choice != NULL); |
| ASSERT_HOST(best_choice->blob_choices() != NULL); |
| |
| // Compute the number of unichars in the label. |
| int label_num_unichars = 0; |
| int step = 1; // should be non-zero on the first iteration |
| for (offset = 0; label[offset] != '\0' && step > 0; |
| step = getDict().getUnicharset().step(label + offset), |
| offset += step, ++label_num_unichars); |
| if (step == 0) { |
| tprintf("Not outputting illegal unichar %s\n", label); |
| return; |
| } |
| |
| // Output all classifier choices for the unigrams (1-1 classifications). |
| if (label_num_unichars == 1 && best_choice->blob_choices()->length() == 1) { |
| BLOB_CHOICE_LIST_C_IT outer_blob_choice_it; |
| outer_blob_choice_it.set_to_list(best_choice->blob_choices()); |
| BLOB_CHOICE_IT blob_choice_it; |
| blob_choice_it.set_to_list(outer_blob_choice_it.data()); |
| for (blob_choice_it.mark_cycle_pt(); |
| !blob_choice_it.cycled_list(); |
| blob_choice_it.forward()) { |
| BLOB_CHOICE *blob_choice = blob_choice_it.data(); |
| if (blob_choice->unichar_id() != INVALID_UNICHAR_ID) { |
| fprintf(output_file, "%s\t%s\t%.4f\t%.4f\n", |
| unicharset.id_to_unichar(blob_choice->unichar_id()), |
| label, blob_choice->rating(), blob_choice->certainty()); |
| } |
| } |
| } |
| // Output the raw choice for succesful non 1-1 classifications. |
| getDict().PrintAmbigAlternatives(output_file, label, label_num_unichars); |
| } |
| |
| } // namespace tesseract |
