#include <math.h>
#include <stdio.h>
#include <assert.h>
#include "classify.h"
#include "const.h"
#include "emalloc.h"
#include "fontinfo.h"
#include "genericvector.h"
#include "globals.h"
#include "helpers.h"
#include "intproto.h"
#include "mfoutline.h"
#include "ndminx.h"
#include "picofeat.h"
#include "shapetable.h"
#include "svmnode.h"

Classes
struct	FILL_SWITCH

struct	TABLE_FILLER

struct	FILL_SPEC

Namespaces
	tesseract

Macros
#define	PROTO_PRUNER_SCALE (4.0)

#define	INT_DESCENDER (0.0 * INT_CHAR_NORM_RANGE)

#define	INT_BASELINE (0.25 * INT_CHAR_NORM_RANGE)

#define	INT_XHEIGHT (0.75 * INT_CHAR_NORM_RANGE)

#define	INT_CAPHEIGHT (1.0 * INT_CHAR_NORM_RANGE)

#define	INT_XCENTER (0.5 * INT_CHAR_NORM_RANGE)

#define	INT_YCENTER (0.5 * INT_CHAR_NORM_RANGE)

#define	INT_XRADIUS (0.2 * INT_CHAR_NORM_RANGE)

#define	INT_YRADIUS (0.2 * INT_CHAR_NORM_RANGE)

#define	INT_MIN_X 0

#define	INT_MIN_Y 0

#define	INT_MAX_X INT_CHAR_NORM_RANGE

#define	INT_MAX_Y INT_CHAR_NORM_RANGE

#define	HV_TOLERANCE (0.0025) /* approx 0.9 degrees */

#define	MAX_NUM_SWITCHES 3

#define	OLD_MAX_NUM_CONFIGS 32

#define	OLD_WERDS_PER_CONFIG_VEC

#define	CircularIncrement(i, r) (((i) < (r) - 1)?((i)++):((i) = 0))

#define	MapParam(P, O, N) (floor (((P) + (O)) * (N)))

#define	MAX_LEVEL 2

#define	XS X_SHIFT

#define	YS Y_SHIFT

#define	AS ANGLE_SHIFT

#define	NB NUM_CP_BUCKETS

Enumerations
enum	SWITCH_TYPE { StartSwitch, EndSwitch, LastSwitch }

Functions
FLOAT32	BucketStart (int Bucket, FLOAT32 Offset, int NumBuckets)

FLOAT32	BucketEnd (int Bucket, FLOAT32 Offset, int NumBuckets)

void	DoFill (FILL_SPEC FillSpec, CLASS_PRUNER_STRUCT Pruner, register uinT32 ClassMask, register uinT32 ClassCount, register uinT32 WordIndex)

BOOL8	FillerDone (TABLE_FILLER *Filler)

void	FillPPCircularBits (uinT32 ParamTable[NUM_PP_BUCKETS][WERDS_PER_PP_VECTOR], int Bit, FLOAT32 Center, FLOAT32 Spread, bool debug)

void	FillPPLinearBits (uinT32 ParamTable[NUM_PP_BUCKETS][WERDS_PER_PP_VECTOR], int Bit, FLOAT32 Center, FLOAT32 Spread, bool debug)

void	GetCPPadsForLevel (int Level, FLOAT32 EndPad, FLOAT32 SidePad, FLOAT32 *AnglePad)

ScrollView::Color	GetMatchColorFor (FLOAT32 Evidence)

void	GetNextFill (TABLE_FILLER Filler, FILL_SPEC Fill)

void	InitTableFiller (FLOAT32 EndPad, FLOAT32 SidePad, FLOAT32 AnglePad, PROTO Proto, TABLE_FILLER *Filler)

void	RenderIntFeature (ScrollView window, const INT_FEATURE_STRUCT Feature, ScrollView::Color color)

void	RenderIntProto (ScrollView *window, INT_CLASS Class, PROTO_ID ProtoId, ScrollView::Color color)

int	TruncateParam (FLOAT32 Param, int Min, int Max, char *Id)

void	AddIntClass (INT_TEMPLATES Templates, CLASS_ID ClassId, INT_CLASS Class)

int	AddIntConfig (INT_CLASS Class)

int	AddIntProto (INT_CLASS Class)

void	AddProtoToClassPruner (PROTO Proto, CLASS_ID ClassId, INT_TEMPLATES Templates)

void	AddProtoToProtoPruner (PROTO Proto, int ProtoId, INT_CLASS Class, bool debug)

int	BucketFor (FLOAT32 Param, FLOAT32 Offset, int NumBuckets)

int	CircBucketFor (FLOAT32 Param, FLOAT32 Offset, int NumBuckets)

void	UpdateMatchDisplay ()

void	ConvertConfig (BIT_VECTOR Config, int ConfigId, INT_CLASS Class)

void	DisplayIntFeature (const INT_FEATURE_STRUCT *Feature, FLOAT32 Evidence)

void	DisplayIntProto (INT_CLASS Class, PROTO_ID ProtoId, FLOAT32 Evidence)

INT_CLASS	NewIntClass (int MaxNumProtos, int MaxNumConfigs)

void	free_int_class (INT_CLASS int_class)

INT_TEMPLATES	NewIntTemplates ()

void	free_int_templates (INT_TEMPLATES templates)

void	tesseract::ClearFeatureSpaceWindow (NORM_METHOD norm_method, ScrollView *window)

void	InitIntMatchWindowIfReqd ()

void	InitProtoDisplayWindowIfReqd ()

void	InitFeatureDisplayWindowIfReqd ()

ScrollView *	CreateFeatureSpaceWindow (const char *name, int xpos, int ypos)

Variables
ScrollView *	IntMatchWindow = NULL

ScrollView *	FeatureDisplayWindow = NULL

ScrollView *	ProtoDisplayWindow = NULL

int	classify_num_cp_levels = 3

double	classify_cp_angle_pad_loose = 45.0

double	classify_cp_angle_pad_medium = 20.0

double	classify_cp_angle_pad_tight = 10.0

double	classify_cp_end_pad_loose = 0.5

double	classify_cp_end_pad_medium = 0.5

double	classify_cp_end_pad_tight = 0.5

double	classify_cp_side_pad_loose = 2.5

double	classify_cp_side_pad_medium = 1.2

double	classify_cp_side_pad_tight = 0.6

double	classify_pp_angle_pad = 45.0

double	classify_pp_end_pad = 0.5

double	classify_pp_side_pad = 2.5

Macro Definition Documentation

#define AS ANGLE_SHIFT

#define CircularIncrement	(	i,
		r
	)	(((i) < (r) - 1)?((i)++):((i) = 0))

macro for performing circular increments of bucket indices

Definition at line 121 of file intproto.cpp.

#define HV_TOLERANCE (0.0025) /* approx 0.9 degrees */

define pad used to snap near horiz/vertical protos to horiz/vertical

Definition at line 70 of file intproto.cpp.

#define INT_BASELINE (0.25 * INT_CHAR_NORM_RANGE)

Definition at line 56 of file intproto.cpp.

