tesseract_bin 1.0.0

data/vendor/tesseract-2.04/ccutil/tessclas.h

@@ -0,0 +1,135 @@
+#ifndef                    TESSCLAS_H
+#define                    TESSCLAS_H 1
+
+#define SPLINESIZE      23       /*max spline parts to a line */
+
+#define TBLOBFLAGS      4        /*No of flags in a blob */
+#define MAX_WO_CLASSES    3
+#define EDGEPTFLAGS     4        /*concavity,length etc. */
+
+typedef struct
+{
+  double a;                      /*x squared */
+  double b;                      /*x */
+  double c;                      /*constant */
+} QUAD_SPEC;                     /*definiton of quadratic */
+
+typedef struct
+{
+  int segments;                  /*no of spline segments */
+  int xstarts[SPLINESIZE];       /*start x coords */
+  QUAD_SPEC quads[SPLINESIZE];   /*quadratic sections */
+} SPLINE_SPEC;                   /*quadratic spline */
+
+typedef struct
+{
+  short x;                       /*absolute x coord */
+  short y;                       /*absolute y coord */
+} TPOINT;
+typedef TPOINT VECTOR;           /*structure for coordinates */
+
+typedef struct
+{
+  char dx;                       /*compact vectors */
+  char dy;
+} BYTEVEC;
+
+typedef struct edgeptstruct
+{
+  TPOINT pos;                    /*position */
+  VECTOR vec;                    /*vector to next point */
+  char flags[EDGEPTFLAGS];       /*concavity, length etc */
+  struct edgeptstruct *next;     /*anticlockwise element */
+  struct edgeptstruct *prev;     /*clockwise element */
+} EDGEPT;                        /*point on expanded outline */
+
+typedef struct blobstruct
+{
+  struct olinestruct *outlines;  /*list of outlines in blob */
+  char flags[TBLOBFLAGS];        /*blob flags */
+  char correct;                  /*correct text */
+  char guess;                    /*best guess */
+                                 /*quickie classification */
+  unsigned char classes[MAX_WO_CLASSES];
+                                 /*quickie ratings */
+  unsigned char values[MAX_WO_CLASSES];
+  struct blobstruct *next;       /*next blob in block */
+} TBLOB;                         /*blob structure */
+
+typedef struct olinestruct
+{
+  TPOINT topleft;                /*top left of loop */
+  TPOINT botright;               /*bottom right of loop */
+  TPOINT start;                  /*start of loop */
+  BYTEVEC *compactloop;          /*ptr to compacted loop */
+  EDGEPT *loop;                  /*edgeloop */
+  void *node;                    /*1st node on outline */
+  struct olinestruct *next;      /*next at this level */
+  struct olinestruct *child;     /*inner outline */
+} TESSLINE;                      /*outline structure */
+
+typedef struct wordstruct
+{
+  struct textrowstruct *row;     /*row it came from */
+  char *correct;                 /*correct word string */
+  char *guess;                   /*guess word string */
+  TBLOB *blobs;                  /*blobs in word */
+  int blanks;                    /*blanks before word */
+  int blobcount;                 /*no of blobs in word */
+  struct wordstruct *next;       /*next word */
+} TWERD;                         /*word structure */
+
+typedef struct textrowstruct
+{
+  int blobcount;                 /** count of blobs in row. **/
+  TBLOB *blobs;                  /*list of blobs in row */
+  TWERD *words;                  /*list of words in row */
+  int mean_y;                    /** y coordinate of centre of row **/
+  int max_y;                     /** y coordinate of top of row **/
+  int min_y;                     /** y coordinate of bottom of row **/
+  SPLINE_SPEC xheight;           /*top of row */
+  SPLINE_SPEC baseline;          /*bottom of row */
+  float descdrop;                /*descender drop */
+  float ascrise;                 /*ascender rise */
+  float lineheight;              /*average xheight-baseline */
+  int kerning;                   /*kerning of row */
+  int space;                     /*spacing of row */
+  float space_threshold;         /*Bayesian space limit */
+  int p_spaced;                  /*proportinal flag */
+  int b_space;                   /*block spacing */
+  int b_kern;                    /*block kerning */
+  struct textrowstruct *next;    /*next row in block */
+} TEXTROW;
+
+typedef struct blockstruct       /** list of coordinates **/
+{
+  TBLOB *blobs;                  /*blobs in block */
+  TEXTROW *rows;                 /*rows in block */
+  int blobcount;                 /*no of blobs */
+  short xmin;
+  short xmax;
+  short ymin;
+  short ymax;
+  char type;                     /** block type **/
+  char p_spaced;                 /** flag to show propertianal spacing **/
+  short rowcount;                /** number of rows **/
+  short leading;                 /** space between rows **/
+  short kerning;                 /** space between characters **/
+  short space;                   /** distance between char centres **/
+  short minwidth;                /*min width of char in block */
+  short p_size;                  /** point size of text **/
+  short l_margin;                /** posn of left margin **/
+  short italic;                  /** flag to show italic block **/
+  short spurious;                /** percentage of spurious characters **/
+  struct blockstruct *next;      /*next text block */
+} TEXTBLOCK;                     /*block from image */
+
+/**********************************************************************
+ * iterate_blobs
+ *
+ * Visit all the words in a list using a local variable.
+ **********************************************************************/
+
+#define iterate_blobs(blob,blobs)  \
+for (blob = blobs; blob != NULL; blob = blob->next)
+#endif

