classify/adaptmatch.cpp File Reference

#include <ctype.h>
#include "adaptmatch.h"
#include "normfeat.h"
#include "mfoutline.h"
#include "picofeat.h"
#include "float2int.h"
#include "outfeat.h"
#include "emalloc.h"
#include "intfx.h"
#include "permnum.h"
#include "speckle.h"
#include "efio.h"
#include "normmatch.h"
#include "stopper.h"
#include "permute.h"
#include "context.h"
#include "ndminx.h"
#include "intproto.h"
#include "const.h"
#include "globals.h"
#include "werd.h"
#include "callcpp.h"
#include "tordvars.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

Go to the source code of this file.

Classes

• struct ADAPT_RESULTS

  Holds results of high level adaptive matcher, companion of PROTO_KEY. More...
  

• struct PROTO_KEY

  Holds ADAPT_TEMPLATES, data from adaptive matcher for all classes) & other info; or enough to identify one prototype. More...
  

Defines

• #define ADAPT_TEMPLATE_SUFFIX   ".a"
• #define ADAPTABLE_WERD   (GOOD_NUMBER + 0.05)
• #define BUILT_IN_CUTOFFS_FILE   "tessdata/pffmtable"
• #define BUILT_IN_TEMPLATES_FILE   "tessdata/inttemp"
• #define InitIntFX()   (FeaturesHaveBeenExtracted = FALSE)
• #define MarginalMatch(Rating)   ((Rating) > GreatAdaptiveMatch)
• #define MAX_ADAPTABLE_WERD_SIZE   40
• #define MAX_MATCHES   10
• #define NO_DEBUG   0
• #define TempConfigReliable(Config)   ((Config)->NumTimesSeen > ReliableConfigThreshold)
• #define UNLIKELY_NUM_FEAT   200
• #define WORST_POSSIBLE_RATING   (1.0)
• #define Y_DIM_OFFSET   (Y_SHIFT - BASELINE_Y_SHIFT)

Functions

• int AdaptableWord (TWERD *Word, const char *BestChoice, const char *BestRawChoice)

  Return TRUE if the specified word is acceptable for adaptation. Rules that apply in general, those simplest to compute come first.
  

• LIST AdaptiveClassifier (TBLOB *Blob, TBLOB *DotBlob, TEXTROW *Row)

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

• void AdaptToChar (TBLOB *Blob, LINE_STATS *LineStats, CLASS_ID ClassId, FLOAT32 Threshold)

  Adapts to character?
  

• void AdaptToPunc (TBLOB *Blob, LINE_STATS *LineStats, CLASS_ID ClassId, FLOAT32 Threshold)

  Adapts to punctuation.
  

• void AdaptToWord (TWERD *Word, TEXTROW *Row, const char *BestChoice, const char *BestRawChoice, const char *rejmap)

  Implements a preliminary version of the rules which are used to decide which characters to adapt to.
  

• void AddNewResult (ADAPT_RESULTS *Results, CLASS_ID ClassId, FLOAT32 Rating, int ConfigId)

  Adds the result of a classification into Results.
  

• void AmbigClassifier (TBLOB *Blob, LINE_STATS *LineStats, INT_TEMPLATES Templates, char *Ambiguities, ADAPT_RESULTS *Results)

  Identical to CharNormClassifier() except that it does no class pruning, simply matches the unknown blob against the classes listed in Ambiguities.
  

• char * BaselineClassifier (TBLOB *Blob, LINE_STATS *LineStats, ADAPT_TEMPLATES Templates, ADAPT_RESULTS *Results)

  Extracts baseline normalized features from the unknown character and matches them against the specified set of templates.
  

• void CharNormClassifier (TBLOB *Blob, LINE_STATS *LineStats, INT_TEMPLATES Templates, ADAPT_RESULTS *Results)

  Extracts character normalized features from the unknown character and matches them against the specified set of templates.
  

• void ClassifyAsNoise (TBLOB *Blob, LINE_STATS *LineStats, ADAPT_RESULTS *Results)

  Computes a rating which reflects the likelihood that the blob being classified is a noise blob.
  

• int CompareCurrentRatings (const void *arg1, const void *arg2)

  Gets the ratings for the 2 specified classes from a global variable (CurrentRatings) and returns:.
  

• LIST ConvertMatchesToChoices (ADAPT_RESULTS *Results)

  Creates a choice for each matching class in Results (up to MAX_MATCHES) and returns LIST of these choices.
  

• void DebugAdaptiveClassifier (TBLOB *Blob, LINE_STATS *LineStats, ADAPT_RESULTS *Results)

  Debug Adaptive Classifier using GUI.
  

• void DoAdaptiveMatch (TBLOB *Blob, LINE_STATS *LineStats, ADAPT_RESULTS *Results)

  Performs an adaptive classification.
  

• void EndAdaptiveClassifier ()

  Performs cleanup operations on the adaptive classifier.
  

• int GetAdaptiveFeatures (TBLOB *Blob, LINE_STATS *LineStats, INT_FEATURE_ARRAY IntFeatures, FEATURE_SET *FloatFeatures)

  Sets up the feature extractor to extract baseline normalized pico-features.
  

• void GetAdaptThresholds (TWERD *Word, LINE_STATS *LineStats, const char *BestChoice, const char *BestRawChoice, FLOAT32 Thresholds[])

  Tries to estimate how tight the adaptation threshold should be set for each character in the current word.
  

• char * GetAmbiguities (TBLOB *Blob, LINE_STATS *LineStats, CLASS_ID CorrectClass)

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

• int GetBaselineFeatures (TBLOB *Blob, LINE_STATS *LineStats, INT_TEMPLATES Templates, INT_FEATURE_ARRAY IntFeatures, CLASS_NORMALIZATION_ARRAY CharNormArray, FLOAT32 *BlobLength)

  Sets up the feature extractor to extract baseline normalized pico-features.
  

• FLOAT32 GetBestRatingFor (TBLOB *Blob, LINE_STATS *LineStats, CLASS_ID ClassId)

  Classifies Blob against both sets of templates for the specified class and returns the best rating found.
  

• int GetCharNormFeatures (TBLOB *Blob, LINE_STATS *LineStats, INT_TEMPLATES Templates, INT_FEATURE_ARRAY IntFeatures, CLASS_NORMALIZATION_ARRAY CharNormArray, FLOAT32 *BlobLength)

  Sets up the feature extractor to extract character normalization features and character normalized pico-features.
  

• int GetIntBaselineFeatures (TBLOB *Blob, LINE_STATS *LineStats, INT_TEMPLATES Templates, INT_FEATURE_ARRAY IntFeatures, CLASS_NORMALIZATION_ARRAY CharNormArray, FLOAT32 *BlobLength)

  Calls the integer feature-extractor if it has not been called before for this blob.
  

• int GetIntCharNormFeatures (TBLOB *Blob, LINE_STATS *LineStats, INT_TEMPLATES Templates, INT_FEATURE_ARRAY IntFeatures, CLASS_NORMALIZATION_ARRAY CharNormArray, FLOAT32 *BlobLength)

  Calls the integer feature-extractor if it has not been called before for this blob.
  

• void InitAdaptiveClassifier ()

  Reads in the training information needed by the adaptive classifier and saves it into global variables.
  

• void InitAdaptiveClassifierVars ()

  Installs the control knobs used by the adaptive matcher.
  

• void InitMatcherRatings (register FLOAT32 *Rating)

  Initializes the best rating for each class to be the worst possible rating (1.0).
  

• void make_config_pruner (INT_TEMPLATES templates, CONFIG_PRUNER *config_pruner)

  Prune the possible classes for speed.
  

• make_float_var (CertaintyScale, 20.0, MakeCertaintyScale, 18, 18, SetCertaintyScale,"CertaintyScale: ")
• make_float_var (RatingScale, 30.0, MakeRatingScale, 18, 17, SetRatingScale,"Rating scale: ")
• make_float_var (MaxAngleDelta, 0.015, MakeMaxAngleDelta, 18, 14, SetMaxAngleDelta,"Maximum angle delta for proto clustering: ")
• make_float_var (NoiseBlobLength, 0.6, MakeNoiseBlobLength, 18, 11, SetNoiseBlobLength,"Avg. noise blob length: ")
• make_float_var (RatingMargin, 0.1, MakeRatingMargin, 18, 10, SetRatingMargin,"New template margin (0-1): ")
• make_float_var (BadMatchPad, 0.15, MakeBadMatchPad, 18, 9, SetBadMatchPad,"Bad Match Pad (0-1): ")
• make_float_var (PerfectRating, 0.02, MakePerfectRating, 18, 8, SetPerfectRating,"Perfect Match (0-1): ")
• make_float_var (GreatAdaptiveMatch, 0.0, MakeGreatAdaptiveMatch, 18, 7, SetGreatAdaptiveMatch,"Great Match (0-1): ")
• make_float_var (GoodAdaptiveMatch, 0.125, MakeGoodAdaptiveMatch, 18, 6, SetGoodAdaptiveMatch,"Good Match (0-1): ")
• make_int_var (ReliableConfigThreshold, 2, MakeReliableConfigThreshold, 18, 13, SetReliableConfigThreshold,"Reliable Config Threshold: ")
• make_int_var (MinNumPermClasses, 3, MakeMinNumPermClasses, 18, 12, SetMinNumPermClasses,"Min # of permanent classes: ")
• make_int_var (LearningDebugLevel, 0, MakeLearningDebugLevel, 18, 5, SetLearningDebugLevel,"Learning Debug Level: ")
• make_int_var (MatchDebugFlags, 0, MakeMatchDebugFlags, 18, 3, SetMatchDebugFlags,"Matcher Debug Flags: ")
• make_int_var (MatcherDebugLevel, 0, MakeMatcherDebugLevel, 18, 2, SetMatcherDebugLevel,"Matcher Debug Level: ")
• make_toggle_const (SaveAdaptedTemplates, 0, MakeSaveAdaptedTemplates)
• make_toggle_const (UsePreAdaptedTemplates, 0, MakeUsePreAdaptedTemplates)
• make_toggle_const (EnableAdaptiveMatcher, 1, MakeEnableAdaptiveMatcher)
• make_toggle_var (EnableNewAdaptRules, 1, MakeEnableNewAdaptRules, 18, 16, SetEnableNewAdaptRules,"Enable new adaptation rules")
• make_toggle_var (EnableIntFX, 1, MakeEnableIntFX, 18, 15, SetEnableIntFX,"Enable integer fx")
• make_toggle_var (EnableLearning, 1, MakeEnableLearning, 18, 4, SetEnableLearning,"Enable learning")
• make_toggle_var (EnableAdaptiveDebugger, 0, MakeEnableAdaptiveDebugger, 18, 1, SetEnableAdaptiveDebugger,"Enable match debugger")
• void MakeNewAdaptedClass (TBLOB *Blob, LINE_STATS *LineStats, CLASS_ID ClassId, ADAPT_TEMPLATES Templates)

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

• void MakeNewTemporaryConfig (ADAPT_TEMPLATES Templates, CLASS_ID ClassId, int NumFeatures, INT_FEATURE_ARRAY Features, FEATURE_SET FloatFeatures)

  Makes new temp config ConfigId using NumOldProtos old and some new protos.
  

• PROTO_ID MakeNewTempProtos (FEATURE_SET Features, int NumBadFeat, FEATURE_ID BadFeat[], INT_CLASS IClass, ADAPT_CLASS Class, BIT_VECTOR TempProtoMask)

  Finds sets of sequential bad features that all have the same angle and converts each set into a new temporary proto.
  

• void MakePermanent (ADAPT_TEMPLATES Templates, CLASS_ID ClassId, int ConfigId, TBLOB *Blob, LINE_STATS *LineStats)

  Makes ConfigId permanent with ambiguities from LineStats.
  

• int MakeTempProtoPerm (void *item1,void *item2)

  Converts TempProto to be permanent if its proto id is used by the configuration specified in ProtoKey.
  

• int NumBlobsIn (TWERD *Word)

  Returns the number of blobs in Word.
  

• int NumOutlinesInBlob (TBLOB *Blob)

  Returns the number of OUTER outlines in Blob.
  

• void PrintAdaptiveMatchResults (FILE *File, ADAPT_RESULTS *Results)

  Writes the matches in Results to File.
  

• void PrintAdaptiveStatistics (FILE *File)

  Print to File the statistics which have been gathered for the adaptive matcher.
  

• void RemoveBadMatches (ADAPT_RESULTS *Results)

  Steps thru each matching class in Results and removes it from the match list if its rating is worse than the BestRating plus a pad - all good matches get moved to the front of the classes array.
  

• void RemoveExtraPuncs (ADAPT_RESULTS *Results)

  Steps thru each matching class in Results and removes it from the match list if its rating is worse than the BestRating plus a pad - all good matches get moved to the front of the classes array.
  

• void ResetAdaptiveClassifier ()

  Free allocated memory and reset templates.
  

• void SetAdaptiveThreshold (FLOAT32 Threshold)

  Resets the internal thresholds inside the integer matcher to correspond to the specified threshold.
  

• void SettupPass1 ()

  This routine prepares the adaptive matcher for the start of the first pass.
  

• void SettupPass2 ()

  Prepares the adaptive matcher for the start of the second pass.
  

• void ShowBestMatchFor (TBLOB *Blob, LINE_STATS *LineStats, CLASS_ID ClassId, BOOL8 AdaptiveOn, BOOL8 PreTrainedOn)

  Compares Blob to both sets of templates (adaptive and pre-trained) and then displays debug information for the config which matched best.
  

Variables

• static ADAPT_TEMPLATES AdaptedTemplates
• static int AdaptiveMatcherCalls = 0
• static BIT_VECTOR AllConfigsOff
• static BIT_VECTOR AllConfigsOn
• static BIT_VECTOR AllProtosOff
• static BIT_VECTOR AllProtosOn

  Dummy proto and config masks for use with the built-in templates.
  

• static int AmbigClassifierCalls = 0
• static int BaselineClassifierCalls = 0
• static CLASS_CUTOFF_ARRAY BaselineCutoffs
• static INT_FEATURE_ARRAY BaselineFeatures
• static const char * BuiltInCutoffsFile = BUILT_IN_CUTOFFS_FILE
• static const char * BuiltInTemplatesFile = BUILT_IN_TEMPLATES_FILE

  Filenames of training data.
  

• static int CharNormClassifierCalls = 0
• static CLASS_CUTOFF_ARRAY CharNormCutoffs
• static INT_FEATURE_ARRAY CharNormFeatures
• static FLOAT32 * CurrentRatings

  Current ratings.
  

• static BOOL8 FeaturesHaveBeenExtracted = FALSE
• static BOOL8 FeaturesOK = TRUE
• static INT_FX_RESULT_STRUCT FXInfo
• char imagefile []
• static int NumAmbigClassesTried = 0
• static int NumBaselineClassesTried = 0
• static int NumCharNormClassesTried = 0
• static int NumCharsAdaptedTo = 0
• static int NumClassesOutput = 0
• static int NumWordsAdaptedTo = 0
• static int old_enable_learning = 1
• static INT_TEMPLATES PreTrainedTemplates
• static BIT_VECTOR PrunedProtos
• static BIT_VECTOR TempProtoMask
• int tess_bn_matching = 0
• int tess_cn_matching = 0

---

Define Documentation

#define ADAPT_TEMPLATE_SUFFIX   ".a"

Note:

File: adaptmatch.cpp
High level adaptive matcher.

Author:

Dan Johnson

Date:

Mon Mar 11 10:00:10 1991, DSJ, Created.

 **	(c) Copyright Hewlett-Packard Company, 1988.
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 ** http://www.apache.org/licenses/LICENSE-2.0
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.

Definition at line 56 of file adaptmatch.cpp.

Referenced by EndAdaptiveClassifier(), and InitAdaptiveClassifier().

#define ADAPTABLE_WERD   (GOOD_NUMBER + 0.05)

Definition at line 67 of file adaptmatch.cpp.

Referenced by AdaptableWord(), and word_adaptable().

#define BUILT_IN_CUTOFFS_FILE   "tessdata/pffmtable"

Definition at line 58 of file adaptmatch.cpp.

Referenced by InitAdaptiveClassifierVars().

#define BUILT_IN_TEMPLATES_FILE   "tessdata/inttemp"

Definition at line 57 of file adaptmatch.cpp.

Referenced by InitAdaptiveClassifierVars().

 

#define InitIntFX

(

)

(FeaturesHaveBeenExtracted = FALSE)

Definition at line 114 of file adaptmatch.cpp.

Referenced by AdaptToWord(), and DoAdaptiveMatch().

#define MarginalMatch

(

Rating

)

((Rating) > GreatAdaptiveMatch)

Bigger is worse

Definition at line 109 of file adaptmatch.cpp.

Referenced by DoAdaptiveMatch().

#define MAX_ADAPTABLE_WERD_SIZE   40

Used in new rules of AdaptableWord()

Definition at line 66 of file adaptmatch.cpp.

Referenced by AdaptableWord(), and AdaptToWord().

#define MAX_MATCHES   10

FIX: Number of lesser other choices for any best choice to keep

Definition at line 61 of file adaptmatch.cpp.

Referenced by ConvertMatchesToChoices().

#define NO_DEBUG   0

Definition at line 64 of file adaptmatch.cpp.

