params.cpp

Go to the documentation of this file.

/**********************************************************************
 * File:        params.cpp
 * Description: Initialization and setting of Tesseract parameters.
 * Author:      Ray Smith
 *
 * (C) Copyright 1991, 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 "params.h"
 
#include "helpers.h"  // for chomp_string
#include "host.h"     // tesseract/export.h, windows.h for MAX_PATH
#include "serialis.h" // for TFile
#include "tprintf.h"
 
#include <climits> // for INT_MIN, INT_MAX
#include <cmath>   // for NAN, std::isnan
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <locale>  // for std::locale::classic
#include <sstream> // for std::stringstream
 
namespace tesseract {
 
tesseract::ParamsVectors *GlobalParams() {
  static tesseract::ParamsVectors global_params = tesseract::ParamsVectors();
  return &global_params;
}
 
bool ParamUtils::ReadParamsFile(const char *file, SetParamConstraint constraint,
                                ParamsVectors *member_params) {
  TFile fp;
  if (!fp.Open(file, nullptr)) {
    tprintf("read_params_file: Can't open %s\n", file);
    return true;
  }
  return ReadParamsFromFp(constraint, &fp, member_params);
}
 
bool ParamUtils::ReadParamsFromFp(SetParamConstraint constraint, TFile *fp,
                                  ParamsVectors *member_params) {
  char line[MAX_PATH]; // input line
  bool anyerr = false; // true if any error
  bool foundit;        // found parameter
  char *valptr;        // value field
 
  while (fp->FGets(line, MAX_PATH) != nullptr) {
    if (line[0] != '\r' && line[0] != '\n' && line[0] != '#') {
      chomp_string(line); // remove newline
      for (valptr = line; *valptr && *valptr != ' ' && *valptr != '\t'; valptr++) {
        ;
      }
      if (*valptr) {    // found blank
        *valptr = '\0'; // make name a string
        do {
          valptr++; // find end of blanks
        } while (*valptr == ' ' || *valptr == '\t');
      }
      foundit = SetParam(line, valptr, constraint, member_params);
 
      if (!foundit) {
        anyerr = true; // had an error
        tprintf("Warning: Parameter not found: %s\n", line);
      }
    }
  }
  return anyerr;
}
 
bool ParamUtils::SetParam(const char *name, const char *value, SetParamConstraint constraint,
                          ParamsVectors *member_params) {
  // Look for the parameter among string parameters.
  auto *sp =
      FindParam<StringParam>(name, GlobalParams()->string_params, member_params->string_params);
  if (sp != nullptr && sp->constraint_ok(constraint)) {
    sp->set_value(value);
  }
  if (*value == '\0') {
    return (sp != nullptr);
  }
 
  // Look for the parameter among int parameters.
  auto *ip = FindParam<IntParam>(name, GlobalParams()->int_params, member_params->int_params);
  if (ip && ip->constraint_ok(constraint)) {
    int intval = INT_MIN;
    std::stringstream stream(value);
    stream.imbue(std::locale::classic());
    stream >> intval;
    if (intval != INT_MIN) {
      ip->set_value(intval);
    }
  }
 
  // Look for the parameter among bool parameters.
  auto *bp = FindParam<BoolParam>(name, GlobalParams()->bool_params, member_params->bool_params);
  if (bp != nullptr && bp->constraint_ok(constraint)) {
    if (*value == 'T' || *value == 't' || *value == 'Y' || *value == 'y' || *value == '1') {
      bp->set_value(true);
    } else if (*value == 'F' || *value == 'f' || *value == 'N' || *value == 'n' || *value == '0') {
      bp->set_value(false);
    }
  }
 
  // Look for the parameter among double parameters.
  auto *dp =
      FindParam<DoubleParam>(name, GlobalParams()->double_params, member_params->double_params);
  if (dp != nullptr && dp->constraint_ok(constraint)) {
    double doubleval = NAN;
    std::stringstream stream(value);
    stream.imbue(std::locale::classic());
    stream >> doubleval;
    if (!std::isnan(doubleval)) {
      dp->set_value(doubleval);
    }
  }
  return (sp || ip || bp || dp);
}
 
bool ParamUtils::GetParamAsString(const char *name, const ParamsVectors *member_params,
                                  std::string *value) {
  // Look for the parameter among string parameters.
  auto *sp =
      FindParam<StringParam>(name, GlobalParams()->string_params, member_params->string_params);
  if (sp) {
    *value = sp->c_str();
    return true;
  }
  // Look for the parameter among int parameters.
  auto *ip = FindParam<IntParam>(name, GlobalParams()->int_params, member_params->int_params);
  if (ip) {
    *value = std::to_string(int32_t(*ip));
    return true;
  }
  // Look for the parameter among bool parameters.
  auto *bp = FindParam<BoolParam>(name, GlobalParams()->bool_params, member_params->bool_params);
  if (bp != nullptr) {
    *value = bool(*bp) ? "1" : "0";
    return true;
  }
  // Look for the parameter among double parameters.
  auto *dp =
      FindParam<DoubleParam>(name, GlobalParams()->double_params, member_params->double_params);
  if (dp != nullptr) {
    std::ostringstream stream;
    stream.imbue(std::locale::classic());
    stream << double(*dp);
    *value = stream.str();
    return true;
  }
  return false;
}
 
void ParamUtils::PrintParams(FILE *fp, const ParamsVectors *member_params) {
  int num_iterations = (member_params == nullptr) ? 1 : 2;
  std::ostringstream stream;
  stream.imbue(std::locale::classic());
  for (int v = 0; v < num_iterations; ++v) {
    const ParamsVectors *vec = (v == 0) ? GlobalParams() : member_params;
    for (auto int_param : vec->int_params) {
      stream << int_param->name_str() << '\t' << (int32_t)(*int_param) << '\t'
             << int_param->info_str() << '\n';
    }
    for (auto bool_param : vec->bool_params) {
      stream << bool_param->name_str() << '\t' << bool(*bool_param) << '\t'
             << bool_param->info_str() << '\n';
    }
    for (auto string_param : vec->string_params) {
      stream << string_param->name_str() << '\t' << string_param->c_str() << '\t'
             << string_param->info_str() << '\n';
    }
    for (auto double_param : vec->double_params) {
      stream << double_param->name_str() << '\t' << (double)(*double_param) << '\t'
             << double_param->info_str() << '\n';
    }
  }
  fprintf(fp, "%s", stream.str().c_str());
}
 
// Resets all parameters back to default values;
void ParamUtils::ResetToDefaults(ParamsVectors *member_params) {
  int num_iterations = (member_params == nullptr) ? 1 : 2;
  for (int v = 0; v < num_iterations; ++v) {
    ParamsVectors *vec = (v == 0) ? GlobalParams() : member_params;
    for (auto &param : vec->int_params) {
      param->ResetToDefault();
    }
    for (auto &param : vec->bool_params) {
      param->ResetToDefault();
    }
    for (auto &param : vec->string_params) {
      param->ResetToDefault();
    }
    for (auto &param : vec->double_params) {
      param->ResetToDefault();
    }
  }
}
 
} // namespace tesseract