tesseract::Classify Class Reference

#include <classify.h>

Inheritance diagram for tesseract::Classify:

Public Member Functions
	Classify ()
	~Classify () override
virtual Dict &	getDict ()
const ShapeTable *	shape_table () const
void	SetStaticClassifier (ShapeClassifier *static_classifier)
void	AddLargeSpeckleTo (int blob_length, BLOB_CHOICE_LIST *choices)
bool	LargeSpeckle (const TBLOB &blob)
int	GetFontinfoId (ADAPT_CLASS_STRUCT *Class, uint8_t ConfigId)
int	PruneClasses (const INT_TEMPLATES_STRUCT *int_templates, int num_features, int keep_this, const INT_FEATURE_STRUCT *features, const uint8_t *normalization_factors, const uint16_t *expected_num_features, std::vector< CP_RESULT_STRUCT > *results)
void	ReadNewCutoffs (TFile *fp, uint16_t *Cutoffs)
void	PrintAdaptedTemplates (FILE *File, ADAPT_TEMPLATES_STRUCT *Templates)
void	WriteAdaptedTemplates (FILE *File, ADAPT_TEMPLATES_STRUCT *Templates)
ADAPT_TEMPLATES_STRUCT *	ReadAdaptedTemplates (TFile *File)
void	ConvertProto (PROTO_STRUCT *Proto, int ProtoId, INT_CLASS_STRUCT *Class)
INT_TEMPLATES_STRUCT *	CreateIntTemplates (CLASSES FloatProtos, const UNICHARSET &target_unicharset)
void	LearnWord (const char *fontname, WERD_RES *word)
void	LearnPieces (const char *fontname, int start, int length, float threshold, CharSegmentationType segmentation, const char *correct_text, WERD_RES *word)
void	InitAdaptiveClassifier (TessdataManager *mgr)
void	InitAdaptedClass (TBLOB *Blob, CLASS_ID ClassId, int FontinfoId, ADAPT_CLASS_STRUCT *Class, ADAPT_TEMPLATES_STRUCT *Templates)
void	AmbigClassifier (const std::vector< INT_FEATURE_STRUCT > &int_features, const INT_FX_RESULT_STRUCT &fx_info, const TBLOB *blob, INT_TEMPLATES_STRUCT *templates, ADAPT_CLASS_STRUCT **classes, UNICHAR_ID *ambiguities, ADAPT_RESULTS *results)
void	MasterMatcher (INT_TEMPLATES_STRUCT *templates, int16_t num_features, const INT_FEATURE_STRUCT *features, const uint8_t *norm_factors, ADAPT_CLASS_STRUCT **classes, int debug, int matcher_multiplier, const TBOX &blob_box, const std::vector< CP_RESULT_STRUCT > &results, ADAPT_RESULTS *final_results)
void	ExpandShapesAndApplyCorrections (ADAPT_CLASS_STRUCT **classes, bool debug, int class_id, int bottom, int top, float cp_rating, int blob_length, int matcher_multiplier, const uint8_t *cn_factors, UnicharRating *int_result, ADAPT_RESULTS *final_results)
double	ComputeCorrectedRating (bool debug, int unichar_id, double cp_rating, double im_rating, int feature_misses, int bottom, int top, int blob_length, int matcher_multiplier, const uint8_t *cn_factors)
void	ConvertMatchesToChoices (const DENORM &denorm, const TBOX &box, ADAPT_RESULTS *Results, BLOB_CHOICE_LIST *Choices)
void	AddNewResult (const UnicharRating &new_result, ADAPT_RESULTS *results)
int	GetAdaptiveFeatures (TBLOB *Blob, INT_FEATURE_ARRAY IntFeatures, FEATURE_SET *FloatFeatures)
void	DebugAdaptiveClassifier (TBLOB *Blob, ADAPT_RESULTS *Results)
PROTO_ID	MakeNewTempProtos (FEATURE_SET Features, int NumBadFeat, FEATURE_ID BadFeat[], INT_CLASS_STRUCT *IClass, ADAPT_CLASS_STRUCT *Class, BIT_VECTOR TempProtoMask)
int	MakeNewTemporaryConfig (ADAPT_TEMPLATES_STRUCT *Templates, CLASS_ID ClassId, int FontinfoId, int NumFeatures, INT_FEATURE_ARRAY Features, FEATURE_SET FloatFeatures)
void	MakePermanent (ADAPT_TEMPLATES_STRUCT *Templates, CLASS_ID ClassId, int ConfigId, TBLOB *Blob)
void	PrintAdaptiveMatchResults (const ADAPT_RESULTS &results)
void	RemoveExtraPuncs (ADAPT_RESULTS *Results)
void	RemoveBadMatches (ADAPT_RESULTS *Results)
void	SetAdaptiveThreshold (float Threshold)
void	ShowBestMatchFor (int shape_id, const INT_FEATURE_STRUCT *features, int num_features)
std::string	ClassIDToDebugStr (const INT_TEMPLATES_STRUCT *templates, int class_id, int config_id) const
int	ClassAndConfigIDToFontOrShapeID (int class_id, int int_result_config) const
int	ShapeIDToClassID (int shape_id) const
UNICHAR_ID *	BaselineClassifier (TBLOB *Blob, const std::vector< INT_FEATURE_STRUCT > &int_features, const INT_FX_RESULT_STRUCT &fx_info, ADAPT_TEMPLATES_STRUCT *Templates, ADAPT_RESULTS *Results)
int	CharNormClassifier (TBLOB *blob, const TrainingSample &sample, ADAPT_RESULTS *adapt_results)
int	CharNormTrainingSample (bool pruner_only, int keep_this, const TrainingSample &sample, std::vector< UnicharRating > *results)
UNICHAR_ID *	GetAmbiguities (TBLOB *Blob, CLASS_ID CorrectClass)
void	DoAdaptiveMatch (TBLOB *Blob, ADAPT_RESULTS *Results)
void	AdaptToChar (TBLOB *Blob, CLASS_ID ClassId, int FontinfoId, float Threshold, ADAPT_TEMPLATES_STRUCT *adaptive_templates)
void	DisplayAdaptedChar (TBLOB *blob, INT_CLASS_STRUCT *int_class)
bool	AdaptableWord (WERD_RES *word)
void	EndAdaptiveClassifier ()
void	SettupPass1 ()
void	SettupPass2 ()
void	AdaptiveClassifier (TBLOB *Blob, BLOB_CHOICE_LIST *Choices)
void	ClassifyAsNoise (ADAPT_RESULTS *Results)
void	ResetAdaptiveClassifierInternal ()
void	SwitchAdaptiveClassifier ()
void	StartBackupAdaptiveClassifier ()
int	GetCharNormFeature (const INT_FX_RESULT_STRUCT &fx_info, INT_TEMPLATES_STRUCT *templates, uint8_t *pruner_norm_array, uint8_t *char_norm_array)
void	ComputeCharNormArrays (FEATURE_STRUCT *norm_feature, INT_TEMPLATES_STRUCT *templates, uint8_t *char_norm_array, uint8_t *pruner_array)
bool	TempConfigReliable (CLASS_ID class_id, const TEMP_CONFIG_STRUCT *config)
void	UpdateAmbigsGroup (CLASS_ID class_id, TBLOB *Blob)
bool	AdaptiveClassifierIsFull () const
bool	AdaptiveClassifierIsEmpty () const
bool	LooksLikeGarbage (TBLOB *blob)
void	RefreshDebugWindow (ScrollView **win, const char *msg, int y_offset, const TBOX &wbox)
void	ClearCharNormArray (uint8_t *char_norm_array)
void	ComputeIntCharNormArray (const FEATURE_STRUCT &norm_feature, uint8_t *char_norm_array)
void	ComputeIntFeatures (FEATURE_SET Features, INT_FEATURE_ARRAY IntFeatures)
INT_TEMPLATES_STRUCT *	ReadIntTemplates (TFile *fp)
void	WriteIntTemplates (FILE *File, INT_TEMPLATES_STRUCT *Templates, const UNICHARSET &target_unicharset)
CLASS_ID	GetClassToDebug (const char *Prompt, bool *adaptive_on, bool *pretrained_on, int *shape_id)
void	ShowMatchDisplay ()
UnicityTable< FontInfo > &	get_fontinfo_table ()
const UnicityTable< FontInfo > &	get_fontinfo_table () const
UnicityTable< FontSet > &	get_fontset_table ()
void	NormalizeOutlines (LIST Outlines, float *XScale, float *YScale)
FEATURE_SET	ExtractOutlineFeatures (TBLOB *Blob)
FEATURE_SET	ExtractPicoFeatures (TBLOB *Blob)
FEATURE_SET	ExtractIntCNFeatures (const TBLOB &blob, const INT_FX_RESULT_STRUCT &fx_info)
FEATURE_SET	ExtractIntGeoFeatures (const TBLOB &blob, const INT_FX_RESULT_STRUCT &fx_info)
void	LearnBlob (const std::string &fontname, TBLOB *Blob, const DENORM &cn_denorm, const INT_FX_RESULT_STRUCT &fx_info, const char *blob_text)
bool	WriteTRFile (const char *filename)
	BOOL_VAR_H (allow_blob_division)
	BOOL_VAR_H (prioritize_division)
	BOOL_VAR_H (classify_enable_learning)
	INT_VAR_H (classify_debug_level)
	INT_VAR_H (classify_norm_method)
	double_VAR_H (classify_char_norm_range)
	double_VAR_H (classify_max_rating_ratio)
	double_VAR_H (classify_max_certainty_margin)
	BOOL_VAR_H (tess_cn_matching)
	BOOL_VAR_H (tess_bn_matching)
	BOOL_VAR_H (classify_enable_adaptive_matcher)
	BOOL_VAR_H (classify_use_pre_adapted_templates)
	BOOL_VAR_H (classify_save_adapted_templates)
	BOOL_VAR_H (classify_enable_adaptive_debugger)
	BOOL_VAR_H (classify_nonlinear_norm)
	INT_VAR_H (matcher_debug_level)
	INT_VAR_H (matcher_debug_flags)
	INT_VAR_H (classify_learning_debug_level)
	double_VAR_H (matcher_good_threshold)
	double_VAR_H (matcher_reliable_adaptive_result)
	double_VAR_H (matcher_perfect_threshold)
	double_VAR_H (matcher_bad_match_pad)
	double_VAR_H (matcher_rating_margin)
	double_VAR_H (matcher_avg_noise_size)
	INT_VAR_H (matcher_permanent_classes_min)
	INT_VAR_H (matcher_min_examples_for_prototyping)
	INT_VAR_H (matcher_sufficient_examples_for_prototyping)
	double_VAR_H (matcher_clustering_max_angle_delta)
	double_VAR_H (classify_misfit_junk_penalty)
	double_VAR_H (rating_scale)
	double_VAR_H (tessedit_class_miss_scale)
	double_VAR_H (classify_adapted_pruning_factor)
	double_VAR_H (classify_adapted_pruning_threshold)
	INT_VAR_H (classify_adapt_proto_threshold)
	INT_VAR_H (classify_adapt_feature_threshold)
	BOOL_VAR_H (disable_character_fragments)
	double_VAR_H (classify_character_fragments_garbage_certainty_threshold)
	BOOL_VAR_H (classify_debug_character_fragments)
	BOOL_VAR_H (matcher_debug_separate_windows)
	STRING_VAR_H (classify_learn_debug_str)
	INT_VAR_H (classify_class_pruner_threshold)
	INT_VAR_H (classify_class_pruner_multiplier)
	INT_VAR_H (classify_cp_cutoff_strength)
	INT_VAR_H (classify_integer_matcher_multiplier)
	BOOL_VAR_H (classify_bln_numeric_mode)
	double_VAR_H (speckle_large_max_size)
	double_VAR_H (speckle_rating_penalty)
NormEvidenceOf
Return the new type of evidence number corresponding to this normalization adjustment. The equation that represents the transform is: 1 / (1 + (NormAdj / midpoint) ^ curl)
float	ComputeNormMatch (CLASS_ID ClassId, const FEATURE_STRUCT &feature, bool DebugMatch)
void	FreeNormProtos ()
NORM_PROTOS *	ReadNormProtos (TFile *fp)
Public Member Functions inherited from tesseract::CCUtil
	CCUtil ()
virtual	~CCUtil ()
void	main_setup (const std::string &argv0, const std::string &basename)
	CCUtil::main_setup - set location of tessdata and name of image. More...
ParamsVectors *	params ()
	INT_VAR_H (ambigs_debug_level)
	BOOL_VAR_H (use_ambigs_for_adaption)

Static Public Member Functions
static void	SetupBLCNDenorms (const TBLOB &blob, bool nonlinear_norm, DENORM *bl_denorm, DENORM *cn_denorm, INT_FX_RESULT_STRUCT *fx_info)
static void	ExtractFeatures (const TBLOB &blob, bool nonlinear_norm, std::vector< INT_FEATURE_STRUCT > *bl_features, std::vector< INT_FEATURE_STRUCT > *cn_features, INT_FX_RESULT_STRUCT *results, std::vector< int > *outline_cn_counts)

Public Attributes
INT_TEMPLATES_STRUCT *	PreTrainedTemplates = nullptr
ADAPT_TEMPLATES_STRUCT *	AdaptedTemplates = nullptr
ADAPT_TEMPLATES_STRUCT *	BackupAdaptedTemplates = nullptr
BIT_VECTOR	AllProtosOn = nullptr
BIT_VECTOR	AllConfigsOn = nullptr
BIT_VECTOR	AllConfigsOff = nullptr
BIT_VECTOR	TempProtoMask = nullptr
NORM_PROTOS *	NormProtos = nullptr
UnicityTable< FontInfo >	fontinfo_table_
UnicityTable< FontSet >	fontset_table_
bool	EnableLearning = true
Public Attributes inherited from tesseract::CCUtil
std::string	datadir
std::string	imagebasename
std::string	lang
std::string	language_data_path_prefix
UNICHARSET	unicharset
UnicharAmbigs	unichar_ambigs
std::string	imagefile
std::string	directory

Protected Attributes
IntegerMatcher	im_
FEATURE_DEFS_STRUCT	feature_defs_
ShapeTable *	shape_table_ = nullptr

Additional Inherited Members
Static Public Attributes inherited from tesseract::CCStruct
static const double	kDescenderFraction = 0.25
static const double	kXHeightFraction = 0.5
static const double	kAscenderFraction = 0.25
static const double	kXHeightCapRatio

Detailed Description

Definition at line 94 of file classify.h.

Constructor & Destructor Documentation

Classify()

tesseract::Classify::Classify

(

)

Definition at line 60 of file classify.cpp.

    : BOOL_MEMBER(allow_blob_division, true, "Use divisible blobs chopping", this->params())
    , BOOL_MEMBER(prioritize_division, false, "Prioritize blob division over chopping",
                  this->params())
    , BOOL_MEMBER(classify_enable_learning, true, "Enable adaptive classifier", this->params())
    , INT_MEMBER(classify_debug_level, 0, "Classify debug level", this->params())
    , INT_MEMBER(classify_norm_method, character, "Normalization Method   ...", this->params())
    , double_MEMBER(classify_char_norm_range, 0.2, "Character Normalization Range ...",
                    this->params())
    , double_MEMBER(classify_max_rating_ratio, 1.5, "Veto ratio between classifier ratings",
                    this->params())
    , double_MEMBER(classify_max_certainty_margin, 5.5,
                    "Veto difference between classifier certainties", this->params())
    , BOOL_MEMBER(tess_cn_matching, 0, "Character Normalized Matching", this->params())
    , BOOL_MEMBER(tess_bn_matching, 0, "Baseline Normalized Matching", this->params())
    , BOOL_MEMBER(classify_enable_adaptive_matcher, 1, "Enable adaptive classifier", this->params())
    , BOOL_MEMBER(classify_use_pre_adapted_templates, 0, "Use pre-adapted classifier templates",
                  this->params())
    , BOOL_MEMBER(classify_save_adapted_templates, 0, "Save adapted templates to a file",
                  this->params())
    , BOOL_MEMBER(classify_enable_adaptive_debugger, 0, "Enable match debugger", this->params())
    , BOOL_MEMBER(classify_nonlinear_norm, 0, "Non-linear stroke-density normalization",
                  this->params())
    , INT_MEMBER(matcher_debug_level, 0, "Matcher Debug Level", this->params())
    , INT_MEMBER(matcher_debug_flags, 0, "Matcher Debug Flags", this->params())
    , INT_MEMBER(classify_learning_debug_level, 0, "Learning Debug Level: ", this->params())
    , double_MEMBER(matcher_good_threshold, 0.125, "Good Match (0-1)", this->params())
    , double_MEMBER(matcher_reliable_adaptive_result, 0.0, "Great Match (0-1)", this->params())
    , double_MEMBER(matcher_perfect_threshold, 0.02, "Perfect Match (0-1)", this->params())
    , double_MEMBER(matcher_bad_match_pad, 0.15, "Bad Match Pad (0-1)", this->params())
    , double_MEMBER(matcher_rating_margin, 0.1, "New template margin (0-1)", this->params())
    , double_MEMBER(matcher_avg_noise_size, 12.0, "Avg. noise blob length", this->params())
    , INT_MEMBER(matcher_permanent_classes_min, 1, "Min # of permanent classes", this->params())
    , INT_MEMBER(matcher_min_examples_for_prototyping, 3, "Reliable Config Threshold",
                 this->params())
    , INT_MEMBER(matcher_sufficient_examples_for_prototyping, 5,
                 "Enable adaption even if the ambiguities have not been seen", this->params())
    , double_MEMBER(matcher_clustering_max_angle_delta, 0.015,
                    "Maximum angle delta for prototype clustering", this->params())
    , double_MEMBER(classify_misfit_junk_penalty, 0.0,
                    "Penalty to apply when a non-alnum is vertically out of "
                    "its expected textline position",
                    this->params())
    , double_MEMBER(rating_scale, 1.5, "Rating scaling factor", this->params())
    , double_MEMBER(tessedit_class_miss_scale, 0.00390625, "Scale factor for features not used",
                    this->params())
    , double_MEMBER(classify_adapted_pruning_factor, 2.5,
                    "Prune poor adapted results this much worse than best result", this->params())
    , double_MEMBER(classify_adapted_pruning_threshold, -1.0,
                    "Threshold at which classify_adapted_pruning_factor starts", this->params())
    , INT_MEMBER(classify_adapt_proto_threshold, 230,
                 "Threshold for good protos during adaptive 0-255", this->params())
    , INT_MEMBER(classify_adapt_feature_threshold, 230,
                 "Threshold for good features during adaptive 0-255", this->params())
    , BOOL_MEMBER(disable_character_fragments, true,
                  "Do not include character fragments in the"
                  " results of the classifier",
                  this->params())
    , double_MEMBER(classify_character_fragments_garbage_certainty_threshold, -3.0,
                    "Exclude fragments that do not look like whole"
                    " characters from training and adaption",
                    this->params())
    , BOOL_MEMBER(classify_debug_character_fragments, false,
                  "Bring up graphical debugging windows for fragments training", this->params())
    , BOOL_MEMBER(matcher_debug_separate_windows, false,
                  "Use two different windows for debugging the matching: "
                  "One for the protos and one for the features.",
                  this->params())
    , STRING_MEMBER(classify_learn_debug_str, "", "Class str to debug learning", this->params())
    , INT_MEMBER(classify_class_pruner_threshold, 229, "Class Pruner Threshold 0-255",
                 this->params())
    , INT_MEMBER(classify_class_pruner_multiplier, 15,
                 "Class Pruner Multiplier 0-255:       ", this->params())
    , INT_MEMBER(classify_cp_cutoff_strength, 7,
                 "Class Pruner CutoffStrength:         ", this->params())
    , INT_MEMBER(classify_integer_matcher_multiplier, 10,
                 "Integer Matcher Multiplier  0-255:   ", this->params())
    , BOOL_MEMBER(classify_bln_numeric_mode, 0, "Assume the input is numbers [0-9].",
                  this->params())
    , double_MEMBER(speckle_large_max_size, 0.30, "Max large speckle size", this->params())
    , double_MEMBER(speckle_rating_penalty, 10.0, "Penalty to add to worst rating for noise",
                    this->params())
    , im_(&classify_debug_level)
    , dict_(this) {
  using namespace std::placeholders; // for _1, _2
  fontinfo_table_.set_clear_callback(std::bind(FontInfoDeleteCallback, _1));
 
  InitFeatureDefs(&feature_defs_);
}

~Classify()

tesseract::Classify::~Classify ( )

override