Referenced by AdaptToChar(), AmbigClassifier(), GetBestRatingFor(), MakeNewTemporaryConfig(), and ShowBestMatchFor().

#define TempConfigReliable

(

Config

)

((Config)->NumTimesSeen > ReliableConfigThreshold)

Definition at line 111 of file adaptmatch.cpp.

Referenced by AdaptToChar().

#define UNLIKELY_NUM_FEAT   200

If over this number of features, we are sucking mud

Definition at line 63 of file adaptmatch.cpp.

Referenced by GetAdaptiveFeatures(), GetBaselineFeatures(), and MakeNewAdaptedClass().

#define WORST_POSSIBLE_RATING   (1.0)

FIX: Worst rating, also used to signify initial match ??

Definition at line 75 of file adaptmatch.cpp.

Referenced by AdaptiveClassifier(), AdaptToPunc(), AddNewResult(), BaselineClassifier(), CharNormClassifier(), GetAmbiguities(), and InitMatcherRatings().

#define Y_DIM_OFFSET   (Y_SHIFT - BASELINE_Y_SHIFT)

Because ConvertProto assumes that the Y dimension varies from -0.5 to 0.5 and not -0.25 to 0.75 used in baseline normalization, we need to offset it

Definition at line 72 of file adaptmatch.cpp.

Referenced by MakeNewAdaptedClass(), and MakeNewTempProtos().

---

Function Documentation

int AdaptableWord	(	TWERD *	Word,
		const char *	BestChoice,
		const char *	BestRawChoice
	)

Return TRUE if the specified word is acceptable for adaptation. Rules that apply in general, those simplest to compute come first.

Parameters:

	Word	current word
	BestChoice	best overall choice for word with context
	BestRawChoice	best choice for word without context

Note:

Globals: none

Returns:

TRUE or FALSE

Note:

Exceptions: none

Date:

Thu May 30 14:25:06 1991, DSJ, Created.

Definition at line 1224 of file adaptmatch.cpp.

References ADAPTABLE_WERD, AlternativeChoicesWorseThan(), case_ok(), CurrentBestChoiceAdjustFactor(), CurrentBestChoiceIs(), MAX_ADAPTABLE_WERD_SIZE, NULL, NumBlobsIn(), punctuation_ok(), pure_number(), valid_number(), and valid_word().

Referenced by tess_adaptable_word().

                                             {
  int BestChoiceLength;

  return
   (
      /* EnableLearning && */
      /* new rules */
      BestChoice != NULL
      && BestRawChoice != NULL
      && Word != NULL
      && ( BestChoiceLength = strlen (BestChoice)) > 0
      && BestChoiceLength == NumBlobsIn (Word)
      && BestChoiceLength <= MAX_ADAPTABLE_WERD_SIZE
      && (
         /* new rules */
         EnableNewAdaptRules
         && CurrentBestChoiceAdjustFactor() <= ADAPTABLE_WERD
          && AlternativeChoicesWorseThan(ADAPTABLE_WERD)
         && CurrentBestChoiceIs(BestChoice)
         ||
         /* old rules */
         !EnableNewAdaptRules
         && BestChoiceLength == strlen (BestRawChoice)
         && (
               (
               valid_word (BestChoice)
               && case_ok (BestChoice)
               )
             ||   (
               valid_number (BestChoice)
               && pure_number (BestChoice)
               )
            )
            && punctuation_ok (BestChoice) != -1
            && punctuation_ok (BestChoice) <= 1
         )
   );
}// AdaptableWord

LIST AdaptiveClassifier	(	TBLOB *	Blob,
		TBLOB *	DotBlob,
		TEXTROW *	Row
	)

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

Parameters:

	Blob	blob to be classified
	DotBlob	(obsolete)
	Row	row of text that word appears in

Note:

Globals: CurrentRatings used by compare function for qsort

Returns:

List of choices found by adaptive matcher.

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.

Note:

Exceptions: none

Date:

Mon Mar 11 10:00:58 1991, DSJ, Created.

Definition at line 616 of file adaptmatch.cpp.

References AdaptedTemplates, AddLargeSpeckleTo(), append_choice(), ADAPT_RESULTS::BestClass, ADAPT_RESULTS::BestConfig, ADAPT_RESULTS::BestRating, ADAPT_RESULTS::BlobLength, ADAPT_RESULTS::Classes, CompareCurrentRatings(), ConvertMatchesToChoices(), count(), cprintf(), CurrentRatings, DebugAdaptiveClassifier(), DoAdaptiveMatch(), EnterClassifyMode, f, GetLineStatsFromRow(), InitMatcherRatings(), LargeSpeckle(), MatcherDebugLevel, MAX_FLOAT32, NewAdaptedTemplates(), NIL, NO_CLASS, NULL, NumClassesOutput, ADAPT_RESULTS::NumMatches, PrintAdaptiveMatchResults(), ADAPT_RESULTS::Ratings, RemoveBadMatches(), RemoveExtraPuncs(), and WORST_POSSIBLE_RATING.

Referenced by tess_bn_matcher(), tess_cn_matcher(), and tess_default_matcher().

                                                                   { 
  LIST Choices;
  ADAPT_RESULTS Results;
  LINE_STATS LineStats;

  // next 2 lines new for v1.03
  if (AdaptedTemplates == NULL)
    AdaptedTemplates = NewAdaptedTemplates ();
  EnterClassifyMode;

  Results.BlobLength = MAX_FLOAT32;
  Results.NumMatches = 0;
  Results.BestRating = WORST_POSSIBLE_RATING;
  Results.BestClass = NO_CLASS;
  Results.BestConfig = 0;
  GetLineStatsFromRow(Row, &LineStats);
  InitMatcherRatings (Results.Ratings);

  DoAdaptiveMatch(Blob, &LineStats, &Results);
  RemoveBadMatches(&Results);

  /* save ratings in a global so that CompareCurrentRatings() can see them */
  CurrentRatings = Results.Ratings;
  qsort ((void *) (Results.Classes), Results.NumMatches,
    sizeof (CLASS_ID), CompareCurrentRatings);
  RemoveExtraPuncs(&Results);
  Choices = ConvertMatchesToChoices (&Results);

  if (MatcherDebugLevel >= 1) {
    cprintf ("AD Matches =  ");
    PrintAdaptiveMatchResults(stdout, &Results);
  }

  if (LargeSpeckle (Blob, Row))
    Choices = AddLargeSpeckleTo (Choices);

#ifndef GRAPHICS_DISABLED
  if (EnableAdaptiveDebugger)
    DebugAdaptiveClassifier(Blob, &LineStats, &Results);
#endif

  NumClassesOutput += count (Choices);
  if (Choices == NIL) {
    if (!bln_numericmode)
      printf ("Nil classification!\n");  // Should never normally happen.
    return (append_choice (NIL, "", 50.0f, -20.0f, -1));
  }

  return (Choices);

}// AdaptiveClassifier

void AdaptToChar	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		CLASS_ID	ClassId,
		FLOAT32	Threshold
	)

Adapts to character?

Parameters:

	Blob	blob to add to templates for ClassId
	LineStats	statistics about text line blob is in
	ClassId	class to add blob to
	Threshold	minimum match rating to existing template

Note:

Globals:

• AdaptedTemplates current set of adapted templates
• AllProtosOn dummy mask to match against all protos
• AllConfigsOn dummy mask to match against all configs

Returns:

none

Note:

Exceptions: none

Date:

Thu Mar 14 09:36:03 1991, DSJ, Created.

Definition at line 1282 of file adaptmatch.cpp.

References AdaptedTemplates, AllConfigsOn, AllProtosOn, ADAPT_TEMPLATES_STRUCT::Class, ClassForClassId, INT_RESULT_STRUCT::Config, ConfigIsPermanent, cprintf(), FreeFeatureSet(), GetAdaptiveFeatures(), GetClassToDebug(), IncreaseConfidence, IndexForClassId, IntegerMatcher(), LearningDebugLevel, LegalClassId, MakeNewAdaptedClass(), MakeNewTemporaryConfig(), MakePermanent(), NO_DEBUG, NumCharsAdaptedTo, TEMP_CONFIG_STRUCT::NumTimesSeen, INT_RESULT_STRUCT::Rating, SetAdaptiveThreshold(), SetBaseLineMatch(), ShowMatchDisplay(), TempConfigFor, TempConfigReliable, ADAPT_TEMPLATES_STRUCT::Templates, UnusedClassIdIn, and UpdateMatchDisplay().

Referenced by AdaptToPunc(), and AdaptToWord().

                                    {
  int NumFeatures;
  INT_FEATURE_ARRAY IntFeatures;
  INT_RESULT_STRUCT IntResult;
  CLASS_INDEX ClassIndex;
  INT_CLASS IClass;
  ADAPT_CLASS Class;
  TEMP_CONFIG TempConfig;
  FEATURE_SET FloatFeatures;

  NumCharsAdaptedTo++;
  if (!LegalClassId (ClassId))
    return;

  if (UnusedClassIdIn (AdaptedTemplates->Templates, ClassId)) {
    MakeNewAdaptedClass(Blob, LineStats, ClassId, AdaptedTemplates);
  }
  else {
    IClass = ClassForClassId (AdaptedTemplates->Templates, ClassId);
    ClassIndex = IndexForClassId (AdaptedTemplates->Templates, ClassId);
    Class = AdaptedTemplates->Class[ClassIndex];

    NumFeatures = GetAdaptiveFeatures (Blob, LineStats,
      IntFeatures, &FloatFeatures);
    if (NumFeatures <= 0)
      return;

    SetBaseLineMatch();
    IntegerMatcher (IClass, AllProtosOn, AllConfigsOn,
      NumFeatures, NumFeatures, IntFeatures, 0, 0,
      &IntResult, NO_DEBUG);

    SetAdaptiveThreshold(Threshold);

    if (IntResult.Rating <= Threshold) {
      if (ConfigIsPermanent (Class, IntResult.Config)) {
        if (LearningDebugLevel >= 1)
          cprintf ("Found good match to perm config %d = %4.1f%%.\n",
            IntResult.Config, (1.0 - IntResult.Rating) * 100.0);
        FreeFeatureSet(FloatFeatures);
        return;
      }

      TempConfig = TempConfigFor (Class, IntResult.Config);
      IncreaseConfidence(TempConfig);
      if (LearningDebugLevel >= 1)
        cprintf ("Increasing reliability of temp config %d to %d.\n",
          IntResult.Config, TempConfig->NumTimesSeen);

      if (TempConfigReliable (TempConfig))
        MakePermanent (AdaptedTemplates, ClassId, IntResult.Config,
          Blob, LineStats);
    }
    else {
      if (LearningDebugLevel >= 1) // new in v1.03
        cprintf ("Found poor match to temp config %d = %4.1f%%.\n",
          IntResult.Config, (1.0 - IntResult.Rating) * 100.0);
      MakeNewTemporaryConfig(AdaptedTemplates,
                             ClassId,
                             NumFeatures,
                             IntFeatures,
                             FloatFeatures);
      if (LearningDebugLevel >= 1) { // new in v1.03
        IntegerMatcher (IClass, AllProtosOn, AllConfigsOn,
          NumFeatures, NumFeatures, IntFeatures, 0, 0,
          &IntResult, NO_DEBUG);
        cprintf ("Best match to temp config %d = %4.1f%%.\n",
          IntResult.Config, (1.0 - IntResult.Rating) * 100.0);
        if (LearningDebugLevel >= 2) {
          UINT32 ConfigMask;
          ConfigMask = 1 << IntResult.Config;
          ShowMatchDisplay();
          IntegerMatcher (IClass, AllProtosOn, (BIT_VECTOR)&ConfigMask,
            NumFeatures, NumFeatures, IntFeatures, 0, 0,
            &IntResult, 6 | 0x19);
          UpdateMatchDisplay();
          GetClassToDebug ("Adapting");
        }
      }
    }
    FreeFeatureSet(FloatFeatures);
  }
}                                /* AdaptToChar */

void AdaptToPunc	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		CLASS_ID	ClassId,
		FLOAT32	Threshold
	)

Adapts to punctuation.

Parameters:

	Blob	blob to add to templates for ClassId
	LineStats	statistics about text line blob is in
	ClassId	class to add blob to
	Threshold	minimum match rating to existing template

Note:

Globals: PreTrainedTemplates current set of built-in templates

Returns:

none

Note:

Exceptions: none

Date:

Thu Mar 14 09:36:03 1991, DSJ, Created.

Definition at line 1383 of file adaptmatch.cpp.

References AdaptToChar(), ADAPT_RESULTS::BestClass, ADAPT_RESULTS::BestConfig, ADAPT_RESULTS::BestRating, ADAPT_RESULTS::BlobLength, CharNormClassifier(), ADAPT_RESULTS::Classes, cprintf(), InitMatcherRatings(), LearningDebugLevel, MAX_FLOAT32, NO_CLASS, ADAPT_RESULTS::NumMatches, PreTrainedTemplates, ADAPT_RESULTS::Ratings, RemoveBadMatches(), and WORST_POSSIBLE_RATING.

Referenced by AdaptToWord().

                                    {
  ADAPT_RESULTS Results;
  int i;

  Results.BlobLength = MAX_FLOAT32;
  Results.NumMatches = 0;
  Results.BestRating = WORST_POSSIBLE_RATING;
  Results.BestClass = NO_CLASS;
  Results.BestConfig = 0;
  InitMatcherRatings (Results.Ratings);
  CharNormClassifier(Blob, LineStats, PreTrainedTemplates, &Results);
  RemoveBadMatches(&Results);

  if (Results.NumMatches != 1) {
    if (LearningDebugLevel >= 1) {
      cprintf ("Rejecting punc = %c (Alternatives = ", ClassId);

      for (i = 0; i < Results.NumMatches; i++)
        cprintf ("%c", Results.Classes[i]);
      cprintf (")\n");
    }
    return;
  }

  #ifndef SECURE_NAMES
  if (LearningDebugLevel >= 1)
    cprintf ("Adapting to punc = %c\n", ClassId);
  #endif
  AdaptToChar(Blob, LineStats, ClassId, Threshold);

}                                /* AdaptToPunc */

void AdaptToWord	(	TWERD *	Word,
		TEXTROW *	Row,
		const char *	BestChoice,
		const char *	BestRawChoice,
		const char *	rejmap
	)

Implements a preliminary version of the rules which are used to decide which characters to adapt to.

Parameters:

	Word	Word to be adapted to
	Row	Row of text that word is found in
	BestChoice	Best choice for word found by system
	BestRawChoice	Best choice for word found by classifier only
	rejmap	Reject map

Note:

Globals: EnableLearning TRUE if learning is enabled

Returns:

none

A word is adapted to if it is in the dictionary or if it is a "good" number (no trailing units, etc.). It cannot contain broken or merged characters. Within that word, only letters and digits are adapted to (no punctuation).

SPECIAL RULE: Don't adapt to an 'i' which is the first char in a word because they are too ambiguous with 'I'.

The new adaptation rules should account for this automatically, since they exclude ambiguous words from adaptation, but for safety's sake we'll leave the rule in.

Also, don't adapt to i's that have only one blob in them because this creates too much ambiguity for broken characters.

Note:

Exceptions: none

Date:

Thu Mar 14 07:40:36 1991, DSJ, Created.

Definition at line 700 of file adaptmatch.cpp.

References AdaptToChar(), AdaptToPunc(), assert(), wordstruct::blobs, cprintf(), GetAdaptThresholds(), GetLineStatsFromRow(), InitIntFX, LearningDebugLevel, MAX_ADAPTABLE_WERD_SIZE, blobstruct::next, NULL, NumOutlinesInBlob(), and NumWordsAdaptedTo.

Referenced by tess_adapter().

                                     {
  TBLOB *Blob;
  LINE_STATS LineStats;
  FLOAT32 Thresholds[MAX_ADAPTABLE_WERD_SIZE];
  FLOAT32 *Threshold;
  const char *map = rejmap;
  char map_char = '1';

  if (EnableLearning) {
    NumWordsAdaptedTo++;

    #ifndef SECURE_NAMES
    if (LearningDebugLevel >= 1)
      cprintf ("\n\nAdapting to word = %s\n", BestChoice);
    #endif
    GetLineStatsFromRow(Row, &LineStats);

    GetAdaptThresholds(Word,
                       &LineStats,
                       BestChoice,
                       BestRawChoice,
                       Thresholds);

    for (Blob = Word->blobs, Threshold = Thresholds;
    Blob != NULL; Blob = Blob->next, BestChoice++, Threshold++) {
      InitIntFX();

      if (rejmap != NULL)
        map_char = *map++;

      assert (map_char == '1' || map_char == '0');

      if (map_char == '1') {

        if (isalnum (*BestChoice)) {
          /* Use SPECIAL RULE here */
          if ((*BestChoice == 'i'
            || il1_adaption_test && *BestChoice == 'I'
            && islower (BestChoice[1])) && (Blob == Word->blobs
            ||
            ispunct (*
            (BestChoice -
            1))
            || !il1_adaption_test
            &&
            NumOutlinesInBlob
          (Blob) != 2)) {
            if (LearningDebugLevel >= 1)
              cprintf ("Rejecting char = %c\n", *BestChoice);
          }
          else {
            #ifndef SECURE_NAMES
            if (LearningDebugLevel >= 1)
              cprintf ("Adapting to char = %c, thr= %g\n", *BestChoice, *Threshold);
            #endif
            AdaptToChar(Blob, &LineStats, *BestChoice, *Threshold);
          }
        }
        else
          AdaptToPunc(Blob, &LineStats, *BestChoice, *Threshold);
      }
    }
    if (LearningDebugLevel >= 1)
      cprintf ("\n");
  }
}                                /* AdaptToWord */

