tesseract_bin 1.0.0

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

@@ -0,0 +1,258 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        protos.h  (Formerly protos.h)
+ * Description:
+ * Author:       Mark Seaman, SW Productivity
+ * Created:      Fri Oct 16 14:37:00 1987
+ * Modified:     Fri Jul 12 10:06:55 1991 (Dan Johnson) danj@hpgrlj
+ * Language:     C
+ * Package:      N/A
+ * Status:       Reusable Software Component
+ *
+ * (c) Copyright 1987, Hewlett-Packard Company.
+ ** 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 PROTOS_H
+#define PROTOS_H
+
+/*----------------------------------------------------------------------
+              I n c l u d e s
+----------------------------------------------------------------------*/
+#include "bitvec.h"
+#include "cutil.h"
+#include "unichar.h"
+
+/*----------------------------------------------------------------------
+              T y p e s
+----------------------------------------------------------------------*/
+typedef BIT_VECTOR *CONFIGS;
+
+typedef struct
+{
+  FLOAT32 A;
+  FLOAT32 B;
+  FLOAT32 C;
+  FLOAT32 X;
+  FLOAT32 Y;
+  FLOAT32 Angle;
+  FLOAT32 Length;
+} PROTO_STRUCT;
+typedef PROTO_STRUCT *PROTO;
+
+typedef struct
+{
+  inT16 NumProtos;
+  inT16 MaxNumProtos;
+  PROTO Prototypes;
+  inT16 NumConfigs;
+  inT16 MaxNumConfigs;
+  CONFIGS Configurations;
+} CLASS_STRUCT;
+typedef CLASS_STRUCT *CLASS_TYPE;
+typedef CLASS_STRUCT *CLASSES;
+
+/*----------------------------------------------------------------------
+              C o n s t a n t s
+----------------------------------------------------------------------*/
+#define NUMBER_OF_CLASSES  MAX_NUM_CLASSES
+#define Y_OFFSET           -40.0
+#define FEATURE_SCALE      100.0
+
+/*----------------------------------------------------------------------
+              V a r i a b l e s
+----------------------------------------------------------------------*/
+extern CLASS_STRUCT TrainingData[];
+
+/*----------------------------------------------------------------------
+              M a c r o s
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * AddProtoToConfig
+ *
+ * Set a single proto bit in the specified configuration.
+ **********************************************************************/
+
+#define AddProtoToConfig(Pid,Config)	\
+(SET_BIT (Config, Pid))
+
+/**********************************************************************
+ * RemoveProtoFromConfig
+ *
+ * Clear a single proto bit in the specified configuration.
+ **********************************************************************/
+
+#define RemoveProtoFromConfig(Pid,Config)	\
+(reset_bit (Config, Pid))
+
+/**********************************************************************
+ * ClassOfChar
+ *
+ * Return the class of a particular ASCII character value.
+ **********************************************************************/
+
+#define ClassOfChar(Char)            \
+((TrainingData [Char].NumProtos) ? \
+	(& TrainingData [Char])         : \
+	NO_CLASS)
+
+/**********************************************************************
+ * ProtoIn
+ *
+ * Choose the selected prototype in this class record.  Return the
+ * pointer to it (type PROTO).
+ **********************************************************************/
+
+#define ProtoIn(Class,Pid)  \
+(& (Class)->Prototypes [Pid])
+
+/**********************************************************************
+ * PrintProto
+ *
+ * Print out the contents of a prototype.   The 'Proto' argument is of
+ * type 'PROTO'.
+ **********************************************************************/
+
+#define PrintProto(Proto)                      \
+(cprintf ("X=%4.2f, Y=%4.2f, Angle=%4.2f",    \
+			Proto->X,                \
+			Proto->Y,                \
+			Proto->Length,                \
+			Proto->Angle))                \
+
+
+/**********************************************************************
+ * PrintProtoLine
+ *
+ * Print out the contents of a prototype.   The 'Proto' argument is of
+ * type 'PROTO'.
+ **********************************************************************/
+
+#define PrintProtoLine(Proto)             \
+(cprintf ("A=%4.2f, B=%4.2f, C=%4.2f",   \
+			Proto->A,           \
+			Proto->B,           \
+			Proto->C))           \
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+int AddConfigToClass(CLASS_TYPE Class);
+
+int AddProtoToClass(CLASS_TYPE Class);
+
+FLOAT32 ClassConfigLength(CLASS_TYPE Class, BIT_VECTOR Config);
+
+FLOAT32 ClassProtoLength(CLASS_TYPE Class);
+
+void CopyProto(PROTO Src, PROTO Dest);
+
+void FillABC(PROTO Proto);
+
+void FreeClass(CLASS_TYPE Class);
+
+void FreeClassFields(CLASS_TYPE Class);
+
+void InitPrototypes();
+
+CLASS_TYPE NewClass(int NumProtos, int NumConfigs);
+
+void PrintProtos(CLASS_TYPE Class);
+
+void ReadClassFile();
+
+void ReadClassFromFile(FILE *File, UNICHAR_ID unichar_id);
+
+void ReadConfigs(register FILE *File, CLASS_TYPE Class);
+
+void ReadProtos(register FILE *File, CLASS_TYPE Class);
+
+int SplitProto(CLASS_TYPE Class, int OldPid);
+
+void WriteOldConfigFile(FILE *File, CLASS_TYPE Class);
+
+void WriteOldProtoFile(FILE *File, CLASS_TYPE Class);
+
+/*
+#if defined(__STDC__) || defined(__cplusplus)
+# define _ARGS(s) s
+#else
+# define _ARGS(s) ()
+#endif*/
+
+/* protos.c *
+int AddConfigToClass
+  _ARGS((CLASS_TYPE Class));
+
+int AddProtoToClass
+  _ARGS((CLASS_TYPE Class));
+
+FLOAT32 ClassConfigLength
+  _ARGS((CLASS_TYPE Class,
+  BIT_VECTOR Config));
+
+FLOAT32 ClassProtoLength
+  _ARGS((CLASS_TYPE Class));
+
+void CopyProto
+  _ARGS((PROTO Src,
+  PROTO Dest));
+
+void FillABC
+  _ARGS((PROTO Proto));
+
+void FreeClass
+  _ARGS((CLASS_TYPE Class));
+
+void FreeClassFields
+  _ARGS((CLASS_TYPE Class));
+
+void InitPrototypes
+  _ARGS((void));
+
+CLASS_TYPE NewClass
+  _ARGS((int NumProtos,
+  int NumConfigs));
+
+void PrintProtos
+  _ARGS((CLASS_TYPE Class));
+
+void ReadClassFile
+  _ARGS((void));
+
+void ReadClassFromFile
+  _ARGS((FILE *File,
+  int ClassChar));
+
+void ReadConfigs
+  _ARGS((FILE *File,
+  CLASS_TYPE Class));
+
+void ReadProtos
+  _ARGS((FILE *File,
+  CLASS_TYPE Class));
+
+int SplitProto
+  _ARGS((CLASS_TYPE Class,
+  int OldPid));
+
+void WriteOldConfigFile
+  _ARGS((FILE *File,
+  CLASS_TYPE Class));
+
+void WriteOldProtoFile
+  _ARGS((FILE *File,
+  CLASS_TYPE Class));
+
+#undef _ARGS
+*/
+#endif

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

