lm_state.h

Go to the documentation of this file.

 
// File:        lm_state.h
// Description: Structures and functionality for capturing the state of
//              segmentation search guided by the language model.
// Author:      Rika Antonova
//
// (C) Copyright 2012, 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.
//
 
#ifndef TESSERACT_WORDREC_LANGUAGE_MODEL_DEFS_H_
#define TESSERACT_WORDREC_LANGUAGE_MODEL_DEFS_H_
 
#include <tesseract/unichar.h> // for UNICHAR_ID
#include "associate.h"         // for AssociateStats
#include "dawg.h"              // for DawgPositionVector
#include "elst.h"              // for ELIST_ITERATOR, ELISTIZEH, ELIST_LINK
#include "lm_consistency.h"    // for LMConsistencyInfo
#include "ratngs.h"            // for BLOB_CHOICE, PermuterType
#include "stopper.h"           // for DANGERR
#include "unicharset.h"        // for UNICHARSET
 
namespace tesseract {
 
using LanguageModelFlagsType = unsigned char;
 
 
struct LanguageModelDawgInfo {
  LanguageModelDawgInfo(const DawgPositionVector *a, PermuterType pt)
      : active_dawgs(*a), permuter(pt) {}
  DawgPositionVector active_dawgs;
  PermuterType permuter;
};
 
struct LanguageModelNgramInfo {
  LanguageModelNgramInfo(const char *c, int l, bool p, float nc, float ncc)
      : context(c)
      , context_unichar_step_len(l)
      , pruned(p)
      , ngram_cost(nc)
      , ngram_and_classifier_cost(ncc) {}
  std::string context; 
  int context_unichar_step_len;
  bool pruned;
  float ngram_cost;
  float ngram_and_classifier_cost;
};
 
struct ViterbiStateEntry : public ELIST_LINK {
  ViterbiStateEntry(ViterbiStateEntry *pe, BLOB_CHOICE *b, float c, float ol,
                    const LMConsistencyInfo &ci, const AssociateStats &as,
                    LanguageModelFlagsType tcf, LanguageModelDawgInfo *d, LanguageModelNgramInfo *n,
                    const char *debug_uch)
      : curr_b(b)
      , parent_vse(pe)
      , competing_vse(nullptr)
      , dawg_info(d)
      , ngram_info(n)
      , cost(c)
      , ratings_sum(b->rating())
      , min_certainty(b->certainty())
      , adapted(b->IsAdapted())
      , length(1)
      , outline_length(ol)
      , consistency_info(ci)
      , associate_stats(as)
      , top_choice_flags(tcf)
      , updated(true) {
    debug_str = (debug_uch == nullptr) ? nullptr : new std::string();
    if (pe != nullptr) {
      ratings_sum += pe->ratings_sum;
      if (pe->min_certainty < min_certainty) {
        min_certainty = pe->min_certainty;
      }
      adapted += pe->adapted;
      length += pe->length;
      outline_length += pe->outline_length;
      if (debug_uch != nullptr) {
        *debug_str += *(pe->debug_str);
      }
    }
    if (debug_str != nullptr && debug_uch != nullptr) {
      *debug_str += debug_uch;
    }
  }
  ~ViterbiStateEntry() {
    delete dawg_info;
    delete ngram_info;
    delete debug_str;
  }
  static int Compare(const void *e1, const void *e2) {
    const ViterbiStateEntry *ve1 = *static_cast<const ViterbiStateEntry *const *>(e1);
    const ViterbiStateEntry *ve2 = *static_cast<const ViterbiStateEntry *const *>(e2);
    return (ve1->cost < ve2->cost) ? -1 : 1;
  }
  inline bool Consistent() const {
    if (dawg_info != nullptr && consistency_info.NumInconsistentCase() == 0) {
      return true;
    }
    return consistency_info.Consistent();
  }
  bool HasAlnumChoice(const UNICHARSET &unicharset) {
    if (curr_b == nullptr) {
      return false;
    }
    UNICHAR_ID unichar_id = curr_b->unichar_id();
    if (unicharset.get_isalpha(unichar_id) || unicharset.get_isdigit(unichar_id)) {
      return true;
    }
    return false;
  }
  void Print(const char *msg) const;
 
  BLOB_CHOICE *curr_b;
  ViterbiStateEntry *parent_vse;
  ViterbiStateEntry *competing_vse;
 
  LanguageModelDawgInfo *dawg_info;
 
  LanguageModelNgramInfo *ngram_info;
 
  std::string *debug_str;
 
  float cost;
 
  float ratings_sum;                  
  float min_certainty;                
  int adapted;                        
  int length;                         
  float outline_length;               
  LMConsistencyInfo consistency_info; 
  AssociateStats associate_stats;     
 
  LanguageModelFlagsType top_choice_flags;
 
  bool updated; 
};
 
ELISTIZEH(ViterbiStateEntry)
 
 
struct LanguageModelState {
  LanguageModelState()
      : viterbi_state_entries_prunable_length(0)
      , viterbi_state_entries_prunable_max_cost(FLT_MAX)
      , viterbi_state_entries_length(0) {}
  ~LanguageModelState() = default;
 
  void Clear();
 
  void Print(const char *msg);
 
  ViterbiStateEntry_LIST viterbi_state_entries;
  int viterbi_state_entries_prunable_length;
  float viterbi_state_entries_prunable_max_cost;
  int viterbi_state_entries_length;
};
 
struct BestChoiceBundle {
  explicit BestChoiceBundle(int matrix_dimension) : updated(false), best_vse(nullptr) {
    beam.reserve(matrix_dimension);
    for (int i = 0; i < matrix_dimension; ++i) {
      beam.push_back(new LanguageModelState);
    }
  }
  ~BestChoiceBundle() {
    for (auto &state : beam) {
      delete state;
    }
  }
 
  bool updated;
  DANGERR fixpt;
  std::vector<LanguageModelState *> beam;
  ViterbiStateEntry *best_vse;
};
 
} // namespace tesseract
 
#endif // TESSERACT_WORDREC_LANGUAGE_MODEL_DEFS_H_