adaptmatch.cpp

来自「一个google的OCR源码」· C++ 代码 · 共 1,846 行 · 第 1/5 页

**                          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.
**                          Return: none
**                          Exceptions: none
**                          History: Tue Mar 12 18:19:29 1991, DSJ, Created.
*/
  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,
                     UNICHAR_ID *Ambiguities,
                     ADAPT_RESULTS *Results) {
/*
 **                         Parameters:
 **                         Blob
              blob to be classified
**                          LineStats
              statistics for text line Blob is in
**                          Templates
              built-in templates to classify against
**                          Ambiguities
              array of class id's to match against
**                          Results
              place to put match results
**                          Globals:
**                          AllProtosOn
              mask that enables all protos
**                          AllConfigsOn
              mask that enables all configs
**                          Operation: This routine is identical to CharNormClassifier()
**                          except that it does no class pruning.  It simply matches
**                          the unknown blob against the classes listed in
**                          Ambiguities.
**                          Return: none
**                          Exceptions: none
**                          History: Tue Mar 12 19:40:36 1991, DSJ, Created.
*/
  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;

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

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

    SetCharNormMatch();
    IntegerMatcher (ClassForClassId (Templates, ClassId),
      AllProtosOn, AllConfigsOn,
      Results->BlobLength, NumFeatures, IntFeatures,
      CharNormArray[ClassIndex], &IntResult, NO_DEBUG);

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

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

    Ambiguities++;

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

}                                /* AmbigClassifier */

/*---------------------------------------------------------------------------*/
// Factored-out calls to IntegerMatcher based on class pruner results.
// Returns integer matcher results inside CLASS_PRUNER_RESULTS structure.
void MasterMatcher(INT_TEMPLATES templates,
                   inT16 num_features,
                   INT_FEATURE_ARRAY features,
                   CLASS_NORMALIZATION_ARRAY norm_factors,
                   ADAPT_CLASS* classes,
                   int debug,
                   int num_classes,
                   CLASS_PRUNER_RESULTS results,
                   ADAPT_RESULTS* final_results) {
  for (int c = 0; c < num_classes; c++) {
    CLASS_ID class_id = results[c].Class;
    INT_RESULT_STRUCT& int_result = results[c].IMResult;
    CLASS_INDEX class_index = IndexForClassId(templates, class_id);
    BIT_VECTOR protos = classes != NULL ? classes[class_index]->PermProtos
                                        : AllProtosOn;
    BIT_VECTOR configs = classes != NULL ? classes[class_index]->PermConfigs
                                         : AllConfigsOn;

    IntegerMatcher(ClassForClassId(templates, class_id),
                   protos, configs, final_results->BlobLength,
                   num_features, features, norm_factors[class_index],
                   &int_result, NO_DEBUG);
    // Compute class feature corrections.
    double miss_penalty = tessedit_class_miss_scale *
                          int_result.FeatureMisses;
    if (MatcherDebugLevel >= 2 || display_ratings > 1) {
      cprintf("%s-%-2d %2.1f(CP%2.1f, IM%2.1f + MP%2.1f)  ",
              unicharset.id_to_unichar(class_id), int_result.Config,
              (int_result.Rating + miss_penalty) * 100.0,
              results[c].Rating * 100.0,
              int_result.Rating * 100.0, miss_penalty * 100.0);
      if (c % 4 == 3)
        cprintf ("\n");
    }
    int_result.Rating += miss_penalty;
    if (int_result.Rating > WORST_POSSIBLE_RATING)
      int_result.Rating = WORST_POSSIBLE_RATING;
    AddNewResult(final_results, class_id, int_result.Rating, int_result.Config);
  }
  if (MatcherDebugLevel >= 2 || display_ratings > 1)
    cprintf("\n");
}