@@ -0,0 +1,225 @@
+/******************************************************************************
+ **	Filename:    sigmenu.c
+ **	Purpose:     General purpose, menu-oriented signal handling routines
+ **	Author:      Dan Johnson
+ **	History:     Mon Oct  2 07:25:50 1989, 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 "sigmenu.h"
+#include "oldlist.h"
+#include "emalloc.h"
+#include "secname.h"
+
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+
+#define MAX_COMMAND_LENGTH  128
+
+typedef struct
+{
+  int ItemNum;
+  char *ItemLabel;
+  int_void ItemFunc;
+} SIG_MENU_ITEM;
+
+/**----------------------------------------------------------------------------
+        Global Data Definitions and Declarations
+----------------------------------------------------------------------------**/
+static LIST SignalMenus[NSIG];   /* must be initialized to NIL */
+
+/**----------------------------------------------------------------------------
+          Private Function Prototypes
+----------------------------------------------------------------------------**/
+void MainSignalHandler(int Signal);
+
+SIG_MENU_ITEM *NewSignalMenuItem (int ItemNum,
+const char ItemLabel[], int_void ItemFunc);
+
+int ItemCompare(void *arg1,   //SIG_MENU_ITEM         *Item1,
+                void *arg2);  //SIG_MENU_ITEM         *Item2);
+
+/**----------------------------------------------------------------------------
+              Public Code
+----------------------------------------------------------------------------**/
+/*---------------------------------------------------------------------------*/
+void
+AddSignalMenuItem (int Signal,
+int ItemNum, const char ItemLabel[], int_void ItemFunc) {
+/*
+ **	Parameters:
+ **		Signal		signal to be trapped for this menu
+ **		ItemNum		menu number for this item
+ **		ItemLabel	menu label for this item
+ **		ItemFunc	function to be called when item is selected
+ **	Globals:
+ **		SignalMenus	list of menu items for each possible signal
+ **	Operation:
+ **		Add a new menu item to the list of menu items for Signal.
+ **		Whenever Signal is encountered, the user will be given
+ **		a list of options to choose from.  This list is the list
+ **		of all of the menu items that have been specified for that
+ **		Signal.
+ **	Return: none
+ **	Exceptions: none
+ **	History: Mon Oct  2 07:42:19 1989, DSJ, Created.
+ */
+  #if 0
+  #ifndef SECURE_NAMES
+  SIG_MENU_ITEM *NewItem;
+
+  /* check for a valid Signal */
+  if (Signal >= NSIG || Signal <= 0) {
+    cprintf ("Illegal signal (%d) specified for menu item!\n", Signal);
+    return;
+  }
+
+  /* if this is the first item for this signal, indicate that the
+     appropriate signal handler has been enabled */
+  if (SignalMenus[Signal] == NIL)
+    cprintf ("Signal handler enabled for signal %d.\n", Signal);
+
+  /* add the new menu item to the appropriate list of menu items */
+  NewItem = NewSignalMenuItem (ItemNum, ItemLabel, ItemFunc);
+  SignalMenus[Signal] = s_adjoin (SignalMenus[Signal], NewItem, ItemCompare);
+
+  /* set up the trap for the appropriate signal */
+  signal(Signal, MainSignalHandler);
+  #endif
+  #endif
+}                                /* AddSignalMenuItem */
+
+
+/**----------------------------------------------------------------------------
+              Private Code
+----------------------------------------------------------------------------**/
+/*---------------------------------------------------------------------------*/
+void MainSignalHandler(int Signal) {
+/*
+ **	Parameters:
+ **		Signal		signal that caused this function to be called
+ **	Globals:
+ **		SignalMenus	list of menu items for each possible signal
+ **	Operation: Provide the user with a menu of actions for the trapped
+ **		signal.  Execute the appropriate function.  If the function
+ **		returns SIG_RESUME, then terminate the signal handler and
+ **		resume normal processing.  If the function does not return
+ **		SIG_RESUME, remain in the main signal handler menu.
+ **	Return: none
+ **	Exceptions: none
+ **	History: Mon Oct  2 08:18:52 1989, DSJ, Created.
+ */
+  #ifndef SECURE_NAMES
+  int Command;
+  char CommandLine[MAX_COMMAND_LENGTH];
+  char *Params;
+  LIST Items;
+  SIG_MENU_ITEM *MenuItem;
+
+  while (TRUE) {
+    Command = -1;
+    cprintf ("\nMAIN SIGNAL HANDLER FOR SIGNAL %d\n", Signal);
+    cprintf ("0. Resume normal operation\n");
+
+    Items = SignalMenus[Signal];
+    iterate(Items) {
+      MenuItem = (SIG_MENU_ITEM *) first_node (Items);
+      cprintf ("%d. %s\n", MenuItem->ItemNum, MenuItem->ItemLabel);
+    }
+    cprintf ("\nEnter Selection: ");
+
+    while (fgets (CommandLine, MAX_COMMAND_LENGTH, stdin) == NULL
+      || strlen (CommandLine) <= 0);
+
+    Command = strtol (CommandLine, &Params, 10);
+    if (CommandLine == Params) {
+      cprintf ("\nIllegal command! - Try again.\n");
+      continue;
+    }
+
+    if (Command == 0)
+      signal(Signal, MainSignalHandler);
+
+    Items = SignalMenus[Signal];
+    iterate(Items) {
+      MenuItem = (SIG_MENU_ITEM *) first_node (Items);
+      if (Command == MenuItem->ItemNum) {
+        if ((*MenuItem->ItemFunc) ( /*Params */ ) == SIG_RESUME)
+          signal(Signal, MainSignalHandler);
+        break;
+      }
+    }
+    if (Items == NIL)
+      cprintf ("\nIllegal command! - Try again.\n");
+  }
+  #endif
+}                                /* MainSignalHandler */
+
+
+/*---------------------------------------------------------------------------*/
+SIG_MENU_ITEM *
+NewSignalMenuItem (int ItemNum, const char ItemLabel[], int_void ItemFunc) {
+/*
+ **	Parameters:
+ **		ItemNum		menu number for this item
+ **		ItemLabel	menu label for this item
+ **		ItemFunc	function to be called when item is selected
+ **	Globals: none
+ **	Operation: Allocate, initialize, and return a new signal menu item.
+ **	Return: Ptr to new signal menu item data structure.
+ **	Exceptions: none
+ **	History: Mon Oct  2 08:04:20 1989, DSJ, Created.
+ */
+  SIG_MENU_ITEM *NewItem;
+
+  NewItem = (SIG_MENU_ITEM *) Emalloc (sizeof (SIG_MENU_ITEM));
+  NewItem->ItemNum = ItemNum;
+  NewItem->ItemFunc = ItemFunc;
+  NewItem->ItemLabel = (char *) Emalloc (strlen (ItemLabel) + 1);
+  strcpy (NewItem->ItemLabel, ItemLabel);
+  return (NewItem);
+
+}                                /* NewSignalMenuItem */
+
+
+/*---------------------------------------------------------------------------*/
+int ItemCompare(void *arg1,    //SIG_MENU_ITEM         *Item1,
+                void *arg2) {  //SIG_MENU_ITEM         *Item2)
+/*
+ **	Parameters:
+ **		Item1, Item2	two menu items to be compared
+ **	Globals: none
+ **	Operation: Return -1 if the ItemNum of Item1 is less than the
+ **		ItemNum of Item2.  Return 0 if they are equal.  Return +1
+ **		if the ItemNum of Item1 is greater than the ItemNum of
+ **		Item2.  This routine is used by the list sorter to sort
+ **		lists of menu items according to their item number.
+ **	Return: -1, 0, or 1
+ **	Exceptions: none
+ **	History: Mon Oct  2 08:11:59 1989, DSJ, Created.
+ */
+  SIG_MENU_ITEM *Item1 = (SIG_MENU_ITEM *) arg1;
+  SIG_MENU_ITEM *Item2 = (SIG_MENU_ITEM *) arg2;
+
+  if (Item1->ItemNum < Item2->ItemNum)
+    return (-1);
+  else if (Item1->ItemNum == Item2->ItemNum)
+    return (0);
+  else if (Item1->ItemNum > Item2->ItemNum)
+    return (1);
+  else
+    return 0;
+}                                /* ItemCompare */

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