#define INT_CAPHEIGHT (1.0 * INT_CHAR_NORM_RANGE)

Definition at line 58 of file intproto.cpp.

#define INT_DESCENDER (0.0 * INT_CHAR_NORM_RANGE)

Definition at line 55 of file intproto.cpp.

#define INT_MAX_X INT_CHAR_NORM_RANGE

Definition at line 66 of file intproto.cpp.

#define INT_MAX_Y INT_CHAR_NORM_RANGE

Definition at line 67 of file intproto.cpp.

#define INT_MIN_X 0

Definition at line 64 of file intproto.cpp.

#define INT_MIN_Y 0

Definition at line 65 of file intproto.cpp.

#define INT_XCENTER (0.5 * INT_CHAR_NORM_RANGE)

Definition at line 60 of file intproto.cpp.

#define INT_XHEIGHT (0.75 * INT_CHAR_NORM_RANGE)

Definition at line 57 of file intproto.cpp.

#define INT_XRADIUS (0.2 * INT_CHAR_NORM_RANGE)

Definition at line 62 of file intproto.cpp.

#define INT_YCENTER (0.5 * INT_CHAR_NORM_RANGE)

Definition at line 61 of file intproto.cpp.

#define INT_YRADIUS (0.2 * INT_CHAR_NORM_RANGE)

Definition at line 63 of file intproto.cpp.

#define MapParam	(	P,
		O,
		N
	)	(floor (((P) + (O)) * (N)))

macro for mapping floats to ints without bounds checking

Definition at line 124 of file intproto.cpp.

#define MAX_LEVEL 2

#define MAX_NUM_SWITCHES 3

Definition at line 75 of file intproto.cpp.

#define NB NUM_CP_BUCKETS

#define OLD_MAX_NUM_CONFIGS 32

Definition at line 113 of file intproto.cpp.

#define OLD_WERDS_PER_CONFIG_VEC

Value:

((OLD_MAX_NUM_CONFIGS + BITS_PER_WERD - 1) /\

BITS_PER_WERD)

OLD_MAX_NUM_CONFIGS

#define OLD_MAX_NUM_CONFIGS

Definition: intproto.cpp:113

BITS_PER_WERD

#define BITS_PER_WERD

Definition: intproto.h:42

Definition at line 114 of file intproto.cpp.

#define PROTO_PRUNER_SCALE (4.0)

Definition at line 53 of file intproto.cpp.

#define XS X_SHIFT

#define YS Y_SHIFT

Enumeration Type Documentation

enum SWITCH_TYPE

Enumerator
StartSwitch
EndSwitch
LastSwitch

Definition at line 72 of file intproto.cpp.

73 { StartSwitch, EndSwitch, LastSwitch }

StartSwitch

Definition: intproto.cpp:73

LastSwitch

Definition: intproto.cpp:73

EndSwitch

Definition: intproto.cpp:73

Function Documentation

void AddIntClass	(	INT_TEMPLATES	Templates,
		CLASS_ID	ClassId,
		INT_CLASS	Class
	)

This routine adds a new class structure to a set of templates. Classes have to be added to Templates in the order of increasing ClassIds.

Parameters

Templates	templates to add new class to
ClassId	class id to associate new class with
Class	class data structure to add to templates

Globals: none

Note: Exceptions: none; History: Mon Feb 11 11:52:08 1991, DSJ, Created.

Definition at line 224 of file intproto.cpp.

                                                                              {
   int Pruner;
 
   assert (LegalClassId (ClassId));
   if (ClassId != Templates->NumClasses) {
     fprintf(stderr, "Please make sure that classes are added to templates");
     fprintf(stderr, " in increasing order of ClassIds\n");
     exit(1);
   }
   ClassForClassId (Templates, ClassId) = Class;
   Templates->NumClasses++;
 
   if (Templates->NumClasses > MaxNumClassesIn (Templates)) {
     Pruner = Templates->NumClassPruners++;
     Templates->ClassPruners[Pruner] = new CLASS_PRUNER_STRUCT;
     memset(Templates->ClassPruners[Pruner], 0, sizeof(CLASS_PRUNER_STRUCT));
   }
 }                                /* AddIntClass */

int AddIntConfig ( INT_CLASS Class )

This routine returns the index of the next free config in Class.

Parameters

Class class to add new configuration to

Globals: none

Returns: Index of next free config.

Note: Exceptions: none; History: Mon Feb 11 14:44:40 1991, DSJ, Created.

Definition at line 257 of file intproto.cpp.

                                   {
   int Index;
 
   assert(Class->NumConfigs < MAX_NUM_CONFIGS);
 
   Index = Class->NumConfigs++;
   Class->ConfigLengths[Index] = 0;
   return Index;
 }                                /* AddIntConfig */

int AddIntProto ( INT_CLASS Class )

This routine allocates the next free proto in Class and returns its index.

Parameters

Class class to add new proto to

Globals: none

Returns: Proto index of new proto.

Note: Exceptions: none; History: Mon Feb 11 13:26:41 1991, DSJ, Created.

Definition at line 281 of file intproto.cpp.

                                  {
   int Index;
   int ProtoSetId;
   PROTO_SET ProtoSet;
   INT_PROTO Proto;
   register uinT32 *Word;
 
   if (Class->NumProtos >= MAX_NUM_PROTOS)
     return (NO_PROTO);
 
   Index = Class->NumProtos++;
 
   if (Class->NumProtos > MaxNumIntProtosIn(Class)) {
     ProtoSetId = Class->NumProtoSets++;
 
     ProtoSet = (PROTO_SET) Emalloc(sizeof(PROTO_SET_STRUCT));
     Class->ProtoSets[ProtoSetId] = ProtoSet;
     memset(ProtoSet, 0, sizeof(*ProtoSet));
 
     /* reallocate space for the proto lengths and install in class */
     Class->ProtoLengths =
       (uinT8 *)Erealloc(Class->ProtoLengths,
                         MaxNumIntProtosIn(Class) * sizeof(uinT8));
     memset(&Class->ProtoLengths[Index], 0,
            sizeof(*Class->ProtoLengths) * (MaxNumIntProtosIn(Class) - Index));
   }
 
   /* initialize proto so its length is zero and it isn't in any configs */
   Class->ProtoLengths[Index] = 0;
   Proto = ProtoForProtoId (Class, Index);
   for (Word = Proto->Configs;
        Word < Proto->Configs + WERDS_PER_CONFIG_VEC; *Word++ = 0);
 
   return (Index);
 
 }                                /* AddIntProto */

void AddProtoToClassPruner	(	PROTO	Proto,
		CLASS_ID	ClassId,
		INT_TEMPLATES	Templates
	)

