#include "bitvec.h"
#include "params.h"
#include "unichar.h"
#include "unicity_table.h"

Classes
struct	PROTO_STRUCT

struct	CLASS_STRUCT

Macros
#define	NUMBER_OF_CLASSES MAX_NUM_CLASSES

#define	Y_OFFSET -40.0

#define	FEATURE_SCALE 100.0

#define	AddProtoToConfig(Pid, Config) (SET_BIT(Config, Pid))

#define	RemoveProtoFromConfig(Pid, Config) (reset_bit(Config, Pid))

#define	ClassOfChar(Char) ((TrainingData[Char].NumProtos) ? (&TrainingData[Char]) : NO_CLASS)

#define	ProtoIn(Class, Pid) (&(Class)->Prototypes[Pid])

#define	PrintProto(Proto)

#define	PrintProtoLine(Proto) (cprintf("A=%4.2f, B=%4.2f, C=%4.2f", Proto->A, Proto->B, Proto->C))

Typedefs
using	CONFIGS = BIT_VECTOR *

using	PROTO = PROTO_STRUCT *

using	CLASS_TYPE = CLASS_STRUCT *

using	CLASSES = CLASS_STRUCT *

Functions
int	AddConfigToClass (CLASS_TYPE Class)

int	AddProtoToClass (CLASS_TYPE Class)

float	ClassConfigLength (CLASS_TYPE Class, BIT_VECTOR Config)

float	ClassProtoLength (CLASS_TYPE Class)

void	CopyProto (PROTO Src, PROTO Dest)

void	FillABC (PROTO Proto)

void	FreeClass (CLASS_TYPE Class)

void	FreeClassFields (CLASS_TYPE Class)

void	InitPrototypes ()

CLASS_TYPE	NewClass (int NumProtos, int NumConfigs)

void	PrintProtos (CLASS_TYPE Class)

Variables
CLASS_STRUCT	TrainingData []

char *	classify_training_file = "MicroFeatures"

Macro Definition Documentation

◆ AddProtoToConfig

#define AddProtoToConfig	(	Pid,
		Config
	)	(SET_BIT(Config, Pid))

AddProtoToConfig

Set a single proto bit in the specified configuration.

Definition at line 95 of file protos.h.

◆ ClassOfChar

#define ClassOfChar ( Char ) ((TrainingData[Char].NumProtos) ? (&TrainingData[Char]) : NO_CLASS)

ClassOfChar

Return the class of a particular ASCII character value.

Definition at line 111 of file protos.h.

◆ FEATURE_SCALE

#define FEATURE_SCALE 100.0

Definition at line 77 of file protos.h.

◆ NUMBER_OF_CLASSES

#define NUMBER_OF_CLASSES MAX_NUM_CLASSES

Definition at line 75 of file protos.h.

◆ PrintProto

#define PrintProto ( Proto )

Value:

(tprintf("X=%4.2f, Y=%4.2f, Length=%4.2f, Angle=%4.2f", Proto->X, Proto->Y, \

Proto->Length, Proto->Angle))

tprintf

DLLSYM void tprintf(const char *format,...)

Definition: tprintf.cpp:37

PrintProto

Print out the contents of a prototype. The 'Proto' argument is of type 'PROTO'.

Definition at line 130 of file protos.h.

◆ PrintProtoLine

#define PrintProtoLine ( Proto ) (cprintf("A=%4.2f, B=%4.2f, C=%4.2f", Proto->A, Proto->B, Proto->C))

PrintProtoLine

Print out the contents of a prototype. The 'Proto' argument is of type 'PROTO'.

Definition at line 141 of file protos.h.

◆ ProtoIn

#define ProtoIn	(	Class,
		Pid
	)	(&(Class)->Prototypes[Pid])

ProtoIn

Choose the selected prototype in this class record. Return the pointer to it (type PROTO).

Definition at line 121 of file protos.h.

◆ RemoveProtoFromConfig

#define RemoveProtoFromConfig	(	Pid,
		Config
	)	(reset_bit(Config, Pid))

RemoveProtoFromConfig

Clear a single proto bit in the specified configuration.

Definition at line 103 of file protos.h.

◆ Y_OFFSET

#define Y_OFFSET -40.0

Definition at line 76 of file protos.h.

Typedef Documentation

◆ CLASS_TYPE

using CLASS_TYPE = CLASS_STRUCT*

Definition at line 69 of file protos.h.

◆ CLASSES

using CLASSES = CLASS_STRUCT*

Definition at line 70 of file protos.h.

◆ CONFIGS

using CONFIGS = BIT_VECTOR*

Definition at line 40 of file protos.h.

◆ PROTO

using PROTO = PROTO_STRUCT*

Definition at line 51 of file protos.h.

Function Documentation

◆ AddConfigToClass()

int AddConfigToClass ( CLASS_TYPE Class )

Definition at line 60 of file protos.cpp.

                                        {
   int NewNumConfigs;
   int NewConfig;
   int MaxNumProtos;
   BIT_VECTOR Config;
 
   MaxNumProtos = Class->MaxNumProtos;
 
   if (Class->NumConfigs >= Class->MaxNumConfigs) {
     /* add configs in CONFIG_INCREMENT chunks at a time */
     NewNumConfigs = (((Class->MaxNumConfigs + CONFIG_INCREMENT) /
       CONFIG_INCREMENT) * CONFIG_INCREMENT);
 
     Class->Configurations =
       (CONFIGS) Erealloc (Class->Configurations,
       sizeof (BIT_VECTOR) * NewNumConfigs);
 
     Class->MaxNumConfigs = NewNumConfigs;
   }
   NewConfig = Class->NumConfigs++;
   Config = NewBitVector (MaxNumProtos);
   Class->Configurations[NewConfig] = Config;
   zero_all_bits (Config, WordsInVectorOfSize (MaxNumProtos));
 
   return (NewConfig);
 }