void AddNewResult	(	ADAPT_RESULTS *	Results,
		CLASS_ID	ClassId,
		FLOAT32	Rating,
		int	ConfigId
	)

Adds the result of a classification into Results.

Parameters:

	Results	results to add new result to
	ClassId	class of new result
	Rating	rating of new result
	ConfigId	config id of new result

Note:

Globals: BadMatchPad defines limits of an acceptable match

Returns:

none

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.

Note:

Exceptions: none

Date:

Tue Mar 12 18:19:29 1991, DSJ, Created.

Definition at line 1441 of file adaptmatch.cpp.

References ADAPT_RESULTS::BestClass, ADAPT_RESULTS::BestConfig, ADAPT_RESULTS::BestRating, BestRating, ADAPT_RESULTS::Classes, ClassForClassId, ADAPT_RESULTS::Configs, NO_CLASS, NULL, NumIntConfigsIn, ADAPT_RESULTS::NumMatches, PreTrainedTemplates, ADAPT_RESULTS::Ratings, and WORST_POSSIBLE_RATING.

Referenced by AmbigClassifier(), BaselineClassifier(), CharNormClassifier(), and ClassifyAsNoise().

                                {
  FLOAT32 OldRating;
  INT_CLASS_STRUCT* CharClass = NULL;

  OldRating = Results->Ratings[ClassId];
  if (Rating <= Results->BestRating + BadMatchPad && Rating < OldRating) {
    Results->Ratings[ClassId] = Rating;
    if (ClassId != NO_CLASS)
      CharClass = ClassForClassId(PreTrainedTemplates, ClassId);
    if (CharClass != NULL && NumIntConfigsIn(CharClass) == 32)
      Results->Configs[ClassId] = ConfigId;
    else
      Results->Configs[ClassId] = ~0;

    if (Rating < Results->BestRating) {
      Results->BestRating = Rating;
      Results->BestClass = ClassId;
      Results->BestConfig = ConfigId;
    }

    /* if this is first rating for class, add to list of classes matched */
    if (OldRating == WORST_POSSIBLE_RATING)
      Results->Classes[Results->NumMatches++] = ClassId;
  }
}                                /* AddNewResult */

void AmbigClassifier	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		INT_TEMPLATES	Templates,
		char *	Ambiguities,
		ADAPT_RESULTS *	Results
	)

Identical to CharNormClassifier() except that it does no class pruning, simply matches the unknown blob against the classes listed in Ambiguities.

Parameters:

	Blob	blob to be classified
	LineStats	statistics for text line Blob is in
	Templates	built-in templates to classify against
	Ambiguities	string of class id's to match against
	Results	place to put match results

Note:

Globals:

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

Returns:

none

Note:

Exceptions: none

Date:

Tue Mar 12 19:40:36 1991, DSJ, Created.

Definition at line 1489 of file adaptmatch.cpp.

References AddNewResult(), AllConfigsOn, AllProtosOn, AmbigClassifierCalls, ADAPT_RESULTS::BlobLength, ClassForClassId, INT_RESULT_STRUCT::Config, cprintf(), GetCharNormFeatures(), GetPicoFeatureLength, IndexForClassId, IntegerMatcher(), MatcherDebugLevel, NO_DEBUG, NumAmbigClassesTried, INT_RESULT_STRUCT::Rating, and SetCharNormMatch().

Referenced by DoAdaptiveMatch().

                                             {
  int IntOutlineLength;
  int NumFeatures;
  INT_FEATURE_ARRAY IntFeatures;
  CLASS_NORMALIZATION_ARRAY CharNormArray;
  INT_RESULT_STRUCT IntResult;
  CLASS_ID ClassId;
  CLASS_INDEX ClassIndex;

  AmbigClassifierCalls++;

  NumFeatures = GetCharNormFeatures (Blob, LineStats,
    Templates,
    IntFeatures, CharNormArray,
    &(Results->BlobLength));
  if (NumFeatures <= 0)
    return;

  IntOutlineLength = (int) (Results->BlobLength / GetPicoFeatureLength ());

  if (MatcherDebugLevel >= 2)
    cprintf ("AM Matches =  ");

  while (*Ambiguities) {
    ClassId = *Ambiguities;
    ClassIndex = IndexForClassId (Templates, ClassId);

    SetCharNormMatch();
    IntegerMatcher (ClassForClassId (Templates, ClassId),
      AllProtosOn, AllConfigsOn,
      IntOutlineLength, NumFeatures, IntFeatures, 0,
      CharNormArray[ClassIndex], &IntResult, NO_DEBUG);

    if (MatcherDebugLevel >= 2)
      cprintf ("%c-%-2d %2.0f  ", ClassId, IntResult.Config,
        IntResult.Rating * 100.0);

    AddNewResult (Results, ClassId, IntResult.Rating, IntResult.Config);

    Ambiguities++;

    NumAmbigClassesTried++;
  }
  if (MatcherDebugLevel >= 2)
    cprintf ("\n");

}                                /* AmbigClassifier */

char * BaselineClassifier	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		ADAPT_TEMPLATES	Templates,
		ADAPT_RESULTS *	Results
	)

Extracts baseline normalized features from the unknown character and matches them against the specified set of templates.

Parameters:

	Blob	blob to be classified
	LineStats	statistics for text line Blob is in
	Templates	current set of adapted templates
	Results	place to put match results

Note:

Globals: BaselineCutoffs expected num features for each class

Returns:

String of possible ambiguous chars that should be checked.

The classes which match are added to Results.

Note:

Exceptions: none

Date:

Tue Mar 12 19:38:03 1991, DSJ, Created.

Definition at line 1559 of file adaptmatch.cpp.

References AddNewResult(), BaselineClassifierCalls, BaselineCutoffs, ADAPT_RESULTS::BestClass, ADAPT_RESULTS::BestConfig, ADAPT_RESULTS::BlobLength, ADAPT_TEMPLATES_STRUCT::Class, ClassForClassId, ClassForIndex, ClassPruner(), Config, INT_RESULT_STRUCT::Config, ConfigIsPermanent, cprintf(), display_ratings, GetBaselineFeatures(), GetPicoFeatureLength, IndexForClassId, IntegerMatcher(), MatcherDebugLevel, NO_CLASS, NULL, NumBaselineClassesTried, NumIntConfigsIn, ADAPT_CLASS_STRUCT::PermConfigs, ADAPT_CLASS_STRUCT::PermProtos, INT_RESULT_STRUCT::Rating, SetBaseLineMatch(), ADAPT_TEMPLATES_STRUCT::Templates, and WORST_POSSIBLE_RATING.

Referenced by DoAdaptiveMatch().

                                                 {
  int IntOutlineLength;
  int NumFeatures;
  int NumClasses;
  int i;
  int config;
  float best_rating;
  INT_FEATURE_ARRAY IntFeatures;
  CLASS_NORMALIZATION_ARRAY CharNormArray;
  CLASS_PRUNER_RESULTS ClassPrunerResults;
  INT_RESULT_STRUCT IntResult;
  CLASS_ID ClassId;
  CLASS_INDEX ClassIndex;
  ADAPT_CLASS Class;

  BaselineClassifierCalls++;

  NumFeatures = GetBaselineFeatures (Blob, LineStats,
    Templates->Templates,
    IntFeatures, CharNormArray,
    &(Results->BlobLength));
  if (NumFeatures <= 0)
    return NULL;

  IntOutlineLength = (int) (Results->BlobLength / GetPicoFeatureLength ());

  NumClasses = ClassPruner (Templates->Templates, NumFeatures,
    IntFeatures, CharNormArray,
    BaselineCutoffs, ClassPrunerResults,
    MatchDebugFlags);

  NumBaselineClassesTried += NumClasses;

  if (MatcherDebugLevel >= 2 || display_ratings > 1)
    cprintf ("BL Matches =  ");

  best_rating = WORST_POSSIBLE_RATING;
  for (i = 0; i < NumClasses
    && ((newcp_ratings_on & 12) < 8
    || (newcp_ratings_on & 12) == 8
    && ClassPrunerResults[i].Rating < best_rating + BadMatchPad / 2
    && ClassPrunerResults[i].Rating < newcp_duff_rating
  && NumClasses > 1); i++) {
    ClassId = ClassPrunerResults[i].Class;
    ClassIndex = IndexForClassId (Templates->Templates, ClassId);

    SetBaseLineMatch();
    IntegerMatcher (ClassForClassId (Templates->Templates, ClassId),
      Templates->Class[ClassIndex]->PermProtos,
      Templates->Class[ClassIndex]->PermConfigs,
      IntOutlineLength, NumFeatures, IntFeatures, 0,
      CharNormArray[ClassIndex], &IntResult, MatchDebugFlags);

    if (MatcherDebugLevel >= 2 || display_ratings > 1) {
      cprintf ("%c-%-2d %2.1f(%2.1f/%2.1f)  ", ClassId, IntResult.Config,
        IntResult.Rating * 100.0,
        ClassPrunerResults[i].Rating * 100.0,
        ClassPrunerResults[i].Rating2 * 100.0);
      if (i % 4 == 3)
        cprintf ("\n");
    }

    AddNewResult (Results, ClassId, IntResult.Rating, IntResult.Config);
  }
  while (i < NumClasses) {
    ClassId = ClassPrunerResults[i].Class;
    ClassIndex = IndexForClassId (Templates->Templates, ClassId);
    Class = Templates->Class[ClassIndex];
    config =
      NumIntConfigsIn (ClassForIndex (Templates->Templates, ClassIndex));
    for (config--; config >= 0 && !ConfigIsPermanent (Class, config);
      config--);

    if (MatcherDebugLevel >= 2 || display_ratings > 1) {
      cprintf ("%c(%d) %2.1f(%2.1f)  ", ClassId, config,
        ClassPrunerResults[i].Rating * 200.0,
        ClassPrunerResults[i].Rating2 * 100.0);
      if (i % 4 == 3)
        cprintf ("\n");
    }

    AddNewResult (Results, ClassId, ClassPrunerResults[i].Rating * 2,
      config);
    i++;
  }
  if (MatcherDebugLevel >= 2 || display_ratings > 1)
    cprintf ("\n");

  ClassId = Results->BestClass;
  if (ClassId == NO_CLASS)
    return (NULL);
  /* this is a bug - maybe should return "" */

  ClassIndex = IndexForClassId (Templates->Templates, ClassId);
  return ((char *) (Templates->Class[ClassIndex]->
    Config[Results->BestConfig].Perm));

}                                /* BaselineClassifier */

void CharNormClassifier	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		INT_TEMPLATES	Templates,
		ADAPT_RESULTS *	Results
	)

Extracts character normalized features from the unknown character and matches them against the specified set of templates.

Parameters:

	Blob	Blob to be classified
	LineStats	Statistics for text line Blob is in
	Templates	Templates to classify unknown against
	Results	Place to put match results

Note:

Globals:

• CharNormCutoffs Expected num features for each class
• AllProtosOn Mask that enables all protos
• AllConfigsOn Mask that enables all configs

Returns:

none

The classes which match are added to Results.

Note:

Exceptions: none

Date:

Tue Mar 12 16:02:52 1991, DSJ, Created.

Definition at line 1802 of file adaptmatch.cpp.

References AddNewResult(), ADAPT_RESULTS::BlobLength, CharNormClassifierCalls, CharNormCutoffs, ClassForClassId, ClassPruner(), INT_RESULT_STRUCT::Config, config_mask_to_proto_mask(), cprintf(), display_ratings, feature_pruner(), GetCharNormFeatures(), GetPicoFeatureLength, IndexForClassId, IntegerMatcher(), MatcherDebugLevel, NumCharNormClassesTried, prune_configs(), PrunedProtos, INT_RESULT_STRUCT::Rating, SetCharNormMatch(), and WORST_POSSIBLE_RATING.

Referenced by AdaptToPunc(), DoAdaptiveMatch(), and GetAmbiguities().

                                                {
  int IntOutlineLength;
  int NumFeatures;
  int NumClasses;
  int i;
  INT32 min_misses;
  float best_rating;
  INT_FEATURE_ARRAY IntFeatures;
  CLASS_NORMALIZATION_ARRAY CharNormArray;
  CLASS_PRUNER_RESULTS ClassPrunerResults;
  INT_RESULT_STRUCT IntResult;
  CLASS_ID ClassId;
  CLASS_INDEX ClassIndex;

  CharNormClassifierCalls++;

  NumFeatures = GetCharNormFeatures (Blob, LineStats,
    Templates,
    IntFeatures, CharNormArray,
    &(Results->BlobLength));
  if (NumFeatures <= 0)
    return;

  IntOutlineLength = (int) (Results->BlobLength / GetPicoFeatureLength ());

  NumClasses = ClassPruner (Templates, NumFeatures,
    IntFeatures, CharNormArray,
    CharNormCutoffs, ClassPrunerResults,
    MatchDebugFlags);

  if (feature_prune_percentile > 0) {
    min_misses = feature_pruner (Templates, NumFeatures,
      IntFeatures, NumClasses,
      ClassPrunerResults);
    NumClasses =
      prune_configs(Templates,
                    min_misses,
                    NumFeatures,
                    IntFeatures,
                    CharNormArray,
                    NumClasses,
                    IntOutlineLength,
                    ClassPrunerResults,
                    MatchDebugFlags);
  }
  else
    min_misses = 0;
  if (tessedit_single_match && NumClasses > 1)
    NumClasses = 1;
  NumCharNormClassesTried += NumClasses;

  if (MatcherDebugLevel >= 2 || display_ratings > 1)
    cprintf ("CN Matches =  ");

  best_rating = WORST_POSSIBLE_RATING;
  for (i = 0; i < NumClasses
    && ((newcp_ratings_on & 3) < 2
    || (newcp_ratings_on & 3) == 2
    && ClassPrunerResults[i].Rating < best_rating + BadMatchPad / 2
    && ClassPrunerResults[i].Rating < newcp_duff_rating
  && NumClasses > 1); i++) {
    ClassId = ClassPrunerResults[i].Class;
    ClassIndex = IndexForClassId (Templates, ClassId);

    SetCharNormMatch();

    if (feature_prune_percentile > 0)
                                 //xiaofan
      config_mask_to_proto_mask (ClassForClassId (Templates, ClassId), (BIT_VECTOR) & ClassPrunerResults[i].config_mask,
        PrunedProtos);
                                 //xiaofan
    IntegerMatcher (ClassForClassId (Templates, ClassId), PrunedProtos, (BIT_VECTOR) & ClassPrunerResults[i].config_mask,
      IntOutlineLength, NumFeatures, IntFeatures, 0,
      CharNormArray[ClassIndex], &IntResult, MatchDebugFlags);

    if (MatcherDebugLevel >= 2 || display_ratings > 1) {
      cprintf ("%c-%-2d %2.1f(%2.1f/%2.1f)  ", ClassId, IntResult.Config,
        IntResult.Rating * 100.0,
        ClassPrunerResults[i].Rating * 100.0,
        ClassPrunerResults[i].Rating2 * 100.0);
      if (i % 4 == 3)
        cprintf ("\n");
    }

    AddNewResult (Results, ClassId, IntResult.Rating, IntResult.Config);
    if (IntResult.Rating < best_rating)
      best_rating = IntResult.Rating;
  }
  while (i < NumClasses) {
    ClassId = ClassPrunerResults[i].Class;
    ClassIndex = IndexForClassId (Templates, ClassId);

    if (MatcherDebugLevel >= 2 || display_ratings > 1) {
      cprintf ("%c %2.1f(%2.1f)  ", ClassId,
        ClassPrunerResults[i].Rating * 200.0,
        ClassPrunerResults[i].Rating2 * 100.0);
      if (i % 4 == 3)
        cprintf ("\n");
    }

    AddNewResult (Results, ClassId, ClassPrunerResults[i].Rating * 2, 0);
    i++;
  }
  if (MatcherDebugLevel >= 2 || display_ratings > 1)
    cprintf ("\n");

}                                /* CharNormClassifier */

void ClassifyAsNoise	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		ADAPT_RESULTS *	Results
	)

Computes a rating which reflects the likelihood that the blob being classified is a noise blob.

Parameters:

	Blob	blob to be classified
	LineStats	statistics for text line Blob is in
	Results	results to add noise classification to

Note:

Globals:

• NoiseBlobLength average length of a noise blob

Returns:

none

Note:

Assumes that the blob length has already been computed and placed into Results.

Exceptions: none

Date:

Tue Mar 12 18:36:52 1991, DSJ, Created.

Definition at line 1929 of file adaptmatch.cpp.

References AddNewResult(), ADAPT_RESULTS::BlobLength, and NO_CLASS.

Referenced by DoAdaptiveMatch().

                                             {
  register FLOAT32 Rating;

  Rating = Results->BlobLength / NoiseBlobLength;
  Rating *= Rating;
  Rating /= 1.0 + Rating;

  AddNewResult (Results, NO_CLASS, Rating, 0);

}                                /* ClassifyAsNoise */

int CompareCurrentRatings	(	const void *	arg1,
		const void *	arg2
	)