Definition at line 320 of file intproto.cpp.

 {
   CLASS_PRUNER_STRUCT* Pruner;
   uinT32 ClassMask;
   uinT32 ClassCount;
   uinT32 WordIndex;
   int Level;
   FLOAT32 EndPad, SidePad, AnglePad;
   TABLE_FILLER TableFiller;
   FILL_SPEC FillSpec;
 
   Pruner = CPrunerFor (Templates, ClassId);
   WordIndex = CPrunerWordIndexFor (ClassId);
   ClassMask = CPrunerMaskFor (MAX_LEVEL, ClassId);
 
   for (Level = classify_num_cp_levels - 1; Level >= 0; Level--) {
     GetCPPadsForLevel(Level, &EndPad, &SidePad, &AnglePad);
     ClassCount = CPrunerMaskFor (Level, ClassId);
     InitTableFiller(EndPad, SidePad, AnglePad, Proto, &TableFiller);
 
     while (!FillerDone (&TableFiller)) {
       GetNextFill(&TableFiller, &FillSpec);
       DoFill(&FillSpec, Pruner, ClassMask, ClassCount, WordIndex);
     }
   }
 }                                /* AddProtoToClassPruner */

void AddProtoToProtoPruner	(	PROTO	Proto,
		int	ProtoId,
		INT_CLASS	Class,
		bool	debug
	)

Definition at line 364 of file intproto.cpp.

                                                         {
 /*
  ** Parameters:
  **   Proto floating-pt proto to be added to proto pruner
  **   ProtoId id of proto
  **   Class integer class that contains desired proto pruner
  ** Globals: none
  ** Operation: This routine updates the proto pruner lookup tables
  **   for Class to include a new proto identified by ProtoId
  **   and described by Proto.
  ** Return: none
  ** Exceptions: none
  ** History: Fri Feb  8 13:07:19 1991, DSJ, Created.
  */
   FLOAT32 Angle, X, Y, Length;
   FLOAT32 Pad;
   int Index;
   PROTO_SET ProtoSet;
 
   if (ProtoId >= Class->NumProtos)
     cprintf("AddProtoToProtoPruner:assert failed: %d < %d",
             ProtoId, Class->NumProtos);
   assert(ProtoId < Class->NumProtos);
 
   Index = IndexForProto (ProtoId);
   ProtoSet = Class->ProtoSets[SetForProto (ProtoId)];
 
   Angle = Proto->Angle;
 #ifndef _WIN32
   assert(!isnan(Angle));
 #endif
 
   FillPPCircularBits (ProtoSet->ProtoPruner[PRUNER_ANGLE], Index,
                       Angle + ANGLE_SHIFT, classify_pp_angle_pad / 360.0,
                       debug);
 
   Angle *= 2.0 * PI;
   Length = Proto->Length;
 
   X = Proto->X + X_SHIFT;
   Pad = MAX (fabs (cos (Angle)) * (Length / 2.0 +
                                    classify_pp_end_pad *
                                    GetPicoFeatureLength ()),
              fabs (sin (Angle)) * (classify_pp_side_pad *
                                    GetPicoFeatureLength ()));
 
   FillPPLinearBits(ProtoSet->ProtoPruner[PRUNER_X], Index, X, Pad, debug);
 
   Y = Proto->Y + Y_SHIFT;
   Pad = MAX (fabs (sin (Angle)) * (Length / 2.0 +
                                    classify_pp_end_pad *
                                    GetPicoFeatureLength ()),
              fabs (cos (Angle)) * (classify_pp_side_pad *
                                    GetPicoFeatureLength ()));
 
   FillPPLinearBits(ProtoSet->ProtoPruner[PRUNER_Y], Index, Y, Pad, debug);
 }                                /* AddProtoToProtoPruner */

FLOAT32 BucketEnd	(	int	Bucket,
		FLOAT32	Offset,
		int	NumBuckets
	)

Definition at line 1254 of file intproto.cpp.

                                                               {
 /*
  ** Parameters:
  **   Bucket    bucket whose end is to be computed
  **   Offset    offset used to map params to buckets
  **   NumBuckets  total number of buckets
  ** Globals: none
  ** Operation: This routine returns the parameter value which
  **   corresponds to the end of the specified bucket.
  **   The bucket number should have been generated using the
  **   BucketFor() function with parameters Offset and NumBuckets.
  ** Return: Param value corresponding to end position of Bucket.
  ** Exceptions: none
  ** History: Thu Feb 14 13:24:33 1991, DSJ, Created.
  */
   return (((FLOAT32) (Bucket + 1) / NumBuckets) - Offset);
 }                                /* BucketEnd */

int BucketFor	(	FLOAT32	Param,
		FLOAT32	Offset,
		int	NumBuckets
	)

Definition at line 425 of file intproto.cpp.

                                                              {
 /*
  ** Parameters:
  **   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
  ** Globals: none
  ** Operation: This routine maps a parameter value into a bucket between
  **   0 and NumBuckets-1.  Offset is added to the parameter
  **   before mapping it.  Values which map to buckets outside
  **   the range are truncated to fit within the range.  Mapping
  **   is done by truncating rather than rounding.
  ** Return: Bucket number corresponding to Param + Offset.
  ** Exceptions: none
  ** History: Thu Feb 14 13:24:33 1991, DSJ, Created.
  */
   return ClipToRange(static_cast<int>(MapParam(Param, Offset, NumBuckets)),
                      0, NumBuckets - 1);
 }                                /* BucketFor */

FLOAT32 BucketStart	(	int	Bucket,
		FLOAT32	Offset,
		int	NumBuckets
	)

Definition at line 1233 of file intproto.cpp.

                                                                 {
 /*
  ** Parameters:
  **   Bucket    bucket whose start is to be computed
  **   Offset    offset used to map params to buckets
  **   NumBuckets  total number of buckets
  ** Globals: none
  ** Operation: This routine returns the parameter value which
  **   corresponds to the beginning of the specified bucket.
  **   The bucket number should have been generated using the
  **   BucketFor() function with parameters Offset and NumBuckets.
  ** Return: Param value corresponding to start position of Bucket.
  ** Exceptions: none
  ** History: Thu Feb 14 13:24:33 1991, DSJ, Created.
  */
   return (((FLOAT32) Bucket / NumBuckets) - Offset);
 
 }                                /* BucketStart */

int CircBucketFor	(	FLOAT32	Param,
		FLOAT32	Offset,
		int	NumBuckets
	)

Definition at line 447 of file intproto.cpp.

                                                                  {
 /*
  ** Parameters:
  **   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
  ** Globals: none
  ** Operation: This routine maps a parameter value into a bucket between
  **   0 and NumBuckets-1.  Offset is added to the parameter
  **   before mapping it.  Values which map to buckets outside
  **   the range are wrapped to a new value in a circular fashion.
  **   Mapping is done by truncating rather than rounding.
  ** Return: Bucket number corresponding to Param + Offset.
  ** Exceptions: none
  ** History: Thu Feb 14 13:24:33 1991, DSJ, Created.
  */
   int Bucket;
 
   Bucket = static_cast<int>(MapParam(Param, Offset, NumBuckets));
   if (Bucket < 0)
     Bucket += NumBuckets;
   else if (Bucket >= NumBuckets)
     Bucket -= NumBuckets;
   return Bucket;
 }                                /* CircBucketFor */

void ConvertConfig	(	BIT_VECTOR	Config,
		int	ConfigId,
		INT_CLASS	Class
	)

