intproto.cpp File Reference

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cassert>
#include "classify.h"
#include "callcpp.h"
#include "emalloc.h"
#include "fontinfo.h"
#include <tesseract/genericvector.h>
#include <tesseract/helpers.h>
#include "intproto.h"
#include "mfoutline.h"
#include "picofeat.h"
#include "points.h"
#include "shapetable.h"
#include "svmnode.h"

Go to the source code of this file.

Classes
struct	FILL_SWITCH
struct	TABLE_FILLER
struct	FILL_SPEC

Namespaces
	tesseract

Macros
#define	_USE_MATH_DEFINES
#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)   (std::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
float	BucketStart (int Bucket, float Offset, int NumBuckets)
float	BucketEnd (int Bucket, float Offset, int NumBuckets)
void	DoFill (FILL_SPEC *FillSpec, CLASS_PRUNER_STRUCT *Pruner, uint32_t ClassMask, uint32_t ClassCount, uint32_t WordIndex)
bool	FillerDone (TABLE_FILLER *Filler)
void	FillPPCircularBits (uint32_t ParamTable[NUM_PP_BUCKETS][WERDS_PER_PP_VECTOR], int Bit, float Center, float Spread, bool debug)
void	FillPPLinearBits (uint32_t ParamTable[NUM_PP_BUCKETS][WERDS_PER_PP_VECTOR], int Bit, float Center, float Spread, bool debug)
void	GetCPPadsForLevel (int Level, float *EndPad, float *SidePad, float *AnglePad)
ScrollView::Color	GetMatchColorFor (float Evidence)
void	GetNextFill (TABLE_FILLER *Filler, FILL_SPEC *Fill)
void	InitTableFiller (float EndPad, float SidePad, float 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 (float 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)
uint8_t	Bucket8For (float param, float offset, int num_buckets)
uint16_t	Bucket16For (float param, float offset, int num_buckets)
uint8_t	CircBucketFor (float param, float offset, int num_buckets)
void	UpdateMatchDisplay ()
void	ConvertConfig (BIT_VECTOR Config, int ConfigId, INT_CLASS Class)
void	DisplayIntFeature (const INT_FEATURE_STRUCT *Feature, float Evidence)
void	DisplayIntProto (INT_CLASS Class, PROTO_ID ProtoId, float Evidence)
INT_CLASS	NewIntClass (int MaxNumProtos, int MaxNumConfigs)
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)

Macro Definition Documentation

_USE_MATH_DEFINES

#define _USE_MATH_DEFINES

Definition at line 20 of file intproto.cpp.

AS

#define AS   ANGLE_SHIFT

CircularIncrement

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

macro for performing circular increments of bucket indices

Definition at line 115 of file intproto.cpp.

HV_TOLERANCE

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

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

Definition at line 64 of file intproto.cpp.

INT_BASELINE

#define INT_BASELINE   (0.25 * INT_CHAR_NORM_RANGE)

Definition at line 50 of file intproto.cpp.

INT_CAPHEIGHT

#define INT_CAPHEIGHT   (1.0 * INT_CHAR_NORM_RANGE)

Definition at line 52 of file intproto.cpp.

INT_DESCENDER

#define INT_DESCENDER   (0.0 * INT_CHAR_NORM_RANGE)

Definition at line 49 of file intproto.cpp.

INT_MAX_X

#define INT_MAX_X   INT_CHAR_NORM_RANGE

Definition at line 60 of file intproto.cpp.

INT_MAX_Y

#define INT_MAX_Y   INT_CHAR_NORM_RANGE

Definition at line 61 of file intproto.cpp.

INT_MIN_X

#define INT_MIN_X   0

Definition at line 58 of file intproto.cpp.

INT_MIN_Y

#define INT_MIN_Y   0

Definition at line 59 of file intproto.cpp.

INT_XCENTER

#define INT_XCENTER   (0.5 * INT_CHAR_NORM_RANGE)

Definition at line 54 of file intproto.cpp.

INT_XHEIGHT