Gets the ratings for the 2 specified classes from a global variable (CurrentRatings) and returns:.

Parameters:

	arg1	class whose ratings are to be compared
	arg2	class whose ratings are to be compared

Note:

Globals:

• CurrentRatings contains actual ratings for each class

Returns:

Order of classes based on their ratings (see above).

• \-1 if Rating1 < Rating2
• 0 if Rating1 = Rating2
• 1 if Rating1 > Rating2

  Note:

  Exceptions: none

  Date:

  Tue Mar 12 14:18:31 1991, DSJ, Created.

Definition at line 1960 of file adaptmatch.cpp.

References CurrentRatings.

Referenced by AdaptiveClassifier(), and GetAmbiguities().

                                            {
  FLOAT32 Rating1, Rating2;
  CLASS_ID *Class1 = (CLASS_ID *) arg1;
  CLASS_ID *Class2 = (CLASS_ID *) arg2;

  Rating1 = CurrentRatings[*Class1];
  Rating2 = CurrentRatings[*Class2];

  if (Rating1 < Rating2)
    return (-1);
  else if (Rating1 > Rating2)
    return (1);
  else
    return (0);

}                                /* CompareCurrentRatings */

LIST ConvertMatchesToChoices

(

ADAPT_RESULTS *

Results

)

Creates a choice for each matching class in Results (up to MAX_MATCHES) and returns LIST of these choices.

Parameters:

Results

Pointer to our ADAPT_RESULTS

Note:

Globals: none

Returns:

List of choices.

The match ratings are converted to be the ratings and certainties as used by the context checkers

FIX: This implement the RATING equation shown in Column 10, Row 0 to 5 of Patent 5,237,627 (top of pg 16), right?

Note:

Exceptions: none

Date:

Tue Mar 12 08:55:37 1991, DSJ, Created.

Definition at line 1998 of file adaptmatch.cpp.

References append_choice(), ADAPT_RESULTS::BlobLength, CertaintyScale, ADAPT_RESULTS::Classes, ADAPT_RESULTS::Configs, MAX_MATCHES, NIL, ADAPT_RESULTS::NumMatches, and ADAPT_RESULTS::Ratings.

Referenced by AdaptiveClassifier().

                                                     {
  char ChoiceString[2];
  int i;
  LIST Choices;
  CLASS_ID NextMatch;
  FLOAT32 Rating;
  FLOAT32 Certainty;

  ChoiceString[1] = '\0';
  if (Results->NumMatches > MAX_MATCHES)
    Results->NumMatches = MAX_MATCHES;

  for (Choices = NIL, i = 0; i < Results->NumMatches; i++) {
    NextMatch = Results->Classes[i];
    ChoiceString[0] = NextMatch;
    Rating = Certainty = Results->Ratings[NextMatch];
    Rating *= RatingScale * Results->BlobLength;
    Certainty *= -CertaintyScale;
    Choices = append_choice (Choices, ChoiceString, Rating, Certainty,
      Results->Configs[NextMatch]);
  }
  return (Choices);

}                                /* ConvertMatchesToChoices */

void DebugAdaptiveClassifier	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		ADAPT_RESULTS *	Results
	)

Debug Adaptive Classifier using GUI.

Parameters:

	Blob	Blob whose classification is being debugged
	LineStats	Statistics for text line blob is in
	Results	Results of match being debugged

Note:

Globals: none

Returns:

none

Note:

Exceptions: none

Date:

Wed Mar 13 16:44:41 1991, DSJ, Created.

Definition at line 2037 of file adaptmatch.cpp.

References ADAPT_RESULTS::BestClass, cprintf(), FALSE, GetClassToDebug(), ShowBestMatchFor(), ShowMatchDisplay(), TRUE, and UpdateMatchDisplay().

Referenced by AdaptiveClassifier().

                                                     {
  const char *Prompt =
    "\nType class id (or CTRL-A,B,C) in IntegerMatch Window ...";
  const char *DebugMode = "All Templates";
  CLASS_ID LastClass = Results->BestClass;
  CLASS_ID ClassId;
  BOOL8 AdaptiveOn = TRUE;
  BOOL8 PreTrainedOn = TRUE;

  ShowMatchDisplay();
  cprintf ("\nDebugging class = %c  (%s) ...\n", LastClass, DebugMode);
  ShowBestMatchFor(Blob, LineStats, LastClass, AdaptiveOn, PreTrainedOn);
  UpdateMatchDisplay();

  while ((ClassId = GetClassToDebug (Prompt)) != 0) {
    switch (ClassId) {
      case 'b':
        AdaptiveOn = TRUE;
        PreTrainedOn = FALSE;
        DebugMode = "Adaptive Templates Only";
        break;

      case 'c':
        AdaptiveOn = FALSE;
        PreTrainedOn = TRUE;
        DebugMode = "PreTrained Templates Only";
        break;

      case 'a':
        AdaptiveOn = TRUE;
        PreTrainedOn = TRUE;
        DebugMode = "All Templates";
        break;

      default:
        LastClass = ClassId;
        break;
    }

    ShowMatchDisplay();
    cprintf ("\nDebugging class = %c  (%s) ...\n", LastClass, DebugMode);
    ShowBestMatchFor(Blob, LineStats, LastClass, AdaptiveOn, PreTrainedOn);
    UpdateMatchDisplay();
  }
}                                /* DebugAdaptiveClassifier */

void DoAdaptiveMatch	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		ADAPT_RESULTS *	Results
	)

Performs an adaptive classification.

Parameters:

	Blob	blob to be classified
	LineStats	statistics for text line Blob is in
	Results	place to put match results

Note:

Globals:

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

Returns:

none

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.

Note:

Exceptions: none

Date:

Tue Mar 12 08:50:11 1991, DSJ, Created.

Definition at line 2110 of file adaptmatch.cpp.

References AdaptedTemplates, AdaptiveMatcherCalls, AmbigClassifier(), BaselineClassifier(), ADAPT_RESULTS::BestRating, CharNormClassifier(), ClassifyAsNoise(), InitIntFX, MarginalMatch, ADAPT_RESULTS::NumMatches, ADAPT_TEMPLATES_STRUCT::NumPermClasses, PreTrainedTemplates, tess_bn_matching, and tess_cn_matching.

Referenced by AdaptiveClassifier().

                                             {
  char *Ambiguities;

  AdaptiveMatcherCalls++;
  InitIntFX();

  if (AdaptedTemplates->NumPermClasses < MinNumPermClasses
  || tess_cn_matching) {
    CharNormClassifier(Blob, LineStats, PreTrainedTemplates, Results);
  }
  else {
    Ambiguities = BaselineClassifier (Blob, LineStats,
      AdaptedTemplates, Results);

    if (Results->NumMatches > 0 && MarginalMatch (Results->BestRating)
    && !tess_bn_matching) {
      CharNormClassifier(Blob, LineStats, PreTrainedTemplates, Results);
    }
    else if (Ambiguities && *Ambiguities) {
      AmbigClassifier(Blob,
                      LineStats,
                      PreTrainedTemplates,
                      Ambiguities,
                      Results);
    }
  }

  if (Results->NumMatches == 0)
    ClassifyAsNoise(Blob, LineStats, Results);
  }   /* DoAdaptiveMatch */

void EndAdaptiveClassifier

(

)

Performs cleanup operations on the adaptive classifier.

Parameters:

none

Note:

Globals:

• AdaptedTemplates current set of adapted templates
• SaveAdaptedTemplates TRUE if templates should be saved
• EnableAdaptiveMatcher TRUE if adaptive matcher is enabled

Returns:

none

It should be called before the program is terminated. Its main function is to save the adapted templates to a file.

Finally, free all allocated memory (new for v1.03)

Note:

Exceptions: none

Date:

Tue Mar 19 14:37:06 1991, DSJ, Created.

Definition at line 790 of file adaptmatch.cpp.

References ADAPT_TEMPLATE_SUFFIX, AdaptedTemplates, AllConfigsOff, AllConfigsOn, AllProtosOff, AllProtosOn, cprintf(), EndDangerousAmbigs(), free_int_templates(), FreeBitVector(), FreeNormProtos(), imagefile, NULL, PreTrainedTemplates, PrunedProtos, TempProtoMask, and WriteAdaptedTemplates().

Referenced by dj_cleanup().

                             {
  char Filename[256];
  FILE *File;

  #ifndef SECURE_NAMES
  if (EnableAdaptiveMatcher && SaveAdaptedTemplates) {
    strcpy(Filename, imagefile);
    strcat(Filename, ADAPT_TEMPLATE_SUFFIX);
    File = fopen (Filename, "wb");
    if (File == NULL)
      cprintf ("Unable to save adapted templates to %s!\n", Filename);
    else {
      cprintf ("\nSaving adapted templates to %s ...", Filename);
      fflush(stdout);
      WriteAdaptedTemplates(File, AdaptedTemplates);
      cprintf ("\n");
      fclose(File);
    }
  }
  #endif

  // the following are new for v1.03
  EndDangerousAmbigs();
  FreeNormProtos();
  free_int_templates(PreTrainedTemplates);
  PreTrainedTemplates = NULL;
  FreeBitVector(AllProtosOn);
  FreeBitVector(PrunedProtos);
  FreeBitVector(AllConfigsOn);
  FreeBitVector(AllProtosOff);
  FreeBitVector(AllConfigsOff);
  FreeBitVector(TempProtoMask);
  AllProtosOn = NULL;
  PrunedProtos = NULL;
  AllConfigsOn = NULL;
  AllProtosOff = NULL;
  AllConfigsOff = NULL;
  TempProtoMask = NULL;
}// EndAdaptiveClassifier

int GetAdaptiveFeatures	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		INT_FEATURE_ARRAY	IntFeatures,
		FEATURE_SET *	FloatFeatures
	)

Sets up the feature extractor to extract baseline normalized pico-features.

Parameters:

	Blob	blob to extract features from
	LineStats	statistics about text row blob is in
	IntFeatures	array to fill with integer features
	FloatFeatures	place to return actual floating-pt features

Note:

Globals: none

Returns:

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

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

Note:

Exceptions: none

Date:

Tue Mar 12 17:55:18 1991, DSJ, Created.

Definition at line 1185 of file adaptmatch.cpp.

References baseline, ComputeIntFeatures(), ExtractPicoFeatures(), FreeFeatureSet(), NormMethod, NumFeaturesIn, and UNLIKELY_NUM_FEAT.

Referenced by AdaptToChar(), and compare_tess_blobs().

                                                    {
  FEATURE_SET Features;
  int NumFeatures;

  NormMethod = baseline;
  Features = ExtractPicoFeatures (Blob, LineStats);

  NumFeatures = NumFeaturesIn (Features);
  if (NumFeatures > UNLIKELY_NUM_FEAT) {
    FreeFeatureSet(Features);
    return (0);
  }

  ComputeIntFeatures(Features, IntFeatures);
  *FloatFeatures = Features;

  return (NumFeatures);

}                                /* GetAdaptiveFeatures */

void GetAdaptThresholds	(	TWERD *	Word,
		LINE_STATS *	LineStats,
		const char *	BestChoice,
		const char *	BestRawChoice,
		FLOAT32	Thresholds[]
	)

Tries to estimate how tight the adaptation threshold should be set for each character in the current word.

Parameters:

	Word	current word
	LineStats	line stats for row word is in
	BestChoice	best choice for current word with context
	BestRawChoice	best choice for current word without context
	Thresholds	array of thresholds to be filled in

Note:

Globals:

• EnableNewAdaptRules
• GoodAdaptiveMatch
• PerfectRating
• RatingMargin

Returns:

none (results are returned in Thresholds)

In general, the routine tries to set tighter thresholds for a character when the current set of templates would have made an error on that character. It tries to set a threshold tight enough to eliminate the error. Two different sets of rules can be used to determine the desired thresholds.

If the blob gets incorrectly classified, find the rating threshold needed to create a template which will correct the error with some margin. However, don't waste time trying to make templates which are too tight.

Note:

Exceptions: none

Date:

Fri May 31 09:22:08 1991, DSJ, Created.

Definition at line 2175 of file adaptmatch.cpp.

References wordstruct::blobs, FindClassifierErrors(), GetBestRatingFor(), GoodAdaptiveMatch, blobstruct::next, and NULL.

Referenced by AdaptToWord().

                                                   {
    TBLOB *Blob;

    if (EnableNewAdaptRules) {   /* new rules */
      FindClassifierErrors(PerfectRating,
                           GoodAdaptiveMatch,
                           RatingMargin,
                           Thresholds);
    }
    else {                       /* old rules */
      for (Blob = Word->blobs;
        Blob != NULL;
        Blob = Blob->next, BestChoice++, BestRawChoice++, Thresholds++)
      if (*BestChoice == *BestRawChoice)
        *Thresholds = GoodAdaptiveMatch;
      else {
        /* The blob was incorrectly classified */
        *Thresholds = GetBestRatingFor (Blob, LineStats, *BestChoice);
        *Thresholds *= (1.0 - RatingMargin);
        if (*Thresholds > GoodAdaptiveMatch)
          *Thresholds = GoodAdaptiveMatch;
        if (*Thresholds < PerfectRating)
          *Thresholds = PerfectRating;
      }
    }
  }                              /* GetAdaptThresholds */

char * GetAmbiguities	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		CLASS_ID	CorrectClass
	)

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
	LineStats	statistics for text line blob is in
	CorrectClass	correct class for Blob

Note:

Globals:

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

Returns:

String containing all possible ambiguous classes.

Note:

Exceptions: none

Date:

Fri Mar 15 08:08:22 1991, DSJ, Created.

Definition at line 2220 of file adaptmatch.cpp.

References ADAPT_RESULTS::BestClass, ADAPT_RESULTS::BestConfig, ADAPT_RESULTS::BestRating, CharNormClassifier(), ADAPT_RESULTS::Classes, CompareCurrentRatings(), CurrentRatings, Emalloc(), EnterClassifyMode, InitMatcherRatings(), NO_CLASS, ADAPT_RESULTS::NumMatches, PreTrainedTemplates, ADAPT_RESULTS::Ratings, RemoveBadMatches(), and WORST_POSSIBLE_RATING.

Referenced by MakePermanent().

                                              {
    ADAPT_RESULTS Results;
    char *Ambiguities;
    int i;

    EnterClassifyMode;

    Results.NumMatches = 0;
    Results.BestRating = WORST_POSSIBLE_RATING;
    Results.BestClass = NO_CLASS;
    Results.BestConfig = 0;
    InitMatcherRatings (Results.Ratings);

    CharNormClassifier(Blob, LineStats, PreTrainedTemplates, &Results);
    RemoveBadMatches(&Results);

    /* save ratings in a global so that CompareCurrentRatings() can see them */
    CurrentRatings = Results.Ratings;
    qsort ((void *) (Results.Classes), Results.NumMatches,
      sizeof (CLASS_ID), CompareCurrentRatings);

    /* copy the class id's into an string of ambiguities - don't copy if
       the correct class is the only class id matched */
    Ambiguities = (char *) Emalloc (sizeof (char) * (Results.NumMatches + 1));
    if (Results.NumMatches > 1 ||
    Results.NumMatches == 1 && Results.Classes[0] != CorrectClass) {
      for (i = 0; i < Results.NumMatches; i++)
        Ambiguities[i] = Results.Classes[i];
      Ambiguities[i] = '\0';
    }
    else
      Ambiguities[0] = '\0';

    return (Ambiguities);

  }                              /* GetAmbiguities */

int GetBaselineFeatures	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		INT_TEMPLATES	Templates,
		INT_FEATURE_ARRAY	IntFeatures,
		CLASS_NORMALIZATION_ARRAY	CharNormArray,
		FLOAT32 *	BlobLength
	)

Sets up the feature extractor to extract baseline normalized pico-features.

Parameters:

	Blob	Blob to extract features from
	LineStats	Statistics about text row blob is in
	Templates	Used to compute char norm adjustments
	IntFeatures	Array to fill with integer features
	CharNormArray	Array to fill with dummy char norm adjustments
	BlobLength	Length of blob in baseline-normalized units

Note:

Globals: none

Returns:

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

The extracted pico-features are converted to integer form and placed in IntFeatures. CharNormArray is filled with 0's to indicate to the matcher that no character normalization adjustment needs to be done.

The total length of all blob outlines in baseline normalized units is also returned.

Note:

Exceptions: none

Date:

Tue Mar 12 17:55:18 1991, DSJ, Created.

Definition at line 2281 of file adaptmatch.cpp.

References baseline, ClearCharNormArray(), ComputeIntFeatures(), ExtractPicoFeatures(), FreeFeatureSet(), GetIntBaselineFeatures(), GetPicoFeatureLength, NormMethod, NumFeaturesIn, and UNLIKELY_NUM_FEAT.

Referenced by BaselineClassifier(), GetBestRatingFor(), and ShowBestMatchFor().

                                               {
    FEATURE_SET Features;
    int NumFeatures;

    if (EnableIntFX)
      return (GetIntBaselineFeatures (Blob, LineStats, Templates,
        IntFeatures, CharNormArray, BlobLength));

    NormMethod = baseline;
    Features = ExtractPicoFeatures (Blob, LineStats);

    NumFeatures = NumFeaturesIn (Features);
    *BlobLength = NumFeatures * GetPicoFeatureLength ();
    if (NumFeatures > UNLIKELY_NUM_FEAT) {
      FreeFeatureSet(Features);
      return (0);
    }

    ComputeIntFeatures(Features, IntFeatures);
    ClearCharNormArray(Templates, CharNormArray);

    FreeFeatureSet(Features);
    return (NumFeatures);

  }                              /* GetBaselineFeatures */