Definition at line 494 of file intproto.cpp.

                                                                      {
 /*
  ** Parameters:
  **   Config    config to be added to class
  **   ConfigId  id to be used for new config
  **   Class   class to add new config to
  ** Globals: none
  ** Operation: This operation updates the config vectors of all protos
  **   in Class to indicate that the protos with 1's in Config
  **   belong to a new configuration identified by ConfigId.
  **   It is assumed that the length of the Config bit vector is
  **   equal to the number of protos in Class.
  ** Return: none
  ** Exceptions: none
  ** History: Mon Feb 11 14:57:31 1991, DSJ, Created.
  */
   int ProtoId;
   INT_PROTO Proto;
   int TotalLength;
 
   for (ProtoId = 0, TotalLength = 0;
     ProtoId < Class->NumProtos; ProtoId++) {
     if (test_bit(Config, ProtoId)) {
       Proto = ProtoForProtoId(Class, ProtoId);
       SET_BIT(Proto->Configs, ConfigId);
       TotalLength += Class->ProtoLengths[ProtoId];
     }
   }
   Class->ConfigLengths[ConfigId] = TotalLength;
 }                                /* ConvertConfig */

ScrollView* CreateFeatureSpaceWindow	(	const char *	name,
		int	xpos,
		int	ypos
	)

Definition at line 1990 of file intproto.cpp.

                                                                            {
   return new ScrollView(name, xpos, ypos, 520, 520, 260, 260, true);
 }

void DisplayIntFeature	(	const INT_FEATURE_STRUCT *	Feature,
		FLOAT32	Evidence
	)

Definition at line 638 of file intproto.cpp.

                                                                             {
 /*
  ** Parameters:
  **   Feature   pico-feature to be displayed
  **   Evidence  best evidence for this feature (0-1)
  ** Globals:
  **   FeatureShapes global display list for features
  ** Operation: This routine renders the specified feature into a
  **   global display list.
  ** Return: none
  ** Exceptions: none
  ** History: Thu Mar 21 14:45:04 1991, DSJ, Created.
  */
   ScrollView::Color color = GetMatchColorFor(Evidence);
   RenderIntFeature(IntMatchWindow, Feature, color);
   if (FeatureDisplayWindow) {
     RenderIntFeature(FeatureDisplayWindow, Feature, color);
   }
 }                                /* DisplayIntFeature */

void DisplayIntProto	(	INT_CLASS	Class,
		PROTO_ID	ProtoId,
		FLOAT32	Evidence
	)

Definition at line 660 of file intproto.cpp.

                                                                           {
 /*
  ** Parameters:
  **   Class   class to take proto from
  **   ProtoId   id of proto in Class to be displayed
  **   Evidence  total evidence for proto (0-1)
  ** Globals:
  **   ProtoShapes global display list for protos
  ** Operation: This routine renders the specified proto into a
  **   global display list.
  ** Return: none
  ** Exceptions: none
  ** History: Thu Mar 21 14:45:04 1991, DSJ, Created.
  */
   ScrollView::Color color = GetMatchColorFor(Evidence);
   RenderIntProto(IntMatchWindow, Class, ProtoId, color);
   if (ProtoDisplayWindow) {
     RenderIntProto(ProtoDisplayWindow, Class, ProtoId, color);
   }
 }                                /* DisplayIntProto */

void DoFill	(	FILL_SPEC *	FillSpec,
		CLASS_PRUNER_STRUCT *	Pruner,
		register uinT32	ClassMask,
		register uinT32	ClassCount,
		register uinT32	WordIndex
	)

Definition at line 1274 of file intproto.cpp.

                                        {
 /*
  ** Parameters:
  **   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
  ** Globals: none
  ** Operation: This routine fills in the section of a class pruner
  **   corresponding to a single x value for a single proto of
  **   a class.
  ** Return: none
  ** Exceptions: none
  ** History: Tue Feb 19 11:11:29 1991, DSJ, Created.
  */
   register int X, Y, Angle;
   register uinT32 OldWord;
 
   X = FillSpec->X;
   if (X < 0)
     X = 0;
   if (X >= NUM_CP_BUCKETS)
     X = NUM_CP_BUCKETS - 1;
 
   if (FillSpec->YStart < 0)
     FillSpec->YStart = 0;
   if (FillSpec->YEnd >= NUM_CP_BUCKETS)
     FillSpec->YEnd = NUM_CP_BUCKETS - 1;
 
   for (Y = FillSpec->YStart; Y <= FillSpec->YEnd; Y++)
     for (Angle = FillSpec->AngleStart;
          TRUE; CircularIncrement (Angle, NUM_CP_BUCKETS)) {
       OldWord = Pruner->p[X][Y][Angle][WordIndex];
       if (ClassCount > (OldWord & ClassMask)) {
         OldWord &= ~ClassMask;
         OldWord |= ClassCount;
         Pruner->p[X][Y][Angle][WordIndex] = OldWord;
       }
       if (Angle == FillSpec->AngleEnd)
         break;
     }
 }                                /* DoFill */

BOOL8 FillerDone ( TABLE_FILLER * Filler )

Definition at line 1324 of file intproto.cpp.

                                        {
 /*
  ** Parameters:
  **   Filler    table filler to check if done
  ** Globals: none
  ** Operation: Return TRUE if the specified table filler is done, i.e.
  **   if it has no more lines to fill.
  ** Return: TRUE if no more lines to fill, FALSE otherwise.
  ** Exceptions: none
  ** History: Tue Feb 19 10:08:05 1991, DSJ, Created.
  */
   FILL_SWITCH *Next;
 
   Next = &(Filler->Switch[Filler->NextSwitch]);
 
   if (Filler->X > Next->X && Next->Type == LastSwitch)
     return (TRUE);
   else
     return (FALSE);
 
 }                                /* FillerDone */

void FillPPCircularBits	(	uinT32	ParamTable[NUM_PP_BUCKETS][WERDS_PER_PP_VECTOR],
		int	Bit,
		FLOAT32	Center,
		FLOAT32	Spread,
		bool	debug
	)

Definition at line 1348 of file intproto.cpp.

                                                                              {
 /*
  ** Parameters:
  **   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
  ** Globals: none
  ** Operation: This routine sets Bit in each bit vector whose
  **   bucket lies within the range Center +- Spread.  The fill
  **   is done for a circular dimension, i.e. bucket 0 is adjacent
  **   to the last bucket.  It is assumed that Center and Spread
  **   are expressed in a circular coordinate system whose range
  **   is 0 to 1.
  ** Return: none
  ** Exceptions: none
  ** History: Tue Oct 16 09:26:54 1990, DSJ, Created.
  */
   int i, FirstBucket, LastBucket;
 
   if (Spread > 0.5)
     Spread = 0.5;
 
   FirstBucket = (int) floor ((Center - Spread) * NUM_PP_BUCKETS);
   if (FirstBucket < 0)
     FirstBucket += NUM_PP_BUCKETS;
 
   LastBucket = (int) floor ((Center + Spread) * NUM_PP_BUCKETS);
   if (LastBucket >= NUM_PP_BUCKETS)
     LastBucket -= NUM_PP_BUCKETS;
   if (debug) tprintf("Circular fill from %d to %d", FirstBucket, LastBucket);
   for (i = FirstBucket; TRUE; CircularIncrement (i, NUM_PP_BUCKETS)) {
     SET_BIT (ParamTable[i], Bit);
 
     /* exit loop after we have set the bit for the last bucket */
     if (i == LastBucket)
       break;
   }
 
 }                                /* FillPPCircularBits */

