intmatcher.cpp

一ＯＣＲ的相关资料。．希望对研究ＯＣＲ的朋友有所帮助．

      ~(3 << (class_index % CLASSES_PER_CP_WERD) * 2);
  }

  /* Update Class Counts */
  NumPruners = NumClassPrunersIn (IntTemplates);
  for (feature_index = 0; feature_index < NumFeatures; feature_index++) {
    feature = &Features[feature_index];
    feature_address = (((feature->X * NUM_CP_BUCKETS >> 8) * NUM_CP_BUCKETS
      +
      (feature->Y * NUM_CP_BUCKETS >> 8)) *
      NUM_CP_BUCKETS +
      (feature->Theta * NUM_CP_BUCKETS >> 8)) << 1;
    CP_misses = 0;
    ClassPruner = ClassPrunersFor (IntTemplates);
    class_index = 0;
    for (PrunerSet = 0; PrunerSet < NumPruners; PrunerSet++, ClassPruner++) {
      BasePrunerAddress = (UINT32 *) (*ClassPruner) + feature_address;

      for (Word = 0; Word < WERDS_PER_CP_VECTOR; Word++) {
        PrunerWord = *BasePrunerAddress++;
        PrunerWord |= class_mask[class_index++];
        CP_misses += miss_table[PrunerWord & 255];
        PrunerWord >>= 8;
        CP_misses += miss_table[PrunerWord & 255];
        PrunerWord >>= 8;
        CP_misses += miss_table[PrunerWord & 255];
        PrunerWord >>= 8;
        CP_misses += miss_table[PrunerWord & 255];
      }
    }
    feature->CP_misses = CP_misses;
    if (display_ratings > 1) {
      cprintf ("F=%d: misses=%d\n", feature_index, CP_misses);
    }
    miss_histogram[CP_misses]++;
  }

  CP_misses = 0;
  feature_index = NumFeatures * feature_prune_percentile / 100;
  for (class_index = MaxNumClasses - 1; class_index >= 0; class_index--) {
    CP_misses += miss_histogram[class_index];
    if (CP_misses >= feature_index)
      break;
  }

  if (display_ratings > 1) {
    cprintf ("FP:Selected miss factor of %d for %d features (%g%%)\n",
      class_index, CP_misses, 100.0 * CP_misses / NumFeatures);
  }
  return class_index;
}


/*---------------------------------------------------------------------------*/
int prune_configs(INT_TEMPLATES IntTemplates,
                  INT32 min_misses,
                  INT16 NumFeatures,
                  INT_FEATURE_ARRAY Features,
                  CLASS_NORMALIZATION_ARRAY NormalizationFactors,
                  INT32 class_count,
                  UINT16 BlobLength,
                  CLASS_PRUNER_RESULTS Results,
                  int Debug) {
/*
 **      Parameters:
 **              IntTemplates           Class pruner tables
 **              NumFeatures            Number of features in blob
 **              Features               Array of features
 **              NormalizationFactors   Array of fudge factors from blob
 **                                     normalization process
 **                                     (by CLASS_INDEX)
 **              ExpectedNumFeatures    Array of expected number of features
 **                                     for each class
 **                                     (by CLASS_INDEX)
 **              Results                Sorted Array of pruned classes
 **                                     (by CLASS_ID)
 **              Debug                  Debugger flag: 1=debugger on
 **      Globals:
 **              ClassPrunerThreshold   Cutoff threshold
 **              ClassPrunerMultiplier  Normalization factor multiplier
 **      Operation:
 **              Prune the classes using a modified fast match table.
 **              Return a sorted list of classes along with the number
 **              of pruned classes in that list.
 **      Return: Number of pruned classes.
 **      Exceptions: none
 **      History: Tue Feb 19 10:24:24 MST 1991, RWM, Created.
 */
  INT32 classindex;              //current Results index
  CLASS_INDEX Class;             //current class
  INT_CLASS ClassTemplate;       //info on current class
  FLOAT32 best_rating;           //best over all classes
  FLOAT32 best_class_rating;     //best over all classes
  INT32 output_count;            //number of classes out
  INT32 best_index;              //for sorting
  INT_RESULT_STRUCT IntResult;
                                 //results of pruning
  CLASS_PRUNER_RESULTS new_results;

  best_class_rating = 9999.0f;
  for (classindex = 0; classindex < class_count; classindex++) {
    Class = IndexForClassId (IntTemplates, Results[classindex].Class);
    ClassTemplate = ClassForIndex (IntTemplates, Class);
    PruningMatcher (ClassTemplate, BlobLength, NumFeatures, Features,
      min_misses, NormalizationFactors[Class],
      &IntResult, Debug);

    /* Prune configs */
                                 //save old rating
    new_results[classindex].Rating2 = Results[classindex].Rating;
                                 //save new rating
    new_results[classindex].Rating = IntResult.Rating;
                                 //save new rating
    new_results[classindex].config_mask = (1 << IntResult.Config) | (1 << IntResult.Config2);
                                 //save old class
    new_results[classindex].Class = Results[classindex].Class;

    if (display_ratings > 1) {
      cprintf ("PC:%c: old=%g, best_rating=%g, config1=%d, config2=%d\n",
        Results[classindex].Class,
        Results[classindex].Rating2,
        IntResult.Rating, IntResult.Config, IntResult.Config2);
    }

    if (IntResult.Rating < best_class_rating)
      best_class_rating = IntResult.Rating;
  }
  /* Select Classes */
  best_class_rating *= newcp_prune_threshold;

  output_count = 0;
  do {
    best_rating = best_class_rating;
    best_index = -1;
    for (classindex = 0; classindex < class_count; classindex++) {
      if (new_results[classindex].Rating <= best_rating) {
        best_rating = new_results[classindex].Rating;
        best_index = classindex;
      }
    }
    if (best_index >= 0) {
      Results[output_count].Class = new_results[best_index].Class;
      Results[output_count].Rating = best_rating;
      Results[output_count].Rating2 = new_results[best_index].Rating2;
      Results[output_count].config_mask =
        new_results[best_index].config_mask;
      new_results[best_index].Rating = 9999.0f;
      output_count++;
    }
  }
  while (best_index >= 0);

  if (display_ratings > 1) {
    cprintf ("%d classes reduced to %d\n", class_count, output_count);
    for (classindex = 0; classindex < output_count; classindex++) {
      cprintf ("%c=%g/%g/0x%x, ",
        Results[classindex].Class,
        Results[classindex].Rating,
        Results[classindex].Rating2,
        Results[classindex].config_mask);
    }
    cprintf ("\n");
  }
  return output_count;
}


/*---------------------------------------------------------------------------*/
void PruningMatcher(INT_CLASS ClassTemplate,
                    UINT16 BlobLength,
                    INT16 NumFeatures,
                    INT_FEATURE_ARRAY Features,
                    INT32 min_misses,
                    UINT8 NormalizationFactor,
                    INT_RESULT Result,
                    int Debug) {
/*
 **      Parameters:
 **              ClassTemplate             Prototypes & tables for a class
 **              BlobLength                Length of unormalized blob
 **              NumFeatures               Number of features in blob
 **              Features                  Array of features
 **              NormalizationFactor       Fudge factor from blob
 **                                        normalization process
 **              Result                    Class rating & configuration:
 **                                        (0.0 -> 1.0), 0=good, 1=bad
 **              Debug                     Debugger flag: 1=debugger on
 **      Globals:
 **              LocalMatcherMultiplier    Normalization factor multiplier
 **              IntThetaFudge             Theta fudge factor used for
 **                                        evidence calculation
 **      Operation:
 **              IntegerMatcher returns the best configuration and rating
 **              for a single class.  The class matched against is determined
 **              by the uniqueness of the ClassTemplate parameter.  The
 **              best rating and its associated configuration are returned.
 **      Return:
 **      Exceptions: none
 **      History: Tue Feb 19 16:36:23 MST 1991, RWM, Created.
 */
  static UINT8 FeatureEvidence[MAX_NUM_CONFIGS];
  static int SumOfFeatureEvidence[MAX_NUM_CONFIGS];
  int *IntPointer;
  int Feature;
  int BestMatch;
  int used_features;
  int NumConfigs;

  if (MatchDebuggingOn (Debug))
    cprintf ("Pruning Matcher -------------------------------------------\n");

  IntPointer = SumOfFeatureEvidence;
  for (NumConfigs = NumIntConfigsIn (ClassTemplate); NumConfigs > 0;
    NumConfigs--)
  *IntPointer++ = 0;

  for (Feature = 0, used_features = 0; Feature < NumFeatures; Feature++) {
    if (Features[Feature].CP_misses >= min_misses) {
      PMUpdateTablesForFeature (ClassTemplate, Feature,
        &(Features[Feature]), FeatureEvidence,
        SumOfFeatureEvidence, Debug);
      used_features++;
    }
  }

  IMNormalizeSumOfEvidences(ClassTemplate,
                            SumOfFeatureEvidence,
                            NumFeatures,
                            used_features);

  BestMatch =
    IMFindBestMatch(ClassTemplate,
                    SumOfFeatureEvidence,
                    BlobLength,
                    NormalizationFactor,
                    Result);

#ifndef GRAPHICS_DISABLED
  if (PrintMatchSummaryOn (Debug))
    IMDebugBestMatch(BestMatch, Result, BlobLength, NormalizationFactor);
#endif

  if (MatchDebuggingOn (Debug))
    cprintf ("Match Complete --------------------------------------------\n");

}


