adaptive.h File Reference

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

Go to the source code of this file.

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)
#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
typedef TEMP_PROTO_STRUCT *	TEMP_PROTO
typedef TEMP_CONFIG_STRUCT *	TEMP_CONFIG
typedef PERM_CONFIG_STRUCT *	PERM_CONFIG
typedef ADAPT_CLASS_STRUCT *	ADAPT_CLASS
typedef ADAPT_TEMPLATES_STRUCT *	ADAPT_TEMPLATES

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

ConfigIsPermanent

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

Definition at line 92 of file adaptive.h.

IncreaseConfidence

#define IncreaseConfidence

(

TempConfig

)

((TempConfig)->NumTimesSeen++)

Definition at line 107 of file adaptive.h.

IsEmptyAdaptedClass

#define IsEmptyAdaptedClass

(

Class

)

Value:

((Class)->NumPermConfigs == 0 &&      \
(Class)->TempProtos == NIL_LIST)

Definition at line 89 of file adaptive.h.

MakeConfigPermanent

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

Definition at line 95 of file adaptive.h.

MakeProtoPermanent

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

Definition at line 98 of file adaptive.h.

NumNonEmptyClassesIn

#define NumNonEmptyClassesIn

(

Template

)

((Template)->NumNonEmptyClasses)

Definition at line 87 of file adaptive.h.

PermConfigFor

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

Definition at line 104 of file adaptive.h.

TempConfigFor

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

Definition at line 101 of file adaptive.h.

Typedef Documentation

ADAPT_CLASS

typedef ADAPT_CLASS_STRUCT* ADAPT_CLASS

Definition at line 72 of file adaptive.h.

ADAPT_TEMPLATES

typedef ADAPT_TEMPLATES_STRUCT* ADAPT_TEMPLATES

Definition at line 82 of file adaptive.h.

PERM_CONFIG

typedef PERM_CONFIG_STRUCT* PERM_CONFIG

Definition at line 54 of file adaptive.h.

TEMP_CONFIG

typedef TEMP_CONFIG_STRUCT* TEMP_CONFIG

Definition at line 47 of file adaptive.h.

TEMP_PROTO

typedef TEMP_PROTO_STRUCT* TEMP_PROTO

Definition at line 37 of file adaptive.h.

Function Documentation

AddAdaptedClass()

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 46 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 */

free_adapted_class()

void free_adapted_class

(

ADAPT_CLASS

adapt_class

)

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

free_adapted_templates()

void free_adapted_templates

(

ADAPT_TEMPLATES

templates

)

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

FreeTempConfig()

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 75 of file adaptive.cpp.

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

FreeTempProto()

void FreeTempProto

(

void *

arg

)

Definition at line 82 of file adaptive.cpp.

                              {
  PROTO proto = (PROTO) arg;

  free(proto);
}

NewAdaptedClass()

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 103 of file adaptive.cpp.

                              {
  ADAPT_CLASS Class;

  Class = (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 */

NewTempConfig()

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 204 of file adaptive.cpp.

                                                          {
  int NumProtos = MaxProtoId + 1;

  TEMP_CONFIG Config = (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 */

NewTempProto()

TEMP_PROTO NewTempProto

(

)

This routine allocates and returns a new temporary proto.

Returns

Ptr to new temporary proto.

Note

Globals: none

Definition at line 229 of file adaptive.cpp.

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

ReadAdaptedClass()

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 282 of file adaptive.cpp.

                                        {
  int NumTempProtos;
  int NumConfigs;
  int i;
  ADAPT_CLASS Class;

  /* first read high level adapted class structure */
  Class = (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++) {
    TEMP_PROTO TempProto = (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 */

ReadPermConfig()

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 363 of file adaptive.cpp.

                                      {
  PERM_CONFIG Config = (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 */

ReadTempConfig()

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 387 of file adaptive.cpp.

                                      {
  TEMP_CONFIG Config = (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 */

WriteAdaptedClass()

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 410 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 */

WritePermConfig()

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 482 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 */

WriteTempConfig()

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 504 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 */