#include <cstdio>
#include "intproto.h"
#include "oldlist.h"

Classes
struct	TEMP_PROTO_STRUCT

struct	TEMP_CONFIG_STRUCT

struct	PERM_CONFIG_STRUCT

union	ADAPTED_CONFIG

struct	ADAPT_CLASS_STRUCT

struct	ADAPT_TEMPLATES_STRUCT

Macros
#define	NumNonEmptyClassesIn(Template) ((Template)->NumNonEmptyClasses)

#define	IsEmptyAdaptedClass(Class) ((Class)->NumPermConfigs == 0 && (Class)->TempProtos == NIL_LIST)

#define	ConfigIsPermanent(Class, ConfigId) (test_bit((Class)->PermConfigs, ConfigId))

#define	MakeConfigPermanent(Class, ConfigId) (SET_BIT((Class)->PermConfigs, ConfigId))

#define	MakeProtoPermanent(Class, ProtoId) (SET_BIT((Class)->PermProtos, ProtoId))

#define	TempConfigFor(Class, ConfigId) ((Class)->Config[ConfigId].Temp)

#define	PermConfigFor(Class, ConfigId) ((Class)->Config[ConfigId].Perm)

#define	IncreaseConfidence(TempConfig) ((TempConfig)->NumTimesSeen++)

Typedefs
using	TEMP_PROTO = TEMP_PROTO_STRUCT *

using	TEMP_CONFIG = TEMP_CONFIG_STRUCT *

using	PERM_CONFIG = PERM_CONFIG_STRUCT *

using	ADAPT_CLASS = ADAPT_CLASS_STRUCT *

using	ADAPT_TEMPLATES = ADAPT_TEMPLATES_STRUCT *

Functions
void	AddAdaptedClass (ADAPT_TEMPLATES Templates, ADAPT_CLASS Class, CLASS_ID ClassId)

void	FreeTempProto (void *arg)

void	FreeTempConfig (TEMP_CONFIG Config)

ADAPT_CLASS	NewAdaptedClass ()

void	free_adapted_class (ADAPT_CLASS adapt_class)

void	free_adapted_templates (ADAPT_TEMPLATES templates)

TEMP_CONFIG	NewTempConfig (int MaxProtoId, int FontinfoId)

TEMP_PROTO	NewTempProto ()

ADAPT_CLASS	ReadAdaptedClass (tesseract::TFile *File)

PERM_CONFIG	ReadPermConfig (tesseract::TFile *File)

TEMP_CONFIG	ReadTempConfig (tesseract::TFile *File)

void	WriteAdaptedClass (FILE *File, ADAPT_CLASS Class, int NumConfigs)

void	WritePermConfig (FILE *File, PERM_CONFIG Config)

void	WriteTempConfig (FILE *File, TEMP_CONFIG Config)

Macro Definition Documentation

#define ConfigIsPermanent	(	Class,
		ConfigId
	)	(test_bit((Class)->PermConfigs, ConfigId))

Definition at line 85 of file adaptive.h.

#define IncreaseConfidence ( TempConfig ) ((TempConfig)->NumTimesSeen++)

Definition at line 98 of file adaptive.h.

#define IsEmptyAdaptedClass ( Class ) ((Class)->NumPermConfigs == 0 && (Class)->TempProtos == NIL_LIST)

Definition at line 82 of file adaptive.h.

#define MakeConfigPermanent	(	Class,
		ConfigId
	)	(SET_BIT((Class)->PermConfigs, ConfigId))

Definition at line 88 of file adaptive.h.

#define MakeProtoPermanent	(	Class,
		ProtoId
	)	(SET_BIT((Class)->PermProtos, ProtoId))

Definition at line 91 of file adaptive.h.

#define NumNonEmptyClassesIn ( Template ) ((Template)->NumNonEmptyClasses)

Definition at line 80 of file adaptive.h.

#define PermConfigFor	(	Class,
		ConfigId
	)	((Class)->Config[ConfigId].Perm)

Definition at line 96 of file adaptive.h.

#define TempConfigFor	(	Class,
		ConfigId
	)	((Class)->Config[ConfigId].Temp)

Definition at line 94 of file adaptive.h.

Typedef Documentation

using ADAPT_CLASS = ADAPT_CLASS_STRUCT*

