tesseract_bin 1.0.0

data/vendor/tesseract-2.04/wordrec/makechop.cpp

@@ -0,0 +1,281 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        makechop.c  (Formerly makechop.c)
+ * Description:
+ * Author:   Mark Seaman, OCR Technology
+ * Created:  Fri Oct 16 14:37:00 1987
+ * Modified:     Mon Jul 29 15:50:42 1991 (Mark Seaman) marks@hpgrlt
+ * 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.
+ *
+ *********************************************************************************/
+/*----------------------------------------------------------------------
+      I n c l u d e s
+----------------------------------------------------------------------*/
+#include "makechop.h"
+#include "render.h"
+#include "structures.h"
+#ifdef __UNIX__
+#include <assert.h>
+#include <unistd.h>
+#endif
+
+/*----------------------------------------------------------------------
+        Public Function Code
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * apply_seam
+ *
+ * Split this blob into two blobs by applying the splits included in
+ * the seam description.
+ **********************************************************************/
+void apply_seam(TBLOB *blob, TBLOB *other_blob, SEAM *seam) {
+  check_outline_mem();
+  if (seam->split1 == NULL) {
+    divide_blobs (blob, other_blob, seam->location);
+  }
+  else if (seam->split2 == NULL) {
+    make_split_blobs(blob, other_blob, seam);
+  }
+  else if (seam->split3 == NULL) {
+    make_double_split(blob, other_blob, seam);
+  }
+  else {
+    make_triple_split(blob, other_blob, seam);
+  }
+
+  check_outline_mem();
+}
+
+
+/**********************************************************************
+ * divide_blobs
+ *
+ * Create two blobs by grouping the outlines in the appropriate blob.
+ * The outlines that are beyond the location point are moved to the
+ * other blob.  The ones whose x location is less than that point are
+ * retained in the original blob.
+ **********************************************************************/
+void divide_blobs(TBLOB *blob, TBLOB *other_blob, inT32 location) {
+  TESSLINE *outline;
+  TESSLINE *outline1 = NULL;
+  TESSLINE *outline2 = NULL;
+
+  outline = blob->outlines;
+  blob->outlines = NULL;
+
+  while (outline != NULL) {
+    if ((outline->topleft.x + outline->botright.x) / 2 < location) {
+      /* Outline is in 1st blob */
+      if (outline1) {
+        outline1->next = outline;
+      }
+      else {
+        blob->outlines = outline;
+      }
+      outline1 = outline;
+    }
+    else {
+      /* Outline is in 2nd blob */
+      if (outline2) {
+        outline2->next = outline;
+      }
+      else {
+        other_blob->outlines = outline;
+      }
+      outline2 = outline;
+    }
+
+    outline = outline->next;
+  }
+
+  if (outline1)
+    outline1->next = NULL;
+  if (outline2)
+    outline2->next = NULL;
+}
+
+
+/**********************************************************************
+ * form_two_blobs
+ *
+ * Group the outlines from the first blob into both of them. Do so
+ * according to the information about the split.
+ **********************************************************************/
+void form_two_blobs(TBLOB *blob, TBLOB *other_blob, inT32 location) {
+  setup_blob_outlines(blob);
+
+  divide_blobs(blob, other_blob, location);
+
+  eliminate_duplicate_outlines(blob);
+  eliminate_duplicate_outlines(other_blob);
+
+  correct_blob_order(blob, other_blob);
+
+#ifndef GRAPHICS_DISABLED
+  if (chop_debug > 2) {
+    display_blob(blob, Red);
+    #ifdef __UNIX__
+    sleep (1);
+    #endif
+    display_blob(other_blob, Cyan);
+  }
+#endif
+}
+
+
+/**********************************************************************
+ * make_double_split
+ *
+ * Create two blobs out of one by splitting the original one in half.
+ * Return the resultant blobs for classification.
+ **********************************************************************/
+void make_double_split(TBLOB *blob, TBLOB *other_blob, SEAM *seam) {
+  make_single_split (blob->outlines, seam->split1);
+  make_single_split (blob->outlines, seam->split2);
+  form_two_blobs (blob, other_blob, seam->location);
+}
+
+
+/**********************************************************************
+ * make_single_split
+ *
+ * Create two outlines out of one by splitting the original one in half.
+ * Return the resultant outlines.
+ **********************************************************************/
+void make_single_split(TESSLINE *outlines, SPLIT *split) {
+  assert (outlines != NULL);
+
+  split_outline (split->point1, split->point2);
+
+  while (outlines->next != NULL)
+    outlines = outlines->next;
+
+  outlines->next = newoutline ();
+  outlines->next->loop = split->point1;
+  outlines->next->child = NULL;
+  setup_outline (outlines->next);
+
+  outlines = outlines->next;
+
+  outlines->next = newoutline ();
+  outlines->next->loop = split->point2;
+  outlines->next->child = NULL;
+  setup_outline (outlines->next);
+
+  outlines->next->next = NULL;
+}
+
+
+/**********************************************************************
+ * make_split_blobs
+ *
+ * Create two blobs out of one by splitting the original one in half.
+ * Return the resultant blobs for classification.
+ **********************************************************************/
+void make_split_blobs(TBLOB *blob, TBLOB *other_blob, SEAM *seam) {
+  make_single_split (blob->outlines, seam->split1);
+
+  form_two_blobs (blob, other_blob, seam->location);
+}
+
+
+/**********************************************************************
+ * make_triple_split
+ *
+ * Create two blobs out of one by splitting the original one in half.
+ * This splitting is accomplished by applying three separate splits on
+ * the outlines. Three of the starting outlines will produce two ending
+ * outlines. Return the resultant blobs for classification.
+ **********************************************************************/
+void make_triple_split(TBLOB *blob, TBLOB *other_blob, SEAM *seam) {
+  make_single_split (blob->outlines, seam->split1);
+  make_single_split (blob->outlines, seam->split2);
+  make_single_split (blob->outlines, seam->split3);
+
+  form_two_blobs (blob, other_blob, seam->location);
+}
+
+
+/**********************************************************************
+ * undo_seam
+ *
+ * Remove the seam between these two blobs.  Produce one blob as a
+ * result.  The seam may consist of one, two, or three splits.  Each
+ * of these split must be removed from the outlines.
+ **********************************************************************/
+void undo_seam(TBLOB *blob, TBLOB *other_blob, SEAM *seam) {
+  TESSLINE *outline;
+
+  if (!seam)
+    return;                      /* Append other blob outlines */
+  if (blob->outlines == NULL) {
+    blob->outlines = other_blob->outlines;
+    other_blob->outlines = NULL;
+  }
+
+  outline = blob->outlines;
+  while (outline->next)
+    outline = outline->next;
+  outline->next = other_blob->outlines;
+  oldblob(other_blob);
+
+  if (seam->split1 == NULL) {
+  }
+  else if (seam->split2 == NULL) {
+    undo_single_split (blob, seam->split1);
+  }
+  else if (seam->split3 == NULL) {
+    undo_single_split (blob, seam->split1);
+    undo_single_split (blob, seam->split2);
+  }
+  else {
+    undo_single_split (blob, seam->split3);
+    undo_single_split (blob, seam->split2);
+    undo_single_split (blob, seam->split1);
+  }
+
+  setup_blob_outlines(blob);
+  eliminate_duplicate_outlines(blob);
+
+  check_outline_mem();
+}
+
+
+/**********************************************************************
+ * undo_single_split
+ *
+ * Undo a seam that is made by a single split.  Perform the correct
+ * magic to reconstruct the appropriate set of outline data structures.
+ **********************************************************************/
+void undo_single_split(TBLOB *blob, SPLIT *split) {
+  TESSLINE *outline1;
+  TESSLINE *outline2;
+  /* Modify edge points */
+  unsplit_outlines (split->point1, split->point2);
+
+  outline1 = newoutline ();
+  outline1->next = blob->outlines;
+  blob->outlines = outline1;
+  outline1->loop = split->point1;
+  outline1->child = NULL;
+
+  outline2 = newoutline ();
+  outline2->next = blob->outlines;
+  blob->outlines = outline2;
+  outline2->loop = split->point2;
+  outline2->child = NULL;
+}