void FillPPLinearBits	(	uinT32	ParamTable[NUM_PP_BUCKETS][WERDS_PER_PP_VECTOR],
		int	Bit,
		FLOAT32	Center,
		FLOAT32	Spread,
		bool	debug
	)

Definition at line 1392 of file intproto.cpp.

                                                                            {
 /*
  ** Parameters:
  **   ParamTable  table of bit vectors, one per param bucket
  **   Bit   bit number being filled
  **   Center    center of filled area
  **   Spread    spread of filled area
  ** Globals: none
  ** Operation: This routine sets Bit in each bit vector whose
  **   bucket lies within the range Center +- Spread.  The fill
  **   is done for a linear dimension, i.e. there is no wrap-around
  **   for this dimension.  It is assumed that Center and Spread
  **   are expressed in a linear coordinate system whose range
  **   is approximately 0 to 1.  Values outside this range will
  **   be clipped.
  ** Return: none
  ** Exceptions: none
  ** History: Tue Oct 16 09:26:54 1990, DSJ, Created.
  */
   int i, FirstBucket, LastBucket;
 
   FirstBucket = (int) floor ((Center - Spread) * NUM_PP_BUCKETS);
   if (FirstBucket < 0)
     FirstBucket = 0;
 
   LastBucket = (int) floor ((Center + Spread) * NUM_PP_BUCKETS);
   if (LastBucket >= NUM_PP_BUCKETS)
     LastBucket = NUM_PP_BUCKETS - 1;
 
   if (debug) tprintf("Linear fill from %d to %d", FirstBucket, LastBucket);
   for (i = FirstBucket; i <= LastBucket; i++)
     SET_BIT (ParamTable[i], Bit);
 
 }                                /* FillPPLinearBits */

void free_int_class ( INT_CLASS int_class )

Definition at line 735 of file intproto.cpp.

                                          {
   int i;
 
   for (i = 0; i < int_class->NumProtoSets; i++) {
     Efree (int_class->ProtoSets[i]);
   }
   if (int_class->ProtoLengths != NULL) {
     Efree (int_class->ProtoLengths);
   }
   Efree(int_class);
 }

void free_int_templates ( INT_TEMPLATES templates )

Definition at line 774 of file intproto.cpp.

                                                  {
   int i;
 
   for (i = 0; i < templates->NumClasses; i++)
     free_int_class(templates->Class[i]);
   for (i = 0; i < templates->NumClassPruners; i++)
     delete templates->ClassPruners[i];
   Efree(templates);
 }

void GetCPPadsForLevel	(	int	Level,
		FLOAT32 *	EndPad,
		FLOAT32 *	SidePad,
		FLOAT32 *	AnglePad
	)

Definition at line 1508 of file intproto.cpp.

                                           {
 /*
  ** Parameters:
  **   Level   "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
  ** Globals: none
  ** Operation: This routine copies the appropriate global pad variables
  **   into EndPad, SidePad, and AnglePad.  This is a kludge used
  **   to get around the fact that global control variables cannot
  **   be arrays.  If the specified level is illegal, the tightest
  **   possible pads are returned.
  ** Return: none (results are returned in EndPad, SidePad, and AnglePad.
  ** Exceptions: none
  ** History: Thu Feb 14 08:26:49 1991, DSJ, Created.
  */
   switch (Level) {
     case 0:
       *EndPad = classify_cp_end_pad_loose * GetPicoFeatureLength ();
       *SidePad = classify_cp_side_pad_loose * GetPicoFeatureLength ();
       *AnglePad = classify_cp_angle_pad_loose / 360.0;
       break;
 
     case 1:
       *EndPad = classify_cp_end_pad_medium * GetPicoFeatureLength ();
       *SidePad = classify_cp_side_pad_medium * GetPicoFeatureLength ();
       *AnglePad = classify_cp_angle_pad_medium / 360.0;
       break;
 
     case 2:
       *EndPad = classify_cp_end_pad_tight * GetPicoFeatureLength ();
       *SidePad = classify_cp_side_pad_tight * GetPicoFeatureLength ();
       *AnglePad = classify_cp_angle_pad_tight / 360.0;
       break;
 
     default:
       *EndPad = classify_cp_end_pad_tight * GetPicoFeatureLength ();
       *SidePad = classify_cp_side_pad_tight * GetPicoFeatureLength ();
       *AnglePad = classify_cp_angle_pad_tight / 360.0;
       break;
   }
   if (*AnglePad > 0.5)
     *AnglePad = 0.5;
 
 }                                /* GetCPPadsForLevel */

ScrollView::Color GetMatchColorFor ( FLOAT32 Evidence )

Definition at line 1560 of file intproto.cpp.

                                                    {
 /*
  ** Parameters:
  **   Evidence  evidence value to return color for
  ** Globals: none
  ** Operation:
  ** Return: Color which corresponds to specified Evidence value.
  ** Exceptions: none
  ** History: Thu Mar 21 15:24:52 1991, DSJ, Created.
  */
 
   assert (Evidence >= 0.0);
   assert (Evidence <= 1.0);
 
   if (Evidence >= 0.90)
     return ScrollView::WHITE;
   else if (Evidence >= 0.75)
     return ScrollView::GREEN;
   else if (Evidence >= 0.50)
     return ScrollView::RED;
   else
     return ScrollView::BLUE;
 }                                /* GetMatchColorFor */

void GetNextFill	(	TABLE_FILLER *	Filler,
		FILL_SPEC *	Fill
	)

Definition at line 1586 of file intproto.cpp.

                                                         {
 /*
  ** Parameters:
  **   Filler    filler to get next fill spec from
  **   Fill    place to put spec for next fill
  ** Globals: none
  ** Operation: This routine returns (in Fill) the specification of
  **   the next line to be filled from Filler.  FillerDone() should
  **   always be called before GetNextFill() to ensure that we
  **   do not run past the end of the fill table.
  ** Return: none (results are returned in Fill)
  ** Exceptions: none
  ** History: Tue Feb 19 10:17:42 1991, DSJ, Created.
  */
   FILL_SWITCH *Next;
 
   /* compute the fill assuming no switches will be encountered */
   Fill->AngleStart = Filler->AngleStart;
   Fill->AngleEnd = Filler->AngleEnd;
   Fill->X = Filler->X;
   Fill->YStart = Filler->YStart >> 8;
   Fill->YEnd = Filler->YEnd >> 8;
 
   /* update the fill info and the filler for ALL switches at this X value */
   Next = &(Filler->Switch[Filler->NextSwitch]);
   while (Filler->X >= Next->X) {
     Fill->X = Filler->X = Next->X;
     if (Next->Type == StartSwitch) {
       Fill->YStart = Next->Y;
       Filler->StartDelta = Next->Delta;
       Filler->YStart = Next->YInit;
     }
     else if (Next->Type == EndSwitch) {
       Fill->YEnd = Next->Y;
       Filler->EndDelta = Next->Delta;
       Filler->YEnd = Next->YInit;
     }
     else {                       /* Type must be LastSwitch */
       break;
     }
     Filler->NextSwitch++;
     Next = &(Filler->Switch[Filler->NextSwitch]);
   }
 
   /* prepare the filler for the next call to this routine */
   Filler->X++;
   Filler->YStart += Filler->StartDelta;
   Filler->YEnd += Filler->EndDelta;
 
 }                                /* GetNextFill */