Definition at line 66 of file adaptive.h.

using ADAPT_TEMPLATES = ADAPT_TEMPLATES_STRUCT*

Definition at line 75 of file adaptive.h.

using PERM_CONFIG = PERM_CONFIG_STRUCT*

Definition at line 50 of file adaptive.h.

using TEMP_CONFIG = TEMP_CONFIG_STRUCT*

Definition at line 44 of file adaptive.h.

using TEMP_PROTO = TEMP_PROTO_STRUCT*

Definition at line 35 of file adaptive.h.

Function Documentation

void AddAdaptedClass	(	ADAPT_TEMPLATES	Templates,
		ADAPT_CLASS	Class,
		CLASS_ID	ClassId
	)

This routine adds a new adapted class to an existing set of adapted templates.

Parameters

Templates	set of templates to add new class to
Class	new class to add to templates
ClassId	class id to associate with new class

Note: Globals: none

Definition at line 45 of file adaptive.cpp.

                                        {
   INT_CLASS IntClass;
 
   assert (Templates != nullptr);
   assert (Class != nullptr);
   assert (LegalClassId (ClassId));
   assert (UnusedClassIdIn (Templates->Templates, ClassId));
   assert (Class->NumPermConfigs == 0);
 
   IntClass = NewIntClass (1, 1);
   AddIntClass (Templates->Templates, ClassId, IntClass);
 
   assert (Templates->Class[ClassId] == nullptr);
   Templates->Class[ClassId] = Class;
 
 }                                /* AddAdaptedClass */

void free_adapted_class ( ADAPT_CLASS adapt_class )

Definition at line 124 of file adaptive.cpp.

                                                  {
   for (int i = 0; i < MAX_NUM_CONFIGS; i++) {
     if (ConfigIsPermanent (adapt_class, i)
       && PermConfigFor (adapt_class, i) != nullptr)
       FreePermConfig (PermConfigFor (adapt_class, i));
     else if (!ConfigIsPermanent (adapt_class, i)
       && TempConfigFor (adapt_class, i) != nullptr)
       FreeTempConfig (TempConfigFor (adapt_class, i));
   }
   FreeBitVector (adapt_class->PermProtos);
   FreeBitVector (adapt_class->PermConfigs);
   destroy_nodes (adapt_class->TempProtos, FreeTempProto);
   Efree(adapt_class);
 }

void free_adapted_templates ( ADAPT_TEMPLATES templates )

Definition at line 182 of file adaptive.cpp.

                                                        {
 
   if (templates != nullptr) {
     for (int i = 0; i < (templates->Templates)->NumClasses; i++)
       free_adapted_class (templates->Class[i]);
     free_int_templates (templates->Templates);
     Efree(templates);
   }
 }

void FreeTempConfig ( TEMP_CONFIG Config )

This routine frees all memory consumed by a temporary configuration.

Parameters

Config config to be freed

Note: Globals: none

Definition at line 74 of file adaptive.cpp.

                                         {
   assert (Config != nullptr);
   FreeBitVector (Config->Protos);
   free(Config);
 }                                /* FreeTempConfig */

void FreeTempProto ( void * arg )

Definition at line 81 of file adaptive.cpp.

                               {
   auto proto = static_cast<PROTO>(arg);
 
   free(proto);
 }

ADAPT_CLASS NewAdaptedClass ( )

This operation allocates and initializes a new adapted class data structure and returns a ptr to it.

Returns: Ptr to new class data structure.

Note: Globals: none

Definition at line 102 of file adaptive.cpp.

                               {
   ADAPT_CLASS Class;
 
   Class = static_cast<ADAPT_CLASS>(Emalloc (sizeof (ADAPT_CLASS_STRUCT)));
   Class->NumPermConfigs = 0;
   Class->MaxNumTimesSeen = 0;
   Class->TempProtos = NIL_LIST;
 
   Class->PermProtos = NewBitVector (MAX_NUM_PROTOS);
   Class->PermConfigs = NewBitVector (MAX_NUM_CONFIGS);
   zero_all_bits (Class->PermProtos, WordsInVectorOfSize (MAX_NUM_PROTOS));
   zero_all_bits (Class->PermConfigs, WordsInVectorOfSize (MAX_NUM_CONFIGS));
 
   for (int i = 0; i < MAX_NUM_CONFIGS; i++)
     TempConfigFor (Class, i) = nullptr;
 
   return (Class);
 
 }                                /* NewAdaptedClass */