data/vendor/tesseract-2.04/wordrec/makechop.h

@@ -0,0 +1,69 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        makechop.h  (Formerly makechop.h)
+ * Description:
+ * Author:	Mark Seaman, SW Productivity
+ * Created:	Fri Oct 16 14:37:00 1987
+ * Modified:     Mon Jul 29 13:33:23 1991 (Mark Seaman) marks@hpgrlt
+ * 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 MAKECHOP_H
+#define MAKECHOP_H
+
+/*----------------------------------------------------------------------
+      I n c l u d e s
+----------------------------------------------------------------------*/
+#include "chop.h"
+#include "olutil.h"
+
+/*----------------------------------------------------------------------
+      M a c r o s
+---------------------------------------------------------------------*/
+/**********************************************************************
+ * is_split_outline
+ *
+ * Check to see if both sides of the split fall within the bounding
+ * box of this outline.
+ **********************************************************************/
+
+#define is_split_outline(outline,split)          \
+(point_in_outline (split->point1, outline) &&  \
+	point_in_outline (split->point2, outline))    \
+
+
+/*----------------------------------------------------------------------
+        Public Function Prototypes
+----------------------------------------------------------------------*/
+void apply_seam(TBLOB *blob, TBLOB *other_blob, SEAM *seam);
+
+void divide_blobs(TBLOB *blob, TBLOB *other_blob, inT32 location);
+
+void form_two_blobs(TBLOB *blob, TBLOB *other_blob, inT32 location);
+
+void make_double_split(TBLOB *blob, TBLOB *other_blob, SEAM *seam);
+
+void make_single_split(TESSLINE *outlines, SPLIT *split);
+
+void make_split_blobs(TBLOB *blob, TBLOB *other_blob, SEAM *seam);
+
+void make_triple_split(TBLOB *blob, TBLOB *other_blob, SEAM *seam);
+
+void undo_seam(TBLOB *blob, TBLOB *other_blob, SEAM *seam);
+
+void undo_single_split(TBLOB *blob, SPLIT *split);
+#endif

