Font and classifier output structure cleanup.

Font recognition was poor, due to forcing a 1st and 2nd choice at
a character level, when the total score for the correct font is often
correct at the word level, so allowed the propagation of a full set
of fonts and scores to the word recognizer, which can now decide word
level fonts using the scores instead of simple votes.

Change precipitated a cleanup of output data structures for classifier
results, eliminating ScoredClass and INT_RESULT_STRUCT, with a few
extra elements going in UnicharRating, and using that wherever possible.
That added the extra complexity of 1-rating due to a flip between 0 is
good and 0 is bad for the internal classifier scores before they are
converted to rating and certainty.

Author: theraysmith

ccmain/applybox.cpp

@@ -272,7 +272,7 @@ void Tesseract::MaximallyChopWord(const GenericVector<TBOX>& boxes,
     // limited by the ability of the chopper to find suitable chop points,
     // and not by the value of the certainties.
     BLOB_CHOICE* choice =
-        new BLOB_CHOICE(0, rating, -rating, -1, -1, 0, 0, 0, 0, BCC_FAKE);
+        new BLOB_CHOICE(0, rating, -rating, -1, 0.0f, 0.0f, 0.0f, BCC_FAKE);
     blob_choices.push_back(choice);
     rating -= 0.125f;
   }
@@ -291,8 +291,8 @@ void Tesseract::MaximallyChopWord(const GenericVector<TBOX>& boxes,
       left_choice->set_certainty(-rating);
       // combine confidence w/ serial #
       BLOB_CHOICE* right_choice = new BLOB_CHOICE(++right_chop_index,
-                                                  rating - 0.125f, -rating,
-                                                  -1, -1, 0, 0, 0, 0, BCC_FAKE);
+                                                  rating - 0.125f, -rating, -1,
+                                                  0.0f, 0.0f, 0.0f, BCC_FAKE);
       blob_choices.insert(right_choice, blob_number + 1);
     }
   }

ccmain/control.cpp

