adaptive.cpp File Reference

#include "adaptive.h"
#include "emalloc.h"
#include "globals.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 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 */