FLOAT32 GetBestRatingFor	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		CLASS_ID	ClassId
	)

Classifies Blob against both sets of templates for the specified class and returns the best rating found.

Parameters:

	Blob	blob to get best rating for
	LineStats	statistics about text line blob is in
	ClassId	class blob is to be compared to

Note:

Globals:

• PreTrainedTemplates built-in templates
• AdaptedTemplates current set of adapted templates
• AllProtosOn dummy mask to enable all protos
• AllConfigsOn dummy mask to enable all configs

Returns:

Best rating for match of Blob to ClassId.

Note:

Exceptions: none

Date:

Tue Apr 9 09:01:24 1991, DSJ, Created.

Definition at line 2329 of file adaptmatch.cpp.

References AdaptedTemplates, AllConfigsOn, AllProtosOn, ADAPT_TEMPLATES_STRUCT::Class, ClassForClassId, GetBaselineFeatures(), GetCharNormFeatures(), GetPicoFeatureLength, IndexForClassId, IntegerMatcher(), LegalClassId, MIN, NO_DEBUG, ADAPT_CLASS_STRUCT::PermConfigs, ADAPT_CLASS_STRUCT::PermProtos, PreTrainedTemplates, INT_RESULT_STRUCT::Rating, SetBaseLineMatch(), SetCharNormMatch(), ADAPT_TEMPLATES_STRUCT::Templates, and UnusedClassIdIn.

Referenced by GetAdaptThresholds().

                                             {
    int CNOutlineLength, BLOutlineLength;
    int NumCNFeatures, NumBLFeatures;
    INT_FEATURE_ARRAY CNFeatures, BLFeatures;
    INT_RESULT_STRUCT CNResult, BLResult;
    CLASS_NORMALIZATION_ARRAY CNAdjust, BLAdjust;
    CLASS_INDEX ClassIndex;
    FLOAT32 BlobLength;

    CNResult.Rating = BLResult.Rating = 1.0;

    if (!LegalClassId (ClassId))
      return (1.0);

    if (!UnusedClassIdIn (PreTrainedTemplates, ClassId)) {
      NumCNFeatures = GetCharNormFeatures (Blob, LineStats,
        PreTrainedTemplates,
        CNFeatures, CNAdjust, &BlobLength);
      if (NumCNFeatures > 0) {
        CNOutlineLength = (int) (BlobLength / GetPicoFeatureLength ());
        ClassIndex = IndexForClassId (PreTrainedTemplates, ClassId);

        SetCharNormMatch();
        IntegerMatcher (ClassForClassId (PreTrainedTemplates, ClassId),
          AllProtosOn, AllConfigsOn,
          CNOutlineLength, NumCNFeatures, CNFeatures, 0,
          CNAdjust[ClassIndex], &CNResult, NO_DEBUG);
      }
    }

    if (!UnusedClassIdIn (AdaptedTemplates->Templates, ClassId)) {
      NumBLFeatures = GetBaselineFeatures (Blob, LineStats,
        AdaptedTemplates->Templates,
        BLFeatures, BLAdjust, &BlobLength);
      if (NumBLFeatures > 0) {
        BLOutlineLength = (int) (BlobLength / GetPicoFeatureLength ());
        ClassIndex = IndexForClassId (AdaptedTemplates->Templates, ClassId);

        SetBaseLineMatch();
        IntegerMatcher (ClassForClassId
          (AdaptedTemplates->Templates, ClassId),
          AdaptedTemplates->Class[ClassIndex]->PermProtos,
          AdaptedTemplates->Class[ClassIndex]->PermConfigs,
          BLOutlineLength, NumBLFeatures, BLFeatures, 0,
          BLAdjust[ClassIndex], &BLResult, NO_DEBUG);
      }
    }

    return (MIN (BLResult.Rating, CNResult.Rating));

  }                              /* GetBestRatingFor */

int GetCharNormFeatures	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		INT_TEMPLATES	Templates,
		INT_FEATURE_ARRAY	IntFeatures,
		CLASS_NORMALIZATION_ARRAY	CharNormArray,
		FLOAT32 *	BlobLength
	)

Sets up the feature extractor to extract character normalization features and character normalized pico-features.

Parameters:

	Blob	blob to extract features from
	LineStats	statistics about text row blob is in
	Templates	used to compute char norm adjustments
	IntFeatures	array to fill with integer features
	CharNormArray	array to fill with char norm adjustments
	BlobLength	length of blob in baseline-normalized units

Note:

Globals: none

Returns:

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

The extracted pico-features are converted to integer form and placed in IntFeatures. The character normalization features are matched to each class in templates and the resulting adjustment factors are returned in CharNormArray. The total length of all blob outlines in baseline normalized units is also returned.

Note:

Exceptions: none

Date:

Tue Mar 12 17:55:18 1991, DSJ, Created.

Definition at line 2407 of file adaptmatch.cpp.

References GetIntCharNormFeatures().

Referenced by AmbigClassifier(), CharNormClassifier(), GetBestRatingFor(), and ShowBestMatchFor().

                                               {
    return (GetIntCharNormFeatures (Blob, LineStats, Templates,
      IntFeatures, CharNormArray, BlobLength));
  }                              /* GetCharNormFeatures */

int GetIntBaselineFeatures	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		INT_TEMPLATES	Templates,
		INT_FEATURE_ARRAY	IntFeatures,
		CLASS_NORMALIZATION_ARRAY	CharNormArray,
		FLOAT32 *	BlobLength
	)

Calls the integer feature-extractor if it has not been called before for this blob.

Parameters:

	Blob	blob to extract features from
	LineStats	statistics about text row blob is in
	Templates	used to compute char norm adjustments
	IntFeatures	array to fill with integer features
	CharNormArray	array to fill with dummy char norm adjustments
	BlobLength	length of blob in baseline-normalized units

Note:

Globals:

• FeaturesHaveBeenExtracted TRUE if fx has been done
• BaselineFeatures holds extracted baseline feat
• CharNormFeatures holds extracted char norm feat
• FXInfo holds misc FX info

Returns:

Number of features extracted or 0 if an error occured.

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 baseline features into the IntFeatures array provided by the caller.

Note:

Exceptions: none

Date:

Tue May 28 10:40:52 1991, DSJ, Created.

Definition at line 2444 of file adaptmatch.cpp.

References BaselineFeatures, CharNormFeatures, ClearCharNormArray(), ComputeScaleFactor, ExtractIntFeat(), FeaturesHaveBeenExtracted, FeaturesOK, FXInfo, INT_FX_RESULT_STRUCT::Length, INT_FX_RESULT_STRUCT::NumBL, and TRUE.

Referenced by GetBaselineFeatures().

                                                  {
    register INT_FEATURE Src, Dest, End;

    if (!FeaturesHaveBeenExtracted) {
      FeaturesOK = ExtractIntFeat (Blob, BaselineFeatures,
        CharNormFeatures, &FXInfo);
      FeaturesHaveBeenExtracted = TRUE;
    }

    if (!FeaturesOK) {
      *BlobLength = FXInfo.Length * ComputeScaleFactor (LineStats);
      return (0);
    }

    for (Src = BaselineFeatures, End = Src + FXInfo.NumBL, Dest = IntFeatures;
      Src < End; *Dest++ = *Src++);

    ClearCharNormArray(Templates, CharNormArray);
    *BlobLength = FXInfo.Length * ComputeScaleFactor (LineStats);
    return (FXInfo.NumBL);

  }                              /* GetIntBaselineFeatures */

int GetIntCharNormFeatures	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		INT_TEMPLATES	Templates,
		INT_FEATURE_ARRAY	IntFeatures,
		CLASS_NORMALIZATION_ARRAY	CharNormArray,
		FLOAT32 *	BlobLength
	)

Calls the integer feature-extractor if it has not been called before for this blob.

Parameters:

	Blob	blob to extract features from
	LineStats	statistics about text row blob is in
	Templates	used to compute char norm adjustments
	IntFeatures	array to fill with integer features
	CharNormArray	array to fill with dummy char norm adjustments
	BlobLength	length of blob in baseline-normalized units

Note:

Globals:

• FeaturesHaveBeenExtracted TRUE if fx has been done
• BaselineFeatures holds extracted baseline feat
• CharNormFeatures holds extracted char norm feat
• FXInfo holds misc. FX info

Returns:

Number of features extracted or 0 if an error occured.

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.

Note:

Exceptions: none

Date:

Tue May 28 10:40:52 1991, DSJ, Created.

Definition at line 2499 of file adaptmatch.cpp.

References BaselineAt, BaselineFeatures, CharNormDesc, CharNormFeatures, CharNormLength, CharNormRx, CharNormRy, CharNormY, ComputeIntCharNormArray(), ComputeScaleFactor, ExtractIntFeat(), FeaturesHaveBeenExtracted, FeaturesOK, FreeFeature(), FXInfo, INT_FX_RESULT_STRUCT::Length, LENGTH_COMPRESSION, NewFeature(), INT_FX_RESULT_STRUCT::NumCN, ParamOf, INT_FX_RESULT_STRUCT::Rx, INT_FX_RESULT_STRUCT::Ry, TRUE, INT_FX_RESULT_STRUCT::Xmean, and INT_FX_RESULT_STRUCT::Ymean.

Referenced by GetCharNormFeatures().

                                                  {
    register INT_FEATURE Src, Dest, End;
    FEATURE NormFeature;
    FLOAT32 Baseline, Scale;

    if (!FeaturesHaveBeenExtracted) {
      FeaturesOK = ExtractIntFeat (Blob, BaselineFeatures,
        CharNormFeatures, &FXInfo);
      FeaturesHaveBeenExtracted = TRUE;
    }

    if (!FeaturesOK) {
      *BlobLength = FXInfo.Length * ComputeScaleFactor (LineStats);
      return (0);
    }

    for (Src = CharNormFeatures, End = Src + FXInfo.NumCN, Dest = IntFeatures;
      Src < End; *Dest++ = *Src++);

    NormFeature = NewFeature (&CharNormDesc);
    Baseline = BaselineAt (LineStats, FXInfo.Xmean);
    Scale = ComputeScaleFactor (LineStats);
    ParamOf (NormFeature, CharNormY) = (FXInfo.Ymean - Baseline) * Scale;
    ParamOf (NormFeature, CharNormLength) =
      FXInfo.Length * Scale / LENGTH_COMPRESSION;
    ParamOf (NormFeature, CharNormRx) = FXInfo.Rx * Scale;
    ParamOf (NormFeature, CharNormRy) = FXInfo.Ry * Scale;
    ComputeIntCharNormArray(NormFeature, Templates, CharNormArray);
    FreeFeature(NormFeature);

    *BlobLength = FXInfo.Length * Scale;
    return (FXInfo.NumCN);

  }                              /* GetIntCharNormFeatures */

void InitAdaptiveClassifier

(

)

Reads in the training information needed by the adaptive classifier and saves it into global variables.

Parameters:

none

Note:

Globals:

• BuiltInTemplatesFile file to get built-in temps from
• BuiltInCutoffsFile file to get avg. feat per class from
• PreTrainedTemplates pre-trained configs and protos
• AdaptedTemplates templates adapted to current page
• CharNormCutoffs avg # of features per class
• AllProtosOn dummy proto mask with all bits 1
• AllConfigsOn dummy config mask with all bits 1
• UsePreAdaptedTemplates enables use of pre-adapted templates

Returns:

none

Note:

Exceptions: none

Date:

Mon Mar 11 12:49:34 1991, DSJ, Created.

Definition at line 850 of file adaptmatch.cpp.

References ADAPT_TEMPLATE_SUFFIX, AdaptedTemplates, AllConfigsOff, AllConfigsOn, AllProtosOff, AllProtosOn, BaselineCutoffs, BuiltInCutoffsFile, BuiltInTemplatesFile, CharNormCutoffs, ClassIdForIndex, cprintf(), demodir, Efopen(), GetNormProtos(), imagefile, IndexForClassId, InitIntegerFX(), InitIntegerMatcher(), MAX_NUM_CONFIGS, MAX_NUM_PROTOS, NewAdaptedTemplates(), NewBitVector(), NULL, NumClassesIn, old_enable_learning, PreTrainedTemplates, PrintAdaptedTemplates(), PrunedProtos, ReadAdaptedTemplates(), ReadIntTemplates(), ReadNewCutoffs(), set_all_bits, ADAPT_TEMPLATES_STRUCT::Templates, TempProtoMask, TRUE, WordsInVectorOfSize, and zero_all_bits.

Referenced by mfeature_init().

                              {
  int i;
  FILE *File;
  char Filename[1024];

  if (!EnableAdaptiveMatcher)
    return;

  strcpy(Filename, demodir);
  strcat(Filename, BuiltInTemplatesFile);
  #ifndef SECURE_NAMES
  //      cprintf( "\nReading built-in templates from %s ...",
  //              Filename);
  fflush(stdout);
  #endif

  #ifdef __UNIX__
  File = Efopen (Filename, "r");
  #else
  File = Efopen (Filename, "rb");
  #endif
  PreTrainedTemplates = ReadIntTemplates (File, TRUE);
  fclose(File);

  strcpy(Filename, demodir);
  strcat(Filename, BuiltInCutoffsFile);
  #ifndef SECURE_NAMES
  //      cprintf( "\nReading built-in pico-feature cutoffs from %s ...",
  //              Filename);
  fflush(stdout);
  #endif
  ReadNewCutoffs (Filename, PreTrainedTemplates->IndexFor, CharNormCutoffs);

  GetNormProtos();

  InitIntegerMatcher();
  InitIntegerFX();

  AllProtosOn = NewBitVector (MAX_NUM_PROTOS);
  PrunedProtos = NewBitVector (MAX_NUM_PROTOS);
  AllConfigsOn = NewBitVector (MAX_NUM_CONFIGS);
  AllProtosOff = NewBitVector (MAX_NUM_PROTOS);
  AllConfigsOff = NewBitVector (MAX_NUM_CONFIGS);
  TempProtoMask = NewBitVector (MAX_NUM_PROTOS);
  set_all_bits (AllProtosOn, WordsInVectorOfSize (MAX_NUM_PROTOS));
  set_all_bits (PrunedProtos, WordsInVectorOfSize (MAX_NUM_PROTOS));
  set_all_bits (AllConfigsOn, WordsInVectorOfSize (MAX_NUM_CONFIGS));
  zero_all_bits (AllProtosOff, WordsInVectorOfSize (MAX_NUM_PROTOS));
  zero_all_bits (AllConfigsOff, WordsInVectorOfSize (MAX_NUM_CONFIGS));

  if (UsePreAdaptedTemplates) {
    strcpy(Filename, imagefile);
    strcat(Filename, ADAPT_TEMPLATE_SUFFIX);
    File = fopen (Filename, "rb");
    if (File == NULL)
      AdaptedTemplates = NewAdaptedTemplates ();
    else {
      #ifndef SECURE_NAMES
      cprintf ("\nReading pre-adapted templates from %s ...", Filename);
      fflush(stdout);
      #endif
      AdaptedTemplates = ReadAdaptedTemplates (File);
      cprintf ("\n");
      fclose(File);
      PrintAdaptedTemplates(stdout, AdaptedTemplates);

      for (i = 0; i < NumClassesIn (AdaptedTemplates->Templates); i++) {
        BaselineCutoffs[i] =
          CharNormCutoffs[IndexForClassId (PreTrainedTemplates,
          ClassIdForIndex
          (AdaptedTemplates->Templates,
          i))];
      }
    }
  }
  else
    AdaptedTemplates = NewAdaptedTemplates ();
  old_enable_learning = EnableLearning;

}                                /* InitAdaptiveClassifier */

void InitAdaptiveClassifierVars

(

)

Installs the control knobs used by the adaptive matcher.

Parameters:

none

Note:

Globals: none

Returns:

none

Note:

Exceptions: none

Date:

Mon Mar 11 12:49:34 1991, DSJ, Created.

Definition at line 950 of file adaptmatch.cpp.

References BUILT_IN_CUTOFFS_FILE, BUILT_IN_TEMPLATES_FILE, BuiltInCutoffsFile, BuiltInTemplatesFile, dummy, InitOutlineFXVars(), InitPicoFXVars(), and string_variable.

Referenced by init_dj_debug().

                                  {
  VALUE dummy;

  string_variable (BuiltInTemplatesFile, "BuiltInTemplatesFile",
    BUILT_IN_TEMPLATES_FILE);
  string_variable (BuiltInCutoffsFile, "BuiltInCutoffsFile",
    BUILT_IN_CUTOFFS_FILE);

  MakeEnableAdaptiveMatcher();
  MakeUsePreAdaptedTemplates();
  MakeSaveAdaptedTemplates();

  MakeEnableLearning();
  MakeEnableAdaptiveDebugger();
  MakeBadMatchPad();
  MakeGoodAdaptiveMatch();
  MakeGreatAdaptiveMatch();
  MakeNoiseBlobLength();
  MakeMinNumPermClasses();
  MakeReliableConfigThreshold();
  MakeMaxAngleDelta();
  MakeLearningDebugLevel();
  MakeMatcherDebugLevel();
  MakeMatchDebugFlags();
  MakeRatingMargin();
  MakePerfectRating();
  MakeEnableIntFX();
  MakeEnableNewAdaptRules();
  MakeRatingScale();
  MakeCertaintyScale();

  InitPicoFXVars();
  InitOutlineFXVars();  //?

}                                /* InitAdaptiveClassifierVars */