Definition at line 150 of file classify.cpp.

                    {
  EndAdaptiveClassifier();
#ifndef GRAPHICS_DISABLED
  delete learn_debug_win_;
  delete learn_fragmented_word_debug_win_;
  delete learn_fragments_debug_win_;
#endif
}

Member Function Documentation

AdaptableWord()

bool tesseract::Classify::AdaptableWord

(

WERD_RES *

word

)

Return true if the specified word is acceptable for adaptation.

Globals: none

Parameters

word	current word

Returns

true or false

Definition at line 811 of file adaptmatch.cpp.

                                           {
  if (word->best_choice == nullptr) {
    return false;
  }
  auto BestChoiceLength = word->best_choice->length();
  float adaptable_score = getDict().segment_penalty_dict_case_ok + ADAPTABLE_WERD_ADJUSTMENT;
  return // rules that apply in general - simplest to compute first
      BestChoiceLength > 0 && BestChoiceLength == word->rebuild_word->NumBlobs() &&
      BestChoiceLength <= MAX_ADAPTABLE_WERD_SIZE &&
      // This basically ensures that the word is at least a dictionary match
      // (freq word, user word, system dawg word, etc).
      // Since all the other adjustments will make adjust factor higher
      // than higher than adaptable_score=1.1+0.05=1.15
      // Since these are other flags that ensure that the word is dict word,
      // this check could be at times redundant.
      word->best_choice->adjust_factor() <= adaptable_score &&
      // Make sure that alternative choices are not dictionary words.
      word->AlternativeChoiceAdjustmentsWorseThan(adaptable_score);
}

AdaptiveClassifier()

void tesseract::Classify::AdaptiveClassifier	(	TBLOB *	Blob,
		BLOB_CHOICE_LIST *	Choices
	)

This routine calls the adaptive matcher which returns (in an array) the class id of each class matched.

It also returns the number of classes matched. For each class matched it places the best rating found for that class into the Ratings array.

Bad matches are then removed so that they don't need to be sorted. The remaining good matches are then sorted and converted to choices.

This routine also performs some simple speckle filtering.

Parameters

	Blob	blob to be classified
[out]	Choices	List of choices found by adaptive matcher. filled on return with the choices found by the class pruner and the ratings there from. Also contains the detailed results of the integer matcher.

Definition at line 202 of file adaptmatch.cpp.

                                                                        {
  assert(Choices != nullptr);
  auto *Results = new ADAPT_RESULTS;
  Results->Initialize();
 
  ASSERT_HOST(AdaptedTemplates != nullptr);
 
  DoAdaptiveMatch(Blob, Results);
 
  RemoveBadMatches(Results);
  std::sort(Results->match.begin(), Results->match.end(), SortDescendingRating);
  RemoveExtraPuncs(Results);
  Results->ComputeBest();
  ConvertMatchesToChoices(Blob->denorm(), Blob->bounding_box(), Results, Choices);
 
  // TODO(rays) Move to before ConvertMatchesToChoices!
  if (LargeSpeckle(*Blob) || Choices->empty()) {
    AddLargeSpeckleTo(Results->BlobLength, Choices);
  }
 
  if (matcher_debug_level >= 1) {
    tprintf("AD Matches =  ");
    PrintAdaptiveMatchResults(*Results);
  }
 
#ifndef GRAPHICS_DISABLED
  if (classify_enable_adaptive_debugger) {
    DebugAdaptiveClassifier(Blob, Results);
  }
#endif
 
  delete Results;
} /* AdaptiveClassifier */

AdaptiveClassifierIsEmpty()

bool tesseract::Classify::AdaptiveClassifierIsEmpty ( ) const

inline

Definition at line 268 of file classify.h.

                                         {
    return AdaptedTemplates->NumPermClasses == 0;
  }

AdaptiveClassifierIsFull()

bool tesseract::Classify::AdaptiveClassifierIsFull ( ) const

inline

Definition at line 265 of file classify.h.

                                        {
    return NumAdaptationsFailed > 0;
  }

AdaptToChar()

void tesseract::Classify::AdaptToChar	(	TBLOB *	Blob,
		CLASS_ID	ClassId,
		int	FontinfoId,
		float	Threshold,
		ADAPT_TEMPLATES_STRUCT *	adaptive_templates
	)

Parameters

Blob	blob to add to templates for ClassId
ClassId	class to add blob to
FontinfoId	font information from pre-trained templates
Threshold	minimum match rating to existing template
adaptive_templates	current set of adapted templates

Globals:

• AllProtosOn dummy mask to match against all protos
• AllConfigsOn dummy mask to match against all configs

Definition at line 843 of file adaptmatch.cpp.

                                                                       {
  int NumFeatures;
  INT_FEATURE_ARRAY IntFeatures;
  UnicharRating int_result;
  INT_CLASS_STRUCT *IClass;
  ADAPT_CLASS_STRUCT *Class;
  TEMP_CONFIG_STRUCT *TempConfig;
  FEATURE_SET FloatFeatures;
  int NewTempConfigId;
 
  if (!LegalClassId(ClassId)) {
    return;
  }
 
  int_result.unichar_id = ClassId;
  Class = adaptive_templates->Class[ClassId];
  assert(Class != nullptr);
  if (IsEmptyAdaptedClass(Class)) {
    InitAdaptedClass(Blob, ClassId, FontinfoId, Class, adaptive_templates);
  } else {
    IClass = ClassForClassId(adaptive_templates->Templates, ClassId);
 
    NumFeatures = GetAdaptiveFeatures(Blob, IntFeatures, &FloatFeatures);
    if (NumFeatures <= 0) {
      return; // Features already freed by GetAdaptiveFeatures.
    }
 
    // Only match configs with the matching font.
    BIT_VECTOR MatchingFontConfigs = NewBitVector(MAX_NUM_PROTOS);
    for (int cfg = 0; cfg < IClass->NumConfigs; ++cfg) {
      if (GetFontinfoId(Class, cfg) == FontinfoId) {
        SET_BIT(MatchingFontConfigs, cfg);
      } else {
        reset_bit(MatchingFontConfigs, cfg);
      }
    }
    im_.Match(IClass, AllProtosOn, MatchingFontConfigs, NumFeatures, IntFeatures, &int_result,
              classify_adapt_feature_threshold, NO_DEBUG, matcher_debug_separate_windows);
    FreeBitVector(MatchingFontConfigs);
 
    SetAdaptiveThreshold(Threshold);
 
    if (1.0f - int_result.rating <= Threshold) {
      if (ConfigIsPermanent(Class, int_result.config)) {
        if (classify_learning_debug_level >= 1) {
          tprintf("Found good match to perm config %d = %4.1f%%.\n", int_result.config,
                  int_result.rating * 100.0);
        }
        delete FloatFeatures;
        return;
      }
 
      TempConfig = TempConfigFor(Class, int_result.config);
      IncreaseConfidence(TempConfig);
      if (TempConfig->NumTimesSeen > Class->MaxNumTimesSeen) {
        Class->MaxNumTimesSeen = TempConfig->NumTimesSeen;
      }
      if (classify_learning_debug_level >= 1) {
        tprintf("Increasing reliability of temp config %d to %d.\n", int_result.config,
                TempConfig->NumTimesSeen);
      }
 
      if (TempConfigReliable(ClassId, TempConfig)) {
        MakePermanent(adaptive_templates, ClassId, int_result.config, Blob);
        UpdateAmbigsGroup(ClassId, Blob);
      }
    } else {
      if (classify_learning_debug_level >= 1) {
        tprintf("Found poor match to temp config %d = %4.1f%%.\n", int_result.config,
                int_result.rating * 100.0);
#ifndef GRAPHICS_DISABLED
        if (classify_learning_debug_level > 2) {
          DisplayAdaptedChar(Blob, IClass);
        }
#endif
      }
      NewTempConfigId = MakeNewTemporaryConfig(adaptive_templates, ClassId, FontinfoId, NumFeatures,
                                               IntFeatures, FloatFeatures);
      if (NewTempConfigId >= 0 &&
          TempConfigReliable(ClassId, TempConfigFor(Class, NewTempConfigId))) {
        MakePermanent(adaptive_templates, ClassId, NewTempConfigId, Blob);
        UpdateAmbigsGroup(ClassId, Blob);
      }
 
#ifndef GRAPHICS_DISABLED
      if (classify_learning_debug_level > 1) {
        DisplayAdaptedChar(Blob, IClass);
      }
#endif
    }
    delete FloatFeatures;
  }
} /* AdaptToChar */

AddLargeSpeckleTo()

void tesseract::Classify::AddLargeSpeckleTo	(	int	blob_length,
		BLOB_CHOICE_LIST *	choices
	)

Definition at line 169 of file classify.cpp.

                                                                           {
  BLOB_CHOICE_IT bc_it(choices);
  // If there is no classifier result, we will use the worst possible certainty
  // and corresponding rating.
  float certainty = -getDict().certainty_scale;
  float rating = rating_scale * blob_length;
  if (!choices->empty() && blob_length > 0) {
    bc_it.move_to_last();
    BLOB_CHOICE *worst_choice = bc_it.data();
    // Add speckle_rating_penalty to worst rating, matching old value.
    rating = worst_choice->rating() + speckle_rating_penalty;
    // Compute the rating to correspond to the certainty. (Used to be kept
    // the same, but that messes up the language model search.)
    certainty = -rating * getDict().certainty_scale / (rating_scale * blob_length);
  }
  auto *blob_choice = new BLOB_CHOICE(UNICHAR_SPACE, rating, certainty, -1, 0.0f, FLT_MAX, 0,
                                      BCC_SPECKLE_CLASSIFIER);
  bc_it.add_to_end(blob_choice);
}

AddNewResult()

void tesseract::Classify::AddNewResult	(	const UnicharRating &	new_result,
		ADAPT_RESULTS *	results
	)

This routine adds the result of a classification into Results. If the new rating is much worse than the current best rating, it is not entered into results because it would end up being stripped later anyway. If the new rating is better than the old rating for the class, it replaces the old rating. If this is the first rating for the class, the class is added to the list of matched classes in Results. If the new rating is better than the best so far, it becomes the best so far.

Globals:

• #matcher_bad_match_pad defines limits of an acceptable match

Parameters

	new_result	new result to add
[out]	results	results to add new result to

Definition at line 986 of file adaptmatch.cpp.

                                                                                   {
  auto old_match = FindScoredUnichar(new_result.unichar_id, *results);
 
  if (new_result.rating + matcher_bad_match_pad < results->best_rating ||
      (old_match < results->match.size() &&
       new_result.rating <= results->match[old_match].rating)) {
    return; // New one not good enough.
  }
 
  if (!unicharset.get_fragment(new_result.unichar_id)) {
    results->HasNonfragment = true;
  }
 
  if (old_match < results->match.size()) {
    results->match[old_match].rating = new_result.rating;
  } else {
    results->match.push_back(new_result);
  }
 
  if (new_result.rating > results->best_rating &&
      // Ensure that fragments do not affect best rating, class and config.
      // This is needed so that at least one non-fragmented character is
      // always present in the results.
      // TODO(daria): verify that this helps accuracy and does not
      // hurt performance.
      !unicharset.get_fragment(new_result.unichar_id)) {
    results->best_match_index = old_match;
    results->best_rating = new_result.rating;
    results->best_unichar_id = new_result.unichar_id;
  }
} /* AddNewResult */

AmbigClassifier()

void tesseract::Classify::AmbigClassifier	(	const std::vector< INT_FEATURE_STRUCT > &	int_features,
		const INT_FX_RESULT_STRUCT &	fx_info,
		const TBLOB *	blob,
		INT_TEMPLATES_STRUCT *	templates,
		ADAPT_CLASS_STRUCT **	classes,
		UNICHAR_ID *	ambiguities,
		ADAPT_RESULTS *	results
	)

This routine is identical to CharNormClassifier() except that it does no class pruning. It simply matches the unknown blob against the classes listed in Ambiguities.

Globals:

• AllProtosOn mask that enables all protos
• AllConfigsOn mask that enables all configs

Parameters

	blob	blob to be classified
	templates	built-in templates to classify against
	classes	adapted class templates
	ambiguities	array of unichar id's to match against
[out]	results	place to put match results
	int_features
	fx_info

Definition at line 1037 of file adaptmatch.cpp.

                                                                                {
  if (int_features.empty()) {
    return;
  }
  auto *CharNormArray = new uint8_t[unicharset.size()];
  UnicharRating int_result;
 
  results->BlobLength = GetCharNormFeature(fx_info, templates, nullptr, CharNormArray);
  bool debug = matcher_debug_level >= 2 || classify_debug_level > 1;
  if (debug) {
    tprintf("AM Matches =  ");
  }
 
  int top = blob->bounding_box().top();
  int bottom = blob->bounding_box().bottom();
  while (*ambiguities >= 0) {
    CLASS_ID class_id = *ambiguities;
 
    int_result.unichar_id = class_id;
    im_.Match(ClassForClassId(templates, class_id), AllProtosOn, AllConfigsOn, int_features.size(),
              &int_features[0], &int_result, classify_adapt_feature_threshold, NO_DEBUG,
              matcher_debug_separate_windows);
 
    ExpandShapesAndApplyCorrections(nullptr, debug, class_id, bottom, top, 0, results->BlobLength,
                                    classify_integer_matcher_multiplier, CharNormArray, &int_result,
                                    results);
    ambiguities++;
  }
  delete[] CharNormArray;
} /* AmbigClassifier */

BaselineClassifier()

UNICHAR_ID * tesseract::Classify::BaselineClassifier	(	TBLOB *	Blob,
		const std::vector< INT_FEATURE_STRUCT > &	int_features,
		const INT_FX_RESULT_STRUCT &	fx_info,
		ADAPT_TEMPLATES_STRUCT *	Templates,
		ADAPT_RESULTS *	Results
	)

This routine extracts baseline normalized features from the unknown character and matches them against the specified set of templates. The classes which match are added to Results.

Globals:

• BaselineCutoffs expected num features for each class

Parameters

Blob	blob to be classified
Templates	current set of adapted templates
Results	place to put match results
int_features
fx_info

Returns

Array of possible ambiguous chars that should be checked.

Definition at line 1224 of file adaptmatch.cpp.

                                                                                                    {
  if (int_features.empty()) {
    return nullptr;
  }
  auto *CharNormArray = new uint8_t[unicharset.size()];
  ClearCharNormArray(CharNormArray);
 
  Results->BlobLength = IntCastRounded(fx_info.Length / kStandardFeatureLength);
  PruneClasses(Templates->Templates, int_features.size(), -1, &int_features[0], CharNormArray,
               BaselineCutoffs, &Results->CPResults);
 
  if (matcher_debug_level >= 2 || classify_debug_level > 1) {
    tprintf("BL Matches =  ");
  }
 
  MasterMatcher(Templates->Templates, int_features.size(), &int_features[0], CharNormArray,
                Templates->Class, matcher_debug_flags, 0, Blob->bounding_box(), Results->CPResults,
                Results);
 
  delete[] CharNormArray;
  CLASS_ID ClassId = Results->best_unichar_id;
  if (ClassId == INVALID_UNICHAR_ID || Results->best_match_index < 0) {
    return nullptr;
  }
 
  return Templates->Class[ClassId]
      ->Config[Results->match[Results->best_match_index].config]
      .Perm->Ambigs;
} /* BaselineClassifier */

BOOL_VAR_H() [1/14]

tesseract::Classify::BOOL_VAR_H

(

allow_blob_division

)

BOOL_VAR_H() [2/14]

tesseract::Classify::BOOL_VAR_H

(

classify_bln_numeric_mode

)

BOOL_VAR_H() [3/14]

tesseract::Classify::BOOL_VAR_H

(

classify_debug_character_fragments

)

BOOL_VAR_H() [4/14]

tesseract::Classify::BOOL_VAR_H

(

classify_enable_adaptive_debugger

)

BOOL_VAR_H() [5/14]

tesseract::Classify::BOOL_VAR_H

(

classify_enable_adaptive_matcher

)

BOOL_VAR_H() [6/14]

tesseract::Classify::BOOL_VAR_H

(

classify_enable_learning

)

BOOL_VAR_H() [7/14]

tesseract::Classify::BOOL_VAR_H

(

classify_nonlinear_norm

)

BOOL_VAR_H() [8/14]

tesseract::Classify::BOOL_VAR_H

(

classify_save_adapted_templates

)

BOOL_VAR_H() [9/14]

tesseract::Classify::BOOL_VAR_H

(

classify_use_pre_adapted_templates

)

BOOL_VAR_H() [10/14]

tesseract::Classify::BOOL_VAR_H

(

disable_character_fragments

)

BOOL_VAR_H() [11/14]

tesseract::Classify::BOOL_VAR_H

(

matcher_debug_separate_windows

)

BOOL_VAR_H() [12/14]

tesseract::Classify::BOOL_VAR_H

(

prioritize_division

)

BOOL_VAR_H() [13/14]

tesseract::Classify::BOOL_VAR_H

(

tess_bn_matching

)

BOOL_VAR_H() [14/14]

tesseract::Classify::BOOL_VAR_H

(

tess_cn_matching

)

CharNormClassifier()

int tesseract::Classify::CharNormClassifier	(	TBLOB *	blob,
		const TrainingSample &	sample,
		ADAPT_RESULTS *	adapt_results
	)

This routine extracts character normalized features from the unknown character and matches them against the specified set of templates. The classes which match are added to Results.

Parameters

blob	blob to be classified
sample	templates to classify unknown against
adapt_results	place to put match results

Globals:

• CharNormCutoffs expected num features for each class
• AllProtosOn mask that enables all protos
• AllConfigsOn mask that enables all configs

Definition at line 1273 of file adaptmatch.cpp.

                                                               {
  // This is the length that is used for scaling ratings vs certainty.
  adapt_results->BlobLength = IntCastRounded(sample.outline_length() / kStandardFeatureLength);
  std::vector<UnicharRating> unichar_results;
  static_classifier_->UnicharClassifySample(sample, blob->denorm().pix(), 0, -1, &unichar_results);
  // Convert results to the format used internally by AdaptiveClassifier.
  for (auto &r : unichar_results) {
    AddNewResult(r, adapt_results);
  }
  return sample.num_features();
} /* CharNormClassifier */

CharNormTrainingSample()

int tesseract::Classify::CharNormTrainingSample	(	bool	pruner_only,
		int	keep_this,
		const TrainingSample &	sample,
		std::vector< UnicharRating > *	results
	)

Definition at line 1288 of file adaptmatch.cpp.

                                                                        {
  results->clear();
  std::unique_ptr<ADAPT_RESULTS> adapt_results(new ADAPT_RESULTS());
  adapt_results->Initialize();
  // Compute the bounding box of the features.
  uint32_t num_features = sample.num_features();
  // Only the top and bottom of the blob_box are used by MasterMatcher, so
  // fabricate right and left using top and bottom.
  TBOX blob_box(sample.geo_feature(GeoBottom), sample.geo_feature(GeoBottom),
                sample.geo_feature(GeoTop), sample.geo_feature(GeoTop));
  // Compute the char_norm_array from the saved cn_feature.
  FEATURE norm_feature = sample.GetCNFeature();
  std::vector<uint8_t> char_norm_array(unicharset.size());
  auto num_pruner_classes = std::max(static_cast<unsigned>(unicharset.size()), PreTrainedTemplates->NumClasses);
  std::vector<uint8_t> pruner_norm_array(num_pruner_classes);
  adapt_results->BlobLength = static_cast<int>(ActualOutlineLength(norm_feature) * 20 + 0.5f);
  ComputeCharNormArrays(norm_feature, PreTrainedTemplates, &char_norm_array[0], &pruner_norm_array[0]);
 
  PruneClasses(PreTrainedTemplates, num_features, keep_this, sample.features(), &pruner_norm_array[0],
               shape_table_ != nullptr ? &shapetable_cutoffs_[0] : CharNormCutoffs,
               &adapt_results->CPResults);
  if (keep_this >= 0) {
    adapt_results->CPResults[0].Class = keep_this;
    adapt_results->CPResults.resize(1);
  }
  if (pruner_only) {
    // Convert pruner results to output format.
    for (auto &it : adapt_results->CPResults) {
      int class_id = it.Class;
      results->push_back(UnicharRating(class_id, 1.0f - it.Rating));
    }
  } else {
    MasterMatcher(PreTrainedTemplates, num_features, sample.features(), &char_norm_array[0], nullptr,
                  matcher_debug_flags, classify_integer_matcher_multiplier, blob_box,
                  adapt_results->CPResults, adapt_results.get());
    // Convert master matcher results to output format.
    for (auto &i : adapt_results->match) {
      results->push_back(i);
    }
    if (results->size() > 1) {
      std::sort(results->begin(), results->end(), SortDescendingRating);
    }
  }
  return num_features;
} /* CharNormTrainingSample */

