tesseract_bin 1.0.0

data/vendor/tesseract-2.04/classify/mfx.h

@@ -0,0 +1,52 @@
+/******************************************************************************
+ **	Filename:	mfx.h
+ **	Purpose:	Definition of micro-feature extraction routines
+ **	Author:		Dan Johnson
+ **	History:	5/29/89, 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.
+ ******************************************************************************/
+#ifndef   MFX_H
+#define   MFX_H
+
+/**----------------------------------------------------------------------------
+          Include Files and Type Defines
+----------------------------------------------------------------------------**/
+#include "fxdefs.h"
+
+extern FLOAT32 MinSlope;
+extern FLOAT32 MaxSlope;
+/**----------------------------------------------------------------------------
+          Public Function Prototypes
+----------------------------------------------------------------------------**/
+void InitMicroFxVars(); 
+
+CHAR_FEATURES BlobMicroFeatures(TBLOB *Blob, LINE_STATS *LineStats); 
+
+/*
+#if defined(__STDC__) || defined(__cplusplus)
+# define _ARGS(s) s
+#else
+# define _ARGS(s) ()
+#endif*/
+
+/* mfx.c
+void InitMicroFxVars
+  _ARGS((void));
+
+CHAR_FEATURES BlobMicroFeatures
+  _ARGS((BLOB *Blob,
+  LINE_STATS *LineStats));
+
+#undef _ARGS
+*/
+#endif

data/vendor/tesseract-2.04/classify/normfeat.cpp

@@ -0,0 +1,132 @@
+/******************************************************************************
+ **	Filename:    normfeat.c
+ **	Purpose:     Definition of char normalization features.
+ **	Author:      Dan Johnson
+ **	History:     12/14/90, 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 "normfeat.h"
+#include "mfoutline.h"
+#include "intfx.h"
+
+#include "ocrfeatures.h"         //Debug
+#include <stdio.h>               //Debug
+#include "efio.h"                //Debug
+//#include "christydbg.h"
+
+/**----------------------------------------------------------------------------
+        Global Data Definitions and Declarations
+----------------------------------------------------------------------------**/
+/**----------------------------------------------------------------------------
+              Public Code
+----------------------------------------------------------------------------**/
+/*---------------------------------------------------------------------------*/
+FLOAT32 ActualOutlineLength(FEATURE Feature) {
+/*
+ **	Parameters:
+ **		Feature		normalization feature
+ **	Globals: none
+ **	Operation: This routine returns the length that the outline
+ **		would have been if it were baseline normalized instead
+ **		of character normalized.
+ **	Return: Baseline normalized length of outline.
+ **	Exceptions: none
+ **	History: Thu Dec 20 14:50:57 1990, DSJ, Created.
+ */
+  return (Feature->Params[CharNormLength] * LENGTH_COMPRESSION);
+
+}                                /* ActualOutlineLength */
+
+
+/*---------------------------------------------------------------------------*/
+FEATURE_SET ExtractCharNormFeatures(TBLOB *Blob, LINE_STATS *LineStats) {
+/*
+ **	Parameters:
+ **		Blob		blob to extract char norm feature from
+ **		LineStats	statistics on text row blob is in
+ **	Globals: none
+ **	Operation: Compute a feature whose parameters describe how a
+ **		character will be affected by the character normalization
+ **		algorithm.  The feature parameters are:
+ **			y position of center of mass in baseline coordinates
+ **			total length of outlines in baseline coordinates
+ **				divided by a scale factor
+ **			radii of gyration about the center of mass in
+ **				baseline coordinates
+ **	Return: Character normalization feature for Blob.
+ **	Exceptions: none
+ **	History: Wed May 23 18:06:38 1990, DSJ, Created.
+ */
+  FEATURE_SET FeatureSet;
+  FEATURE Feature;
+  FLOAT32 Scale;
+  FLOAT32 Baseline;
+  LIST Outlines;
+  INT_FEATURE_ARRAY blfeatures;
+  INT_FEATURE_ARRAY cnfeatures;
+  INT_FX_RESULT_STRUCT FXInfo;
+
+  /* allocate the feature and feature set - note that there is always one
+     and only one char normalization feature for any blob */
+  FeatureSet = NewFeatureSet (1);
+  Feature = NewFeature (&CharNormDesc);
+  AddFeature(FeatureSet, Feature);
+
+  /* compute the normalization statistics for this blob */
+  Outlines = ConvertBlob (Blob);
+  /*---------Debug--------------------------------------------------*
+  OFile = fopen ("f:/ims/debug/nfOutline.logCPP", "r");
+  if (OFile == NULL)
+  {
+    OFile = Efopen ("f:/ims/debug/nfOutline.logCPP", "w");
+    WriteOutlines(OFile, Outlines);
+  }
+  else
+  {
+    fclose (OFile);
+    OFile = Efopen ("f:/ims/debug/nfOutline.logCPP", "a");
+  }
+  WriteOutlines(OFile, Outlines);
+  fclose (OFile);
+  *--------------------------------------------------------------------*/
+
+  ExtractIntFeat(Blob, blfeatures, cnfeatures, &FXInfo);
+  Baseline = BaselineAt (LineStats, FXInfo.Xmean);
+  Scale = ComputeScaleFactor (LineStats);
+  Feature->Params[CharNormY] = (FXInfo.Ymean - Baseline) * Scale;
+  Feature->Params[CharNormLength] =
+    FXInfo.Length * Scale / LENGTH_COMPRESSION;
+  Feature->Params[CharNormRx] = FXInfo.Rx * Scale;
+  Feature->Params[CharNormRy] = FXInfo.Ry * Scale;
+
+  /*---------Debug--------------------------------------------------*
+  File = fopen ("f:/ims/debug/nfFeatSet.logCPP", "r");
+  if (File == NULL)
+  {
+    File = Efopen ("f:/ims/debug/nfFeatSet.logCPP", "w");
+    WriteFeatureSet(File, FeatureSet);
+  }
+  else
+  {
+    fclose (File);
+    File = Efopen ("f:/ims/debug/nfFeatSet.logCPP", "a");
+  }
+  WriteFeatureSet(File, FeatureSet);
+  fclose (File);
+  *--------------------------------------------------------------------*/
+  FreeOutlines(Outlines);
+  return (FeatureSet);
+}                                /* ExtractCharNormFeatures */

