classify/adaptive.cpp

Go to the documentation of this file.
00001 
00020 /* =================
00021           Include Files and Type Defines
00022  ==================== */
00023 #include "adaptive.h"
00024 #include "emalloc.h"
00025 #include "freelist.h"
00026 
00027 #ifdef __UNIX__
00028 #include <assert.h>
00029 #endif
00030 #include <stdio.h>
00031 
00032 /* =================
00033    Public Code
00034  ==================== */
00046 int AddAdaptedClass(ADAPT_TEMPLATES Templates,
00047                     ADAPT_CLASS Class,
00048                     CLASS_ID ClassId) {
00049   INT_CLASS IntClass;
00050   CLASS_INDEX ClassIndex;
00051 
00052   assert (Templates != NULL);
00053   assert (Class != NULL);
00054   assert (LegalClassId (ClassId));
00055   assert (UnusedClassIdIn (Templates->Templates, ClassId));
00056   assert (Class->NumPermConfigs == 0);
00057 
00058   IntClass = NewIntClass (1, 1);
00059   ClassIndex = AddIntClass (Templates->Templates, ClassId, IntClass);
00060 
00061   assert (Templates->Class[ClassIndex] == NULL);
00062 
00063   Templates->Class[ClassIndex] = Class;
00064 
00065   return (ClassIndex);
00066 
00067 }                                /* AddAdaptedClass */
00068 
00069 
00070 /* =============================== */
00080 void FreeTempConfig(TEMP_CONFIG Config) { 
00081   assert (Config != NULL);
00082 
00083   destroy_nodes (Config->ContextsSeen, memfree);
00084   FreeBitVector (Config->Protos);
00085   c_free_struct (Config, sizeof (TEMP_CONFIG_STRUCT), "TEMP_CONFIG_STRUCT");
00086 
00087 }                                /* FreeTempConfig */
00088 
00089 
00093 void FreeTempProto(void *arg) { 
00094   PROTO proto = (PROTO) arg;
00095 
00096   c_free_struct (proto, sizeof (TEMP_PROTO_STRUCT), "TEMP_PROTO_STRUCT");
00097 }
00098 
00099 
00100 /* =============================== */
00111 ADAPT_CLASS NewAdaptedClass() { 
00112   ADAPT_CLASS Class;
00113   int i;
00114 
00115   Class = (ADAPT_CLASS) Emalloc (sizeof (ADAPT_CLASS_STRUCT));
00116   Class->NumPermConfigs = 0;
00117   Class->TempProtos = NIL;
00118 
00119   Class->PermProtos = NewBitVector (MAX_NUM_PROTOS);
00120   Class->PermConfigs = NewBitVector (MAX_NUM_CONFIGS);
00121   zero_all_bits (Class->PermProtos, WordsInVectorOfSize (MAX_NUM_PROTOS));
00122   zero_all_bits (Class->PermConfigs, WordsInVectorOfSize (MAX_NUM_CONFIGS));
00123 
00124   for (i = 0; i < MAX_NUM_CONFIGS; i++)
00125     TempConfigFor (Class, i) = NULL;
00126 
00127   return (Class);
00128 
00129 }                                /* NewAdaptedClass */
00130 
00131 
00132 /* =============================== */
00136 void free_adapted_class(ADAPT_CLASS adapt_class) { 
00137   int i;
00138 
00139   for (i = 0; i < MAX_NUM_CONFIGS; i++) {
00140     if (ConfigIsPermanent (adapt_class, i)
00141       && PermConfigFor (adapt_class, i) != NULL)
00142       Efree (PermConfigFor (adapt_class, i));
00143     else if (!ConfigIsPermanent (adapt_class, i)
00144       && TempConfigFor (adapt_class, i) != NULL)
00145       FreeTempConfig (TempConfigFor (adapt_class, i));
00146   }
00147   FreeBitVector (adapt_class->PermProtos);
00148   FreeBitVector (adapt_class->PermConfigs);
00149   destroy_nodes (adapt_class->TempProtos, FreeTempProto);
00150   Efree(adapt_class); 
00151 }
00152 
00153 
00154 /* =============================== */
00164 ADAPT_TEMPLATES NewAdaptedTemplates() { 
00165   ADAPT_TEMPLATES Templates;
00166   int i;
00167 
00168   Templates = (ADAPT_TEMPLATES) Emalloc (sizeof (ADAPT_TEMPLATES_STRUCT));
00169 
00170   Templates->Templates = NewIntTemplates ();
00171   Templates->NumPermClasses = 0;
00172 
00173   for (i = 0; i < MAX_NUM_CLASSES; i++)
00174     Templates->Class[i] = NULL;
00175 
00176   return (Templates);
00177 
00178 }                                /* NewAdaptedTemplates */
00179 
00180 
00181 /* =============================== */
00185 void free_adapted_templates(ADAPT_TEMPLATES templates) { 
00186 
00187   if (templates != NULL) {
00188     int i;
00189     for (i = 0; i < NumClassesIn (templates->Templates); i++)
00190       free_adapted_class (templates->Class[i]);
00191     free_int_templates (templates->Templates);
00192     Efree(templates); 
00193   }
00194 }
00195 
00196 
00197 /* =============================== */
00207 TEMP_CONFIG NewTempConfig(int MaxProtoId) { 
00208   TEMP_CONFIG Config;
00209   int NumProtos = MaxProtoId + 1;
00210 
00211   Config =
00212     (TEMP_CONFIG) c_alloc_struct (sizeof (TEMP_CONFIG_STRUCT),
00213     "TEMP_CONFIG_STRUCT");
00214   Config->Protos = NewBitVector (NumProtos);
00215 
00216   Config->NumTimesSeen = 1;
00217   Config->MaxProtoId = MaxProtoId;
00218   Config->ProtoVectorSize = WordsInVectorOfSize (NumProtos);
00219   Config->ContextsSeen = NIL;
00220   zero_all_bits (Config->Protos, Config->ProtoVectorSize);
00221 
00222   return (Config);
00223 
00224 }                                /* NewTempConfig */
00225 
00226 
00227 /* =============================== */
00237 TEMP_PROTO NewTempProto() { 
00238   return ((TEMP_PROTO)
00239     c_alloc_struct (sizeof (TEMP_PROTO_STRUCT), "TEMP_PROTO_STRUCT"));
00240 }                                /* NewTempProto */
00241 
00242 
00243 /* =============================== */
00254 void PrintAdaptedTemplates(FILE *File, ADAPT_TEMPLATES Templates) { 
00255   int i;
00256   INT_CLASS IClass;
00257   ADAPT_CLASS AClass;
00258 
00259   #ifndef SECURE_NAMES
00260   fprintf (File, "\n\nSUMMARY OF ADAPTED TEMPLATES:\n\n");
00261   fprintf (File, "Num classes = %d;  Num permanent classes = %d\n\n",
00262     NumClassesIn (Templates->Templates), Templates->NumPermClasses);
00263   fprintf (File, "Index Id  NC NPC  NP NPP\n");
00264   fprintf (File, "------------------------\n");
00265 
00266   for (i = 0; i < NumClassesIn (Templates->Templates); i++) {
00267     IClass = ClassForIndex (Templates->Templates, i);
00268     AClass = Templates->Class[i];
00269 
00270     fprintf (File, "%5d  %c %3d %3d %3d %3d\n",
00271       i, ClassIdForIndex (Templates->Templates, i),
00272       NumIntConfigsIn (IClass), AClass->NumPermConfigs,
00273       NumIntProtosIn (IClass),
00274       NumIntProtosIn (IClass) - count (AClass->TempProtos));
00275   }
00276   #endif
00277   fprintf (File, "\n");
00278 
00279 }                                /* PrintAdaptedTemplates */
00280 
00281 
00282 /* =============================== */
00293 ADAPT_CLASS ReadAdaptedClass(FILE *File) { 
00294   int NumTempProtos;
00295   int NumConfigs;
00296   int i;
00297   ADAPT_CLASS Class;
00298   TEMP_PROTO TempProto;
00299 
00300   /* 1: Read high level adapted class structure */
00301   Class = (ADAPT_CLASS) Emalloc (sizeof (ADAPT_CLASS_STRUCT));
00302   fread ((char *) Class, sizeof (ADAPT_CLASS_STRUCT), 1, File);
00303 
00304   /* 2: Read in the definitions of the permanent protos and configs */
00305   Class->PermProtos = NewBitVector (MAX_NUM_PROTOS);
00306   Class->PermConfigs = NewBitVector (MAX_NUM_CONFIGS);
00307   fread ((char *) Class->PermProtos, sizeof (UINT32),
00308     WordsInVectorOfSize (MAX_NUM_PROTOS), File);
00309   fread ((char *) Class->PermConfigs, sizeof (UINT32),
00310     WordsInVectorOfSize (MAX_NUM_CONFIGS), File);
00311 
00312   /* 3: Read in the list of temporary protos */
00313   fread ((char *) &NumTempProtos, sizeof (int), 1, File);
00314   Class->TempProtos = NIL;
00315   for (i = 0; i < NumTempProtos; i++) {
00316     TempProto =
00317       (TEMP_PROTO) c_alloc_struct (sizeof (TEMP_PROTO_STRUCT),
00318       "TEMP_PROTO_STRUCT");
00319     fread ((char *) TempProto, sizeof (TEMP_PROTO_STRUCT), 1, File);
00320     Class->TempProtos = push_last (Class->TempProtos, TempProto);
00321   }
00322 
00323   /* 4: Read in the adapted configs */
00324   fread ((char *) &NumConfigs, sizeof (int), 1, File);
00325   for (i = 0; i < NumConfigs; i++)
00326     if (test_bit (Class->PermConfigs, i))
00327       Class->Config[i].Perm = ReadPermConfig (File);
00328   else
00329     Class->Config[i].Temp = ReadTempConfig (File);
00330 
00331   return (Class);
00332 
00333 }                                /* ReadAdaptedClass */
00334 
00335 
00336 /* =============================== */
00347 ADAPT_TEMPLATES ReadAdaptedTemplates(FILE *File) { 
00348   int i;
00349   ADAPT_TEMPLATES Templates;
00350 
00351   /* first read the high level adaptive template struct */
00352   Templates = (ADAPT_TEMPLATES) Emalloc (sizeof (ADAPT_TEMPLATES_STRUCT));
00353   fread ((char *) Templates, sizeof (ADAPT_TEMPLATES_STRUCT), 1, File);
00354 
00355   /* then read in the basic integer templates */
00356   Templates->Templates = ReadIntTemplates (File, FALSE);
00357 
00358   /* then read in the adaptive info for each class */
00359   for (i = 0; i < NumClassesIn (Templates->Templates); i++) {
00360     Templates->Class[i] = ReadAdaptedClass (File);
00361   }
00362   return (Templates);
00363 
00364 }                                /* ReadAdaptedTemplates */
00365 
00366 
00367 /* =============================== */
00380 PERM_CONFIG ReadPermConfig(FILE *File) { 
00381   PERM_CONFIG Config;
00382   UINT8 NumAmbigs;
00383 
00384   fread ((char *) &NumAmbigs, sizeof (UINT8), 1, File);
00385   Config = (PERM_CONFIG) Emalloc (sizeof (char) * (NumAmbigs + 1));
00386   fread (Config, sizeof (char), NumAmbigs, File);
00387   Config[NumAmbigs] = '\0';
00388 
00389   return (Config);
00390 
00391 }                                /* ReadPermConfig */
00392 
00393 
00394 /* =============================== */
00405 TEMP_CONFIG ReadTempConfig(FILE *File) { 
00406   TEMP_CONFIG Config;
00407 
00408   Config =
00409     (TEMP_CONFIG) c_alloc_struct (sizeof (TEMP_CONFIG_STRUCT),
00410     "TEMP_CONFIG_STRUCT");
00411   fread ((char *) Config, sizeof (TEMP_CONFIG_STRUCT), 1, File);
00412 
00413   Config->Protos = NewBitVector (Config->ProtoVectorSize * BITSINLONG);
00414   fread ((char *) Config->Protos, sizeof (UINT32),
00415     Config->ProtoVectorSize, File);
00416 
00417   return (Config);
00418 
00419 }                                /* ReadTempConfig */
00420 
00421 
00422 /* =============================== */
00434 void WriteAdaptedClass(FILE *File, ADAPT_CLASS Class, int NumConfigs) { 
00435   int NumTempProtos;
00436   LIST TempProtos;
00437   int i;
00438 
00439   /* first write high level adapted class structure */
00440   fwrite ((char *) Class, sizeof (ADAPT_CLASS_STRUCT), 1, File);
00441 
00442   /* then write out the definitions of the permanent protos and configs */
00443   fwrite ((char *) Class->PermProtos, sizeof (UINT32),
00444     WordsInVectorOfSize (MAX_NUM_PROTOS), File);
00445   fwrite ((char *) Class->PermConfigs, sizeof (UINT32),
00446     WordsInVectorOfSize (MAX_NUM_CONFIGS), File);
00447 
00448   /* then write out the list of temporary protos */
00449   NumTempProtos = count (Class->TempProtos);
00450   fwrite ((char *) &NumTempProtos, sizeof (int), 1, File);
00451   TempProtos = Class->TempProtos;
00452   iterate (TempProtos) {
00453     void* proto = first(TempProtos);
00454     fwrite ((char *) proto, sizeof (TEMP_PROTO_STRUCT), 1, File);
00455   }
00456 
00457   /* then write out the adapted configs */
00458   fwrite ((char *) &NumConfigs, sizeof (int), 1, File);
00459   for (i = 0; i < NumConfigs; i++)
00460     if (test_bit (Class->PermConfigs, i))
00461       WritePermConfig (File, Class->Config[i].Perm);
00462   else
00463     WriteTempConfig (File, Class->Config[i].Temp);
00464 
00465 }// WriteAdaptedClass
00466 
00467 
00468 /* =============================== */
00479 void WriteAdaptedTemplates(FILE *File, ADAPT_TEMPLATES Templates) { 
00480   int i;
00481 
00482   /* first write the high level adaptive template struct */
00483   fwrite ((char *) Templates, sizeof (ADAPT_TEMPLATES_STRUCT), 1, File);
00484 
00485   /* then write out the basic integer templates */
00486   WriteIntTemplates (File, Templates->Templates);
00487 
00488   /* then write out the adaptive info for each class */
00489   for (i = 0; i < NumClassesIn (Templates->Templates); i++) {
00490     WriteAdaptedClass (File, Templates->Class[i],
00491       NumIntConfigsIn (ClassForIndex
00492       (Templates->Templates, i)));
00493   }
00494 }                                /* WriteAdaptedTemplates */
00495 
00496 
00497 /* =============================== */
00508 void WritePermConfig(FILE *File, PERM_CONFIG Config) { 
00509   UINT8 NumAmbigs;
00510 
00511   assert (Config != NULL);
00512 
00513   NumAmbigs = strlen (Config);
00514   fwrite ((char *) &NumAmbigs, sizeof (UINT8), 1, File);
00515   fwrite (Config, sizeof (char), NumAmbigs, File);
00516 
00517 }                                /* WritePermConfig */
00518 
00519 
00520 /* =============================== */
00531 void WriteTempConfig(FILE *File, TEMP_CONFIG Config) { 
00532   assert (Config != NULL);
00533                                  /* contexts not yet implemented */
00534   assert (Config->ContextsSeen == NULL);
00535 
00536   fwrite ((char *) Config, sizeof (TEMP_CONFIG_STRUCT), 1, File);
00537   fwrite ((char *) Config->Protos, sizeof (UINT32),
00538     Config->ProtoVectorSize, File);
00539 
00540 }                                /* WriteTempConfig */

Generated on Wed Feb 28 19:49:09 2007 for Tesseract by  doxygen 1.5.1