adaptive.cpp File Reference

#include "adaptive.h"
#include "emalloc.h"
#include "classify.h"
#include <cassert>
#include <cstdio>

Go to the source code of this file.

Namespaces
	tesseract

Functions
void	AddAdaptedClass (ADAPT_TEMPLATES Templates, ADAPT_CLASS Class, CLASS_ID ClassId)
void	FreeTempConfig (TEMP_CONFIG Config)
void	FreeTempProto (void *arg)
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 (TFile *fp)
PERM_CONFIG	ReadPermConfig (TFile *fp)
TEMP_CONFIG	ReadTempConfig (TFile *fp)
void	WriteAdaptedClass (FILE *File, ADAPT_CLASS Class, int NumConfigs)
void	WritePermConfig (FILE *File, PERM_CONFIG Config)
void	WriteTempConfig (FILE *File, TEMP_CONFIG Config)

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

free_adapted_class()

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);
}

free_adapted_templates()

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);
  }
}

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

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

FreeTempProto()

void FreeTempProto

(

void *

arg

)

Definition at line 81 of file adaptive.cpp.

                              {
  auto proto = static_cast<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 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 */

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

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

                          {
  return static_cast<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 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 */

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

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

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

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

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