@@ -0,0 +1,39 @@
+/******************************************************************************
+ **	Filename:	sigmenu.h
+ **	Purpose:	Definition of signal handler routines
+ **	Author:		Dan Johnson
+ **	History:	10/2/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   SIGMENU_H
+#define   SIGMENU_H
+
+/**----------------------------------------------------------------------------
+          Include Files and Type Defines
+----------------------------------------------------------------------------**/
+#include "cutil.h"
+#include <signal.h>
+
+/* functions to be placed in the signal menu look like: */
+//typedef int   (*SIG_MENU_FUNC)(...);
+/* the value returned from a SIG_MENU_FUNC must be one of the following */
+#define SIG_RESUME      1
+#define SIG_MENU      0
+
+/**----------------------------------------------------------------------------
+          Public Function Prototypes
+----------------------------------------------------------------------------**/
+void AddSignalMenuItem (int Signal,
+int ItemNum,
+const char ItemLabel[], int_void ItemFunc);
+#endif

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

@@ -0,0 +1,127 @@
+/******************************************************************************
+ **	Filename:    speckle.c
+ **	Purpose:     Routines used by classifier to filter out speckle.
+ **	Author:      Dan Johnson
+ **	History:     Mon Mar 11 10:06:14 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 "speckle.h"
+#include "debug.h"
+#include "blobs.h"
+
+/**----------------------------------------------------------------------------
+        Global Data Definitions and Declarations
+----------------------------------------------------------------------------**/
+/* define control knobs for adjusting definition of speckle*/
+make_float_var (MaxLargeSpeckleSize, 0.30, MakeMaxLargeSpeckleSize,
+16, 2, SetMaxLargeSpeckleSize, "Max Large Speckle Size ...");
+
+make_float_var (SmallSpecklePenalty, 10.0, MakeSmallSpecklePenalty,
+16, 3, SetSmallSpecklePenalty, "Small Speckle Penalty ...");
+
+make_float_var (LargeSpecklePenalty, 10.0, MakeLargeSpecklePenalty,
+16, 4, SetLargeSpecklePenalty, "Large Speckle Penalty ...");
+
+make_float_var (SmallSpeckleCertainty, -1.0, MakeSmallSpeckleCertainty,
+16, 5, SetSmallSpeckleCertainty,
+"Small Speckle Certainty ...");
+
+/**----------------------------------------------------------------------------
+              Public Code
+----------------------------------------------------------------------------**/
+/*---------------------------------------------------------------------------*/
+LIST AddLargeSpeckleTo(LIST Choices) {
+/*
+ **	Parameters:
+ **		Choices		choices to add a speckle choice to
+ **	Globals:
+ **		SmallSpecklePenalty	rating for a small speckle
+ **		LargeSpecklePenalty	rating penalty for a large speckle
+ **		SmallSpeckleCertainty	certainty for a small speckle
+ **	Operation: This routine adds a null choice to Choices with a
+ **		rating equal to the worst rating in Choices plus a pad.
+ **		The certainty of the new choice is the same as the
+ **		certainty of the worst choice in Choices.  The new choice
+ **		is added to the end of Choices.
+ **	Return: New Choices list with null choice added to end.
+ **	Exceptions: none
+ **	History: Mon Mar 11 11:08:11 1991, DSJ, Created.
+ */
+  LIST WorstChoice;
+  char empty_lengths[] = {0};
+
+  /* if there are no other choices, use the small speckle penalty plus
+     the large speckle penalty */
+  if (Choices == NIL)
+    return (append_choice (NIL, "", empty_lengths, SmallSpecklePenalty + LargeSpecklePenalty,
+      SmallSpeckleCertainty, -1));
+
+  /* if there are other choices,  add a null choice that is slightly worse
+     than the worst choice so far */
+  WorstChoice = last (Choices);
+  return (append_choice (Choices, "", empty_lengths,
+    best_probability (WorstChoice) + LargeSpecklePenalty,
+    best_certainty (WorstChoice), -1));
+
+}                                /* AddLargeSpeckleTo */
+
+
+/*---------------------------------------------------------------------------*/
+void InitSpeckleVars() {
+/*
+ **	Parameters: none
+ **	Globals: none
+ **	Operation: Install the control variables needed for the speckle
+ **		filters.
+ **	Return: none
+ **	Exceptions: none
+ **	History: Mon Mar 11 12:04:59 1991, DSJ, Created.
+ */
+  MakeMaxLargeSpeckleSize();
+  MakeSmallSpecklePenalty();
+  MakeLargeSpecklePenalty();
+  MakeSmallSpeckleCertainty();
+}                                /* InitSpeckleVars */
+
+
+/*---------------------------------------------------------------------------*/
+BOOL8 LargeSpeckle(TBLOB *Blob, TEXTROW *Row) {
+/*
+ **	Parameters:
+ **		Blob		blob to test against speckle criteria
+ **		Row		text row that blob is in
+ **	Globals:
+ **		MaxLargeSpeckleSize	largest allowed speckle
+ **	Operation: This routine returns TRUE if both the width of height
+ **		of Blob are less than the MaxLargeSpeckleSize.
+ **	Return: TRUE if Blob is speckle, FALSE otherwise.
+ **	Exceptions: none
+ **	History: Mon Mar 11 10:06:49 1991, DSJ, Created.
+ */
+  FLOAT32 SpeckleSize;
+  TPOINT TopLeft;
+  TPOINT BottomRight;
+
+  SpeckleSize = RowHeight (Row) * MaxLargeSpeckleSize;
+  blob_bounding_box(Blob, &TopLeft, &BottomRight);
+
+  if (TopLeft.y - BottomRight.y < SpeckleSize &&
+    BottomRight.x - TopLeft.x < SpeckleSize)
+    return (TRUE);
+  else
+    return (FALSE);
+
+}                                /* LargeSpeckle */