void InitFeatureDisplayWindowIfReqd ( )

Initializes the feature display window if it is not already initialized.

Definition at line 1981 of file intproto.cpp.

                                       {
   if (FeatureDisplayWindow == NULL) {
     FeatureDisplayWindow = CreateFeatureSpaceWindow("FeatureDisplayWindow",
                                                     50, 700);
   }
 }

void InitIntMatchWindowIfReqd ( )

Initializes the int matcher window if it is not already initialized.

Definition at line 1949 of file intproto.cpp.

                                 {
   if (IntMatchWindow == NULL) {
     IntMatchWindow = CreateFeatureSpaceWindow("IntMatchWindow", 50, 200);
     SVMenuNode* popup_menu = new SVMenuNode();
 
     popup_menu->AddChild("Debug Adapted classes", IDA_ADAPTIVE,
                          "x", "Class to debug");
     popup_menu->AddChild("Debug Static classes", IDA_STATIC,
                          "x", "Class to debug");
     popup_menu->AddChild("Debug Both", IDA_BOTH,
                          "x", "Class to debug");
     popup_menu->AddChild("Debug Shape Index", IDA_SHAPE_INDEX,
                          "0", "Index to debug");
     popup_menu->BuildMenu(IntMatchWindow, false);
   }
 }

void InitProtoDisplayWindowIfReqd ( )

Initializes the proto display window if it is not already initialized.

Definition at line 1970 of file intproto.cpp.

                                     {
   if (ProtoDisplayWindow == NULL) {
     ProtoDisplayWindow = CreateFeatureSpaceWindow("ProtoDisplayWindow",
                                                   550, 200);
  }
 }

void InitTableFiller	(	FLOAT32	EndPad,
		FLOAT32	SidePad,
		FLOAT32	AnglePad,
		PROTO	Proto,
		TABLE_FILLER *	Filler
	)

This routine computes a data structure (Filler) which can be used to fill in a rectangle surrounding the specified Proto.

Parameters

EndPad,SidePad,AnglePad	padding to add to proto
Proto	proto to create a filler for
Filler	place to put table filler

Globals: none

Returns: none (results are returned in Filler)

Note: Exceptions: none; History: Thu Feb 14 09:27:05 1991, DSJ, Created.

Definition at line 1654 of file intproto.cpp.

 {
   FLOAT32 Angle;
   FLOAT32 X, Y, HalfLength;
   FLOAT32 Cos, Sin;
   FLOAT32 XAdjust, YAdjust;
   FPOINT Start, Switch1, Switch2, End;
   int S1 = 0;
   int S2 = 1;
 
   Angle = Proto->Angle;
   X = Proto->X;
   Y = Proto->Y;
   HalfLength = Proto->Length / 2.0;
 
   Filler->AngleStart = CircBucketFor(Angle - AnglePad, AS, NB);
   Filler->AngleEnd = CircBucketFor(Angle + AnglePad, AS, NB);
   Filler->NextSwitch = 0;
 
   if (fabs (Angle - 0.0) < HV_TOLERANCE || fabs (Angle - 0.5) < HV_TOLERANCE) {
     /* horizontal proto - handle as special case */
     Filler->X = BucketFor(X - HalfLength - EndPad, XS, NB);
     Filler->YStart = BucketFor(Y - SidePad, YS, NB * 256);
     Filler->YEnd = BucketFor(Y + SidePad, YS, NB * 256);
     Filler->StartDelta = 0;
     Filler->EndDelta = 0;
     Filler->Switch[0].Type = LastSwitch;
     Filler->Switch[0].X = BucketFor(X + HalfLength + EndPad, XS, NB);
   } else if (fabs(Angle - 0.25) < HV_TOLERANCE ||
            fabs(Angle - 0.75) < HV_TOLERANCE) {
     /* vertical proto - handle as special case */
     Filler->X = BucketFor(X - SidePad, XS, NB);
     Filler->YStart = BucketFor(Y - HalfLength - EndPad, YS, NB * 256);
     Filler->YEnd = BucketFor(Y + HalfLength + EndPad, YS, NB * 256);
     Filler->StartDelta = 0;
     Filler->EndDelta = 0;
     Filler->Switch[0].Type = LastSwitch;
     Filler->Switch[0].X = BucketFor(X + SidePad, XS, NB);
   } else {
     /* diagonal proto */
 
     if ((Angle > 0.0 && Angle < 0.25) || (Angle > 0.5 && Angle < 0.75)) {
       /* rising diagonal proto */
       Angle *= 2.0 * PI;
       Cos = fabs(cos(Angle));
       Sin = fabs(sin(Angle));
 
       /* compute the positions of the corners of the acceptance region */
       Start.x = X - (HalfLength + EndPad) * Cos - SidePad * Sin;
       Start.y = Y - (HalfLength + EndPad) * Sin + SidePad * Cos;
       End.x = 2.0 * X - Start.x;
       End.y = 2.0 * Y - Start.y;
       Switch1.x = X - (HalfLength + EndPad) * Cos + SidePad * Sin;
       Switch1.y = Y - (HalfLength + EndPad) * Sin - SidePad * Cos;
       Switch2.x = 2.0 * X - Switch1.x;
       Switch2.y = 2.0 * Y - Switch1.y;
 
       if (Switch1.x > Switch2.x) {
         S1 = 1;
         S2 = 0;
       }
 
       /* translate into bucket positions and deltas */
       Filler->X = (inT8) MapParam(Start.x, XS, NB);
       Filler->StartDelta = -(inT16) ((Cos / Sin) * 256);
       Filler->EndDelta = (inT16) ((Sin / Cos) * 256);
 
       XAdjust = BucketEnd(Filler->X, XS, NB) - Start.x;
       YAdjust = XAdjust * Cos / Sin;
       Filler->YStart = (inT16) MapParam(Start.y - YAdjust, YS, NB * 256);
       YAdjust = XAdjust * Sin / Cos;
       Filler->YEnd = (inT16) MapParam(Start.y + YAdjust, YS, NB * 256);
 
       Filler->Switch[S1].Type = StartSwitch;
       Filler->Switch[S1].X = (inT8) MapParam(Switch1.x, XS, NB);
       Filler->Switch[S1].Y = (inT8) MapParam(Switch1.y, YS, NB);
       XAdjust = Switch1.x - BucketStart(Filler->Switch[S1].X, XS, NB);
       YAdjust = XAdjust * Sin / Cos;
       Filler->Switch[S1].YInit =
         (inT16) MapParam(Switch1.y - YAdjust, YS, NB * 256);
       Filler->Switch[S1].Delta = Filler->EndDelta;
 
       Filler->Switch[S2].Type = EndSwitch;
       Filler->Switch[S2].X = (inT8) MapParam(Switch2.x, XS, NB);
       Filler->Switch[S2].Y = (inT8) MapParam(Switch2.y, YS, NB);
       XAdjust = Switch2.x - BucketStart(Filler->Switch[S2].X, XS, NB);
       YAdjust = XAdjust * Cos / Sin;
       Filler->Switch[S2].YInit =
         (inT16) MapParam(Switch2.y + YAdjust, YS, NB * 256);
       Filler->Switch[S2].Delta = Filler->StartDelta;
 
       Filler->Switch[2].Type = LastSwitch;
       Filler->Switch[2].X = (inT8)MapParam(End.x, XS, NB);
     } else {
       /* falling diagonal proto */
       Angle *= 2.0 * PI;
       Cos = fabs(cos(Angle));
       Sin = fabs(sin(Angle));
 
       /* compute the positions of the corners of the acceptance region */
       Start.x = X - (HalfLength + EndPad) * Cos - SidePad * Sin;
       Start.y = Y + (HalfLength + EndPad) * Sin - SidePad * Cos;
       End.x = 2.0 * X - Start.x;
       End.y = 2.0 * Y - Start.y;
       Switch1.x = X - (HalfLength + EndPad) * Cos + SidePad * Sin;
       Switch1.y = Y + (HalfLength + EndPad) * Sin + SidePad * Cos;
       Switch2.x = 2.0 * X - Switch1.x;
       Switch2.y = 2.0 * Y - Switch1.y;
 
       if (Switch1.x > Switch2.x) {
         S1 = 1;
         S2 = 0;
       }
 
       /* translate into bucket positions and deltas */
       Filler->X = (inT8) MapParam(Start.x, XS, NB);
       Filler->StartDelta = -(inT16) ((Sin / Cos) * 256);
       Filler->EndDelta = (inT16) ((Cos / Sin) * 256);
 
       XAdjust = BucketEnd(Filler->X, XS, NB) - Start.x;
       YAdjust = XAdjust * Sin / Cos;
       Filler->YStart = (inT16) MapParam(Start.y - YAdjust, YS, NB * 256);
       YAdjust = XAdjust * Cos / Sin;
       Filler->YEnd = (inT16) MapParam(Start.y + YAdjust, YS, NB * 256);
 
       Filler->Switch[S1].Type = EndSwitch;
       Filler->Switch[S1].X = (inT8) MapParam(Switch1.x, XS, NB);
       Filler->Switch[S1].Y = (inT8) MapParam(Switch1.y, YS, NB);
       XAdjust = Switch1.x - BucketStart(Filler->Switch[S1].X, XS, NB);
       YAdjust = XAdjust * Sin / Cos;
       Filler->Switch[S1].YInit =
         (inT16) MapParam(Switch1.y + YAdjust, YS, NB * 256);
       Filler->Switch[S1].Delta = Filler->StartDelta;
 
       Filler->Switch[S2].Type = StartSwitch;
       Filler->Switch[S2].X = (inT8) MapParam(Switch2.x, XS, NB);
       Filler->Switch[S2].Y = (inT8) MapParam(Switch2.y, YS, NB);
       XAdjust = Switch2.x - BucketStart(Filler->Switch[S2].X, XS, NB);
       YAdjust = XAdjust * Cos / Sin;
       Filler->Switch[S2].YInit =
         (inT16) MapParam(Switch2.y - YAdjust, YS, NB * 256);
       Filler->Switch[S2].Delta = Filler->EndDelta;
 
       Filler->Switch[2].Type = LastSwitch;
       Filler->Switch[2].X = (inT8) MapParam(End.x, XS, NB);
     }
   }
 }                                /* InitTableFiller */