/*---------------------------------------------------------------------------*/
void config_mask_to_proto_mask(INT_CLASS ClassTemplate,
                               BIT_VECTOR config_mask,
                               BIT_VECTOR proto_mask) {
  UINT32 ConfigWord;
  int ProtoSetIndex;
  UINT32 ProtoNum;
  PROTO_SET ProtoSet;
  int NumProtos;
  UINT32 ActualProtoNum;

  NumProtos = NumIntProtosIn (ClassTemplate);

  zero_all_bits (proto_mask, WordsInVectorOfSize (MAX_NUM_PROTOS));
  for (ProtoSetIndex = 0; ProtoSetIndex < NumProtoSetsIn (ClassTemplate);
  ProtoSetIndex++) {
    ProtoSet = ProtoSetIn (ClassTemplate, ProtoSetIndex);
    ActualProtoNum = (ProtoSetIndex * PROTOS_PER_PROTO_SET);
    for (ProtoNum = 0;
      ((ProtoNum < PROTOS_PER_PROTO_SET)
    && (ActualProtoNum < NumProtos)); ProtoNum++, ActualProtoNum++) {
      ConfigWord = (ProtoSet->Protos[ProtoNum]).Configs[0];
      ConfigWord &= *config_mask;
      if (ConfigWord != 0) {
        proto_mask[ActualProtoNum / 32] |= 1 << (ActualProtoNum % 32);
      }
    }
  }
}


/*---------------------------------------------------------------------------*/
void IntegerMatcher(INT_CLASS ClassTemplate,
                    BIT_VECTOR ProtoMask,
                    BIT_VECTOR ConfigMask,
                    UINT16 BlobLength,
                    INT16 NumFeatures,
                    INT_FEATURE_ARRAY Features,
                    INT32 min_misses,
                    UINT8 NormalizationFactor,
                    INT_RESULT Result,
                    int Debug) {
/*
 **      Parameters:
 **              ClassTemplate             Prototypes & tables for a class
 **              BlobLength                Length of unormalized blob
 **              NumFeatures               Number of features in blob
 **              Features                  Array of features
 **              NormalizationFactor       Fudge factor from blob
 **                                        normalization process
 **              Result                    Class rating & configuration:
 **                                        (0.0 -> 1.0), 0=good, 1=bad
 **              Debug                     Debugger flag: 1=debugger on
 **      Globals:
 **              LocalMatcherMultiplier    Normalization factor multiplier
 **              IntThetaFudge             Theta fudge factor used for
 **                                        evidence calculation
 **      Operation:
 **              IntegerMatcher returns the best configuration and rating
 **              for a single class.  The class matched against is determined
 **              by the uniqueness of the ClassTemplate parameter.  The
 **              best rating and its associated configuration are returned.
 **      Return:
 **      Exceptions: none
 **      History: Tue Feb 19 16:36:23 MST 1991, RWM, Created.
 */
  static UINT8 FeatureEvidence[MAX_NUM_CONFIGS];
  static int SumOfFeatureEvidence[MAX_NUM_CONFIGS];
  static UINT8 ProtoEvidence[MAX_NUM_PROTOS][MAX_PROTO_INDEX];
  int Feature;
  int BestMatch;
  int used_features;

  if (MatchDebuggingOn (Debug))
    cprintf ("Integer Matcher -------------------------------------------\n");

  IMClearTables(ClassTemplate, SumOfFeatureEvidence, ProtoEvidence);

  for (Feature = 0, used_features = 0; Feature < NumFeatures; Feature++) {
    if (Features[Feature].CP_misses >= min_misses) {
      IMUpdateTablesForFeature (ClassTemplate, ProtoMask, ConfigMask,
        Feature, &(Features[Feature]),
        FeatureEvidence, SumOfFeatureEvidence,
        ProtoEvidence, Debug);
      used_features++;
    }
  }

#ifndef GRAPHICS_DISABLED
  if (PrintProtoMatchesOn (Debug) || PrintMatchSummaryOn (Debug))
    IMDebugFeatureProtoError(ClassTemplate,
                             ProtoMask,
                             ConfigMask,
                             SumOfFeatureEvidence,
                             ProtoEvidence,
                             NumFeatures,
                             Debug);

  if (DisplayProtoMatchesOn (Debug))
    IMDisplayProtoDebugInfo(ClassTemplate,
                            ProtoMask,
                            ConfigMask,
                            ProtoEvidence,
                            Debug);

  if (DisplayFeatureMatchesOn (Debug))
    IMDisplayFeatureDebugInfo(ClassTemplate,
                              ProtoMask,