#define INT_XHEIGHT   (0.75 * INT_CHAR_NORM_RANGE)

Definition at line 51 of file intproto.cpp.

INT_XRADIUS

#define INT_XRADIUS   (0.2 * INT_CHAR_NORM_RANGE)

Definition at line 56 of file intproto.cpp.

INT_YCENTER

#define INT_YCENTER   (0.5 * INT_CHAR_NORM_RANGE)

Definition at line 55 of file intproto.cpp.

INT_YRADIUS

#define INT_YRADIUS   (0.2 * INT_CHAR_NORM_RANGE)

Definition at line 57 of file intproto.cpp.

MapParam

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

macro for mapping floats to ints without bounds checking

Definition at line 118 of file intproto.cpp.

MAX_LEVEL

#define MAX_LEVEL   2

MAX_NUM_SWITCHES

#define MAX_NUM_SWITCHES   3

Definition at line 69 of file intproto.cpp.

NB

#define NB   NUM_CP_BUCKETS

OLD_MAX_NUM_CONFIGS

#define OLD_MAX_NUM_CONFIGS   32

Definition at line 107 of file intproto.cpp.

OLD_WERDS_PER_CONFIG_VEC

#define OLD_WERDS_PER_CONFIG_VEC

Value:

((OLD_MAX_NUM_CONFIGS + BITS_PER_WERD - 1) /\
                                  BITS_PER_WERD)

Definition at line 108 of file intproto.cpp.

PROTO_PRUNER_SCALE

#define PROTO_PRUNER_SCALE   (4.0)

Definition at line 47 of file intproto.cpp.

XS

#define XS   X_SHIFT

YS

#define YS   Y_SHIFT

Enumeration Type Documentation

SWITCH_TYPE

enum SWITCH_TYPE

Enumerator
StartSwitch
EndSwitch
LastSwitch

Definition at line 66 of file intproto.cpp.

{ StartSwitch, EndSwitch, LastSwitch }

Function Documentation

AddIntClass()

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

Definition at line 230 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));
  }

AddIntConfig()

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.

Definition at line 260 of file intproto.cpp.

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

AddIntProto()

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.

Definition at line 281 of file intproto.cpp.

                                 {
  int Index;
  int ProtoSetId;
  PROTO_SET ProtoSet;
  INT_PROTO Proto;
  uint32_t *Word;
 
  if (Class->NumProtos >= MAX_NUM_PROTOS)
    return (NO_PROTO);
 
  Index = Class->NumProtos++;
 
  if (Class->NumProtos > MaxNumIntProtosIn(Class)) {
    ProtoSetId = Class->NumProtoSets++;
 
    ProtoSet = static_cast<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 =
      static_cast<uint8_t *>(Erealloc(Class->ProtoLengths,
                        MaxNumIntProtosIn(Class) * sizeof(uint8_t)));
    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);

AddProtoToClassPruner()

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

This routine adds Proto to the class pruning tables for the specified class in Templates.

Globals:

• classify_num_cp_levels number of levels used in the class pruner

  Parameters

  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 327 of file intproto.cpp.

{
  CLASS_PRUNER_STRUCT* Pruner;
  uint32_t ClassMask;
  uint32_t ClassCount;
  uint32_t WordIndex;
  int Level;
  float 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);
    }
  }

AddProtoToProtoPruner()

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

This routine updates the proto pruner lookup tables for Class to include a new proto identified by ProtoId and described by Proto.

Parameters

Proto	floating-pt proto to be added to proto pruner
ProtoId	id of proto
Class	integer class that contains desired proto pruner
debug	debug flag

Note

Globals: none

Definition at line 366 of file intproto.cpp.

                                                        {
  float Angle, X, Y, Length;
  float 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(!std::isnan(Angle));
#endif
 
  FillPPCircularBits (ProtoSet->ProtoPruner[PRUNER_ANGLE], Index,
                      Angle + ANGLE_SHIFT, classify_pp_angle_pad / 360.0,
                      debug);
 
  Angle *= 2.0 * M_PI;
  Length = Proto->Length;
 
  X = Proto->X + X_SHIFT;
  Pad = std::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 = std::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);