data/vendor/tesseract-2.04/wordrec/matchtab.cpp

@@ -0,0 +1,191 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        matchtab.c  (Formerly matchtab.c)
+ * Description:  Match table to retain blobs that were matched.
+ * Author:       Mark Seaman, OCR Technology
+ * Created:      Mon Jan 29 09:00:56 1990
+ * Modified:     Tue Mar 19 15:09:06 1991 (Mark Seaman) marks@hpgrlt
+ * Language:     C
+ * Package:      N/A
+ * Status:       Experimental (Do Not Distribute)
+ *
+ * (c) Copyright 1990, 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.
+ *
+ *********************************************************************************/
+/*----------------------------------------------------------------------
+              I n c l u d e s
+----------------------------------------------------------------------*/
+#include "matchtab.h"
+#include "freelist.h"
+#include "callcpp.h"
+#include "blobs.h"
+
+/*----------------------------------------------------------------------
+              T y p e s
+----------------------------------------------------------------------*/
+typedef struct _MATCH_
+{
+  int topleft;
+  int botright;
+  LIST rating;
+} MATCH;
+
+/*----------------------------------------------------------------------
+              V a r i a b l e s
+----------------------------------------------------------------------*/
+MATCH *match_table;
+//?int   missed_count = 0;
+
+/*----------------------------------------------------------------------
+              M a c r o s
+----------------------------------------------------------------------*/
+#define NUM_MATCH_ENTRIES 500    /* Entries in match_table */
+
+/**********************************************************************
+ * blank_entry
+ *
+ * Test an element in the blob match table to see if it is blank.
+ * Return a non-zero value if it is blank.
+ **********************************************************************/
+
+#define blank_entry(match_table,x)  \
+(! (match_table[x].topleft | match_table[x].botright))
+
+/*----------------------------------------------------------------------
+          Public Function Code
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * init_match_table
+ *
+ * Create and clear a match table to be used to speed up the splitter.
+ **********************************************************************/
+static int been_initialized = 0;
+void init_match_table() {
+  int x;
+
+  if (been_initialized) {
+    /* Reclaim old choices */
+    for (x = 0; x < NUM_MATCH_ENTRIES; x++) {
+      if ((!blank_entry (match_table, x)) && match_table[x].rating)
+        destroy_nodes (match_table[x].rating, free_choice);
+    }
+  }
+  else {
+    /* Allocate memory once */
+    been_initialized = 1;
+    match_table = (MATCH *) memalloc (sizeof (MATCH) * NUM_MATCH_ENTRIES);
+  }
+  /* Initialize the table */
+  for (x = 0; x < NUM_MATCH_ENTRIES; x++) {
+    match_table[x].topleft = 0;
+    match_table[x].botright = 0;
+    match_table[x].rating = NULL;
+  }
+}
+
+void end_match_table() {
+  if (been_initialized) {
+    init_match_table();
+    memfree(match_table);
+    match_table = NULL;
+    been_initialized = 0;
+  }
+}
+
+
+/**********************************************************************
+ * put_match
+ *
+ * Put a new blob and its corresponding match ratings into the match
+ * table.
+ **********************************************************************/
+void put_match(TBLOB *blob, CHOICES ratings) {
+  unsigned int topleft;
+  unsigned int botright;
+  unsigned int start;
+  TPOINT tp_topleft;
+  TPOINT tp_botright;
+  int x;
+  /* Hash into table */
+  blob_bounding_box(blob, &tp_topleft, &tp_botright);
+  topleft = *(unsigned int *) &tp_topleft;
+  botright = *(unsigned int *) &tp_botright;
+  start = (topleft * botright) % NUM_MATCH_ENTRIES;
+
+  /* Look for empty */
+  x = start;
+  do {
+    if (blank_entry (match_table, x)) {
+      /* Add this entry */
+      match_table[x].topleft = topleft;
+      match_table[x].botright = botright;
+      match_table[x].rating = copy_choices (ratings);
+      return;
+    }
+    if (++x >= NUM_MATCH_ENTRIES)
+      x = 0;
+  }
+  while (x != start);
+
+  cprintf ("error: Match table is full\n");
+}
+
+
+/**********************************************************************
+ * get_match
+ *
+ * Look up this blob in the match table to see if it needs to be
+ * matched.  If it is not present then NULL is returned.
+ **********************************************************************/
+CHOICES get_match(TBLOB *blob) {
+  unsigned int topleft;
+  unsigned int botright;
+  TPOINT tp_topleft;
+  TPOINT tp_botright;
+  /* Do starting hash */
+  blob_bounding_box(blob, &tp_topleft, &tp_botright);
+  topleft = *(unsigned int *) &tp_topleft;
+  botright = *(unsigned int *) &tp_botright;
+  return (get_match_by_bounds (topleft, botright));
+}
+
+
+/**********************************************************************
+ * get_match_by_bounds
+ *
+ * Look up this blob in the match table to see if it needs to be
+ * matched.  If it is not present then NULL is returned.
+ **********************************************************************/
+CHOICES get_match_by_bounds(unsigned int topleft, unsigned int botright) {
+  unsigned int start;
+  int x;
+  /* Do starting hash */
+  start = (topleft * botright) % NUM_MATCH_ENTRIES;
+  /* Search for match */
+  x = start;
+  do {
+    /* Not found when blank */
+    if (blank_entry (match_table, x))
+      break;
+    /* Is this the match ? */
+    if (match_table[x].topleft == topleft &&
+    match_table[x].botright == botright) {
+      return (copy_choices (match_table[x].rating));
+    }
+    if (++x >= NUM_MATCH_ENTRIES)
+      x = 0;
+  }
+  while (x != start);
+
+  return (NIL);
+}