@@ -1885,62 +1885,54 @@ void Tesseract::set_word_fonts(WERD_RES *word) {
   if (word->chopped_word == NULL) return;
   ASSERT_HOST(word->best_choice != NULL);
 
-  inT32 index;                   // char id index
-                                 // character iterator
-  BLOB_CHOICE_IT choice_it;      // choice iterator
   int fontinfo_size = get_fontinfo_table().size();
-  int fontset_size = get_fontset_table().size();
-  if (fontinfo_size == 0 || fontset_size == 0) return;
-  STATS fonts(0, fontinfo_size);  // font counters
+  if (fontinfo_size == 0) return;
+  GenericVector<int> font_total_score;
+  font_total_score.init_to_size(fontinfo_size, 0);
 
   word->italic = 0;
   word->bold = 0;
-  if (!word->best_choice_fontinfo_ids.empty()) {
-    word->best_choice_fontinfo_ids.clear();
+  // Compute the font scores for the word
+  if (tessedit_debug_fonts) {
+    tprintf("Examining fonts in %s\n",
+            word->best_choice->debug_string().string());
+  }
+  for (int b = 0; b < word->best_choice->length(); ++b) {
+    BLOB_CHOICE* choice = word->GetBlobChoice(b);
+    if (choice == NULL) continue;
+    const GenericVector<ScoredFont>& fonts = choice->fonts();
+    for (int f = 0; f < fonts.size(); ++f) {
+      int fontinfo_id = fonts[f].fontinfo_id;
+      if (0 <= fontinfo_id && fontinfo_id < fontinfo_size) {
+        font_total_score[fontinfo_id] += fonts[f].score;
+      }
+    }
   }
-  // Compute the modal font for the word
-  for (index = 0; index < word->best_choice->length(); ++index) {
-    UNICHAR_ID word_ch_id = word->best_choice->unichar_id(index);
-    choice_it.set_to_list(word->GetBlobChoices(index));
-    if (tessedit_debug_fonts) {
-      tprintf("Examining fonts in %s\n",
-              word->best_choice->debug_string().string());
+  // Find the top and 2nd choice for the word.
+  int score1 = 0, score2 = 0;
+  inT16 font_id1 = -1, font_id2 = -1;
+  for (int f = 0; f < fontinfo_size; ++f) {
+    if (tessedit_debug_fonts && font_total_score[f] > 0) {
+      tprintf("Font %s, total score = %d\n",
+              fontinfo_table_.get(f).name, font_total_score[f]);
     }
-    for (choice_it.mark_cycle_pt(); !choice_it.cycled_list();
-         choice_it.forward()) {
-      UNICHAR_ID blob_ch_id = choice_it.data()->unichar_id();
-      if (blob_ch_id == word_ch_id) {
-        if (tessedit_debug_fonts) {
-          tprintf("%s font %s (%d) font2 %s (%d)\n",
-                  word->uch_set->id_to_unichar(blob_ch_id),
-                  choice_it.data()->fontinfo_id() < 0 ? "unknown" :
-                  fontinfo_table_.get(choice_it.data()->fontinfo_id()).name,
-                  choice_it.data()->fontinfo_id(),
-                  choice_it.data()->fontinfo_id2() < 0 ? "unknown" :
-                  fontinfo_table_.get(choice_it.data()->fontinfo_id2()).name,
-                  choice_it.data()->fontinfo_id2());
-        }
-        // 1st choice font gets 2 pts, 2nd choice 1 pt.
-        if (choice_it.data()->fontinfo_id() >= 0) {
-          fonts.add(choice_it.data()->fontinfo_id(), 2);
-        }
-        if (choice_it.data()->fontinfo_id2() >= 0) {
-          fonts.add(choice_it.data()->fontinfo_id2(), 1);
-        }
-        break;
-      }
+    if (font_total_score[f] > score1) {
+      score2 = score1;
+      font_id2 = font_id1;
+      score1 = font_total_score[f];
+      font_id1 = f;
+    } else if (font_total_score[f] > score2) {
+      score2 = font_total_score[f];
+      font_id2 = f;
     }
   }
-  inT16 font_id1, font_id2;
-  find_modal_font(&fonts, &font_id1, &word->fontinfo_id_count);
-  find_modal_font(&fonts, &font_id2, &word->fontinfo_id2_count);
   word->fontinfo = font_id1 >= 0 ? &fontinfo_table_.get(font_id1) : NULL;
   word->fontinfo2 = font_id2 >= 0 ? &fontinfo_table_.get(font_id2) : NULL;
-  // All the blobs get the word's best choice font.
-  for (int i = 0; i < word->best_choice->length(); ++i) {
-    word->best_choice_fontinfo_ids.push_back(font_id1);
-  }
-  if (word->fontinfo_id_count > 0) {
+  // Each score has a limit of MAX_UINT16, so divide by that to get the number
+  // of "votes" for that font, ie number of perfect scores.
+  word->fontinfo_id_count = ClipToRange(score1 / MAX_UINT16, 1, MAX_INT8);
+  word->fontinfo_id2_count = ClipToRange(score2 / MAX_UINT16, 0, MAX_INT8);
+  if (score1 > 0) {
     FontInfo fi = fontinfo_table_.get(font_id1);
     if (tessedit_debug_fonts) {
       if (word->fontinfo_id2_count > 0) {
@@ -1953,9 +1945,8 @@ void Tesseract::set_word_fonts(WERD_RES *word) {
                 fi.name, word->fontinfo_id_count);
       }
     }
-    // 1st choices got 2 pts, so we need to halve the score for the mode.
-    word->italic = (fi.is_italic() ? 1 : -1) * (word->fontinfo_id_count + 1) / 2;
-    word->bold = (fi.is_bold() ? 1 : -1) * (word->fontinfo_id_count + 1) / 2;
+    word->italic = (fi.is_italic() ? 1 : -1) * word->fontinfo_id_count;
+    word->bold = (fi.is_bold() ? 1 : -1) * word->fontinfo_id_count;
   }
 }
 
@@ -2009,8 +2000,7 @@ void Tesseract::font_recognition_pass(PAGE_RES* page_res) {
     word = page_res_it.word();
     int length = word->best_choice->length();
 
-    // 1st choices got 2 pts, so we need to halve the score for the mode.
-    int count = (word->fontinfo_id_count + 1) / 2;
+    int count = word->fontinfo_id_count;
     if (!(count == length || (length > 3 && count >= length * 3 / 4))) {
       word->fontinfo = modal_font;
       // Counts only get 1 as it came from the doc.

ccmain/cube_control.cpp

@@ -384,7 +384,7 @@ bool Tesseract::cube_recognize(CubeObject *cube_obj, BLOCK* block,
     UNICHAR_ID uch_id =
         cube_cntxt_->CharacterSet()->UnicharID(char_samples[i]->StrLabel());
     choices[i] = new BLOB_CHOICE(uch_id, -cube_certainty, cube_certainty,
-                                 -1, -1, 0, 0, 0, 0, BCC_STATIC_CLASSIFIER);
+                                 -1, 0.0f, 0.0f, 0.0f, BCC_STATIC_CLASSIFIER);
   }
   word->FakeClassifyWord(num_chars, choices);
   // within a word, cube recognizes the word in reading order.

ccstruct/fontinfo.cpp

@@ -59,23 +59,23 @@ bool FontInfoTable::DeSerialize(bool swap, FILE* fp) {
 // Returns true if the given set of fonts includes one with the same
 // properties as font_id.
 bool FontInfoTable::SetContainsFontProperties(
-    int font_id, const GenericVector<int>& font_set) const {
+    int font_id, const GenericVector<ScoredFont>& font_set) const {
   uinT32 properties = get(font_id).properties;
   for (int f = 0; f < font_set.size(); ++f) {
-    if (get(font_set[f]).properties == properties)
+    if (get(font_set[f].fontinfo_id).properties == properties)
       return true;
   }
   return false;
 }
 
 // Returns true if the given set of fonts includes multiple properties.
 bool FontInfoTable::SetContainsMultipleFontProperties(
-    const GenericVector<int>& font_set) const {
+    const GenericVector<ScoredFont>& font_set) const {
   if (font_set.empty()) return false;
-  int first_font = font_set[0];
+  int first_font = font_set[0].fontinfo_id;
   uinT32 properties = get(first_font).properties;
   for (int f = 1; f < font_set.size(); ++f) {
-    if (get(font_set[f]).properties != properties)
+    if (get(font_set[f].fontinfo_id).properties != properties)
       return true;
   }
   return false;

ccstruct/fontinfo.h

@@ -31,6 +31,22 @@ namespace tesseract {
 
 class BitVector;
 
+// Simple struct to hold a font and a score. The scores come from the low-level
+// integer matcher, so they are in the uinT16 range. Fonts are an index to
+// fontinfo_table.
+// These get copied around a lot, so best to keep them small.
+struct ScoredFont {
+  ScoredFont() : fontinfo_id(-1), score(0) {}
+  ScoredFont(int font_id, uinT16 classifier_score)
+      : fontinfo_id(font_id), score(classifier_score) {}
+
+  // Index into fontinfo table, but inside the classifier, may be a shapetable
+  // index.
+  inT32 fontinfo_id;
+  // Raw score from the low-level classifier.
+  uinT16 score;
+};
+
 // Struct for information about spacing between characters in a particular font.
 struct FontSpacingInfo {
   inT16 x_gap_before;
@@ -140,11 +156,11 @@ class FontInfoTable : public GenericVector<FontInfo> {
 
   // Returns true if the given set of fonts includes one with the same
   // properties as font_id.
-  bool SetContainsFontProperties(int font_id,
-                                 const GenericVector<int>& font_set) const;
+  bool SetContainsFontProperties(
+      int font_id, const GenericVector<ScoredFont>& font_set) const;
   // Returns true if the given set of fonts includes multiple properties.
   bool SetContainsMultipleFontProperties(
-      const GenericVector<int>& font_set) const;
+      const GenericVector<ScoredFont>& font_set) const;
 
   // Moves any non-empty FontSpacingInfo entries from other to this.
   void MoveSpacingInfoFrom(FontInfoTable* other);

ccstruct/pageres.cpp

@@ -148,6 +148,7 @@ ROW_RES::ROW_RES(bool merge_similar_words, ROW *the_row) {
           add_next_word = false;
         }
       }
+      next_word->set_flag(W_FUZZY_NON, add_next_word);
     } else {
       add_next_word = next_word->flag(W_FUZZY_NON);
     }
@@ -206,12 +207,8 @@ WERD_RES& WERD_RES::operator=(const WERD_RES & source) {
   if (!wc_dest_it.empty()) {
     wc_dest_it.move_to_first();
     best_choice = wc_dest_it.data();
-    best_choice_fontinfo_ids = source.best_choice_fontinfo_ids;
   } else {
     best_choice = NULL;
-    if (!best_choice_fontinfo_ids.empty()) {
-      best_choice_fontinfo_ids.clear();
-    }
   }
 
   if (source.raw_choice != NULL) {

ccstruct/pageres.h

@@ -315,8 +315,6 @@ class WERD_RES : public ELIST_LINK {
   BOOL8 combination;           //of two fuzzy gap wds
   BOOL8 part_of_combo;         //part of a combo
   BOOL8 reject_spaces;         //Reject spacing?
-  // FontInfo ids for each unichar in best_choice.
-  GenericVector<inT8> best_choice_fontinfo_ids;
 
   WERD_RES() {
     InitNonPointers();

ccstruct/ratngs.cpp

@@ -90,8 +90,6 @@ static const char * const kPermuterTypeNames[] = {
 BLOB_CHOICE::BLOB_CHOICE(UNICHAR_ID src_unichar_id, // character id
                          float src_rating,         // rating
                          float src_cert,           // certainty
-                         inT16 src_fontinfo_id,     // font
-                         inT16 src_fontinfo_id2,    // 2nd choice font
                          int src_script_id,        // script
                          float min_xheight,        // min xheight allowed
                          float max_xheight,        // max xheight by this char
@@ -100,8 +98,8 @@ BLOB_CHOICE::BLOB_CHOICE(UNICHAR_ID src_unichar_id, // character id
   unichar_id_ = src_unichar_id;
   rating_ = src_rating;
   certainty_ = src_cert;
-  fontinfo_id_ = src_fontinfo_id;
-  fontinfo_id2_ = src_fontinfo_id2;
+  fontinfo_id_ = -1;
+  fontinfo_id2_ = -1;
   script_id_ = src_script_id;
   min_xheight_ = min_xheight;
   max_xheight_ = max_xheight;
@@ -126,6 +124,7 @@ BLOB_CHOICE::BLOB_CHOICE(const BLOB_CHOICE &other) {
   max_xheight_ = other.max_xheight_;
   yshift_ = other.yshift();
   classifier_ = other.classifier_;
+  fonts_ = other.fonts_;
 }
 
 // Returns true if *this and other agree on the baseline and x-height

ccstruct/ratngs.h

@@ -24,6 +24,7 @@
 
 #include "clst.h"
 #include "elst.h"
+#include "fontinfo.h"
 #include "genericvector.h"
 #include "matrix.h"
 #include "unichar.h"
@@ -64,8 +65,6 @@ class BLOB_CHOICE: public ELIST_LINK
     BLOB_CHOICE(UNICHAR_ID src_unichar_id,  // character id
                 float src_rating,          // rating
                 float src_cert,            // certainty
-                inT16 src_fontinfo_id,     // font
-                inT16 src_fontinfo_id2,    // 2nd choice font
                 int script_id,             // script
                 float min_xheight,         // min xheight in image pixel units
                 float max_xheight,         // max xheight allowed by this char
@@ -89,6 +88,26 @@ class BLOB_CHOICE: public ELIST_LINK
     inT16 fontinfo_id2() const {
       return fontinfo_id2_;
     }
+    const GenericVector<tesseract::ScoredFont>& fonts() const {
+      return fonts_;
+    }
+    void set_fonts(const GenericVector<tesseract::ScoredFont>& fonts) {
+      fonts_ = fonts;
+      int score1 = 0, score2 = 0;
+      fontinfo_id_ = -1;
+      fontinfo_id2_ = -1;
+      for (int f = 0; f < fonts_.size(); ++f) {
+        if (fonts_[f].score > score1) {
+          score2 = score1;
+          fontinfo_id2_ = fontinfo_id_;
+          score1 = fonts_[f].score;
+          fontinfo_id_ = fonts_[f].fontinfo_id;
+        } else if (fonts_[f].score > score2) {
+          score2 = fonts_[f].score;
+          fontinfo_id2_ = fonts_[f].fontinfo_id;
+        }
+      }
+    }
     int script_id() const {
       return script_id_;
     }
@@ -131,12 +150,6 @@ class BLOB_CHOICE: public ELIST_LINK
     void set_certainty(float newrat) {
       certainty_ = newrat;
     }
-    void set_fontinfo_id(inT16 newfont) {
-      fontinfo_id_ = newfont;
-    }
-    void set_fontinfo_id2(inT16 newfont) {
-      fontinfo_id2_ = newfont;
-    }
     void set_script(int newscript_id) {
       script_id_ = newscript_id;
     }
@@ -186,6 +199,8 @@ class BLOB_CHOICE: public ELIST_LINK
 
  private:
   UNICHAR_ID unichar_id_;          // unichar id
+  // Fonts and scores. Allowed to be empty.
+  GenericVector<tesseract::ScoredFont> fonts_;
   inT16 fontinfo_id_;              // char font information
   inT16 fontinfo_id2_;             // 2nd choice font information
   // Rating is the classifier distance weighted by the length of the outline

ccutil/genericvector.h

@@ -445,8 +445,10 @@ class PointerVector : public GenericVector<T*> {
   }
 
   PointerVector<T>& operator=(const PointerVector& other) {
-    this->truncate(0);
-    this->operator+=(other);
+    if (&other != this) {
+      this->truncate(0);
+      this->operator+=(other);
+    }
     return *this;
   }
 
@@ -777,8 +779,10 @@ GenericVector<T> &GenericVector<T>::operator+=(const GenericVector& other) {
 
 template <typename T>
 GenericVector<T> &GenericVector<T>::operator=(const GenericVector& other) {
-  this->truncate(0);
-  this->operator+=(other);
+  if (&other != this) {
+    this->truncate(0);
+    this->operator+=(other);
+  }
   return *this;
 }