tesseract_bin 1.0.0

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

@@ -0,0 +1,482 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        seam.c  (Formerly seam.c)
+ * Description:
+ * Author:       Mark Seaman, OCR Technology
+ * Created:      Fri Oct 16 14:37:00 1987
+ * Modified:     Fri May 17 16:30:13 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 "seam.h"
+#include "callcpp.h"
+#include "structures.h"
+#include "makechop.h"
+
+#ifdef __UNIX__
+#include <assert.h>
+#endif
+
+/*----------------------------------------------------------------------
+              V a r i a b l e s
+----------------------------------------------------------------------*/
+#define NUM_STARTING_SEAMS  20
+
+#define SEAMBLOCK 100            /* Cells per block */
+makestructure (newseam, free_seam, printseam, SEAM,
+freeseam, SEAMBLOCK, "SEAM", seamcount);
+
+/*----------------------------------------------------------------------
+        Public Function Code
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * point_in_split
+ *
+ * Check to see if either of these points are present in the current
+ * split.  Return TRUE if one of them is.
+ **********************************************************************/
+bool point_in_split(SPLIT *split, EDGEPT *point1, EDGEPT *point2) {
+  return ((split) ?
+    ((exact_point (split->point1, point1) ||
+    exact_point (split->point1, point2) ||
+    exact_point (split->point2, point1) ||
+    exact_point (split->point2, point2)) ? TRUE : FALSE) : FALSE);
+}
+
+
+/**********************************************************************
+ * point_in_seam
+ *
+ * Check to see if either of these points are present in the current
+ * seam.  Return TRUE if one of them is.
+ **********************************************************************/
+bool point_in_seam(SEAM *seam, SPLIT *split) {
+  return (point_in_split (seam->split1, split->point1, split->point2) ||
+    point_in_split (seam->split2, split->point1, split->point2) ||
+    point_in_split (seam->split3, split->point1, split->point2));
+}
+
+
+/**********************************************************************
+ * add_seam
+ *
+ * Add another seam to a collection of seams.
+ **********************************************************************/
+SEAMS add_seam(SEAMS seam_list, SEAM *seam) {
+  return (array_push (seam_list, seam));
+}
+
+
+/**********************************************************************
+ * combine_seam
+ *
+ * Combine two seam records into a single seam.  Move the split
+ * references from the second seam to the first one.  The argument
+ * convention is patterned after strcpy.
+ **********************************************************************/
+void combine_seams(SEAM *dest_seam, SEAM *source_seam) {
+  dest_seam->priority += source_seam->priority;
+  dest_seam->location += source_seam->location;
+  dest_seam->location /= 2;
+
+  if (source_seam->split1) {
+    if (!dest_seam->split1)
+      dest_seam->split1 = source_seam->split1;
+    else if (!dest_seam->split2)
+      dest_seam->split2 = source_seam->split1;
+    else if (!dest_seam->split3)
+      dest_seam->split3 = source_seam->split1;
+    else
+      cprintf ("combine_seam: Seam is too crowded, can't be combined !\n");
+  }
+  if (source_seam->split2) {
+    if (!dest_seam->split2)
+      dest_seam->split2 = source_seam->split2;
+    else if (!dest_seam->split3)
+      dest_seam->split3 = source_seam->split2;
+    else
+      cprintf ("combine_seam: Seam is too crowded, can't be combined !\n");
+  }
+  if (source_seam->split3) {
+    if (!dest_seam->split3)
+      dest_seam->split3 = source_seam->split3;
+    else
+      cprintf ("combine_seam: Seam is too crowded, can't be combined !\n");
+  }
+  free_seam(source_seam);
+}
+
+
+/**********************************************************************
+ * delete_seam
+ *
+ * Free this seam record and the splits that are attached to it.
+ **********************************************************************/
+void delete_seam(void *arg) {  //SEAM  *seam)
+  SEAM *seam = (SEAM *) arg;
+
+  if (seam) {
+    if (seam->split1)
+      delete_split (seam->split1);
+    if (seam->split2)
+      delete_split (seam->split2);
+    if (seam->split3)
+      delete_split (seam->split3);
+    free_seam(seam);
+  }
+}
+
+
+/**********************************************************************
+ * free_seam_list
+ *
+ * Free all the seams that have been allocated in this list.  Reclaim
+ * the memory for each of the splits as well.
+ **********************************************************************/
+void free_seam_list(SEAMS seam_list) {
+  int x;
+
+  array_loop (seam_list, x) delete_seam (array_value (seam_list, x));
+  array_free(seam_list);
+}
+
+
+/**********************************************************************
+ * test_insert_seam
+ *
+ * Return true if insert_seam will succeed.
+ **********************************************************************/
+bool test_insert_seam(SEAMS seam_list,
+                      int index,
+                      TBLOB *left_blob,
+                      TBLOB *first_blob) {
+  SEAM *test_seam;
+  TBLOB *blob;
+  int test_index;
+  int list_length;
+
+  list_length = array_count (seam_list);
+  for (test_index = 0, blob = first_blob->next;
+  test_index < index; test_index++, blob = blob->next) {
+    test_seam = (SEAM *) array_value (seam_list, test_index);
+    if (test_index + test_seam->widthp < index &&
+        test_seam->widthp + test_index == index - 1 &&
+        account_splits_right(test_seam, blob) < 0)
+      return false;
+  }
+  for (test_index = index, blob = left_blob->next;
+  test_index < list_length; test_index++, blob = blob->next) {
+    test_seam = (SEAM *) array_value (seam_list, test_index);
+    if (test_index - test_seam->widthn >= index &&
+        test_index - test_seam->widthn == index &&
+        account_splits_left(test_seam, first_blob, blob) < 0)
+      return false;
+  }
+  return true;
+}
+
+/**********************************************************************
+ * insert_seam
+ *
+ * Add another seam to a collection of seams at a particular location
+ * in the seam array.
+ **********************************************************************/
+SEAMS insert_seam(SEAMS seam_list,
+                  int index,
+                  SEAM *seam,
+                  TBLOB *left_blob,
+                  TBLOB *first_blob) {
+  SEAM *test_seam;
+  TBLOB *blob;
+  int test_index;
+  int list_length;
+
+  list_length = array_count (seam_list);
+  for (test_index = 0, blob = first_blob->next;
+  test_index < index; test_index++, blob = blob->next) {
+    test_seam = (SEAM *) array_value (seam_list, test_index);
+    if (test_index + test_seam->widthp >= index) {
+      test_seam->widthp++;       /*got in the way */
+    }
+    else if (test_seam->widthp + test_index == index - 1) {
+      test_seam->widthp = account_splits_right(test_seam, blob);
+      if (test_seam->widthp < 0) {
+        cprintf ("Failed to find any right blob for a split!\n");
+        print_seam("New dud seam", seam);
+        print_seam("Failed seam", test_seam);
+      }
+    }
+  }
+  for (test_index = index, blob = left_blob->next;
+  test_index < list_length; test_index++, blob = blob->next) {
+    test_seam = (SEAM *) array_value (seam_list, test_index);
+    if (test_index - test_seam->widthn < index) {
+      test_seam->widthn++;       /*got in the way */
+    }
+    else if (test_index - test_seam->widthn == index) {
+      test_seam->widthn = account_splits_left(test_seam, first_blob, blob);
+      if (test_seam->widthn < 0) {
+        cprintf ("Failed to find any left blob for a split!\n");
+        print_seam("New dud seam", seam);
+        print_seam("Failed seam", test_seam);
+      }
+    }
+  }
+  return (array_insert (seam_list, index, seam));
+}
+
+
+/**********************************************************************
+ * account_splits_right
+ *
+ * Account for all the splits by looking to the right.
+ * in the blob list.
+ **********************************************************************/
+int account_splits_right(SEAM *seam, TBLOB *blob) {
+  inT8 found_em[3];
+  inT8 width;
+
+  found_em[0] = seam->split1 == NULL;
+  found_em[1] = seam->split2 == NULL;
+  found_em[2] = seam->split3 == NULL;
+  if (found_em[0] && found_em[1] && found_em[2])
+    return 0;
+  width = 0;
+  do {
+    if (!found_em[0])
+      found_em[0] = find_split_in_blob (seam->split1, blob);
+    if (!found_em[1])
+      found_em[1] = find_split_in_blob (seam->split2, blob);
+    if (!found_em[2])
+      found_em[2] = find_split_in_blob (seam->split3, blob);
+    if (found_em[0] && found_em[1] && found_em[2]) {
+      return width;
+    }
+    width++;
+    blob = blob->next;
+  }
+  while (blob != NULL);
+  return -1;
+}
+
+
+/**********************************************************************
+ * account_splits_left
+ *
+ * Account for all the splits by looking to the left.
+ * in the blob list.
+ **********************************************************************/
+int account_splits_left(SEAM *seam, TBLOB *blob, TBLOB *end_blob) {
+  static inT32 depth = 0;
+  static inT8 width;
+  static inT8 found_em[3];
+
+  if (blob != end_blob) {
+    depth++;
+    account_splits_left (seam, blob->next, end_blob);
+    depth--;
+  }
+  else {
+    found_em[0] = seam->split1 == NULL;
+    found_em[1] = seam->split2 == NULL;
+    found_em[2] = seam->split3 == NULL;
+    width = 0;
+  }
+  if (!found_em[0])
+    found_em[0] = find_split_in_blob (seam->split1, blob);
+  if (!found_em[1])
+    found_em[1] = find_split_in_blob (seam->split2, blob);
+  if (!found_em[2])
+    found_em[2] = find_split_in_blob (seam->split3, blob);
+  if (!found_em[0] || !found_em[1] || !found_em[2]) {
+    width++;
+    if (depth == 0) {
+      width = -1;
+    }
+  }
+  return width;
+}
+
+
+/**********************************************************************
+ * find_split_in_blob
+ *
+ * Return TRUE if the split is somewhere in this blob.
+ **********************************************************************/
+bool find_split_in_blob(SPLIT *split, TBLOB *blob) {
+  TESSLINE *outline;
+
+#if 0
+  for (outline = blob->outlines; outline != NULL; outline = outline->next)
+    if (is_split_outline (outline, split))
+      return TRUE;
+  return FALSE;
+#endif
+  for (outline = blob->outlines; outline != NULL; outline = outline->next)
+    if (point_in_outline(split->point1, outline))
+      break;
+  if (outline == NULL)
+    return FALSE;
+  for (outline = blob->outlines; outline != NULL; outline = outline->next)
+    if (point_in_outline(split->point2, outline))
+      return TRUE;
+  return FALSE;
+}
+
+
+/**********************************************************************
+ * join_two_seams
+ *
+ * Merge these two seams into a new seam.  Duplicate the split records
+ * in both of the input seams.  Return the resultant seam.
+ **********************************************************************/
+SEAM *join_two_seams(SEAM *seam1, SEAM *seam2) {
+  SEAM *result = NULL;
+  SEAM *temp;
+
+  assert(seam1 &&seam2);
+
+  if (((seam1->split3 == NULL && seam2->split2 == NULL) ||
+    (seam1->split2 == NULL && seam2->split3 == NULL) ||
+    seam1->split1 == NULL ||
+  seam2->split1 == NULL) && (!shared_split_points (seam1, seam2))) {
+    clone_seam(result, seam1);
+    clone_seam(temp, seam2);
+    combine_seams(result, temp);
+  }
+  return (result);
+}
+
+
+/**********************************************************************
+ * new_seam
+ *
+ * Create a structure for a "seam" between two blobs.  This data
+ * structure may actually hold up to three different splits.
+ * Initailization of this record is done by this routine.
+ **********************************************************************/
+SEAM *new_seam(PRIORITY priority,
+               int x_location,
+               SPLIT *split1,
+               SPLIT *split2,
+               SPLIT *split3) {
+  SEAM *seam;
+
+  seam = newseam ();
+
+  seam->priority = priority;
+  seam->location = x_location;
+  seam->widthp = 0;
+  seam->widthn = 0;
+  seam->split1 = split1;
+  seam->split2 = split2;
+  seam->split3 = split3;
+
+  return (seam);
+}
+
+
+/**********************************************************************
+ * new_seam_list
+ *
+ * Create a collection of seam records in an array.
+ **********************************************************************/
+SEAMS new_seam_list() {
+  return (array_new (NUM_STARTING_SEAMS));
+}
+
+
+/**********************************************************************
+ * print_seam
+ *
+ * Print a list of splits.  Show the coordinates of both points in
+ * each split.
+ **********************************************************************/
+void print_seam(const char *label, SEAM *seam) {
+  if (seam) {
+    cprintf(label);
+    cprintf (" %6.2f @ %5d, p=%d, n=%d ",
+      seam->priority, seam->location, seam->widthp, seam->widthn);
+
+    print_split (seam->split1);
+
+    if (seam->split2) {
+      cprintf (",   ");
+      print_split (seam->split2);
+
+      if (seam->split3) {
+        cprintf (",   ");
+        print_split (seam->split3);
+      }
+    }
+    cprintf ("\n");
+  }
+}
+
+
+/**********************************************************************
+ * print_seams
+ *
+ * Print a list of splits.  Show the coordinates of both points in
+ * each split.
+ **********************************************************************/
+void print_seams(const char *label, SEAMS seams) {
+  int x;
+  char number[CHARS_PER_LINE];
+
+  if (seams) {
+    cprintf ("%s\n", label);
+    array_loop(seams, x) {
+      sprintf (number, "%2d:   ", x);
+      print_seam (number, (SEAM *) array_value (seams, x));
+    }
+    cprintf ("\n");
+  }
+}
+
+
+/**********************************************************************
+ * shared_split_points
+ *
+ * Check these two seams to make sure that neither of them have two
+ * points in common. Return TRUE if any of the same points are present
+ * in any of the splits of both seams.
+ **********************************************************************/
+int shared_split_points(SEAM *seam1, SEAM *seam2) {
+  if (seam1 == NULL || seam2 == NULL)
+    return (FALSE);
+
+  if (seam2->split1 == NULL)
+    return (FALSE);
+  if (point_in_seam (seam1, seam2->split1))
+    return (TRUE);
+
+  if (seam2->split2 == NULL)
+    return (FALSE);
+  if (point_in_seam (seam1, seam2->split2))
+    return (TRUE);
+
+  if (seam2->split3 == NULL)
+    return (FALSE);
+  if (point_in_seam (seam1, seam2->split3))
+    return (TRUE);
+
+  return (FALSE);
+}

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

@@ -0,0 +1,136 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        seam.h  (Formerly seam.h)
+ * Description:
+ * Author:       Mark Seaman, SW Productivity
+ * Created:      Fri Oct 16 14:37:00 1987
+ * Modified:     Thu May 16 17:05:52 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 SEAM_H
+#define SEAM_H
+
+/*----------------------------------------------------------------------
+              I n c l u d e s
+----------------------------------------------------------------------*/
+#include "split.h"
+#include "tessarray.h"
+
+/*----------------------------------------------------------------------
+              T y p e s
+----------------------------------------------------------------------*/
+typedef float PRIORITY;          /*  PRIORITY  */
+
+typedef struct seam_record
+{                                /*  SEAM  */
+  PRIORITY priority;
+  inT8 widthp;
+  inT8 widthn;
+  inT16 location;
+  SPLIT *split1;
+  SPLIT *split2;
+  SPLIT *split3;
+} SEAM;
+
+typedef ARRAY SEAMS;             /*  SEAMS  */
+
+extern SEAM *newseam();
+
+/*----------------------------------------------------------------------
+              M a c r o s
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * clone_seam
+ *
+ * Create a new seam record and copy the contents of this seam into it.
+ **********************************************************************/
+
+#define clone_seam(dest,source)                       \
+if (source) {                                       \
+	(dest) = newseam ();                     \
+	(dest)->location = (source)->location;           \
+	(dest)->widthp = (source)->widthp;           \
+	(dest)->widthn = (source)->widthn;           \
+	(dest)->priority = (source)->priority;           \
+	clone_split ((dest)->split1, (source)->split1);  \
+	clone_split ((dest)->split2, (source)->split2);  \
+	clone_split ((dest)->split3, (source)->split3);  \
+}                                                   \
+else {                                              \
+	(dest) = (SEAM*) NULL;                           \
+}                                                   \
+
+
+/**********************************************************************
+ * exact_point
+ *
+ * Return TRUE if the point positions are the exactly the same. The
+ * parameters must be of type (EDGEPT*).
+ **********************************************************************/
+
+#define exact_point(p1,p2)                    \
+	(! ((p1->pos.x - p2->pos.x) || (p1->pos.y - p2->pos.y)))
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+bool point_in_split(SPLIT *split, EDGEPT *point1, EDGEPT *point2);
+
+bool point_in_seam(SEAM *seam, SPLIT *split);
+
+SEAMS add_seam(SEAMS seam_list, SEAM *seam);
+
+void combine_seams(SEAM *dest_seam, SEAM *source_seam);
+
+void delete_seam(void *arg);  //SEAM  *seam);
+
+void free_seam_list(SEAMS seam_list);
+
+bool test_insert_seam(SEAMS seam_list,
+                      int index,
+                      TBLOB *left_blob,
+                      TBLOB *first_blob);
+
+SEAMS insert_seam(SEAMS seam_list,
+                  int index,
+                  SEAM *seam,
+                  TBLOB *left_blob,
+                  TBLOB *first_blob);
+
+int account_splits_right(SEAM *seam, TBLOB *blob);
+
+int account_splits_left(SEAM *seam, TBLOB *blob, TBLOB *end_blob);
+
+bool find_split_in_blob(SPLIT *split, TBLOB *blob);
+
+SEAM *join_two_seams(SEAM *seam1, SEAM *seam2);
+
+SEAM *new_seam(PRIORITY priority,
+               int x_location,
+               SPLIT *split1,
+               SPLIT *split2,
+               SPLIT *split3);
+
+SEAMS new_seam_list();
+
+void print_seam(const char *label, SEAM *seam);
+
+void print_seams(const char *label, SEAMS seams);
+
+int shared_split_points(SEAM *seam1, SEAM *seam2);
+#endif