void InitMatcherRatings

(

register FLOAT32 *

Rating

)

Initializes the best rating for each class to be the worst possible rating (1.0).

Parameters:

Rating

ptr to array of ratings to be initialized

Note:

Globals: none

Returns:

none

Note:

Exceptions: none

Date:

Tue Mar 12 13:43:28 1991, DSJ, Created.

Definition at line 2550 of file adaptmatch.cpp.

References MAX_CLASS_ID, and WORST_POSSIBLE_RATING.

Referenced by AdaptiveClassifier(), AdaptToPunc(), and GetAmbiguities().

                                                    {
    register FLOAT32 *LastRating;
    register FLOAT32 WorstRating = WORST_POSSIBLE_RATING;

    for (LastRating = Rating + MAX_CLASS_ID;
      Rating <= LastRating; *Rating++ = WorstRating);

  }                              /* InitMatcherRatings */

void make_config_pruner	(	INT_TEMPLATES	templates,
		CONFIG_PRUNER *	config_pruner
	)

Prune the possible classes for speed.

Parameters:

	templates	Predefined templates, from tessdata file
	config_pruner	Changed by function

Returns:

none

This is a pre-classifier that is used to create a short-list of classification candidates (pruning the possible classes) so that the full distance metric can be calculated on the short-list without taking excessive time, instead of exhaustively matching against each character possibility.

The class pruner uses a faster, but approximate method of matching the features, so while it does make mistakes, the mistakes are rare.

Definition at line 1679 of file adaptmatch.cpp.

References ClassForIndex, NUM_PP_BUCKETS, NumClassesIn, NumProtoSetsIn, PROTOS_PER_PROTO_SET, and ProtoSetIn.

                                                      {
  int classid;
  int x;                         //feature coord
  int word_index;                //in faster version
  int bit_index;
  UINT32 XFeatureAddress;
  UINT32 YFeatureAddress;
  UINT32 ThetaFeatureAddress;
  INT_CLASS ClassTemplate;
  int ProtoSetIndex;
  PROTO_SET ProtoSet;
  UINT32 *ProtoPrunerPtr;
  UINT32 ProtoNum;
  INT32 proto_offset;
  UINT32 ConfigWord;
  UINT32 ProtoWord;
  INT_PROTO Proto;
  UINT32 x_config_mask;          //forming mask
  UINT32 y_config_mask;          //forming mask
  UINT32 th_config_mask;         //forming mask

  for (classid = 0; classid < NumClassesIn (templates); classid++) {
    ClassTemplate = ClassForIndex (templates, classid);
    for (x = 0; x < NUM_PP_BUCKETS; x++) {
      XFeatureAddress = (x << 1);
      YFeatureAddress = (NUM_PP_BUCKETS << 1) + (x << 1);
      ThetaFeatureAddress = (NUM_PP_BUCKETS << 2) + (x << 1);
      x_config_mask = 0;
      y_config_mask = 0;
      th_config_mask = 0;
      for (ProtoSetIndex = 0;
        ProtoSetIndex < NumProtoSetsIn (ClassTemplate);
      ProtoSetIndex++) {
        ProtoSet = ProtoSetIn (ClassTemplate, ProtoSetIndex);
        ProtoPrunerPtr = (UINT32 *) ((*ProtoSet).ProtoPruner);
        for (ProtoNum = 0; ProtoNum < PROTOS_PER_PROTO_SET;
        ProtoNum += (PROTOS_PER_PROTO_SET >> 1), ProtoPrunerPtr++) {
          /* Prune Protos of current Proto Set */
          ProtoWord = *(ProtoPrunerPtr + XFeatureAddress);
          for (proto_offset = 0; ProtoWord != 0;
          proto_offset++, ProtoWord >>= 1) {
            if (ProtoWord & 1) {
              Proto =
                &(ProtoSet->Protos[ProtoNum + proto_offset]);
              ConfigWord = Proto->Configs[0];
              x_config_mask |= ConfigWord;
            }
          }

          ProtoWord = *(ProtoPrunerPtr + YFeatureAddress);
          for (proto_offset = 0; ProtoWord != 0;
          proto_offset++, ProtoWord >>= 1) {
            if (ProtoWord & 1) {
              Proto =
                &(ProtoSet->Protos[ProtoNum + proto_offset]);
              ConfigWord = Proto->Configs[0];
              y_config_mask |= ConfigWord;
            }
          }

          ProtoWord = *(ProtoPrunerPtr + ThetaFeatureAddress);
          for (proto_offset = 0; ProtoWord != 0;
          proto_offset++, ProtoWord >>= 1) {
            if (ProtoWord & 1) {
              Proto =
                &(ProtoSet->Protos[ProtoNum + proto_offset]);
              ConfigWord = Proto->Configs[0];
              th_config_mask |= ConfigWord;
            }
          }
        }
      }
      for (word_index = 0; word_index < 4; word_index++) {
        ConfigWord = 0;
        for (bit_index = 0; bit_index < 8; bit_index++) {
          if (x_config_mask & 1)
            ConfigWord |= 1 << (bit_index * 4);
          x_config_mask >>= 1;
        }
        config_pruner[classid][0][x][word_index] = ConfigWord;

        ConfigWord = 0;
        for (bit_index = 0; bit_index < 8; bit_index++) {
          if (y_config_mask & 1)
            ConfigWord |= 1 << (bit_index * 4);
          y_config_mask >>= 1;
        }
        config_pruner[classid][1][x][word_index] = ConfigWord;

        ConfigWord = 0;
        for (bit_index = 0; bit_index < 8; bit_index++) {
          if (th_config_mask & 1)
            ConfigWord |= 1 << (bit_index * 4);
          th_config_mask >>= 1;
        }
        config_pruner[classid][2][x][word_index] = ConfigWord;
      }
    }
  }
}

make_float_var	(	CertaintyScale	,
		20.	0,
		MakeCertaintyScale	,
		18	,
		18	,
		SetCertaintyScale	,
		"CertaintyScale: "
	)

make_float_var	(	RatingScale	,
		30.	0,
		MakeRatingScale	,
		18	,
		17	,
		SetRatingScale	,
		"Rating scale: "
	)

make_float_var	(	MaxAngleDelta	,
		0.	015,
		MakeMaxAngleDelta	,
		18	,
		14	,
		SetMaxAngleDelta	,
		"Maximum angle delta for proto clustering: "
	)

make_float_var	(	NoiseBlobLength	,
		0.	6,
		MakeNoiseBlobLength	,
		18	,
		11	,
		SetNoiseBlobLength	,
		"Avg. noise blob length: "
	)

make_float_var	(	RatingMargin	,
		0.	1,
		MakeRatingMargin	,
		18	,
		10	,
		SetRatingMargin	,
		"New template margin (0-1): "
	)

make_float_var	(	BadMatchPad	,
		0.	15,
		MakeBadMatchPad	,
		18	,
		9	,
		SetBadMatchPad	,
		"Bad Match Pad (0-1): "
	)

make_float_var	(	PerfectRating	,
		0.	02,
		MakePerfectRating	,
		18	,
		8	,
		SetPerfectRating	,
		"Perfect Match (0-1): "
	)

make_float_var	(	GreatAdaptiveMatch	,
		0.	0,
		MakeGreatAdaptiveMatch	,
		18	,
		7	,
		SetGreatAdaptiveMatch	,
		"Great Match (0-1): "
	)

make_float_var	(	GoodAdaptiveMatch	,
		0.	125,
		MakeGoodAdaptiveMatch	,
		18	,
		6	,
		SetGoodAdaptiveMatch	,
		"Good Match (0-1): "
	)

make_int_var	(	ReliableConfigThreshold	,
		2	,
		MakeReliableConfigThreshold	,
		18	,
		13	,
		SetReliableConfigThreshold	,
		"Reliable Config Threshold: "
	)

make_int_var	(	MinNumPermClasses	,
		3	,
		MakeMinNumPermClasses	,
		18	,
		12	,
		SetMinNumPermClasses	,
		"Min # of permanent classes: "
	)

make_int_var	(	LearningDebugLevel	,
		0	,
		MakeLearningDebugLevel	,
		18	,
		5	,
		SetLearningDebugLevel	,
		"Learning Debug Level: "
	)

make_int_var	(	MatchDebugFlags	,
		0	,
		MakeMatchDebugFlags	,
		18	,
		3	,
		SetMatchDebugFlags	,
		"Matcher Debug Flags: "
	)

make_int_var	(	MatcherDebugLevel	,
		0	,
		MakeMatcherDebugLevel	,
		18	,
		2	,
		SetMatcherDebugLevel	,
		"Matcher Debug Level: "
	)

make_toggle_const	(	SaveAdaptedTemplates	,
		0	,
		MakeSaveAdaptedTemplates
	)

make_toggle_const	(	UsePreAdaptedTemplates	,
		0	,
		MakeUsePreAdaptedTemplates
	)

make_toggle_const	(	EnableAdaptiveMatcher	,
		1	,
		MakeEnableAdaptiveMatcher
	)

make_toggle_var	(	EnableNewAdaptRules	,
		1	,
		MakeEnableNewAdaptRules	,
		18	,
		16	,
		SetEnableNewAdaptRules	,
		"Enable new adaptation rules"
	)

make_toggle_var	(	EnableIntFX	,
		1	,
		MakeEnableIntFX	,
		18	,
		15	,
		SetEnableIntFX	,
		"Enable integer fx"
	)

make_toggle_var	(	EnableLearning	,
		1	,
		MakeEnableLearning	,
		18	,
		4	,
		SetEnableLearning	,
		"Enable learning"
	)

make_toggle_var	(	EnableAdaptiveDebugger	,
		0	,
		MakeEnableAdaptiveDebugger	,
		18	,
		1	,
		SetEnableAdaptiveDebugger	,
		"Enable match debugger"
	)

void MakeNewAdaptedClass	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		CLASS_ID	ClassId,
		ADAPT_TEMPLATES	Templates
	)

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
	LineStats	statistics for text row blob is in
	ClassId	id of new class to be created
	Templates	adapted templates to add new class to

Note:

Globals:

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

Returns:

none

Note:

Exceptions: none

Date:

Thu Mar 14 12:49:39 1991, DSJ, Created.

Definition at line 1096 of file adaptmatch.cpp.

References AddAdaptedClass(), AddIntConfig(), AddIntProto(), AddProtoToProtoPruner(), AllProtosOn, assert(), baseline, BaselineCutoffs, CharNormCutoffs, ClassForClassId, Config, ConvertConfig(), ConvertProto(), cprintf(), ExtractOutlineFeatures(), FeatureIn, FillABC(), FreeFeatureSet(), IndexForClassId, LearningDebugLevel, NewAdaptedClass(), NewTempConfig(), NewTempProto(), NO_PROTO, NormMethod, NumFeaturesIn, OutlineFeatDir, OutlineFeatLength, OutlineFeatX, OutlineFeatY, ParamOf, PreTrainedTemplates, TEMP_PROTO_STRUCT::Proto, ProtoAngle, TEMP_PROTO_STRUCT::ProtoId, ProtoLength, ProtoX, ProtoY, push(), SET_BIT, TempConfigFor, ADAPT_TEMPLATES_STRUCT::Templates, ADAPT_CLASS_STRUCT::TempProtos, UNLIKELY_NUM_FEAT, and Y_DIM_OFFSET.

Referenced by AdaptToChar(), and compare_tess_blobs().

                                                    {
  FEATURE_SET Features;
  int Fid, Pid;
  FEATURE Feature;
  int NumFeatures;
  TEMP_PROTO TempProto;
  PROTO Proto;
  ADAPT_CLASS Class;
  INT_CLASS IClass;
  CLASS_INDEX ClassIndex;
  TEMP_CONFIG Config;

  NormMethod = baseline;
  Features = ExtractOutlineFeatures (Blob, LineStats);
  NumFeatures = NumFeaturesIn (Features);
  if (NumFeatures > UNLIKELY_NUM_FEAT) {
    FreeFeatureSet(Features);
    return;
  }

  Class = NewAdaptedClass ();
  ClassIndex = AddAdaptedClass (Templates, Class, ClassId);
  Config = NewTempConfig (NumFeatures - 1);
  TempConfigFor (Class, 0) = Config;

  /* This is a kludge to construct cutoffs for adapted templates */
  BaselineCutoffs[ClassIndex] =
    CharNormCutoffs[IndexForClassId (PreTrainedTemplates, ClassId)];

  IClass = ClassForClassId (Templates->Templates, ClassId);

  for (Fid = 0; Fid < NumFeaturesIn (Features); Fid++) {
    Pid = AddIntProto (IClass);
    assert (Pid != NO_PROTO);

    Feature = FeatureIn (Features, Fid);
    TempProto = NewTempProto ();
    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 */
    ProtoAngle (Proto) = ParamOf (Feature, OutlineFeatDir);
    ProtoX (Proto) = ParamOf (Feature, OutlineFeatX);
    ProtoY (Proto) = ParamOf (Feature, OutlineFeatY) - Y_DIM_OFFSET;
    ProtoLength (Proto) = ParamOf (Feature, OutlineFeatLength);
    FillABC(Proto);

    TempProto->ProtoId = Pid;
    SET_BIT (Config->Protos, Pid);

    ConvertProto(Proto, Pid, IClass);
    AddProtoToProtoPruner(Proto, Pid, IClass);

    Class->TempProtos = push (Class->TempProtos, TempProto);
  }
  FreeFeatureSet(Features);

  AddIntConfig(IClass);
  ConvertConfig (AllProtosOn, 0, IClass);

  if (LearningDebugLevel >= 1) {
    cprintf ("Added new class '%c' with index %d and %d protos.\n",
      ClassId, ClassIndex, NumFeatures);
  }

}                                /* MakeNewAdaptedClass */

void MakeNewTemporaryConfig	(	ADAPT_TEMPLATES	Templates,
		CLASS_ID	ClassId,
		int	NumFeatures,
		INT_FEATURE_ARRAY	Features,
		FEATURE_SET	FloatFeatures
	)

Makes new temp config ConfigId using NumOldProtos old and some new protos.

Parameters:

	Templates	Adapted templates to add new config to
	ClassId	Class id to associate with new config
	NumFeatures	Number of features in IntFeatures
	Features	Features describing model for new config
	FloatFeatures	Floating-pt representation of features

Note:

Globals:

• AllProtosOn mask to enable all protos
• AllConfigsOff mask to disable all configs
• TempProtoMask defines old protos matched in new config

Returns:

none

Note:

Exceptions: none

Date:

Fri Mar 15 08:49:46 1991, DSJ, Created.

Definition at line 2576 of file adaptmatch.cpp.

References AddIntConfig(), AllConfigsOff, AllConfigsOn, AllProtosOn, ADAPT_TEMPLATES_STRUCT::Class, ClassForClassId, Config, ConvertConfig(), copy_all_bits, cprintf(), FindBadFeatures(), FindGoodProtos(), IndexForClassId, LearningDebugLevel, MakeNewTempProtos(), MAX_NUM_CONFIGS, MAX_NUM_INT_FEATURES, MAX_NUM_PROTOS, NewTempConfig(), NO_DEBUG, NO_PROTO, NumIntConfigsIn, NumIntProtosIn, PRINT_FEATURE_MATCHES, PRINT_MATCH_SUMMARY, PRINT_PROTO_MATCHES, SET_BIT, TempConfigFor, ADAPT_TEMPLATES_STRUCT::Templates, TempProtoMask, WordsInVectorOfSize, and zero_all_bits.

Referenced by AdaptToChar().

                                                         {
    CLASS_INDEX ClassIndex;
    INT_CLASS IClass;
    ADAPT_CLASS Class;
    PROTO_ID OldProtos[MAX_NUM_PROTOS];
    FEATURE_ID BadFeatures[MAX_NUM_INT_FEATURES];
    int NumOldProtos;
    int NumBadFeatures;
    int MaxProtoId, OldMaxProtoId;
    int BlobLength = 0;
    int MaskSize;
    int ConfigId;
    TEMP_CONFIG Config;
    int i;
    int debug_level = NO_DEBUG;

    if (LearningDebugLevel >= 3)
      debug_level =
        PRINT_MATCH_SUMMARY | PRINT_FEATURE_MATCHES | PRINT_PROTO_MATCHES;

    ClassIndex = IndexForClassId (Templates->Templates, ClassId);
    IClass = ClassForClassId (Templates->Templates, ClassId);
    Class = Templates->Class[ClassIndex];

    if (NumIntConfigsIn (IClass) >= MAX_NUM_CONFIGS)
      return;

    OldMaxProtoId = NumIntProtosIn (IClass) - 1;

    NumOldProtos = FindGoodProtos (IClass, AllProtosOn, AllConfigsOff,
      BlobLength, NumFeatures, Features,
      OldProtos, debug_level);
    NumOldProtos = 0;

    MaskSize = WordsInVectorOfSize (MAX_NUM_PROTOS);
    zero_all_bits(TempProtoMask, MaskSize);
    for (i = 0; i < NumOldProtos; i++)
      SET_BIT (TempProtoMask, OldProtos[i]);

    NumBadFeatures = FindBadFeatures (IClass, TempProtoMask, AllConfigsOn,
      BlobLength, NumFeatures, Features,
      BadFeatures, debug_level);

    MaxProtoId = MakeNewTempProtos (FloatFeatures, NumBadFeatures, BadFeatures,
      IClass, Class, TempProtoMask);
    if (MaxProtoId == NO_PROTO)
      return;

    ConfigId = AddIntConfig (IClass);
    ConvertConfig(TempProtoMask, ConfigId, IClass);
    Config = NewTempConfig (MaxProtoId);
    TempConfigFor (Class, ConfigId) = Config;
    copy_all_bits (TempProtoMask, Config->Protos, Config->ProtoVectorSize);

    if (LearningDebugLevel >= 1)
      cprintf ("Making new temp config %d using %d old and %d new protos.\n",
        ConfigId, NumOldProtos, MaxProtoId - OldMaxProtoId);

  }                              /* MakeNewTemporaryConfig */