Bucket16For()

uint16_t Bucket16For	(	float	param,
		float	offset,
		int	num_buckets
	)

Definition at line 421 of file intproto.cpp.

                                                                 {
  int bucket = IntCastRounded(MapParam(param, offset, num_buckets));
  return static_cast<uint16_t>(ClipToRange<int>(bucket, 0, num_buckets - 1));

Bucket8For()

uint8_t Bucket8For	(	float	param,
		float	offset,
		int	num_buckets
	)

Returns a quantized bucket for the given param shifted by offset, notionally (param + offset) * num_buckets, but clipped and casted to the appropriate type.

Definition at line 417 of file intproto.cpp.

                                                               {
  int bucket = IntCastRounded(MapParam(param, offset, num_buckets));
  return static_cast<uint8_t>(ClipToRange<int>(bucket, 0, num_buckets - 1));

BucketEnd()

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

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.

Parameters

Bucket	bucket whose end is to be computed
Offset	offset used to map params to buckets
NumBuckets	total number of buckets

Returns

Param value corresponding to end position of Bucket.

Note

Globals: none

Definition at line 1109 of file intproto.cpp.

                                                          {
  return ((static_cast<float>(Bucket + 1) / NumBuckets) - Offset);

BucketStart()

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

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.

Parameters

Bucket	bucket whose start is to be computed
Offset	offset used to map params to buckets
NumBuckets	total number of buckets

Returns

Param value corresponding to start position of Bucket.

Note

Globals: none

Definition at line 1093 of file intproto.cpp.

                                                            {
  return ((static_cast<float>(Bucket) / NumBuckets) - Offset);
 

CircBucketFor()

uint8_t CircBucketFor	(	float	param,
		float	offset,
		int	num_buckets
	)

Returns a quantized bucket for the given circular param shifted by offset, notionally (param + offset) * num_buckets, but modded and casted to the appropriate type.

Definition at line 431 of file intproto.cpp.

                                                                  {
  int bucket = IntCastRounded(MapParam(param, offset, num_buckets));
  return static_cast<uint8_t>(Modulo(bucket, num_buckets));

ConvertConfig()

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

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.

Parameters

Config	config to be added to class
ConfigId	id to be used for new config
Class	class to add new config to

Definition at line 462 of file intproto.cpp.

                                                                     {
  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;

CreateFeatureSpaceWindow()

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

Creates a window of the appropriate size for displaying elements in feature space.

Definition at line 1764 of file intproto.cpp.

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

DisplayIntFeature()

void DisplayIntFeature	(	const INT_FEATURE_STRUCT *	Feature,
		float	Evidence
	)

This routine renders the specified feature into a global display list.

Globals:

• FeatureShapes global display list for features

  Parameters

  Feature	pico-feature to be displayed
  Evidence	best evidence for this feature (0-1)

Definition at line 589 of file intproto.cpp.

                                                                          {
  ScrollView::Color color = GetMatchColorFor(Evidence);
  RenderIntFeature(IntMatchWindow, Feature, color);
  if (FeatureDisplayWindow) {
    RenderIntFeature(FeatureDisplayWindow, Feature, color);
  }

DisplayIntProto()

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

This routine renders the specified proto into a global display list.

Globals:

• ProtoShapes global display list for protos

  Parameters

  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 607 of file intproto.cpp.

                                                                        {
  ScrollView::Color color = GetMatchColorFor(Evidence);
  RenderIntProto(IntMatchWindow, Class, ProtoId, color);
  if (ProtoDisplayWindow) {
    RenderIntProto(ProtoDisplayWindow, Class, ProtoId, color);
  }

DoFill()

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

This routine fills in the section of a class pruner corresponding to a single x value for a single proto of a class.

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

Definition at line 1123 of file intproto.cpp.

                                {
  int X, Y, Angle;
  uint32_t 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; ;
         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;
    }

FillerDone()

bool FillerDone

(

TABLE_FILLER *

Filler

)

Return true if the specified table filler is done, i.e. if it has no more lines to fill.

Parameters

Filler

table filler to check if done

Returns

true if no more lines to fill, false otherwise.

Note

Globals: none

Definition at line 1163 of file intproto.cpp.

                                      {
  FILL_SWITCH *Next;
 
  Next = &(Filler->Switch[Filler->NextSwitch]);
 
  return Filler->X > Next->X && Next->Type == LastSwitch;
 

FillPPCircularBits()

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

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.

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
debug	debug flag

Definition at line 1185 of file intproto.cpp.

                                                                         {
  int i, FirstBucket, LastBucket;
 
  if (Spread > 0.5)
    Spread = 0.5;
 
  FirstBucket = static_cast<int>(std::floor((Center - Spread) * NUM_PP_BUCKETS));
  if (FirstBucket < 0)
    FirstBucket += NUM_PP_BUCKETS;
 
  LastBucket = static_cast<int>(std::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;
  }
 

FillPPLinearBits()

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

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.

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
debug	debug flag

Definition at line 1224 of file intproto.cpp.

                                                                       {
  int i, FirstBucket, LastBucket;
 
  FirstBucket = static_cast<int>(std::floor((Center - Spread) * NUM_PP_BUCKETS));
  if (FirstBucket < 0)
    FirstBucket = 0;
 
  LastBucket = static_cast<int>(std::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);
 

free_int_templates()

void free_int_templates

(

INT_TEMPLATES

templates

)

Definition at line 697 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);

GetCPPadsForLevel()

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

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.

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

Definition at line 1332 of file intproto.cpp.

                                        {
  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;
 

GetMatchColorFor()

ScrollView::Color GetMatchColorFor

(

float

Evidence

)

Parameters

Evidence

evidence value to return color for

Returns

Color which corresponds to specified Evidence value.

Note

Globals: none

Definition at line 1371 of file intproto.cpp.

                                                 {
  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;

GetNextFill()

void GetNextFill	(	TABLE_FILLER *	Filler,
		FILL_SPEC *	Fill
	)

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.

Parameters

Filler	filler to get next fill spec from
Fill	place to put spec for next fill

Definition at line 1393 of file intproto.cpp.

                                                        {
  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;
 

InitFeatureDisplayWindowIfReqd()

void InitFeatureDisplayWindowIfReqd

(

)

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

Definition at line 1755 of file intproto.cpp.

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

InitIntMatchWindowIfReqd()

void InitIntMatchWindowIfReqd

(

)

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

Definition at line 1723 of file intproto.cpp.

                                {
  if (IntMatchWindow == nullptr) {
    IntMatchWindow = CreateFeatureSpaceWindow("IntMatchWindow", 50, 200);
    auto* 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);
  }

InitProtoDisplayWindowIfReqd()

void InitProtoDisplayWindowIfReqd

(

)

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

Definition at line 1744 of file intproto.cpp.

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

InitTableFiller()

void InitTableFiller	(	float	EndPad,
		float	SidePad,
		float	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. Results are returned in Filler.

Parameters

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

Definition at line 1440 of file intproto.cpp.

{
  float Angle;
  float X, Y, HalfLength;
  float Cos, Sin;
  float 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 = Bucket8For(X - HalfLength - EndPad, XS, NB);
    Filler->YStart = Bucket16For(Y - SidePad, YS, NB * 256);
    Filler->YEnd = Bucket16For(Y + SidePad, YS, NB * 256);
    Filler->StartDelta = 0;
    Filler->EndDelta = 0;
    Filler->Switch[0].Type = LastSwitch;
    Filler->Switch[0].X = Bucket8For(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 = Bucket8For(X - SidePad, XS, NB);
    Filler->YStart = Bucket16For(Y - HalfLength - EndPad, YS, NB * 256);
    Filler->YEnd = Bucket16For(Y + HalfLength + EndPad, YS, NB * 256);
    Filler->StartDelta = 0;
    Filler->EndDelta = 0;
    Filler->Switch[0].Type = LastSwitch;
    Filler->Switch[0].X = Bucket8For(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 * M_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 = Bucket8For(Start.x, XS, NB);
      Filler->StartDelta = -static_cast<int16_t>((Cos / Sin) * 256);
      Filler->EndDelta = static_cast<int16_t>((Sin / Cos) * 256);
 
      XAdjust = BucketEnd(Filler->X, XS, NB) - Start.x;
      YAdjust = XAdjust * Cos / Sin;
      Filler->YStart = Bucket16For(Start.y - YAdjust, YS, NB * 256);
      YAdjust = XAdjust * Sin / Cos;
      Filler->YEnd = Bucket16For(Start.y + YAdjust, YS, NB * 256);
 
      Filler->Switch[S1].Type = StartSwitch;
      Filler->Switch[S1].X = Bucket8For(Switch1.x, XS, NB);
      Filler->Switch[S1].Y = Bucket8For(Switch1.y, YS, NB);
      XAdjust = Switch1.x - BucketStart(Filler->Switch[S1].X, XS, NB);
      YAdjust = XAdjust * Sin / Cos;
      Filler->Switch[S1].YInit = Bucket16For(Switch1.y - YAdjust, YS, NB * 256);
      Filler->Switch[S1].Delta = Filler->EndDelta;
 
      Filler->Switch[S2].Type = EndSwitch;
      Filler->Switch[S2].X = Bucket8For(Switch2.x, XS, NB);
      Filler->Switch[S2].Y = Bucket8For(Switch2.y, YS, NB);
      XAdjust = Switch2.x - BucketStart(Filler->Switch[S2].X, XS, NB);
      YAdjust = XAdjust * Cos / Sin;
      Filler->Switch[S2].YInit = Bucket16For(Switch2.y + YAdjust, YS, NB * 256);
      Filler->Switch[S2].Delta = Filler->StartDelta;
 
      Filler->Switch[2].Type = LastSwitch;
      Filler->Switch[2].X = Bucket8For(End.x, XS, NB);
    } else {
      /* falling diagonal proto */
      Angle *= 2.0 * M_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 = Bucket8For(Start.x, XS, NB);
      Filler->StartDelta = static_cast<int16_t>(ClipToRange<int>(
          -IntCastRounded((Sin / Cos) * 256), INT16_MIN, INT16_MAX));
      Filler->EndDelta = static_cast<int16_t>(ClipToRange<int>(
          IntCastRounded((Cos / Sin) * 256), INT16_MIN, INT16_MAX));
 
      XAdjust = BucketEnd(Filler->X, XS, NB) - Start.x;
      YAdjust = XAdjust * Sin / Cos;
      Filler->YStart = Bucket16For(Start.y - YAdjust, YS, NB * 256);
      YAdjust = XAdjust * Cos / Sin;
      Filler->YEnd = Bucket16For(Start.y + YAdjust, YS, NB * 256);
 
      Filler->Switch[S1].Type = EndSwitch;
      Filler->Switch[S1].X = Bucket8For(Switch1.x, XS, NB);
      Filler->Switch[S1].Y = Bucket8For(Switch1.y, YS, NB);
      XAdjust = Switch1.x - BucketStart(Filler->Switch[S1].X, XS, NB);
      YAdjust = XAdjust * Sin / Cos;
      Filler->Switch[S1].YInit = Bucket16For(Switch1.y + YAdjust, YS, NB * 256);
      Filler->Switch[S1].Delta = Filler->StartDelta;
 
      Filler->Switch[S2].Type = StartSwitch;
      Filler->Switch[S2].X = Bucket8For(Switch2.x, XS, NB);
      Filler->Switch[S2].Y = Bucket8For(Switch2.y, YS, NB);
      XAdjust = Switch2.x - BucketStart(Filler->Switch[S2].X, XS, NB);
      YAdjust = XAdjust * Cos / Sin;
      Filler->Switch[S2].YInit = Bucket16For(Switch2.y - YAdjust, YS, NB * 256);
      Filler->Switch[S2].Delta = Filler->EndDelta;
 
      Filler->Switch[2].Type = LastSwitch;
      Filler->Switch[2].X = Bucket8For(End.x, XS, NB);
    }
  }

NewIntClass()

INT_CLASS NewIntClass	(	int	MaxNumProtos,
		int	MaxNumConfigs
	)

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.

Parameters

MaxNumProtos	number of protos to allocate space for
MaxNumConfigs	number of configs to allocate space for

Returns

New class created.

Note

Globals: none

Definition at line 625 of file intproto.cpp.

                                                           {
  INT_CLASS Class;
  PROTO_SET ProtoSet;
  int i;
 
  assert(MaxNumConfigs <= MAX_NUM_CONFIGS);
 
  Class = static_cast<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 = static_cast<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 =
      static_cast<uint8_t *>(Emalloc(MaxNumIntProtosIn (Class) * sizeof (uint8_t)));
    memset(Class->ProtoLengths, 0,
           MaxNumIntProtosIn(Class) * sizeof(*Class->ProtoLengths));
  } else {
    Class->ProtoLengths = nullptr;
  }
  memset(Class->ConfigLengths, 0, sizeof(Class->ConfigLengths));
 
  return (Class);
 

NewIntTemplates()

INT_TEMPLATES NewIntTemplates

(

)

This routine allocates a new set of integer templates initialized to hold 0 classes.

Returns

The integer templates created.

Note

Globals: none

Definition at line 681 of file intproto.cpp.

                                {
  INT_TEMPLATES T;
  int i;
 
  T = static_cast<INT_TEMPLATES>(Emalloc (sizeof (INT_TEMPLATES_STRUCT)));
  T->NumClasses = 0;
  T->NumClassPruners = 0;
 
  for (i = 0; i < MAX_NUM_CLASSES; i++)
    ClassForClassId (T, i) = nullptr;
 
  return (T);

RenderIntFeature()

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

This routine renders the specified feature into ShapeList.

Parameters

window	to add feature rendering to
Feature	feature to be rendered
color	color to use for feature rendering

Returns

New shape list with rendering of Feature added.

Note

Globals: none

Definition at line 1603 of file intproto.cpp.

                                             {
  float X, Y, Dx, Dy, Length;
 
  window->Pen(color);
  assert(Feature != nullptr);
  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 * M_PI - M_PI);
  Dy = (Length / 2.0) * sin((Feature->Theta / 256.0) * 2.0 * M_PI - M_PI);
 
  window->SetCursor(X, Y);
  window->DrawTo(X + Dx, Y + Dy);

RenderIntProto()

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

This routine extracts the parameters of the specified proto from the class description and adds a rendering of the proto onto the ShapeList.

Parameters

window	ScrollView instance
Class	class that proto is contained in
ProtoId	id of proto to be rendered
color	color to render proto in

Globals: none

Returns

New shape list with a rendering of one proto added.

Definition at line 1637 of file intproto.cpp.

                                           {
  PROTO_SET ProtoSet;
  INT_PROTO Proto;
  int ProtoSetIndex;
  int ProtoWordIndex;
  float Length;
  int Xmin, Xmax, Ymin, Ymax;
  float X, Y, Dx, Dy;
  uint32_t ProtoMask;
  int Bucket;
 
  assert(ProtoId >= 0);
  assert(Class != nullptr);
  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 * M_PI - M_PI);
  Dy = (Length / 2.0) * sin((Proto->Angle / 256.0) * 2.0 * M_PI - M_PI);
 
  window->SetCursor(X - Dx, Y - Dy);
  window->DrawTo(X + Dx, Y + Dy);

TruncateParam()

int TruncateParam	(	float	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.

Definition at line 1702 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>(std::floor(Param));

UpdateMatchDisplay()

void UpdateMatchDisplay

(

)

This routine clears the global feature and proto display lists.

Globals:

• FeatureShapes display list for features
• ProtoShapes display list for protos

Definition at line 446 of file intproto.cpp.

                          {
  if (IntMatchWindow != nullptr)
    IntMatchWindow->Update();