INT_CLASS NewIntClass	(	int	MaxNumProtos,
		int	MaxNumConfigs
	)

Definition at line 683 of file intproto.cpp.

                                                            {
 /*
  ** Parameters:
  **   MaxNumProtos  number of protos to allocate space for
  **   MaxNumConfigs number of configs to allocate space for
  ** Globals: none
  ** Operation: This routine creates a new integer class data structure
  **   and returns it.  Sufficient space is allocated
  **   to handle the specified number of protos and configs.
  ** Return: New class created.
  ** Exceptions: none
  ** History: Fri Feb  8 10:51:23 1991, DSJ, Created.
  */
   INT_CLASS Class;
   PROTO_SET ProtoSet;
   int i;
 
   assert(MaxNumConfigs <= MAX_NUM_CONFIGS);
 
   Class = (INT_CLASS) Emalloc(sizeof(INT_CLASS_STRUCT));
   Class->NumProtoSets = ((MaxNumProtos + PROTOS_PER_PROTO_SET - 1) /
                             PROTOS_PER_PROTO_SET);
 
   assert(Class->NumProtoSets <= MAX_NUM_PROTO_SETS);
 
   Class->NumProtos = 0;
   Class->NumConfigs = 0;
 
   for (i = 0; i < Class->NumProtoSets; i++) {
     /* allocate space for a proto set, install in class, and initialize */
     ProtoSet = (PROTO_SET) Emalloc(sizeof(PROTO_SET_STRUCT));
     memset(ProtoSet, 0, sizeof(*ProtoSet));
     Class->ProtoSets[i] = ProtoSet;
 
     /* allocate space for the proto lengths and install in class */
   }
   if (MaxNumIntProtosIn (Class) > 0) {
     Class->ProtoLengths =
       (uinT8 *)Emalloc(MaxNumIntProtosIn (Class) * sizeof (uinT8));
     memset(Class->ProtoLengths, 0,
            MaxNumIntProtosIn(Class) * sizeof(*Class->ProtoLengths));
   } else {
     Class->ProtoLengths = NULL;
   }
   memset(Class->ConfigLengths, 0, sizeof(Class->ConfigLengths));
 
   return (Class);
 
 }                                /* NewIntClass */

INT_TEMPLATES NewIntTemplates ( )

Definition at line 749 of file intproto.cpp.

                                 {
 /*
  ** Parameters: none
  ** Globals: none
  ** Operation: This routine allocates a new set of integer templates
  **   initialized to hold 0 classes.
  ** Return: The integer templates created.
  ** Exceptions: none
  ** History: Fri Feb  8 08:38:51 1991, DSJ, Created.
  */
   INT_TEMPLATES T;
   int i;
 
   T = (INT_TEMPLATES) Emalloc (sizeof (INT_TEMPLATES_STRUCT));
   T->NumClasses = 0;
   T->NumClassPruners = 0;
 
   for (i = 0; i < MAX_NUM_CLASSES; i++)
     ClassForClassId (T, i) = NULL;
 
   return (T);
 }                                /* NewIntTemplates */

void RenderIntFeature	(	ScrollView *	window,
		const INT_FEATURE_STRUCT *	Feature,
		ScrollView::Color	color
	)

