mirror of
https://github.com/tesseract-ocr/tesseract.git
synced 2024-12-19 20:08:16 +08:00
2f4a43b419
git-svn-id: https://tesseract-ocr.googlecode.com/svn/trunk@79 d0cd1f9f-072b-0410-8dd7-cf729c803f20
2318 lines
80 KiB
C++
2318 lines
80 KiB
C++
/******************************************************************************
|
|
** Filename: intmatcher.c
|
|
** Purpose: Generic high level classification routines.
|
|
** Author: Robert Moss
|
|
** History: Wed Feb 13 17:35:28 MST 1991, RWM, Created.
|
|
** Mon Mar 11 16:33:02 MST 1991, RWM, Modified to add
|
|
** support for adaptive matching.
|
|
** (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.
|
|
******************************************************************************/
|
|
/**----------------------------------------------------------------------------
|
|
Include Files and Type Defines
|
|
----------------------------------------------------------------------------**/
|
|
#include "intmatcher.h"
|
|
#include "tordvars.h"
|
|
#include "callcpp.h"
|
|
#include "globals.h"
|
|
#include <math.h>
|
|
|
|
#define CLASS_MASK_SIZE ((MAX_NUM_CLASSES*NUM_BITS_PER_CLASS \
|
|
+BITS_PER_WERD-1)/BITS_PER_WERD)
|
|
|
|
/**----------------------------------------------------------------------------
|
|
Global Data Definitions and Declarations
|
|
----------------------------------------------------------------------------**/
|
|
#define SE_TABLE_BITS 9
|
|
#define SE_TABLE_SIZE 512
|
|
#define TEMPLATE_CACHE 2
|
|
static UINT8 SimilarityEvidenceTable[SE_TABLE_SIZE];
|
|
static UINT8 offset_table[256] = {
|
|
255, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
|
|
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
|
|
};
|
|
static UINT8 next_table[256] = {
|
|
0, 0, 0, 0x2, 0, 0x4, 0x4, 0x6, 0, 0x8, 0x8, 0x0a, 0x08, 0x0c, 0x0c, 0x0e,
|
|
0, 0x10, 0x10, 0x12, 0x10, 0x14, 0x14, 0x16, 0x10, 0x18, 0x18, 0x1a, 0x18,
|
|
0x1c, 0x1c, 0x1e,
|
|
0, 0x20, 0x20, 0x22, 0x20, 0x24, 0x24, 0x26, 0x20, 0x28, 0x28, 0x2a, 0x28,
|
|
0x2c, 0x2c, 0x2e,
|
|
0x20, 0x30, 0x30, 0x32, 0x30, 0x34, 0x34, 0x36, 0x30, 0x38, 0x38, 0x3a,
|
|
0x38, 0x3c, 0x3c, 0x3e,
|
|
0, 0x40, 0x40, 0x42, 0x40, 0x44, 0x44, 0x46, 0x40, 0x48, 0x48, 0x4a, 0x48,
|
|
0x4c, 0x4c, 0x4e,
|
|
0x40, 0x50, 0x50, 0x52, 0x50, 0x54, 0x54, 0x56, 0x50, 0x58, 0x58, 0x5a,
|
|
0x58, 0x5c, 0x5c, 0x5e,
|
|
0x40, 0x60, 0x60, 0x62, 0x60, 0x64, 0x64, 0x66, 0x60, 0x68, 0x68, 0x6a,
|
|
0x68, 0x6c, 0x6c, 0x6e,
|
|
0x60, 0x70, 0x70, 0x72, 0x70, 0x74, 0x74, 0x76, 0x70, 0x78, 0x78, 0x7a,
|
|
0x78, 0x7c, 0x7c, 0x7e,
|
|
0, 0x80, 0x80, 0x82, 0x80, 0x84, 0x84, 0x86, 0x80, 0x88, 0x88, 0x8a, 0x88,
|
|
0x8c, 0x8c, 0x8e,
|
|
0x80, 0x90, 0x90, 0x92, 0x90, 0x94, 0x94, 0x96, 0x90, 0x98, 0x98, 0x9a,
|
|
0x98, 0x9c, 0x9c, 0x9e,
|
|
0x80, 0xa0, 0xa0, 0xa2, 0xa0, 0xa4, 0xa4, 0xa6, 0xa0, 0xa8, 0xa8, 0xaa,
|
|
0xa8, 0xac, 0xac, 0xae,
|
|
0xa0, 0xb0, 0xb0, 0xb2, 0xb0, 0xb4, 0xb4, 0xb6, 0xb0, 0xb8, 0xb8, 0xba,
|
|
0xb8, 0xbc, 0xbc, 0xbe,
|
|
0x80, 0xc0, 0xc0, 0xc2, 0xc0, 0xc4, 0xc4, 0xc6, 0xc0, 0xc8, 0xc8, 0xca,
|
|
0xc8, 0xcc, 0xcc, 0xce,
|
|
0xc0, 0xd0, 0xd0, 0xd2, 0xd0, 0xd4, 0xd4, 0xd6, 0xd0, 0xd8, 0xd8, 0xda,
|
|
0xd8, 0xdc, 0xdc, 0xde,
|
|
0xc0, 0xe0, 0xe0, 0xe2, 0xe0, 0xe4, 0xe4, 0xe6, 0xe0, 0xe8, 0xe8, 0xea,
|
|
0xe8, 0xec, 0xec, 0xee,
|
|
0xe0, 0xf0, 0xf0, 0xf2, 0xf0, 0xf4, 0xf4, 0xf6, 0xf0, 0xf8, 0xf8, 0xfa,
|
|
0xf8, 0xfc, 0xfc, 0xfe
|
|
};
|
|
static int cp_maxes[128] = {
|
|
100,
|
|
100, 100, 100, 100, 100, 100, 100, 100,
|
|
100, 100, 100, 100, 100, 100, 100, 100,
|
|
100, 100, 100, 100, 100, 100, 100, 100,
|
|
100, 100, 100, 100, 100, 100, 100, 100,
|
|
194, //!
|
|
100, //"
|
|
182, //#
|
|
224, //$
|
|
203, //%
|
|
242, //&
|
|
245, //'
|
|
226, //(
|
|
190, //)
|
|
244, //*
|
|
195, //+
|
|
254, //,
|
|
253, //-
|
|
253, //.
|
|
206, ///
|
|
253, //0
|
|
234, //1
|
|
252, //2
|
|
246, //3
|
|
253, //4
|
|
160, //5
|
|
202, //6
|
|
199, //7
|
|
171, //8
|
|
227, //9
|
|
208, //:
|
|
188, //;
|
|
60, //<
|
|
221, //=
|
|
138, //>
|
|
108, //?
|
|
98, //@
|
|
251, //A
|
|
214, //B
|
|
230, //C
|
|
252, //D
|
|
237, //E
|
|
217, //F
|
|
233, //G
|
|
174, //H
|
|
216, //I
|
|
210, //J
|
|
252, //K
|
|
253, //L
|
|
233, //M
|
|
243, //N
|
|
240, //O
|
|
230, //P
|
|
167, //Q
|
|
248, //R
|
|
250, //S
|
|
232, //T
|
|
209, //U
|
|
193, //V
|
|
254, //W
|
|
146, //X
|
|
198, //Y
|
|
107, //Z
|
|
167, //[
|
|
163, //
|
|
73, //]
|
|
16, //^
|
|
199, //_
|
|
162, //`
|
|
251, //a
|
|
250, //b
|
|
254, //c
|
|
253, //d
|
|
252, //e
|
|
253, //f
|
|
248, //g
|
|
251, //h
|
|
254, //i
|
|
201, //j
|
|
224, //k
|
|
253, //l
|
|
242, //m
|
|
254, //n
|
|
254, //o
|
|
253, //p
|
|
246, //q
|
|
254, //r
|
|
254, //s
|
|
254, //t
|
|
245, //u
|
|
221, //v
|
|
230, //w
|
|
251, //x
|
|
243, //y
|
|
133, //z
|
|
35, //{
|
|
100, //|
|
|
143, //}
|
|
100, //~
|
|
100
|
|
};
|
|
|
|
static float cp_ratios[128] = {
|
|
1.5f,
|
|
1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f,
|
|
1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f,
|
|
1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f,
|
|
1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f,
|
|
2.24775, //!
|
|
1.5, //"
|
|
1.90376, //#
|
|
1.61443, //$
|
|
1.87857, //%
|
|
2.29167, //&
|
|
7.4, //'
|
|
4.7, //(
|
|
9.4, //)
|
|
2.13014, //*
|
|
1.53175, //+
|
|
2.86957, //,
|
|
7.4, //-
|
|
7.4, //.
|
|
9.4, ///
|
|
8.1, //0
|
|
12.6, //1
|
|
2.7439, //2
|
|
4.22222, //3
|
|
2.57447, //4
|
|
2.93902, //5
|
|
4.23684, //6
|
|
6, //7
|
|
2.78889, //8
|
|
3.55, //9
|
|
8.5, //:
|
|
2.4, //;
|
|
1.5, //<
|
|
1.94737, //=
|
|
1.89394, //>
|
|
1.5, //?
|
|
1.5, //@
|
|
3.125, //A
|
|
5.5, //B
|
|
6.1, //C
|
|
6, //D
|
|
2.78205, //E
|
|
2.03763, //F
|
|
2.73256, //G
|
|
2.57692, //H
|
|
11.8, //I
|
|
7.1, //J
|
|
1.85227, //K
|
|
7.4, //L
|
|
2.26056, //M
|
|
2.46078, //N
|
|
6.85714, //O
|
|
3.45238, //P
|
|
2.47222, //Q
|
|
3.74, //R
|
|
10.2, //S
|
|
3.08065, //T
|
|
6.1, //U
|
|
9.5, //V
|
|
7.1, //W
|
|
7.9, //X
|
|
2.55714, //Y
|
|
7.7, //Z
|
|
2, //[
|
|
1.5, //
|
|
2.55714, //]
|
|
1.5, //^
|
|
1.80065, //_
|
|
1.69512, //`
|
|
5.34, //a
|
|
7.3, //b
|
|
6.43333, //c
|
|
4.10606, //d
|
|
4.41667, //e
|
|
12.6, //f
|
|
3.7093, //g
|
|
2.38889, //h
|
|
5.5, //i
|
|
4.03125, //j
|
|
2.24561, //k
|
|
11.5, //l
|
|
3.5, //m
|
|
5.63333, //n
|
|
11, //o
|
|
2.52667, //p
|
|
2.1129, //q
|
|
6.56667, //r
|
|
6.42857, //s
|
|
11.4, //t
|
|
3.62, //u
|
|
2.77273, //v
|
|
2.90909, //w
|
|
6.5, //x
|
|
4.98387, //y
|
|
2.92857, //z
|
|
1.5, //{
|
|
1.5, //|
|
|
2.02128, //}
|
|
1.5, //~
|
|
1.5f
|
|
};
|
|
static INT8 miss_table[256] = {
|
|
4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3, 2,
|
|
4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3, 2,
|
|
4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3, 2,
|
|
3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 2, 2, 2, 1,
|
|
4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3, 2,
|
|
4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3, 2,
|
|
4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3, 2,
|
|
3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 2, 2, 2, 1,
|
|
4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3, 2,
|
|
4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3, 2,
|
|
4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3, 2,
|
|
3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 2, 2, 2, 1,
|
|
3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 2, 2, 2, 1,
|
|
3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 2, 2, 2, 1,
|
|
3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 2, 2, 2, 1,
|
|
2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 1, 1, 1, 0
|
|
};
|
|
|
|
static UINT32 EvidenceTableMask;
|
|
|
|
static UINT32 MultTruncShiftBits;
|
|
|
|
static UINT32 TableTruncShiftBits;
|
|
|
|
UINT32 EvidenceMultMask;
|
|
|
|
static INT16 LocalMatcherMultiplier;
|
|
|
|
make_int_var (ClassPrunerThreshold, 229, MakeClassPrunerThreshold,
|
|
16, 20, SetClassPrunerThreshold,
|
|
"Class Pruner Threshold 0-255: ");
|
|
|
|
make_int_var (ClassPrunerMultiplier, 30, MakeClassPrunerMultiplier,
|
|
16, 21, SetClassPrunerMultiplier,
|
|
"Class Pruner Multiplier 0-255: ");
|
|
|
|
make_int_var (IntegerMatcherMultiplier, 14, MakeIntegerMatcherMultiplier,
|
|
16, 22, SetIntegerMatcherMultiplier,
|
|
"Integer Matcher Multiplier 0-255: ");
|
|
|
|
make_int_var (IntThetaFudge, 128, MakeIntThetaFudge,
|
|
16, 23, SetIntThetaFudge,
|
|
"Integer Matcher Theta Fudge 0-255: ");
|
|
|
|
make_int_var (CPCutoffStrength, 7, MakeCPCutoffStrength,
|
|
16, 24, SetCPCutoffStrength,
|
|
"Class Pruner CutoffStrength: ");
|
|
|
|
make_int_var (EvidenceTableBits, 9, MakeEvidenceTableBits,
|
|
16, 25, SetEvidenceTableBits,
|
|
"Bits in Similarity to Evidence Lookup 8-9: ");
|
|
|
|
make_int_var (IntEvidenceTruncBits, 14, MakeIntEvidenceTruncBits,
|
|
16, 26, SetIntEvidenceTruncBits,
|
|
"Integer Evidence Truncation Bits (Distance) 8-14: ");
|
|
|
|
make_float_var (SEExponentialMultiplier, 0, MakeSEExponentialMultiplier,
|
|
16, 27, SetSEExponentialMultiplier,
|
|
"Similarity to Evidence Table Exponential Multiplier: ");
|
|
|
|
make_float_var (SimilarityCenter, 0.0075, MakeSimilarityCenter,
|
|
16, 28, SetSimilarityCenter, "Center of Similarity Curve: ");
|
|
|
|
make_int_var (AdaptProtoThresh, 230, MakeAdaptProtoThresh,
|
|
16, 29, SetAdaptProtoThresh,
|
|
"Threshold for good protos during adaptive 0-255: ");
|
|
|
|
make_int_var (AdaptFeatureThresh, 230, MakeAdaptFeatureThresh,
|
|
16, 30, SetAdaptFeatureThresh,
|
|
"Threshold for good features during adaptive 0-255: ");
|
|
//extern int display_ratings;
|
|
//extern "C" int newcp_ratings_on;
|
|
//extern "C" double newcp_prune_threshold;
|
|
//extern "C" double tessedit_cp_ratio;
|
|
//extern "C" int feature_prune_percentile;
|
|
//extern INT32 cp_maps[4];
|
|
|
|
int protoword_lookups;
|
|
int zero_protowords;
|
|
int proto_shifts;
|
|
int set_proto_bits;
|
|
int config_shifts;
|
|
int set_config_bits;
|
|
|
|
/**----------------------------------------------------------------------------
|
|
Public Code
|
|
----------------------------------------------------------------------------**/
|
|
/*---------------------------------------------------------------------------*/
|
|
int ClassPruner(INT_TEMPLATES IntTemplates,
|
|
INT16 NumFeatures,
|
|
INT_FEATURE_ARRAY Features,
|
|
CLASS_NORMALIZATION_ARRAY NormalizationFactors,
|
|
CLASS_CUTOFF_ARRAY ExpectedNumFeatures,
|
|
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.
|
|
*/
|
|
UINT32 PrunerWord;
|
|
INT32 class_index; //index to class
|
|
int Word;
|
|
UINT32 *BasePrunerAddress;
|
|
UINT32 feature_address; //current feature index
|
|
INT_FEATURE feature; //current feature
|
|
CLASS_PRUNER *ClassPruner;
|
|
int PrunerSet;
|
|
int NumPruners;
|
|
INT32 feature_index; //current feature
|
|
|
|
static INT32 ClassCount[MAX_NUM_CLASSES];
|
|
static INT16 NormCount[MAX_NUM_CLASSES];
|
|
static INT16 SortKey[MAX_NUM_CLASSES + 1];
|
|
static UINT8 SortIndex[MAX_NUM_CLASSES + 1];
|
|
CLASS_INDEX Class;
|
|
int out_class;
|
|
int MaxNumClasses;
|
|
int MaxCount;
|
|
int NumClasses;
|
|
FLOAT32 max_rating; //max allowed rating
|
|
INT32 *ClassCountPtr;
|
|
CLASS_ID classch;
|
|
|
|
MaxNumClasses = NumClassesIn (IntTemplates);
|
|
|
|
/* Clear Class Counts */
|
|
ClassCountPtr = &(ClassCount[0]);
|
|
for (Class = 0; Class < MaxNumClasses; Class++) {
|
|
*ClassCountPtr++ = 0;
|
|
}
|
|
|
|
/* Update Class Counts */
|
|
NumPruners = NumClassPrunersIn (IntTemplates);
|
|
for (feature_index = 0; feature_index < NumFeatures; feature_index++) {
|
|
feature = &Features[feature_index];
|
|
feature->CP_misses = 0;
|
|
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;
|
|
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++;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
PrunerWord >>= 2;
|
|
ClassCount[class_index++] += cp_maps[PrunerWord & 3];
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Adjust Class Counts for Number of Expected Features */
|
|
for (Class = 0; Class < MaxNumClasses; Class++)
|
|
if (NumFeatures < ExpectedNumFeatures[Class]) {
|
|
int deficit = ExpectedNumFeatures[Class] - NumFeatures;
|
|
ClassCount[Class] -= ClassCount[Class] * deficit /
|
|
(NumFeatures*CPCutoffStrength + deficit);
|
|
}
|
|
|
|
/* Adjust Class Counts for Normalization Factors */
|
|
MaxCount = 0;
|
|
for (Class = 0; Class < MaxNumClasses; Class++) {
|
|
NormCount[Class] = ClassCount[Class]
|
|
- ((ClassPrunerMultiplier * NormalizationFactors[Class]) >> 8)
|
|
* cp_maps[3] / 3;
|
|
if (NormCount[Class] > MaxCount)
|
|
MaxCount = NormCount[Class];
|
|
}
|
|
|
|
/* Prune Classes */
|
|
MaxCount *= ClassPrunerThreshold;
|
|
MaxCount >>= 8;
|
|
/* Select Classes */
|
|
if (MaxCount < 1)
|
|
MaxCount = 1;
|
|
NumClasses = 0;
|
|
for (Class = 0; Class < MaxNumClasses; Class++)
|
|
if (NormCount[Class] >= MaxCount) {
|
|
NumClasses++;
|
|
SortIndex[NumClasses] = Class;
|
|
SortKey[NumClasses] = NormCount[Class];
|
|
}
|
|
|
|
/* Sort Classes using Heapsort Algorithm */
|
|
if (NumClasses > 1)
|
|
HeapSort(NumClasses, SortKey, SortIndex);
|
|
|
|
if (display_ratings > 1) {
|
|
cprintf ("CP:%d classes, %d features:\n", NumClasses, NumFeatures);
|
|
for (Class = 0; Class < NumClasses; Class++) {
|
|
classch = ClassIdForIndex (IntTemplates, SortIndex[NumClasses - Class]);
|
|
cprintf ("%s:C=%d, E=%d, N=%d, Rat=%d\n",
|
|
unicharset.id_to_unichar(classch),
|
|
ClassCount[SortIndex[NumClasses - Class]],
|
|
ExpectedNumFeatures[SortIndex[NumClasses - Class]],
|
|
SortKey[NumClasses - Class],
|
|
1010 - 1000 * SortKey[NumClasses - Class] /
|
|
(cp_maps[3] * NumFeatures));
|
|
}
|
|
if (display_ratings > 2) {
|
|
NumPruners = NumClassPrunersIn (IntTemplates);
|
|
for (feature_index = 0; feature_index < NumFeatures;
|
|
feature_index++) {
|
|
cprintf ("F=%3d,", feature_index);
|
|
feature = &Features[feature_index];
|
|
feature->CP_misses = 0;
|
|
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;
|
|
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++;
|
|
for (Class = 0; Class < 16; Class++, class_index++) {
|
|
if (NormCount[class_index] >= MaxCount)
|
|
cprintf (" %s=%d,",
|
|
unicharset.id_to_unichar(ClassIdForIndex (IntTemplates,
|
|
class_index)),
|
|
PrunerWord & 3);
|
|
PrunerWord >>= 2;
|
|
}
|
|
}
|
|
}
|
|
cprintf ("\n");
|
|
}
|
|
cprintf ("Adjustments:");
|
|
for (Class = 0; Class < MaxNumClasses; Class++) {
|
|
if (NormCount[Class] > MaxCount)
|
|
cprintf (" %s=%d,",
|
|
unicharset.id_to_unichar(ClassIdForIndex (IntTemplates, Class)),
|
|
-((ClassPrunerMultiplier *
|
|
NormalizationFactors[Class]) >> 8) * cp_maps[3] /
|
|
3);
|
|
}
|
|
cprintf ("\n");
|
|
}
|
|
}
|
|
|
|
/* Set Up Results */
|
|
max_rating = 0.0f;
|
|
for (Class = 0, out_class = 0; Class < NumClasses; Class++) {
|
|
Results[out_class].Class =
|
|
ClassIdForIndex (IntTemplates, SortIndex[NumClasses - Class]);
|
|
Results[out_class].config_mask = (UINT32) - 1;
|
|
Results[out_class].Rating =
|
|
1.0 - SortKey[NumClasses -
|
|
Class] / ((float) cp_maps[3] * NumFeatures);
|
|
/**/ Results[out_class].Rating2 =
|
|
1.0 - SortKey[NumClasses -
|
|
Class] / ((float) cp_maps[3] * NumFeatures);
|
|
if (tessedit_cp_ratio == 0.0 || Class == 0
|
|
|| Results[out_class].Rating * 1000 + 10 <
|
|
cp_maxes[Results[out_class].Class]
|
|
&& Results[out_class].Rating * 1000 + 10 <
|
|
(Results[0].Rating * 1000 +
|
|
10) * cp_ratios[Results[out_class].Class])
|
|
out_class++;
|
|
}
|
|
NumClasses = out_class;
|
|
if (blob_type != 0) {
|
|
cp_classes = NumClasses;
|
|
if (NumClasses > 0) {
|
|
cp_chars[0] = Results[0].Class;
|
|
cp_ratings[0] = (int) (1000 * Results[0].Rating + 10);
|
|
cp_confs[0] = (int) (1000 * Results[0].Rating2 + 10);
|
|
if (NumClasses > 1) {
|
|
cp_chars[1] = Results[1].Class;
|
|
cp_ratings[1] = (int) (1000 * Results[1].Rating + 10);
|
|
cp_confs[1] = (int) (1000 * Results[1].Rating2 + 10);
|
|
}
|
|
else {
|
|
cp_chars[1] = '~';
|
|
cp_ratings[1] = -1;
|
|
cp_confs[1] = -1;
|
|
}
|
|
}
|
|
else {
|
|
cp_chars[0] = '~';
|
|
cp_ratings[0] = -1;
|
|
cp_confs[0] = -1;
|
|
}
|
|
cp_bestindex = -1;
|
|
cp_bestrating = -1;
|
|
cp_bestconf = -1;
|
|
for (Class = 0; Class < NumClasses; Class++) {
|
|
classch = Results[Class].Class;
|
|
if (strcmp(unicharset.id_to_unichar(classch), blob_answer) == 0) {
|
|
cp_bestindex = Class;
|
|
cp_bestrating = (int) (1000 * Results[Class].Rating + 10);
|
|
cp_bestconf = (int) (1000 * Results[Class].Rating2 + 10);
|
|
}
|
|
}
|
|
}
|
|
return NumClasses;
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
int feature_pruner(INT_TEMPLATES IntTemplates,
|
|
INT16 NumFeatures,
|
|
INT_FEATURE_ARRAY Features,
|
|
INT32 NumClasses,
|
|
CLASS_PRUNER_RESULTS Results) {
|
|
/*
|
|
** 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.
|
|
*/
|
|
UINT32 PrunerWord;
|
|
CLASS_PRUNER *ClassPruner;
|
|
INT32 class_index; //index to class
|
|
INT32 result_index; //CP results index
|
|
int PrunerSet;
|
|
int NumPruners;
|
|
int Word;
|
|
INT_FEATURE feature; //current feature
|
|
INT32 feature_index; //current feature
|
|
INT32 CP_misses; //missed features
|
|
UINT32 feature_address; //current feature index
|
|
UINT32 *BasePrunerAddress;
|
|
int MaxNumClasses;
|
|
UINT32 class_mask[CLASS_MASK_SIZE];
|
|
INT32 miss_histogram[MAX_NUM_CLASSES];
|
|
|
|
MaxNumClasses = NumClassesIn (IntTemplates);
|
|
for (class_index = 0; class_index < MaxNumClasses; class_index++)
|
|
miss_histogram[class_index] = 0;
|
|
|
|
/* Create class mask */
|
|
for (class_index = 0; class_index < CLASS_MASK_SIZE; class_index++)
|
|
class_mask[class_index] = (UINT32) - 1;
|
|
for (result_index = 0; result_index < NumClasses; result_index++) {
|
|
class_index =
|
|
IndexForClassId (IntTemplates, Results[result_index].Class);
|
|
class_mask[class_index / CLASSES_PER_CP_WERD] &=
|
|
~(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,
|
|
ConfigMask,
|
|
NumFeatures,
|
|
Features,
|
|
Debug);
|
|
#endif
|
|
|
|
IMUpdateSumOfProtoEvidences(ClassTemplate,
|
|
ConfigMask,
|
|
SumOfFeatureEvidence,
|
|
ProtoEvidence,
|
|
NumFeatures);
|
|
|
|
IMNormalizeSumOfEvidences(ClassTemplate,
|
|
SumOfFeatureEvidence,
|
|
NumFeatures,
|
|
used_features);
|
|
|
|
BestMatch =
|
|
IMFindBestMatch(ClassTemplate,
|
|
SumOfFeatureEvidence,
|
|
BlobLength,
|
|
NormalizationFactor,
|
|
Result);
|
|
|
|
#ifndef GRAPHICS_DISABLED
|
|
if (PrintMatchSummaryOn (Debug))
|
|
IMDebugBestMatch(BestMatch, Result, BlobLength, NormalizationFactor);
|
|
|
|
if (MatchDebuggingOn (Debug))
|
|
cprintf ("Match Complete --------------------------------------------\n");
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
int FindGoodProtos(INT_CLASS ClassTemplate,
|
|
BIT_VECTOR ProtoMask,
|
|
BIT_VECTOR ConfigMask,
|
|
UINT16 BlobLength,
|
|
INT16 NumFeatures,
|
|
INT_FEATURE_ARRAY Features,
|
|
PROTO_ID *ProtoArray,
|
|
int Debug) {
|
|
/*
|
|
** Parameters:
|
|
** ClassTemplate Prototypes & tables for a class
|
|
** ProtoMask AND Mask for proto word
|
|
** ConfigMask AND Mask for config word
|
|
** BlobLength Length of unormalized blob
|
|
** NumFeatures Number of features in blob
|
|
** Features Array of features
|
|
** ProtoArray Array of good protos
|
|
** Debug Debugger flag: 1=debugger on
|
|
** Globals:
|
|
** LocalMatcherMultiplier Normalization factor multiplier
|
|
** IntThetaFudge Theta fudge factor used for
|
|
** evidence calculation
|
|
** AdaptProtoThresh Threshold for good protos
|
|
** Operation:
|
|
** FindGoodProtos finds all protos whose normalized proto-evidence
|
|
** exceed AdaptProtoThresh. The list is ordered by increasing
|
|
** proto id number.
|
|
** Return:
|
|
** Number of good protos in ProtoArray.
|
|
** Exceptions: none
|
|
** History: Tue Mar 12 17:09:26 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;
|
|
register UINT8 *UINT8Pointer;
|
|
register int ProtoIndex;
|
|
int NumProtos;
|
|
int NumGoodProtos;
|
|
UINT16 ActualProtoNum;
|
|
register int Temp;
|
|
|
|
/* DEBUG opening heading */
|
|
if (MatchDebuggingOn (Debug))
|
|
cprintf
|
|
("Find Good Protos -------------------------------------------\n");
|
|
|
|
IMClearTables(ClassTemplate, SumOfFeatureEvidence, ProtoEvidence);
|
|
|
|
for (Feature = 0; Feature < NumFeatures; Feature++)
|
|
IMUpdateTablesForFeature (ClassTemplate, ProtoMask, ConfigMask, Feature,
|
|
&(Features[Feature]), FeatureEvidence,
|
|
SumOfFeatureEvidence, ProtoEvidence, Debug);
|
|
|
|
#ifndef GRAPHICS_DISABLED
|
|
if (PrintProtoMatchesOn (Debug) || PrintMatchSummaryOn (Debug))
|
|
IMDebugFeatureProtoError(ClassTemplate,
|
|
ProtoMask,
|
|
ConfigMask,
|
|
SumOfFeatureEvidence,
|
|
ProtoEvidence,
|
|
NumFeatures,
|
|
Debug);
|
|
#endif
|
|
|
|
/* Average Proto Evidences & Find Good Protos */
|
|
NumProtos = NumIntProtosIn (ClassTemplate);
|
|
NumGoodProtos = 0;
|
|
for (ActualProtoNum = 0; ActualProtoNum < NumProtos; ActualProtoNum++) {
|
|
/* Compute Average for Actual Proto */
|
|
Temp = 0;
|
|
UINT8Pointer = &(ProtoEvidence[ActualProtoNum][0]);
|
|
for (ProtoIndex = LengthForProtoId (ClassTemplate, ActualProtoNum);
|
|
ProtoIndex > 0; ProtoIndex--, UINT8Pointer++)
|
|
Temp += *UINT8Pointer;
|
|
|
|
Temp /= LengthForProtoId (ClassTemplate, ActualProtoNum);
|
|
|
|
/* Find Good Protos */
|
|
if (Temp >= AdaptProtoThresh) {
|
|
*ProtoArray = ActualProtoNum;
|
|
ProtoArray++;
|
|
NumGoodProtos++;
|
|
}
|
|
}
|
|
|
|
if (MatchDebuggingOn (Debug))
|
|
cprintf ("Match Complete --------------------------------------------\n");
|
|
return NumGoodProtos;
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
int FindBadFeatures(INT_CLASS ClassTemplate,
|
|
BIT_VECTOR ProtoMask,
|
|
BIT_VECTOR ConfigMask,
|
|
UINT16 BlobLength,
|
|
INT16 NumFeatures,
|
|
INT_FEATURE_ARRAY Features,
|
|
FEATURE_ID *FeatureArray,
|
|
int Debug) {
|
|
/*
|
|
** Parameters:
|
|
** ClassTemplate Prototypes & tables for a class
|
|
** ProtoMask AND Mask for proto word
|
|
** ConfigMask AND Mask for config word
|
|
** BlobLength Length of unormalized blob
|
|
** NumFeatures Number of features in blob
|
|
** Features Array of features
|
|
** FeatureArray Array of bad features
|
|
** Debug Debugger flag: 1=debugger on
|
|
** Globals:
|
|
** LocalMatcherMultiplier Normalization factor multiplier
|
|
** IntThetaFudge Theta fudge factor used for
|
|
** evidence calculation
|
|
** AdaptFeatureThresh Threshold for bad features
|
|
** Operation:
|
|
** FindBadFeatures finds all features whose maximum feature-evidence
|
|
** was less than AdaptFeatureThresh. The list is ordered by increasing
|
|
** feature number.
|
|
** Return:
|
|
** Number of bad features in FeatureArray.
|
|
** Exceptions: none
|
|
** History: Tue Mar 12 17:09:26 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;
|
|
register UINT8 *UINT8Pointer;
|
|
register int ConfigNum;
|
|
int NumConfigs;
|
|
int NumBadFeatures;
|
|
register int Temp;
|
|
|
|
/* DEBUG opening heading */
|
|
if (MatchDebuggingOn (Debug))
|
|
cprintf
|
|
("Find Bad Features -------------------------------------------\n");
|
|
|
|
IMClearTables(ClassTemplate, SumOfFeatureEvidence, ProtoEvidence);
|
|
|
|
NumBadFeatures = 0;
|
|
NumConfigs = NumIntConfigsIn (ClassTemplate);
|
|
for (Feature = 0; Feature < NumFeatures; Feature++) {
|
|
IMUpdateTablesForFeature (ClassTemplate, ProtoMask, ConfigMask, Feature,
|
|
&(Features[Feature]), FeatureEvidence,
|
|
SumOfFeatureEvidence, ProtoEvidence, Debug);
|
|
|
|
/* Find Best Evidence for Current Feature */
|
|
Temp = 0;
|
|
UINT8Pointer = FeatureEvidence;
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++, UINT8Pointer++)
|
|
if (*UINT8Pointer > Temp)
|
|
Temp = *UINT8Pointer;
|
|
|
|
/* Find Bad Features */
|
|
if (Temp < AdaptFeatureThresh) {
|
|
*FeatureArray = Feature;
|
|
FeatureArray++;
|
|
NumBadFeatures++;
|
|
}
|
|
}
|
|
|
|
#ifndef GRAPHICS_DISABLED
|
|
if (PrintProtoMatchesOn (Debug) || PrintMatchSummaryOn (Debug))
|
|
IMDebugFeatureProtoError(ClassTemplate,
|
|
ProtoMask,
|
|
ConfigMask,
|
|
SumOfFeatureEvidence,
|
|
ProtoEvidence,
|
|
NumFeatures,
|
|
Debug);
|
|
#endif
|
|
|
|
if (MatchDebuggingOn (Debug))
|
|
cprintf ("Match Complete --------------------------------------------\n");
|
|
|
|
return NumBadFeatures;
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void InitIntegerMatcher() {
|
|
int i;
|
|
UINT32 IntSimilarity;
|
|
double Similarity;
|
|
double Evidence;
|
|
double ScaleFactor;
|
|
|
|
/* Set default mode of operation of IntegerMatcher */
|
|
SetCharNormMatch();
|
|
|
|
/* Initialize table for evidence to similarity lookup */
|
|
for (i = 0; i < SE_TABLE_SIZE; i++) {
|
|
IntSimilarity = i << (27 - SE_TABLE_BITS);
|
|
Similarity = ((double) IntSimilarity) / 65536.0 / 65536.0;
|
|
Evidence = Similarity / SimilarityCenter;
|
|
Evidence *= Evidence;
|
|
Evidence += 1.0;
|
|
Evidence = 1.0 / Evidence;
|
|
Evidence *= 255.0;
|
|
|
|
if (SEExponentialMultiplier > 0.0) {
|
|
ScaleFactor = 1.0 - exp (-SEExponentialMultiplier) *
|
|
exp (SEExponentialMultiplier * ((double) i / SE_TABLE_SIZE));
|
|
if (ScaleFactor > 1.0)
|
|
ScaleFactor = 1.0;
|
|
if (ScaleFactor < 0.0)
|
|
ScaleFactor = 0.0;
|
|
Evidence *= ScaleFactor;
|
|
}
|
|
|
|
SimilarityEvidenceTable[i] = (UINT8) (Evidence + 0.5);
|
|
}
|
|
|
|
/* Initialize evidence computation variables */
|
|
EvidenceTableMask =
|
|
((1 << EvidenceTableBits) - 1) << (9 - EvidenceTableBits);
|
|
MultTruncShiftBits = (14 - IntEvidenceTruncBits);
|
|
TableTruncShiftBits = (27 - SE_TABLE_BITS - (MultTruncShiftBits << 1));
|
|
EvidenceMultMask = ((1 << IntEvidenceTruncBits) - 1);
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void InitIntegerMatcherVars() {
|
|
MakeClassPrunerThreshold();
|
|
MakeClassPrunerMultiplier();
|
|
MakeIntegerMatcherMultiplier();
|
|
MakeIntThetaFudge();
|
|
MakeCPCutoffStrength();
|
|
MakeEvidenceTableBits();
|
|
MakeIntEvidenceTruncBits();
|
|
MakeSEExponentialMultiplier();
|
|
MakeSimilarityCenter();
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
void PrintIntMatcherStats(FILE *f) {
|
|
fprintf (f, "protoword_lookups=%d, zero_protowords=%d, proto_shifts=%d\n",
|
|
protoword_lookups, zero_protowords, proto_shifts);
|
|
fprintf (f, "set_proto_bits=%d, config_shifts=%d, set_config_bits=%d\n",
|
|
set_proto_bits, config_shifts, set_config_bits);
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
void SetProtoThresh(FLOAT32 Threshold) {
|
|
AdaptProtoThresh = (int) (255 * Threshold);
|
|
if (AdaptProtoThresh < 0)
|
|
AdaptProtoThresh = 0;
|
|
if (AdaptProtoThresh > 255)
|
|
AdaptProtoThresh = 255;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void SetFeatureThresh(FLOAT32 Threshold) {
|
|
AdaptFeatureThresh = (int) (255 * Threshold);
|
|
if (AdaptFeatureThresh < 0)
|
|
AdaptFeatureThresh = 0;
|
|
if (AdaptFeatureThresh > 255)
|
|
AdaptFeatureThresh = 255;
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
void SetBaseLineMatch() {
|
|
LocalMatcherMultiplier = 0;
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
void SetCharNormMatch() {
|
|
LocalMatcherMultiplier = IntegerMatcherMultiplier;
|
|
}
|
|
|
|
|
|
/**----------------------------------------------------------------------------
|
|
Private Code
|
|
----------------------------------------------------------------------------**/
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
IMClearTables (INT_CLASS ClassTemplate,
|
|
int SumOfFeatureEvidence[MAX_NUM_CONFIGS],
|
|
UINT8 ProtoEvidence[MAX_NUM_PROTOS][MAX_PROTO_INDEX]) {
|
|
/*
|
|
** Parameters:
|
|
** SumOfFeatureEvidence Sum of Feature Evidence Table
|
|
** NumConfigs Number of Configurations
|
|
** ProtoEvidence Prototype Evidence Table
|
|
** NumProtos Number of Prototypes
|
|
** Globals:
|
|
** Operation:
|
|
** Clear SumOfFeatureEvidence and ProtoEvidence tables.
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
register UINT8 *UINT8Pointer;
|
|
register int *IntPointer;
|
|
register int ConfigNum;
|
|
int NumConfigs;
|
|
register UINT16 ProtoNum;
|
|
int NumProtos;
|
|
register int ProtoIndex;
|
|
|
|
NumProtos = NumIntProtosIn (ClassTemplate);
|
|
NumConfigs = NumIntConfigsIn (ClassTemplate);
|
|
|
|
IntPointer = SumOfFeatureEvidence;
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++, IntPointer++)
|
|
*IntPointer = 0;
|
|
UINT8Pointer = (UINT8 *) ProtoEvidence;
|
|
for (ProtoNum = 0; ProtoNum < NumProtos; ProtoNum++)
|
|
for (ProtoIndex = 0; ProtoIndex < MAX_PROTO_INDEX;
|
|
ProtoIndex++, UINT8Pointer++)
|
|
*UINT8Pointer = 0;
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
IMClearFeatureEvidenceTable (UINT8 FeatureEvidence[MAX_NUM_CONFIGS],
|
|
int NumConfigs) {
|
|
/*
|
|
** Parameters:
|
|
** FeatureEvidence Feature Evidence Table
|
|
** NumConfigs Number of Configurations
|
|
** Globals:
|
|
** Operation:
|
|
** Clear FeatureEvidence table.
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
register UINT8 *UINT8Pointer;
|
|
register int ConfigNum;
|
|
|
|
UINT8Pointer = FeatureEvidence;
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++, UINT8Pointer++)
|
|
*UINT8Pointer = 0;
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void IMDebugConfiguration(int FeatureNum,
|
|
UINT16 ActualProtoNum,
|
|
UINT8 Evidence,
|
|
BIT_VECTOR ConfigMask,
|
|
UINT32 ConfigWord) {
|
|
/*
|
|
** Parameters:
|
|
** Globals:
|
|
** Operation:
|
|
** Print debugging information for Configuations
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
cprintf ("F = %3d, P = %3d, E = %3d, Configs = ",
|
|
FeatureNum, (int) ActualProtoNum, (int) Evidence);
|
|
while (ConfigWord) {
|
|
if (ConfigWord & 1)
|
|
cprintf ("1");
|
|
else
|
|
cprintf ("0");
|
|
ConfigWord >>= 1;
|
|
}
|
|
cprintf ("\n");
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void IMDebugConfigurationSum(int FeatureNum,
|
|
UINT8 *FeatureEvidence,
|
|
INT32 ConfigCount) {
|
|
/*
|
|
** Parameters:
|
|
** Globals:
|
|
** Operation:
|
|
** Print debugging information for Configuations
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
int ConfigNum;
|
|
|
|
cprintf ("F=%3d, C=", (int) FeatureNum);
|
|
|
|
for (ConfigNum = 0; ConfigNum < ConfigCount; ConfigNum++) {
|
|
cprintf ("%4d", FeatureEvidence[ConfigNum]);
|
|
}
|
|
cprintf ("\n");
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
PMUpdateTablesForFeature (INT_CLASS ClassTemplate,
|
|
int FeatureNum,
|
|
INT_FEATURE Feature,
|
|
UINT8 FeatureEvidence[MAX_NUM_CONFIGS],
|
|
int SumOfFeatureEvidence[MAX_NUM_CONFIGS],
|
|
int Debug) {
|
|
/*
|
|
** Parameters:
|
|
** ClassTemplate Prototypes & tables for a class
|
|
** FeatureNum Current feature number (for DEBUG only)
|
|
** Feature Pointer to a feature struct
|
|
** FeatureEvidence Feature Evidence Table
|
|
** SumOfFeatureEvidence Sum of Feature Evidence Table
|
|
** ProtoEvidence Prototype Evidence Table
|
|
** Debug Debugger flag: 1=debugger on
|
|
** Globals:
|
|
** Operation:
|
|
** For the given feature: prune protos, compute evidence, update Feature Evidence,
|
|
** Proto Evidence, and Sum of Feature Evidence tables.
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
UINT8 config_byte;
|
|
UINT8 proto_byte;
|
|
UINT8 Evidence;
|
|
INT32 config_offset;
|
|
UINT8 *UINT8Pointer;
|
|
UINT32 ConfigWord;
|
|
UINT32 ProtoWord;
|
|
INT32 M3;
|
|
INT32 A3;
|
|
UINT32 A4;
|
|
INT32 proto_word_offset;
|
|
INT32 proto_offset;
|
|
UINT32 ProtoNum;
|
|
UINT32 ActualProtoNum;
|
|
PROTO_SET ProtoSet;
|
|
UINT32 *ProtoPrunerPtr;
|
|
INT_PROTO Proto;
|
|
int ProtoSetIndex;
|
|
UINT32 XFeatureAddress;
|
|
UINT32 YFeatureAddress;
|
|
UINT32 ThetaFeatureAddress;
|
|
int *IntPointer;
|
|
int ConfigNum;
|
|
|
|
IMClearFeatureEvidenceTable (FeatureEvidence,
|
|
NumIntConfigsIn (ClassTemplate));
|
|
|
|
/* Precompute Feature Address offset for Proto Pruning */
|
|
XFeatureAddress = ((Feature->X >> 2) << 1);
|
|
YFeatureAddress = (NUM_PP_BUCKETS << 1) + ((Feature->Y >> 2) << 1);
|
|
ThetaFeatureAddress = (NUM_PP_BUCKETS << 2) + ((Feature->Theta >> 2) << 1);
|
|
|
|
for (ProtoSetIndex = 0, ActualProtoNum = 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), ActualProtoNum +=
|
|
(PROTOS_PER_PROTO_SET >> 1), ProtoPrunerPtr++) {
|
|
/* Prune Protos of current Proto Set */
|
|
ProtoWord = *(ProtoPrunerPtr + XFeatureAddress);
|
|
ProtoWord &= *(ProtoPrunerPtr + YFeatureAddress);
|
|
ProtoWord &= *(ProtoPrunerPtr + ThetaFeatureAddress);
|
|
|
|
if (ProtoWord != 0) {
|
|
proto_byte = ProtoWord & 0xff;
|
|
ProtoWord >>= 8;
|
|
proto_word_offset = 0;
|
|
while (ProtoWord != 0 || proto_byte != 0) {
|
|
while (proto_byte == 0) {
|
|
proto_byte = ProtoWord & 0xff;
|
|
ProtoWord >>= 8;
|
|
proto_word_offset += 8;
|
|
}
|
|
proto_offset = offset_table[proto_byte] + proto_word_offset;
|
|
proto_byte = next_table[proto_byte];
|
|
/* Compute Evidence */
|
|
Proto = &(ProtoSet->Protos[ProtoNum + proto_offset]);
|
|
ConfigWord = Proto->Configs[0];
|
|
A3 = (((Proto->A * (Feature->X - 128)) << 1)
|
|
- (Proto->B * (Feature->Y - 128)) + (Proto->C << 9));
|
|
M3 =
|
|
(((INT8) (Feature->Theta - Proto->Angle)) *
|
|
IntThetaFudge) << 1;
|
|
|
|
if (A3 < 0)
|
|
A3 = ~A3;
|
|
if (M3 < 0)
|
|
M3 = ~M3;
|
|
A3 >>= MultTruncShiftBits;
|
|
M3 >>= MultTruncShiftBits;
|
|
if (A3 > EvidenceMultMask)
|
|
A3 = EvidenceMultMask;
|
|
if (M3 > EvidenceMultMask)
|
|
M3 = EvidenceMultMask;
|
|
|
|
A4 = (A3 * A3) + (M3 * M3);
|
|
A4 >>= TableTruncShiftBits;
|
|
if (A4 > EvidenceTableMask)
|
|
Evidence = 0;
|
|
else
|
|
Evidence = SimilarityEvidenceTable[A4];
|
|
|
|
UINT8Pointer = FeatureEvidence - 8;
|
|
config_byte = 0;
|
|
while (ConfigWord != 0 || config_byte != 0) {
|
|
while (config_byte == 0) {
|
|
config_byte = ConfigWord & 0xff;
|
|
ConfigWord >>= 8;
|
|
UINT8Pointer += 8;
|
|
}
|
|
config_offset = offset_table[config_byte];
|
|
config_byte = next_table[config_byte];
|
|
if (Evidence > UINT8Pointer[config_offset])
|
|
UINT8Pointer[config_offset] = Evidence;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PrintFeatureMatchesOn (Debug))
|
|
IMDebugConfigurationSum (FeatureNum, FeatureEvidence,
|
|
NumIntConfigsIn (ClassTemplate));
|
|
IntPointer = SumOfFeatureEvidence;
|
|
UINT8Pointer = FeatureEvidence;
|
|
for (ConfigNum = NumIntConfigsIn (ClassTemplate); ConfigNum > 0;
|
|
ConfigNum--)
|
|
*IntPointer++ += (*UINT8Pointer++);
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
IMUpdateTablesForFeature (INT_CLASS ClassTemplate,
|
|
BIT_VECTOR ProtoMask,
|
|
BIT_VECTOR ConfigMask,
|
|
int FeatureNum,
|
|
INT_FEATURE Feature,
|
|
UINT8 FeatureEvidence[MAX_NUM_CONFIGS],
|
|
int SumOfFeatureEvidence[MAX_NUM_CONFIGS],
|
|
UINT8
|
|
ProtoEvidence[MAX_NUM_PROTOS][MAX_PROTO_INDEX],
|
|
int Debug) {
|
|
/*
|
|
** Parameters:
|
|
** ClassTemplate Prototypes & tables for a class
|
|
** FeatureNum Current feature number (for DEBUG only)
|
|
** Feature Pointer to a feature struct
|
|
** FeatureEvidence Feature Evidence Table
|
|
** SumOfFeatureEvidence Sum of Feature Evidence Table
|
|
** ProtoEvidence Prototype Evidence Table
|
|
** Debug Debugger flag: 1=debugger on
|
|
** Globals:
|
|
** Operation:
|
|
** For the given feature: prune protos, compute evidence, update Feature Evidence,
|
|
** Proto Evidence, and Sum of Feature Evidence tables.
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
register UINT32 ConfigWord;
|
|
register UINT32 ProtoWord;
|
|
register UINT32 ProtoNum;
|
|
register UINT32 ActualProtoNum;
|
|
UINT8 proto_byte;
|
|
INT32 proto_word_offset;
|
|
INT32 proto_offset;
|
|
UINT8 config_byte;
|
|
INT32 config_offset;
|
|
PROTO_SET ProtoSet;
|
|
UINT32 *ProtoPrunerPtr;
|
|
INT_PROTO Proto;
|
|
int ProtoSetIndex;
|
|
UINT8 Evidence;
|
|
UINT32 XFeatureAddress;
|
|
UINT32 YFeatureAddress;
|
|
UINT32 ThetaFeatureAddress;
|
|
register UINT8 *UINT8Pointer;
|
|
register int ProtoIndex;
|
|
UINT8 Temp;
|
|
register int *IntPointer;
|
|
int ConfigNum;
|
|
register INT32 M3;
|
|
register INT32 A3;
|
|
register UINT32 A4;
|
|
|
|
IMClearFeatureEvidenceTable (FeatureEvidence,
|
|
NumIntConfigsIn (ClassTemplate));
|
|
|
|
/* Precompute Feature Address offset for Proto Pruning */
|
|
XFeatureAddress = ((Feature->X >> 2) << 1);
|
|
YFeatureAddress = (NUM_PP_BUCKETS << 1) + ((Feature->Y >> 2) << 1);
|
|
ThetaFeatureAddress = (NUM_PP_BUCKETS << 2) + ((Feature->Theta >> 2) << 1);
|
|
|
|
for (ProtoSetIndex = 0, ActualProtoNum = 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), ActualProtoNum +=
|
|
(PROTOS_PER_PROTO_SET >> 1), ProtoMask++, ProtoPrunerPtr++) {
|
|
/* Prune Protos of current Proto Set */
|
|
ProtoWord = *(ProtoPrunerPtr + XFeatureAddress);
|
|
ProtoWord &= *(ProtoPrunerPtr + YFeatureAddress);
|
|
ProtoWord &= *(ProtoPrunerPtr + ThetaFeatureAddress);
|
|
ProtoWord &= *ProtoMask;
|
|
|
|
if (ProtoWord != 0) {
|
|
proto_byte = ProtoWord & 0xff;
|
|
ProtoWord >>= 8;
|
|
proto_word_offset = 0;
|
|
while (ProtoWord != 0 || proto_byte != 0) {
|
|
while (proto_byte == 0) {
|
|
proto_byte = ProtoWord & 0xff;
|
|
ProtoWord >>= 8;
|
|
proto_word_offset += 8;
|
|
}
|
|
proto_offset = offset_table[proto_byte] + proto_word_offset;
|
|
proto_byte = next_table[proto_byte];
|
|
Proto = &(ProtoSet->Protos[ProtoNum + proto_offset]);
|
|
ConfigWord = Proto->Configs[0];
|
|
A3 = (((Proto->A * (Feature->X - 128)) << 1)
|
|
- (Proto->B * (Feature->Y - 128)) + (Proto->C << 9));
|
|
M3 =
|
|
(((INT8) (Feature->Theta - Proto->Angle)) *
|
|
IntThetaFudge) << 1;
|
|
|
|
if (A3 < 0)
|
|
A3 = ~A3;
|
|
if (M3 < 0)
|
|
M3 = ~M3;
|
|
A3 >>= MultTruncShiftBits;
|
|
M3 >>= MultTruncShiftBits;
|
|
if (A3 > EvidenceMultMask)
|
|
A3 = EvidenceMultMask;
|
|
if (M3 > EvidenceMultMask)
|
|
M3 = EvidenceMultMask;
|
|
|
|
A4 = (A3 * A3) + (M3 * M3);
|
|
A4 >>= TableTruncShiftBits;
|
|
if (A4 > EvidenceTableMask)
|
|
Evidence = 0;
|
|
else
|
|
Evidence = SimilarityEvidenceTable[A4];
|
|
|
|
if (PrintFeatureMatchesOn (Debug))
|
|
IMDebugConfiguration (FeatureNum,
|
|
ActualProtoNum + proto_offset,
|
|
Evidence, ConfigMask, ConfigWord);
|
|
|
|
ConfigWord &= *ConfigMask;
|
|
|
|
UINT8Pointer = FeatureEvidence - 8;
|
|
config_byte = 0;
|
|
while (ConfigWord != 0 || config_byte != 0) {
|
|
while (config_byte == 0) {
|
|
config_byte = ConfigWord & 0xff;
|
|
ConfigWord >>= 8;
|
|
UINT8Pointer += 8;
|
|
// config_shifts++;
|
|
}
|
|
config_offset = offset_table[config_byte];
|
|
config_byte = next_table[config_byte];
|
|
if (Evidence > UINT8Pointer[config_offset])
|
|
UINT8Pointer[config_offset] = Evidence;
|
|
}
|
|
|
|
UINT8Pointer =
|
|
&(ProtoEvidence[ActualProtoNum + proto_offset][0]);
|
|
for (ProtoIndex =
|
|
LengthForProtoId (ClassTemplate,
|
|
ActualProtoNum + proto_offset);
|
|
ProtoIndex > 0; ProtoIndex--, UINT8Pointer++) {
|
|
if (Evidence > *UINT8Pointer) {
|
|
Temp = *UINT8Pointer;
|
|
*UINT8Pointer = Evidence;
|
|
Evidence = Temp;
|
|
}
|
|
else if (Evidence == 0)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PrintFeatureMatchesOn (Debug))
|
|
IMDebugConfigurationSum (FeatureNum, FeatureEvidence,
|
|
NumIntConfigsIn (ClassTemplate));
|
|
IntPointer = SumOfFeatureEvidence;
|
|
UINT8Pointer = FeatureEvidence;
|
|
for (ConfigNum = NumIntConfigsIn (ClassTemplate); ConfigNum > 0;
|
|
ConfigNum--)
|
|
*IntPointer++ += (*UINT8Pointer++);
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
#ifndef GRAPHICS_DISABLED
|
|
void
|
|
IMDebugFeatureProtoError (INT_CLASS ClassTemplate,
|
|
BIT_VECTOR ProtoMask,
|
|
BIT_VECTOR ConfigMask,
|
|
int SumOfFeatureEvidence[MAX_NUM_CONFIGS],
|
|
UINT8
|
|
ProtoEvidence[MAX_NUM_PROTOS][MAX_PROTO_INDEX],
|
|
INT16 NumFeatures, int Debug) {
|
|
/*
|
|
** Parameters:
|
|
** Globals:
|
|
** Operation:
|
|
** Print debugging information for Configuations
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
UINT8 *UINT8Pointer;
|
|
int *IntPointer;
|
|
FLOAT32 ProtoConfigs[MAX_NUM_CONFIGS];
|
|
int ConfigNum;
|
|
UINT32 ConfigWord;
|
|
int ProtoSetIndex;
|
|
UINT16 ProtoNum;
|
|
UINT8 ProtoWordNum;
|
|
PROTO_SET ProtoSet;
|
|
int ProtoIndex;
|
|
int NumProtos;
|
|
UINT16 ActualProtoNum;
|
|
int Temp;
|
|
int NumConfigs;
|
|
|
|
NumProtos = NumIntProtosIn (ClassTemplate);
|
|
NumConfigs = NumIntConfigsIn (ClassTemplate);
|
|
|
|
if (PrintMatchSummaryOn (Debug)) {
|
|
cprintf ("Configuration Mask:\n");
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++)
|
|
cprintf ("%1d", (((*ConfigMask) >> ConfigNum) & 1));
|
|
cprintf ("\n");
|
|
|
|
cprintf ("Feature Error for Configurations:\n");
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++)
|
|
cprintf (" %5.1f",
|
|
100.0 * (1.0 -
|
|
(FLOAT32) SumOfFeatureEvidence[ConfigNum] /
|
|
NumFeatures / 256.0));
|
|
cprintf ("\n\n\n");
|
|
}
|
|
|
|
if (PrintMatchSummaryOn (Debug)) {
|
|
cprintf ("Proto Mask:\n");
|
|
for (ProtoSetIndex = 0; ProtoSetIndex < NumProtoSetsIn (ClassTemplate);
|
|
ProtoSetIndex++) {
|
|
ActualProtoNum = (ProtoSetIndex * PROTOS_PER_PROTO_SET);
|
|
for (ProtoWordNum = 0; ProtoWordNum < 2;
|
|
ProtoWordNum++, ProtoMask++) {
|
|
ActualProtoNum = (ProtoSetIndex * PROTOS_PER_PROTO_SET);
|
|
for (ProtoNum = 0;
|
|
((ProtoNum < (PROTOS_PER_PROTO_SET >> 1))
|
|
&& (ActualProtoNum < NumProtos));
|
|
ProtoNum++, ActualProtoNum++)
|
|
cprintf ("%1d", (((*ProtoMask) >> ProtoNum) & 1));
|
|
cprintf ("\n");
|
|
}
|
|
}
|
|
cprintf ("\n");
|
|
}
|
|
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++)
|
|
ProtoConfigs[ConfigNum] = 0;
|
|
|
|
if (PrintProtoMatchesOn (Debug)) {
|
|
cprintf ("Proto Evidence:\n");
|
|
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++) {
|
|
cprintf ("P %3d =", ActualProtoNum);
|
|
Temp = 0;
|
|
UINT8Pointer = &(ProtoEvidence[ActualProtoNum][0]);
|
|
for (ProtoIndex = 0;
|
|
ProtoIndex < LengthForProtoId (ClassTemplate,
|
|
ActualProtoNum);
|
|
ProtoIndex++, UINT8Pointer++) {
|
|
cprintf (" %d", *UINT8Pointer);
|
|
Temp += *UINT8Pointer;
|
|
}
|
|
|
|
cprintf (" = %6.4f%%\n", Temp /
|
|
256.0 / LengthForProtoId (ClassTemplate,
|
|
ActualProtoNum));
|
|
|
|
ConfigWord = (ProtoSet->Protos[ProtoNum]).Configs[0];
|
|
IntPointer = SumOfFeatureEvidence;
|
|
ConfigNum = 0;
|
|
while (ConfigWord) {
|
|
cprintf ("%5d", ConfigWord & 1 ? Temp : 0);
|
|
if (ConfigWord & 1)
|
|
ProtoConfigs[ConfigNum] += Temp;
|
|
IntPointer++;
|
|
ConfigNum++;
|
|
ConfigWord >>= 1;
|
|
}
|
|
cprintf ("\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PrintMatchSummaryOn (Debug)) {
|
|
cprintf ("Proto Error for Configurations:\n");
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++)
|
|
cprintf (" %5.1f",
|
|
100.0 * (1.0 -
|
|
ProtoConfigs[ConfigNum] /
|
|
LengthForConfigId (ClassTemplate,
|
|
ConfigNum) / 256.0));
|
|
cprintf ("\n\n");
|
|
}
|
|
|
|
if (PrintProtoMatchesOn (Debug)) {
|
|
cprintf ("Proto Sum for Configurations:\n");
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++)
|
|
cprintf (" %4.1f", ProtoConfigs[ConfigNum] / 256.0);
|
|
cprintf ("\n\n");
|
|
|
|
cprintf ("Proto Length for Configurations:\n");
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++)
|
|
cprintf (" %4.1f",
|
|
(float) LengthForConfigId (ClassTemplate, ConfigNum));
|
|
cprintf ("\n\n");
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
IMDisplayProtoDebugInfo (INT_CLASS ClassTemplate,
|
|
BIT_VECTOR ProtoMask,
|
|
BIT_VECTOR ConfigMask,
|
|
UINT8 ProtoEvidence[MAX_NUM_PROTOS][MAX_PROTO_INDEX],
|
|
int Debug) {
|
|
register UINT8 *UINT8Pointer;
|
|
register UINT32 ConfigWord;
|
|
register UINT16 ProtoNum;
|
|
register UINT16 ActualProtoNum;
|
|
PROTO_SET ProtoSet;
|
|
int ProtoSetIndex;
|
|
int ProtoIndex;
|
|
int NumProtos;
|
|
register int Temp;
|
|
|
|
extern void *IntMatchWindow;
|
|
|
|
if (IntMatchWindow == NULL) {
|
|
IntMatchWindow = c_create_window ("IntMatchWindow", 50, 200,
|
|
520, 520,
|
|
-130.0, 130.0, -130.0, 130.0);
|
|
}
|
|
NumProtos = NumIntProtosIn (ClassTemplate);
|
|
|
|
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++) {
|
|
/* Compute Average for Actual Proto */
|
|
Temp = 0;
|
|
UINT8Pointer = &(ProtoEvidence[ActualProtoNum][0]);
|
|
for (ProtoIndex = LengthForProtoId (ClassTemplate, ActualProtoNum);
|
|
ProtoIndex > 0; ProtoIndex--, UINT8Pointer++)
|
|
Temp += *UINT8Pointer;
|
|
|
|
Temp /= LengthForProtoId (ClassTemplate, ActualProtoNum);
|
|
|
|
ConfigWord = (ProtoSet->Protos[ProtoNum]).Configs[0];
|
|
ConfigWord &= *ConfigMask;
|
|
if (ConfigWord)
|
|
/* Update display for current proto */
|
|
if (ClipMatchEvidenceOn (Debug)) {
|
|
if (Temp < AdaptProtoThresh)
|
|
DisplayIntProto (ClassTemplate, ActualProtoNum,
|
|
(Temp / 255.0));
|
|
else
|
|
DisplayIntProto (ClassTemplate, ActualProtoNum,
|
|
(Temp / 255.0));
|
|
}
|
|
else {
|
|
DisplayIntProto (ClassTemplate, ActualProtoNum,
|
|
(Temp / 255.0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void IMDisplayFeatureDebugInfo(INT_CLASS ClassTemplate,
|
|
BIT_VECTOR ProtoMask,
|
|
BIT_VECTOR ConfigMask,
|
|
INT16 NumFeatures,
|
|
INT_FEATURE_ARRAY Features,
|
|
int Debug) {
|
|
static UINT8 FeatureEvidence[MAX_NUM_CONFIGS];
|
|
static int SumOfFeatureEvidence[MAX_NUM_CONFIGS];
|
|
static UINT8 ProtoEvidence[MAX_NUM_PROTOS][MAX_PROTO_INDEX];
|
|
int Feature;
|
|
register UINT8 *UINT8Pointer;
|
|
register int ConfigNum;
|
|
int NumConfigs;
|
|
register int Temp;
|
|
|
|
IMClearTables(ClassTemplate, SumOfFeatureEvidence, ProtoEvidence);
|
|
|
|
NumConfigs = NumIntConfigsIn (ClassTemplate);
|
|
for (Feature = 0; Feature < NumFeatures; Feature++) {
|
|
IMUpdateTablesForFeature (ClassTemplate, ProtoMask, ConfigMask, Feature,
|
|
&(Features[Feature]), FeatureEvidence,
|
|
SumOfFeatureEvidence, ProtoEvidence, 0);
|
|
|
|
/* Find Best Evidence for Current Feature */
|
|
Temp = 0;
|
|
UINT8Pointer = FeatureEvidence;
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++, UINT8Pointer++)
|
|
if (*UINT8Pointer > Temp)
|
|
Temp = *UINT8Pointer;
|
|
|
|
/* Update display for current feature */
|
|
if (ClipMatchEvidenceOn (Debug)) {
|
|
if (Temp < AdaptFeatureThresh)
|
|
DisplayIntFeature (&(Features[Feature]), 0.0);
|
|
else
|
|
DisplayIntFeature (&(Features[Feature]), 1.0);
|
|
}
|
|
else {
|
|
DisplayIntFeature (&(Features[Feature]), (Temp / 255.0));
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
IMUpdateSumOfProtoEvidences (INT_CLASS ClassTemplate,
|
|
BIT_VECTOR ConfigMask,
|
|
int SumOfFeatureEvidence[MAX_NUM_CONFIGS],
|
|
UINT8
|
|
ProtoEvidence[MAX_NUM_PROTOS][MAX_PROTO_INDEX],
|
|
INT16 NumFeatures) {
|
|
/*
|
|
** Parameters:
|
|
** Globals:
|
|
** Operation:
|
|
** Add sum of Proto Evidences into Sum Of Feature Evidence Array
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
register UINT8 *UINT8Pointer;
|
|
register int *IntPointer;
|
|
register UINT32 ConfigWord;
|
|
int ProtoSetIndex;
|
|
register UINT16 ProtoNum;
|
|
PROTO_SET ProtoSet;
|
|
register int ProtoIndex;
|
|
int NumProtos;
|
|
UINT16 ActualProtoNum;
|
|
int Temp;
|
|
|
|
NumProtos = NumIntProtosIn (ClassTemplate);
|
|
|
|
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++) {
|
|
Temp = 0;
|
|
UINT8Pointer = &(ProtoEvidence[ActualProtoNum][0]);
|
|
for (ProtoIndex = LengthForProtoId (ClassTemplate, ActualProtoNum);
|
|
ProtoIndex > 0; ProtoIndex--, UINT8Pointer++)
|
|
Temp += *UINT8Pointer;
|
|
|
|
ConfigWord = (ProtoSet->Protos[ProtoNum]).Configs[0];
|
|
ConfigWord &= *ConfigMask;
|
|
IntPointer = SumOfFeatureEvidence;
|
|
while (ConfigWord) {
|
|
if (ConfigWord & 1)
|
|
*IntPointer += Temp;
|
|
IntPointer++;
|
|
ConfigWord >>= 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
PMNormalizeSumOfEvidences (INT_CLASS ClassTemplate,
|
|
int SumOfFeatureEvidence[MAX_NUM_CONFIGS],
|
|
INT16 NumFeatures, INT32 used_features) {
|
|
/*
|
|
** Parameters:
|
|
** Globals:
|
|
** Operation:
|
|
** Normalize Sum of Proto and Feature Evidence by dividing by
|
|
** the sum of the Feature Lengths and the Proto Lengths for each
|
|
** configuration.
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
register int *IntPointer;
|
|
register int ConfigNum;
|
|
int NumConfigs;
|
|
|
|
NumConfigs = NumIntConfigsIn (ClassTemplate);
|
|
if (used_features <= 0)
|
|
used_features = 1;
|
|
|
|
IntPointer = SumOfFeatureEvidence;
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++, IntPointer++)
|
|
*IntPointer = (*IntPointer << 8) / used_features;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
IMNormalizeSumOfEvidences (INT_CLASS ClassTemplate,
|
|
int SumOfFeatureEvidence[MAX_NUM_CONFIGS],
|
|
INT16 NumFeatures, INT32 used_features) {
|
|
/*
|
|
** Parameters:
|
|
** Globals:
|
|
** Operation:
|
|
** Normalize Sum of Proto and Feature Evidence by dividing by
|
|
** the sum of the Feature Lengths and the Proto Lengths for each
|
|
** configuration.
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
register int *IntPointer;
|
|
register int ConfigNum;
|
|
int NumConfigs;
|
|
|
|
NumConfigs = NumIntConfigsIn (ClassTemplate);
|
|
|
|
IntPointer = SumOfFeatureEvidence;
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++, IntPointer++)
|
|
*IntPointer = (*IntPointer << 8) /
|
|
(NumFeatures + LengthForConfigId (ClassTemplate, ConfigNum));
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
int
|
|
IMFindBestMatch (INT_CLASS ClassTemplate,
|
|
int SumOfFeatureEvidence[MAX_NUM_CONFIGS],
|
|
UINT16 BlobLength,
|
|
UINT8 NormalizationFactor, INT_RESULT Result) {
|
|
/*
|
|
** Parameters:
|
|
** Globals:
|
|
** Operation:
|
|
** Find the best match for the current class and update the Result
|
|
** with the configuration and match rating.
|
|
** Return:
|
|
** The best normalized sum of evidences
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
register int *IntPointer;
|
|
register int ConfigNum;
|
|
register int NumConfigs;
|
|
register int BestMatch;
|
|
register int Best2Match;
|
|
|
|
NumConfigs = NumIntConfigsIn (ClassTemplate);
|
|
|
|
/* Find best match */
|
|
BestMatch = 0;
|
|
Best2Match = 0;
|
|
IntPointer = SumOfFeatureEvidence;
|
|
for (ConfigNum = 0; ConfigNum < NumConfigs; ConfigNum++, IntPointer++) {
|
|
if (display_ratings > 1)
|
|
cprintf ("Config %d, rating=%d\n", ConfigNum, *IntPointer);
|
|
if (*IntPointer > BestMatch) {
|
|
if (BestMatch > 0) {
|
|
Result->Config2 = Result->Config;
|
|
Best2Match = BestMatch;
|
|
}
|
|
else
|
|
Result->Config2 = ConfigNum;
|
|
Result->Config = ConfigNum;
|
|
BestMatch = *IntPointer;
|
|
}
|
|
else if (*IntPointer > Best2Match) {
|
|
Result->Config2 = ConfigNum;
|
|
Best2Match = *IntPointer;
|
|
}
|
|
}
|
|
|
|
/* Compute Certainty Rating */
|
|
(*Result).Rating = ((65536.0 - BestMatch) / 65536.0 * BlobLength +
|
|
LocalMatcherMultiplier * NormalizationFactor / 256.0) /
|
|
(BlobLength + LocalMatcherMultiplier);
|
|
|
|
return BestMatch;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
#ifndef GRAPHICS_DISABLED
|
|
void IMDebugBestMatch(int BestMatch,
|
|
INT_RESULT Result,
|
|
UINT16 BlobLength,
|
|
UINT8 NormalizationFactor) {
|
|
/*
|
|
** Parameters:
|
|
** Globals:
|
|
** Operation:
|
|
** Find the best match for the current class and update the Result
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Wed Feb 27 14:12:28 MST 1991, RWM, Created.
|
|
*/
|
|
cprintf ("Rating = %5.1f%% Best Config = %3d\n",
|
|
100.0 * ((*Result).Rating), (int) ((*Result).Config));
|
|
cprintf
|
|
("Matcher Error = %5.1f%% Blob Length = %3d Weight = %4.1f%%\n",
|
|
100.0 * (65536.0 - BestMatch) / 65536.0, (int) BlobLength,
|
|
100.0 * BlobLength / (BlobLength + LocalMatcherMultiplier));
|
|
cprintf
|
|
("Char Norm Error = %5.1f%% Norm Strength = %3d Weight = %4.1f%%\n",
|
|
100.0 * NormalizationFactor / 256.0, LocalMatcherMultiplier,
|
|
100.0 * LocalMatcherMultiplier / (BlobLength + LocalMatcherMultiplier));
|
|
}
|
|
#endif
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
HeapSort (int n, register INT16 ra[], register UINT8 rb[]) {
|
|
/*
|
|
** Parameters:
|
|
** n Number of elements to sort
|
|
** ra Key array [1..n]
|
|
** rb Index array [1..n]
|
|
** Globals:
|
|
** Operation:
|
|
** Sort Key array in ascending order using heap sort
|
|
** algorithm. Also sort Index array that is tied to
|
|
** the key array.
|
|
** Return:
|
|
** Exceptions: none
|
|
** History: Tue Feb 19 10:24:24 MST 1991, RWM, Created.
|
|
*/
|
|
register int i, rra, rrb;
|
|
int l, j, ir;
|
|
|
|
l = (n >> 1) + 1;
|
|
ir = n;
|
|
for (;;) {
|
|
if (l > 1) {
|
|
rra = ra[--l];
|
|
rrb = rb[l];
|
|
}
|
|
else {
|
|
rra = ra[ir];
|
|
rrb = rb[ir];
|
|
ra[ir] = ra[1];
|
|
rb[ir] = rb[1];
|
|
if (--ir == 1) {
|
|
ra[1] = rra;
|
|
rb[1] = rrb;
|
|
return;
|
|
}
|
|
}
|
|
i = l;
|
|
j = l << 1;
|
|
while (j <= ir) {
|
|
if (j < ir && ra[j] < ra[j + 1])
|
|
++j;
|
|
if (rra < ra[j]) {
|
|
ra[i] = ra[j];
|
|
rb[i] = rb[j];
|
|
j += (i = j);
|
|
}
|
|
else
|
|
j = ir + 1;
|
|
}
|
|
ra[i] = rra;
|
|
rb[i] = rrb;
|
|
}
|
|
}
|