ClassAndConfigIDToFontOrShapeID()

int tesseract::Classify::ClassAndConfigIDToFontOrShapeID	(	int	class_id,
		int	int_result_config
	)		const

Definition at line 2109 of file adaptmatch.cpp.

                                                                                       {
  int font_set_id = PreTrainedTemplates->Class[class_id]->font_set_id;
  // Older inttemps have no font_ids.
  if (font_set_id < 0) {
    return kBlankFontinfoId;
  }
  const FontSet &fs = fontset_table_.at(font_set_id);
  return fs.at(int_result_config);
}

ClassIDToDebugStr()

std::string tesseract::Classify::ClassIDToDebugStr	(	const INT_TEMPLATES_STRUCT *	templates,
		int	class_id,
		int	config_id
	)		const

Definition at line 2096 of file adaptmatch.cpp.

                                                             {
  std::string class_string;
  if (templates == PreTrainedTemplates && shape_table_ != nullptr) {
    int shape_id = ClassAndConfigIDToFontOrShapeID(class_id, config_id);
    class_string = shape_table_->DebugStr(shape_id);
  } else {
    class_string = unicharset.debug_str(class_id);
  }
  return class_string;
}

ClassifyAsNoise()

void tesseract::Classify::ClassifyAsNoise

(

ADAPT_RESULTS *

results

)

This routine computes a rating which reflects the likelihood that the blob being classified is a noise blob. NOTE: assumes that the blob length has already been computed and placed into Results.

Parameters

results

results to add noise classification to

Globals:

• matcher_avg_noise_size avg. length of a noise blob

Definition at line 1347 of file adaptmatch.cpp.

                                                     {
  float rating = results->BlobLength / matcher_avg_noise_size;
  rating *= rating;
  rating /= 1 + rating;
 
  AddNewResult(UnicharRating(UNICHAR_SPACE, 1.0f - rating), results);
} /* ClassifyAsNoise */

ClearCharNormArray()

void tesseract::Classify::ClearCharNormArray

(

uint8_t *

char_norm_array

)

For each class in the unicharset, clears the corresponding entry in char_norm_array. char_norm_array is indexed by unichar_id.

Globals:

• none

Parameters

char_norm_array

array to be cleared

Definition at line 41 of file float2int.cpp.

                                                          {
  memset(char_norm_array, 0, sizeof(*char_norm_array) * unicharset.size());
} /* ClearCharNormArray */

ComputeCharNormArrays()

void tesseract::Classify::ComputeCharNormArrays	(	FEATURE_STRUCT *	norm_feature,
		INT_TEMPLATES_STRUCT *	templates,
		uint8_t *	char_norm_array,
		uint8_t *	pruner_array
	)

Definition at line 1629 of file adaptmatch.cpp.

                                                                                      {
  ComputeIntCharNormArray(*norm_feature, char_norm_array);
  //if (pruner_array != nullptr) {
    if (shape_table_ == nullptr) {
      ComputeIntCharNormArray(*norm_feature, pruner_array);
    } else {
      memset(&pruner_array[0], UINT8_MAX, templates->NumClasses * sizeof(pruner_array[0]));
      // Each entry in the pruner norm array is the MIN of all the entries of
      // the corresponding unichars in the CharNormArray.
      for (unsigned id = 0; id < templates->NumClasses; ++id) {
        int font_set_id = templates->Class[id]->font_set_id;
        const FontSet &fs = fontset_table_.at(font_set_id);
        for (auto f : fs) {
          const Shape &shape = shape_table_->GetShape(f);
          for (int c = 0; c < shape.size(); ++c) {
            if (char_norm_array[shape[c].unichar_id] < pruner_array[id]) {
              pruner_array[id] = char_norm_array[shape[c].unichar_id];
            }
          }
        }
      }
    }
  //}
  delete norm_feature;
}

ComputeCorrectedRating()

double tesseract::Classify::ComputeCorrectedRating	(	bool	debug,
		int	unichar_id,
		double	cp_rating,
		double	im_rating,
		int	feature_misses,
		int	bottom,
		int	top,
		int	blob_length,
		int	matcher_multiplier,
		const uint8_t *	cn_factors
	)

Definition at line 1171 of file adaptmatch.cpp.

                                                                   {
  // Compute class feature corrections.
  double cn_corrected = im_.ApplyCNCorrection(1.0 - im_rating, blob_length, cn_factors[unichar_id],
                                              matcher_multiplier);
  double miss_penalty = tessedit_class_miss_scale * feature_misses;
  double vertical_penalty = 0.0;
  // Penalize non-alnums for being vertical misfits.
  if (!unicharset.get_isalpha(unichar_id) && !unicharset.get_isdigit(unichar_id) &&
      cn_factors[unichar_id] != 0 && classify_misfit_junk_penalty > 0.0) {
    int min_bottom, max_bottom, min_top, max_top;
    unicharset.get_top_bottom(unichar_id, &min_bottom, &max_bottom, &min_top, &max_top);
    if (debug) {
      tprintf("top=%d, vs [%d, %d], bottom=%d, vs [%d, %d]\n", top, min_top, max_top, bottom,
              min_bottom, max_bottom);
    }
    if (top < min_top || top > max_top || bottom < min_bottom || bottom > max_bottom) {
      vertical_penalty = classify_misfit_junk_penalty;
    }
  }
  double result = 1.0 - (cn_corrected + miss_penalty + vertical_penalty);
  if (result < WORST_POSSIBLE_RATING) {
    result = WORST_POSSIBLE_RATING;
  }
  if (debug) {
    tprintf("%s: %2.1f%%(CP%2.1f, IM%2.1f + CN%.2f(%d) + MP%2.1f + VP%2.1f)\n",
            unicharset.id_to_unichar(unichar_id), result * 100.0, cp_rating * 100.0,
            (1.0 - im_rating) * 100.0, (cn_corrected - (1.0 - im_rating)) * 100.0,
            cn_factors[unichar_id], miss_penalty * 100.0, vertical_penalty * 100.0);
  }
  return result;
}

ComputeIntCharNormArray()

void tesseract::Classify::ComputeIntCharNormArray	(	const FEATURE_STRUCT &	norm_feature,
		uint8_t *	char_norm_array
	)

For each class in unicharset, computes the match between norm_feature and the normalization protos for that class. Converts this number to the range from 0 - 255 and stores it into char_norm_array. CharNormArray is indexed by unichar_id.

Globals:

• PreTrainedTemplates current set of built-in templates

Parameters

	norm_feature	character normalization feature
[out]	char_norm_array	place to put results of size unicharset.size()

Definition at line 58 of file float2int.cpp.

                                                                 {
  for (unsigned i = 0; i < unicharset.size(); i++) {
    if (i < PreTrainedTemplates->NumClasses) {
      int norm_adjust =
          static_cast<int>(INT_CHAR_NORM_RANGE * ComputeNormMatch(i, norm_feature, false));
      char_norm_array[i] = ClipToRange(norm_adjust, 0, MAX_INT_CHAR_NORM);
    } else {
      // Classes with no templates (eg. ambigs & ligatures) default
      // to worst match.
      char_norm_array[i] = MAX_INT_CHAR_NORM;
    }
  }
} /* ComputeIntCharNormArray */

ComputeIntFeatures()

void tesseract::Classify::ComputeIntFeatures	(	FEATURE_SET	Features,
		INT_FEATURE_ARRAY	IntFeatures
	)

This routine converts each floating point pico-feature in Features into integer format and saves it into IntFeatures.

Globals:

• none

Parameters

	Features	floating point pico-features to be converted
[out]	IntFeatures	array to put converted features into

Definition at line 85 of file float2int.cpp.

                                                                                     {
  float YShift;
 
  if (classify_norm_method == baseline) {
    YShift = BASELINE_Y_SHIFT;
  } else {
    YShift = Y_SHIFT;
  }
 
  for (int Fid = 0; Fid < Features->NumFeatures; Fid++) {
    FEATURE Feature = Features->Features[Fid];
 
    IntFeatures[Fid].X = Bucket8For(Feature->Params[PicoFeatX], X_SHIFT, INT_FEAT_RANGE);
    IntFeatures[Fid].Y = Bucket8For(Feature->Params[PicoFeatY], YShift, INT_FEAT_RANGE);
    IntFeatures[Fid].Theta =
        CircBucketFor(Feature->Params[PicoFeatDir], ANGLE_SHIFT, INT_FEAT_RANGE);
    IntFeatures[Fid].CP_misses = 0;
  }
} /* ComputeIntFeatures */

ComputeNormMatch()

float tesseract::Classify::ComputeNormMatch	(	CLASS_ID	ClassId,
		const FEATURE_STRUCT &	feature,
		bool	DebugMatch
	)

This routine compares Features against each character normalization proto for ClassId and returns the match rating of the best match.

Parameters

ClassId	id of class to match against
feature	character normalization feature
DebugMatch	controls dump of debug info

Globals: NormProtos character normalization prototypes

Returns

Best match rating for Feature against protos of ClassId.

Definition at line 94 of file normmatch.cpp.

                                                                                                 {
  if (ClassId >= NormProtos->NumProtos) {
    ClassId = NO_CLASS;
  }
 
  /* handle requests for classification as noise */
  if (ClassId == NO_CLASS) {
    /* kludge - clean up constants and make into control knobs later */
    float Match = (feature.Params[CharNormLength] * feature.Params[CharNormLength] * 500.0f +
                   feature.Params[CharNormRx] * feature.Params[CharNormRx] * 8000.0f +
                   feature.Params[CharNormRy] * feature.Params[CharNormRy] * 8000.0f);
    return (1.0f - NormEvidenceOf(Match));
  }
 
  float BestMatch = FLT_MAX;
  LIST Protos = NormProtos->Protos[ClassId];
 
  if (DebugMatch) {
    tprintf("\nChar norm for class %s\n", unicharset.id_to_unichar(ClassId));
  }
 
  int ProtoId = 0;
  iterate(Protos) {
    auto Proto = reinterpret_cast<PROTOTYPE *>(Protos->first_node());
    float Delta = feature.Params[CharNormY] - Proto->Mean[CharNormY];
    float Match = Delta * Delta * Proto->Weight.Elliptical[CharNormY];
    if (DebugMatch) {
      tprintf("YMiddle: Proto=%g, Delta=%g, Var=%g, Dist=%g\n", Proto->Mean[CharNormY], Delta,
              Proto->Weight.Elliptical[CharNormY], Match);
    }
    Delta = feature.Params[CharNormRx] - Proto->Mean[CharNormRx];
    Match += Delta * Delta * Proto->Weight.Elliptical[CharNormRx];
    if (DebugMatch) {
      tprintf("Height: Proto=%g, Delta=%g, Var=%g, Dist=%g\n", Proto->Mean[CharNormRx], Delta,
              Proto->Weight.Elliptical[CharNormRx], Match);
    }
    // Ry is width! See intfx.cpp.
    Delta = feature.Params[CharNormRy] - Proto->Mean[CharNormRy];
    if (DebugMatch) {
      tprintf("Width: Proto=%g, Delta=%g, Var=%g\n", Proto->Mean[CharNormRy], Delta,
              Proto->Weight.Elliptical[CharNormRy]);
    }
    Delta = Delta * Delta * Proto->Weight.Elliptical[CharNormRy];
    Delta *= kWidthErrorWeighting;
    Match += Delta;
    if (DebugMatch) {
      tprintf("Total Dist=%g, scaled=%g, sigmoid=%g, penalty=%g\n", Match,
              Match / classify_norm_adj_midpoint, NormEvidenceOf(Match),
              256 * (1 - NormEvidenceOf(Match)));
    }
 
    if (Match < BestMatch) {
      BestMatch = Match;
    }
 
    ProtoId++;
  }
  return 1.0 - NormEvidenceOf(BestMatch);
} /* ComputeNormMatch */

ConvertMatchesToChoices()

void tesseract::Classify::ConvertMatchesToChoices	(	const DENORM &	denorm,
		const TBOX &	box,
		ADAPT_RESULTS *	Results,
		BLOB_CHOICE_LIST *	Choices
	)

The function converts the given match ratings to the list of blob choices with ratings and certainties (used by the context checkers). If character fragments are present in the results, this function also makes sure that there is at least one non-fragmented classification included. For each classification result check the unicharset for "definite" ambiguities and modify the resulting Choices accordingly.

Definition at line 1361 of file adaptmatch.cpp.

                                                                                          {
  assert(Choices != nullptr);
  float Rating;
  float Certainty;
  BLOB_CHOICE_IT temp_it;
  bool contains_nonfrag = false;
  temp_it.set_to_list(Choices);
  int choices_length = 0;
  // With no shape_table_ maintain the previous MAX_MATCHES as the maximum
  // number of returned results, but with a shape_table_ we want to have room
  // for at least the biggest shape (which might contain hundreds of Indic
  // grapheme fragments) and more, so use double the size of the biggest shape
  // if that is more than the default.
  int max_matches = MAX_MATCHES;
  if (shape_table_ != nullptr) {
    max_matches = shape_table_->MaxNumUnichars() * 2;
    if (max_matches < MAX_MATCHES) {
      max_matches = MAX_MATCHES;
    }
  }
 
  float best_certainty = -FLT_MAX;
  for (auto &it : Results->match) {
    const UnicharRating &result = it;
    bool adapted = result.adapted;
    bool current_is_frag = (unicharset.get_fragment(result.unichar_id) != nullptr);
    if (temp_it.length() + 1 == max_matches && !contains_nonfrag && current_is_frag) {
      continue; // look for a non-fragmented character to fill the
                // last spot in Choices if only fragments are present
    }
    // BlobLength can never be legally 0, this means recognition failed.
    // But we must return a classification result because some invoking
    // functions (chopper/permuter) do not anticipate a null blob choice.
    // So we need to assign a poor, but not infinitely bad score.
    if (Results->BlobLength == 0) {
      Certainty = -20;
      Rating = 100; // should be -certainty * real_blob_length
    } else {
      Rating = Certainty = (1.0f - result.rating);
      Rating *= rating_scale * Results->BlobLength;
      Certainty *= -(getDict().certainty_scale);
    }
    // Adapted results, by their very nature, should have good certainty.
    // Those that don't are at best misleading, and often lead to errors,
    // so don't accept adapted results that are too far behind the best result,
    // whether adapted or static.
    // TODO(rays) find some way of automatically tuning these constants.
    if (Certainty > best_certainty) {
      best_certainty = std::min(Certainty, static_cast<float>(classify_adapted_pruning_threshold));
    } else if (adapted && Certainty / classify_adapted_pruning_factor < best_certainty) {
      continue; // Don't accept bad adapted results.
    }
 
    float min_xheight, max_xheight, yshift;
    denorm.XHeightRange(result.unichar_id, unicharset, box, &min_xheight, &max_xheight, &yshift);
    auto *choice = new BLOB_CHOICE(
        result.unichar_id, Rating, Certainty, unicharset.get_script(result.unichar_id), min_xheight,
        max_xheight, yshift, adapted ? BCC_ADAPTED_CLASSIFIER : BCC_STATIC_CLASSIFIER);
    choice->set_fonts(result.fonts);
    temp_it.add_to_end(choice);
    contains_nonfrag |= !current_is_frag; // update contains_nonfrag
    choices_length++;
    if (choices_length >= max_matches) {
      break;
    }
  }
  Results->match.resize(choices_length);
} // ConvertMatchesToChoices

ConvertProto()

void tesseract::Classify::ConvertProto	(	PROTO_STRUCT *	Proto,
		int	ProtoId,
		INT_CLASS_STRUCT *	Class
	)

This routine converts Proto to integer format and installs it as ProtoId in Class.

Parameters

Proto	floating-pt proto to be converted to integer format
ProtoId	id of proto
Class	integer class to add converted proto to

Definition at line 452 of file intproto.cpp.

                                                                                     {
  assert(ProtoId < Class->NumProtos);
 
  INT_PROTO_STRUCT *P = ProtoForProtoId(Class, ProtoId);
 
  float Param = Proto->A * 128;
  P->A = TruncateParam(Param, -128, 127);
 
  Param = -Proto->B * 256;
  P->B = TruncateParam(Param, 0, 255);
 
  Param = Proto->C * 128;
  P->C = TruncateParam(Param, -128, 127);
 
  Param = Proto->Angle * 256;
  if (Param < 0 || Param >= 256) {
    P->Angle = 0;
  } else {
    P->Angle = static_cast<uint8_t>(Param);
  }
 
  /* round proto length to nearest integer number of pico-features */
  Param = (Proto->Length / GetPicoFeatureLength()) + 0.5;
  Class->ProtoLengths[ProtoId] = TruncateParam(Param, 1, 255);
  if (classify_learning_debug_level >= 2) {
    tprintf("Converted ffeat to (A=%d,B=%d,C=%d,L=%d)", P->A, P->B, P->C,
            Class->ProtoLengths[ProtoId]);
  }
} /* ConvertProto */

CreateIntTemplates()

INT_TEMPLATES_STRUCT * tesseract::Classify::CreateIntTemplates	(	CLASSES	FloatProtos,
		const UNICHARSET &	target_unicharset
	)

This routine converts from the old floating point format to the new integer format.

Parameters

FloatProtos	prototypes in old floating pt format
target_unicharset	the UNICHARSET to use

Returns

New set of training templates in integer format.

Note

Globals: none

Definition at line 490 of file intproto.cpp.

                                                                                {
  CLASS_TYPE FClass;
  INT_CLASS_STRUCT *IClass;
  int ProtoId;
  int ConfigId;
 
  auto IntTemplates = new INT_TEMPLATES_STRUCT;
 
  for (unsigned ClassId = 0; ClassId < target_unicharset.size(); ClassId++) {
    FClass = &(FloatProtos[ClassId]);
    if (FClass->NumProtos == 0 && FClass->NumConfigs == 0 &&
        strcmp(target_unicharset.id_to_unichar(ClassId), " ") != 0) {
      tprintf("Warning: no protos/configs for %s in CreateIntTemplates()\n",
              target_unicharset.id_to_unichar(ClassId));
    }
    assert(UnusedClassIdIn(IntTemplates, ClassId));
    IClass = new INT_CLASS_STRUCT(FClass->NumProtos, FClass->NumConfigs);
    unsigned fs_size = FClass->font_set.size();
    FontSet fs;
    fs.reserve(fs_size);
    for (unsigned i = 0; i < fs_size; ++i) {
      fs.push_back(FClass->font_set[i]);
    }
    IClass->font_set_id = this->fontset_table_.push_back(fs);
    AddIntClass(IntTemplates, ClassId, IClass);
 
    for (ProtoId = 0; ProtoId < FClass->NumProtos; ProtoId++) {
      AddIntProto(IClass);
      ConvertProto(ProtoIn(FClass, ProtoId), ProtoId, IClass);
      AddProtoToProtoPruner(ProtoIn(FClass, ProtoId), ProtoId, IClass,
                            classify_learning_debug_level >= 2);
      AddProtoToClassPruner(ProtoIn(FClass, ProtoId), ClassId, IntTemplates);
    }
 
    for (ConfigId = 0; ConfigId < FClass->NumConfigs; ConfigId++) {
      AddIntConfig(IClass);
      ConvertConfig(FClass->Configurations[ConfigId], ConfigId, IClass);
    }
  }
  return (IntTemplates);
} /* CreateIntTemplates */

DebugAdaptiveClassifier()

void tesseract::Classify::DebugAdaptiveClassifier	(	TBLOB *	blob,
		ADAPT_RESULTS *	Results
	)

Parameters

blob	blob whose classification is being debugged
Results	results of match being debugged

Globals: none

Definition at line 1440 of file adaptmatch.cpp.

                                                                          {
  if (static_classifier_ == nullptr) {
    return;
  }
  INT_FX_RESULT_STRUCT fx_info;
  std::vector<INT_FEATURE_STRUCT> bl_features;
  TrainingSample *sample = BlobToTrainingSample(*blob, false, &fx_info, &bl_features);
  if (sample == nullptr) {
    return;
  }
  static_classifier_->DebugDisplay(*sample, blob->denorm().pix(), Results->best_unichar_id);
} /* DebugAdaptiveClassifier */

DisplayAdaptedChar()

void tesseract::Classify::DisplayAdaptedChar	(	TBLOB *	blob,
		INT_CLASS_STRUCT *	int_class
	)

