#include "intproto.h"
#include "picofeat.h"
#include "debug.h"
#include "mfoutline.h"
#include "emalloc.h"
#include "const.h"
#include "ndminx.h"
#include "adaptmatch.h"
#include <math.h>
#include <stdio.h>
#include <assert.h>
Go to the source code of this file.
#define AS ANGLE_SHIFT |
Referenced by InitTableFiller().
#define CircularIncrement | ( | i, | |||
r | ) | (((i) < (r) - 1)?((i)++):((i) = 0)) |
Performing circular increments of bucket indices
Definition at line 114 of file intproto.cpp.
Referenced by DoFill(), and FillPPCircularBits().
#define DISPLAY_OFFSET (0.5 * INT_CHAR_NORM_RANGE) |
** (c) Copyright Hewlett-Packard Company, 1988. ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with the License. ** You may obtain a copy of the License at ** http://www.apache.org/licenses/LICENSE-2.0 ** Unless required by applicable law or agreed to in writing, software ** distributed under the License is distributed on an "AS IS" BASIS, ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** See the License for the specific language governing permissions and ** limitations under the License.
Definition at line 38 of file intproto.cpp.
Referenced by RenderIntFeature(), and RenderIntProto().
#define DOUBLE_OFFSET 0.095 |
#define HV_TOLERANCE (0.0025) |
Pad used to snap near horiz/vertical protos to horiz/vertical; approx 0.9 degrees
Definition at line 58 of file intproto.cpp.
Referenced by InitTableFiller().
#define INT_BASELINE (0.25 * INT_CHAR_NORM_RANGE - DISPLAY_OFFSET) |
#define INT_CAPHEIGHT (1.0 * INT_CHAR_NORM_RANGE - DISPLAY_OFFSET) |
#define INT_DESCENDER (0.0 * INT_CHAR_NORM_RANGE - DISPLAY_OFFSET) |
#define INT_MAX_X ( DISPLAY_OFFSET) |
#define INT_MAX_Y ( DISPLAY_OFFSET) |
#define INT_MIN_X (- DISPLAY_OFFSET) |
#define INT_MIN_Y (- DISPLAY_OFFSET) |
#define INT_XCENTER (0.5 * INT_CHAR_NORM_RANGE - DISPLAY_OFFSET) |
#define INT_XHEIGHT (0.75 * INT_CHAR_NORM_RANGE - DISPLAY_OFFSET) |
#define INT_XRADIUS (0.2 * INT_CHAR_NORM_RANGE) |
#define INT_YCENTER (0.5 * INT_CHAR_NORM_RANGE - DISPLAY_OFFSET) |
#define INT_YRADIUS (0.2 * INT_CHAR_NORM_RANGE) |
Mapping floats to ints without bounds checking
Definition at line 117 of file intproto.cpp.
Referenced by BucketFor(), CircBucketFor(), and InitTableFiller().
#define MAX_LEVEL 2 |
Referenced by AddProtoToClassPruner().
#define MAX_NUM_SWITCHES 3 |
Definition at line 71 of file intproto.cpp.
#define NB NUM_CP_BUCKETS |
Referenced by InitTableFiller().
#define PROTO_PRUNER_SCALE (4.0) |
#define XS X_SHIFT |
Referenced by InitTableFiller().
#define YS Y_SHIFT |
Referenced by InitTableFiller().
enum SWITCH_TYPE |
FIX: something for integer prototypes.
Definition at line 64 of file intproto.cpp.
00065 { 00066 StartSwitch, 00067 EndSwitch, 00068 LastSwitch 00069 } SWITCH_TYPE;
int AddIntClass | ( | INT_TEMPLATES | Templates, | |
CLASS_ID | ClassId, | |||
INT_CLASS | Class | |||
) |
Adds a new class structure to a set of templates.
Templates | Templates to add new class to | |
ClassId | Class id to associate new class with | |
Class | Class data structure to add to templates |
Definition at line 289 of file intproto.cpp.
References assert(), ClassForIndex, ClassIdForIndex, Emalloc(), IndexForClassId, LegalClassId, MaxNumClassesIn, NumClassesIn, NumClassPrunersIn, UnusedClassIdIn, and WERDS_PER_CP.
Referenced by AddAdaptedClass(), and CreateIntTemplates().
00289 { 00290 int Index; 00291 int Pruner; 00292 UINT32 *Word; 00293 00294 assert (LegalClassId (ClassId)); 00295 assert (UnusedClassIdIn (Templates, ClassId)); 00296 00297 Index = NumClassesIn (Templates); 00298 IndexForClassId (Templates, ClassId) = Index; 00299 ClassIdForIndex (Templates, Index) = ClassId; 00300 00301 NumClassesIn (Templates)++; 00302 ClassForIndex (Templates, Index) = Class; 00303 00304 if (NumClassesIn (Templates) > MaxNumClassesIn (Templates)) { 00305 Pruner = NumClassPrunersIn (Templates); 00306 NumClassPrunersIn (Templates)++; 00307 Templates->ClassPruner[Pruner] = 00308 (CLASS_PRUNER) Emalloc (sizeof (CLASS_PRUNER_STRUCT)); 00309 00310 for (Word = (UINT32 *) (Templates->ClassPruner[Pruner]); 00311 Word < (UINT32 *) (Templates->ClassPruner[Pruner]) + WERDS_PER_CP; 00312 *Word++ = 0); 00313 } 00314 00315 return (Index); 00316 00317 } /* AddIntClass */
int AddIntConfig | ( | INT_CLASS | Class | ) |
Returns the index of the next free config in Class.
Class | Class to add new configuration to |
Definition at line 329 of file intproto.cpp.
References assert(), LengthForConfigId, MAX_NUM_CONFIGS, and NumIntConfigsIn.
Referenced by CreateIntTemplates(), MakeNewAdaptedClass(), and MakeNewTemporaryConfig().
00329 { 00330 int Index; 00331 00332 assert (NumIntConfigsIn (Class) < MAX_NUM_CONFIGS); 00333 00334 Index = NumIntConfigsIn (Class); 00335 NumIntConfigsIn (Class)++; 00336 LengthForConfigId (Class, Index) = 0; 00337 return (Index); 00338 } /* AddIntConfig */
int AddIntProto | ( | INT_CLASS | Class | ) |
Allocates the next free proto in Class and returns its index.
Class | Class to add new proto to |
Definition at line 350 of file intproto.cpp.
References Emalloc(), Erealloc(), LengthForProtoId, MAX_NUM_PROTOS, MaxNumIntProtosIn, NO_PROTO, NumIntProtosIn, NumProtoSetsIn, ProtoForProtoId, ProtoPrunerFor, ProtoSetIn, WERDS_PER_CONFIG_VEC, and WERDS_PER_PP.
Referenced by CreateIntTemplates(), MakeNewAdaptedClass(), and MakeNewTempProtos().
00350 { 00351 int Index; 00352 int ProtoSetId; 00353 PROTO_SET ProtoSet; 00354 INT_PROTO Proto; 00355 register UINT32 *Word; 00356 00357 if (NumIntProtosIn (Class) >= MAX_NUM_PROTOS) 00358 return (NO_PROTO); 00359 00360 Index = NumIntProtosIn (Class); 00361 NumIntProtosIn (Class)++; 00362 00363 if (NumIntProtosIn (Class) > MaxNumIntProtosIn (Class)) { 00364 ProtoSetId = NumProtoSetsIn (Class); 00365 NumProtoSetsIn (Class)++; 00366 00367 ProtoSet = (PROTO_SET) Emalloc (sizeof (PROTO_SET_STRUCT)); 00368 ProtoSetIn (Class, ProtoSetId) = ProtoSet; 00369 for (Word = (UINT32 *) (ProtoPrunerFor (ProtoSet)); 00370 Word < (UINT32 *) (ProtoPrunerFor (ProtoSet)) + WERDS_PER_PP; 00371 *Word++ = 0); 00372 00373 /* reallocate space for the proto lengths and install in class */ 00374 Class->ProtoLengths = (UINT8 *) Erealloc (Class->ProtoLengths, 00375 MaxNumIntProtosIn (Class) * 00376 sizeof (UINT8)); 00377 } 00378 00379 /* initialize proto so its length is zero and it isn't in any configs */ 00380 LengthForProtoId (Class, Index) = 0; 00381 Proto = ProtoForProtoId (Class, Index); 00382 for (Word = Proto->Configs; 00383 Word < Proto->Configs + WERDS_PER_CONFIG_VEC; *Word++ = 0); 00384 00385 return (Index); 00386 00387 } /* AddIntProto */
void AddProtoToClassPruner | ( | PROTO | Proto, | |
CLASS_ID | ClassId, | |||
INT_TEMPLATES | Templates | |||
) |
Adds Proto to the class pruning tables for the specified class in Templates.
Proto | Floating-pt proto to add to class pruner | |
ClassId | Class id corresponding to Proto | |
Templates | Set of templates containing class pruner |
Definition at line 404 of file intproto.cpp.
References CPrunerFor, CPrunerMaskFor, CPrunerWordIndexFor, DoFill(), FillerDone(), GetCPPadsForLevel(), GetNextFill(), IndexForClassId, InitTableFiller(), and MAX_LEVEL.
Referenced by CreateIntTemplates(), and MakeTempProtoPerm().
00406 { 00407 CLASS_PRUNER Pruner; 00408 UINT32 ClassMask; 00409 UINT32 ClassCount; 00410 CLASS_INDEX ClassIndex; 00411 UINT32 WordIndex; 00412 int Level; 00413 FLOAT32 EndPad, SidePad, AnglePad; 00414 TABLE_FILLER TableFiller; 00415 FILL_SPEC FillSpec; 00416 00417 ClassIndex = IndexForClassId (Templates, ClassId); 00418 Pruner = CPrunerFor (Templates, ClassIndex); 00419 WordIndex = CPrunerWordIndexFor (ClassIndex); 00420 ClassMask = CPrunerMaskFor (MAX_LEVEL, ClassIndex); 00421 00422 for (Level = NumCPLevels - 1; Level >= 0; Level--) { 00423 GetCPPadsForLevel(Level, &EndPad, &SidePad, &AnglePad); 00424 ClassCount = CPrunerMaskFor (Level, ClassIndex); 00425 InitTableFiller(EndPad, SidePad, AnglePad, Proto, &TableFiller); 00426 00427 while (!FillerDone (&TableFiller)) { 00428 GetNextFill(&TableFiller, &FillSpec); 00429 DoFill(&FillSpec, Pruner, ClassMask, ClassCount, WordIndex); 00430 } 00431 } 00432 } /* AddProtoToClassPruner */
Updates the proto-pruner lookup tables for Class to include a new proto identified by ProtoId and described by Proto.
Proto | Floating-pt proto to be added to proto pruner | |
ProtoId | Id of proto | |
Class | Integer class that contains desired proto pruner |
Definition at line 447 of file intproto.cpp.
References ANGLE_SHIFT, assert(), cprintf(), FillPPCircularBits(), FillPPLinearBits(), GetPicoFeatureLength, IndexForProto, max, NumIntProtosIn, PI, ProtoAngle, ProtoLength, ProtoSetIn, ProtoX, ProtoY, PRUNER_ANGLE, PRUNER_X, PRUNER_Y, SetForProto, X_SHIFT, and Y_SHIFT.
Referenced by CreateIntTemplates(), MakeNewAdaptedClass(), and MakeNewTempProtos().
00447 { 00448 FLOAT32 Angle, X, Y, Length; 00449 FLOAT32 Pad; 00450 int Index; 00451 PROTO_SET ProtoSet; 00452 00453 if (ProtoId >= NumIntProtosIn (Class)) 00454 cprintf ("AddProtoToProtoPruner:assert failed: %d < %d", 00455 ProtoId, NumIntProtosIn (Class)); 00456 assert (ProtoId < NumIntProtosIn (Class)); 00457 00458 Index = IndexForProto (ProtoId); 00459 ProtoSet = ProtoSetIn (Class, SetForProto (ProtoId)); 00460 00461 Angle = ProtoAngle (Proto); 00462 FillPPCircularBits (ProtoSet->ProtoPruner[PRUNER_ANGLE], Index, 00463 Angle + ANGLE_SHIFT, PPAnglePad / 360.0); 00464 00465 Angle *= 2.0 * PI; 00466 Length = ProtoLength (Proto); 00467 00468 X = ProtoX (Proto) + X_SHIFT; 00469 Pad = max (fabs (cos (Angle)) * (Length / 2.0 + 00470 PPEndPad * GetPicoFeatureLength ()), 00471 fabs (sin (Angle)) * (PPSidePad * GetPicoFeatureLength ())); 00472 00473 FillPPLinearBits (ProtoSet->ProtoPruner[PRUNER_X], Index, X, Pad); 00474 00475 Y = ProtoY (Proto) + Y_SHIFT; 00476 Pad = max (fabs (sin (Angle)) * (Length / 2.0 + 00477 PPEndPad * GetPicoFeatureLength ()), 00478 fabs (cos (Angle)) * (PPSidePad * GetPicoFeatureLength ())); 00479 00480 FillPPLinearBits (ProtoSet->ProtoPruner[PRUNER_Y], Index, Y, Pad); 00481 00482 } /* AddProtoToProtoPruner */
Returns the parameter value which corresponds to the end of the specified bucket.
Bucket | Bucket whose end is to be computed | |
Offset | Offset used to map params to buckets | |
NumBuckets | Total number of buckets |
Definition at line 1131 of file intproto.cpp.
Referenced by InitTableFiller().
01131 { 01132 return (((FLOAT32) (Bucket + 1) / NumBuckets) - Offset); 01133 } /* BucketEnd */
Maps a parameter value into a bucket between 0 and NumBuckets-1.
Param | Parameter value to map into a bucket number | |
Offset | Amount to shift param before mapping it | |
NumBuckets | Number of buckets to map param into |
Definition at line 501 of file intproto.cpp.
References MapParam.
Referenced by ComputeIntFeatures(), and InitTableFiller().
00501 { 00502 int Bucket; 00503 00504 Bucket = (int) MapParam (Param, Offset, NumBuckets); 00505 if (Bucket < 0) 00506 Bucket = 0; 00507 else if (Bucket >= NumBuckets) 00508 Bucket = NumBuckets - 1; 00509 return (Bucket); 00510 00511 } /* BucketFor */
Returns the parameter value which corresponds to the beginning of the specified bucket.
Bucket | Bucket whose start is to be computed | |
Offset | Offset used to map params to buckets | |
NumBuckets | Total number of buckets |
Definition at line 1110 of file intproto.cpp.
Referenced by InitTableFiller().
01110 { 01111 return (((FLOAT32) Bucket / NumBuckets) - Offset); 01112 01113 } /* BucketStart */
Maps a parameter value into a bucket between 0 and NumBuckets-1.
Param | Parameter value to map into a circular bucket | |
Offset | Amount to shift param before mapping it | |
NumBuckets | Number of buckets to map param into |
Definition at line 529 of file intproto.cpp.
References MapParam.
Referenced by ComputeIntFeatures(), and InitTableFiller().
00529 { 00530 int Bucket; 00531 00532 Bucket = (int) MapParam (Param, Offset, NumBuckets); 00533 if (Bucket < 0) 00534 Bucket += NumBuckets; 00535 else if (Bucket >= NumBuckets) 00536 Bucket -= NumBuckets; 00537 return (Bucket); 00538 00539 } /* CircBucketFor */
void ConvertConfig | ( | BIT_VECTOR | Config, | |
int | ConfigId, | |||
INT_CLASS | Class | |||
) |
Update config vectors of all protos in Class.
Config | Config to be added to class | |
ConfigId | Id to be used for new config | |
Class | Class to add new config to |
It is assumed that the length of the Config bit vector is equal to the number of protos in Class.
Definition at line 578 of file intproto.cpp.
References LengthForConfigId, LengthForProtoId, NumIntProtosIn, ProtoForProtoId, SET_BIT, and test_bit.
Referenced by CreateIntTemplates(), MakeNewAdaptedClass(), and MakeNewTemporaryConfig().
00578 { 00579 int ProtoId; 00580 INT_PROTO Proto; 00581 int TotalLength; 00582 00583 for (ProtoId = 0, TotalLength = 0; 00584 ProtoId < NumIntProtosIn (Class); ProtoId++) 00585 if (test_bit (Config, ProtoId)) { 00586 Proto = ProtoForProtoId (Class, ProtoId); 00587 SET_BIT (Proto->Configs, ConfigId); 00588 TotalLength += LengthForProtoId (Class, ProtoId); 00589 } 00590 LengthForConfigId (Class, ConfigId) = TotalLength; 00591 } /* ConvertConfig */
Converts Proto to integer format and installs it as ProtoId in Class.
Proto | Floating-pt proto to be converted to integer format | |
ProtoId | Id of proto | |
Class | Integer class to add converted proto to |
Definition at line 605 of file intproto.cpp.
References assert(), CoefficientA, CoefficientB, CoefficientC, cprintf(), GetPicoFeatureLength, LearningDebugLevel, LengthForProtoId, NULL, NumIntProtosIn, ProtoAngle, ProtoForProtoId, ProtoLength, and TruncateParam().
Referenced by CreateIntTemplates(), MakeNewAdaptedClass(), and MakeNewTempProtos().
00605 { 00606 INT_PROTO P; 00607 FLOAT32 Param; 00608 00609 assert (ProtoId < NumIntProtosIn (Class)); 00610 00611 P = ProtoForProtoId (Class, ProtoId); 00612 00613 Param = CoefficientA (Proto) * 128; 00614 P->A = TruncateParam (Param, -128, 127, NULL); 00615 00616 Param = -CoefficientB (Proto) * 256; 00617 P->B = TruncateParam (Param, 0, 255, NULL); 00618 00619 Param = CoefficientC (Proto) * 128; 00620 P->C = TruncateParam (Param, -128, 127, NULL); 00621 00622 Param = ProtoAngle (Proto) * 256; 00623 if (Param < 0 || Param >= 256) 00624 P->Angle = 0; 00625 else 00626 P->Angle = (UINT8) Param; 00627 00628 /* round proto length to nearest integer number of pico-features */ 00629 Param = (ProtoLength (Proto) / GetPicoFeatureLength ()) + 0.5; 00630 LengthForProtoId (Class, ProtoId) = TruncateParam (Param, 1, 255, NULL); 00631 if (LearningDebugLevel >= 2) 00632 cprintf ("Converted ffeat to (A=%d,B=%d,C=%d,L=%d)", 00633 P->A, P->B, P->C, LengthForProtoId (Class, ProtoId)); 00634 } /* ConvertProto */
INT_TEMPLATES CreateIntTemplates | ( | CLASSES | FloatProtos | ) |
Converts from the old floating point format to the new integer format.
FloatProtos | Prototypes in old floating pt format |
Definition at line 646 of file intproto.cpp.
References AddIntClass(), AddIntConfig(), AddIntProto(), AddProtoToClassPruner(), AddProtoToProtoPruner(), assert(), ConfigIn, ConvertConfig(), ConvertProto(), NewIntClass(), NewIntTemplates(), NUMBER_OF_CLASSES, NumConfigsIn, NumProtosIn, ProtoIn, and UnusedClassIdIn.
00646 { 00647 INT_TEMPLATES IntTemplates; 00648 CLASS_TYPE FClass; 00649 INT_CLASS IClass; 00650 int ClassId; 00651 int ProtoId; 00652 int ConfigId; 00653 00654 IntTemplates = NewIntTemplates (); 00655 00656 for (ClassId = 0; ClassId < NUMBER_OF_CLASSES; ClassId++) { 00657 FClass = &(FloatProtos[ClassId]); 00658 if (NumProtosIn (FClass) > 0) { 00659 assert (UnusedClassIdIn (IntTemplates, ClassId)); 00660 00661 IClass = NewIntClass (NumProtosIn (FClass), NumConfigsIn (FClass)); 00662 AddIntClass(IntTemplates, ClassId, IClass); 00663 00664 for (ProtoId = 0; ProtoId < NumProtosIn (FClass); ProtoId++) { 00665 AddIntProto(IClass); 00666 ConvertProto (ProtoIn (FClass, ProtoId), ProtoId, IClass); 00667 AddProtoToProtoPruner (ProtoIn (FClass, ProtoId), ProtoId, 00668 IClass); 00669 AddProtoToClassPruner (ProtoIn (FClass, ProtoId), ClassId, 00670 IntTemplates); 00671 } 00672 00673 for (ConfigId = 0; ConfigId < NumConfigsIn (FClass); ConfigId++) { 00674 AddIntConfig(IClass); 00675 ConvertConfig (ConfigIn (FClass, ConfigId), ConfigId, IClass); 00676 } 00677 } 00678 } 00679 return (IntTemplates); 00680 } /* CreateIntTemplates */
void DisplayIntFeature | ( | INT_FEATURE | Feature, | |
FLOAT32 | Evidence | |||
) |
Renders the specified feature into a global display list.
Feature | Pico-feature to be displayed | |
Evidence | Best evidence for this feature (0-1) |
Definition at line 695 of file intproto.cpp.
References GetMatchColorFor(), IntMatchWindow, and RenderIntFeature().
Referenced by IMDisplayFeatureDebugInfo().
00695 { 00696 C_COL Color; 00697 00698 Color = GetMatchColorFor (Evidence); 00699 RenderIntFeature(IntMatchWindow, Feature, Color); 00700 } /* DisplayIntFeature */
Renders the specified proto into a global display list.
Class | Class to take proto from | |
ProtoId | Id of proto in Class to be displayed | |
Evidence | Total evidence for proto (0-1) |
Definition at line 715 of file intproto.cpp.
References GetMatchColorFor(), IntMatchWindow, and RenderIntProto().
Referenced by IMDisplayProtoDebugInfo().
00715 { 00716 C_COL Color; 00717 00718 Color = GetMatchColorFor (Evidence); 00719 RenderIntProto(IntMatchWindow, Class, ProtoId, Color); 00720 00721 } /* DisplayIntProto */
void DoFill | ( | FILL_SPEC * | FillSpec, | |
CLASS_PRUNER | Pruner, | |||
register UINT32 | ClassMask, | |||
register UINT32 | ClassCount, | |||
register UINT32 | WordIndex | |||
) |
Fills in the section of a class pruner corresponding to a single x value for a single proto of a class.
FillSpec | Specifies which bits to fill in pruner | |
Pruner | Class pruner to be filled | |
ClassMask | Indicates which bits to change in each word | |
ClassCount | Indicates what to change bits to | |
WordIndex | Indicates which word to change |
Definition at line 1151 of file intproto.cpp.
References FILL_SPEC::AngleEnd, FILL_SPEC::AngleStart, CircularIncrement, NUM_CP_BUCKETS, TRUE, FILL_SPEC::X, FILL_SPEC::YEnd, and FILL_SPEC::YStart.
Referenced by AddProtoToClassPruner().
01155 { 01156 register int X, Y, Angle; 01157 register UINT32 OldWord; 01158 01159 X = FillSpec->X; 01160 if (X < 0) 01161 X = 0; 01162 if (X >= NUM_CP_BUCKETS) 01163 X = NUM_CP_BUCKETS - 1; 01164 01165 if (FillSpec->YStart < 0) 01166 FillSpec->YStart = 0; 01167 if (FillSpec->YEnd >= NUM_CP_BUCKETS) 01168 FillSpec->YEnd = NUM_CP_BUCKETS - 1; 01169 01170 for (Y = FillSpec->YStart; Y <= FillSpec->YEnd; Y++) 01171 for (Angle = FillSpec->AngleStart; 01172 TRUE; CircularIncrement (Angle, NUM_CP_BUCKETS)) { 01173 OldWord = Pruner[X][Y][Angle][WordIndex]; 01174 if (ClassCount > (OldWord & ClassMask)) { 01175 OldWord &= ~ClassMask; 01176 OldWord |= ClassCount; 01177 Pruner[X][Y][Angle][WordIndex] = OldWord; 01178 } 01179 if (Angle == FillSpec->AngleEnd) 01180 break; 01181 } 01182 } /* DoFill */
BOOL8 FillerDone | ( | TABLE_FILLER * | Filler | ) |
Determines if specified table filler is done; if it has no more lines to fill.
Filler | Table filler to check if done |
Definition at line 1195 of file intproto.cpp.
References FALSE, LastSwitch, TABLE_FILLER::NextSwitch, TABLE_FILLER::Switch, TRUE, FILL_SWITCH::Type, FILL_SWITCH::X, and TABLE_FILLER::X.
Referenced by AddProtoToClassPruner().
01195 { 01196 FILL_SWITCH *Next; 01197 01198 Next = &(Filler->Switch[Filler->NextSwitch]); 01199 01200 if (Filler->X > Next->X && Next->Type == LastSwitch) 01201 return (TRUE); 01202 else 01203 return (FALSE); 01204 01205 } /* FillerDone */
void FillPPCircularBits | ( | UINT32 | ParamTable[NUM_PP_BUCKETS][WERDS_PER_PP_VECTOR], | |
int | Bit, | |||
FLOAT32 | Center, | |||
FLOAT32 | Spread | |||
) |
Sets Bit in each bit vector whose bucket lies within the range Center +- Spread.
ParamTable | Table of bit vectors, one per param bucket | |
Bit | Bit position in vectors to be filled | |
Center | Center of filled area | |
Spread | Spread of filled area |
Definition at line 1227 of file intproto.cpp.
References CircularIncrement, cprintf(), LearningDebugLevel, NUM_PP_BUCKETS, SET_BIT, and TRUE.
Referenced by AddProtoToProtoPruner().
01228 { 01229 int i, FirstBucket, LastBucket; 01230 01231 if (Spread > 0.5) 01232 Spread = 0.5; 01233 01234 FirstBucket = (int) floor ((Center - Spread) * NUM_PP_BUCKETS); 01235 if (FirstBucket < 0) 01236 FirstBucket += NUM_PP_BUCKETS; 01237 01238 LastBucket = (int) floor ((Center + Spread) * NUM_PP_BUCKETS); 01239 if (LastBucket >= NUM_PP_BUCKETS) 01240 LastBucket -= NUM_PP_BUCKETS; 01241 if (LearningDebugLevel >= 2) 01242 cprintf ("Circular fill from %d to %d", FirstBucket, LastBucket); 01243 for (i = FirstBucket; TRUE; CircularIncrement (i, NUM_PP_BUCKETS)) { 01244 SET_BIT (ParamTable[i], Bit); 01245 01246 /* exit loop after we have set the bit for the last bucket */ 01247 if (i == LastBucket) 01248 break; 01249 } 01250 01251 } /* FillPPCircularBits */
void FillPPLinearBits | ( | UINT32 | ParamTable[NUM_PP_BUCKETS][WERDS_PER_PP_VECTOR], | |
int | Bit, | |||
FLOAT32 | Center, | |||
FLOAT32 | Spread | |||
) |
Sets Bit in each bit vector whose bucket lies within the range Center +- Spread.
ParamTable | Table of bit vectors, one per param bucket | |
Bit | Bit number being filled | |
Center | Center of filled area | |
Spread | Spread of filled area |
Definition at line 1274 of file intproto.cpp.
References cprintf(), LearningDebugLevel, NUM_PP_BUCKETS, and SET_BIT.
Referenced by AddProtoToProtoPruner().
01275 { 01276 int i, FirstBucket, LastBucket; 01277 01278 FirstBucket = (int) floor ((Center - Spread) * NUM_PP_BUCKETS); 01279 if (FirstBucket < 0) 01280 FirstBucket = 0; 01281 01282 LastBucket = (int) floor ((Center + Spread) * NUM_PP_BUCKETS); 01283 if (LastBucket >= NUM_PP_BUCKETS) 01284 LastBucket = NUM_PP_BUCKETS - 1; 01285 01286 if (LearningDebugLevel >= 2) 01287 cprintf ("Linear fill from %d to %d", FirstBucket, LastBucket); 01288 for (i = FirstBucket; i <= LastBucket; i++) 01289 SET_BIT (ParamTable[i], Bit); 01290 01291 } /* FillPPLinearBits */
void free_int_class | ( | INT_CLASS | int_class | ) |
Frees a class.
Definition at line 802 of file intproto.cpp.
References Efree(), NumProtoSetsIn, and ProtoSetIn.
Referenced by free_int_templates().
00803 { /*class to free */ 00804 int i; 00805 00806 for (i = 0; i < NumProtoSetsIn (int_class); i++) { 00807 Efree (ProtoSetIn (int_class, i)); 00808 } 00809 Efree (int_class->ProtoLengths); 00810 Efree(int_class); 00811 }
void free_int_templates | ( | INT_TEMPLATES | templates | ) |
Frees the template.
Definition at line 846 of file intproto.cpp.
References ClassForIndex, Efree(), free_int_class(), NumClassesIn, and NumClassPrunersIn.
Referenced by EndAdaptiveClassifier(), and free_adapted_templates().
00846 { 00847 int i; 00848 00849 for (i = 0; i < NumClassesIn (templates); i++) 00850 free_int_class (ClassForIndex (templates, i)); 00851 for (i = 0; i < NumClassPrunersIn (templates); i++) 00852 Efree (templates->ClassPruner[i]); 00853 Efree(templates); 00854 }
CLASS_ID GetClassToDebug | ( | const char * | Prompt | ) |
Prompts the user with Prompt and waits for the user to enter something in the debug window.
Prompt | prompt to print while waiting for input from window |
Definition at line 1305 of file intproto.cpp.
References IntMatchWindow, and window_wait().
Referenced by AdaptToChar(), and DebugAdaptiveClassifier().
01305 { 01306 return window_wait (IntMatchWindow); 01307 01308 } /* GetClassToDebug */
Copies the appropriate global pad variables into EndPad, SidePad, and AnglePad.
Level | The "tightness" level to return pads for | |
EndPad | Place to put end pad for Level | |
SidePad | Place to put side pad for Level | |
AnglePad | Place to put angle pad for Level |
Definition at line 1328 of file intproto.cpp.
References GetPicoFeatureLength.
Referenced by AddProtoToClassPruner().
01331 { 01332 switch (Level) { 01333 case 0: 01334 *EndPad = CPEndPadLoose * GetPicoFeatureLength (); 01335 *SidePad = CPSidePadLoose * GetPicoFeatureLength (); 01336 *AnglePad = CPAnglePadLoose / 360.0; 01337 break; 01338 01339 case 1: 01340 *EndPad = CPEndPadMedium * GetPicoFeatureLength (); 01341 *SidePad = CPSidePadMedium * GetPicoFeatureLength (); 01342 *AnglePad = CPAnglePadMedium / 360.0; 01343 break; 01344 01345 case 2: 01346 *EndPad = CPEndPadTight * GetPicoFeatureLength (); 01347 *SidePad = CPSidePadTight * GetPicoFeatureLength (); 01348 *AnglePad = CPAnglePadTight / 360.0; 01349 break; 01350 01351 default: 01352 *EndPad = CPEndPadTight * GetPicoFeatureLength (); 01353 *SidePad = CPSidePadTight * GetPicoFeatureLength (); 01354 *AnglePad = CPAnglePadTight / 360.0; 01355 break; 01356 } 01357 if (*AnglePad > 0.5) 01358 *AnglePad = 0.5; 01359 01360 } /* GetCPPadsForLevel */
Returns color depending on evidence; different confidence is shown with a different color.
Evidence | Evidence value to return color for |
Definition at line 1373 of file intproto.cpp.
References assert(), Blue, Green, Red, and White.
Referenced by DisplayIntFeature(), and DisplayIntProto().
01373 { 01374 assert (Evidence >= 0.0); 01375 assert (Evidence <= 1.0); 01376 01377 if (Evidence >= 0.90) 01378 return White; 01379 else if (Evidence >= 0.75) 01380 return Green; 01381 else if (Evidence >= 0.50) 01382 return Red; 01383 else 01384 return Blue; 01385 } /* GetMatchColorFor */
void GetNextFill | ( | TABLE_FILLER * | Filler, | |
FILL_SPEC * | Fill | |||
) |
Returns (in Fill) the specification of the next line to be filled from Filler.
Filler | Filler to get next fill spec from | |
Fill | Place to put spec for next fill |
Definition at line 1402 of file intproto.cpp.
References TABLE_FILLER::AngleEnd, FILL_SPEC::AngleEnd, TABLE_FILLER::AngleStart, FILL_SPEC::AngleStart, FILL_SWITCH::Delta, TABLE_FILLER::EndDelta, EndSwitch, TABLE_FILLER::NextSwitch, TABLE_FILLER::StartDelta, StartSwitch, TABLE_FILLER::Switch, FILL_SWITCH::Type, FILL_SWITCH::X, TABLE_FILLER::X, FILL_SPEC::X, FILL_SWITCH::Y, TABLE_FILLER::YEnd, FILL_SPEC::YEnd, FILL_SWITCH::YInit, TABLE_FILLER::YStart, and FILL_SPEC::YStart.
Referenced by AddProtoToClassPruner().
01402 { 01403 FILL_SWITCH *Next; 01404 01405 /* compute the fill assuming no switches will be encountered */ 01406 Fill->AngleStart = Filler->AngleStart; 01407 Fill->AngleEnd = Filler->AngleEnd; 01408 Fill->X = Filler->X; 01409 Fill->YStart = Filler->YStart >> 8; 01410 Fill->YEnd = Filler->YEnd >> 8; 01411 01412 /* update the fill info and the filler for ALL switches at this X value */ 01413 Next = &(Filler->Switch[Filler->NextSwitch]); 01414 while (Filler->X >= Next->X) { 01415 Fill->X = Filler->X = Next->X; 01416 if (Next->Type == StartSwitch) { 01417 Fill->YStart = Next->Y; 01418 Filler->StartDelta = Next->Delta; 01419 Filler->YStart = Next->YInit; 01420 } 01421 else if (Next->Type == EndSwitch) { 01422 Fill->YEnd = Next->Y; 01423 Filler->EndDelta = Next->Delta; 01424 Filler->YEnd = Next->YInit; 01425 } 01426 else { /* Type must be LastSwitch */ 01427 break; 01428 } 01429 Filler->NextSwitch++; 01430 Next = &(Filler->Switch[Filler->NextSwitch]); 01431 } 01432 01433 /* prepare the filler for the next call to this routine */ 01434 Filler->X++; 01435 Filler->YStart += Filler->StartDelta; 01436 Filler->YEnd += Filler->EndDelta; 01437 01438 } /* GetNextFill */
void InitIntProtoVars | ( | ) |
Initialize the control variables for the integer proto routines.
none |
Definition at line 733 of file intproto.cpp.
Referenced by init_dj_debug().
00733 { 00734 MakeNumCPLevels(); 00735 MakeCPAnglePadLoose(); 00736 MakeCPAnglePadMedium(); 00737 MakeCPAnglePadTight(); 00738 MakeCPEndPadLoose(); 00739 MakeCPEndPadMedium(); 00740 MakeCPEndPadTight(); 00741 MakeCPSidePadLoose(); 00742 MakeCPSidePadMedium(); 00743 MakeCPSidePadTight(); 00744 MakePPAnglePad(); 00745 MakePPEndPad(); 00746 MakePPSidePad(); 00747 } /* InitIntProtoVars */
void InitTableFiller | ( | FLOAT32 | EndPad, | |
FLOAT32 | SidePad, | |||
FLOAT32 | AnglePad, | |||
PROTO | Proto, | |||
TABLE_FILLER * | Filler | |||
) |
Computes a data structure (Filler) which can be used to fill in a rectangle surrounding the specified Proto.
EndPad | Padding to add to proto | |
SidePad | Padding to add to proto | |
AnglePad | Padding to add to proto | |
Proto | Proto to create a filler for | |
Filler | Place to put table filler |
Definition at line 1460 of file intproto.cpp.
References TABLE_FILLER::AngleEnd, TABLE_FILLER::AngleStart, AS, BucketEnd(), BucketFor(), BucketStart(), CircBucketFor(), FILL_SWITCH::Delta, TABLE_FILLER::EndDelta, EndSwitch, HV_TOLERANCE, LastSwitch, MapParam, NB, TABLE_FILLER::NextSwitch, PI, ProtoAngle, ProtoLength, ProtoX, ProtoY, TABLE_FILLER::StartDelta, StartSwitch, TABLE_FILLER::Switch, FILL_SWITCH::Type, FPOINT::x, FILL_SWITCH::X, TABLE_FILLER::X, XS, FILL_SWITCH::Y, FPOINT::y, TABLE_FILLER::YEnd, FILL_SWITCH::YInit, YS, and TABLE_FILLER::YStart.
Referenced by AddProtoToClassPruner().
01467 { 01468 FLOAT32 Angle; 01469 FLOAT32 X, Y, HalfLength; 01470 FLOAT32 Cos, Sin; 01471 FLOAT32 XAdjust, YAdjust; 01472 FPOINT Start, Switch1, Switch2, End; 01473 int S1 = 0; 01474 int S2 = 1; 01475 01476 Angle = ProtoAngle (Proto); 01477 X = ProtoX (Proto); 01478 Y = ProtoY (Proto); 01479 HalfLength = ProtoLength (Proto) / 2.0; 01480 01481 Filler->AngleStart = CircBucketFor (Angle - AnglePad, AS, NB); 01482 Filler->AngleEnd = CircBucketFor (Angle + AnglePad, AS, NB); 01483 Filler->NextSwitch = 0; 01484 01485 if (fabs (Angle - 0.0) < HV_TOLERANCE || fabs (Angle - 0.5) < HV_TOLERANCE) { 01486 /* horizontal proto - handle as special case */ 01487 Filler->X = BucketFor (X - HalfLength - EndPad, XS, NB); 01488 Filler->YStart = BucketFor (Y - SidePad, YS, NB * 256); 01489 Filler->YEnd = BucketFor (Y + SidePad, YS, NB * 256); 01490 Filler->StartDelta = 0; 01491 Filler->EndDelta = 0; 01492 Filler->Switch[0].Type = LastSwitch; 01493 Filler->Switch[0].X = BucketFor (X + HalfLength + EndPad, XS, NB); 01494 } 01495 else if (fabs (Angle - 0.25) < HV_TOLERANCE || 01496 fabs (Angle - 0.75) < HV_TOLERANCE) { 01497 /* vertical proto - handle as special case */ 01498 Filler->X = BucketFor (X - SidePad, XS, NB); 01499 Filler->YStart = BucketFor (Y - HalfLength - EndPad, YS, NB * 256); 01500 Filler->YEnd = BucketFor (Y + HalfLength + EndPad, YS, NB * 256); 01501 Filler->StartDelta = 0; 01502 Filler->EndDelta = 0; 01503 Filler->Switch[0].Type = LastSwitch; 01504 Filler->Switch[0].X = BucketFor (X + SidePad, XS, NB); 01505 } 01506 else { 01507 /* diagonal proto */ 01508 01509 if (Angle > 0.0 && Angle < 0.25 || Angle > 0.5 && Angle < 0.75) { 01510 /* rising diagonal proto */ 01511 Angle *= 2.0 * PI; 01512 Cos = fabs (cos (Angle)); 01513 Sin = fabs (sin (Angle)); 01514 01515 /* compute the positions of the corners of the acceptance region */ 01516 Start.x = X - (HalfLength + EndPad) * Cos - SidePad * Sin; 01517 Start.y = Y - (HalfLength + EndPad) * Sin + SidePad * Cos; 01518 End.x = 2.0 * X - Start.x; 01519 End.y = 2.0 * Y - Start.y; 01520 Switch1.x = X - (HalfLength + EndPad) * Cos + SidePad * Sin; 01521 Switch1.y = Y - (HalfLength + EndPad) * Sin - SidePad * Cos; 01522 Switch2.x = 2.0 * X - Switch1.x; 01523 Switch2.y = 2.0 * Y - Switch1.y; 01524 01525 if (Switch1.x > Switch2.x) { 01526 S1 = 1; 01527 S2 = 0; 01528 } 01529 01530 /* translate into bucket positions and deltas */ 01531 Filler->X = (INT8) MapParam (Start.x, XS, NB); 01532 Filler->StartDelta = -(INT16) ((Cos / Sin) * 256); 01533 Filler->EndDelta = (INT16) ((Sin / Cos) * 256); 01534 01535 XAdjust = BucketEnd (Filler->X, XS, NB) - Start.x; 01536 YAdjust = XAdjust * Cos / Sin; 01537 Filler->YStart = (INT16) MapParam (Start.y - YAdjust, YS, NB * 256); 01538 YAdjust = XAdjust * Sin / Cos; 01539 Filler->YEnd = (INT16) MapParam (Start.y + YAdjust, YS, NB * 256); 01540 01541 Filler->Switch[S1].Type = StartSwitch; 01542 Filler->Switch[S1].X = (INT8) MapParam (Switch1.x, XS, NB); 01543 Filler->Switch[S1].Y = (INT8) MapParam (Switch1.y, YS, NB); 01544 XAdjust = Switch1.x - BucketStart (Filler->Switch[S1].X, XS, NB); 01545 YAdjust = XAdjust * Sin / Cos; 01546 Filler->Switch[S1].YInit = 01547 (INT16) MapParam (Switch1.y - YAdjust, YS, NB * 256); 01548 Filler->Switch[S1].Delta = Filler->EndDelta; 01549 01550 Filler->Switch[S2].Type = EndSwitch; 01551 Filler->Switch[S2].X = (INT8) MapParam (Switch2.x, XS, NB); 01552 Filler->Switch[S2].Y = (INT8) MapParam (Switch2.y, YS, NB); 01553 XAdjust = Switch2.x - BucketStart (Filler->Switch[S2].X, XS, NB); 01554 YAdjust = XAdjust * Cos / Sin; 01555 Filler->Switch[S2].YInit = 01556 (INT16) MapParam (Switch2.y + YAdjust, YS, NB * 256); 01557 Filler->Switch[S2].Delta = Filler->StartDelta; 01558 01559 Filler->Switch[2].Type = LastSwitch; 01560 Filler->Switch[2].X = (INT8) MapParam (End.x, XS, NB); 01561 } 01562 else { 01563 /* falling diagonal proto */ 01564 Angle *= 2.0 * PI; 01565 Cos = fabs (cos (Angle)); 01566 Sin = fabs (sin (Angle)); 01567 01568 /* compute the positions of the corners of the acceptance region */ 01569 Start.x = X - (HalfLength + EndPad) * Cos - SidePad * Sin; 01570 Start.y = Y + (HalfLength + EndPad) * Sin - SidePad * Cos; 01571 End.x = 2.0 * X - Start.x; 01572 End.y = 2.0 * Y - Start.y; 01573 Switch1.x = X - (HalfLength + EndPad) * Cos + SidePad * Sin; 01574 Switch1.y = Y + (HalfLength + EndPad) * Sin + SidePad * Cos; 01575 Switch2.x = 2.0 * X - Switch1.x; 01576 Switch2.y = 2.0 * Y - Switch1.y; 01577 01578 if (Switch1.x > Switch2.x) { 01579 S1 = 1; 01580 S2 = 0; 01581 } 01582 01583 /* translate into bucket positions and deltas */ 01584 Filler->X = (INT8) MapParam (Start.x, XS, NB); 01585 Filler->StartDelta = -(INT16) ((Sin / Cos) * 256); 01586 Filler->EndDelta = (INT16) ((Cos / Sin) * 256); 01587 01588 XAdjust = BucketEnd (Filler->X, XS, NB) - Start.x; 01589 YAdjust = XAdjust * Sin / Cos; 01590 Filler->YStart = (INT16) MapParam (Start.y - YAdjust, YS, NB * 256); 01591 YAdjust = XAdjust * Cos / Sin; 01592 Filler->YEnd = (INT16) MapParam (Start.y + YAdjust, YS, NB * 256); 01593 01594 Filler->Switch[S1].Type = EndSwitch; 01595 Filler->Switch[S1].X = (INT8) MapParam (Switch1.x, XS, NB); 01596 Filler->Switch[S1].Y = (INT8) MapParam (Switch1.y, YS, NB); 01597 XAdjust = Switch1.x - BucketStart (Filler->Switch[S1].X, XS, NB); 01598 YAdjust = XAdjust * Sin / Cos; 01599 Filler->Switch[S1].YInit = 01600 (INT16) MapParam (Switch1.y + YAdjust, YS, NB * 256); 01601 Filler->Switch[S1].Delta = Filler->StartDelta; 01602 01603 Filler->Switch[S2].Type = StartSwitch; 01604 Filler->Switch[S2].X = (INT8) MapParam (Switch2.x, XS, NB); 01605 Filler->Switch[S2].Y = (INT8) MapParam (Switch2.y, YS, NB); 01606 XAdjust = Switch2.x - BucketStart (Filler->Switch[S2].X, XS, NB); 01607 YAdjust = XAdjust * Cos / Sin; 01608 Filler->Switch[S2].YInit = 01609 (INT16) MapParam (Switch2.y - YAdjust, YS, NB * 256); 01610 Filler->Switch[S2].Delta = Filler->EndDelta; 01611 01612 Filler->Switch[2].Type = LastSwitch; 01613 Filler->Switch[2].X = (INT8) MapParam (End.x, XS, NB); 01614 } 01615 } 01616 } /* InitTableFiller */
INT_CLASS NewIntClass | ( | int | MaxNumProtos, | |
int | MaxNumConfigs | |||
) |
Creates a new integer class data structure and returns it.
MaxNumProtos | Number of protos to allocate space for | |
MaxNumConfigs | Number of configs to allocate space for |
Definition at line 763 of file intproto.cpp.
References assert(), Emalloc(), MAX_NUM_CONFIGS, MAX_NUM_PROTO_SETS, MaxNumIntProtosIn, NumIntConfigsIn, NumIntProtosIn, NumProtoSetsIn, ProtoPrunerFor, PROTOS_PER_PROTO_SET, ProtoSetIn, and WERDS_PER_PP.
Referenced by AddAdaptedClass(), and CreateIntTemplates().
00763 { 00764 INT_CLASS Class; 00765 PROTO_SET ProtoSet; 00766 int i; 00767 register UINT32 *Word; 00768 00769 assert (MaxNumConfigs <= MAX_NUM_CONFIGS); 00770 00771 Class = (INT_CLASS) Emalloc (sizeof (INT_CLASS_STRUCT)); 00772 NumProtoSetsIn (Class) = ((MaxNumProtos + PROTOS_PER_PROTO_SET - 1) / 00773 PROTOS_PER_PROTO_SET); 00774 00775 assert (NumProtoSetsIn (Class) <= MAX_NUM_PROTO_SETS); 00776 00777 NumIntProtosIn (Class) = 0; 00778 NumIntConfigsIn (Class) = 0; 00779 00780 for (i = 0; i < NumProtoSetsIn (Class); i++) { 00781 /* allocate space for a proto set, install in class, and initialize */ 00782 ProtoSet = (PROTO_SET) Emalloc (sizeof (PROTO_SET_STRUCT)); 00783 ProtoSetIn (Class, i) = ProtoSet; 00784 for (Word = (UINT32 *) (ProtoPrunerFor (ProtoSet)); 00785 Word < (UINT32 *) (ProtoPrunerFor (ProtoSet)) + WERDS_PER_PP; 00786 *Word++ = 0); 00787 00788 /* allocate space for the proto lengths and install in class */ 00789 } 00790 Class->ProtoLengths = (UINT8 *) Emalloc (MaxNumIntProtosIn (Class) * 00791 sizeof (UINT8)); 00792 00793 return (Class); 00794 00795 } /* NewIntClass */
INT_TEMPLATES NewIntTemplates | ( | ) |
Allocates a new set of integer templates initialized to hold 0 classes.
none |
Definition at line 823 of file intproto.cpp.
References ClassIdForIndex, Emalloc(), ILLEGAL_CLASS, IndexForClassId, MAX_CLASS_ID, MAX_NUM_CLASSES, NO_CLASS, NumClassesIn, and NumClassPrunersIn.
Referenced by CreateIntTemplates(), NewAdaptedTemplates(), and ReadIntTemplates().
00823 { 00824 INT_TEMPLATES T; 00825 int i; 00826 00827 T = (INT_TEMPLATES) Emalloc (sizeof (INT_TEMPLATES_STRUCT)); 00828 NumClassesIn (T) = 0; 00829 NumClassPrunersIn (T) = 0; 00830 00831 /* initialize mapping tables */ 00832 for (i = 0; i <= MAX_CLASS_ID; i++) 00833 IndexForClassId (T, i) = ILLEGAL_CLASS; 00834 for (i = 0; i < MAX_NUM_CLASSES; i++) 00835 ClassIdForIndex (T, i) = NO_CLASS; 00836 00837 return (T); 00838 00839 } /* NewIntTemplates */
INT_TEMPLATES ReadIntTemplates | ( | FILE * | File, | |
BOOL8 | swap | |||
) |
Reads a set of integer templates from File.
File | Open file to read templates from | |
swap | 0 or 1, if need to call reverse32 |
Definition at line 870 of file intproto.cpp.
References ClassForIndex, cprintf(), Emalloc(), MAX_CLASS_ID, MAX_NUM_CLASS_PRUNERS, MAX_NUM_CLASSES, MAX_NUM_CONFIGS, MAX_NUM_PROTO_SETS, MaxNumIntProtosIn, NewIntTemplates(), NUM_CP_BUCKETS, NUM_PP_BUCKETS, NUM_PP_PARAMS, NumClassesIn, NumClassPrunersIn, NumProtoSetsIn, PROTOS_PER_PROTO_SET, ProtoSetIn, reverse16(), reverse32(), WERDS_PER_CONFIG_VEC, WERDS_PER_CP_VECTOR, and WERDS_PER_PP_VECTOR.
Referenced by InitAdaptiveClassifier(), and ReadAdaptedTemplates().
00870 { 00871 int i, j, x, y, z; 00872 int nread; 00873 INT_TEMPLATES Templates; 00874 CLASS_PRUNER Pruner; 00875 INT_CLASS Class; 00876 UINT8 *Lengths; 00877 PROTO_SET ProtoSet; 00878 00879 /* first read the high level template struct */ 00880 Templates = NewIntTemplates (); 00881 // Read Templates in parts for 64 bit compatibility. 00882 if (fread(&Templates->NumClasses, sizeof(int), 1, File) != 1 || 00883 fread(&Templates->NumClassPruners, sizeof(int), 1, File) != 1) 00884 cprintf ("Bad read of inttemp!\n"); 00885 for (i = 0; i <= MAX_CLASS_ID; ++i) { 00886 if (fread(&Templates->IndexFor[i], sizeof(CLASS_INDEX), 1, File) != 1) 00887 cprintf("Bad read of inttemp!\n"); 00888 } 00889 for (i = 0; i < MAX_NUM_CLASSES; ++i) { 00890 if (fread(&Templates->ClassIdFor[i], sizeof(CLASS_ID), 1, File) != 1) 00891 cprintf("Bad read of inttemp!\n"); 00892 } 00893 for (i = 0; i < MAX_NUM_CLASSES + MAX_NUM_CLASS_PRUNERS; ++i) { 00894 int junk; 00895 if (fread(&junk, sizeof(junk), 1, File) != 1) 00896 cprintf("Bad read of inttemp!\n"); 00897 } 00898 // Swap status is determined automatically. 00899 swap = Templates->NumClassPruners < 0 || 00900 Templates->NumClassPruners > MAX_NUM_CLASS_PRUNERS; 00901 if (swap) { 00902 reverse32 (&Templates->NumClassPruners); 00903 reverse32 (&Templates->NumClasses); 00904 for (i = 0; i < MAX_CLASS_ID + 1; i++) 00905 reverse16 (&Templates->IndexFor[i]); 00906 } 00907 00908 /* then read in the class pruners */ 00909 for (i = 0; i < NumClassPrunersIn (Templates); i++) { 00910 Pruner = (CLASS_PRUNER) Emalloc (sizeof (CLASS_PRUNER_STRUCT)); 00911 if ((nread = 00912 fread ((char *) Pruner, 1, sizeof (CLASS_PRUNER_STRUCT), 00913 File)) != sizeof (CLASS_PRUNER_STRUCT)) 00914 cprintf ("Bad read of inttemp!\n"); 00915 if (swap) { 00916 for (j = 0; j < NUM_CP_BUCKETS; j++) { 00917 for (x = 0; x < NUM_CP_BUCKETS; x++) { 00918 for (y = 0; y < NUM_CP_BUCKETS; y++) { 00919 for (z = 0; z < WERDS_PER_CP_VECTOR; z++) { 00920 reverse32 (&Pruner[j][x][y][z]); 00921 } 00922 } 00923 } 00924 } 00925 } 00926 Templates->ClassPruner[i] = Pruner; 00927 } 00928 00929 /* then read in each class */ 00930 for (i = 0; i < NumClassesIn (Templates); i++) { 00931 /* first read in the high level struct for the class */ 00932 Class = (INT_CLASS) Emalloc (sizeof (INT_CLASS_STRUCT)); 00933 if (fread(&Class->NumProtos, sizeof(Class->NumProtos), 1, File) != 1 || 00934 fread(&Class->NumProtoSets, sizeof(Class->NumProtoSets), 1, File) != 1 || 00935 fread(&Class->NumConfigs, sizeof(Class->NumConfigs), 1, File) != 1) 00936 cprintf ("Bad read of inttemp!\n"); 00937 for (j = 0; j <= MAX_NUM_PROTO_SETS; ++j) { 00938 int junk; 00939 if (fread(&junk, sizeof(junk), 1, File) != 1) 00940 cprintf ("Bad read of inttemp!\n"); 00941 } 00942 for (j = 0; j < MAX_NUM_CONFIGS; ++j) { 00943 if (fread(&Class->ConfigLengths[j], sizeof(UINT16), 1, File) != 1) 00944 cprintf ("Bad read of inttemp!\n"); 00945 } 00946 if (swap) { 00947 reverse16 (&Class->NumProtos); 00948 for (j = 0; j < MAX_NUM_CONFIGS; j++) 00949 reverse16 (&Class->ConfigLengths[j]); 00950 } 00951 ClassForIndex (Templates, i) = Class; 00952 00953 /* then read in the proto lengths */ 00954 Lengths = (UINT8 *) Emalloc (sizeof (UINT8) * 00955 MaxNumIntProtosIn (Class)); 00956 if ((nread = fread ((char *) Lengths, sizeof (UINT8), 00957 MaxNumIntProtosIn (Class), 00958 File)) != MaxNumIntProtosIn (Class)) 00959 cprintf ("Bad read of inttemp!\n"); 00960 Class->ProtoLengths = Lengths; 00961 00962 /* then read in the proto sets */ 00963 for (j = 0; j < NumProtoSetsIn (Class); j++) { 00964 ProtoSet = (PROTO_SET) Emalloc (sizeof (PROTO_SET_STRUCT)); 00965 if ((nread = 00966 fread ((char *) ProtoSet, 1, sizeof (PROTO_SET_STRUCT), 00967 File)) != sizeof (PROTO_SET_STRUCT)) 00968 cprintf ("Bad read of inttemp!\n"); 00969 if (swap) { 00970 for (x = 0; x < NUM_PP_PARAMS; x++) 00971 for (y = 0; y < NUM_PP_BUCKETS; y++) 00972 for (z = 0; z < WERDS_PER_PP_VECTOR; z++) 00973 reverse32 (&ProtoSet->ProtoPruner[x][y][z]); 00974 for (x = 0; x < PROTOS_PER_PROTO_SET; x++) 00975 for (y = 0; y < WERDS_PER_CONFIG_VEC; y++) 00976 reverse32 (&ProtoSet->Protos[x].Configs[y]); 00977 } 00978 ProtoSetIn (Class, j) = ProtoSet; 00979 } 00980 } 00981 return (Templates); 00982 } /* ReadIntTemplates */
void RenderIntFeature | ( | void * | window, | |
INT_FEATURE | Feature, | |||
C_COL | Color | |||
) |
Renders the specified feature into ShapeList.
window | Window handle | |
Feature | Feature to be rendered | |
Color | Color to use for feature rendering |
Definition at line 1631 of file intproto.cpp.
References assert(), c_draw(), c_line_color_index(), c_move(), DISPLAY_OFFSET, DOUBLE_OFFSET, GetPicoFeatureLength, INT_CHAR_NORM_RANGE, NULL, PI, INT_FEATURE_STRUCT::Theta, INT_FEATURE_STRUCT::X, and INT_FEATURE_STRUCT::Y.
Referenced by DisplayIntFeature().
01631 { 01632 FLOAT32 X, Y, Dx, Dy, Length; 01633 01634 c_line_color_index(window, Color); 01635 assert (Feature != NULL); 01636 assert (Color != 0); 01637 01638 X = Feature->X - DISPLAY_OFFSET; 01639 Y = Feature->Y - DISPLAY_OFFSET; 01640 Length = GetPicoFeatureLength () * 0.7 * INT_CHAR_NORM_RANGE; 01641 Dx = (Length / 2.0) * cos ((Feature->Theta / 256.0) * 2.0 * PI); 01642 Dy = (Length / 2.0) * sin ((Feature->Theta / 256.0) * 2.0 * PI); 01643 01644 c_move (window, X - Dx, Y - Dy); 01645 c_draw (window, X + Dx, Y + Dy); 01646 c_move (window, X - Dx - Dy * DOUBLE_OFFSET, Y - Dy + Dx * DOUBLE_OFFSET); 01647 c_draw (window, X + Dx - Dy * DOUBLE_OFFSET, Y + Dy + Dx * DOUBLE_OFFSET); 01648 } /* RenderIntFeature */
Extracts the parameters of the specified proto from the class description and adds a rendering of the proto onto the ShapeList.
window | Window handle | |
Class | Class that proto is contained in | |
ProtoId | Id of proto to be rendered | |
Color | Color to render proto in |
Definition at line 1665 of file intproto.cpp.
References assert(), c_draw(), c_line_color_index(), c_move(), DISPLAY_OFFSET, GetPicoFeatureLength, IndexForProto, INT_CHAR_NORM_RANGE, LengthForProtoId, NULL, NUM_PP_BUCKETS, NumIntProtosIn, PI, PPrunerMaskFor, PPrunerWordIndexFor, PROTO_PRUNER_SCALE, ProtoSetIn, PRUNER_X, PRUNER_Y, and SetForProto.
Referenced by DisplayIntProto().
01668 { 01669 PROTO_SET ProtoSet; 01670 INT_PROTO Proto; 01671 int ProtoSetIndex; 01672 int ProtoWordIndex; 01673 FLOAT32 Length; 01674 int Xmin, Xmax, Ymin, Ymax; 01675 FLOAT32 X, Y, Dx, Dy; 01676 UINT32 ProtoMask; 01677 int Bucket; 01678 01679 assert (ProtoId >= 0); 01680 assert (Class != NULL); 01681 assert (ProtoId < NumIntProtosIn (Class)); 01682 assert (Color != 0); 01683 c_line_color_index(window, Color); 01684 01685 ProtoSet = ProtoSetIn (Class, SetForProto (ProtoId)); 01686 ProtoSetIndex = IndexForProto (ProtoId); 01687 Proto = &(ProtoSet->Protos[ProtoSetIndex]); 01688 Length = (LengthForProtoId (Class, ProtoId) * 01689 GetPicoFeatureLength () * INT_CHAR_NORM_RANGE); 01690 ProtoMask = PPrunerMaskFor (ProtoId); 01691 ProtoWordIndex = PPrunerWordIndexFor (ProtoId); 01692 01693 // find the x and y extent of the proto from the proto pruning table 01694 Xmin = Ymin = NUM_PP_BUCKETS; 01695 Xmax = Ymax = 0; 01696 for (Bucket = 0; Bucket < NUM_PP_BUCKETS; Bucket++) { 01697 if (ProtoMask & ProtoSet->ProtoPruner[PRUNER_X][Bucket][ProtoWordIndex]) 01698 if (Bucket < Xmin) 01699 Xmin = Bucket; 01700 else if (Bucket > Xmax) 01701 Xmax = Bucket; 01702 01703 if (ProtoMask & ProtoSet->ProtoPruner[PRUNER_Y][Bucket][ProtoWordIndex]) 01704 if (Bucket < Ymin) 01705 Ymin = Bucket; 01706 else if (Bucket > Ymax) 01707 Ymax = Bucket; 01708 } 01709 X = (Xmin + Xmax + 1) / 2.0 * PROTO_PRUNER_SCALE - DISPLAY_OFFSET; 01710 Y = (Ymin + Ymax + 1) / 2.0 * PROTO_PRUNER_SCALE - DISPLAY_OFFSET; 01711 Dx = (Length / 2.0) * cos ((Proto->Angle / 256.0) * 2.0 * PI); 01712 Dy = (Length / 2.0) * sin ((Proto->Angle / 256.0) * 2.0 * PI); 01713 01714 c_move (window, X - Dx, Y - Dy); 01715 c_draw (window, X + Dx, Y + Dy); 01716 } /* RenderIntProto */
void ShowMatchDisplay | ( | ) |
Sends the shapes in the global display lists to the match debugger window.
none |
Definition at line 999 of file intproto.cpp.
References baseline, c_clear_window(), c_create_window(), c_draw(), c_line_color_index(), c_move(), Grey, INT_BASELINE, INT_CAPHEIGHT, INT_DESCENDER, INT_MAX_X, INT_MAX_Y, INT_MIN_X, INT_MIN_Y, INT_XCENTER, INT_XHEIGHT, INT_XRADIUS, INT_YCENTER, INT_YRADIUS, IntMatchWindow, NormMethod, and NULL.
Referenced by AdaptToChar(), and DebugAdaptiveClassifier().
00999 { 01000 void *window; 01001 /* Size of drawable */ 01002 if (IntMatchWindow == NULL) { 01003 IntMatchWindow = c_create_window ("IntMatchWindow", 50, 200, 01004 520, 520, 01005 -130.0, 130.0, -130.0, 130.0); 01006 } 01007 else 01008 c_clear_window(IntMatchWindow); 01009 01010 window = IntMatchWindow; 01011 c_line_color_index(window, Grey); 01012 /* Default size of drawing */ 01013 if (NormMethod == baseline) { 01014 c_move (window, -1000.0, INT_BASELINE); 01015 c_draw (window, 1000.0, INT_BASELINE); 01016 c_move (window, -1000.0, INT_DESCENDER); 01017 c_draw (window, 1000.0, INT_DESCENDER); 01018 c_move (window, -1000.0, INT_XHEIGHT); 01019 c_draw (window, 1000.0, INT_XHEIGHT); 01020 c_move (window, -1000.0, INT_CAPHEIGHT); 01021 c_draw (window, 1000.0, INT_CAPHEIGHT); 01022 c_move (window, INT_MIN_X, -1000.0); 01023 c_draw (window, INT_MIN_X, 1000.0); 01024 c_move (window, INT_MAX_X, -1000.0); 01025 c_draw (window, INT_MAX_X, 1000.0); 01026 } 01027 else { 01028 c_move (window, INT_XCENTER - INT_XRADIUS, INT_YCENTER - INT_YRADIUS); 01029 c_draw (window, INT_XCENTER + INT_XRADIUS, INT_YCENTER - INT_YRADIUS); 01030 c_move (window, INT_XCENTER - INT_XRADIUS, INT_YCENTER + INT_YRADIUS); 01031 c_draw (window, INT_XCENTER + INT_XRADIUS, INT_YCENTER + INT_YRADIUS); 01032 c_move (window, INT_XCENTER - INT_XRADIUS, INT_YCENTER - INT_YRADIUS); 01033 c_draw (window, INT_XCENTER - INT_XRADIUS, INT_YCENTER + INT_YRADIUS); 01034 c_move (window, INT_XCENTER + INT_XRADIUS, INT_YCENTER - INT_YRADIUS); 01035 c_draw (window, INT_XCENTER + INT_XRADIUS, INT_YCENTER + INT_YRADIUS); 01036 c_move(window, INT_MIN_X, INT_MIN_Y); 01037 c_draw(window, INT_MIN_X, INT_MAX_Y); 01038 c_move(window, INT_MIN_X, INT_MIN_Y); 01039 c_draw(window, INT_MAX_X, INT_MIN_Y); 01040 c_move(window, INT_MAX_X, INT_MAX_Y); 01041 c_draw(window, INT_MIN_X, INT_MAX_Y); 01042 c_move(window, INT_MAX_X, INT_MAX_Y); 01043 c_draw(window, INT_MAX_X, INT_MIN_Y); 01044 } 01045 } /* ShowMatchDisplay */
int TruncateParam | ( | FLOAT32 | Param, | |
int | Min, | |||
int | Max, | |||
char * | Id | |||
) |
Truncates Param to lie within the range of Min-Max inclusive.
Param | Parameter value to be truncated | |
Min | Parameter limits (inclusive) | |
Max | Parameter limits (inclusive) | |
Id | String id of parameter for error messages |
Definition at line 1734 of file intproto.cpp.
References cprintf().
Referenced by ConvertProto().
01734 { 01735 if (Param < Min) { 01736 if (Id) 01737 cprintf ("Warning: Param %s truncated from %f to %d!\n", 01738 Id, Param, Min); 01739 Param = Min; 01740 } 01741 else if (Param > Max) { 01742 if (Id) 01743 cprintf ("Warning: Param %s truncated from %f to %d!\n", 01744 Id, Param, Max); 01745 Param = Max; 01746 } 01747 return (int) floor (Param); 01748 01749 } /* TruncateParam */
void UpdateMatchDisplay | ( | ) |
Clears the global feature and proto display lists.
none |
Definition at line 555 of file intproto.cpp.
References c_make_current(), IntMatchWindow, and NULL.
Referenced by AdaptToChar(), and DebugAdaptiveClassifier().
00555 { 00556 if (IntMatchWindow != NULL) 00557 c_make_current(IntMatchWindow); 00558 } /* ClearMatchDisplay */
void WriteIntTemplates | ( | FILE * | File, | |
INT_TEMPLATES | Templates | |||
) |
Writes Templates to File.
File | Open file to write templates to | |
Templates | Templates to save into File |
Definition at line 1061 of file intproto.cpp.
References ClassForIndex, MaxNumIntProtosIn, NumClassesIn, NumClassPrunersIn, NumProtoSetsIn, and ProtoSetIn.
Referenced by WriteAdaptedTemplates().
01061 { 01062 int i, j; 01063 INT_CLASS Class; 01064 01065 /* first write the high level template struct */ 01066 fwrite ((char *) Templates, sizeof (INT_TEMPLATES_STRUCT), 1, File); 01067 01068 /* then write out the class pruners */ 01069 for (i = 0; i < NumClassPrunersIn (Templates); i++) 01070 fwrite ((char *) (Templates->ClassPruner[i]), 01071 sizeof (CLASS_PRUNER_STRUCT), 1, File); 01072 01073 /* then write out each class */ 01074 for (i = 0; i < NumClassesIn (Templates); i++) { 01075 Class = ClassForIndex (Templates, i); 01076 01077 /* first write out the high level struct for the class */ 01078 fwrite ((char *) Class, sizeof (INT_CLASS_STRUCT), 1, File); 01079 01080 /* then write out the proto lengths */ 01081 fwrite ((char *) (Class->ProtoLengths), sizeof (UINT8), 01082 MaxNumIntProtosIn (Class), File); 01083 01084 /* then write out the proto sets */ 01085 for (j = 0; j < NumProtoSetsIn (Class); j++) 01086 fwrite ((char *) ProtoSetIn (Class, j), 01087 sizeof (PROTO_SET_STRUCT), 1, File); 01088 } 01089 } /* WriteIntTemplates */
void* IntMatchWindow = NULL |
global display lists used to display proto and feature match information
Definition at line 273 of file intproto.cpp.
Referenced by DisplayIntFeature(), DisplayIntProto(), GetClassToDebug(), IMDisplayProtoDebugInfo(), ShowMatchDisplay(), and UpdateMatchDisplay().