data/vendor/tesseract-2.04/wordrec/matchtab.h

@@ -0,0 +1,45 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        matchtab.h  (Formerly matchtab.h)
+ * Description:  Match table to retain blobs that were matched.
+ * Author:       Mark Seaman, OCR Technology
+ * Created:      Mon Jan 29 09:00:56 1990
+ * Modified:     Tue Mar 19 15:38:19 1991 (Mark Seaman) marks@hpgrlt
+ * Language:     C
+ * Package:      N/A
+ * Status:       Experimental (Do Not Distribute)
+ *
+ * (c) Copyright 1990, 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 MATCHTAB_H
+#define MATCHTAB_H
+
+/*----------------------------------------------------------------------
+              I n c l u d e s
+----------------------------------------------------------------------*/
+#include "choices.h"
+#include "tessclas.h"
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+void init_match_table();
+void end_match_table();
+
+void put_match(TBLOB *blob, CHOICES ratings);
+
+CHOICES get_match(TBLOB *blob);
+
+CHOICES get_match_by_bounds(unsigned int topleft, unsigned int botright);
+#endif

data/vendor/tesseract-2.04/wordrec/matrix.cpp

@@ -0,0 +1,118 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        matrix.c  (Formerly matrix.c)
+ * Description:  Ratings matrix code. (Used by associator)
+ * Author:       Mark Seaman, OCR Technology
+ * Created:      Wed May 16 13:18:47 1990
+ * Modified:     Wed Mar 20 09:44:47 1991 (Mark Seaman) marks@hpgrlt
+ * Language:     C
+ * Package:      N/A
+ * Status:       Experimental (Do Not Distribute)
+ *
+ * (c) Copyright 1990, 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.
+ *
+ *********************************************************************************/
+/*----------------------------------------------------------------------
+              I n c l u d e s
+----------------------------------------------------------------------*/
+#include "matrix.h"
+#include "cutil.h"
+#include "freelist.h"
+#include "callcpp.h"
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * create_matrix
+ *
+ * Allocate a piece of memory to hold a matrix of choice list pointers.
+ * initialize all the elements of the matrix to NULL.
+ **********************************************************************/
+MATRIX create_matrix(int dimension) {
+  MATRIX m;
+  int x;
+  int y;
+
+  m = (MATRIX) memalloc ((dimension * dimension + 1) * sizeof (LIST));
+  m[0] = (LIST) dimension;
+  for (x = 0; x < dimension; x++)
+    for (y = 0; y < dimension; y++)
+      matrix_put(m, x, y, NOT_CLASSIFIED);
+  return (m);
+}
+
+
+/**********************************************************************
+ * free_matrix
+ *
+ * Deallocate the memory taken up by a matrix of match ratings.
+ *********************************************************************/
+void free_matrix(MATRIX matrix) {
+  int x;
+  int y;
+  int dimension = matrix_dimension (matrix);
+  CHOICES matrix_cell;
+
+  for (x = 0; x < dimension; x++) {
+    for (y = 0; y < dimension; y++) {
+      matrix_cell = matrix_get (matrix, x, y);
+      if (matrix_cell != NOT_CLASSIFIED)
+        free_choices(matrix_cell);
+    }
+  }
+  memfree(matrix);
+}
+
+
+/**********************************************************************
+ * print_matrix
+ *
+ * Print the best guesses out of the match rating matrix.
+ **********************************************************************/
+void print_matrix(MATRIX rating_matrix) {
+  int x;
+  int dimension;
+  int spread;
+  CHOICES rating;
+
+  cprintf ("Ratings Matrix (top choices)\n");
+
+  dimension = matrix_dimension (rating_matrix);
+  /* Do each diagonal */
+  for (spread = 0; spread < dimension; spread++) {
+    /* For each spot */
+    for (x = 0; x < dimension - spread; x++) {
+      /* Process one square */
+      rating = matrix_get (rating_matrix, x, x + spread);
+
+      if (rating != NOT_CLASSIFIED) {
+        cprintf ("\t[%d,%d] : ", x, x + spread);
+        if (first_node (rating))
+          cprintf ("%-10s%4.0f\t|\t",
+            class_string (first_node (rating)),
+            class_probability (first_node (rating)));
+        if (second_node (rating))
+          cprintf ("%-10s%4.0f\t|\t",
+            class_string (second_node (rating)),
+            class_probability (second_node (rating)));
+        if (third (rating))
+          cprintf ("%-10s%4.0f\n",
+            class_string (third (rating)),
+            class_probability (third (rating)));
+        else
+          new_line();
+      }
+    }
+  }
+}