PROTO_ID MakeNewTempProtos	(	FEATURE_SET	Features,
		int	NumBadFeat,
		FEATURE_ID	BadFeat[],
		INT_CLASS	IClass,
		ADAPT_CLASS	Class,
		BIT_VECTOR	TempProtoMask
	)

Finds sets of sequential bad features that all have the same angle and converts each set into a new temporary proto.

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

Note:

Globals: none

Returns:

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

The temp proto is added to the proto pruner for IClass, pushed onto the list of temp protos in Class, and added to TempProtoMask.

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

Note:

Exceptions: none

Date:

Fri Mar 15 11:39:38 1991, DSJ, Created.

Definition at line 2664 of file adaptmatch.cpp.

References AddIntProto(), AddProtoToProtoPruner(), ConvertProto(), FeatureIn, FillABC(), GetPicoFeatureLength, NewTempProto(), NO_PROTO, NumIntProtosIn, ParamOf, PicoFeatDir, PicoFeatX, PicoFeatY, TEMP_PROTO_STRUCT::Proto, ProtoAngle, TEMP_PROTO_STRUCT::ProtoId, ProtoLength, ProtoX, ProtoY, push(), SET_BIT, ADAPT_CLASS_STRUCT::TempProtos, and Y_DIM_OFFSET.

Referenced by MakeNewTemporaryConfig().

                                               {
    FEATURE_ID *ProtoStart;
    FEATURE_ID *ProtoEnd;
    FEATURE_ID *LastBad;
    TEMP_PROTO TempProto;
    PROTO Proto;
    FEATURE F1, F2;
    FLOAT32 X1, X2, Y1, Y2;
    FLOAT32 A1, A2, AngleDelta;
    FLOAT32 SegmentLength;
    PROTO_ID Pid;

    for (ProtoStart = BadFeat, LastBad = ProtoStart + NumBadFeat;
    ProtoStart < LastBad; ProtoStart = ProtoEnd) {
      F1 = FeatureIn (Features, *ProtoStart);
      X1 = ParamOf (F1, PicoFeatX);
      Y1 = ParamOf (F1, PicoFeatY);
      A1 = ParamOf (F1, PicoFeatDir);

      for (ProtoEnd = ProtoStart + 1,
        SegmentLength = GetPicoFeatureLength ();
        ProtoEnd < LastBad;
      ProtoEnd++, SegmentLength += GetPicoFeatureLength ()) {
        F2 = FeatureIn (Features, *ProtoEnd);
        X2 = ParamOf (F2, PicoFeatX);
        Y2 = ParamOf (F2, PicoFeatY);
        A2 = ParamOf (F2, PicoFeatDir);

        AngleDelta = fabs (A1 - A2);
        if (AngleDelta > 0.5)
          AngleDelta = 1.0 - AngleDelta;

        if (AngleDelta > MaxAngleDelta ||
          fabs (X1 - X2) > SegmentLength ||
          fabs (Y1 - Y2) > SegmentLength)
          break;
      }

      F2 = FeatureIn (Features, *(ProtoEnd - 1));
      X2 = ParamOf (F2, PicoFeatX);
      Y2 = ParamOf (F2, PicoFeatY);
      A2 = ParamOf (F2, PicoFeatDir);

      Pid = AddIntProto (IClass);
      if (Pid == NO_PROTO)
        return (NO_PROTO);

      TempProto = NewTempProto ();
      Proto = &(TempProto->Proto);

      /* compute proto params using Y_DIM_OFFSET */
      ProtoLength (Proto) = SegmentLength;
      ProtoAngle (Proto) = A1;
      ProtoX (Proto) = (X1 + X2) / 2.0;
      ProtoY (Proto) = (Y1 + Y2) / 2.0 - Y_DIM_OFFSET;
      FillABC(Proto);

      TempProto->ProtoId = Pid;
      SET_BIT(TempProtoMask, Pid);

      ConvertProto(Proto, Pid, IClass);
      AddProtoToProtoPruner(Proto, Pid, IClass);

      Class->TempProtos = push (Class->TempProtos, TempProto);
    }
    return (NumIntProtosIn (IClass) - 1);
  }                              /* MakeNewTempProtos */

void MakePermanent	(	ADAPT_TEMPLATES	Templates,
		CLASS_ID	ClassId,
		int	ConfigId,
		TBLOB *	Blob,
		LINE_STATS *	LineStats
	)

Makes ConfigId permanent with ambiguities from LineStats.

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
	LineStats	statistics about text line Blob is in

Note:

Globals: none

Returns:

none

Note:

Exceptions: none

Date:

Thu Mar 14 15:54:08 1991, DSJ, Created.

Definition at line 2750 of file adaptmatch.cpp.

References ADAPT_TEMPLATES_STRUCT::Class, PROTO_KEY::ClassId, Config, PROTO_KEY::ConfigId, cprintf(), delete_d(), FreeTempConfig(), GetAmbiguities(), IndexForClassId, LearningDebugLevel, MakeConfigPermanent, MakeTempProtoPerm(), ADAPT_TEMPLATES_STRUCT::NumPermClasses, ADAPT_CLASS_STRUCT::NumPermConfigs, PermConfigFor, TempConfigFor, PROTO_KEY::Templates, ADAPT_TEMPLATES_STRUCT::Templates, and ADAPT_CLASS_STRUCT::TempProtos.

Referenced by AdaptToChar().

                                            {
    char *Ambigs;
    TEMP_CONFIG Config;
    CLASS_INDEX ClassIndex;
    ADAPT_CLASS Class;
    PROTO_KEY ProtoKey;

    ClassIndex = IndexForClassId (Templates->Templates, ClassId);
    Class = Templates->Class[ClassIndex];
    Config = TempConfigFor (Class, ConfigId);

    MakeConfigPermanent(Class, ConfigId);
    if (Class->NumPermConfigs == 0)
      Templates->NumPermClasses++;
    Class->NumPermConfigs++;

    ProtoKey.Templates = Templates;
    ProtoKey.ClassId = ClassId;
    ProtoKey.ConfigId = ConfigId;
    Class->TempProtos = delete_d (Class->TempProtos, &ProtoKey,
      MakeTempProtoPerm);
    FreeTempConfig(Config);

    Ambigs = GetAmbiguities (Blob, LineStats, ClassId);
    PermConfigFor (Class, ConfigId) = Ambigs;

    if (LearningDebugLevel >= 1)
      cprintf ("Making config %d permanent with ambiguities '%s'.\n",
        ConfigId, Ambigs);

  }                              /* MakePermanent */

int MakeTempProtoPerm	(	void *	item1,
		void *	item2
	)

Converts TempProto to be permanent if its proto id is used by the configuration specified in ProtoKey.

Parameters:

	item1	temporary proto to compare to key
	item2	defines which protos to make permanent

Note:

Globals: none

Returns:

TRUE if TempProto is converted, FALSE otherwise

Note:

Exceptions: none

Date:

Thu Mar 14 18:49:54 1991, DSJ, Created.

Definition at line 2799 of file adaptmatch.cpp.

References AddProtoToClassPruner(), ADAPT_TEMPLATES_STRUCT::Class, PROTO_KEY::ClassId, Config, PROTO_KEY::ConfigId, FALSE, FreeTempProto(), IndexForClassId, MakeProtoPermanent, TEMP_PROTO_STRUCT::Proto, TEMP_PROTO_STRUCT::ProtoId, TempConfigFor, ADAPT_TEMPLATES_STRUCT::Templates, PROTO_KEY::Templates, test_bit, and TRUE.

Referenced by MakePermanent().

                                     {  //PROTO_KEY             *ProtoKey)
    CLASS_INDEX ClassIndex;
    ADAPT_CLASS Class;
    TEMP_CONFIG Config;
    TEMP_PROTO TempProto;
    PROTO_KEY *ProtoKey;

    TempProto = (TEMP_PROTO) item1;
    ProtoKey = (PROTO_KEY *) item2;

    ClassIndex = IndexForClassId (ProtoKey->Templates->Templates,
      ProtoKey->ClassId);
    Class = ProtoKey->Templates->Class[ClassIndex];
    Config = TempConfigFor (Class, ProtoKey->ConfigId);

    if (TempProto->ProtoId > Config->MaxProtoId ||
      !test_bit (Config->Protos, TempProto->ProtoId))
      return (FALSE);

    MakeProtoPermanent (Class, TempProto->ProtoId);
    AddProtoToClassPruner (&(TempProto->Proto), ProtoKey->ClassId,
      ProtoKey->Templates->Templates);
    FreeTempProto(TempProto);

    return (TRUE);

  }                              /* MakeTempProtoPerm */

int NumBlobsIn

(

TWERD *

Word

)

Returns the number of blobs in Word.

Parameters:

Word

Word to count blobs in

Note:

Globals: none

Returns:

Number of blobs in Word.

Note:

Exceptions: none

Date:

Thu Mar 14 08:30:27 1991, DSJ, Created.

Definition at line 2838 of file adaptmatch.cpp.

References wordstruct::blobs, blobstruct::next, and NULL.

Referenced by AdaptableWord().

                              {
    register TBLOB *Blob;
    register int NumBlobs;

    if (Word == NULL)
      return (0);

    for (Blob = Word->blobs, NumBlobs = 0;
      Blob != NULL; Blob = Blob->next, NumBlobs++);

    return (NumBlobs);

  }                              /* NumBlobsIn */

int NumOutlinesInBlob

(

TBLOB *

Blob

)

Returns the number of OUTER outlines in Blob.

Parameters:

Blob

Blob to count outlines in

Note:

Globals: none

Returns:

Number of outer outlines in Blob.

Note:

Exceptions: none

Date:

Mon Jun 10 15:46:20 1991, DSJ, Created.

Definition at line 2862 of file adaptmatch.cpp.

References NULL, Outline, and blobstruct::outlines.

Referenced by AdaptToWord().

                                     {
    register TESSLINE *Outline;
    register int NumOutlines;

    if (Blob == NULL)
      return (0);

    for (Outline = Blob->outlines, NumOutlines = 0;
      Outline != NULL; Outline = Outline->next, NumOutlines++);

    return (NumOutlines);

}// NumOutlinesInBlob

void PrintAdaptiveMatchResults	(	FILE *	File,
		ADAPT_RESULTS *	Results
	)

Writes the matches in Results to File.

Parameters:

	File	open text file to write Results to
	Results	match results to write to File

Note:

Globals: none

Returns:

none

Note:

Exceptions: none

Date:

Mon Mar 18 09:24:53 1991, DSJ, Created.

Definition at line 2887 of file adaptmatch.cpp.

References ADAPT_RESULTS::Classes, cprintf(), ADAPT_RESULTS::NumMatches, and ADAPT_RESULTS::Ratings.

Referenced by AdaptiveClassifier().

                                                                     {
    int i;

    if (Results->NumMatches > 0) {
      cprintf ("%c(%d)  %4.1f  ", Results->Classes[0], Results->Classes[0],
        Results->Ratings[Results->Classes[0]] * 100.0);

      for (i = 1; i < Results->NumMatches; i++) {
        cprintf ("%c(%d)  %4.1f  ", Results->Classes[i],
          Results->Classes[i],
          Results->Ratings[Results->Classes[i]] * 100.0);
      }
    }
  }                              /* PrintAdaptiveMatchResults */

void PrintAdaptiveStatistics

(

FILE *

File

)

Print to File the statistics which have been gathered for the adaptive matcher.

Parameters:

File

open text file to print adaptive statistics to

Note:

Globals: none

Returns:

none

Note:

Exceptions: none

Date:

Thu Apr 18 14:37:37 1991, DSJ, Created.

Definition at line 998 of file adaptmatch.cpp.

References AdaptedTemplates, AdaptiveMatcherCalls, AmbigClassifierCalls, BaselineClassifierCalls, CharNormClassifierCalls, NumAmbigClassesTried, NumBaselineClassesTried, NumCharNormClassesTried, NumCharsAdaptedTo, NumClassesOutput, NumWordsAdaptedTo, and PrintAdaptedTemplates().

Referenced by dj_statistics().

                                         {
  #ifndef SECURE_NAMES

  fprintf (File, "\nADAPTIVE MATCHER STATISTICS:\n");
  fprintf (File, "\tNum blobs classified = %d\n", AdaptiveMatcherCalls);
  fprintf (File, "\tNum classes output   = %d (Avg = %4.2f)\n",
    NumClassesOutput,
    ((AdaptiveMatcherCalls == 0) ? (0.0) :
  ((float) NumClassesOutput / AdaptiveMatcherCalls)));
  fprintf (File, "\t\tBaseline Classifier: %4d calls (%4.2f classes/call)\n",
    BaselineClassifierCalls,
    ((BaselineClassifierCalls == 0) ? (0.0) :
  ((float) NumBaselineClassesTried / BaselineClassifierCalls)));
  fprintf (File, "\t\tCharNorm Classifier: %4d calls (%4.2f classes/call)\n",
    CharNormClassifierCalls,
    ((CharNormClassifierCalls == 0) ? (0.0) :
  ((float) NumCharNormClassesTried / CharNormClassifierCalls)));
  fprintf (File, "\t\tAmbig    Classifier: %4d calls (%4.2f classes/call)\n",
    AmbigClassifierCalls,
    ((AmbigClassifierCalls == 0) ? (0.0) :
  ((float) NumAmbigClassesTried / AmbigClassifierCalls)));

  fprintf (File, "\nADAPTIVE LEARNER STATISTICS:\n");
  fprintf (File, "\tNumber of words adapted to: %d\n", NumWordsAdaptedTo);
  fprintf (File, "\tNumber of chars adapted to: %d\n", NumCharsAdaptedTo);

  PrintAdaptedTemplates(File, AdaptedTemplates);
  #endif
}                                /* PrintAdaptiveStatistics */

void RemoveBadMatches

(

ADAPT_RESULTS *

Results

)

Steps thru each matching class in Results and removes it from the match list if its rating is worse than the BestRating plus a pad - all good matches get moved to the front of the classes array.

Parameters:

Results

contains matches to be filtered

Note:

Globals: BadMatchPad defines a "bad match"

Returns:

none

Note:

Exceptions: none

Date:

Tue Mar 12 13:51:03 1991, DSJ, Created.

Definition at line 2915 of file adaptmatch.cpp.

References ADAPT_RESULTS::BestRating, ADAPT_RESULTS::Classes, NULL, ADAPT_RESULTS::NumMatches, and ADAPT_RESULTS::Ratings.

Referenced by AdaptiveClassifier(), AdaptToPunc(), and GetAmbiguities().

                                                {
    int Next, NextGood;
    FLOAT32 *Rating = Results->Ratings;
    CLASS_ID *Match = Results->Classes;
    FLOAT32 BadMatchThreshold;
    static const char* romans = "ivxIVX";
    BadMatchThreshold = Results->BestRating + BadMatchPad;

    if (bln_numericmode) {
      for (Next = NextGood = 0; Next < Results->NumMatches; Next++) {
        if (Rating[Match[Next]] <= BadMatchThreshold) {
          if (!isalpha(Match[Next]) || strchr(romans, Match[Next]) != NULL) {
            Match[NextGood++] = Match[Next];
          } else if (Match[Next] == 'l' && Rating['1'] >= BadMatchThreshold) {
            Match[NextGood++] = '1';
            Rating['1'] = Rating['l'];
          } else if (Match[Next] == 'O' && Rating['0'] >= BadMatchThreshold) {
              Match[NextGood++] = '0';
              Rating['0'] = Rating['O'];
          }
        }
      }
    }
    else {
      for (Next = NextGood = 0; Next < Results->NumMatches; Next++) {
        if (Rating[Match[Next]] <= BadMatchThreshold)
          Match[NextGood++] = Match[Next];
      }
    }

    Results->NumMatches = NextGood;

  }                              /* RemoveBadMatches */

void RemoveExtraPuncs

(

ADAPT_RESULTS *

Results

)

Steps thru each matching class in Results and removes it from the match list if its rating is worse than the BestRating plus a pad - all good matches get moved to the front of the classes array.

Parameters:

Results

contains matches to be filtered

Note:

Globals: BadMatchPad defines a "bad match"

Returns:

none

Note:

Exceptions: none

Date:

Tue Mar 12 13:51:03 1991, DSJ, Created.

Definition at line 2962 of file adaptmatch.cpp.

References ADAPT_RESULTS::Classes, NULL, and ADAPT_RESULTS::NumMatches.