Definition at line 940 of file adaptmatch.cpp.

                                                                          {
  INT_FX_RESULT_STRUCT fx_info;
  std::vector<INT_FEATURE_STRUCT> bl_features;
  TrainingSample *sample =
      BlobToTrainingSample(*blob, classify_nonlinear_norm, &fx_info, &bl_features);
  if (sample == nullptr) {
    return;
  }
 
  UnicharRating int_result;
  im_.Match(int_class, AllProtosOn, AllConfigsOn, bl_features.size(), &bl_features[0], &int_result,
            classify_adapt_feature_threshold, NO_DEBUG, matcher_debug_separate_windows);
  tprintf("Best match to temp config %d = %4.1f%%.\n", int_result.config,
          int_result.rating * 100.0);
  if (classify_learning_debug_level >= 2) {
    uint32_t ConfigMask;
    ConfigMask = 1 << int_result.config;
    ShowMatchDisplay();
    im_.Match(int_class, AllProtosOn, static_cast<BIT_VECTOR>(&ConfigMask), bl_features.size(),
              &bl_features[0], &int_result, classify_adapt_feature_threshold, 6 | 0x19,
              matcher_debug_separate_windows);
    UpdateMatchDisplay();
  }
 
  delete sample;
}

DoAdaptiveMatch()

void tesseract::Classify::DoAdaptiveMatch	(	TBLOB *	Blob,
		ADAPT_RESULTS *	Results
	)

This routine performs an adaptive classification. If we have not yet adapted to enough classes, a simple classification to the pre-trained templates is performed. Otherwise, we match the blob against the adapted templates. If the adapted templates do not match well, we try a match against the pre-trained templates. If an adapted template match is found, we do a match to any pre-trained templates which could be ambiguous. The results from all of these classifications are merged together into Results.

Parameters

Blob	blob to be classified
Results	place to put match results

Globals:

• PreTrainedTemplates built-in training templates
• AdaptedTemplates templates adapted for this page
• matcher_reliable_adaptive_result rating limit for a great match

Definition at line 1474 of file adaptmatch.cpp.

                                                                  {
  UNICHAR_ID *Ambiguities;
 
  INT_FX_RESULT_STRUCT fx_info;
  std::vector<INT_FEATURE_STRUCT> bl_features;
  TrainingSample *sample =
      BlobToTrainingSample(*Blob, classify_nonlinear_norm, &fx_info, &bl_features);
  if (sample == nullptr) {
    return;
  }
 
  // TODO: With LSTM, static_classifier_ is nullptr.
  // Return to avoid crash in CharNormClassifier.
  if (static_classifier_ == nullptr) {
    delete sample;
    return;
  }
 
  if (AdaptedTemplates->NumPermClasses < matcher_permanent_classes_min || tess_cn_matching) {
    CharNormClassifier(Blob, *sample, Results);
  } else {
    Ambiguities = BaselineClassifier(Blob, bl_features, fx_info, AdaptedTemplates, Results);
    if ((!Results->match.empty() &&
         MarginalMatch(Results->best_rating, matcher_reliable_adaptive_result) &&
         !tess_bn_matching) ||
        Results->match.empty()) {
      CharNormClassifier(Blob, *sample, Results);
    } else if (Ambiguities && *Ambiguities >= 0 && !tess_bn_matching) {
      AmbigClassifier(bl_features, fx_info, Blob, PreTrainedTemplates, AdaptedTemplates->Class,
                      Ambiguities, Results);
    }
  }
 
  // Force the blob to be classified as noise
  // if the results contain only fragments.
  // TODO(daria): verify that this is better than
  // just adding a nullptr classification.
  if (!Results->HasNonfragment || Results->match.empty()) {
    ClassifyAsNoise(Results);
  }
  delete sample;
} /* DoAdaptiveMatch */

double_VAR_H() [1/18]

tesseract::Classify::double_VAR_H

(

classify_adapted_pruning_factor

)

double_VAR_H() [2/18]

tesseract::Classify::double_VAR_H

(

classify_adapted_pruning_threshold

)

double_VAR_H() [3/18]

tesseract::Classify::double_VAR_H

(

classify_char_norm_range

)

double_VAR_H() [4/18]

tesseract::Classify::double_VAR_H

(

classify_character_fragments_garbage_certainty_threshold

)

double_VAR_H() [5/18]

tesseract::Classify::double_VAR_H

(

classify_max_certainty_margin

)

double_VAR_H() [6/18]

tesseract::Classify::double_VAR_H

(

classify_max_rating_ratio

)

double_VAR_H() [7/18]

tesseract::Classify::double_VAR_H

(

classify_misfit_junk_penalty

)

double_VAR_H() [8/18]

tesseract::Classify::double_VAR_H

(

matcher_avg_noise_size

)

double_VAR_H() [9/18]

tesseract::Classify::double_VAR_H

(

matcher_bad_match_pad

)

double_VAR_H() [10/18]

tesseract::Classify::double_VAR_H

(

matcher_clustering_max_angle_delta

)

double_VAR_H() [11/18]

tesseract::Classify::double_VAR_H

(

matcher_good_threshold

)

double_VAR_H() [12/18]

tesseract::Classify::double_VAR_H

(

matcher_perfect_threshold

)

double_VAR_H() [13/18]

tesseract::Classify::double_VAR_H

(

matcher_rating_margin

)

double_VAR_H() [14/18]

tesseract::Classify::double_VAR_H

(

matcher_reliable_adaptive_result

)

double_VAR_H() [15/18]

tesseract::Classify::double_VAR_H

(

rating_scale

)

double_VAR_H() [16/18]

tesseract::Classify::double_VAR_H

(

speckle_large_max_size

)

double_VAR_H() [17/18]

tesseract::Classify::double_VAR_H

(

speckle_rating_penalty

)

double_VAR_H() [18/18]

tesseract::Classify::double_VAR_H

(

tessedit_class_miss_scale

)

EndAdaptiveClassifier()

void tesseract::Classify::EndAdaptiveClassifier

(

)

This routine performs cleanup operations on the adaptive classifier. It should be called before the program is terminated. Its main function is to save the adapted templates to a file.

Globals:

• AdaptedTemplates current set of adapted templates
• #classify_save_adapted_templates true if templates should be saved
• classify_enable_adaptive_matcher true if adaptive matcher is enabled

Definition at line 464 of file adaptmatch.cpp.

                                     {
  std::string Filename;
  FILE *File;
 
  if (AdaptedTemplates != nullptr && classify_enable_adaptive_matcher &&
      classify_save_adapted_templates) {
    Filename = imagefile + ADAPT_TEMPLATE_SUFFIX;
    File = fopen(Filename.c_str(), "wb");
    if (File == nullptr) {
      tprintf("Unable to save adapted templates to %s!\n", Filename.c_str());
    } else {
      tprintf("\nSaving adapted templates to %s ...", Filename.c_str());
      fflush(stdout);
      WriteAdaptedTemplates(File, AdaptedTemplates);
      tprintf("\n");
      fclose(File);
    }
  }
 
  delete AdaptedTemplates;
  AdaptedTemplates = nullptr;
  delete BackupAdaptedTemplates;
  BackupAdaptedTemplates = nullptr;
 
  if (PreTrainedTemplates != nullptr) {
    delete PreTrainedTemplates;
    PreTrainedTemplates = nullptr;
  }
  getDict().EndDangerousAmbigs();
  FreeNormProtos();
  if (AllProtosOn != nullptr) {
    FreeBitVector(AllProtosOn);
    FreeBitVector(AllConfigsOn);
    FreeBitVector(AllConfigsOff);
    FreeBitVector(TempProtoMask);
    AllProtosOn = nullptr;
    AllConfigsOn = nullptr;
    AllConfigsOff = nullptr;
    TempProtoMask = nullptr;
  }
  delete shape_table_;
  shape_table_ = nullptr;
  delete static_classifier_;
  static_classifier_ = nullptr;
} /* EndAdaptiveClassifier */

ExpandShapesAndApplyCorrections()

void tesseract::Classify::ExpandShapesAndApplyCorrections	(	ADAPT_CLASS_STRUCT **	classes,
		bool	debug,
		int	class_id,
		int	bottom,
		int	top,
		float	cp_rating,
		int	blob_length,
		int	matcher_multiplier,
		const uint8_t *	cn_factors,
		UnicharRating *	int_result,
		ADAPT_RESULTS *	final_results
	)

Definition at line 1102 of file adaptmatch.cpp.

                                                                             {
  if (classes != nullptr) {
    // Adapted result. Convert configs to fontinfo_ids.
    int_result->adapted = true;
    for (auto &font : int_result->fonts) {
      font.fontinfo_id = GetFontinfoId(classes[class_id], font.fontinfo_id);
    }
  } else {
    // Pre-trained result. Map fonts using font_sets_.
    int_result->adapted = false;
    for (auto &font : int_result->fonts) {
      font.fontinfo_id = ClassAndConfigIDToFontOrShapeID(class_id, font.fontinfo_id);
    }
    if (shape_table_ != nullptr) {
      // Two possible cases:
      // 1. Flat shapetable. All unichar-ids of the shapes referenced by
      // int_result->fonts are the same. In this case build a new vector of
      // mapped fonts and replace the fonts in int_result.
      // 2. Multi-unichar shapetable. Variable unichars in the shapes referenced
      // by int_result. In this case, build a vector of UnicharRating to
      // gather together different font-ids for each unichar. Also covers case1.
      std::vector<UnicharRating> mapped_results;
      for (auto &f : int_result->fonts) {
        int shape_id = f.fontinfo_id;
        const Shape &shape = shape_table_->GetShape(shape_id);
        for (int c = 0; c < shape.size(); ++c) {
          int unichar_id = shape[c].unichar_id;
          if (!unicharset.get_enabled(unichar_id)) {
            continue;
          }
          // Find the mapped_result for unichar_id.
          unsigned r = 0;
          for (r = 0; r < mapped_results.size() && mapped_results[r].unichar_id != unichar_id;
               ++r) {
          }
          if (r == mapped_results.size()) {
            mapped_results.push_back(*int_result);
            mapped_results[r].unichar_id = unichar_id;
            mapped_results[r].fonts.clear();
          }
          for (int font_id : shape[c].font_ids) {
            mapped_results[r].fonts.emplace_back(font_id, f.score);
          }
        }
      }
      for (auto &m : mapped_results) {
        m.rating = ComputeCorrectedRating(debug, m.unichar_id, cp_rating, int_result->rating,
                                          int_result->feature_misses, bottom, top, blob_length,
                                          matcher_multiplier, cn_factors);
        AddNewResult(m, final_results);
      }
      return;
    }
  }
  if (unicharset.get_enabled(class_id)) {
    int_result->rating = ComputeCorrectedRating(debug, class_id, cp_rating, int_result->rating,
                                                int_result->feature_misses, bottom, top,
                                                blob_length, matcher_multiplier, cn_factors);
    AddNewResult(*int_result, final_results);
  }
}

ExtractFeatures()

void tesseract::Classify::ExtractFeatures ( const TBLOB &  blob, bool  nonlinear_norm, std::vector< INT_FEATURE_STRUCT > *  bl_features, std::vector< INT_FEATURE_STRUCT > *  cn_features, INT_FX_RESULT_STRUCT *  results, std::vector< int > *  outline_cn_counts  )

static

Definition at line 436 of file intfx.cpp.

                                                                  {
  DENORM bl_denorm, cn_denorm;
  tesseract::Classify::SetupBLCNDenorms(blob, nonlinear_norm, &bl_denorm, &cn_denorm, results);
  if (outline_cn_counts != nullptr) {
    outline_cn_counts->clear();
  }
  // Iterate the outlines.
  for (TESSLINE *ol = blob.outlines; ol != nullptr; ol = ol->next) {
    // Iterate the polygon.
    EDGEPT *loop_pt = ol->FindBestStartPt();
    EDGEPT *pt = loop_pt;
    if (pt == nullptr) {
      continue;
    }
    do {
      if (pt->IsHidden()) {
        continue;
      }
      // Find a run of equal src_outline.
      EDGEPT *last_pt = pt;
      do {
        last_pt = last_pt->next;
      } while (last_pt != loop_pt && !last_pt->IsHidden() &&
               last_pt->src_outline == pt->src_outline);
      last_pt = last_pt->prev;
      // Until the adaptive classifier can be weaned off polygon segments,
      // we have to force extraction from the polygon for the bl_features.
      ExtractFeaturesFromRun(pt, last_pt, bl_denorm, kStandardFeatureLength, true, bl_features);
      ExtractFeaturesFromRun(pt, last_pt, cn_denorm, kStandardFeatureLength, false, cn_features);
      pt = last_pt;
    } while ((pt = pt->next) != loop_pt);
    if (outline_cn_counts != nullptr) {
      outline_cn_counts->push_back(cn_features->size());
    }
  }
  results->NumBL = bl_features->size();
  results->NumCN = cn_features->size();
  results->YBottom = blob.bounding_box().bottom();
  results->YTop = blob.bounding_box().top();
  results->Width = blob.bounding_box().width();
}

ExtractIntCNFeatures()

FEATURE_SET tesseract::Classify::ExtractIntCNFeatures	(	const TBLOB &	blob,
		const INT_FX_RESULT_STRUCT &	fx_info
	)

Parameters

blob	blob to extract features from
fx_info

Returns

Integer character-normalized features for blob.

Definition at line 204 of file picofeat.cpp.

                                                                                                 {
  INT_FX_RESULT_STRUCT local_fx_info(fx_info);
  std::vector<INT_FEATURE_STRUCT> bl_features;
  tesseract::TrainingSample *sample =
      tesseract::BlobToTrainingSample(blob, false, &local_fx_info, &bl_features);
  if (sample == nullptr) {
    return nullptr;
  }
 
  uint32_t num_features = sample->num_features();
  const INT_FEATURE_STRUCT *features = sample->features();
  auto feature_set = new FEATURE_SET_STRUCT(num_features);
  for (uint32_t f = 0; f < num_features; ++f) {
    auto feature = new FEATURE_STRUCT(&IntFeatDesc);
    feature->Params[IntX] = features[f].X;
    feature->Params[IntY] = features[f].Y;
    feature->Params[IntDir] = features[f].Theta;
    AddFeature(feature_set, feature);
  }
  delete sample;
 
  return feature_set;
} /* ExtractIntCNFeatures */

ExtractIntGeoFeatures()

FEATURE_SET tesseract::Classify::ExtractIntGeoFeatures	(	const TBLOB &	blob,
		const INT_FX_RESULT_STRUCT &	fx_info
	)

Parameters

blob	blob to extract features from
fx_info

Returns

Geometric (top/bottom/width) features for blob.

Definition at line 234 of file picofeat.cpp.

                                                                                 {
  INT_FX_RESULT_STRUCT local_fx_info(fx_info);
  std::vector<INT_FEATURE_STRUCT> bl_features;
  tesseract::TrainingSample *sample =
      tesseract::BlobToTrainingSample(blob, false, &local_fx_info, &bl_features);
  if (sample == nullptr) {
    return nullptr;
  }
 
  auto feature_set = new FEATURE_SET_STRUCT(1);
  auto feature = new FEATURE_STRUCT(&IntFeatDesc);
 
  feature->Params[GeoBottom] = sample->geo_feature(GeoBottom);
  feature->Params[GeoTop] = sample->geo_feature(GeoTop);
  feature->Params[GeoWidth] = sample->geo_feature(GeoWidth);
  AddFeature(feature_set, feature);
  delete sample;
 
  return feature_set;
} /* ExtractIntGeoFeatures */

ExtractOutlineFeatures()

FEATURE_SET tesseract::Classify::ExtractOutlineFeatures

(

TBLOB *

Blob

)

Convert each segment in the outline to a feature and return the features.

Parameters

Blob	blob to extract pico-features from

Returns

Outline-features for Blob.

Note

Globals: none

Definition at line 40 of file outfeat.cpp.

                                                        {
  auto FeatureSet = new FEATURE_SET_STRUCT(MAX_OUTLINE_FEATURES);
  if (Blob == nullptr) {
    return (FeatureSet);
  }
 
  auto Outlines = ConvertBlob(Blob);
 
  float XScale, YScale;
  NormalizeOutlines(Outlines, &XScale, &YScale);
  auto RemainingOutlines = Outlines;
  iterate(RemainingOutlines) {
    auto Outline = static_cast<MFOUTLINE>(RemainingOutlines->first_node());
    ConvertToOutlineFeatures(Outline, FeatureSet);
  }
  if (classify_norm_method == baseline) {
    NormalizeOutlineX(FeatureSet);
  }
  FreeOutlines(Outlines);
  return (FeatureSet);
} /* ExtractOutlineFeatures */

ExtractPicoFeatures()

FEATURE_SET tesseract::Classify::ExtractPicoFeatures

(

TBLOB *

Blob

)

Operation: Dummy for now.

Globals:

• classify_norm_method normalization method currently specified

  Parameters

  Blob	blob to extract pico-features from

  Returns

  Pico-features for Blob.

Definition at line 60 of file picofeat.cpp.

                                                     {
  auto FeatureSet = new FEATURE_SET_STRUCT(MAX_PICO_FEATURES);
  auto Outlines = ConvertBlob(Blob);
  float XScale, YScale;
  NormalizeOutlines(Outlines, &XScale, &YScale);
  auto RemainingOutlines = Outlines;
  iterate(RemainingOutlines) {
    auto Outline = static_cast<MFOUTLINE>(RemainingOutlines->first_node());
    ConvertToPicoFeatures2(Outline, FeatureSet);
  }
  if (classify_norm_method == baseline) {
    NormalizePicoX(FeatureSet);
  }
  FreeOutlines(Outlines);
  return (FeatureSet);
 
} /* ExtractPicoFeatures */

FreeNormProtos()

void tesseract::Classify::FreeNormProtos

(

)

Definition at line 154 of file normmatch.cpp.

                              {
  if (NormProtos != nullptr) {
    for (int i = 0; i < NormProtos->NumProtos; i++) {
      FreeProtoList(&NormProtos->Protos[i]);
    }
    delete[] NormProtos->ParamDesc;
    delete NormProtos;
    NormProtos = nullptr;
  }
}

get_fontinfo_table() [1/2]

UnicityTable< FontInfo > & tesseract::Classify::get_fontinfo_table ( )

inline

Definition at line 324 of file classify.h.

                                               {
    return fontinfo_table_;
  }

get_fontinfo_table() [2/2]

const UnicityTable< FontInfo > & tesseract::Classify::get_fontinfo_table ( ) const

inline

Definition at line 327 of file classify.h.

                                                           {
    return fontinfo_table_;
  }

get_fontset_table()

UnicityTable< FontSet > & tesseract::Classify::get_fontset_table ( )

inline

Definition at line 330 of file classify.h.

                                             {
    return fontset_table_;
  }

GetAdaptiveFeatures()

int tesseract::Classify::GetAdaptiveFeatures	(	TBLOB *	Blob,
		INT_FEATURE_ARRAY	IntFeatures,
		FEATURE_SET *	FloatFeatures
	)

This routine sets up the feature extractor to extract baseline normalized pico-features.

The extracted pico-features are converted to integer form and placed in IntFeatures. The original floating-pt. features are returned in FloatFeatures.

Globals: none

Parameters

	Blob	blob to extract features from
[out]	IntFeatures	array to fill with integer features
[out]	FloatFeatures	place to return actual floating-pt features

Returns

Number of pico-features returned (0 if an error occurred)

Definition at line 778 of file adaptmatch.cpp.

                                                              {
  FEATURE_SET Features;
  int NumFeatures;
 
  classify_norm_method.set_value(baseline);
  Features = ExtractPicoFeatures(Blob);
 
  NumFeatures = Features->NumFeatures;
  if (NumFeatures == 0 || NumFeatures > UNLIKELY_NUM_FEAT) {
    delete Features;
    return 0;
  }
 
  ComputeIntFeatures(Features, IntFeatures);
  *FloatFeatures = Features;
 
  return NumFeatures;
} /* GetAdaptiveFeatures */

GetAmbiguities()

UNICHAR_ID * tesseract::Classify::GetAmbiguities	(	TBLOB *	Blob,
		CLASS_ID	CorrectClass
	)

This routine matches blob to the built-in templates to find out if there are any classes other than the correct class which are potential ambiguities.

Parameters

Blob	blob to get classification ambiguities for
CorrectClass	correct class for Blob

Globals:

• CurrentRatings used by qsort compare routine
• PreTrainedTemplates built-in templates

Returns

String containing all possible ambiguous classes.