data/vendor/tesseract-2.04/ccutil/tessopt.cpp

@@ -0,0 +1,61 @@
+/**********************************************************************
+ * File:        getopt.c
+ * Description: Re-implementation of the unix code.
+ * Author:					Ray Smith
+ * Created:					Tue Nov 28 05:52:50 MST 1995
+ *
+ * (C) Copyright 1995, Hewlett-Packard Co.
+ ** 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          "mfcpch.h"     //precompiled headers
+#include          <string.h>
+#include          <stdio.h>
+#include          "tessopt.h"
+#include          "notdll.h"     //must be last include
+
+int tessoptind;
+char *tessoptarg;
+
+/**********************************************************************
+ * tessopt
+ *
+ * parse command line args.
+ **********************************************************************/
+
+int tessopt (                         //parse args
+inT32 argc,                      //arg count
+char *argv[],                    //args
+const char *arglist                    //string of arg chars
+) {
+  const char *arg;                     //arg char
+
+  if (tessoptind == 0)
+    tessoptind = 1;
+  if (tessoptind < argc && argv[tessoptind][0] == '-') {
+    arg = strchr (arglist, argv[tessoptind][1]);
+    if (arg == NULL || *arg == ':')
+      return '?';                //dud option
+    tessoptind++;
+    tessoptarg = argv[tessoptind];
+    if (arg[1] == ':') {
+      if (argv[tessoptind - 1][2] != '\0')
+                                 //immediately after
+        tessoptarg = argv[tessoptind - 1] + 2;
+      else
+        tessoptind++;
+    }
+    return *arg;
+  }
+  else
+    return EOF;
+}

data/vendor/tesseract-2.04/ccutil/tessopt.h

@@ -0,0 +1,30 @@
+/**********************************************************************
+ * File:        getopt.h
+ * Description: Re-implementation of the unix code.
+ * Author:					Ray Smith
+ * Created:					Tue Nov 28 05:52:50 MST 1995
+ *
+ * (C) Copyright 1995, Hewlett-Packard Co.
+ ** 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          "host.h"
+#include          "notdll.h"     //must be last include
+
+extern int tessoptind;
+extern char *tessoptarg;
+
+int tessopt (                     //parse args
+inT32 argc,                      //arg count
+char *argv[],                    //args
+const char *arglist                    //string of arg chars
+);

data/vendor/tesseract-2.04/ccutil/tprintf.cpp

@@ -0,0 +1,122 @@
+/**********************************************************************
+ * File:        tprintf.c
+ * Description: Trace version of printf - portable between UX and NT
+ * Author:      Phil Cheatle
+ * Created:     Wed Jun 28 15:01:15 BST 1995
+ *
+ * (C) Copyright 1995, Hewlett-Packard Ltd.
+ ** 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          "mfcpch.h"     //precompiled headers
+#include          <stdio.h>
+#include          <stdarg.h>
+#include          "strngs.h"
+#include          "varable.h"
+#include              "debugwin.h"
+//#include                                      "ipeerr.h"
+#include          "tprintf.h"
+
+#define MAX_MSG_LEN     1024
+
+#define EXTERN
+DLLSYM STRING_VAR (debug_file, "", "File to send tprintf output to");
+DLLSYM BOOL_VAR (debug_window_on, FALSE,
+"Send tprintf to window unless file set");
+
+DLLSYM void
+tprintf (                        //Trace printf
+const char *format, ...          //special message
+) {
+  va_list args;                  //variable args
+  static FILE *debugfp = NULL;   //debug file
+                                 //debug window
+  static DEBUG_WIN *debugwin = NULL;
+  inT32 offset = 0;              //into message
+  static char msg[MAX_MSG_LEN + 1];
+
+  va_start(args, format);  //variable list
+  #ifdef __MSW32__
+                                 //Format into msg
+  offset += _vsnprintf (msg + offset, MAX_MSG_LEN - offset, format, args);
+  #else
+                                 //Format into msg
+  offset += vsprintf (msg + offset, format, args);
+  #endif
+  va_end(args);
+
+  if (debugfp == NULL && strlen (debug_file.string ()) > 0)
+    debugfp = fopen (debug_file.string (), "w");
+  else if (debugfp != NULL && strlen (debug_file.string ()) == 0) {
+    fclose(debugfp);
+    debugfp = NULL;
+  }
+  if (debugfp != NULL)
+    fprintf (debugfp, "%s", msg);
+  else {
+
+    if (debug_window_on) {
+      if (debugwin == NULL)
+                                 //in pixels
+        debugwin = new DEBUG_WIN ("Debug Window", DEBUG_WIN_XPOS, DEBUG_WIN_YPOS,
+                                 //in pixels
+          DEBUG_WIN_XSIZE, DEBUG_WIN_YSIZE,
+          debug_lines);
+      debugwin->dprintf (msg);
+    }
+    else {
+      fprintf (stderr, "%s", msg);
+    }
+  }
+}
+
+
+/*************************************************************************
+ * pause_continue()
+ * UI for a debugging pause - to see an intermediate state
+ * Returns TRUE to continue as normal to the next pause in the current mode;
+ * FALSE to quit the current pausing mode.
+ *************************************************************************/
+
+DLLSYM BOOL8
+                                 //special message
+pause_continue (const char *format, ...
+) {
+  va_list args;                  //variable args
+  char msg[1000];
+  STRING str = STRING ("DEBUG PAUSE:\n");
+
+  va_start(args, format);  //variable list
+  vsprintf(msg, format, args);  //Format into msg
+  va_end(args);
+
+  #ifdef GRAPHICS_DISABLED
+  // No interaction allowed -> simply go on
+  return true;
+  #else
+
+  #ifdef __UNIX__
+  printf ("%s\n", msg);
+  printf ("Type \"c\" to cancel, anything else to continue: ");
+  char c = getchar ();
+  return (c != 'c');
+  #endif
+
+  #ifdef __MSW32__
+  str +=
+    STRING (msg) + STRING ("\nUse OK to continue, CANCEL to stop pausing");
+  //   return AfxMessageBox( str.string(), MB_OKCANCEL ) == IDOK;
+  return::MessageBox (NULL, msg, "IMGAPP",
+    MB_APPLMODAL | MB_OKCANCEL) == IDOK;
+  #endif
+
+  #endif
+}

data/vendor/tesseract-2.04/ccutil/tprintf.h