Referenced by AdaptiveClassifier().

                                                {
    int Next, NextGood;
    int punc_count;              /*no of garbage characters */
    int digit_count;
    CLASS_ID *Match = Results->Classes;
                                 /*garbage characters */
    static char punc_chars[] = ".,;:/`~'-=\\|\"!_^";
    static char digit_chars[] = "0123456789";

    punc_count = 0;
    digit_count = 0;
    for (Next = NextGood = 0; Next < Results->NumMatches; Next++) {
      if (strchr (punc_chars, Match[Next]) == NULL) {
        if (strchr (digit_chars, Match[Next]) == NULL) {
          Match[NextGood++] = Match[Next];
        }
        else {
          if (digit_count < 1)
            Match[NextGood++] = Match[Next];
          digit_count++;
        }
      }
      else {
        if (punc_count < 2)
          Match[NextGood++] = Match[Next];
        punc_count++;            /*count them */
      }
    }
    Results->NumMatches = NextGood;
  }                              /* RemoveExtraPuncs */

void ResetAdaptiveClassifier

(

)

Free allocated memory and reset templates.

Definition at line 934 of file adaptmatch.cpp.

References AdaptedTemplates, free_adapted_templates(), and NULL.

Referenced by TessBaseAPI::ClearAdaptiveClassifier(), and TessBaseAPI::End().

                               {
  free_adapted_templates(AdaptedTemplates);
  AdaptedTemplates = NULL;
}

void SetAdaptiveThreshold

(

FLOAT32

Threshold

)

Resets the internal thresholds inside the integer matcher to correspond to the specified threshold.

Parameters:

Threshold

threshold for creating new templates

Note:

Globals: GoodAdaptiveMatch default good match rating

Returns:

none

Note:

Exceptions: none

Date:

Tue Apr 9 08:33:13 1991, DSJ, Created.

Definition at line 3004 of file adaptmatch.cpp.

References GoodAdaptiveMatch, SetFeatureThresh(), and SetProtoThresh().

Referenced by AdaptToChar().

                                               {
    if (Threshold == GoodAdaptiveMatch) {
      /* the blob was probably classified correctly - use the default rating
         threshold */
      SetProtoThresh (0.9);
      SetFeatureThresh (0.9);
    }
    else {
      /* the blob was probably incorrectly classified */
      SetProtoThresh (1.0 - Threshold);
      SetFeatureThresh (1.0 - Threshold);
    }
  }                              /* SetAdaptiveThreshold */

void SettupPass1

(

)

This routine prepares the adaptive matcher for the start of the first pass.

Parameters:

none

Note:

Globals:

• EnableLearning set to TRUE by this routine

Returns:

none

Learning is enabled (unless it is disabled for the whole program).

Note:

Exceptions: none

Date:

Mon Apr 15 16:39:29 1991, DSJ, Created.

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.

Definition at line 1050 of file adaptmatch.cpp.

References old_enable_learning, and SettupStopperPass1().

Referenced by set_pass1().

                   {
  EnableLearning = old_enable_learning;

  SettupStopperPass1();

}                                /* SettupPass1 */

void SettupPass2

(

)

Prepares the adaptive matcher for the start of the second pass.

Parameters:

none

Note:

Globals:

• EnableLearning set to FALSE by this routine

Returns:

none

Further learning is disabled.

Note:

Exceptions: none

Date:

Mon Apr 15 16:39:29 1991, DSJ, Created.

Definition at line 1072 of file adaptmatch.cpp.

References FALSE, and SettupStopperPass2().

Referenced by set_pass2().

                   {
  EnableLearning = FALSE;
  SettupStopperPass2();

}                                /* SettupPass2 */

void ShowBestMatchFor	(	TBLOB *	Blob,
		LINE_STATS *	LineStats,
		CLASS_ID	ClassId,
		BOOL8	AdaptiveOn,
		BOOL8	PreTrainedOn
	)

Compares Blob to both sets of templates (adaptive and pre-trained) and then displays debug information for the config which matched best.

Parameters:

	Blob	blob to show best matching config for
	LineStats	statistics for text line Blob is in
	ClassId	class whose configs are to be searched
	AdaptiveOn	TRUE if adaptive configs are enabled
	PreTrainedOn	TRUE if pretrained configs are enabled

Note:

Globals:

• PreTrainedTemplates built-in training
• AdaptedTemplates adaptive templates
• AllProtosOn dummy proto mask
• AllConfigsOn dummy config mask

Returns:

none

Note:

Exceptions: none
Some changes for v1.03

Date:

Fri Mar 22 08:43:52 1991, DSJ, Created.

Definition at line 3039 of file adaptmatch.cpp.

References AdaptedTemplates, AllConfigsOn, AllProtosOn, baseline, character, ClassForClassId, INT_RESULT_STRUCT::Config, cprintf(), GetBaselineFeatures(), GetCharNormFeatures(), GetPicoFeatureLength, IndexForClassId, IntegerMatcher(), LegalClassId, NO_DEBUG, NormMethod, PreTrainedTemplates, INT_RESULT_STRUCT::Rating, SetBaseLineMatch(), SetCharNormMatch(), ADAPT_TEMPLATES_STRUCT::Templates, and UnusedClassIdIn.

Referenced by DebugAdaptiveClassifier().

                                            {
    int CNOutlineLength = 0, BLOutlineLength = 0;
    int NumCNFeatures = 0, NumBLFeatures = 0;
    INT_FEATURE_ARRAY CNFeatures, BLFeatures;
    INT_RESULT_STRUCT CNResult, BLResult;
    CLASS_NORMALIZATION_ARRAY CNAdjust, BLAdjust;
    CLASS_INDEX ClassIndex;
    FLOAT32 BlobLength;
    UINT32 ConfigMask;
    static int next_config = -1;

    if (PreTrainedOn) next_config = -1;

    CNResult.Rating = BLResult.Rating = 2.0;

    if (!LegalClassId (ClassId)) {
      cprintf ("%c is not a legal class!!\n", ClassId);
      return;
    }

    if (PreTrainedOn)
      if (UnusedClassIdIn (PreTrainedTemplates, ClassId))
        cprintf ("No built-in templates for class '%c'\n", ClassId);
    else {
      NumCNFeatures = GetCharNormFeatures (Blob, LineStats,
        PreTrainedTemplates,
        CNFeatures, CNAdjust,
        &BlobLength);
      if (NumCNFeatures <= 0)
        cprintf ("Illegal blob (char norm features)!\n");
      else {
        CNOutlineLength = (int) (BlobLength / GetPicoFeatureLength ());
        ClassIndex = IndexForClassId (PreTrainedTemplates, ClassId);

        SetCharNormMatch();
        IntegerMatcher (ClassForClassId (PreTrainedTemplates, ClassId),
          AllProtosOn, AllConfigsOn,
          CNOutlineLength, NumCNFeatures, CNFeatures, 0,
          CNAdjust[ClassIndex], &CNResult, NO_DEBUG);

        cprintf ("Best built-in template match is config %2d (%4.1f) (cn=%d)\n",
          CNResult.Config, CNResult.Rating * 100.0, CNAdjust[ClassIndex]);
      }
    }

    if (AdaptiveOn)
      if (UnusedClassIdIn (AdaptedTemplates->Templates, ClassId))
        cprintf ("No AD templates for class '%c'\n", ClassId);
    else {
      NumBLFeatures = GetBaselineFeatures (Blob, LineStats,
        AdaptedTemplates->Templates,
        BLFeatures, BLAdjust,
        &BlobLength);
      if (NumBLFeatures <= 0)
        cprintf ("Illegal blob (baseline features)!\n");
      else {
        BLOutlineLength = (int) (BlobLength / GetPicoFeatureLength ());
        ClassIndex =
          IndexForClassId (AdaptedTemplates->Templates, ClassId);

        SetBaseLineMatch();
        IntegerMatcher (ClassForClassId
          (AdaptedTemplates->Templates, ClassId),
                        AllProtosOn, AllConfigsOn,
//          AdaptedTemplates->Class[ClassIndex]->PermProtos,
//          AdaptedTemplates->Class[ClassIndex]->PermConfigs,
          BLOutlineLength, NumBLFeatures, BLFeatures, 0,
          BLAdjust[ClassIndex], &BLResult, NO_DEBUG);

        #ifndef SECURE_NAMES
        cprintf ("Best adaptive template match is config %2d (%4.1f)\n",
          BLResult.Config, BLResult.Rating * 100.0);
        #endif
      }
    }

    cprintf ("\n");
    if (BLResult.Rating < CNResult.Rating) {
      ClassIndex = IndexForClassId (AdaptedTemplates->Templates, ClassId);
      if (next_config < 0) {
        ConfigMask = 1 << BLResult.Config;
        next_config = 0;
      } else {
        ConfigMask = 1 << next_config;
        ++next_config;
      }
      NormMethod = baseline;

      SetBaseLineMatch();
      IntegerMatcher (ClassForClassId (AdaptedTemplates->Templates, ClassId),
                      AllProtosOn,
//        AdaptedTemplates->Class[ClassIndex]->PermProtos,
        (BIT_VECTOR) & ConfigMask,
        BLOutlineLength, NumBLFeatures, BLFeatures, 0,
        BLAdjust[ClassIndex], &BLResult, MatchDebugFlags);
      cprintf ("Adaptive template match for config %2d is %4.1f\n",
        BLResult.Config, BLResult.Rating * 100.0);
    }
    else {
      ClassIndex = IndexForClassId (PreTrainedTemplates, ClassId);
      ConfigMask = 1 << CNResult.Config;
      NormMethod = character;

      SetCharNormMatch();
                                 //xiaofan
      IntegerMatcher (ClassForClassId (PreTrainedTemplates, ClassId), AllProtosOn, (BIT_VECTOR) & ConfigMask,
        CNOutlineLength, NumCNFeatures, CNFeatures, 0,
        CNAdjust[ClassIndex], &CNResult, MatchDebugFlags);
    }
}// ShowBestMatchFor

---

Variable Documentation

ADAPT_TEMPLATES AdaptedTemplates [static]

Adapted templates

Definition at line 507 of file adaptmatch.cpp.

Referenced by AdaptiveClassifier(), AdaptToChar(), DoAdaptiveMatch(), EndAdaptiveClassifier(), GetBestRatingFor(), InitAdaptiveClassifier(), PrintAdaptiveStatistics(), ResetAdaptiveClassifier(), and ShowBestMatchFor().

int AdaptiveMatcherCalls = 0 [static]

Definition at line 457 of file adaptmatch.cpp.

Referenced by DoAdaptiveMatch(), and PrintAdaptiveStatistics().

BIT_VECTOR AllConfigsOff [static]

Definition at line 516 of file adaptmatch.cpp.

Referenced by EndAdaptiveClassifier(), InitAdaptiveClassifier(), and MakeNewTemporaryConfig().

BIT_VECTOR AllConfigsOn [static]

Definition at line 514 of file adaptmatch.cpp.

Referenced by AdaptToChar(), AmbigClassifier(), compare_tess_blobs(), EndAdaptiveClassifier(), GetBestRatingFor(), InitAdaptiveClassifier(), MakeNewTemporaryConfig(), and ShowBestMatchFor().

BIT_VECTOR AllProtosOff [static]

Definition at line 515 of file adaptmatch.cpp.

Referenced by EndAdaptiveClassifier(), and InitAdaptiveClassifier().

BIT_VECTOR AllProtosOn [static]

Dummy proto and config masks for use with the built-in templates.

Definition at line 512 of file adaptmatch.cpp.

Referenced by AdaptToChar(), AmbigClassifier(), compare_tess_blobs(), EndAdaptiveClassifier(), GetBestRatingFor(), InitAdaptiveClassifier(), MakeNewAdaptedClass(), MakeNewTemporaryConfig(), and ShowBestMatchFor().

int AmbigClassifierCalls = 0 [static]

Definition at line 460 of file adaptmatch.cpp.

Referenced by AmbigClassifier(), and PrintAdaptiveStatistics().

int BaselineClassifierCalls = 0 [static]

Definition at line 458 of file adaptmatch.cpp.

Referenced by BaselineClassifier(), and PrintAdaptiveStatistics().

CLASS_CUTOFF_ARRAY BaselineCutoffs [static]

Definition at line 502 of file adaptmatch.cpp.

Referenced by BaselineClassifier(), InitAdaptiveClassifier(), and MakeNewAdaptedClass().

INT_FEATURE_ARRAY BaselineFeatures [static]

Definition at line 483 of file adaptmatch.cpp.

Referenced by GetIntBaselineFeatures(), and GetIntCharNormFeatures().

const char* BuiltInCutoffsFile = BUILT_IN_CUTOFFS_FILE [static]

Definition at line 500 of file adaptmatch.cpp.

Referenced by InitAdaptiveClassifier(), and InitAdaptiveClassifierVars().

const char* BuiltInTemplatesFile = BUILT_IN_TEMPLATES_FILE [static]

Filenames of training data.

Definition at line 499 of file adaptmatch.cpp.

Referenced by InitAdaptiveClassifier(), and InitAdaptiveClassifierVars().

int CharNormClassifierCalls = 0 [static]

Definition at line 459 of file adaptmatch.cpp.

Referenced by CharNormClassifier(), and PrintAdaptiveStatistics().

CLASS_CUTOFF_ARRAY CharNormCutoffs [static]

Definition at line 501 of file adaptmatch.cpp.

Referenced by CharNormClassifier(), InitAdaptiveClassifier(), and MakeNewAdaptedClass().

INT_FEATURE_ARRAY CharNormFeatures [static]

Definition at line 484 of file adaptmatch.cpp.

Referenced by GetIntBaselineFeatures(), and GetIntCharNormFeatures().

FLOAT32* CurrentRatings [static]

Current ratings.

Hold onto the current ratings so that the comparison function passes to qsort can get at them

Definition at line 494 of file adaptmatch.cpp.

Referenced by AdaptiveClassifier(), CompareCurrentRatings(), and GetAmbiguities().

BOOL8 FeaturesHaveBeenExtracted = FALSE [static]

Definition at line 481 of file adaptmatch.cpp.

Referenced by GetIntBaselineFeatures(), and GetIntCharNormFeatures().

BOOL8 FeaturesOK = TRUE [static]

Definition at line 482 of file adaptmatch.cpp.

Referenced by GetIntBaselineFeatures(), and GetIntCharNormFeatures().

INT_FX_RESULT_STRUCT FXInfo [static]

Definition at line 486 of file adaptmatch.cpp.

Referenced by ExtractCharNormFeatures(), GetIntBaselineFeatures(), and GetIntCharNormFeatures().

char imagefile[]

Image file name

Definition at line 53 of file globals.cpp.

Referenced by add_document_word(), apply_boxes(), EndAdaptiveClassifier(), InitAdaptiveClassifier(), LearnBlob(), program_editup2(), and save_summary().

int NumAmbigClassesTried = 0 [static]

Definition at line 465 of file adaptmatch.cpp.

Referenced by AmbigClassifier(), and PrintAdaptiveStatistics().

int NumBaselineClassesTried = 0 [static]

Definition at line 463 of file adaptmatch.cpp.

Referenced by BaselineClassifier(), and PrintAdaptiveStatistics().

int NumCharNormClassesTried = 0 [static]

Definition at line 464 of file adaptmatch.cpp.

Referenced by CharNormClassifier(), and PrintAdaptiveStatistics().

int NumCharsAdaptedTo = 0 [static]

Definition at line 462 of file adaptmatch.cpp.

Referenced by AdaptToChar(), and PrintAdaptiveStatistics().

int NumClassesOutput = 0 [static]

Definition at line 466 of file adaptmatch.cpp.

Referenced by AdaptiveClassifier(), and PrintAdaptiveStatistics().

int NumWordsAdaptedTo = 0 [static]

Definition at line 461 of file adaptmatch.cpp.

Referenced by AdaptToWord(), and PrintAdaptiveStatistics().

int old_enable_learning = 1 [static]

Definition at line 539 of file adaptmatch.cpp.

Referenced by InitAdaptiveClassifier(), and SettupPass1().

INT_TEMPLATES PreTrainedTemplates [static]

Built-in templates

Definition at line 505 of file adaptmatch.cpp.

Referenced by AdaptToPunc(), AddNewResult(), DoAdaptiveMatch(), EndAdaptiveClassifier(), GetAmbiguities(), GetBestRatingFor(), InitAdaptiveClassifier(), MakeNewAdaptedClass(), and ShowBestMatchFor().

BIT_VECTOR PrunedProtos [static]

Definition at line 513 of file adaptmatch.cpp.

Referenced by CharNormClassifier(), EndAdaptiveClassifier(), and InitAdaptiveClassifier().

BIT_VECTOR TempProtoMask [static]

Definition at line 517 of file adaptmatch.cpp.

Referenced by EndAdaptiveClassifier(), InitAdaptiveClassifier(), and MakeNewTemporaryConfig().

int tess_bn_matching = 0

Definition at line 591 of file adaptmatch.cpp.

Referenced by DoAdaptiveMatch(), tess_bn_matcher(), tess_cn_matcher(), tess_default_matcher(), and tess_training_tester().

int tess_cn_matching = 0

Definition at line 590 of file adaptmatch.cpp.

Referenced by DoAdaptiveMatch(), tess_bn_matcher(), tess_cn_matcher(), tess_default_matcher(), and tess_training_tester().

---