data/vendor/tesseract-2.04/classify/normfeat.h

@@ -0,0 +1,63 @@
+/******************************************************************************
+ **	Filename:    normfeat.h
+ **	Purpose:     Definition of character normalization features.
+ **	Author:      Dan Johnson
+ **	History:     12/14/90, 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.
+ ******************************************************************************/
+#ifndef   NORMFEAT_H
+#define   NORMFEAT_H
+
+/**----------------------------------------------------------------------------
+          Include Files and Type Defines
+----------------------------------------------------------------------------**/
+#include "ocrfeatures.h"
+#include "tessclas.h"
+#include "fxdefs.h"
+
+#define LENGTH_COMPRESSION  (10.0)
+
+typedef enum
+{ CharNormY, CharNormLength, CharNormRx, CharNormRy }
+NORM_PARAM_NAME;
+
+/**----------------------------------------------------------------------------
+          Public Function Prototypes
+----------------------------------------------------------------------------**/
+FLOAT32 ActualOutlineLength(FEATURE Feature); 
+
+FEATURE_SET ExtractCharNormFeatures(TBLOB *Blob, LINE_STATS *LineStats); 
+
+/*
+#if defined(__STDC__) || defined(__cplusplus)
+# define        _ARGS(s) s
+#else
+# define        _ARGS(s) ()
+#endif*/
+
+/* normfeat.c
+FLOAT32 ActualOutlineLength
+    _ARGS((FEATURE Feature));
+
+FEATURE_SET ExtractCharNormFeatures
+    _ARGS((BLOB *Blob,
+  LINE_STATS *LineStats));
+
+#undef _ARGS
+*/
+
+/**----------------------------------------------------------------------------
+        Global Data Definitions and Declarations
+----------------------------------------------------------------------------**/
+extern FEATURE_DESC_STRUCT CharNormDesc;
+#endif