Definition at line 1822 of file intproto.cpp.

                                              {
   FLOAT32 X, Y, Dx, Dy, Length;
 
   window->Pen(color);
   assert(Feature != NULL);
   assert(color != 0);
 
   X = Feature->X;
   Y = Feature->Y;
   Length = GetPicoFeatureLength() * 0.7 * INT_CHAR_NORM_RANGE;
   // The -PI has no significant effect here, but the value of Theta is computed
   // using BinaryAnglePlusPi in intfx.cpp.
   Dx = (Length / 2.0) * cos((Feature->Theta / 256.0) * 2.0 * PI - PI);
   Dy = (Length / 2.0) * sin((Feature->Theta / 256.0) * 2.0 * PI - PI);
 
   window->SetCursor(X, Y);
   window->DrawTo(X + Dx, Y + Dy);
 }                                /* RenderIntFeature */

void RenderIntProto	(	ScrollView *	window,
		INT_CLASS	Class,
		PROTO_ID	ProtoId,
		ScrollView::Color	color
	)

Definition at line 1859 of file intproto.cpp.

                                            {
   PROTO_SET ProtoSet;
   INT_PROTO Proto;
   int ProtoSetIndex;
   int ProtoWordIndex;
   FLOAT32 Length;
   int Xmin, Xmax, Ymin, Ymax;
   FLOAT32 X, Y, Dx, Dy;
   uinT32 ProtoMask;
   int Bucket;
 
   assert(ProtoId >= 0);
   assert(Class != NULL);
   assert(ProtoId < Class->NumProtos);
   assert(color != 0);
   window->Pen(color);
 
   ProtoSet = Class->ProtoSets[SetForProto(ProtoId)];
   ProtoSetIndex = IndexForProto(ProtoId);
   Proto = &(ProtoSet->Protos[ProtoSetIndex]);
   Length = (Class->ProtoLengths[ProtoId] *
     GetPicoFeatureLength() * INT_CHAR_NORM_RANGE);
   ProtoMask = PPrunerMaskFor(ProtoId);
   ProtoWordIndex = PPrunerWordIndexFor(ProtoId);
 
   // find the x and y extent of the proto from the proto pruning table
   Xmin = Ymin = NUM_PP_BUCKETS;
   Xmax = Ymax = 0;
   for (Bucket = 0; Bucket < NUM_PP_BUCKETS; Bucket++) {
     if (ProtoMask & ProtoSet->ProtoPruner[PRUNER_X][Bucket][ProtoWordIndex]) {
       UpdateRange(Bucket, &Xmin, &Xmax);
     }
 
     if (ProtoMask & ProtoSet->ProtoPruner[PRUNER_Y][Bucket][ProtoWordIndex]) {
       UpdateRange(Bucket, &Ymin, &Ymax);
     }
   }
   X = (Xmin + Xmax + 1) / 2.0 * PROTO_PRUNER_SCALE;
   Y = (Ymin + Ymax + 1) / 2.0 * PROTO_PRUNER_SCALE;
   // The -PI has no significant effect here, but the value of Theta is computed
   // using BinaryAnglePlusPi in intfx.cpp.
   Dx = (Length / 2.0) * cos((Proto->Angle / 256.0) * 2.0 * PI - PI);
   Dy = (Length / 2.0) * sin((Proto->Angle / 256.0) * 2.0 * PI - PI);
 
   window->SetCursor(X - Dx, Y - Dy);
   window->DrawTo(X + Dx, Y + Dy);
 }                                /* RenderIntProto */

int TruncateParam	(	FLOAT32	Param,
		int	Min,
		int	Max,
		char *	Id
	)

This routine truncates Param to lie within the range of Min-Max inclusive. If a truncation is performed, and Id is not null, an warning message is printed.

Parameters

Param	parameter value to be truncated
Min,Max	parameter limits (inclusive)
Id	string id of parameter for error messages

Globals: none

Returns: Truncated parameter.

Note: Exceptions: none; History: Fri Feb 8 11:54:28 1991, DSJ, Created.

Definition at line 1927 of file intproto.cpp.

                                                              {
   if (Param < Min) {
     if (Id)
       cprintf("Warning: Param %s truncated from %f to %d!\n",
               Id, Param, Min);
     Param = Min;
   } else if (Param > Max) {
     if (Id)
       cprintf("Warning: Param %s truncated from %f to %d!\n",
               Id, Param, Max);
     Param = Max;
   }
   return static_cast<int>(floor(Param));
 }                                /* TruncateParam */

void UpdateMatchDisplay ( )

Definition at line 476 of file intproto.cpp.

                           {
 /*
  ** Parameters: none
  ** Globals:
  **   FeatureShapes display list for features
  **   ProtoShapes display list for protos
  ** Operation: This routine clears the global feature and proto
  **   display lists.
  ** Return: none
  ** Exceptions: none
  ** History: Thu Mar 21 15:40:19 1991, DSJ, Created.
  */
   if (IntMatchWindow != NULL)
     IntMatchWindow->Update();
 }                                /* ClearMatchDisplay */

Variable Documentation

double classify_cp_angle_pad_loose = 45.0

"Class Pruner Angle Pad Loose"

Definition at line 191 of file intproto.cpp.

double classify_cp_angle_pad_medium = 20.0

"Class Pruner Angle Pad Medium"

Definition at line 193 of file intproto.cpp.

double classify_cp_angle_pad_tight = 10.0

"CLass Pruner Angle Pad Tight"

Definition at line 195 of file intproto.cpp.

double classify_cp_end_pad_loose = 0.5

"Class Pruner End Pad Loose"

Definition at line 196 of file intproto.cpp.

double classify_cp_end_pad_medium = 0.5

"Class Pruner End Pad Medium"

Definition at line 197 of file intproto.cpp.

double classify_cp_end_pad_tight = 0.5

"Class Pruner End Pad Tight"

Definition at line 198 of file intproto.cpp.

double classify_cp_side_pad_loose = 2.5

"Class Pruner Side Pad Loose"

Definition at line 199 of file intproto.cpp.

double classify_cp_side_pad_medium = 1.2

"Class Pruner Side Pad Medium"

Definition at line 200 of file intproto.cpp.

double classify_cp_side_pad_tight = 0.6

"Class Pruner Side Pad Tight"

Definition at line 201 of file intproto.cpp.

int classify_num_cp_levels = 3

"Number of Class Pruner Levels"

Definition at line 189 of file intproto.cpp.

double classify_pp_angle_pad = 45.0

"Proto Pruner Angle Pad"

Definition at line 202 of file intproto.cpp.

double classify_pp_end_pad = 0.5

"Proto Prune End Pad"

Definition at line 203 of file intproto.cpp.

double classify_pp_side_pad = 2.5

"Proto Pruner Side Pad"

Definition at line 204 of file intproto.cpp.

ScrollView* FeatureDisplayWindow = NULL

Definition at line 181 of file intproto.cpp.

ScrollView* IntMatchWindow = NULL

Definition at line 180 of file intproto.cpp.

ScrollView* ProtoDisplayWindow = NULL

Definition at line 182 of file intproto.cpp.

Classes

Namespaces

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation