classify/adaptmatch.h File Reference

#include "oldlist.h"
#include "tessclas.h"
#include "fxdefs.h"
#include "matchdefs.h"
#include "adaptive.h"
#include "ocrfeatures.h"

Go to the source code of this file.

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 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 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 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 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 PrintAdaptiveStatistics (FILE *File)

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

• void ResetAdaptiveClassifier ()

  Free allocated memory and reset templates.
  

• 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.
  

Variables

• float GoodAdaptiveMatch
• float GreatAdaptiveMatch
• int LearningDebugLevel
• int ReliableConfigThreshold
• int tess_bn_matching
• int tess_cn_matching

---

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 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 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 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 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 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 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 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 */

---

Variable Documentation

float GoodAdaptiveMatch

Note:

File: adaptmatch.h
Interface to high-level adaptive matcher

Author:

Dan Johnson

Date:

Mon Mar 11 11:48:48 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.

Referenced by GetAdaptThresholds(), set_tess_tweak_vars(), and SetAdaptiveThreshold().

float GreatAdaptiveMatch

Referenced by set_tess_tweak_vars().

int LearningDebugLevel

Referenced by AdaptToChar(), AdaptToPunc(), AdaptToWord(), ConvertProto(), FillPPCircularBits(), FillPPLinearBits(), MakeNewAdaptedClass(), MakeNewTemporaryConfig(), and MakePermanent().

int ReliableConfigThreshold

Referenced by init_tesseract().

int tess_bn_matching

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

Definition at line 590 of file adaptmatch.cpp.

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

---