summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat (limited to 'tesseract/src/ccutil/params.h')
-rw-r--r--tesseract/src/ccutil/params.h339
1 files changed, 339 insertions, 0 deletions
diff --git a/tesseract/src/ccutil/params.h b/tesseract/src/ccutil/params.h
new file mode 100644
index 00000000..988c40be
--- /dev/null
+++ b/tesseract/src/ccutil/params.h
@@ -0,0 +1,339 @@
+/**********************************************************************
+ * File: params.h
+ * Description: Class definitions of the *_VAR classes for tunable constants.
+ * 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.
+ *
+ **********************************************************************/
+
+#ifndef PARAMS_H
+#define PARAMS_H
+
+#include "genericvector.h"
+#include "strngs.h"
+
+#include <cstdio>
+
+namespace tesseract {
+
+class IntParam;
+class BoolParam;
+class StringParam;
+class DoubleParam;
+
+// Enum for constraints on what kind of params should be set by SetParam().
+enum SetParamConstraint {
+ SET_PARAM_CONSTRAINT_NONE,
+ SET_PARAM_CONSTRAINT_DEBUG_ONLY,
+ SET_PARAM_CONSTRAINT_NON_DEBUG_ONLY,
+ SET_PARAM_CONSTRAINT_NON_INIT_ONLY,
+};
+
+struct ParamsVectors {
+ GenericVector<IntParam*> int_params;
+ GenericVector<BoolParam*> bool_params;
+ GenericVector<StringParam*> string_params;
+ GenericVector<DoubleParam*> double_params;
+};
+
+// Utility functions for working with Tesseract parameters.
+class TESS_API ParamUtils {
+ public:
+ // Reads a file of parameter definitions and set/modify the values therein.
+ // If the filename begins with a + or -, the BoolVariables will be
+ // ORed or ANDed with any current values.
+ // Blank lines and lines beginning # are ignored.
+ // Values may have any whitespace after the name and are the rest of line.
+ static bool ReadParamsFile(const char* file, // filename to read
+ SetParamConstraint constraint,
+ ParamsVectors* member_params);
+
+ // Read parameters from the given file pointer.
+ static bool ReadParamsFromFp(SetParamConstraint constraint, TFile* fp,
+ ParamsVectors* member_params);
+
+ // Set a parameters to have the given value.
+ static bool SetParam(const char* name, const char* value,
+ SetParamConstraint constraint,
+ ParamsVectors* member_params);
+
+ // Returns the pointer to the parameter with the given name (of the
+ // appropriate type) if it was found in the vector obtained from
+ // GlobalParams() or in the given member_params.
+ template <class T>
+ static T* FindParam(const char* name, const GenericVector<T*>& global_vec,
+ const GenericVector<T*>& member_vec) {
+ int i;
+ for (i = 0; i < global_vec.size(); ++i) {
+ if (strcmp(global_vec[i]->name_str(), name) == 0) return global_vec[i];
+ }
+ for (i = 0; i < member_vec.size(); ++i) {
+ if (strcmp(member_vec[i]->name_str(), name) == 0) return member_vec[i];
+ }
+ return nullptr;
+ }
+ // Removes the given pointer to the param from the given vector.
+ template <class T>
+ static void RemoveParam(T* param_ptr, GenericVector<T*>* vec) {
+ for (int i = 0; i < vec->size(); ++i) {
+ if ((*vec)[i] == param_ptr) {
+ vec->remove(i);
+ return;
+ }
+ }
+ }
+ // Fetches the value of the named param as a STRING. Returns false if not
+ // found.
+ static bool GetParamAsString(const char* name,
+ const ParamsVectors* member_params,
+ std::string* value);
+
+ // Print parameters to the given file.
+ static void PrintParams(FILE* fp, const ParamsVectors* member_params);
+
+ // Resets all parameters back to default values;
+ static void ResetToDefaults(ParamsVectors* member_params);
+};
+
+// Definition of various parameter types.
+class Param {
+ public:
+ ~Param() = default;
+
+ const char* name_str() const { return name_; }
+ const char* info_str() const { return info_; }
+ bool is_init() const { return init_; }
+ bool is_debug() const { return debug_; }
+ bool constraint_ok(SetParamConstraint constraint) const {
+ return (
+ constraint == SET_PARAM_CONSTRAINT_NONE ||
+ (constraint == SET_PARAM_CONSTRAINT_DEBUG_ONLY && this->is_debug()) ||
+ (constraint == SET_PARAM_CONSTRAINT_NON_DEBUG_ONLY &&
+ !this->is_debug()) ||
+ (constraint == SET_PARAM_CONSTRAINT_NON_INIT_ONLY && !this->is_init()));
+ }
+
+ protected:
+ Param(const char* name, const char* comment, bool init)
+ : name_(name), info_(comment), init_(init) {
+ debug_ = (strstr(name, "debug") != nullptr) || (strstr(name, "display"));
+ }
+
+ const char* name_; // name of this parameter
+ const char* info_; // for menus
+ bool init_; // needs to be set before init
+ bool debug_;
+};
+
+class IntParam : public Param {
+ public:
+ IntParam(int32_t value, const char* name, const char* comment, bool init,
+ ParamsVectors* vec)
+ : Param(name, comment, init) {
+ value_ = value;
+ default_ = value;
+ params_vec_ = &(vec->int_params);
+ vec->int_params.push_back(this);
+ }
+ ~IntParam() { ParamUtils::RemoveParam<IntParam>(this, params_vec_); }
+ operator int32_t() const { return value_; }
+ void operator=(int32_t value) { value_ = value; }
+ void set_value(int32_t value) { value_ = value; }
+ void ResetToDefault() { value_ = default_; }
+ void ResetFrom(const ParamsVectors* vec) {
+ for (int i = 0; i < vec->int_params.size(); ++i) {
+ if (strcmp(vec->int_params[i]->name_str(), name_) == 0) {
+ // printf("overriding param %s=%d by =%d\n", name_, value_,
+ // *vec->int_params[i]);
+ value_ = *vec->int_params[i];
+ break;
+ }
+ }
+ }
+
+ private:
+ int32_t value_;
+ int32_t default_;
+ // Pointer to the vector that contains this param (not owned by this class).
+ GenericVector<IntParam*>* params_vec_;
+};
+
+class BoolParam : public Param {
+ public:
+ BoolParam(bool value, const char* name, const char* comment, bool init,
+ ParamsVectors* vec)
+ : Param(name, comment, init) {
+ value_ = value;
+ default_ = value;
+ params_vec_ = &(vec->bool_params);
+ vec->bool_params.push_back(this);
+ }
+ ~BoolParam() { ParamUtils::RemoveParam<BoolParam>(this, params_vec_); }
+ operator bool() const { return value_; }
+ void operator=(bool value) { value_ = value; }
+ void set_value(bool value) { value_ = value; }
+ void ResetToDefault() { value_ = default_; }
+ void ResetFrom(const ParamsVectors* vec) {
+ for (int i = 0; i < vec->bool_params.size(); ++i) {
+ if (strcmp(vec->bool_params[i]->name_str(), name_) == 0) {
+ // printf("overriding param %s=%s by =%s\n", name_, value_ ? "true" :
+ // "false", *vec->bool_params[i] ? "true" : "false");
+ value_ = *vec->bool_params[i];
+ break;
+ }
+ }
+ }
+
+ private:
+ bool value_;
+ bool default_;
+ // Pointer to the vector that contains this param (not owned by this class).
+ GenericVector<BoolParam*>* params_vec_;
+};
+
+class StringParam : public Param {
+ public:
+ StringParam(const char* value, const char* name, const char* comment,
+ bool init, ParamsVectors* vec)
+ : Param(name, comment, init) {
+ value_ = value;
+ default_ = value;
+ params_vec_ = &(vec->string_params);
+ vec->string_params.push_back(this);
+ }
+ ~StringParam() { ParamUtils::RemoveParam<StringParam>(this, params_vec_); }
+ operator STRING&() { return value_; }
+ const char* c_str() const { return value_.c_str(); }
+ bool empty() { return value_.length() <= 0; }
+ bool operator==(const STRING& other) { return value_ == other; }
+ void operator=(const STRING& value) { value_ = value; }
+ void set_value(const STRING& value) { value_ = value; }
+ void ResetToDefault() { value_ = default_; }
+ void ResetFrom(const ParamsVectors* vec) {
+ for (int i = 0; i < vec->string_params.size(); ++i) {
+ if (strcmp(vec->string_params[i]->name_str(), name_) == 0) {
+ // printf("overriding param %s=%s by =%s\n", name_, value_,
+ // vec->string_params[i]->c_str());
+ value_ = *vec->string_params[i];
+ break;
+ }
+ }
+ }
+
+ private:
+ STRING value_;
+ STRING default_;
+ // Pointer to the vector that contains this param (not owned by this class).
+ GenericVector<StringParam*>* params_vec_;
+};
+
+class DoubleParam : public Param {
+ public:
+ DoubleParam(double value, const char* name, const char* comment, bool init,
+ ParamsVectors* vec)
+ : Param(name, comment, init) {
+ value_ = value;
+ default_ = value;
+ params_vec_ = &(vec->double_params);
+ vec->double_params.push_back(this);
+ }
+ ~DoubleParam() { ParamUtils::RemoveParam<DoubleParam>(this, params_vec_); }
+ operator double() const { return value_; }
+ void operator=(double value) { value_ = value; }
+ void set_value(double value) { value_ = value; }
+ void ResetToDefault() { value_ = default_; }
+ void ResetFrom(const ParamsVectors* vec) {
+ for (int i = 0; i < vec->double_params.size(); ++i) {
+ if (strcmp(vec->double_params[i]->name_str(), name_) == 0) {
+ // printf("overriding param %s=%f by =%f\n", name_, value_,
+ // *vec->double_params[i]);
+ value_ = *vec->double_params[i];
+ break;
+ }
+ }
+ }
+
+ private:
+ double value_;
+ double default_;
+ // Pointer to the vector that contains this param (not owned by this class).
+ GenericVector<DoubleParam*>* params_vec_;
+};
+
+// Global parameter lists.
+//
+// To avoid the problem of undetermined order of static initialization
+// global_params are accessed through the GlobalParams function that
+// initializes the static pointer to global_params only on the first time
+// GlobalParams() is called.
+//
+// TODO(daria): remove GlobalParams() when all global Tesseract
+// parameters are converted to members.
+TESS_API
+ParamsVectors* GlobalParams();
+
+/*************************************************************************
+ * Note on defining parameters.
+ *
+ * The values of the parameters defined with *_INIT_* macros are guaranteed
+ * to be loaded from config files before Tesseract initialization is done
+ * (there is no such guarantee for parameters defined with the other macros).
+ *************************************************************************/
+
+#define INT_VAR_H(name, val, comment) ::tesseract::IntParam name
+
+#define BOOL_VAR_H(name, val, comment) ::tesseract::BoolParam name
+
+#define STRING_VAR_H(name, val, comment) ::tesseract::StringParam name
+
+#define double_VAR_H(name, val, comment) ::tesseract::DoubleParam name
+
+#define INT_VAR(name, val, comment) \
+ ::tesseract::IntParam name(val, #name, comment, false, ::tesseract::GlobalParams())
+
+#define BOOL_VAR(name, val, comment) \
+ ::tesseract::BoolParam name(val, #name, comment, false, ::tesseract::GlobalParams())
+
+#define STRING_VAR(name, val, comment) \
+ ::tesseract::StringParam name(val, #name, comment, false, ::tesseract::GlobalParams())
+
+#define double_VAR(name, val, comment) \
+ ::tesseract::DoubleParam name(val, #name, comment, false, ::tesseract::GlobalParams())
+
+#define INT_MEMBER(name, val, comment, vec) \
+ name(val, #name, comment, false, vec)
+
+#define BOOL_MEMBER(name, val, comment, vec) \
+ name(val, #name, comment, false, vec)
+
+#define STRING_MEMBER(name, val, comment, vec) \
+ name(val, #name, comment, false, vec)
+
+#define double_MEMBER(name, val, comment, vec) \
+ name(val, #name, comment, false, vec)
+
+#define INT_INIT_MEMBER(name, val, comment, vec) \
+ name(val, #name, comment, true, vec)
+
+#define BOOL_INIT_MEMBER(name, val, comment, vec) \
+ name(val, #name, comment, true, vec)
+
+#define STRING_INIT_MEMBER(name, val, comment, vec) \
+ name(val, #name, comment, true, vec)
+
+#define double_INIT_MEMBER(name, val, comment, vec) \
+ name(val, #name, comment, true, vec)
+
+} // namespace tesseract
+
+#endif