Definition at line 1532 of file adaptmatch.cpp.

                                                                       {
  auto *Results = new ADAPT_RESULTS();
  UNICHAR_ID *Ambiguities;
 
  Results->Initialize();
  INT_FX_RESULT_STRUCT fx_info;
  std::vector<INT_FEATURE_STRUCT> bl_features;
  TrainingSample *sample =
      BlobToTrainingSample(*Blob, classify_nonlinear_norm, &fx_info, &bl_features);
  if (sample == nullptr) {
    delete Results;
    return nullptr;
  }
 
  CharNormClassifier(Blob, *sample, Results);
  delete sample;
  RemoveBadMatches(Results);
  std::sort(Results->match.begin(), Results->match.end(), SortDescendingRating);
 
  /* copy the class id's into an string of ambiguities - don't copy if
   the correct class is the only class id matched */
  Ambiguities = new UNICHAR_ID[Results->match.size() + 1];
  if (Results->match.size() > 1 ||
      (Results->match.size() == 1 && Results->match[0].unichar_id != CorrectClass)) {
    unsigned i;
    for (i = 0; i < Results->match.size(); i++) {
      Ambiguities[i] = Results->match[i].unichar_id;
    }
    Ambiguities[i] = -1;
  } else {
    Ambiguities[0] = -1;
  }
 
  delete Results;
  return Ambiguities;
} /* GetAmbiguities */

GetCharNormFeature()

int tesseract::Classify::GetCharNormFeature	(	const INT_FX_RESULT_STRUCT &	fx_info,
		INT_TEMPLATES_STRUCT *	templates,
		uint8_t *	pruner_norm_array,
		uint8_t *	char_norm_array
	)

This routine calls the integer (Hardware) feature extractor if it has not been called before for this blob.

The results from the feature extractor are placed into globals so that they can be used in other routines without re-extracting the features.

It then copies the char norm features into the IntFeatures array provided by the caller.

Parameters

templates	used to compute char norm adjustments
pruner_norm_array	Array of factors from blob normalization process
char_norm_array	array to fill with dummy char norm adjustments
fx_info

Globals:

Returns

Number of features extracted or 0 if an error occurred.

Definition at line 1613 of file adaptmatch.cpp.

                                                                                       {
  auto norm_feature = new FEATURE_STRUCT(&CharNormDesc);
  float baseline = kBlnBaselineOffset;
  float scale = MF_SCALE_FACTOR;
  norm_feature->Params[CharNormY] = (fx_info.Ymean - baseline) * scale;
  norm_feature->Params[CharNormLength] = fx_info.Length * scale / LENGTH_COMPRESSION;
  norm_feature->Params[CharNormRx] = fx_info.Rx * scale;
  norm_feature->Params[CharNormRy] = fx_info.Ry * scale;
  // Deletes norm_feature.
  ComputeCharNormArrays(norm_feature, templates, char_norm_array, pruner_norm_array);
  return IntCastRounded(fx_info.Length / kStandardFeatureLength);
} /* GetCharNormFeature */

GetClassToDebug()

CLASS_ID tesseract::Classify::GetClassToDebug	(	const char *	Prompt,
		bool *	adaptive_on,
		bool *	pretrained_on,
		int *	shape_id
	)

This routine prompts the user with Prompt and waits for the user to enter something in the debug window.

Parameters

Prompt	prompt to print while waiting for input from window
adaptive_on
pretrained_on
shape_id

Returns

Character entered in the debug window.

Note

Globals: none

Definition at line 1165 of file intproto.cpp.

                                                  {
  tprintf("%s\n", Prompt);
  SVEventType ev_type;
  int unichar_id = INVALID_UNICHAR_ID;
  // Wait until a click or popup event.
  do {
    auto ev = IntMatchWindow->AwaitEvent(SVET_ANY);
    ev_type = ev->type;
    if (ev_type == SVET_POPUP) {
      if (ev->command_id == IDA_SHAPE_INDEX) {
        if (shape_table_ != nullptr) {
          *shape_id = atoi(ev->parameter);
          *adaptive_on = false;
          *pretrained_on = true;
          if (*shape_id >= 0 && static_cast<unsigned>(*shape_id) < shape_table_->NumShapes()) {
            int font_id;
            shape_table_->GetFirstUnicharAndFont(*shape_id, &unichar_id, &font_id);
            tprintf("Shape %d, first unichar=%d, font=%d\n", *shape_id, unichar_id, font_id);
            return unichar_id;
          }
          tprintf("Shape index '%s' not found in shape table\n", ev->parameter);
        } else {
          tprintf("No shape table loaded!\n");
        }
      } else {
        if (unicharset.contains_unichar(ev->parameter)) {
          unichar_id = unicharset.unichar_to_id(ev->parameter);
          if (ev->command_id == IDA_ADAPTIVE) {
            *adaptive_on = true;
            *pretrained_on = false;
            *shape_id = -1;
          } else if (ev->command_id == IDA_STATIC) {
            *adaptive_on = false;
            *pretrained_on = true;
          } else {
            *adaptive_on = true;
            *pretrained_on = true;
          }
          if (ev->command_id == IDA_ADAPTIVE || shape_table_ == nullptr) {
            *shape_id = -1;
            return unichar_id;
          }
          for (unsigned s = 0; s < shape_table_->NumShapes(); ++s) {
            if (shape_table_->GetShape(s).ContainsUnichar(unichar_id)) {
              tprintf("%s\n", shape_table_->DebugStr(s).c_str());
            }
          }
        } else {
          tprintf("Char class '%s' not found in unicharset", ev->parameter);
        }
      }
    }
  } while (ev_type != SVET_CLICK);
  return 0;
} /* GetClassToDebug */

getDict()

virtual Dict & tesseract::Classify::getDict ( )

inlinevirtual

Reimplemented in tesseract::Tesseract.

Definition at line 98 of file classify.h.

                          {
    return dict_;
  }

GetFontinfoId()

int tesseract::Classify::GetFontinfoId	(	ADAPT_CLASS_STRUCT *	Class,
		uint8_t	ConfigId
	)

Definition at line 118 of file adaptive.cpp.

                                                                       {
  return (ConfigIsPermanent(Class, ConfigId) ? PermConfigFor(Class, ConfigId)->FontinfoId
                                             : TempConfigFor(Class, ConfigId)->FontinfoId);
}

InitAdaptedClass()

void tesseract::Classify::InitAdaptedClass	(	TBLOB *	Blob,
		CLASS_ID	ClassId,
		int	FontinfoId,
		ADAPT_CLASS_STRUCT *	Class,
		ADAPT_TEMPLATES_STRUCT *	Templates
	)

This routine creates a new adapted class and uses Blob as the model for the first config in that class.

Parameters

Blob	blob to model new class after
ClassId	id of the class to be initialized
FontinfoId	font information inferred from pre-trained templates
Class	adapted class to be initialized
Templates	adapted templates to add new class to

Globals:

• AllProtosOn dummy mask with all 1's
• BaselineCutoffs kludge needed to get cutoffs
• PreTrainedTemplates kludge needed to get cutoffs

Definition at line 686 of file adaptmatch.cpp.

                                                                   {
  FEATURE_SET Features;
  int Fid, Pid;
  FEATURE Feature;
  int NumFeatures;
  PROTO_STRUCT *Proto;
  INT_CLASS_STRUCT *IClass;
  TEMP_CONFIG_STRUCT *Config;
 
  classify_norm_method.set_value(baseline);
  Features = ExtractOutlineFeatures(Blob);
  NumFeatures = Features->NumFeatures;
  if (NumFeatures > UNLIKELY_NUM_FEAT || NumFeatures <= 0) {
    delete Features;
    return;
  }
 
  Config = new TEMP_CONFIG_STRUCT(NumFeatures - 1, FontinfoId);
  TempConfigFor(Class, 0) = Config;
 
  /* this is a kludge to construct cutoffs for adapted templates */
  if (Templates == AdaptedTemplates) {
    BaselineCutoffs[ClassId] = CharNormCutoffs[ClassId];
  }
 
  IClass = ClassForClassId(Templates->Templates, ClassId);
 
  for (Fid = 0; Fid < Features->NumFeatures; Fid++) {
    Pid = AddIntProto(IClass);
    assert(Pid != NO_PROTO);
 
    Feature = Features->Features[Fid];
    auto TempProto = new TEMP_PROTO_STRUCT;
    Proto = &(TempProto->Proto);
 
    /* compute proto params - NOTE that Y_DIM_OFFSET must be used because
   ConvertProto assumes that the Y dimension varies from -0.5 to 0.5
   instead of the -0.25 to 0.75 used in baseline normalization */
    Proto->Angle = Feature->Params[OutlineFeatDir];
    Proto->X = Feature->Params[OutlineFeatX];
    Proto->Y = Feature->Params[OutlineFeatY] - Y_DIM_OFFSET;
    Proto->Length = Feature->Params[OutlineFeatLength];
    FillABC(Proto);
 
    TempProto->ProtoId = Pid;
    SET_BIT(Config->Protos, Pid);
 
    ConvertProto(Proto, Pid, IClass);
    AddProtoToProtoPruner(Proto, Pid, IClass, classify_learning_debug_level >= 2);
 
    Class->TempProtos = push(Class->TempProtos, TempProto);
  }
  delete Features;
 
  AddIntConfig(IClass);
  ConvertConfig(AllProtosOn, 0, IClass);
 
  if (classify_learning_debug_level >= 1) {
    tprintf("Added new class '%s' with class id %d and %d protos.\n",
            unicharset.id_to_unichar(ClassId), ClassId, NumFeatures);
#ifndef GRAPHICS_DISABLED
    if (classify_learning_debug_level > 1) {
      DisplayAdaptedChar(Blob, IClass);
    }
#endif
  }
 
  if (IsEmptyAdaptedClass(Class)) {
    (Templates->NumNonEmptyClasses)++;
  }
} /* InitAdaptedClass */

InitAdaptiveClassifier()

void tesseract::Classify::InitAdaptiveClassifier

(

TessdataManager *

mgr

)

This routine reads in the training information needed by the adaptive classifier and saves it into global variables. Parameters: load_pre_trained_templates Indicates whether the pre-trained templates (inttemp, normproto and pffmtable components) should be loaded. Should only be set to true if the necessary classifier components are present in the [lang].traineddata file. Globals: BuiltInTemplatesFile file to get built-in temps from BuiltInCutoffsFile file to get avg. feat per class from classify_use_pre_adapted_templates enables use of pre-adapted templates

Definition at line 527 of file adaptmatch.cpp.

                                                          {
  if (!classify_enable_adaptive_matcher) {
    return;
  }
  if (AllProtosOn != nullptr) {
    EndAdaptiveClassifier(); // Don't leak with multiple inits.
  }
 
  // If there is no language_data_path_prefix, the classifier will be
  // adaptive only.
  if (language_data_path_prefix.length() > 0 && mgr != nullptr) {
    TFile fp;
    ASSERT_HOST(mgr->GetComponent(TESSDATA_INTTEMP, &fp));
    PreTrainedTemplates = ReadIntTemplates(&fp);
 
    if (mgr->GetComponent(TESSDATA_SHAPE_TABLE, &fp)) {
      shape_table_ = new ShapeTable(unicharset);
      if (!shape_table_->DeSerialize(&fp)) {
        tprintf("Error loading shape table!\n");
        delete shape_table_;
        shape_table_ = nullptr;
      }
    }
 
    ASSERT_HOST(mgr->GetComponent(TESSDATA_PFFMTABLE, &fp));
    ReadNewCutoffs(&fp, CharNormCutoffs);
 
    ASSERT_HOST(mgr->GetComponent(TESSDATA_NORMPROTO, &fp));
    NormProtos = ReadNormProtos(&fp);
    static_classifier_ = new TessClassifier(false, this);
  }
 
  InitIntegerFX();
 
  AllProtosOn = NewBitVector(MAX_NUM_PROTOS);
  AllConfigsOn = NewBitVector(MAX_NUM_CONFIGS);
  AllConfigsOff = NewBitVector(MAX_NUM_CONFIGS);
  TempProtoMask = NewBitVector(MAX_NUM_PROTOS);
  set_all_bits(AllProtosOn, WordsInVectorOfSize(MAX_NUM_PROTOS));
  set_all_bits(AllConfigsOn, WordsInVectorOfSize(MAX_NUM_CONFIGS));
  zero_all_bits(AllConfigsOff, WordsInVectorOfSize(MAX_NUM_CONFIGS));
 
  for (uint16_t &BaselineCutoff : BaselineCutoffs) {
    BaselineCutoff = 0;
  }
 
  if (classify_use_pre_adapted_templates) {
    TFile fp;
    std::string Filename = imagefile;
    Filename += ADAPT_TEMPLATE_SUFFIX;
    if (!fp.Open(Filename.c_str(), nullptr)) {
      AdaptedTemplates = new ADAPT_TEMPLATES_STRUCT(unicharset);
    } else {
      tprintf("\nReading pre-adapted templates from %s ...\n", Filename.c_str());
      fflush(stdout);
      AdaptedTemplates = ReadAdaptedTemplates(&fp);
      tprintf("\n");
      PrintAdaptedTemplates(stdout, AdaptedTemplates);
 
      for (unsigned i = 0; i < AdaptedTemplates->Templates->NumClasses; i++) {
        BaselineCutoffs[i] = CharNormCutoffs[i];
      }
    }
  } else {
    delete AdaptedTemplates;
    AdaptedTemplates = new ADAPT_TEMPLATES_STRUCT(unicharset);
  }
} /* InitAdaptiveClassifier */

INT_VAR_H() [1/14]

tesseract::Classify::INT_VAR_H

(

classify_adapt_feature_threshold

)

INT_VAR_H() [2/14]

tesseract::Classify::INT_VAR_H

(

classify_adapt_proto_threshold

)

INT_VAR_H() [3/14]

tesseract::Classify::INT_VAR_H

(

classify_class_pruner_multiplier

)

INT_VAR_H() [4/14]

tesseract::Classify::INT_VAR_H

(

classify_class_pruner_threshold

)

INT_VAR_H() [5/14]

tesseract::Classify::INT_VAR_H

(

classify_cp_cutoff_strength

)

INT_VAR_H() [6/14]

tesseract::Classify::INT_VAR_H

(

classify_debug_level

)

INT_VAR_H() [7/14]

tesseract::Classify::INT_VAR_H

(

classify_integer_matcher_multiplier

)

INT_VAR_H() [8/14]

tesseract::Classify::INT_VAR_H

(

classify_learning_debug_level

)

INT_VAR_H() [9/14]

tesseract::Classify::INT_VAR_H

(

classify_norm_method

)

INT_VAR_H() [10/14]

tesseract::Classify::INT_VAR_H

(

matcher_debug_flags

)

INT_VAR_H() [11/14]

tesseract::Classify::INT_VAR_H

(

matcher_debug_level

)

INT_VAR_H() [12/14]

tesseract::Classify::INT_VAR_H

(

matcher_min_examples_for_prototyping

)

INT_VAR_H() [13/14]

tesseract::Classify::INT_VAR_H

(

matcher_permanent_classes_min

)

INT_VAR_H() [14/14]

tesseract::Classify::INT_VAR_H

(

matcher_sufficient_examples_for_prototyping

)

LargeSpeckle()

bool tesseract::Classify::LargeSpeckle

(

const TBLOB &

blob

)

Definition at line 190 of file classify.cpp.

                                             {
  double speckle_size = kBlnXHeight * speckle_large_max_size;
  TBOX bbox = blob.bounding_box();
  return bbox.width() < speckle_size && bbox.height() < speckle_size;
}

LearnBlob()

void tesseract::Classify::LearnBlob	(	const std::string &	fontname,
		TBLOB *	Blob,
		const DENORM &	cn_denorm,
		const INT_FX_RESULT_STRUCT &	fx_info,
		const char *	blob_text
	)

Definition at line 35 of file blobclass.cpp.

                                                                                     {
  std::unique_ptr<CHAR_DESC_STRUCT> CharDesc(new CHAR_DESC_STRUCT(feature_defs_));
  CharDesc->FeatureSets[0] = ExtractMicros(blob, cn_denorm);
  CharDesc->FeatureSets[1] = ExtractCharNormFeatures(fx_info);
  CharDesc->FeatureSets[2] = ExtractIntCNFeatures(*blob, fx_info);
  CharDesc->FeatureSets[3] = ExtractIntGeoFeatures(*blob, fx_info);
 
  if (ValidCharDescription(feature_defs_, CharDesc.get())) {
    // Label the features with a class name and font name.
    tr_file_data_ += "\n";
    tr_file_data_ += fontname;
    tr_file_data_ += " ";
    tr_file_data_ += blob_text;
    tr_file_data_ += "\n";
 
    // write micro-features to file and clean up
    WriteCharDescription(feature_defs_, CharDesc.get(), tr_file_data_);
  } else {
    tprintf("Blob learned was invalid!\n");
  }
} // LearnBlob

LearnPieces()

void tesseract::Classify::LearnPieces	(	const char *	fontname,
		int	start,
		int	length,
		float	threshold,
		CharSegmentationType	segmentation,
		const char *	correct_text,
		WERD_RES *	word
	)

Definition at line 385 of file adaptmatch.cpp.

                                           {
  // TODO(daria) Remove/modify this if/when we want
  // to train and/or adapt to n-grams.
  if (segmentation != CST_WHOLE && (segmentation != CST_FRAGMENT || disable_character_fragments)) {
    return;
  }
 
  if (length > 1) {
    SEAM::JoinPieces(word->seam_array, word->chopped_word->blobs, start, start + length - 1);
  }
  TBLOB *blob = word->chopped_word->blobs[start];
  // Rotate the blob if needed for classification.
  TBLOB *rotated_blob = blob->ClassifyNormalizeIfNeeded();
  if (rotated_blob == nullptr) {
    rotated_blob = blob;
  }
 
#ifndef GRAPHICS_DISABLED
  // Draw debug windows showing the blob that is being learned if needed.
  if (strcmp(classify_learn_debug_str.c_str(), correct_text) == 0) {
    RefreshDebugWindow(&learn_debug_win_, "LearnPieces", 600, word->chopped_word->bounding_box());
    rotated_blob->plot(learn_debug_win_, ScrollView::GREEN, ScrollView::BROWN);
    learn_debug_win_->Update();
    learn_debug_win_->Wait();
  }
  if (classify_debug_character_fragments && segmentation == CST_FRAGMENT) {
    ASSERT_HOST(learn_fragments_debug_win_ != nullptr); // set up in LearnWord
    blob->plot(learn_fragments_debug_win_, ScrollView::BLUE, ScrollView::BROWN);
    learn_fragments_debug_win_->Update();
  }
#endif // !GRAPHICS_DISABLED
 
  if (fontname != nullptr) {
    classify_norm_method.set_value(character); // force char norm spc 30/11/93
    tess_bn_matching.set_value(false);         // turn it off
    tess_cn_matching.set_value(false);
    DENORM bl_denorm, cn_denorm;
    INT_FX_RESULT_STRUCT fx_info;
    SetupBLCNDenorms(*rotated_blob, classify_nonlinear_norm, &bl_denorm, &cn_denorm, &fx_info);
    LearnBlob(fontname, rotated_blob, cn_denorm, fx_info, correct_text);
  } else if (unicharset.contains_unichar(correct_text)) {
    UNICHAR_ID class_id = unicharset.unichar_to_id(correct_text);
    int font_id = word->fontinfo != nullptr ? fontinfo_table_.get_index(*word->fontinfo) : 0;
    if (classify_learning_debug_level >= 1) {
      tprintf("Adapting to char = %s, thr= %g font_id= %d\n", unicharset.id_to_unichar(class_id),
              threshold, font_id);
    }
    // If filename is not nullptr we are doing recognition
    // (as opposed to training), so we must have already set word fonts.
    AdaptToChar(rotated_blob, class_id, font_id, threshold, AdaptedTemplates);
    if (BackupAdaptedTemplates != nullptr) {
      // Adapt the backup templates too. They will be used if the primary gets
      // too full.
      AdaptToChar(rotated_blob, class_id, font_id, threshold, BackupAdaptedTemplates);
    }
  } else if (classify_debug_level >= 1) {
    tprintf("Can't adapt to %s not in unicharset\n", correct_text);
  }
  if (rotated_blob != blob) {
    delete rotated_blob;
  }
 
  SEAM::BreakPieces(word->seam_array, word->chopped_word->blobs, start, start + length - 1);
} // LearnPieces.

LearnWord()

void tesseract::Classify::LearnWord	(	const char *	fontname,
		WERD_RES *	word
	)