data/vendor/tesseract-2.04/classify/normmatch.cpp

@@ -0,0 +1,305 @@
+/******************************************************************************
+ **	Filename:    normmatch.c
+ **	Purpose:     Simple matcher based on character normalization features.
+ **	Author:      Dan Johnson
+ **	History:     Wed Dec 19 16:18:06 1990, 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 "normmatch.h"
+#include "clusttool.h"
+#include "normfeat.h"
+#include "debug.h"
+#include "const.h"
+#include "efio.h"
+#include "emalloc.h"
+#include "globals.h"
+#include "scanutils.h"
+
+#include <stdio.h>
+#include <math.h>
+
+/* define default filenames for training data */
+#define NORM_PROTO_FILE   "normproto"
+
+typedef struct
+{
+  int NumParams;
+  PARAM_DESC *ParamDesc;
+  LIST* Protos;
+  int NumProtos;
+} NORM_PROTOS;
+
+/**----------------------------------------------------------------------------
+          Private Function Prototypes
+----------------------------------------------------------------------------**/
+FLOAT32 NormEvidenceOf(register FLOAT32 NormAdj);
+
+void PrintNormMatch(FILE *File,
+                    int NumParams,
+                    PROTOTYPE *Proto,
+                    FEATURE Feature);
+
+NORM_PROTOS *ReadNormProtos(FILE *File);
+
+/**----------------------------------------------------------------------------
+        Global Data Definitions and Declarations
+----------------------------------------------------------------------------**/
+/* global data structure to hold char normalization protos */
+static NORM_PROTOS *NormProtos;
+
+/* name of file containing char normalization protos */
+static const char *NormProtoFile = NORM_PROTO_FILE;
+
+/* control knobs used to control the normalization adjustment process */
+make_float_var (NormAdjMidpoint, 32.0, MakeNormAdjMidpoint,
+15, 16, SetNormAdjMidpoint, "Norm adjust midpoint ...")
+make_float_var (NormAdjCurl, 2.0, MakeNormAdjCurl,
+15, 17, SetNormAdjCurl, "Norm adjust curl ...")
+/**----------------------------------------------------------------------------
+              Public Code
+----------------------------------------------------------------------------**/
+/*---------------------------------------------------------------------------*/
+FLOAT32 ComputeNormMatch(CLASS_ID ClassId, FEATURE Feature, BOOL8 DebugMatch) {
+/*
+ **	Parameters:
+ **		ClassId		id of class to match against
+ **		Feature		character normalization feature
+ **		DebugMatch	controls dump of debug info
+ **	Globals:
+ **		NormProtos	character normalization prototypes
+ **	Operation: This routine compares Features against each character
+ **		normalization proto for ClassId and returns the match
+ **		rating of the best match.
+ **	Return: Best match rating for Feature against protos of ClassId.
+ **	Exceptions: none
+ **	History: Wed Dec 19 16:56:12 1990, DSJ, Created.
+ */
+  LIST Protos;
+  FLOAT32 BestMatch;
+  FLOAT32 Match;
+  FLOAT32 Delta;
+  PROTOTYPE *Proto;
+  int ProtoId;
+
+  /* handle requests for classification as noise */
+  if (ClassId == NO_CLASS) {
+    /* kludge - clean up constants and make into control knobs later */
+    Match = (Feature->Params[CharNormLength] *
+      Feature->Params[CharNormLength] * 500.0 +
+      Feature->Params[CharNormRx] *
+      Feature->Params[CharNormRx] * 8000.0 +
+      Feature->Params[CharNormRy] *
+      Feature->Params[CharNormRy] * 8000.0);
+    return (1.0 - NormEvidenceOf (Match));
+  }
+
+  BestMatch = MAX_FLOAT32;
+  Protos = NormProtos->Protos[ClassId];
+
+  if (DebugMatch) {
+    cprintf ("\nFeature = ");
+    WriteFeature(stdout, Feature);
+  }
+
+  ProtoId = 0;
+  iterate(Protos) {
+    Proto = (PROTOTYPE *) first_node (Protos);
+    Delta = Feature->Params[CharNormY] - Proto->Mean[CharNormY];
+    Match = Delta * Delta * Proto->Weight.Elliptical[CharNormY];
+    Delta = Feature->Params[CharNormRx] - Proto->Mean[CharNormRx];
+    Match += Delta * Delta * Proto->Weight.Elliptical[CharNormRx];
+
+    if (Match < BestMatch)
+      BestMatch = Match;
+
+    if (DebugMatch) {
+      cprintf ("Proto %1d = ", ProtoId);
+      WriteNFloats (stdout, NormProtos->NumParams, Proto->Mean);
+      cprintf ("      var = ");
+      WriteNFloats (stdout, NormProtos->NumParams,
+        Proto->Variance.Elliptical);
+      cprintf ("    match = ");
+      PrintNormMatch (stdout, NormProtos->NumParams, Proto, Feature);
+    }
+    ProtoId++;
+  }
+  return (1.0 - NormEvidenceOf (BestMatch));
+}                                /* ComputeNormMatch */
+
+
+/*---------------------------------------------------------------------------*/
+void GetNormProtos() {
+/*
+ **	Parameters: none
+ **	Globals:
+ **		NormProtoFile	name of file containing normalization protos
+ **		NormProtos	global data structure to hold protos
+ **	Operation: This routine reads in a set of character normalization
+ **		protos from NormProtoFile and places them into NormProtos.
+ **	Return: none
+ **	Exceptions: none
+ **	History: Wed Dec 19 16:24:25 1990, DSJ, Created.
+ */
+  FILE *File;
+  STRING name;
+
+  name = language_data_path_prefix;
+  name += NormProtoFile;
+  File = Efopen (name.string(), "r");
+  NormProtos = ReadNormProtos (File);
+  fclose(File);
+
+}                                /* GetNormProtos */
+
+void FreeNormProtos() {
+  if (NormProtos != NULL) {
+    for (int i = 0; i < NormProtos->NumProtos; i++)
+      FreeProtoList(&NormProtos->Protos[i]);
+    Efree(NormProtos->Protos);
+    Efree(NormProtos->ParamDesc);
+    Efree(NormProtos);
+    NormProtos = NULL;
+  }
+}
+
+/*---------------------------------------------------------------------------*/
+void InitNormProtoVars() {
+/*
+ **	Parameters: none
+ **	Globals:
+ **		NormProtoFile		filename for normalization protos
+ **	Operation: Initialize the control variables for the normalization
+ **				matcher.
+ **	Return: none
+ **	Exceptions: none
+ **	History: Mon Nov  5 17:22:10 1990, DSJ, Created.
+ */
+  VALUE dummy;
+
+  string_variable (NormProtoFile, "NormProtoFile", NORM_PROTO_FILE);
+
+  MakeNormAdjMidpoint();
+  MakeNormAdjCurl();
+
+}                                /* InitNormProtoVars */
+
+
+/**----------------------------------------------------------------------------
+              Private Code
+----------------------------------------------------------------------------**/
+/**********************************************************************
+ * NormEvidenceOf
+ *
+ * Return the new type of evidence number corresponding to this
+ * normalization adjustment.  The equation that represents the transform is:
+ *       1 / (1 + (NormAdj / midpoint) ^ curl)
+ **********************************************************************/
+FLOAT32 NormEvidenceOf(register FLOAT32 NormAdj) {
+  NormAdj /= NormAdjMidpoint;
+
+  if (NormAdjCurl == 3)
+    NormAdj = NormAdj * NormAdj * NormAdj;
+  else if (NormAdjCurl == 2)
+    NormAdj = NormAdj * NormAdj;
+  else
+    NormAdj = pow (NormAdj, NormAdjCurl);
+  return (1.0 / (1.0 + NormAdj));
+}
+
+
+/*---------------------------------------------------------------------------*/
+void PrintNormMatch(FILE *File,
+                    int NumParams,
+                    PROTOTYPE *Proto,
+                    FEATURE Feature) {
+/*
+ **	Parameters:
+ **		File		open text file to dump match debug info to
+ **		NumParams	# of parameters in proto and feature
+ **		Proto[]		array of prototype parameters
+ **		Feature[]	array of feature parameters
+ **	Globals: none
+ **	Operation: This routine dumps out detailed normalization match info.
+ **	Return: none
+ **	Exceptions: none
+ **	History: Wed Jan  2 09:49:35 1991, DSJ, Created.
+ */
+  int i;
+  FLOAT32 ParamMatch;
+  FLOAT32 TotalMatch;
+
+  for (i = 0, TotalMatch = 0.0; i < NumParams; i++) {
+    ParamMatch = (Feature->Params[i] - Mean (Proto, i)) /
+      StandardDeviation (Proto, i);
+
+    fprintf (File, " %6.1f", ParamMatch);
+
+    if (i == CharNormY || i == CharNormRx)
+      TotalMatch += ParamMatch * ParamMatch;
+  }
+  fprintf (File, " --> %6.1f (%4.2f)\n",
+    TotalMatch, NormEvidenceOf (TotalMatch));
+
+}                                /* PrintNormMatch */
+
+
+/*---------------------------------------------------------------------------*/
+NORM_PROTOS *ReadNormProtos(FILE *File) {
+/*
+ **	Parameters:
+ **		File	open text file to read normalization protos from
+ **	Globals: none
+ **	Operation: This routine allocates a new data structure to hold
+ **		a set of character normalization protos.  It then fills in
+ **		the data structure by reading from the specified File.
+ **	Return: Character normalization protos.
+ **	Exceptions: none
+ **	History: Wed Dec 19 16:38:49 1990, DSJ, Created.
+ */
+  NORM_PROTOS *NormProtos;
+  int i;
+  char unichar[UNICHAR_LEN + 1];
+  UNICHAR_ID unichar_id;
+  LIST Protos;
+  int NumProtos;
+
+  /* allocate and initialization data structure */
+  NormProtos = (NORM_PROTOS *) Emalloc (sizeof (NORM_PROTOS));
+  NormProtos->NumProtos = unicharset.size();
+  NormProtos->Protos = (LIST *) Emalloc (NormProtos->NumProtos * sizeof(LIST));
+  for (i = 0; i < NormProtos->NumProtos; i++)
+    NormProtos->Protos[i] = NIL;
+
+  /* read file header and save in data structure */
+  NormProtos->NumParams = ReadSampleSize (File);
+  NormProtos->ParamDesc = ReadParamDesc (File, NormProtos->NumParams);
+
+  /* read protos for each class into a separate list */
+  while (fscanf (File, "%s %d", unichar, &NumProtos) == 2) {
+    if (unicharset.contains_unichar(unichar)) {
+      unichar_id = unicharset.unichar_to_id(unichar);
+      Protos = NormProtos->Protos[unichar_id];
+      for (i = 0; i < NumProtos; i++)
+        Protos =
+            push_last (Protos, ReadPrototype (File, NormProtos->NumParams));
+      NormProtos->Protos[unichar_id] = Protos;
+    } else
+      cprintf("Error: unichar %s in normproto file is not in unichar set.\n");
+  }
+
+  return (NormProtos);
+
+}                                /* ReadNormProtos */

data/vendor/tesseract-2.04/classify/normmatch.h

@@ -0,0 +1,38 @@
+/******************************************************************************
+ **	Filename:    normmatch.h
+ **	Purpose:     Simple matcher based on character normalization features.
+ **	Author:      Dan Johnson
+ **	History:     Thu Dec 20 08:55:05 1990, 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.
+ ******************************************************************************/
+#ifndef NORMMATCH_H
+#define NORMMATCH_H
+
+/**----------------------------------------------------------------------------
+          Include Files and Type Defines
+----------------------------------------------------------------------------**/
+#include "matchdefs.h"
+//#include "cluster.h"
+#include "ocrfeatures.h"
+
+/**----------------------------------------------------------------------------
+          Public Function Prototypes
+----------------------------------------------------------------------------**/
+FLOAT32 ComputeNormMatch(CLASS_ID ClassId, FEATURE Feature, BOOL8 DebugMatch);
+
+void GetNormProtos();
+void FreeNormProtos();
+
+void InitNormProtoVars();
+
+#endif