◆ AddProtoToClass()

int AddProtoToClass ( CLASS_TYPE Class )

Definition at line 96 of file protos.cpp.

                                       {
   int i;
   int Bit;
   int NewNumProtos;
   int NewProto;
   BIT_VECTOR Config;
 
   if (Class->NumProtos >= Class->MaxNumProtos) {
     /* add protos in PROTO_INCREMENT chunks at a time */
     NewNumProtos = (((Class->MaxNumProtos + PROTO_INCREMENT) /
       PROTO_INCREMENT) * PROTO_INCREMENT);
 
     Class->Prototypes = (PROTO) Erealloc (Class->Prototypes,
       sizeof (PROTO_STRUCT) *
       NewNumProtos);
 
     Class->MaxNumProtos = NewNumProtos;
 
     for (i = 0; i < Class->NumConfigs; i++) {
       Config = Class->Configurations[i];
       Class->Configurations[i] = ExpandBitVector (Config, NewNumProtos);
 
       for (Bit = Class->NumProtos; Bit < NewNumProtos; Bit++)
         reset_bit(Config, Bit);
     }
   }
   NewProto = Class->NumProtos++;
   if (Class->NumProtos > MAX_NUM_PROTOS) {
     tprintf("Ouch! number of protos = %d, vs max of %d!",
             Class->NumProtos, MAX_NUM_PROTOS);
   }
   return (NewProto);
 }

◆ ClassConfigLength()

float ClassConfigLength	(	CLASS_TYPE	Class,
		BIT_VECTOR	Config
	)

Definition at line 139 of file protos.cpp.

                                                              {
   int16_t Pid;
   float TotalLength = 0;
 
   for (Pid = 0; Pid < Class->NumProtos; Pid++) {
     if (test_bit (Config, Pid)) {
 
       TotalLength += (ProtoIn (Class, Pid))->Length;
     }
   }
   return (TotalLength);
 }

◆ ClassProtoLength()

float ClassProtoLength ( CLASS_TYPE Class )

Definition at line 160 of file protos.cpp.

                                          {
   int16_t Pid;
   float TotalLength = 0;
 
   for (Pid = 0; Pid < Class->NumProtos; Pid++) {
     TotalLength += (ProtoIn (Class, Pid))->Length;
   }
   return (TotalLength);
 }

◆ CopyProto()

void CopyProto	(	PROTO	Src,
		PROTO	Dest
	)

Definition at line 179 of file protos.cpp.

                                       {
   Dest->X = Src->X;
   Dest->Y = Src->Y;
   Dest->Length = Src->Length;
   Dest->Angle = Src->Angle;
   Dest->A = Src->A;
   Dest->B = Src->B;
   Dest->C = Src->C;
 }

◆ FillABC()

void FillABC ( PROTO Proto )

Definition at line 195 of file protos.cpp.

                           {
   float Slope, Intercept, Normalizer;
 
   Slope = tan(Proto->Angle * 2.0 * M_PI);
   Intercept = Proto->Y - Slope * Proto->X;
   Normalizer = 1.0 / sqrt (Slope * Slope + 1.0);
   Proto->A = Slope * Normalizer;
   Proto->B = -Normalizer;
   Proto->C = Intercept * Normalizer;
 }

◆ FreeClass()

void FreeClass ( CLASS_TYPE Class )

Definition at line 212 of file protos.cpp.

                                  {
   if (Class) {
     FreeClassFields(Class);
     delete Class;
   }
 }

◆ FreeClassFields()

void FreeClassFields ( CLASS_TYPE Class )

Definition at line 225 of file protos.cpp.

                                        {
   int i;
 
   if (Class) {
     if (Class->MaxNumProtos > 0) free(Class->Prototypes);
     if (Class->MaxNumConfigs > 0) {
       for (i = 0; i < Class->NumConfigs; i++)
         FreeBitVector (Class->Configurations[i]);
       free(Class->Configurations);
     }
   }
 }

◆ InitPrototypes()

void InitPrototypes ( )

◆ NewClass()

CLASS_TYPE NewClass	(	int	NumProtos,
		int	NumConfigs
	)

Definition at line 244 of file protos.cpp.

                                                    {
   CLASS_TYPE Class;
 
   Class = new CLASS_STRUCT;
 
   if (NumProtos > 0)
     Class->Prototypes = (PROTO) Emalloc (NumProtos * sizeof (PROTO_STRUCT));
 
   if (NumConfigs > 0)
     Class->Configurations = (CONFIGS) Emalloc (NumConfigs *
       sizeof (BIT_VECTOR));
   Class->MaxNumProtos = NumProtos;
   Class->MaxNumConfigs = NumConfigs;
   Class->NumProtos = 0;
   Class->NumConfigs = 0;
   return (Class);
 
 }

◆ PrintProtos()

void PrintProtos ( CLASS_TYPE Class )

Definition at line 269 of file protos.cpp.

                                    {
   int16_t Pid;
 
   for (Pid = 0; Pid < Class->NumProtos; Pid++) {
     cprintf ("Proto %d:\t", Pid);
     PrintProto (ProtoIn (Class, Pid));
     cprintf ("\t");
     PrintProtoLine (ProtoIn (Class, Pid));
     tprintf("\n");
   }
 }

Variable Documentation

◆ classify_training_file

char* classify_training_file = "MicroFeatures"

"Training file"

Definition at line 47 of file protos.cpp.

◆ TrainingData

CLASS_STRUCT TrainingData[]

Definition at line 45 of file protos.cpp.

Classes

Macros

Typedefs

Functions

Variables