Definition at line 262 of file adaptmatch.cpp.

                                                             {
  int word_len = word->correct_text.size();
  if (word_len == 0) {
    return;
  }
 
  float *thresholds = nullptr;
  if (fontname == nullptr) {
    // Adaption mode.
    if (!EnableLearning || word->best_choice == nullptr) {
      return; // Can't or won't adapt.
    }
 
    if (classify_learning_debug_level >= 1) {
      tprintf("\n\nAdapting to word = %s\n", word->best_choice->debug_string().c_str());
    }
    thresholds = new float[word_len];
    word->ComputeAdaptionThresholds(getDict().certainty_scale, matcher_perfect_threshold,
                                    matcher_good_threshold, matcher_rating_margin, thresholds);
  }
  int start_blob = 0;
 
#ifndef GRAPHICS_DISABLED
  if (classify_debug_character_fragments) {
    if (learn_fragmented_word_debug_win_ != nullptr) {
      learn_fragmented_word_debug_win_->Wait();
    }
    RefreshDebugWindow(&learn_fragments_debug_win_, "LearnPieces", 400,
                       word->chopped_word->bounding_box());
    RefreshDebugWindow(&learn_fragmented_word_debug_win_, "LearnWord", 200,
                       word->chopped_word->bounding_box());
    word->chopped_word->plot(learn_fragmented_word_debug_win_);
    ScrollView::Update();
  }
#endif // !GRAPHICS_DISABLED
 
  for (int ch = 0; ch < word_len; ++ch) {
    if (classify_debug_character_fragments) {
      tprintf("\nLearning %s\n", word->correct_text[ch].c_str());
    }
    if (word->correct_text[ch].length() > 0) {
      float threshold = thresholds != nullptr ? thresholds[ch] : 0.0f;
 
      LearnPieces(fontname, start_blob, word->best_state[ch], threshold, CST_WHOLE,
                  word->correct_text[ch].c_str(), word);
 
      if (word->best_state[ch] > 1 && !disable_character_fragments) {
        // Check that the character breaks into meaningful fragments
        // that each match a whole character with at least
        // classify_character_fragments_garbage_certainty_threshold
        bool garbage = false;
        int frag;
        for (frag = 0; frag < word->best_state[ch]; ++frag) {
          TBLOB *frag_blob = word->chopped_word->blobs[start_blob + frag];
          if (classify_character_fragments_garbage_certainty_threshold < 0) {
            garbage |= LooksLikeGarbage(frag_blob);
          }
        }
        // Learn the fragments.
        if (!garbage) {
          bool pieces_all_natural = word->PiecesAllNatural(start_blob, word->best_state[ch]);
          if (pieces_all_natural || !prioritize_division) {
            for (frag = 0; frag < word->best_state[ch]; ++frag) {
              std::vector<std::string> tokens = split(word->correct_text[ch], ' ');
 
              tokens[0] = CHAR_FRAGMENT::to_string(tokens[0].c_str(), frag, word->best_state[ch],
                                                   pieces_all_natural);
 
              std::string full_string;
              for (unsigned i = 0; i < tokens.size(); i++) {
                full_string += tokens[i];
                if (i != tokens.size() - 1) {
                  full_string += ' ';
                }
              }
              LearnPieces(fontname, start_blob + frag, 1, threshold, CST_FRAGMENT,
                          full_string.c_str(), word);
            }
          }
        }
      }
 
      // TODO(rays): re-enable this part of the code when we switch to the
      // new classifier that needs to see examples of garbage.
      /*
if (word->best_state[ch] > 1) {
  // If the next blob is good, make junk with the rightmost fragment.
  if (ch + 1 < word_len && word->correct_text[ch + 1].length() > 0) {
    LearnPieces(fontname, start_blob + word->best_state[ch] - 1,
                word->best_state[ch + 1] + 1,
                threshold, CST_IMPROPER, INVALID_UNICHAR, word);
  }
  // If the previous blob is good, make junk with the leftmost fragment.
  if (ch > 0 && word->correct_text[ch - 1].length() > 0) {
    LearnPieces(fontname, start_blob - word->best_state[ch - 1],
                word->best_state[ch - 1] + 1,
                threshold, CST_IMPROPER, INVALID_UNICHAR, word);
  }
}
// If the next blob is good, make a join with it.
if (ch + 1 < word_len && word->correct_text[ch + 1].length() > 0) {
  std::string joined_text = word->correct_text[ch];
  joined_text += word->correct_text[ch + 1];
  LearnPieces(fontname, start_blob,
              word->best_state[ch] + word->best_state[ch + 1],
              threshold, CST_NGRAM, joined_text.c_str(), word);
}
*/
    }
    start_blob += word->best_state[ch];
  }
  delete[] thresholds;
} // LearnWord.

LooksLikeGarbage()

bool tesseract::Classify::LooksLikeGarbage

(

TBLOB *

blob

)

Definition at line 1571 of file adaptmatch.cpp.

                                           {
  auto *ratings = new BLOB_CHOICE_LIST();
  AdaptiveClassifier(blob, ratings);
  BLOB_CHOICE_IT ratings_it(ratings);
  const UNICHARSET &unicharset = getDict().getUnicharset();
  if (classify_debug_character_fragments) {
    print_ratings_list("======================\nLooksLikeGarbage() got ", ratings, unicharset);
  }
  for (ratings_it.mark_cycle_pt(); !ratings_it.cycled_list(); ratings_it.forward()) {
    if (unicharset.get_fragment(ratings_it.data()->unichar_id()) != nullptr) {
      continue;
    }
    float certainty = ratings_it.data()->certainty();
    delete ratings;
    return certainty < classify_character_fragments_garbage_certainty_threshold;
  }
  delete ratings;
  return true; // no whole characters in ratings
}

MakeNewTemporaryConfig()

int tesseract::Classify::MakeNewTemporaryConfig	(	ADAPT_TEMPLATES_STRUCT *	Templates,
		CLASS_ID	ClassId,
		int	FontinfoId,
		int	NumFeatures,
		INT_FEATURE_ARRAY	Features,
		FEATURE_SET	FloatFeatures
	)

Parameters

Templates	adapted templates to add new config to
ClassId	class id to associate with new config
FontinfoId	font information inferred from pre-trained templates
NumFeatures	number of features in IntFeatures
Features	features describing model for new config
FloatFeatures	floating-pt representation of features

Returns

The id of the new config created, a negative integer in case of error.

Definition at line 1669 of file adaptmatch.cpp.

                                                                {
  INT_CLASS_STRUCT *IClass;
  ADAPT_CLASS_STRUCT *Class;
  PROTO_ID OldProtos[MAX_NUM_PROTOS];
  FEATURE_ID BadFeatures[MAX_NUM_INT_FEATURES];
  int NumOldProtos;
  int NumBadFeatures;
  int MaxProtoId, OldMaxProtoId;
  int MaskSize;
  int ConfigId;
  int i;
  int debug_level = NO_DEBUG;
 
  if (classify_learning_debug_level >= 3) {
    debug_level = PRINT_MATCH_SUMMARY | PRINT_FEATURE_MATCHES | PRINT_PROTO_MATCHES;
  }
 
  IClass = ClassForClassId(Templates->Templates, ClassId);
  Class = Templates->Class[ClassId];
 
  if (IClass->NumConfigs >= MAX_NUM_CONFIGS) {
    ++NumAdaptationsFailed;
    if (classify_learning_debug_level >= 1) {
      tprintf("Cannot make new temporary config: maximum number exceeded.\n");
    }
    return -1;
  }
 
  OldMaxProtoId = IClass->NumProtos - 1;
 
  NumOldProtos = im_.FindGoodProtos(IClass, AllProtosOn, AllConfigsOff, NumFeatures, Features,
                                    OldProtos, classify_adapt_proto_threshold, debug_level);
 
  MaskSize = WordsInVectorOfSize(MAX_NUM_PROTOS);
  zero_all_bits(TempProtoMask, MaskSize);
  for (i = 0; i < NumOldProtos; i++) {
    SET_BIT(TempProtoMask, OldProtos[i]);
  }
 
  NumBadFeatures = im_.FindBadFeatures(IClass, TempProtoMask, AllConfigsOn, NumFeatures, Features,
                                       BadFeatures, classify_adapt_feature_threshold, debug_level);
 
  MaxProtoId =
      MakeNewTempProtos(FloatFeatures, NumBadFeatures, BadFeatures, IClass, Class, TempProtoMask);
  if (MaxProtoId == NO_PROTO) {
    ++NumAdaptationsFailed;
    if (classify_learning_debug_level >= 1) {
      tprintf("Cannot make new temp protos: maximum number exceeded.\n");
    }
    return -1;
  }
 
  ConfigId = AddIntConfig(IClass);
  ConvertConfig(TempProtoMask, ConfigId, IClass);
  auto Config = new TEMP_CONFIG_STRUCT(MaxProtoId, FontinfoId);
  TempConfigFor(Class, ConfigId) = Config;
  copy_all_bits(TempProtoMask, Config->Protos, Config->ProtoVectorSize);
 
  if (classify_learning_debug_level >= 1) {
    tprintf(
        "Making new temp config %d fontinfo id %d"
        " using %d old and %d new protos.\n",
        ConfigId, Config->FontinfoId, NumOldProtos, MaxProtoId - OldMaxProtoId);
  }
 
  return ConfigId;
} /* MakeNewTemporaryConfig */

MakeNewTempProtos()

PROTO_ID tesseract::Classify::MakeNewTempProtos	(	FEATURE_SET	Features,
		int	NumBadFeat,
		FEATURE_ID	BadFeat[],
		INT_CLASS_STRUCT *	IClass,
		ADAPT_CLASS_STRUCT *	Class,
		BIT_VECTOR	TempProtoMask
	)

This routine finds sets of sequential bad features that all have the same angle and converts each set into a new temporary proto. The temp proto is added to the proto pruner for IClass, pushed onto the list of temp protos in Class, and added to TempProtoMask.

Parameters

Features	floating-pt features describing new character
NumBadFeat	number of bad features to turn into protos
BadFeat	feature id's of bad features
IClass	integer class templates to add new protos to
Class	adapted class templates to add new protos to
TempProtoMask	proto mask to add new protos to

Globals: none

Returns

Max proto id in class after all protos have been added.

Definition at line 1758 of file adaptmatch.cpp.

                                                               {
  FEATURE_ID *ProtoStart;
  FEATURE_ID *ProtoEnd;
  FEATURE_ID *LastBad;
  PROTO_STRUCT *Proto;
  FEATURE F1, F2;
  float X1, X2, Y1, Y2;
  float A1, A2, AngleDelta;
  float SegmentLength;
  PROTO_ID Pid;
 
  for (ProtoStart = BadFeat, LastBad = ProtoStart + NumBadFeat; ProtoStart < LastBad;
       ProtoStart = ProtoEnd) {
    F1 = Features->Features[*ProtoStart];
    X1 = F1->Params[PicoFeatX];
    Y1 = F1->Params[PicoFeatY];
    A1 = F1->Params[PicoFeatDir];
 
    for (ProtoEnd = ProtoStart + 1, SegmentLength = GetPicoFeatureLength(); ProtoEnd < LastBad;
         ProtoEnd++, SegmentLength += GetPicoFeatureLength()) {
      F2 = Features->Features[*ProtoEnd];
      X2 = F2->Params[PicoFeatX];
      Y2 = F2->Params[PicoFeatY];
      A2 = F2->Params[PicoFeatDir];
 
      AngleDelta = std::fabs(A1 - A2);
      if (AngleDelta > 0.5f) {
        AngleDelta = 1 - AngleDelta;
      }
 
      if (AngleDelta > matcher_clustering_max_angle_delta || std::fabs(X1 - X2) > SegmentLength ||
          std::fabs(Y1 - Y2) > SegmentLength) {
        break;
      }
    }
 
    F2 = Features->Features[*(ProtoEnd - 1)];
    X2 = F2->Params[PicoFeatX];
    Y2 = F2->Params[PicoFeatY];
    A2 = F2->Params[PicoFeatDir];
 
    Pid = AddIntProto(IClass);
    if (Pid == NO_PROTO) {
      return (NO_PROTO);
    }
 
    auto TempProto = new TEMP_PROTO_STRUCT;
    Proto = &(TempProto->Proto);
 
    /* compute proto params - NOTE that Y_DIM_OFFSET must be used because
   ConvertProto assumes that the Y dimension varies from -0.5 to 0.5
   instead of the -0.25 to 0.75 used in baseline normalization */
    Proto->Length = SegmentLength;
    Proto->Angle = A1;
    Proto->X = (X1 + X2) / 2;
    Proto->Y = (Y1 + Y2) / 2 - Y_DIM_OFFSET;
    FillABC(Proto);
 
    TempProto->ProtoId = Pid;
    SET_BIT(TempProtoMask, Pid);
 
    ConvertProto(Proto, Pid, IClass);
    AddProtoToProtoPruner(Proto, Pid, IClass, classify_learning_debug_level >= 2);
 
    Class->TempProtos = push(Class->TempProtos, TempProto);
  }
  return IClass->NumProtos - 1;
} /* MakeNewTempProtos */

MakePermanent()

void tesseract::Classify::MakePermanent	(	ADAPT_TEMPLATES_STRUCT *	Templates,
		CLASS_ID	ClassId,
		int	ConfigId,
		TBLOB *	Blob
	)

Parameters

Templates	current set of adaptive templates
ClassId	class containing config to be made permanent
ConfigId	config to be made permanent
Blob	current blob being adapted to

Globals: none

Definition at line 1839 of file adaptmatch.cpp.

                                          {
  UNICHAR_ID *Ambigs;
  PROTO_KEY ProtoKey;
 
  auto Class = Templates->Class[ClassId];
  auto Config = TempConfigFor(Class, ConfigId);
 
  MakeConfigPermanent(Class, ConfigId);
  if (Class->NumPermConfigs == 0) {
    Templates->NumPermClasses++;
  }
  Class->NumPermConfigs++;
 
  // Initialize permanent config.
  Ambigs = GetAmbiguities(Blob, ClassId);
  auto Perm = new PERM_CONFIG_STRUCT;
  Perm->Ambigs = Ambigs;
  Perm->FontinfoId = Config->FontinfoId;
 
  // Free memory associated with temporary config (since ADAPTED_CONFIG
  // is a union we need to clean up before we record permanent config).
  ProtoKey.Templates = Templates;
  ProtoKey.ClassId = ClassId;
  ProtoKey.ConfigId = ConfigId;
  Class->TempProtos = delete_d(Class->TempProtos, &ProtoKey, MakeTempProtoPerm);
  delete Config;
 
  // Record permanent config.
  PermConfigFor(Class, ConfigId) = Perm;
 
  if (classify_learning_debug_level >= 1) {
    tprintf(
        "Making config %d for %s (ClassId %d) permanent:"
        " fontinfo id %d, ambiguities '",
        ConfigId, getDict().getUnicharset().debug_str(ClassId).c_str(), ClassId,
        PermConfigFor(Class, ConfigId)->FontinfoId);
    for (UNICHAR_ID *AmbigsPointer = Ambigs; *AmbigsPointer >= 0; ++AmbigsPointer) {
      tprintf("%s", unicharset.id_to_unichar(*AmbigsPointer));
    }
    tprintf("'.\n");
  }
} /* MakePermanent */

MasterMatcher()

void tesseract::Classify::MasterMatcher	(	INT_TEMPLATES_STRUCT *	templates,
		int16_t	num_features,
		const INT_FEATURE_STRUCT *	features,
		const uint8_t *	norm_factors,
		ADAPT_CLASS_STRUCT **	classes,
		int	debug,
		int	matcher_multiplier,
		const TBOX &	blob_box,
		const std::vector< CP_RESULT_STRUCT > &	results,
		ADAPT_RESULTS *	final_results
	)

Factored-out calls to IntegerMatcher based on class pruner results. Returns integer matcher results inside CLASS_PRUNER_RESULTS structure.

Definition at line 1074 of file adaptmatch.cpp.

                                                           {
  int top = blob_box.top();
  int bottom = blob_box.bottom();
  UnicharRating int_result;
  for (auto &&result : results) {
    CLASS_ID class_id = result.Class;
    BIT_VECTOR protos = classes != nullptr ? classes[class_id]->PermProtos : AllProtosOn;
    BIT_VECTOR configs = classes != nullptr ? classes[class_id]->PermConfigs : AllConfigsOn;
 
    int_result.unichar_id = class_id;
    im_.Match(ClassForClassId(templates, class_id), protos, configs, num_features, features,
              &int_result, classify_adapt_feature_threshold, debug, matcher_debug_separate_windows);
    bool is_debug = matcher_debug_level >= 2 || classify_debug_level > 1;
    ExpandShapesAndApplyCorrections(classes, is_debug, class_id, bottom, top, result.Rating,
                                    final_results->BlobLength, matcher_multiplier, norm_factors,
                                    &int_result, final_results);
  }
}

NormalizeOutlines()

void tesseract::Classify::NormalizeOutlines	(	LIST	Outlines,
		float *	XScale,
		float *	YScale
	)

This routine normalizes every outline in Outlines according to the currently selected normalization method. It also returns the scale factors that it used to do this scaling. The scale factors returned represent the x and y sizes in the normalized coordinate system that correspond to 1 pixel in the original coordinate system. Outlines are changed and XScale and YScale are updated.

Globals:

• classify_norm_method method being used for normalization
• classify_char_norm_range map radius of gyration to this value

  Parameters

  Outlines	list of outlines to be normalized
  XScale	x-direction scale factor used by routine
  YScale	y-direction scale factor used by routine

Definition at line 249 of file mfoutline.cpp.

                                                                            {
  MFOUTLINE Outline;
 
  switch (classify_norm_method) {
    case character:
      ASSERT_HOST(!"How did NormalizeOutlines get called in character mode?");
      break;
 
    case baseline:
      iterate(Outlines) {
        Outline = static_cast<MFOUTLINE>(Outlines->first_node());
        NormalizeOutline(Outline, 0.0);
      }
      *XScale = *YScale = MF_SCALE_FACTOR;
      break;
  }
} /* NormalizeOutlines */

PrintAdaptedTemplates()

void tesseract::Classify::PrintAdaptedTemplates	(	FILE *	File,
		ADAPT_TEMPLATES_STRUCT *	Templates
	)

This routine prints a summary of the adapted templates in Templates to File.

Parameters

File	open text file to print Templates to
Templates	adapted templates to print to File

Note

Globals: none

Definition at line 153 of file adaptive.cpp.

                                                                                  {
  INT_CLASS_STRUCT *IClass;
  ADAPT_CLASS_STRUCT *AClass;
 
  fprintf(File, "\n\nSUMMARY OF ADAPTED TEMPLATES:\n\n");
  fprintf(File, "Num classes = %d;  Num permanent classes = %d\n\n", Templates->NumNonEmptyClasses,
          Templates->NumPermClasses);
  fprintf(File, "   Id  NC NPC  NP NPP\n");
  fprintf(File, "------------------------\n");
 
  for (unsigned i = 0; i < (Templates->Templates)->NumClasses; i++) {
    IClass = Templates->Templates->Class[i];
    AClass = Templates->Class[i];
    if (!IsEmptyAdaptedClass(AClass)) {
      fprintf(File, "%5u  %s %3d %3d %3d %3zd\n", i, unicharset.id_to_unichar(i), IClass->NumConfigs,
              AClass->NumPermConfigs, IClass->NumProtos,
              IClass->NumProtos - AClass->TempProtos->size());
    }
  }
  fprintf(File, "\n");
 
} /* PrintAdaptedTemplates */

PrintAdaptiveMatchResults()

void tesseract::Classify::PrintAdaptiveMatchResults

(

const ADAPT_RESULTS &

results

)

This routine writes the matches in Results to File.

Parameters

results

match results to write to File

Globals: none

Definition at line 1922 of file adaptmatch.cpp.

                                                                     {
  for (auto &it : results.match) {
    tprintf("%s  ", unicharset.debug_str(it.unichar_id).c_str());
    it.Print();
  }
} /* PrintAdaptiveMatchResults */

PruneClasses()

int tesseract::Classify::PruneClasses	(	const INT_TEMPLATES_STRUCT *	int_templates,
		int	num_features,
		int	keep_this,
		const INT_FEATURE_STRUCT *	features,
		const uint8_t *	normalization_factors,
		const uint16_t *	expected_num_features,
		std::vector< CP_RESULT_STRUCT > *	results
	)

Runs the class pruner from int_templates on the given features, returning the number of classes output in results.

Parameters

int_templates	Class pruner tables
num_features	Number of features in blob
features	Array of features
normalization_factors	Array of fudge factors from blob normalization process (by CLASS_INDEX)
expected_num_features	Array of expected number of features for each class (by CLASS_INDEX)
results	Sorted Array of pruned classes. Must be an array of size at least int_templates->NumClasses.
keep_this

Definition at line 427 of file intmatcher.cpp.

                                                                 {
  ClassPruner pruner(int_templates->NumClasses);
  // Compute initial match scores for all classes.
  pruner.ComputeScores(int_templates, num_features, features);
  // Adjust match scores for number of expected features.
  pruner.AdjustForExpectedNumFeatures(expected_num_features, classify_cp_cutoff_strength);
  // Apply disabled classes in unicharset - only works without a shape_table.
  if (shape_table_ == nullptr) {
    pruner.DisableDisabledClasses(unicharset);
  }
  // If fragments are disabled, remove them, also only without a shape table.
  if (disable_character_fragments && shape_table_ == nullptr) {
    pruner.DisableFragments(unicharset);
  }
 
  // If we have good x-heights, apply the given normalization factors.
  if (normalization_factors != nullptr) {
    pruner.NormalizeForXheight(classify_class_pruner_multiplier, normalization_factors);
  } else {
    pruner.NoNormalization();
  }
  // Do the actual pruning and sort the short-list.
  pruner.PruneAndSort(classify_class_pruner_threshold, keep_this, shape_table_ == nullptr,
                      unicharset);
 
  if (classify_debug_level > 2) {
    pruner.DebugMatch(*this, int_templates, features);
  }
  if (classify_debug_level > 1) {
    pruner.SummarizeResult(*this, int_templates, expected_num_features,
                           classify_class_pruner_multiplier, normalization_factors);
  }
  // Convert to the expected output format.
  return pruner.SetupResults(results);
}

ReadAdaptedTemplates()

ADAPT_TEMPLATES_STRUCT * tesseract::Classify::ReadAdaptedTemplates

(

TFile *

fp

)

Read a set of adapted templates from file and return a ptr to the templates.

Parameters

fp	open text file to read adapted templates from

Returns

Ptr to adapted templates read from file.

Note

Globals: none

Definition at line 235 of file adaptive.cpp.

                                                                {
  auto Templates = new ADAPT_TEMPLATES_STRUCT;
 
  /* first read the high level adaptive template struct */
  fp->FRead(Templates, sizeof(ADAPT_TEMPLATES_STRUCT), 1);
 
  /* then read in the basic integer templates */
  Templates->Templates = ReadIntTemplates(fp);
 
  /* then read in the adaptive info for each class */
  for (unsigned i = 0; i < (Templates->Templates)->NumClasses; i++) {
    Templates->Class[i] = ReadAdaptedClass(fp);
  }
  return (Templates);
 
} /* ReadAdaptedTemplates */

ReadIntTemplates()

INT_TEMPLATES_STRUCT * tesseract::Classify::ReadIntTemplates

(

TFile *

fp

)

This routine reads a set of integer templates from File. File must already be open and must be in the correct binary format.

Parameters

fp	open file to read templates from

Returns

Pointer to integer templates read from File.

Note

Globals: none

Definition at line 629 of file intproto.cpp.

                                                          {
  int j, w, x, y, z;
  INT_TEMPLATES_STRUCT *Templates;
  CLASS_PRUNER_STRUCT *Pruner;
  INT_CLASS_STRUCT *Class;
 
  /* variables for conversion from older inttemp formats */
  int b, bit_number, last_cp_bit_number, new_b, new_i, new_w;
  CLASS_ID class_id, max_class_id;
  std::vector<CLASS_ID> ClassIdFor(MAX_NUM_CLASSES);
  std::vector<CLASS_PRUNER_STRUCT *> TempClassPruner(MAX_NUM_CLASS_PRUNERS);
  uint32_t SetBitsForMask =          // word with NUM_BITS_PER_CLASS
      (1 << NUM_BITS_PER_CLASS) - 1; // set starting at bit 0
  uint32_t Mask, NewMask, ClassBits;
  unsigned MaxNumConfigs = MAX_NUM_CONFIGS;
  unsigned WerdsPerConfigVec = WERDS_PER_CONFIG_VEC;
 
  /* first read the high level template struct */
  Templates = new INT_TEMPLATES_STRUCT;
  // Read Templates in parts for 64 bit compatibility.
  uint32_t unicharset_size;
  if (fp->FReadEndian(&unicharset_size, sizeof(unicharset_size), 1) != 1) {
    tprintf("Bad read of inttemp!\n");
  }
  int32_t version_id = 0;
  if (fp->FReadEndian(&version_id, sizeof(version_id), 1) != 1 ||
      fp->FReadEndian(&Templates->NumClassPruners, sizeof(Templates->NumClassPruners), 1) != 1) {
    tprintf("Bad read of inttemp!\n");
  }
  if (version_id < 0) {
    // This file has a version id!
    version_id = -version_id;
    if (fp->FReadEndian(&Templates->NumClasses, sizeof(Templates->NumClasses), 1) != 1) {
      tprintf("Bad read of inttemp!\n");
    }
  } else {
    Templates->NumClasses = version_id;
  }
 
  if (version_id < 3) {
    MaxNumConfigs = OLD_MAX_NUM_CONFIGS;
    WerdsPerConfigVec = OLD_WERDS_PER_CONFIG_VEC;
  }
 
  if (version_id < 2) {
    std::vector<int16_t> IndexFor(MAX_NUM_CLASSES);
    if (fp->FReadEndian(&IndexFor[0], sizeof(IndexFor[0]), unicharset_size) != unicharset_size) {
      tprintf("Bad read of inttemp!\n");
    }
    if (fp->FReadEndian(&ClassIdFor[0], sizeof(ClassIdFor[0]), Templates->NumClasses) !=
        Templates->NumClasses) {
      tprintf("Bad read of inttemp!\n");
    }
  }
 
  /* then read in the class pruners */
  const unsigned kNumBuckets = NUM_CP_BUCKETS * NUM_CP_BUCKETS * NUM_CP_BUCKETS * WERDS_PER_CP_VECTOR;
  for (unsigned i = 0; i < Templates->NumClassPruners; i++) {
    Pruner = new CLASS_PRUNER_STRUCT;
    if (fp->FReadEndian(Pruner, sizeof(Pruner->p[0][0][0][0]), kNumBuckets) != kNumBuckets) {
      tprintf("Bad read of inttemp!\n");
    }
    if (version_id < 2) {
      TempClassPruner[i] = Pruner;
    } else {
      Templates->ClassPruners[i] = Pruner;
    }
  }
 
  /* fix class pruners if they came from an old version of inttemp */
  if (version_id < 2) {
    // Allocate enough class pruners to cover all the class ids.
    max_class_id = 0;
    for (unsigned i = 0; i < Templates->NumClasses; i++) {
      if (ClassIdFor[i] > max_class_id) {
        max_class_id = ClassIdFor[i];
      }
    }
    for (int i = 0; i <= CPrunerIdFor(max_class_id); i++) {
      Templates->ClassPruners[i] = new CLASS_PRUNER_STRUCT;
      memset(Templates->ClassPruners[i], 0, sizeof(CLASS_PRUNER_STRUCT));
    }
    // Convert class pruners from the old format (indexed by class index)
    // to the new format (indexed by class id).
    last_cp_bit_number = NUM_BITS_PER_CLASS * Templates->NumClasses - 1;
    for (unsigned i = 0; i < Templates->NumClassPruners; i++) {
      for (x = 0; x < NUM_CP_BUCKETS; x++) {
        for (y = 0; y < NUM_CP_BUCKETS; y++) {
          for (z = 0; z < NUM_CP_BUCKETS; z++) {
            for (w = 0; w < WERDS_PER_CP_VECTOR; w++) {
              if (TempClassPruner[i]->p[x][y][z][w] == 0) {
                continue;
              }
              for (b = 0; b < BITS_PER_WERD; b += NUM_BITS_PER_CLASS) {
                bit_number = i * BITS_PER_CP_VECTOR + w * BITS_PER_WERD + b;
                if (bit_number > last_cp_bit_number) {
                  break; // the rest of the bits in this word are not used
                }
                class_id = ClassIdFor[bit_number / NUM_BITS_PER_CLASS];
                // Single out NUM_BITS_PER_CLASS bits relating to class_id.
                Mask = SetBitsForMask << b;
                ClassBits = TempClassPruner[i]->p[x][y][z][w] & Mask;
                // Move these bits to the new position in which they should
                // appear (indexed corresponding to the class_id).
                new_i = CPrunerIdFor(class_id);
                new_w = CPrunerWordIndexFor(class_id);
                new_b = CPrunerBitIndexFor(class_id) * NUM_BITS_PER_CLASS;
                if (new_b > b) {
                  ClassBits <<= (new_b - b);
                } else {
                  ClassBits >>= (b - new_b);
                }
                // Copy bits relating to class_id to the correct position
                // in Templates->ClassPruner.
                NewMask = SetBitsForMask << new_b;
                Templates->ClassPruners[new_i]->p[x][y][z][new_w] &= ~NewMask;
                Templates->ClassPruners[new_i]->p[x][y][z][new_w] |= ClassBits;
              }
            }
          }
        }
      }
    }
    for (unsigned i = 0; i < Templates->NumClassPruners; i++) {
      delete TempClassPruner[i];
    }
  }
 
  /* then read in each class */
  for (unsigned i = 0; i < Templates->NumClasses; i++) {
    /* first read in the high level struct for the class */
    Class = new INT_CLASS_STRUCT;
    if (fp->FReadEndian(&Class->NumProtos, sizeof(Class->NumProtos), 1) != 1 ||
        fp->FRead(&Class->NumProtoSets, sizeof(Class->NumProtoSets), 1) != 1 ||
        fp->FRead(&Class->NumConfigs, sizeof(Class->NumConfigs), 1) != 1) {
      tprintf("Bad read of inttemp!\n");
    }
    if (version_id == 0) {
      // Only version 0 writes 5 pointless pointers to the file.
      for (j = 0; j < 5; ++j) {
        int32_t junk;
        if (fp->FRead(&junk, sizeof(junk), 1) != 1) {
          tprintf("Bad read of inttemp!\n");
        }
      }
    }
    unsigned num_configs = version_id < 4 ? MaxNumConfigs : Class->NumConfigs;
    ASSERT_HOST(num_configs <= MaxNumConfigs);
    if (fp->FReadEndian(Class->ConfigLengths, sizeof(uint16_t), num_configs) != num_configs) {
      tprintf("Bad read of inttemp!\n");
    }
    if (version_id < 2) {
      ClassForClassId(Templates, ClassIdFor[i]) = Class;
    } else {
      ClassForClassId(Templates, i) = Class;
    }
 
    /* then read in the proto lengths */
    Class->ProtoLengths.clear();
    if (MaxNumIntProtosIn(Class) > 0) {
      Class->ProtoLengths.resize(MaxNumIntProtosIn(Class));
      if (fp->FRead(&Class->ProtoLengths[0], sizeof(uint8_t), MaxNumIntProtosIn(Class)) !=
          MaxNumIntProtosIn(Class)) {
        tprintf("Bad read of inttemp!\n");
      }
    }
 
    /* then read in the proto sets */
    for (j = 0; j < Class->NumProtoSets; j++) {
      auto ProtoSet = new PROTO_SET_STRUCT;
      unsigned num_buckets = NUM_PP_PARAMS * NUM_PP_BUCKETS * WERDS_PER_PP_VECTOR;
      if (fp->FReadEndian(&ProtoSet->ProtoPruner, sizeof(ProtoSet->ProtoPruner[0][0][0]),
                          num_buckets) != num_buckets) {
        tprintf("Bad read of inttemp!\n");
      }
      for (x = 0; x < PROTOS_PER_PROTO_SET; x++) {
        if (fp->FRead(&ProtoSet->Protos[x].A, sizeof(ProtoSet->Protos[x].A), 1) != 1 ||
            fp->FRead(&ProtoSet->Protos[x].B, sizeof(ProtoSet->Protos[x].B), 1) != 1 ||
            fp->FRead(&ProtoSet->Protos[x].C, sizeof(ProtoSet->Protos[x].C), 1) != 1 ||
            fp->FRead(&ProtoSet->Protos[x].Angle, sizeof(ProtoSet->Protos[x].Angle), 1) != 1) {
          tprintf("Bad read of inttemp!\n");
        }
        if (fp->FReadEndian(&ProtoSet->Protos[x].Configs, sizeof(ProtoSet->Protos[x].Configs[0]),
                            WerdsPerConfigVec) != WerdsPerConfigVec) {
          tprintf("Bad read of inttemp!\n");
        }
      }
      Class->ProtoSets[j] = ProtoSet;
    }
    if (version_id < 4) {
      Class->font_set_id = -1;
    } else {
      fp->FReadEndian(&Class->font_set_id, sizeof(Class->font_set_id), 1);
    }
  }
 
  if (version_id < 2) {
    /* add an empty nullptr class with class id 0 */
    assert(UnusedClassIdIn(Templates, 0));
    ClassForClassId(Templates, 0) = new INT_CLASS_STRUCT(1, 1);
    ClassForClassId(Templates, 0)->font_set_id = -1;
    Templates->NumClasses++;
    /* make sure the classes are contiguous */
    for (unsigned i = 0; i < MAX_NUM_CLASSES; i++) {
      if (i < Templates->NumClasses) {
        if (ClassForClassId(Templates, i) == nullptr) {
          fprintf(stderr, "Non-contiguous class ids in inttemp\n");
          exit(1);
        }
      } else {
        if (ClassForClassId(Templates, i) != nullptr) {
          fprintf(stderr, "Class id %u exceeds NumClassesIn (Templates) %u\n", i,
                  Templates->NumClasses);
          exit(1);
        }
      }
    }
  }
  if (version_id >= 4) {
    using namespace std::placeholders; // for _1, _2
    this->fontinfo_table_.read(fp, std::bind(read_info, _1, _2));
    if (version_id >= 5) {
      this->fontinfo_table_.read(fp, std::bind(read_spacing_info, _1, _2));
    }
    this->fontset_table_.read(fp, [](auto *f, auto *fs) { return f->DeSerialize(*fs); } );
  }
 
  return (Templates);
} /* ReadIntTemplates */

ReadNewCutoffs()

void tesseract::Classify::ReadNewCutoffs	(	TFile *	fp,
		uint16_t *	Cutoffs
	)

Open file, read in all of the class-id/cutoff pairs and insert them into the Cutoffs array. Cutoffs are indexed in the array by class id. Unused entries in the array are set to an arbitrarily high cutoff value.

Parameters

fp	file containing cutoff definitions
Cutoffs	array to put cutoffs into

Definition at line 41 of file cutoffs.cpp.

                                                          {
  int Cutoff;
 
  if (shape_table_ != nullptr) {
    if (!fp->DeSerialize(shapetable_cutoffs_)) {
      tprintf("Error during read of shapetable pffmtable!\n");
    }
  }
  for (int i = 0; i < MAX_NUM_CLASSES; i++) {
    Cutoffs[i] = MAX_CUTOFF;
  }
 
  const int kMaxLineSize = 100;
  char line[kMaxLineSize];
  while (fp->FGets(line, kMaxLineSize) != nullptr) {
    std::string Class;
    CLASS_ID ClassId;
    std::istringstream stream(line);
    stream.imbue(std::locale::classic());
    stream >> Class >> Cutoff;
    if (stream.fail()) {
      break;
    }
    if (Class.compare("NULL") == 0) {
      ClassId = unicharset.unichar_to_id(" ");
    } else {
      ClassId = unicharset.unichar_to_id(Class.c_str());
    }
    ASSERT_HOST(ClassId >= 0 && ClassId < MAX_NUM_CLASSES);
    Cutoffs[ClassId] = Cutoff;
  }
}

ReadNormProtos()

NORM_PROTOS * tesseract::Classify::ReadNormProtos

(

TFile *

fp

)

This routine allocates a new data structure to hold a set of character normalization protos. It then fills in the data structure by reading from the specified File.

Parameters

fp	open text file to read normalization protos from Globals: none

Returns

Character normalization protos.

Definition at line 173 of file normmatch.cpp.

                                               {
  char unichar[2 * UNICHAR_LEN + 1];
  UNICHAR_ID unichar_id;
  LIST Protos;
  int NumProtos;
 
  /* allocate and initialization data structure */
  auto NormProtos = new NORM_PROTOS(unicharset.size());
 
  /* read file header and save in data structure */
  NormProtos->NumParams = ReadSampleSize(fp);
  NormProtos->ParamDesc = ReadParamDesc(fp, NormProtos->NumParams);
 
  /* read protos for each class into a separate list */
  const int kMaxLineSize = 100;
  char line[kMaxLineSize];
  while (fp->FGets(line, kMaxLineSize) != nullptr) {
    std::istringstream stream(line);
    stream.imbue(std::locale::classic());
    stream >> unichar >> NumProtos;
    if (stream.fail()) {
      continue;
    }
    if (unicharset.contains_unichar(unichar)) {
      unichar_id = unicharset.unichar_to_id(unichar);
      Protos = NormProtos->Protos[unichar_id];
      for (int i = 0; i < NumProtos; i++) {
        Protos = push_last(Protos, ReadPrototype(fp, NormProtos->NumParams));
      }
      NormProtos->Protos[unichar_id] = Protos;
    } else {
      tprintf("Error: unichar %s in normproto file is not in unichar set.\n", unichar);
      for (int i = 0; i < NumProtos; i++) {
        FreePrototype(ReadPrototype(fp, NormProtos->NumParams));
      }
    }
  }
  return NormProtos;
} /* ReadNormProtos */

RefreshDebugWindow()

void tesseract::Classify::RefreshDebugWindow	(	ScrollView **	win,
		const char *	msg,
		int	y_offset,
		const TBOX &	wbox
	)

Definition at line 240 of file adaptmatch.cpp.

                                                    {
  const int kSampleSpaceWidth = 500;
  if (*win == nullptr) {
    *win = new ScrollView(msg, 100, y_offset, kSampleSpaceWidth * 2, 200, kSampleSpaceWidth * 2,
                          200, true);
  }
  (*win)->Clear();
  (*win)->Pen(64, 64, 64);
  (*win)->Line(-kSampleSpaceWidth, kBlnBaselineOffset, kSampleSpaceWidth, kBlnBaselineOffset);
  (*win)->Line(-kSampleSpaceWidth, kBlnXHeight + kBlnBaselineOffset, kSampleSpaceWidth,
               kBlnXHeight + kBlnBaselineOffset);
  (*win)->ZoomToRectangle(wbox.left(), wbox.top(), wbox.right(), wbox.bottom());
}

RemoveBadMatches()

void tesseract::Classify::RemoveBadMatches

(

ADAPT_RESULTS *

Results

)

This routine steps through each matching class in Results and removes it from the match list if its rating is worse than the BestRating plus a pad. In other words, all good matches get moved to the front of the classes array.

Parameters

Results

contains matches to be filtered

Globals:

• matcher_bad_match_pad defines a "bad match"

Definition at line 1942 of file adaptmatch.cpp.

                                                      {
  unsigned Next, NextGood;
  float BadMatchThreshold;
  static const char *romans = "i v x I V X";
  BadMatchThreshold = Results->best_rating - matcher_bad_match_pad;
 
  if (classify_bln_numeric_mode) {
    UNICHAR_ID unichar_id_one =
        unicharset.contains_unichar("1") ? unicharset.unichar_to_id("1") : -1;
    UNICHAR_ID unichar_id_zero =
        unicharset.contains_unichar("0") ? unicharset.unichar_to_id("0") : -1;
    float scored_one = ScoredUnichar(unichar_id_one, *Results);
    float scored_zero = ScoredUnichar(unichar_id_zero, *Results);
 
    for (Next = NextGood = 0; Next < Results->match.size(); Next++) {
      const UnicharRating &match = Results->match[Next];
      if (match.rating >= BadMatchThreshold) {
        if (!unicharset.get_isalpha(match.unichar_id) ||
            strstr(romans, unicharset.id_to_unichar(match.unichar_id)) != nullptr) {
        } else if (unicharset.eq(match.unichar_id, "l") && scored_one < BadMatchThreshold) {
          Results->match[Next].unichar_id = unichar_id_one;
        } else if (unicharset.eq(match.unichar_id, "O") && scored_zero < BadMatchThreshold) {
          Results->match[Next].unichar_id = unichar_id_zero;
        } else {
          Results->match[Next].unichar_id = INVALID_UNICHAR_ID; // Don't copy.
        }
        if (Results->match[Next].unichar_id != INVALID_UNICHAR_ID) {
          if (NextGood == Next) {
            ++NextGood;
          } else {
            Results->match[NextGood++] = Results->match[Next];
          }
        }
      }
    }
  } else {
    for (Next = NextGood = 0; Next < Results->match.size(); Next++) {
      if (Results->match[Next].rating >= BadMatchThreshold) {
        if (NextGood == Next) {
          ++NextGood;
        } else {
          Results->match[NextGood++] = Results->match[Next];
        }
      }
    }
  }
  Results->match.resize(NextGood);
} /* RemoveBadMatches */

RemoveExtraPuncs()

void tesseract::Classify::RemoveExtraPuncs

(

ADAPT_RESULTS *

Results

)