/*---------------------------------------------------------------------------*/
UNICHAR_ID *BaselineClassifier(TBLOB *Blob,
                               LINE_STATS *LineStats,
                               ADAPT_TEMPLATES Templates,
                               ADAPT_RESULTS *Results) {
/*
 **                         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
**                          Globals:
**                          BaselineCutoffs
              expected num features for each class
**                          Operation: This routine extracts baseline normalized features
**                          from the unknown character and matches them against the
**                          specified set of templates.  The classes which match
**                          are added to Results.
**                          Return: Array of possible ambiguous chars that should be checked.
**                          Exceptions: none
**                          History: Tue Mar 12 19:38:03 1991, DSJ, Created.
*/
  int NumFeatures;
  int NumClasses;
  INT_FEATURE_ARRAY IntFeatures;
  CLASS_NORMALIZATION_ARRAY CharNormArray;
  CLASS_ID ClassId;
  CLASS_INDEX ClassIndex;

  BaselineClassifierCalls++;

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

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

  NumBaselineClassesTried += NumClasses;

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

  SetBaseLineMatch();
  MasterMatcher(Templates->Templates, NumFeatures, IntFeatures, CharNormArray,
                Templates->Class, MatchDebugFlags, NumClasses,
                Results->CPResults, Results);

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

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


/*---------------------------------------------------------------------------*/
void CharNormClassifier(TBLOB *Blob,
                        LINE_STATS *LineStats,
                        INT_TEMPLATES Templates,
                        ADAPT_RESULTS *Results) {
/*
 **                         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
**                          Globals:
**                          CharNormCutoffs
              expected num features for each class
**                          AllProtosOn
              mask that enables all protos
**                          AllConfigsOn
              mask that enables all configs
**                          Operation: This routine extracts character normalized features
**                          from the unknown character and matches them against the
**                          specified set of templates.  The classes which match
**                          are added to Results.
**                          Return: none
**                          Exceptions: none
**                          History: Tue Mar 12 16:02:52 1991, DSJ, Created.
*/
  int NumFeatures;
  int NumClasses;
  INT_FEATURE_ARRAY IntFeatures;
  CLASS_NORMALIZATION_ARRAY CharNormArray;

  CharNormClassifierCalls++;

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

  NumClasses = ClassPruner(Templates, NumFeatures,
                           IntFeatures, CharNormArray,
                           CharNormCutoffs, Results->CPResults,
                           MatchDebugFlags);

  if (tessedit_single_match && NumClasses > 1)
    NumClasses = 1;
  NumCharNormClassesTried += NumClasses;

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

  SetCharNormMatch();
  MasterMatcher(Templates, NumFeatures, IntFeatures, CharNormArray,
                NULL, MatchDebugFlags, NumClasses,
                Results->CPResults, Results);
}                                /* CharNormClassifier */


/*---------------------------------------------------------------------------*/
void ClassifyAsNoise(TBLOB *Blob,
                     LINE_STATS *LineStats,
                     ADAPT_RESULTS *Results) {
/*
 **                         Parameters:
 **                         Blob
              blob to be classified
**                          LineStats
              statistics for text line Blob is in
**                          Results
              results to add noise classification to
**                          Globals:
**                          NoiseBlobLength
              avg. length of a noise blob
**                          Operation: This routine computes a rating which reflects the
**                          likelihood that the blob being classified is a noise
**                          blob.  NOTE: assumes that the blob length has already been
**                          computed and placed into Results.
**                          Return: none
**                          Exceptions: none
**                          History: Tue Mar 12 18:36:52 1991, DSJ, Created.
*/
  register FLOAT32 Rating;

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

  AddNewResult (Results, NO_CLASS, Rating, 0);
}                                /* ClassifyAsNoise */


/*---------------------------------------------------------------------------*/
int CompareCurrentRatings(                     //CLASS_ID              *Class1,
                          const void *arg1,
                          const void *arg2) {  //CLASS_ID              *Class2)
/*
 **                         Parameters:
 **                         Class1, Class2
              classes whose ratings are to be compared
**                          Globals:
**                          CurrentRatings
              contains actual ratings for each class
**                          Operation: This routine gets the ratings for the 2 specified classes
**                          from a global variable (CurrentRatings) and returns:
**          -1 if Rating1 < Rating2
**                          0 if Rating1 = Rating2
**                          1 if Rating1 > Rating2
**                          Return: Order of classes based on their ratings (see above).
**                          Exceptions: none
**                          History: Tue Mar 12 14:18:31 1991, DSJ, Created.
*/
  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) {
/*
 **                         Parameters:
 **                         Results
              adaptive matcher results to convert to choices
**                          Globals: none
**                          Operation: This routine create