///////////////////////////////////////////////////////////////////////
// File:        params_training_featdef.h
// Description: Feature definitions for params training.
// Author:      Rika Antonova
//
// (C) Copyright 2011, 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_PARAMS_TRAINING_FEATDEF_H_
#define TESSERACT_WORDREC_PARAMS_TRAINING_FEATDEF_H_

#include <cstring> // for memset
#include <string>
#include <vector>

namespace tesseract {

// Maximum number of unichars in the small and medium sized words
static const int kMaxSmallWordUnichars = 3;
static const int kMaxMediumWordUnichars = 6;

// Raw features extracted from a single OCR hypothesis.
// The features are normalized (by outline length or number of unichars as
// appropriate) real-valued quantities with unbounded range and
// unknown distribution.
// Normalization / binarization of these features is done at a later stage.
// Note: when adding new fields to this enum make sure to modify
// kParamsTrainingFeatureTypeName
enum kParamsTrainingFeatureType {
  // Digits
  PTRAIN_DIGITS_SHORT, // 0
  PTRAIN_DIGITS_MED,   // 1
  PTRAIN_DIGITS_LONG,  // 2
  // Number or pattern (NUMBER_PERM, USER_PATTERN_PERM)
  PTRAIN_NUM_SHORT, // 3
  PTRAIN_NUM_MED,   // 4
  PTRAIN_NUM_LONG,  // 5
  // Document word (DOC_DAWG_PERM)
  PTRAIN_DOC_SHORT, // 6
  PTRAIN_DOC_MED,   // 7
  PTRAIN_DOC_LONG,  // 8
  // Word (SYSTEM_DAWG_PERM, USER_DAWG_PERM, COMPOUND_PERM)
  PTRAIN_DICT_SHORT, // 9
  PTRAIN_DICT_MED,   // 10
  PTRAIN_DICT_LONG,  // 11
  // Frequent word (FREQ_DAWG_PERM)
  PTRAIN_FREQ_SHORT,          // 12
  PTRAIN_FREQ_MED,            // 13
  PTRAIN_FREQ_LONG,           // 14
  PTRAIN_SHAPE_COST_PER_CHAR, // 15
  PTRAIN_NGRAM_COST_PER_CHAR, // 16
  PTRAIN_NUM_BAD_PUNC,        // 17
  PTRAIN_NUM_BAD_CASE,        // 18
  PTRAIN_XHEIGHT_CONSISTENCY, // 19
  PTRAIN_NUM_BAD_CHAR_TYPE,   // 20
  PTRAIN_NUM_BAD_SPACING,     // 21
  PTRAIN_NUM_BAD_FONT,        // 22
  PTRAIN_RATING_PER_CHAR,     // 23

  PTRAIN_NUM_FEATURE_TYPES
};

static const char *const kParamsTrainingFeatureTypeName[] = {
    "PTRAIN_DIGITS_SHORT",        // 0
    "PTRAIN_DIGITS_MED",          // 1
    "PTRAIN_DIGITS_LONG",         // 2
    "PTRAIN_NUM_SHORT",           // 3
    "PTRAIN_NUM_MED",             // 4
    "PTRAIN_NUM_LONG",            // 5
    "PTRAIN_DOC_SHORT",           // 6
    "PTRAIN_DOC_MED",             // 7
    "PTRAIN_DOC_LONG",            // 8
    "PTRAIN_DICT_SHORT",          // 9
    "PTRAIN_DICT_MED",            // 10
    "PTRAIN_DICT_LONG",           // 11
    "PTRAIN_FREQ_SHORT",          // 12
    "PTRAIN_FREQ_MED",            // 13
    "PTRAIN_FREQ_LONG",           // 14
    "PTRAIN_SHAPE_COST_PER_CHAR", // 15
    "PTRAIN_NGRAM_COST_PER_CHAR", // 16
    "PTRAIN_NUM_BAD_PUNC",        // 17
    "PTRAIN_NUM_BAD_CASE",        // 18
    "PTRAIN_XHEIGHT_CONSISTENCY", // 19
    "PTRAIN_NUM_BAD_CHAR_TYPE",   // 20
    "PTRAIN_NUM_BAD_SPACING",     // 21
    "PTRAIN_NUM_BAD_FONT",        // 22
    "PTRAIN_RATING_PER_CHAR",     // 23
};

// Returns the index of the given feature (by name),
// or -1 meaning the feature is unknown.
int ParamsTrainingFeatureByName(const char *name);

// Entry with features extracted from a single OCR hypothesis for a word.
struct ParamsTrainingHypothesis {
  ParamsTrainingHypothesis() : cost(0.0) {
    memset(features, 0, sizeof(features));
  }
  ParamsTrainingHypothesis(const ParamsTrainingHypothesis &other) {
    memcpy(features, other.features, sizeof(features));
    str = other.str;
    cost = other.cost;
  }
  ParamsTrainingHypothesis &operator=(const ParamsTrainingHypothesis &other) {
    memcpy(features, other.features, sizeof(features));
    str = other.str;
    cost = other.cost;
    return *this;
  }
  std::string str; // string corresponding to word hypothesis (for debugging)
  float features[PTRAIN_NUM_FEATURE_TYPES];
  float cost; // path cost computed by segsearch
};

// A list of hypotheses explored during one run of segmentation search.
using ParamsTrainingHypothesisList = std::vector<ParamsTrainingHypothesis>;

// A bundle that accumulates all of the hypothesis lists explored during all
// of the runs of segmentation search on a word (e.g. a list of hypotheses
// explored on PASS1, PASS2, fix xheight pass, etc).
class ParamsTrainingBundle {
public:
  ParamsTrainingBundle() = default;
  // Starts a new hypothesis list.
  // Should be called at the beginning of a new run of the segmentation search.
  void StartHypothesisList() {
    hyp_list_vec.emplace_back();
  }
  // Adds a new ParamsTrainingHypothesis to the current hypothesis list
  // and returns the reference to the newly added entry.
  ParamsTrainingHypothesis &AddHypothesis(const ParamsTrainingHypothesis &other) {
    if (hyp_list_vec.empty()) {
      StartHypothesisList();
    }
    hyp_list_vec.back().push_back(ParamsTrainingHypothesis(other));
    return hyp_list_vec.back().back();
  }

  std::vector<ParamsTrainingHypothesisList> hyp_list_vec;
};

} // namespace tesseract

#endif // TESSERACT_WORDREC_PARAMS_TRAINING_FEATDEF_H_