TEMP_CONFIG NewTempConfig	(	int	MaxProtoId,
		int	FontinfoId
	)

This routine allocates and returns a new temporary config.

Parameters

MaxProtoId	max id of any proto in new config
FontinfoId	font information from pre-trained templates

Returns: Ptr to new temp config.

Note: Globals: none

Definition at line 203 of file adaptive.cpp.

                                                           {
   int NumProtos = MaxProtoId + 1;
 
   auto Config = static_cast<TEMP_CONFIG>(malloc(sizeof(TEMP_CONFIG_STRUCT)));
   Config->Protos = NewBitVector (NumProtos);
 
   Config->NumTimesSeen = 1;
   Config->MaxProtoId = MaxProtoId;
   Config->ProtoVectorSize = WordsInVectorOfSize (NumProtos);
   zero_all_bits (Config->Protos, Config->ProtoVectorSize);
   Config->FontinfoId = FontinfoId;
 
   return (Config);
 
 }                                /* NewTempConfig */

TEMP_PROTO NewTempProto ( )

This routine allocates and returns a new temporary proto.

Returns: Ptr to new temporary proto.

Note: Globals: none

Definition at line 228 of file adaptive.cpp.

                           {
   return static_cast<TEMP_PROTO>(malloc(sizeof(TEMP_PROTO_STRUCT)));
 }                                /* NewTempProto */

ADAPT_CLASS ReadAdaptedClass ( TFile * fp )

Read an adapted class description from file and return a ptr to the adapted class.

Parameters

fp	open file to read adapted class from

Returns: Ptr to new adapted class.

Note: Globals: none

Definition at line 281 of file adaptive.cpp.

                                         {
   int NumTempProtos;
   int NumConfigs;
   int i;
   ADAPT_CLASS Class;
 
   /* first read high level adapted class structure */
   Class = static_cast<ADAPT_CLASS>(Emalloc (sizeof (ADAPT_CLASS_STRUCT)));
   fp->FRead(Class, sizeof(ADAPT_CLASS_STRUCT), 1);
 
   /* then read in the definitions of the permanent protos and configs */
   Class->PermProtos = NewBitVector (MAX_NUM_PROTOS);
   Class->PermConfigs = NewBitVector (MAX_NUM_CONFIGS);
   fp->FRead(Class->PermProtos, sizeof(uint32_t),
             WordsInVectorOfSize(MAX_NUM_PROTOS));
   fp->FRead(Class->PermConfigs, sizeof(uint32_t),
             WordsInVectorOfSize(MAX_NUM_CONFIGS));
 
   /* then read in the list of temporary protos */
   fp->FRead(&NumTempProtos, sizeof(int), 1);
   Class->TempProtos = NIL_LIST;
   for (i = 0; i < NumTempProtos; i++) {
     auto TempProto = static_cast<TEMP_PROTO>(malloc(sizeof(TEMP_PROTO_STRUCT)));
     fp->FRead(TempProto, sizeof(TEMP_PROTO_STRUCT), 1);
     Class->TempProtos = push_last (Class->TempProtos, TempProto);
   }
 
   /* then read in the adapted configs */
   fp->FRead(&NumConfigs, sizeof(int), 1);
   for (i = 0; i < NumConfigs; i++)
     if (test_bit (Class->PermConfigs, i))
       Class->Config[i].Perm = ReadPermConfig(fp);
     else
       Class->Config[i].Temp = ReadTempConfig(fp);
 
   return (Class);
 
 }                                /* ReadAdaptedClass */

PERM_CONFIG ReadPermConfig ( TFile * fp )

Read a permanent configuration description from file and return a ptr to it.

Parameters

fp	open file to read permanent config from

Returns: Ptr to new permanent configuration description.

Note: Globals: none

