tesseract_bin 1.0.0

data/vendor/tesseract-2.04/textord/fpchop.h

@@ -0,0 +1,238 @@
+/**********************************************************************
+ * File:        fpchop.h  (Formerly fp_chop.h)
+ * Description: Code to chop fixed pitch text into character cells.
+ * Author:		Ray Smith
+ * Created:		Thu Sep 16 11:14:15 BST 1993
+ *
+ * (C) Copyright 1993, 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           FPCHOP_H
+#define           FPCHOP_H
+
+#include          "varable.h"
+#include          "blobbox.h"
+#include          "notdll.h"
+#include          "notdll.h"
+
+class OUTLINE_FRAG:public ELIST_LINK
+{
+  public:
+    OUTLINE_FRAG() {
+    }                            //empty constructor
+                                 //head of fragment
+    OUTLINE_FRAG(POLYPT_IT *head_it, POLYPT_IT *tail_it);  //tail of fragment
+                                 //other end
+    OUTLINE_FRAG(OUTLINE_FRAG *head, float tail_y);
+
+    POLYPT_LIST polypts;         //only if a head
+    OUTLINE_FRAG *other_end;     //head if a tail
+    float ycoord;                //coord of cut pt
+
+  private:
+};
+
+class C_OUTLINE_FRAG:public ELIST_LINK
+{
+  public:
+    C_OUTLINE_FRAG() {  //empty constructor
+      steps = NULL;
+      stepcount = 0;
+    }
+    ~C_OUTLINE_FRAG () {
+      if (steps != NULL)
+        delete [] steps;
+    }
+                                 //start coord
+    C_OUTLINE_FRAG(ICOORD start_pt,
+                   ICOORD end_pt,       //end coord
+                   C_OUTLINE *outline,  //source of steps
+                   inT16 start_index,
+                   inT16 end_index);
+                                 //other end
+    C_OUTLINE_FRAG(C_OUTLINE_FRAG *head, inT16 tail_y);
+    C_OUTLINE *close();  //copy to outline
+    C_OUTLINE_FRAG & operator= ( //assign
+      const C_OUTLINE_FRAG & src);
+
+    ICOORD start;                //start coord
+    ICOORD end;                  //end coord
+    DIR128 *steps;                //step array
+    inT32 stepcount;             //no of steps
+    C_OUTLINE_FRAG *other_end;   //head if a tail
+    inT16 ycoord;                //coord of cut pt
+
+  private:
+};
+
+ELISTIZEH (OUTLINE_FRAG) ELISTIZEH (C_OUTLINE_FRAG)
+extern
+INT_VAR_H (textord_fp_chop_error, 2,
+"Max allowed bending of chop cells");
+extern
+double_VAR_H (textord_fp_chop_snap, 0.5,
+"Max distance of chop pt from vertex");
+ROW *fixed_pitch_words(                 //find lines
+                       TO_ROW *row,     //row to do
+                       FCOORD rotation  //for drawing
+                      );
+WERD *add_repeated_word(                         //move repeated word
+                        WERD_IT *rep_it,         //repeated words
+                        inT16 &rep_left,         //left edge of word
+                        inT16 &prev_chop_coord,  //previous word end
+                        uinT8 &blanks,           //no of blanks
+                        float pitch,             //char cell size
+                        WERD_IT *word_it         //list of words
+                       );
+void split_to_blob(                                 //split the blob
+                   BLOBNBOX *blob,                  //blob to split
+                   inT16 chop_coord,                //place to chop
+                   float pitch_error,               //allowed deviation
+                   OUTLINE_LIST *left_outlines,     //left half of chop
+                   C_OUTLINE_LIST *left_coutlines,  //for cblobs
+                   OUTLINE_LIST *right_outlines,    //right half of chop
+                   C_OUTLINE_LIST *right_coutlines);
+void fixed_chop_blob(                              //split the blob
+                     PBLOB *blob,                  //blob to split
+                     inT16 chop_coord,             //place to chop
+                     float pitch_error,            //allowed deviation
+                     OUTLINE_LIST *left_outlines,  //left half of chop
+                     OUTLINE_LIST *right_outlines  //right half of chop
+                    );
+void fixed_split_outline(                      //chop the outline
+                         OUTLINE *srcline,     //source outline
+                         inT16 chop_coord,     //place to chop
+                         float pitch_error,    //allowed deviation
+                         OUTLINE_IT *left_it,  //left half of chop
+                         OUTLINE_IT *right_it  //right half of chop
+                        );
+BOOL8 fixed_chop_outline(                                //chop the outline
+                         OUTLINE *srcline,               //source outline
+                         inT16 chop_coord,               //place to chop
+                         float pitch_error,              //allowed deviation
+                         OUTLINE_FRAG_LIST *left_frags,  //left half of chop
+                         OUTLINE_FRAG_LIST *right_frags  //right half of chop
+                        );
+void save_chop_fragment(                          //chop the outline
+                        POLYPT_IT *head_it,       //head of fragment
+                        POLYPT_IT *tail_it,       //tail of fragment
+                        OUTLINE_FRAG_LIST *frags  //fragment list
+                       );
+void add_frag_to_list(                          //ordered add
+                      OUTLINE_FRAG *frag,       //fragment to add
+                      OUTLINE_FRAG_LIST *frags  //fragment list
+                     );
+void insert_chop_pt(                  //make chop
+                    POLYPT_IT *it,    //iterator
+                    inT16 chop_coord  //required chop pt
+                   );
+FCOORD find_chop_coords(                  //make chop
+                        POLYPT_IT *it,    //iterator
+                        inT16 chop_coord  //required chop pt
+                       );
+void insert_extra_pt(               //make extra
+                     POLYPT_IT *it  //iterator
+                    );
+void close_chopped_fragments(                           //chop the outline
+                             OUTLINE_FRAG_LIST *frags,  //list to clear
+                             OUTLINE_LIST *children,    //potential children
+                             OUTLINE_IT *dest_it        //output list
+                            );
+void join_chopped_fragments(                       //join pieces
+                            OUTLINE_FRAG *bottom,  //bottom of cut
+                            OUTLINE_FRAG *top      //top of cut
+                           );
+void fixed_chop_cblob(                                //split the blob
+                      C_BLOB *blob,                   //blob to split
+                      inT16 chop_coord,               //place to chop
+                      float pitch_error,              //allowed deviation
+                      C_OUTLINE_LIST *left_outlines,  //left half of chop
+                      C_OUTLINE_LIST *right_outlines  //right half of chop
+                     );
+void fixed_split_coutline(                        //chop the outline
+                          C_OUTLINE *srcline,     //source outline
+                          inT16 chop_coord,       //place to chop
+                          float pitch_error,      //allowed deviation
+                          C_OUTLINE_IT *left_it,  //left half of chop
+                          C_OUTLINE_IT *right_it  //right half of chop
+                         );
+BOOL8 fixed_chop_coutline(                                  //chop the outline
+                          C_OUTLINE *srcline,               //source outline
+                          inT16 chop_coord,                 //place to chop
+                          float pitch_error,                //allowed deviation
+                          C_OUTLINE_FRAG_LIST *left_frags,  //left half of chop
+                          C_OUTLINE_FRAG_LIST *right_frags  //right half of chop
+                         );
+inT16 next_anti_left_seg(                     //chop the outline
+                         C_OUTLINE *srcline,  //source outline
+                         inT16 tail_index,    //of tailpos
+                         inT16 startindex,    //end of search
+                         inT32 length,        //of outline
+                         inT16 chop_coord,    //place to chop
+                         float pitch_error,   //allowed deviation
+                         ICOORD *tail_pos     //current position
+                        );
+inT16 next_anti_right_seg(                     //chop the outline
+                          C_OUTLINE *srcline,  //source outline
+                          inT16 tail_index,    //of tailpos
+                          inT16 startindex,    //end of search
+                          inT32 length,        //of outline
+                          inT16 chop_coord,    //place to chop
+                          float pitch_error,   //allowed deviation
+                          ICOORD *tail_pos     //current position
+                         );
+inT16 next_clock_left_seg(                     //chop the outline
+                          C_OUTLINE *srcline,  //source outline
+                          inT16 tail_index,    //of tailpos
+                          inT16 startindex,    //end of search
+                          inT32 length,        //of outline
+                          inT16 chop_coord,    //place to chop
+                          float pitch_error,   //allowed deviation
+                          ICOORD *tail_pos     //current position
+                         );
+inT16 next_clock_right_seg(                     //chop the outline
+                           C_OUTLINE *srcline,  //source outline
+                           inT16 tail_index,    //of tailpos
+                           inT16 startindex,    //end of search
+                           inT32 length,        //of outline
+                           inT16 chop_coord,    //place to chop
+                           float pitch_error,   //allowed deviation
+                           ICOORD *tail_pos     //current position
+                          );
+void save_chop_cfragment(                            //chop the outline
+                         inT16 head_index,           //head of fragment
+                         ICOORD head_pos,            //head of fragment
+                         inT16 tail_index,           //tail of fragment
+                         ICOORD tail_pos,            //tail of fragment
+                         C_OUTLINE *srcline,         //source of edgesteps
+                         C_OUTLINE_FRAG_LIST *frags  //fragment list
+                        );
+void add_frag_to_list(                            //ordered add
+                      C_OUTLINE_FRAG *frag,       //fragment to add
+                      C_OUTLINE_FRAG_LIST *frags  //fragment list
+                     );
+void close_chopped_cfragments(                             //chop the outline
+                              C_OUTLINE_FRAG_LIST *frags,  //list to clear
+                              C_OUTLINE_LIST *children,    //potential children
+                              float pitch_error,           //allowed shrinkage
+                              C_OUTLINE_IT *dest_it        //output list
+                             );
+C_OUTLINE *join_chopped_fragments(                         //join pieces
+                                  C_OUTLINE_FRAG *bottom,  //bottom of cut
+                                  C_OUTLINE_FRAG *top      //top of cut
+                                 );
+void join_segments(                         //join pieces
+                   C_OUTLINE_FRAG *bottom,  //bottom of cut
+                   C_OUTLINE_FRAG *top      //top of cut
+                  );
+#endif

data/vendor/tesseract-2.04/textord/gap_map.cpp

@@ -0,0 +1,166 @@
+#include "mfcpch.h"
+#include          "statistc.h"
+#include          "gap_map.h"
+
+#define EXTERN
+EXTERN BOOL_VAR (gapmap_debug, FALSE, "Say which blocks have tables");
+EXTERN BOOL_VAR (gapmap_use_ends, FALSE,
+"Use large space at start and end of rows");
+EXTERN BOOL_VAR (gapmap_no_isolated_quanta, FALSE,
+"Ensure gaps not less than 2quanta wide");
+EXTERN double_VAR (gapmap_big_gaps, 1.75, "xht multiplier");
+
+/*************************************************************************
+ * A block gap map is a quantised histogram of whitespace regions in the
+ * block. It is a vertical projection of wide gaps WITHIN lines
+ *
+ * The map is held as an array of counts of rows which have a wide gap
+ * covering that region of the row. Each bucket in the map represents a width
+ * of about half an xheight - (The median of the xhts in the rows is used.)
+ *
+ * The block is considered RECTANGULAR - delimited by the left and right
+ * extremes of the rows in the block. However, ONLY wide gaps WITHIN a row are
+ * counted.
+ *
+ *************************************************************************/
+
+GAPMAP::GAPMAP(                 //Constructor
+               TO_BLOCK *block  //block
+              ) {
+  TO_ROW_IT row_it;              //row iterator
+  TO_ROW *row;                   //current row
+  BLOBNBOX_IT blob_it;           //iterator
+  TBOX blob_box;
+  TBOX prev_blob_box;
+  inT16 gap_width;
+  inT16 start_of_row;
+  inT16 end_of_row;
+  STATS xht_stats (0, 128);
+  inT16 min_quantum;
+  inT16 max_quantum;
+  inT16 i;
+
+  row_it.set_to_list (block->get_rows ());
+  /*
+    Find left and right extremes and bucket size
+  */
+  map = NULL;
+  min_left = MAX_INT16;
+  max_right = -MAX_INT16;
+  total_rows = 0;
+  any_tabs = FALSE;
+  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
+    row = row_it.data ();
+    if (!row->blob_list ()->empty ()) {
+      total_rows++;
+      xht_stats.add ((inT16) floor (row->xheight + 0.5), 1);
+      blob_it.set_to_list (row->blob_list ());
+      start_of_row = blob_it.data ()->bounding_box ().left ();
+      end_of_row = blob_it.data_relative (-1)->bounding_box ().right ();
+      if (min_left > start_of_row)
+        min_left = start_of_row;
+      if (max_right < end_of_row)
+        max_right = end_of_row;
+    }
+  }
+  if ((total_rows < 3) || (min_left >= max_right)) {
+    total_rows = 0;
+    min_left = max_right = 0;
+    return;
+  }
+  bucket_size = (inT16) floor (xht_stats.median () + 0.5) / 2;
+  map_max = (max_right - min_left) / bucket_size;
+  map = (inT16 *) alloc_mem ((map_max + 1) * sizeof (inT16));
+  for (i = 0; i <= map_max; i++)
+    map[i] = 0;
+
+  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
+    row = row_it.data ();
+    if (!row->blob_list ()->empty ()) {
+      blob_it.set_to_list (row->blob_list ());
+      blob_it.mark_cycle_pt ();
+      blob_box = box_next (&blob_it);
+      prev_blob_box = blob_box;
+      if (gapmap_use_ends) {
+        /* Leading space */
+        gap_width = blob_box.left () - min_left;
+        if ((gap_width > gapmap_big_gaps * row->xheight)
+        && gap_width > 2) {
+          max_quantum = (blob_box.left () - min_left) / bucket_size;
+          for (i = 0; i <= max_quantum; i++)
+            map[i]++;
+        }
+      }
+      while (!blob_it.cycled_list ()) {
+        blob_box = box_next (&blob_it);
+        gap_width = blob_box.left () - prev_blob_box.right ();
+        if ((gap_width > gapmap_big_gaps * row->xheight)
+        && gap_width > 2) {
+          min_quantum =
+            (prev_blob_box.right () - min_left) / bucket_size;
+          max_quantum = (blob_box.left () - min_left) / bucket_size;
+          for (i = min_quantum; i <= max_quantum; i++)
+            map[i]++;
+        }
+        prev_blob_box = blob_box;
+      }
+      if (gapmap_use_ends) {
+        /* Trailing space */
+        gap_width = max_right - prev_blob_box.right ();
+        if ((gap_width > gapmap_big_gaps * row->xheight)
+        && gap_width > 2) {
+          min_quantum =
+            (prev_blob_box.right () - min_left) / bucket_size;
+          for (i = min_quantum; i <= map_max; i++)
+            map[i]++;
+        }
+      }
+    }
+  }
+  for (i = 0; i <= map_max; i++) {
+    if (map[i] > total_rows / 2) {
+      if (gapmap_no_isolated_quanta &&
+        (((i == 0) &&
+        (map[i + 1] <= total_rows / 2)) ||
+        ((i == map_max) &&
+        (map[i - 1] <= total_rows / 2)) ||
+        ((i > 0) &&
+        (i < map_max) &&
+        (map[i - 1] <= total_rows / 2) &&
+      (map[i + 1] <= total_rows / 2)))) {
+        map[i] = 0;              //prevent isolated quantum
+      }
+      else
+        any_tabs = TRUE;
+    }
+  }
+  if (gapmap_debug && any_tabs)
+    tprintf ("Table found\n");
+}
+
+
+/*************************************************************************
+ * GAPMAP::table_gap()
+ * Is there a bucket in the specified range where more than half the rows in the
+ * block have a wide gap?
+ *************************************************************************/
+
+BOOL8 GAPMAP::table_gap(             //Is gap a table?
+                        inT16 left,  //From here
+                        inT16 right  //To here
+                       ) {
+  inT16 min_quantum;
+  inT16 max_quantum;
+  inT16 i;
+  BOOL8 tab_found = FALSE;
+
+  if (!any_tabs)
+    return FALSE;
+
+  min_quantum = (left - min_left) / bucket_size;
+  max_quantum = (right - min_left) / bucket_size;
+  for (i = min_quantum; (!tab_found && (i <= max_quantum)); i++)
+    if (map[i] > total_rows / 2)
+      tab_found = TRUE;
+  return tab_found;
+}

data/vendor/tesseract-2.04/textord/gap_map.h

@@ -0,0 +1,40 @@
+#ifndef           GAP_MAP_H
+#define           GAP_MAP_H
+
+#include          "blobbox.h"
+#include          "notdll.h"
+
+class GAPMAP
+{
+  public:
+    GAPMAP(  //constructor
+           TO_BLOCK *block);
+
+    ~GAPMAP () {                 //destructor
+      if (map != NULL)
+        free_mem(map);
+    }
+
+    BOOL8 table_gap(               //Is gap a table?
+                    inT16 left,    //From here
+                    inT16 right);  //To here
+
+  private:
+    inT16 total_rows;            //in block
+    inT16 min_left;              //Left extreme
+    inT16 max_right;             //Right extreme
+    inT16 bucket_size;           // half an x ht
+    inT16 *map;                  //empty counts
+    inT16 map_max;               //map[0..max_map]       defind
+    BOOL8 any_tabs;
+};
+
+/*-----------------------------*/
+
+extern BOOL_VAR_H (gapmap_debug, FALSE, "Say which blocks have tables");
+extern BOOL_VAR_H (gapmap_use_ends, FALSE,
+"Use large space at start and end of rows");
+extern BOOL_VAR_H (gapmap_no_isolated_quanta, FALSE,
+"Ensure gaps not less than 2quanta wide");
+extern double_VAR_H (gapmap_big_gaps, 1.75, "xht multiplier");
+#endif