tesseract_bin 1.0.0

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

@@ -0,0 +1,226 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        gradechop.c  (Formerly gradechop.c)
+ * Description:
+ * Author:       Mark Seaman, OCR Technology
+ * Created:      Fri Oct 16 14:37:00 1987
+ * Modified:     Tue Jul 30 16:06:27 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 "gradechop.h"
+#include "debug.h"
+#include "olutil.h"
+#include "chop.h"
+#include <math.h>
+
+/*----------------------------------------------------------------------
+              T y p e s
+----------------------------------------------------------------------*/
+#define CENTER_GRADE_CAP 25.0
+
+/*----------------------------------------------------------------------
+              M a c r o s
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * find_bounds_loop
+ *
+ * This is a macro to be used by set_outline_bounds.
+ **********************************************************************/
+
+#define find_bounds_loop(point1,point2,x_min,x_max)     \
+	x_min = point2->pos.x;                               \
+	x_max = point2->pos.x;                               \
+																		\
+	this_point = point1;                                 \
+	do {                                                 \
+		x_min = min (this_point->pos.x, x_min);           \
+		x_max = max (this_point->pos.x, x_max);           \
+		this_point = this_point->next;                    \
+	}                                                    \
+	while (this_point != point2 && this_point != point1) \
+
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * full_split_priority
+ *
+ * Assign a priority to this split based on the features that it has.
+ * Part of the priority has already been calculated so just return the
+ * additional amount for the bounding box type information.
+ **********************************************************************/
+PRIORITY full_split_priority(SPLIT *split, inT16 xmin, inT16 xmax) {
+  BOUNDS_RECT rect;
+
+  set_outline_bounds (split->point1, split->point2, rect);
+
+  if (xmin < min (rect[0], rect[2]) && xmax > max (rect[1], rect[3]))
+    return (999.0);
+
+  return (grade_overlap (rect) +
+    grade_center_of_blob (rect) + grade_width_change (rect));
+}
+
+
+/**********************************************************************
+ * grade_center_of_blob
+ *
+ * Return a grade for the a split.  Rank it on closeness to the center
+ * of the original blob
+ *   0    =  "perfect"
+ *   100  =  "no way jay"
+ **********************************************************************/
+PRIORITY grade_center_of_blob(register BOUNDS_RECT rect) {
+  register PRIORITY grade;
+
+  grade = (rect[1] - rect[0]) - (rect[3] - rect[2]);
+  if (grade < 0)
+    grade = -grade;
+
+  grade *= center_knob;
+  grade = min (CENTER_GRADE_CAP, grade);
+  return (max (0.0, grade));
+}
+
+
+/**********************************************************************
+ * grade_overlap
+ *
+ * Return a grade for this split for the overlap of the resultant blobs.
+ *   0    =  "perfect"
+ *   100  =  "no way jay"
+ **********************************************************************/
+PRIORITY grade_overlap(register BOUNDS_RECT rect) {
+  register PRIORITY grade;
+  register inT16 width1;
+  register inT16 width2;
+  register inT16 overlap;
+
+  width1 = rect[3] - rect[2];
+  width2 = rect[1] - rect[0];
+
+  overlap = min (rect[1], rect[3]) - max (rect[0], rect[2]);
+  width1 = min (width1, width2);
+  if (overlap == width1)
+    return (100.0);              /* Total overlap */
+
+  width1 = 2 * overlap - width1; /* Extra penalty for too */
+  overlap += max (0, width1);    /* much overlap */
+
+  grade = overlap * overlap_knob;
+
+  return (max (0.0, grade));
+}
+
+
+/**********************************************************************
+ * grade_split_length
+ *
+ * Return a grade for the length of this split.
+ *   0    =  "perfect"
+ *   100  =  "no way jay"
+ **********************************************************************/
+PRIORITY grade_split_length(register SPLIT *split) {
+  register PRIORITY grade;
+  register float split_length;
+
+  split_length = weighted_edgept_dist (split->point1, split->point2,
+    x_y_weight);
+
+  if (split_length <= 0)
+    grade = 0;
+  else
+    grade = sqrt (split_length) * split_dist_knob;
+
+  return (max (0.0, grade));
+}
+
+
+/**********************************************************************
+ * grade_sharpness
+ *
+ * Return a grade for the sharpness of this split.
+ *   0    =  "perfect"
+ *   100  =  "no way jay"
+ **********************************************************************/
+PRIORITY grade_sharpness(register SPLIT *split) {
+  register PRIORITY grade;
+
+  grade = point_priority (split->point1) + point_priority (split->point2);
+
+  if (grade < -360.0)
+    grade = 0;
+  else
+    grade += 360.0;
+
+  grade *= sharpness_knob;       /* Values 0 to -360 */
+
+  return (grade);
+}
+
+
+/**********************************************************************
+ * grade_width_change
+ *
+ * Return a grade for the change in width of the resultant blobs.
+ *   0    =  "perfect"
+ *   100  =  "no way jay"
+ **********************************************************************/
+PRIORITY grade_width_change(register BOUNDS_RECT rect) {
+  register PRIORITY grade;
+  register inT32 width1;
+  register inT32 width2;
+
+  width1 = rect[3] - rect[2];
+  width2 = rect[1] - rect[0];
+
+  grade = 20 - (max (rect[1], rect[3])
+    - min (rect[0], rect[2]) - max (width1, width2));
+
+  grade *= width_change_knob;
+
+  return (max (0.0, grade));
+}
+
+
+/**********************************************************************
+ * set_outline_bounds
+ *
+ * Set up the limits for the x coordinate of the outline.
+ **********************************************************************/
+void set_outline_bounds(register EDGEPT *point1,
+                        register EDGEPT *point2,
+                        BOUNDS_RECT rect) {
+  register EDGEPT *this_point;
+  register inT16 x_min;
+  register inT16 x_max;
+
+  find_bounds_loop(point1, point2, x_min, x_max);
+
+  rect[0] = x_min;
+  rect[1] = x_max;
+
+  find_bounds_loop(point2, point1, x_min, x_max);
+
+  rect[2] = x_min;
+  rect[3] = x_max;
+}

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

@@ -0,0 +1,91 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        gradechop.h  (Formerly gradechop.h)
+ * Description:
+ * Author:       Mark Seaman, SW Productivity
+ * Created:      Fri Oct 16 14:37:00 1987
+ * Modified:     Tue Jul  9 16:40:39 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 GRADECHOP_H
+#define GRADECHOP_H
+
+/*----------------------------------------------------------------------
+              I n c l u d e s
+----------------------------------------------------------------------*/
+#include "seam.h"
+
+/*----------------------------------------------------------------------
+              T y p e s
+----------------------------------------------------------------------*/
+typedef inT16 BOUNDS_RECT[4];
+
+/*----------------------------------------------------------------------
+              V a r i a b l e s
+---------------------------------------------------------------------*/
+extern int x_y_weight;
+
+/*----------------------------------------------------------------------
+              M a c r o s
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * partial_split_priority
+ *
+ * Assign a priority to this split based on the features that it has.
+ * Grade it according to the different rating schemes and return the
+ * value of its goodness.
+ **********************************************************************/
+
+#define partial_split_priority(split)  \
+(grade_split_length   (split) +      \
+	grade_sharpness      (split))       \
+
+
+/**********************************************************************
+ * split_bounds_overlap
+ *
+ * Check to see if this split might overlap with this outline.  Return
+ * TRUE if there is a positive overlap in the bounding boxes of the two.
+ **********************************************************************/
+
+#define split_bounds_overlap(split,outline)  \
+(outline->topleft.x  <= max (split->point1->pos.x,split->point2->pos.x) && \
+	outline->botright.x >= min (split->point1->pos.x,split->point2->pos.x) && \
+	outline->botright.y <= max (split->point1->pos.y,split->point2->pos.y) && \
+	outline->topleft.y  >= min (split->point1->pos.y,split->point2->pos.y))
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+PRIORITY full_split_priority(SPLIT *split, inT16 xmin, inT16 xmax);
+
+PRIORITY grade_center_of_blob(register BOUNDS_RECT rect);
+
+PRIORITY grade_overlap(register BOUNDS_RECT rect);
+
+PRIORITY grade_split_length(register SPLIT *split);
+
+PRIORITY grade_sharpness(register SPLIT *split);
+
+PRIORITY grade_width_change(register BOUNDS_RECT rect);
+
+void set_outline_bounds(register EDGEPT *point1,
+                        register EDGEPT *point2,
+                        BOUNDS_RECT rect);
+#endif

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

@@ -0,0 +1,194 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        heuristic.c  (Formerly heuristic.c)
+ * Description:
+ * Author:       Mark Seaman, OCR Technology
+ * Created:      Fri Oct 16 14:37:00 1987
+ * Modified:     Wed Jul 10 14:15:08 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 "heuristic.h"
+#include "baseline.h"
+#include "metrics.h"
+#include "freelist.h"
+#include <math.h>
+
+/*----------------------------------------------------------------------
+              M a c r o s
+----------------------------------------------------------------------*/
+#define MAX_SQUAT       2.0      /* Width ratio */
+#define BAD_RATING   1000.0      /* No valid blob */
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * prioritize_state
+ *
+ * Create a priority for this state.  It represents the urgency of
+ * checking this state.
+ **********************************************************************/
+FLOAT32 prioritize_state(CHUNKS_RECORD *chunks_record,
+                         SEARCH_RECORD *the_search,
+                         STATE *old_state) {
+  FLOAT32 width_pri;
+  FLOAT32 match_pri;
+
+  match_pri = rating_priority (chunks_record, the_search->this_state,
+    old_state, the_search->num_joints);
+
+  width_pri = width_priority (chunks_record, the_search->this_state,
+    the_search->num_joints) * 1000.0;
+
+  record_priorities(the_search, old_state, match_pri, width_pri);
+
+  return (width_pri + match_pri);
+}
+
+
+/**********************************************************************
+ * rating_priority
+ *
+ * Assign a segmentation priority based on the ratings of the blobs
+ * (in that segmentation) that have been classified.  The average
+ * "goodness" (i.e. rating / weight) for each blob is used to indicate
+ * the segmentation priority.
+ **********************************************************************/
+FLOAT32 rating_priority(CHUNKS_RECORD *chunks_record,
+                        STATE *state,
+                        STATE *old_state,
+                        int num_joints) {
+  PIECES_STATE blob_chunks;
+  inT16 x;
+  inT16 y;
+  CHOICES this_choice;
+  inT16 first_chunk = 0;
+  inT16 last_chunk;
+  inT16 ratings = 0;
+  inT16 weights = 0;
+
+  bin_to_pieces(state, num_joints, blob_chunks);
+
+  for (x = 0; blob_chunks[x]; x++) {
+                                 // Iterate each blob
+    last_chunk = first_chunk + blob_chunks[x] - 1;
+
+    this_choice = matrix_get (chunks_record->ratings,
+      first_chunk, last_chunk);
+
+    if (this_choice == NIL)
+      return (BAD_RATING);
+
+    if (this_choice != NOT_CLASSIFIED) {
+
+      ratings += (inT16) best_probability (this_choice);
+      for (y = first_chunk; y <= last_chunk; y++) {
+        weights += (inT16) (chunks_record->weights[y]);
+      }
+    }
+    first_chunk += blob_chunks[x];
+  }
+  if (weights <= 0)
+    weights = 1;
+  return ((FLOAT32) ratings / weights);
+}
+
+
+/**********************************************************************
+ * state_char_widths
+ *
+ * Return a character width record corresponding to the character
+ * width that will be generated in this segmentation state.
+ **********************************************************************/
+WIDTH_RECORD *state_char_widths(WIDTH_RECORD *chunk_widths,
+                                STATE *state,
+                                int num_joints,
+                                SEARCH_STATE *search_state) {
+  WIDTH_RECORD *width_record;
+  int num_blobs;
+  int x;
+  int y;
+  int i;
+  SEARCH_STATE new_chunks;
+
+  new_chunks = bin_to_chunks (state, num_joints);
+
+  num_blobs = new_chunks[0] + 1;
+  width_record = (WIDTH_RECORD *) memalloc (sizeof (int) * num_blobs * 2);
+  width_record->num_chars = num_blobs;
+
+  x = 0;
+  for (i = 1; i <= new_chunks[0] + 1; i++) {
+    if (i > new_chunks[0])
+      y = num_joints;
+    else
+      y = x + new_chunks[i];
+
+    width_record->widths[2 * i - 2] = chunks_width (chunk_widths, x, y);
+
+    if (i <= new_chunks[0])
+      width_record->widths[2 * i - 1] = chunks_gap (chunk_widths, y);
+
+    x = y + 1;
+  }
+
+  *search_state = new_chunks;
+  return (width_record);
+}
+
+
+/**********************************************************************
+ * width_priority
+ *
+ * Return a priority value for this word segmentation based on the
+ * character widths present in the new segmentation.
+ **********************************************************************/
+FLOAT32 width_priority(CHUNKS_RECORD *chunks_record,
+                       STATE *state,
+                       int num_joints) {
+  SEARCH_STATE new_chunks;
+  FLOAT32 result = 0.0;
+  WIDTH_RECORD *width_record;
+  FLOAT32 squat;
+  int x;
+
+  width_record = state_char_widths (chunks_record->chunk_widths,
+    state, num_joints, &new_chunks);
+  for (x = 0; x < width_record->num_chars; x++) {
+
+    squat = width_record->widths[2 * x];
+    if (!baseline_enable) {
+      squat /= chunks_record->row->lineheight;
+    }
+    else {
+      squat /= BASELINE_SCALE;
+    }
+
+    if (squat > MAX_SQUAT)
+      result += squat - MAX_SQUAT;
+
+  }
+
+  memfree(new_chunks);
+  free_widths(width_record);
+
+  return (result);
+}

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

@@ -0,0 +1,120 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        heuristic.h  (Formerly heuristic.h)
+ * Description:
+ * Author:       Mark Seaman, SW Productivity
+ * Created:      Fri Oct 16 14:37:00 1987
+ * Modified:     Tue Jul  9 17:14:44 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 HEURISTIC_H
+#define HEURISTIC_H
+
+/*----------------------------------------------------------------------
+              I n c l u d e s
+----------------------------------------------------------------------*/
+#include "associate.h"
+#include "bestfirst.h"
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+FLOAT32 prioritize_state(CHUNKS_RECORD *chunks_record,
+                         SEARCH_RECORD *the_search,
+                         STATE *old_state);
+
+FLOAT32 rating_priority(CHUNKS_RECORD *chunks_record,
+                        STATE *state,
+                        STATE *old_state,
+                        int num_joints);
+
+WIDTH_RECORD *state_char_widths(WIDTH_RECORD *chunk_widths,
+                                STATE *state,
+                                int num_joints,
+                                SEARCH_STATE *search_state);
+
+FLOAT32 width_priority(CHUNKS_RECORD *chunks_record,
+                       STATE *state,
+                       int num_joints);
+
+/*
+#if defined(__STDC__) || defined(__cplusplus) || MAC_OR_DOS
+# define	_ARGS(s) s
+#else
+# define	_ARGS(s) ()
+#endif*/
+
+/* heuristic.c
+PROBABILITY best_char_rating
+  _ARGS((CHUNKS_RECORD *chunks_record,
+  int first_chunk,
+  int last_chunk,
+  char *word));
+
+STATE *first_segmentation
+  _ARGS((CHUNKS_RECORD *chunks_record));
+
+FLOAT32 gap_priority
+  _ARGS((CHUNKS_RECORD *chunks_record,
+  STATE *state,
+  int num_joints));
+
+FLOAT32 match_priority
+  _ARGS((CHUNKS_RECORD *chunks_record,
+  STATE *state,
+  STATE *old_state,
+  int num_joints));
+
+FLOAT32 frequency_priority
+  _ARGS((STATE *state,
+  STATE *old_state,
+  int num_joints));
+
+STATE *pick_good_segmentation
+  _ARGS((CHUNKS_RECORD *chunks_record));
+
+void print_widths
+  _ARGS((FILE *file,
+  char *string,
+  WIDTH_RECORD *width_array));
+
+FLOAT32 prioritize_state
+  _ARGS((CHUNKS_RECORD *chunks_record,
+  SEARCH_RECORD *the_search,
+  STATE *old_state));
+
+FLOAT32 rating_priority
+  _ARGS((CHUNKS_RECORD *chunks_record,
+  STATE *state,
+  STATE *old_state,
+  int num_joints));
+
+WIDTH_RECORD *state_char_widths
+  _ARGS((WIDTH_RECORD *chunk_widths,
+  STATE *state,
+  int num_joints,
+  SEARCH_STATE *search_state));
+
+FLOAT32 width_priority
+  _ARGS((CHUNKS_RECORD *chunks_record,
+  STATE *state,
+  int num_joints));
+
+#undef _ARGS
+*/
+#endif