Definition at line 362 of file adaptive.cpp.

                                       {
   auto Config = static_cast<PERM_CONFIG>(malloc(sizeof(PERM_CONFIG_STRUCT)));
   uint8_t NumAmbigs;
   fp->FRead(&NumAmbigs, sizeof(NumAmbigs), 1);
   Config->Ambigs = new UNICHAR_ID[NumAmbigs + 1];
   fp->FRead(Config->Ambigs, sizeof(UNICHAR_ID), NumAmbigs);
   Config->Ambigs[NumAmbigs] = -1;
   fp->FRead(&(Config->FontinfoId), sizeof(int), 1);
 
   return (Config);
 
 }                                /* ReadPermConfig */

TEMP_CONFIG ReadTempConfig ( TFile * fp )

Read a temporary configuration description from file and return a ptr to it.

Parameters

fp	open file to read temporary config from

Returns: Ptr to new temporary configuration description.

Note: Globals: none

Definition at line 386 of file adaptive.cpp.

                                       {
   auto Config = static_cast<TEMP_CONFIG>(malloc(sizeof(TEMP_CONFIG_STRUCT)));
   fp->FRead(Config, sizeof(TEMP_CONFIG_STRUCT), 1);
 
   Config->Protos = NewBitVector (Config->ProtoVectorSize * BITSINLONG);
   fp->FRead(Config->Protos, sizeof(uint32_t), Config->ProtoVectorSize);
 
   return (Config);
 
 }                                /* ReadTempConfig */

void WriteAdaptedClass	(	FILE *	File,
		ADAPT_CLASS	Class,
		int	NumConfigs
	)

This routine writes a binary representation of Class to File.

Parameters

File	open file to write Class to
Class	adapted class to write to File
NumConfigs	number of configs in Class

Note: Globals: none

Definition at line 409 of file adaptive.cpp.

                                                                       {
   int NumTempProtos;
   LIST TempProtos;
   int i;
 
   /* first write high level adapted class structure */
   fwrite(Class, sizeof(ADAPT_CLASS_STRUCT), 1, File);
 
   /* then write out the definitions of the permanent protos and configs */
   fwrite(Class->PermProtos, sizeof(uint32_t),
     WordsInVectorOfSize(MAX_NUM_PROTOS), File);
   fwrite(Class->PermConfigs, sizeof(uint32_t),
     WordsInVectorOfSize(MAX_NUM_CONFIGS), File);
 
   /* then write out the list of temporary protos */
   NumTempProtos = count (Class->TempProtos);
   fwrite(&NumTempProtos, sizeof(int), 1, File);
   TempProtos = Class->TempProtos;
   iterate (TempProtos) {
     void* proto = first_node(TempProtos);
     fwrite(proto, sizeof(TEMP_PROTO_STRUCT), 1, File);
   }
 
   /* then write out the adapted configs */
   fwrite(&NumConfigs, sizeof(int), 1, File);
   for (i = 0; i < NumConfigs; i++)
     if (test_bit (Class->PermConfigs, i))
       WritePermConfig (File, Class->Config[i].Perm);
     else
       WriteTempConfig (File, Class->Config[i].Temp);
 
 }                                /* WriteAdaptedClass */

void WritePermConfig	(	FILE *	File,
		PERM_CONFIG	Config
	)

This routine writes a binary representation of a permanent configuration to File.

Parameters

File	open file to write Config to
Config	permanent config to write to File

Note: Globals: none

Definition at line 481 of file adaptive.cpp.

                                                      {
   uint8_t NumAmbigs = 0;
 
   assert (Config != nullptr);
   while (Config->Ambigs[NumAmbigs] > 0) ++NumAmbigs;
 
   fwrite(&NumAmbigs, sizeof(uint8_t), 1, File);
   fwrite(Config->Ambigs, sizeof(UNICHAR_ID), NumAmbigs, File);
   fwrite(&(Config->FontinfoId), sizeof(int), 1, File);
 }                                /* WritePermConfig */

void WriteTempConfig	(	FILE *	File,
		TEMP_CONFIG	Config
	)

This routine writes a binary representation of a temporary configuration to File.

Parameters

File	open file to write Config to
Config	temporary config to write to File

Note: Globals: none

Definition at line 503 of file adaptive.cpp.

                                                      {
   assert (Config != nullptr);
 
   fwrite(Config, sizeof (TEMP_CONFIG_STRUCT), 1, File);
   fwrite(Config->Protos, sizeof (uint32_t), Config->ProtoVectorSize, File);
 
 }                                /* WriteTempConfig */

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation