mirror of
https://github.com/tesseract-ocr/tesseract.git
synced 2024-12-23 23:17:49 +08:00
fb2e23f6de
git-svn-id: https://tesseract-ocr.googlecode.com/svn/trunk@41 d0cd1f9f-072b-0410-8dd7-cf729c803f20
535 lines
17 KiB
C++
535 lines
17 KiB
C++
/******************************************************************************
|
|
** Filename: adaptive.c
|
|
** Purpose: Adaptive matcher.
|
|
** Author: Dan Johnson
|
|
** History: Fri Mar 8 10:00:21 1991, DSJ, Created.
|
|
**
|
|
** (c) Copyright Hewlett-Packard Company, 1988.
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
******************************************************************************/
|
|
|
|
/**----------------------------------------------------------------------------
|
|
Include Files and Type Defines
|
|
----------------------------------------------------------------------------**/
|
|
#include "adaptive.h"
|
|
#include "emalloc.h"
|
|
#include "freelist.h"
|
|
|
|
#ifdef __UNIX__
|
|
#include <assert.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
|
|
/**----------------------------------------------------------------------------
|
|
Public Code
|
|
----------------------------------------------------------------------------**/
|
|
/*---------------------------------------------------------------------------*/
|
|
int AddAdaptedClass(ADAPT_TEMPLATES Templates,
|
|
ADAPT_CLASS Class,
|
|
CLASS_ID ClassId) {
|
|
/*
|
|
** 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
|
|
** Globals: none
|
|
** Operation: This routine adds a new adapted class to an existing
|
|
** set of adapted templates.
|
|
** Return: The class index of the new class.
|
|
** Exceptions: none
|
|
** History: Thu Mar 14 13:06:09 1991, DSJ, Created.
|
|
*/
|
|
INT_CLASS IntClass;
|
|
CLASS_INDEX ClassIndex;
|
|
|
|
assert (Templates != NULL);
|
|
assert (Class != NULL);
|
|
assert (LegalClassId (ClassId));
|
|
assert (UnusedClassIdIn (Templates->Templates, ClassId));
|
|
assert (Class->NumPermConfigs == 0);
|
|
|
|
IntClass = NewIntClass (1, 1);
|
|
ClassIndex = AddIntClass (Templates->Templates, ClassId, IntClass);
|
|
|
|
assert (Templates->Class[ClassIndex] == NULL);
|
|
|
|
Templates->Class[ClassIndex] = Class;
|
|
|
|
return (ClassIndex);
|
|
|
|
} /* AddAdaptedClass */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void FreeTempConfig(TEMP_CONFIG Config) {
|
|
/*
|
|
** Parameters:
|
|
** Config config to be freed
|
|
** Globals: none
|
|
** Operation: This routine frees all memory consumed by a temporary
|
|
** configuration.
|
|
** Return: none
|
|
** Exceptions: none
|
|
** History: Thu Mar 14 13:34:23 1991, DSJ, Created.
|
|
*/
|
|
assert (Config != NULL);
|
|
|
|
destroy_nodes (Config->ContextsSeen, memfree);
|
|
FreeBitVector (Config->Protos);
|
|
c_free_struct (Config, sizeof (TEMP_CONFIG_STRUCT), "TEMP_CONFIG_STRUCT");
|
|
|
|
} /* FreeTempConfig */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void FreeTempProto(void *arg) {
|
|
PROTO proto = (PROTO) arg;
|
|
|
|
c_free_struct (proto, sizeof (TEMP_PROTO_STRUCT), "TEMP_PROTO_STRUCT");
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
ADAPT_CLASS NewAdaptedClass() {
|
|
/*
|
|
** Parameters: none
|
|
** Globals: none
|
|
** Operation: This operation allocates and initializes a new adapted
|
|
** class data structure and returns a ptr to it.
|
|
** Return: Ptr to new class data structure.
|
|
** Exceptions: none
|
|
** History: Thu Mar 14 12:58:13 1991, DSJ, Created.
|
|
*/
|
|
ADAPT_CLASS Class;
|
|
int i;
|
|
|
|
Class = (ADAPT_CLASS) Emalloc (sizeof (ADAPT_CLASS_STRUCT));
|
|
Class->NumPermConfigs = 0;
|
|
Class->TempProtos = NIL;
|
|
|
|
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 (i = 0; i < MAX_NUM_CONFIGS; i++)
|
|
TempConfigFor (Class, i) = NULL;
|
|
|
|
return (Class);
|
|
|
|
} /* NewAdaptedClass */
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
void free_adapted_class(ADAPT_CLASS adapt_class) {
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_NUM_CONFIGS; i++) {
|
|
if (ConfigIsPermanent (adapt_class, i)
|
|
&& PermConfigFor (adapt_class, i) != NULL)
|
|
Efree (PermConfigFor (adapt_class, i));
|
|
else if (!ConfigIsPermanent (adapt_class, i)
|
|
&& TempConfigFor (adapt_class, i) != NULL)
|
|
FreeTempConfig (TempConfigFor (adapt_class, i));
|
|
}
|
|
FreeBitVector (adapt_class->PermProtos);
|
|
FreeBitVector (adapt_class->PermConfigs);
|
|
destroy_nodes (adapt_class->TempProtos, FreeTempProto);
|
|
Efree(adapt_class);
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
ADAPT_TEMPLATES NewAdaptedTemplates() {
|
|
/*
|
|
** Parameters: none
|
|
** Globals: none
|
|
** Operation:
|
|
** Return: none
|
|
** Exceptions: none
|
|
** History: Fri Mar 8 10:15:28 1991, DSJ, Created.
|
|
*/
|
|
ADAPT_TEMPLATES Templates;
|
|
int i;
|
|
|
|
Templates = (ADAPT_TEMPLATES) Emalloc (sizeof (ADAPT_TEMPLATES_STRUCT));
|
|
|
|
Templates->Templates = NewIntTemplates ();
|
|
Templates->NumPermClasses = 0;
|
|
|
|
for (i = 0; i < MAX_NUM_CLASSES; i++)
|
|
Templates->Class[i] = NULL;
|
|
|
|
return (Templates);
|
|
|
|
} /* NewAdaptedTemplates */
|
|
|
|
|
|
/*-------------------------------------------------------------------------------*/
|
|
void free_adapted_templates(ADAPT_TEMPLATES templates) {
|
|
|
|
if (templates != NULL) {
|
|
int i;
|
|
for (i = 0; i < NumClassesIn (templates->Templates); i++)
|
|
free_adapted_class (templates->Class[i]);
|
|
free_int_templates (templates->Templates);
|
|
Efree(templates);
|
|
}
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
TEMP_CONFIG NewTempConfig(int MaxProtoId) {
|
|
/*
|
|
** Parameters:
|
|
** MaxProtoId max id of any proto in new config
|
|
** Globals: none
|
|
** Operation: This routine allocates and returns a new temporary
|
|
** config.
|
|
** Return: Ptr to new temp config.
|
|
** Exceptions: none
|
|
** History: Thu Mar 14 13:28:21 1991, DSJ, Created.
|
|
*/
|
|
TEMP_CONFIG Config;
|
|
int NumProtos = MaxProtoId + 1;
|
|
|
|
Config =
|
|
(TEMP_CONFIG) c_alloc_struct (sizeof (TEMP_CONFIG_STRUCT),
|
|
"TEMP_CONFIG_STRUCT");
|
|
Config->Protos = NewBitVector (NumProtos);
|
|
|
|
Config->NumTimesSeen = 1;
|
|
Config->MaxProtoId = MaxProtoId;
|
|
Config->ProtoVectorSize = WordsInVectorOfSize (NumProtos);
|
|
Config->ContextsSeen = NIL;
|
|
zero_all_bits (Config->Protos, Config->ProtoVectorSize);
|
|
|
|
return (Config);
|
|
|
|
} /* NewTempConfig */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
TEMP_PROTO NewTempProto() {
|
|
/*
|
|
** Parameters: none
|
|
** Globals: none
|
|
** Operation: This routine allocates and returns a new temporary proto.
|
|
** Return: Ptr to new temporary proto.
|
|
** Exceptions: none
|
|
** History: Thu Mar 14 13:31:31 1991, DSJ, Created.
|
|
*/
|
|
return ((TEMP_PROTO)
|
|
c_alloc_struct (sizeof (TEMP_PROTO_STRUCT), "TEMP_PROTO_STRUCT"));
|
|
} /* NewTempProto */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void PrintAdaptedTemplates(FILE *File, ADAPT_TEMPLATES Templates) {
|
|
/*
|
|
** Parameters:
|
|
** File open text file to print Templates to
|
|
** Templates adapted templates to print to File
|
|
** Globals: none
|
|
** Operation: This routine prints a summary of the adapted templates
|
|
** in Templates to File.
|
|
** Return: none
|
|
** Exceptions: none
|
|
** History: Wed Mar 20 13:35:29 1991, DSJ, Created.
|
|
*/
|
|
int i;
|
|
INT_CLASS IClass;
|
|
ADAPT_CLASS AClass;
|
|
|
|
#ifndef SECURE_NAMES
|
|
fprintf (File, "\n\nSUMMARY OF ADAPTED TEMPLATES:\n\n");
|
|
fprintf (File, "Num classes = %d; Num permanent classes = %d\n\n",
|
|
NumClassesIn (Templates->Templates), Templates->NumPermClasses);
|
|
fprintf (File, "Index Id NC NPC NP NPP\n");
|
|
fprintf (File, "------------------------\n");
|
|
|
|
for (i = 0; i < NumClassesIn (Templates->Templates); i++) {
|
|
IClass = ClassForIndex (Templates->Templates, i);
|
|
AClass = Templates->Class[i];
|
|
|
|
fprintf (File, "%5d %c %3d %3d %3d %3d\n",
|
|
i, ClassIdForIndex (Templates->Templates, i),
|
|
NumIntConfigsIn (IClass), AClass->NumPermConfigs,
|
|
NumIntProtosIn (IClass),
|
|
NumIntProtosIn (IClass) - count (AClass->TempProtos));
|
|
}
|
|
#endif
|
|
fprintf (File, "\n");
|
|
|
|
} /* PrintAdaptedTemplates */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
ADAPT_CLASS ReadAdaptedClass(FILE *File) {
|
|
/*
|
|
** Parameters:
|
|
** File open file to read adapted class from
|
|
** Globals: none
|
|
** Operation: Read an adapted class description from File and return
|
|
** a ptr to the adapted class.
|
|
** Return: Ptr to new adapted class.
|
|
** Exceptions: none
|
|
** History: Tue Mar 19 14:11:01 1991, DSJ, Created.
|
|
*/
|
|
int NumTempProtos;
|
|
int NumConfigs;
|
|
int i;
|
|
ADAPT_CLASS Class;
|
|
TEMP_PROTO TempProto;
|
|
|
|
/* first read high level adapted class structure */
|
|
Class = (ADAPT_CLASS) Emalloc (sizeof (ADAPT_CLASS_STRUCT));
|
|
fread ((char *) Class, sizeof (ADAPT_CLASS_STRUCT), 1, File);
|
|
|
|
/* then read in the definitions of the permanent protos and configs */
|
|
Class->PermProtos = NewBitVector (MAX_NUM_PROTOS);
|
|
Class->PermConfigs = NewBitVector (MAX_NUM_CONFIGS);
|
|
fread ((char *) Class->PermProtos, sizeof (UINT32),
|
|
WordsInVectorOfSize (MAX_NUM_PROTOS), File);
|
|
fread ((char *) Class->PermConfigs, sizeof (UINT32),
|
|
WordsInVectorOfSize (MAX_NUM_CONFIGS), File);
|
|
|
|
/* then read in the list of temporary protos */
|
|
fread ((char *) &NumTempProtos, sizeof (int), 1, File);
|
|
Class->TempProtos = NIL;
|
|
for (i = 0; i < NumTempProtos; i++) {
|
|
TempProto =
|
|
(TEMP_PROTO) c_alloc_struct (sizeof (TEMP_PROTO_STRUCT),
|
|
"TEMP_PROTO_STRUCT");
|
|
fread ((char *) TempProto, sizeof (TEMP_PROTO_STRUCT), 1, File);
|
|
Class->TempProtos = push_last (Class->TempProtos, TempProto);
|
|
}
|
|
|
|
/* then read in the adapted configs */
|
|
fread ((char *) &NumConfigs, sizeof (int), 1, File);
|
|
for (i = 0; i < NumConfigs; i++)
|
|
if (test_bit (Class->PermConfigs, i))
|
|
Class->Config[i].Perm = ReadPermConfig (File);
|
|
else
|
|
Class->Config[i].Temp = ReadTempConfig (File);
|
|
|
|
return (Class);
|
|
|
|
} /* ReadAdaptedClass */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
ADAPT_TEMPLATES ReadAdaptedTemplates(FILE *File) {
|
|
/*
|
|
** Parameters:
|
|
** File open text file to read adapted templates from
|
|
** Globals: none
|
|
** Operation: Read a set of adapted templates from File and return
|
|
** a ptr to the templates.
|
|
** Return: Ptr to adapted templates read from File.
|
|
** Exceptions: none
|
|
** History: Mon Mar 18 15:18:10 1991, DSJ, Created.
|
|
*/
|
|
int i;
|
|
ADAPT_TEMPLATES Templates;
|
|
|
|
/* first read the high level adaptive template struct */
|
|
Templates = (ADAPT_TEMPLATES) Emalloc (sizeof (ADAPT_TEMPLATES_STRUCT));
|
|
fread ((char *) Templates, sizeof (ADAPT_TEMPLATES_STRUCT), 1, File);
|
|
|
|
/* then read in the basic integer templates */
|
|
Templates->Templates = ReadIntTemplates (File, FALSE);
|
|
|
|
/* then read in the adaptive info for each class */
|
|
for (i = 0; i < NumClassesIn (Templates->Templates); i++) {
|
|
Templates->Class[i] = ReadAdaptedClass (File);
|
|
}
|
|
return (Templates);
|
|
|
|
} /* ReadAdaptedTemplates */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
PERM_CONFIG ReadPermConfig(FILE *File) {
|
|
/*
|
|
** Parameters:
|
|
** File open file to read permanent config from
|
|
** Globals: none
|
|
** Operation: Read a permanent configuration description from File
|
|
** and return a ptr to it.
|
|
** Return: Ptr to new permanent configuration description.
|
|
** Exceptions: none
|
|
** History: Tue Mar 19 14:25:26 1991, DSJ, Created.
|
|
*/
|
|
PERM_CONFIG Config;
|
|
UINT8 NumAmbigs;
|
|
|
|
fread ((char *) &NumAmbigs, sizeof (UINT8), 1, File);
|
|
Config = (PERM_CONFIG) Emalloc (sizeof (char) * (NumAmbigs + 1));
|
|
fread (Config, sizeof (char), NumAmbigs, File);
|
|
Config[NumAmbigs] = '\0';
|
|
|
|
return (Config);
|
|
|
|
} /* ReadPermConfig */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
TEMP_CONFIG ReadTempConfig(FILE *File) {
|
|
/*
|
|
** Parameters:
|
|
** File open file to read temporary config from
|
|
** Globals: none
|
|
** Operation: Read a temporary configuration description from File
|
|
** and return a ptr to it.
|
|
** Return: Ptr to new temporary configuration description.
|
|
** Exceptions: none
|
|
** History: Tue Mar 19 14:29:59 1991, DSJ, Created.
|
|
*/
|
|
TEMP_CONFIG Config;
|
|
|
|
Config =
|
|
(TEMP_CONFIG) c_alloc_struct (sizeof (TEMP_CONFIG_STRUCT),
|
|
"TEMP_CONFIG_STRUCT");
|
|
fread ((char *) Config, sizeof (TEMP_CONFIG_STRUCT), 1, File);
|
|
|
|
Config->Protos = NewBitVector (Config->ProtoVectorSize * BITSINLONG);
|
|
fread ((char *) Config->Protos, sizeof (UINT32),
|
|
Config->ProtoVectorSize, File);
|
|
|
|
return (Config);
|
|
|
|
} /* ReadTempConfig */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void WriteAdaptedClass(FILE *File, ADAPT_CLASS Class, int NumConfigs) {
|
|
/*
|
|
** Parameters:
|
|
** File open file to write Class to
|
|
** Class adapted class to write to File
|
|
** NumConfigs number of configs in Class
|
|
** Globals: none
|
|
** Operation: This routine writes a binary representation of Class
|
|
** to File.
|
|
** Return: none
|
|
** Exceptions: none
|
|
** History: Tue Mar 19 13:33:51 1991, DSJ, Created.
|
|
*/
|
|
int NumTempProtos;
|
|
LIST TempProtos;
|
|
int i;
|
|
|
|
/* first write high level adapted class structure */
|
|
fwrite ((char *) Class, sizeof (ADAPT_CLASS_STRUCT), 1, File);
|
|
|
|
/* then write out the definitions of the permanent protos and configs */
|
|
fwrite ((char *) Class->PermProtos, sizeof (UINT32),
|
|
WordsInVectorOfSize (MAX_NUM_PROTOS), File);
|
|
fwrite ((char *) Class->PermConfigs, sizeof (UINT32),
|
|
WordsInVectorOfSize (MAX_NUM_CONFIGS), File);
|
|
|
|
/* then write out the list of temporary protos */
|
|
NumTempProtos = count (Class->TempProtos);
|
|
fwrite ((char *) &NumTempProtos, sizeof (int), 1, File);
|
|
TempProtos = Class->TempProtos;
|
|
iterate (TempProtos) {
|
|
void* proto = first_node(TempProtos);
|
|
fwrite ((char *) proto, sizeof (TEMP_PROTO_STRUCT), 1, File);
|
|
}
|
|
|
|
/* then write out the adapted configs */
|
|
fwrite ((char *) &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 WriteAdaptedTemplates(FILE *File, ADAPT_TEMPLATES Templates) {
|
|
/*
|
|
** Parameters:
|
|
** File open text file to write Templates to
|
|
** Templates set of adapted templates to write to File
|
|
** Globals: none
|
|
** Operation: This routine saves Templates to File in a binary format.
|
|
** Return: none
|
|
** Exceptions: none
|
|
** History: Mon Mar 18 15:07:32 1991, DSJ, Created.
|
|
*/
|
|
int i;
|
|
|
|
/* first write the high level adaptive template struct */
|
|
fwrite ((char *) Templates, sizeof (ADAPT_TEMPLATES_STRUCT), 1, File);
|
|
|
|
/* then write out the basic integer templates */
|
|
WriteIntTemplates (File, Templates->Templates);
|
|
|
|
/* then write out the adaptive info for each class */
|
|
for (i = 0; i < NumClassesIn (Templates->Templates); i++) {
|
|
WriteAdaptedClass (File, Templates->Class[i],
|
|
NumIntConfigsIn (ClassForIndex
|
|
(Templates->Templates, i)));
|
|
}
|
|
} /* WriteAdaptedTemplates */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void WritePermConfig(FILE *File, PERM_CONFIG Config) {
|
|
/*
|
|
** Parameters:
|
|
** File open file to write Config to
|
|
** Config permanent config to write to File
|
|
** Globals: none
|
|
** Operation: This routine writes a binary representation of a
|
|
** permanent configuration to File.
|
|
** Return: none
|
|
** Exceptions: none
|
|
** History: Tue Mar 19 13:55:44 1991, DSJ, Created.
|
|
*/
|
|
UINT8 NumAmbigs;
|
|
|
|
assert (Config != NULL);
|
|
|
|
NumAmbigs = strlen (Config);
|
|
fwrite ((char *) &NumAmbigs, sizeof (UINT8), 1, File);
|
|
fwrite (Config, sizeof (char), NumAmbigs, File);
|
|
|
|
} /* WritePermConfig */
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void WriteTempConfig(FILE *File, TEMP_CONFIG Config) {
|
|
/*
|
|
** Parameters:
|
|
** File open file to write Config to
|
|
** Config temporary config to write to File
|
|
** Globals: none
|
|
** Operation: This routine writes a binary representation of a
|
|
** temporary configuration to File.
|
|
** Return: none
|
|
** Exceptions: none
|
|
** History: Tue Mar 19 14:00:28 1991, DSJ, Created.
|
|
*/
|
|
assert (Config != NULL);
|
|
/* contexts not yet implemented */
|
|
assert (Config->ContextsSeen == NULL);
|
|
|
|
fwrite ((char *) Config, sizeof (TEMP_CONFIG_STRUCT), 1, File);
|
|
fwrite ((char *) Config->Protos, sizeof (UINT32),
|
|
Config->ProtoVectorSize, File);
|
|
|
|
} /* WriteTempConfig */
|