This routine discards extra digits or punctuation from the results. We keep only the top 2 punctuation answers and the top 1 digit answer if present.

Parameters

Results

contains matches to be filtered

Definition at line 1999 of file adaptmatch.cpp.

                                                      {
  unsigned Next, NextGood;
  int punc_count; /*no of garbage characters */
  int digit_count;
  /*garbage characters */
  static char punc_chars[] = ". , ; : / ` ~ ' - = \\ | \" ! _ ^";
  static char digit_chars[] = "0 1 2 3 4 5 6 7 8 9";
 
  punc_count = 0;
  digit_count = 0;
  for (Next = NextGood = 0; Next < Results->match.size(); Next++) {
    const UnicharRating &match = Results->match[Next];
    bool keep = true;
    if (strstr(punc_chars, unicharset.id_to_unichar(match.unichar_id)) != nullptr) {
      if (punc_count >= 2) {
        keep = false;
      }
      punc_count++;
    } else {
      if (strstr(digit_chars, unicharset.id_to_unichar(match.unichar_id)) != nullptr) {
        if (digit_count >= 1) {
          keep = false;
        }
        digit_count++;
      }
    }
    if (keep) {
      if (NextGood == Next) {
        ++NextGood;
      } else {
        Results->match[NextGood++] = match;
      }
    }
  }
  Results->match.resize(NextGood);
} /* RemoveExtraPuncs */

ResetAdaptiveClassifierInternal()

void tesseract::Classify::ResetAdaptiveClassifierInternal

(

)

Definition at line 596 of file adaptmatch.cpp.

                                               {
  if (classify_learning_debug_level > 0) {
    tprintf("Resetting adaptive classifier (NumAdaptationsFailed=%d)\n", NumAdaptationsFailed);
  }
  delete AdaptedTemplates;
  AdaptedTemplates = new ADAPT_TEMPLATES_STRUCT(unicharset);
  delete BackupAdaptedTemplates;
  BackupAdaptedTemplates = nullptr;
  NumAdaptationsFailed = 0;
}

SetAdaptiveThreshold()

void tesseract::Classify::SetAdaptiveThreshold

(

float

Threshold

)

This routine resets the internal thresholds inside the integer matcher to correspond to the specified threshold.

Parameters

Threshold

threshold for creating new templates

Globals:

• matcher_good_threshold default good match rating

Definition at line 2047 of file adaptmatch.cpp.

                                                   {
  Threshold = (Threshold == matcher_good_threshold) ? 0.9f : (1 - Threshold);
  classify_adapt_proto_threshold.set_value(ClipToRange<int>(255 * Threshold, 0, 255));
  classify_adapt_feature_threshold.set_value(ClipToRange<int>(255 * Threshold, 0, 255));
} /* SetAdaptiveThreshold */

SetStaticClassifier()

void tesseract::Classify::SetStaticClassifier

(

ShapeClassifier *

static_classifier

)

Definition at line 161 of file classify.cpp.

                                                                     {
  delete static_classifier_;
  static_classifier_ = static_classifier;
}

SettupPass1()

void tesseract::Classify::SettupPass1

(

)

This routine prepares the adaptive matcher for the start of the first pass. Learning is enabled (unless it is disabled for the whole program).

Note

this is somewhat redundant, it simply says that if learning is enabled then it will remain enabled on the first pass. If it is disabled, then it will remain disabled. This is only put here to make it very clear that learning is controlled directly by the global setting of EnableLearning.

Globals:

• EnableLearning set to true by this routine

Definition at line 647 of file adaptmatch.cpp.

                           {
  EnableLearning = classify_enable_learning;
 
  getDict().SettupStopperPass1();
 
} /* SettupPass1 */

SettupPass2()

void tesseract::Classify::SettupPass2

(

)

This routine prepares the adaptive matcher for the start of the second pass. Further learning is disabled.

Globals:

• EnableLearning set to false by this routine

Definition at line 663 of file adaptmatch.cpp.

                           {
  EnableLearning = false;
  getDict().SettupStopperPass2();
 
} /* SettupPass2 */

SetupBLCNDenorms()

void tesseract::Classify::SetupBLCNDenorms ( const TBLOB &  blob, bool  nonlinear_norm, DENORM *  bl_denorm, DENORM *  cn_denorm, INT_FX_RESULT_STRUCT *  fx_info  )

static

Definition at line 129 of file intfx.cpp.

                                                                                  {
  // Compute 1st and 2nd moments of the original outline.
  FCOORD center, second_moments;
  int length = blob.ComputeMoments(&center, &second_moments);
  if (fx_info != nullptr) {
    fx_info->Length = length;
    fx_info->Rx = IntCastRounded(second_moments.y());
    fx_info->Ry = IntCastRounded(second_moments.x());
 
    fx_info->Xmean = IntCastRounded(center.x());
    fx_info->Ymean = IntCastRounded(center.y());
  }
  // Setup the denorm for Baseline normalization.
  bl_denorm->SetupNormalization(nullptr, nullptr, &blob.denorm(), center.x(), 128.0f, 1.0f, 1.0f,
                                128.0f, 128.0f);
  // Setup the denorm for character normalization.
  if (nonlinear_norm) {
    std::vector<std::vector<int>> x_coords;
    std::vector<std::vector<int>> y_coords;
    TBOX box;
    blob.GetPreciseBoundingBox(&box);
    box.pad(1, 1);
    blob.GetEdgeCoords(box, x_coords, y_coords);
    cn_denorm->SetupNonLinear(&blob.denorm(), box, UINT8_MAX, UINT8_MAX, 0.0f, 0.0f, x_coords,
                              y_coords);
  } else {
    cn_denorm->SetupNormalization(nullptr, nullptr, &blob.denorm(), center.x(), center.y(),
                                  51.2f / second_moments.x(), 51.2f / second_moments.y(), 128.0f,
                                  128.0f);
  }
}

shape_table()

const ShapeTable * tesseract::Classify::shape_table ( ) const

inline

Definition at line 102 of file classify.h.

                                        {
    return shape_table_;
  }

ShapeIDToClassID()

int tesseract::Classify::ShapeIDToClassID

(

int

shape_id

)

const

Definition at line 2121 of file adaptmatch.cpp.

                                                 {
  for (unsigned id = 0; id < PreTrainedTemplates->NumClasses; ++id) {
    int font_set_id = PreTrainedTemplates->Class[id]->font_set_id;
    ASSERT_HOST(font_set_id >= 0);
    const FontSet &fs = fontset_table_.at(font_set_id);
    for (auto f : fs) {
      if (f == shape_id) {
        return id;
      }
    }
  }
  tprintf("Shape %d not found\n", shape_id);
  return -1;
}

ShowBestMatchFor()

void tesseract::Classify::ShowBestMatchFor	(	int	shape_id,
		const INT_FEATURE_STRUCT *	features,
		int	num_features
	)

This routine displays debug information for the best config of the given shape_id for the given set of features.

Parameters

shape_id	classifier id to work with
features	features of the unknown character
num_features	Number of features in the features array.

Definition at line 2065 of file adaptmatch.cpp.

                                                  {
  uint32_t config_mask;
  if (UnusedClassIdIn(PreTrainedTemplates, shape_id)) {
    tprintf("No built-in templates for class/shape %d\n", shape_id);
    return;
  }
  if (num_features <= 0) {
    tprintf("Illegal blob (char norm features)!\n");
    return;
  }
  UnicharRating cn_result;
  classify_norm_method.set_value(character);
  im_.Match(ClassForClassId(PreTrainedTemplates, shape_id), AllProtosOn, AllConfigsOn, num_features,
            features, &cn_result, classify_adapt_feature_threshold, NO_DEBUG,
            matcher_debug_separate_windows);
  tprintf("\n");
  config_mask = 1 << cn_result.config;
 
  tprintf("Static Shape ID: %d\n", shape_id);
  ShowMatchDisplay();
  im_.Match(ClassForClassId(PreTrainedTemplates, shape_id), AllProtosOn, &config_mask, num_features,
            features, &cn_result, classify_adapt_feature_threshold, matcher_debug_flags,
            matcher_debug_separate_windows);
  UpdateMatchDisplay();
} /* ShowBestMatchFor */

ShowMatchDisplay()

void tesseract::Classify::ShowMatchDisplay

(

)

This routine sends the shapes in the global display lists to the match debugger window.

Globals:

• FeatureShapes display list containing feature matches
• ProtoShapes display list containing proto matches

Definition at line 868 of file intproto.cpp.

                                {
  InitIntMatchWindowIfReqd();
  if (ProtoDisplayWindow) {
    ProtoDisplayWindow->Clear();
  }
  if (FeatureDisplayWindow) {
    FeatureDisplayWindow->Clear();
  }
  ClearFeatureSpaceWindow(static_cast<NORM_METHOD>(static_cast<int>(classify_norm_method)),
                          IntMatchWindow);
  IntMatchWindow->ZoomToRectangle(INT_MIN_X, INT_MIN_Y, INT_MAX_X, INT_MAX_Y);
  if (ProtoDisplayWindow) {
    ProtoDisplayWindow->ZoomToRectangle(INT_MIN_X, INT_MIN_Y, INT_MAX_X, INT_MAX_Y);
  }
  if (FeatureDisplayWindow) {
    FeatureDisplayWindow->ZoomToRectangle(INT_MIN_X, INT_MIN_Y, INT_MAX_X, INT_MAX_Y);
  }
} /* ShowMatchDisplay */

StartBackupAdaptiveClassifier()

void tesseract::Classify::StartBackupAdaptiveClassifier

(

)

Definition at line 625 of file adaptmatch.cpp.

                                             {
  delete BackupAdaptedTemplates;
  BackupAdaptedTemplates = new ADAPT_TEMPLATES_STRUCT(unicharset);
}

STRING_VAR_H()

tesseract::Classify::STRING_VAR_H

(

classify_learn_debug_str

)

SwitchAdaptiveClassifier()

void tesseract::Classify::SwitchAdaptiveClassifier

(

)

Definition at line 609 of file adaptmatch.cpp.

                                        {
  if (BackupAdaptedTemplates == nullptr) {
    ResetAdaptiveClassifierInternal();
    return;
  }
  if (classify_learning_debug_level > 0) {
    tprintf("Switch to backup adaptive classifier (NumAdaptationsFailed=%d)\n",
            NumAdaptationsFailed);
  }
  delete AdaptedTemplates;
  AdaptedTemplates = BackupAdaptedTemplates;
  BackupAdaptedTemplates = nullptr;
  NumAdaptationsFailed = 0;
}

TempConfigReliable()

bool tesseract::Classify::TempConfigReliable	(	CLASS_ID	class_id,
		const TEMP_CONFIG_STRUCT *	config
	)

Definition at line 2138 of file adaptmatch.cpp.

                                                                                     {
  if (classify_learning_debug_level >= 1) {
    tprintf("NumTimesSeen for config of %s is %d\n",
            getDict().getUnicharset().debug_str(class_id).c_str(), config->NumTimesSeen);
  }
  if (config->NumTimesSeen >= matcher_sufficient_examples_for_prototyping) {
    return true;
  } else if (config->NumTimesSeen < matcher_min_examples_for_prototyping) {
    return false;
  } else if (use_ambigs_for_adaption) {
    // Go through the ambigs vector and see whether we have already seen
    // enough times all the characters represented by the ambigs vector.
    const UnicharIdVector *ambigs = getDict().getUnicharAmbigs().AmbigsForAdaption(class_id);
    int ambigs_size = (ambigs == nullptr) ? 0 : ambigs->size();
    for (int ambig = 0; ambig < ambigs_size; ++ambig) {
      ADAPT_CLASS_STRUCT *ambig_class = AdaptedTemplates->Class[(*ambigs)[ambig]];
      assert(ambig_class != nullptr);
      if (ambig_class->NumPermConfigs == 0 &&
          ambig_class->MaxNumTimesSeen < matcher_min_examples_for_prototyping) {
        if (classify_learning_debug_level >= 1) {
          tprintf(
              "Ambig %s has not been seen enough times,"
              " not making config for %s permanent\n",
              getDict().getUnicharset().debug_str((*ambigs)[ambig]).c_str(),
              getDict().getUnicharset().debug_str(class_id).c_str());
        }
        return false;
      }
    }
  }
  return true;
}

UpdateAmbigsGroup()

void tesseract::Classify::UpdateAmbigsGroup	(	CLASS_ID	class_id,
		TBLOB *	Blob
	)

Definition at line 2171 of file adaptmatch.cpp.

                                                               {
  const UnicharIdVector *ambigs = getDict().getUnicharAmbigs().ReverseAmbigsForAdaption(class_id);
  int ambigs_size = (ambigs == nullptr) ? 0 : ambigs->size();
  if (classify_learning_debug_level >= 1) {
    tprintf("Running UpdateAmbigsGroup for %s class_id=%d\n",
            getDict().getUnicharset().debug_str(class_id).c_str(), class_id);
  }
  for (int ambig = 0; ambig < ambigs_size; ++ambig) {
    CLASS_ID ambig_class_id = (*ambigs)[ambig];
    const ADAPT_CLASS_STRUCT *ambigs_class = AdaptedTemplates->Class[ambig_class_id];
    for (int cfg = 0; cfg < MAX_NUM_CONFIGS; ++cfg) {
      if (ConfigIsPermanent(ambigs_class, cfg)) {
        continue;
      }
      const TEMP_CONFIG_STRUCT *config = TempConfigFor(AdaptedTemplates->Class[ambig_class_id], cfg);
      if (config != nullptr && TempConfigReliable(ambig_class_id, config)) {
        if (classify_learning_debug_level >= 1) {
          tprintf("Making config %d of %s permanent\n", cfg,
                  getDict().getUnicharset().debug_str(ambig_class_id).c_str());
        }
        MakePermanent(AdaptedTemplates, ambig_class_id, cfg, Blob);
      }
    }
  }
}

WriteAdaptedTemplates()

void tesseract::Classify::WriteAdaptedTemplates	(	FILE *	File,
		ADAPT_TEMPLATES_STRUCT *	Templates
	)

This routine saves Templates to File in a binary format.

Parameters

File	open text file to write Templates to
Templates	set of adapted templates to write to File

Note

Globals: none

Definition at line 345 of file adaptive.cpp.

                                                                                  {
  /* first write the high level adaptive template struct */
  fwrite(Templates, sizeof(ADAPT_TEMPLATES_STRUCT), 1, File);
 
  /* then write out the basic integer templates */
  WriteIntTemplates(File, Templates->Templates, unicharset);
 
  /* then write out the adaptive info for each class */
  for (unsigned i = 0; i < (Templates->Templates)->NumClasses; i++) {
    WriteAdaptedClass(File, Templates->Class[i], Templates->Templates->Class[i]->NumConfigs);
  }
} /* WriteAdaptedTemplates */

WriteIntTemplates()

void tesseract::Classify::WriteIntTemplates	(	FILE *	File,
		INT_TEMPLATES_STRUCT *	Templates,
		const UNICHARSET &	target_unicharset
	)

This routine writes Templates to File. The format is an efficient binary format. File must already be open for writing.

Parameters

File	open file to write templates to
Templates	templates to save into File
target_unicharset	the UNICHARSET to use

Definition at line 919 of file intproto.cpp.

                                                                      {
  INT_CLASS_STRUCT *Class;
  uint32_t unicharset_size = target_unicharset.size();
  int version_id = -5; // When negated by the reader -1 becomes +1 etc.
 
  if (Templates->NumClasses != unicharset_size) {
    tprintf(
        "Warning: executing WriteIntTemplates() with %d classes in"
        " Templates, while target_unicharset size is %" PRIu32 "\n",
        Templates->NumClasses, unicharset_size);
  }
 
  /* first write the high level template struct */
  fwrite(&unicharset_size, sizeof(unicharset_size), 1, File);
  fwrite(&version_id, sizeof(version_id), 1, File);
  fwrite(&Templates->NumClassPruners, sizeof(Templates->NumClassPruners), 1, File);
  fwrite(&Templates->NumClasses, sizeof(Templates->NumClasses), 1, File);
 
  /* then write out the class pruners */
  for (unsigned i = 0; i < Templates->NumClassPruners; i++) {
    fwrite(Templates->ClassPruners[i], sizeof(CLASS_PRUNER_STRUCT), 1, File);
  }
 
  /* then write out each class */
  for (unsigned i = 0; i < Templates->NumClasses; i++) {
    Class = Templates->Class[i];
 
    /* first write out the high level struct for the class */
    fwrite(&Class->NumProtos, sizeof(Class->NumProtos), 1, File);
    fwrite(&Class->NumProtoSets, sizeof(Class->NumProtoSets), 1, File);
    ASSERT_HOST(Class->NumConfigs == this->fontset_table_.at(Class->font_set_id).size());
    fwrite(&Class->NumConfigs, sizeof(Class->NumConfigs), 1, File);
    for (int j = 0; j < Class->NumConfigs; ++j) {
      fwrite(&Class->ConfigLengths[j], sizeof(uint16_t), 1, File);
    }
 
    /* then write out the proto lengths */
    if (MaxNumIntProtosIn(Class) > 0) {
      fwrite(&Class->ProtoLengths[0], sizeof(uint8_t), MaxNumIntProtosIn(Class), File);
    }
 
    /* then write out the proto sets */
    for (int j = 0; j < Class->NumProtoSets; j++) {
      fwrite(Class->ProtoSets[j], sizeof(PROTO_SET_STRUCT), 1, File);
    }
 
    /* then write the fonts info */
    fwrite(&Class->font_set_id, sizeof(int), 1, File);
  }
 
  /* Write the fonts info tables */
  using namespace std::placeholders; // for _1, _2
  this->fontinfo_table_.write(File, std::bind(write_info, _1, _2));
  this->fontinfo_table_.write(File, std::bind(write_spacing_info, _1, _2));
  this->fontset_table_.write(File, std::bind(write_set, _1, _2));
} /* WriteIntTemplates */

WriteTRFile()

bool tesseract::Classify::WriteTRFile

(

const char *

filename

)

Definition at line 60 of file blobclass.cpp.

                                               {
  bool result = false;
  std::string tr_filename = filename;
  tr_filename += ".tr";
  FILE *fp = fopen(tr_filename.c_str(), "wb");
  if (fp) {
    result = tesseract::Serialize(fp, &tr_file_data_[0], tr_file_data_.length());
    fclose(fp);
  }
  tr_file_data_.resize(0);
  return result;
}

Member Data Documentation

AdaptedTemplates

ADAPT_TEMPLATES_STRUCT* tesseract::Classify::AdaptedTemplates = nullptr

Definition at line 420 of file classify.h.

AllConfigsOff

BIT_VECTOR tesseract::Classify::AllConfigsOff = nullptr

Definition at line 429 of file classify.h.

AllConfigsOn

BIT_VECTOR tesseract::Classify::AllConfigsOn = nullptr

Definition at line 428 of file classify.h.

AllProtosOn

BIT_VECTOR tesseract::Classify::AllProtosOn = nullptr

Definition at line 427 of file classify.h.

BackupAdaptedTemplates

ADAPT_TEMPLATES_STRUCT* tesseract::Classify::BackupAdaptedTemplates = nullptr

Definition at line 424 of file classify.h.

EnableLearning

bool tesseract::Classify::EnableLearning = true

Definition at line 484 of file classify.h.

feature_defs_

FEATURE_DEFS_STRUCT tesseract::Classify::feature_defs_

protected

Definition at line 446 of file classify.h.

fontinfo_table_

UnicityTable<FontInfo> tesseract::Classify::fontinfo_table_

Definition at line 434 of file classify.h.

fontset_table_

UnicityTable<FontSet> tesseract::Classify::fontset_table_

Definition at line 442 of file classify.h.

im_

IntegerMatcher tesseract::Classify::im_

protected

Definition at line 445 of file classify.h.

NormProtos

NORM_PROTOS* tesseract::Classify::NormProtos = nullptr

Definition at line 432 of file classify.h.

PreTrainedTemplates

INT_TEMPLATES_STRUCT* tesseract::Classify::PreTrainedTemplates = nullptr

Definition at line 419 of file classify.h.

shape_table_

ShapeTable* tesseract::Classify::shape_table_ = nullptr

protected

Definition at line 451 of file classify.h.

TempProtoMask

BIT_VECTOR tesseract::Classify::TempProtoMask = nullptr

Definition at line 430 of file classify.h.

---

The documentation for this class was generated from the following files:

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/classify.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/adaptive.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/adaptmatch.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/blobclass.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/classify.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/cutoffs.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/float2int.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/intfx.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/intmatcher.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/intproto.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/mfoutline.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/normmatch.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/outfeat.cpp
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/classify/picofeat.cpp