@@ -0,0 +1,35 @@
+/**********************************************************************
+ * File:        tprintf.c
+ * Description: Trace version of printf - portable between UX and NT
+ * Author:      Phil Cheatle
+ * Created:     Wed Jun 28 15:01:15 BST 1995
+ *
+ * (C) Copyright 1995, Hewlett-Packard Ltd.
+ ** 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           TPRINTF_H
+#define           TPRINTF_H
+
+#include                   "varable.h"
+
+extern DLLSYM STRING_VAR_H (debug_file, "", "File to send tprintf output to");
+extern DLLSYM BOOL_VAR_H (debug_window_on, TRUE,
+"Send tprintf to window unless file set");
+
+DLLSYM void tprintf (            //Trace printf
+const char *format, ...          //special message
+);
+                                 //special message
+DLLSYM BOOL8 pause_continue (const char *format, ...
+);
+#endif

data/vendor/tesseract-2.04/ccutil/unichar.cpp

@@ -0,0 +1,144 @@
+///////////////////////////////////////////////////////////////////////
+// File:        unichar.cpp
+// Description: Unicode character/ligature class.
+// Author:      Ray Smith
+// Created:     Wed Jun 28 17:05:01 PDT 2006
+//
+// (C) Copyright 2006, Google Inc.
+// 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 "unichar.h"
+
+#define UNI_MAX_LEGAL_UTF32 0x0010FFFF
+
+// Construct from a utf8 string. If len<0 then the string is null terminated.
+// If the string is too long to fit in the UNICHAR then it takes only what
+// will fit. Checks for illegal input and stops at an illegal sequence.
+// The resulting UNICHAR may be empty.
+UNICHAR::UNICHAR(const char* utf8_str, int len) {
+  int total_len = 0;
+  int step = 0;
+  if (len < 0) {
+    for (len = 0; utf8_str[len] != 0 && len < UNICHAR_LEN; ++len);
+  }
+  for (total_len = 0; total_len < len; total_len += step) {
+    step = utf8_step(utf8_str + total_len);
+    if (total_len + step > UNICHAR_LEN)
+      break;  // Too long.
+    if (step == 0)
+      break;  // Illegal first byte.
+    int i;
+    for (i = 1; i < step; ++i)
+      if ((utf8_str[total_len + i] & 0xc0) != 0x80)
+        break;
+    if (i < step)
+      break;  // Illegal surrogate
+  }
+  memcpy(chars, utf8_str, total_len);
+  if (total_len < UNICHAR_LEN) {
+    chars[UNICHAR_LEN - 1] = total_len;
+    while (total_len < UNICHAR_LEN - 1)
+      chars[total_len++] = 0;
+  }
+}
+
+// Construct from a single UCS4 character. Illegal values are ignored,
+// resulting in an empty UNICHAR.
+UNICHAR::UNICHAR(int unicode) {
+  const int bytemask = 0xBF;
+  const int bytemark = 0x80;
+
+  if (unicode < 0x80) {
+    chars[UNICHAR_LEN - 1] = 1;
+    chars[2] = 0;
+    chars[1] = 0;
+    chars[0] = static_cast<char>(unicode);
+  } else if (unicode < 0x800) {
+    chars[UNICHAR_LEN - 1] = 2;
+    chars[2] = 0;
+    chars[1] = static_cast<char>((unicode | bytemark) & bytemask);
+    unicode >>= 6;
+    chars[0] = static_cast<char>(unicode | 0xc0);
+  } else if (unicode < 0x10000) {
+    chars[UNICHAR_LEN - 1] = 3;
+    chars[2] = static_cast<char>((unicode | bytemark) & bytemask);
+    unicode >>= 6;
+    chars[1] = static_cast<char>((unicode | bytemark) & bytemask);
+    unicode >>= 6;
+    chars[0] = static_cast<char>(unicode | 0xe0);
+  } else if (unicode <= UNI_MAX_LEGAL_UTF32) {
+    chars[UNICHAR_LEN - 1] = 4;
+    chars[3] = static_cast<char>((unicode | bytemark) & bytemask);
+    unicode >>= 6;
+    chars[2] = static_cast<char>((unicode | bytemark) & bytemask);
+    unicode >>= 6;
+    chars[1] = static_cast<char>((unicode | bytemark) & bytemask);
+    unicode >>= 6;
+    chars[0] = static_cast<char>(unicode | 0xf0);
+  } else {
+    memset(chars, 0, UNICHAR_LEN);
+  }
+}
+
+// Get the first character as UCS-4.
+int UNICHAR::first_uni() const {
+  static const int utf8_offsets[5] = {
+    0, 0, 0x3080, 0xE2080, 0x3C82080
+  };
+  int uni = 0;
+  int len = utf8_step(chars);
+  const char* src = chars;
+
+  switch (len) {
+  default:
+    break;
+  case 4:
+    uni += static_cast<unsigned char>(*src++);
+    uni <<= 6;
+  case 3:
+    uni += static_cast<unsigned char>(*src++);
+    uni <<= 6;
+  case 2:
+    uni += static_cast<unsigned char>(*src++);
+    uni <<= 6;
+  case 1:
+    uni += static_cast<unsigned char>(*src++);
+  }
+  uni -= utf8_offsets[len];
+  return uni;
+}
+
+// Get a terminated UTF8 string: Must delete[] it after use.
+char* UNICHAR::utf8_str() const {
+  int len = utf8_len();
+  char* str = new char[len + 1];
+  memcpy(str, chars, len);
+  str[len] = 0;
+  return str;
+}
+
+// Get the number of bytes in the first character of the given utf8 string.
+int UNICHAR::utf8_step(const char* utf8_str) {
+  static const char utf8_bytes[256] = {
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+    3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, 4,4,4,4,4,4,4,4,0,0,0,0,0,0,0,0
+  };
+
+  return utf8_bytes[static_cast<unsigned char>(*utf8_str)];
+}

data/vendor/tesseract-2.04/ccutil/unichar.h

@@ -0,0 +1,84 @@
+///////////////////////////////////////////////////////////////////////
+// File:        unichar.h
+// Description: Unicode character/ligature class.
+// Author:      Ray Smith
+// Created:     Wed Jun 28 17:05:01 PDT 2006
+//
+// (C) Copyright 2006, Google Inc.
+// 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 TESSERACT_CCUTIL_UNICHAR_H__
+#define TESSERACT_CCUTIL_UNICHAR_H__
+
+#include <memory.h>
+
+// Maximum number of characters that can be stored in a UNICHAR. Must be
+// at least 4. Must not exceed 31 without changing the coding of length.
+#define UNICHAR_LEN 24
+
+// A UNICHAR_ID is the unique id of a unichar.
+typedef int UNICHAR_ID;
+
+// A variable to indicate an invalid or uninitialized unichar id.
+static const int INVALID_UNICHAR_ID = -1;
+// A special unichar that corresponds to INVALID_UNICHAR_ID.
+static const char INVALID_UNICHAR[] = "__INVALID_UNICHAR__";
+
+// The UNICHAR class holds a single classification result. This may be
+// a single Unicode character (stored as between 1 and 4 utf8 bytes) or
+// multple Unicode characters representing the NFKC expansion of a ligature
+// such as fi, ffl etc. These are also stored as utf8.
+class UNICHAR {
+ public:
+  UNICHAR() {
+    memset(chars, 0, UNICHAR_LEN);
+  }
+
+  // Construct from a utf8 string. If len<0 then the string is null terminated.
+  // If the string is too long to fit in the UNICHAR then it takes only what
+  // will fit.
+  UNICHAR(const char* utf8_str, int len);
+
+  // Construct from a single UCS4 character.
+  explicit UNICHAR(int unicode);
+
+  // Default copy constructor and operator= are OK.
+
+  // Get the first character as UCS-4.
+  int first_uni() const;
+
+  // Get the length of the UTF8 string.
+  int utf8_len() const {
+    int len = chars[UNICHAR_LEN - 1];
+    return len >=0 && len < UNICHAR_LEN ? len : UNICHAR_LEN;
+  }
+
+  // Get a UTF8 string, but NOT NULL terminated.
+  const char* utf8() const {
+    return chars;
+  }
+
+  // Get a terminated UTF8 string: Must delete[] it after use.
+  char* utf8_str() const;
+
+  // Get the number of bytes in the first character of the given utf8 string.
+  static int utf8_step(const char* utf8_str);
+
+ private:
+  // A UTF-8 representation of 1 or more Unicode characters.
+  // The last element (chars[UNICHAR_LEN - 1]) is a length if
+  // its value < UNICHAR_LEN, otherwise it is a genuine character.
+  char chars[UNICHAR_LEN];
+};
+
+#endif  // TESSERACT_CCUTIL_UNICHAR_H__