tesseract_bin 1.0.0

data/vendor/tesseract-2.04/ccmain/pagewalk.h

@@ -0,0 +1,155 @@
+/**********************************************************************
+ * File:        pagewalk.h  (Formerly walkers.h)
+ * Description: Structure processors
+ * Author:      Phil Cheatle
+ * Created:     Thu Oct 10 16:25:24 BST 1991
+ *
+ * (C) Copyright 1991, 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           PAGEWALK_H
+#define           PAGEWALK_H
+
+#include          "ocrblock.h"
+#include          "ocrrow.h"
+#include          "werd.h"
+#include          "polyblob.h"
+#include          "stepblob.h"
+#include          "rect.h"
+#include          "varable.h"
+#include          "notdll.h"
+
+#define BLOCK_SPACING   20
+
+extern BOOL_VAR_H (current_word_quit, FALSE, "Stop processing this word");
+extern DLLSYM BOOL_VAR_H (selection_quit, FALSE,
+"Stop processing this selection");
+TBOX block_list_bounding_box(                        //find bounding box
+                            BLOCK_LIST *block_list  //of this block list
+                           );
+const TBOX block_list_compress(  //shuffle up blocks
+                              BLOCK_LIST *block_list);
+void block_list_move(                         //move
+                     BLOCK_LIST *block_list,  //this list
+                     ICOORD vec               //by this vector
+                    );
+int block_name_order(                      //sort blocks
+                     const void *block1p,  //ptr to ptr to block1
+                     const void *block2p   //ptr to ptr to block2
+                    );
+void process_all_blobs (         //process blobs
+BLOCK_LIST * block_list,         //blocks to check
+BOOL8 blob_processor (           //function to call
+                                 //function to call
+BLOCK *, ROW *, WERD *, PBLOB *), BOOL8 c_blob_processor (
+BLOCK
+*,
+ROW
+*,
+WERD
+*,
+C_BLOB
+*));
+void process_selected_blobs (    //process blobs
+BLOCK_LIST * block_list,         //blocks to check
+                                 //function to call
+TBOX & selection_box, BOOL8 blob_processor (
+                                 //function to call
+BLOCK *, ROW *, WERD *, PBLOB *), BOOL8 c_blob_processor (
+BLOCK
+*,
+ROW
+*,
+WERD
+*,
+C_BLOB
+*));
+void process_all_words (         //process words
+BLOCK_LIST * block_list,         //blocks to check
+BOOL8 word_processor (           //function to call
+BLOCK *, ROW *, WERD *));
+void process_selected_words (    //process words
+BLOCK_LIST * block_list,         //blocks to check
+                                 //function to call
+TBOX & selection_box, BOOL8 word_processor (
+BLOCK
+*,
+ROW
+*,
+WERD
+*));
+void process_all_words_it (      //process words
+BLOCK_LIST * block_list,         //blocks to check
+BOOL8 word_processor (           //function to call
+BLOCK *,
+ROW *,
+WERD *,
+BLOCK_IT &,
+ROW_IT &, WERD_IT &));
+void process_selected_words_it ( //process words
+BLOCK_LIST * block_list,         //blocks to check
+                                 //function to call
+TBOX & selection_box, BOOL8 word_processor (
+BLOCK
+*,
+ROW
+*,
+WERD
+*,
+BLOCK_IT
+&,
+ROW_IT
+&,
+WERD_IT
+&));
+void process_all_blocks (        //process blocks
+BLOCK_LIST * block_list,         //blocks to check
+BOOL8 block_processor (          //function to call
+BLOCK *));
+void process_selected_blocks (   //process blocks
+BLOCK_LIST * block_list,         //blocks to check
+                                 //function to call
+TBOX & selection_box, BOOL8 block_processor (
+BLOCK
+*));
+void process_all_rows (          //process words
+BLOCK_LIST * block_list,         //blocks to check
+BOOL8 row_processor (            //function to call
+BLOCK *, ROW *));
+void process_selected_rows (     //process rows
+BLOCK_LIST * block_list,         //blocks to check
+                                 //function to call
+TBOX & selection_box, BOOL8 row_processor (
+BLOCK
+*,
+ROW
+*));
+void process_all_rows_it (       //process words
+BLOCK_LIST * block_list,         //blocks to check
+BOOL8 row_processor (            //function to call
+BLOCK *,
+ROW *,
+BLOCK_IT &, ROW_IT &));
+void process_selected_rows_it (  //process rows
+BLOCK_LIST * block_list,         //blocks to check
+                                 //function to call
+TBOX & selection_box, BOOL8 row_processor (
+BLOCK
+*,
+ROW
+*,
+BLOCK_IT
+&,
+ROW_IT
+&));
+#endif

data/vendor/tesseract-2.04/ccmain/paircmp.cpp

@@ -0,0 +1,107 @@
+/**********************************************************************
+ * File:        paircmp.cpp  (Formerly paircmp.c)
+ * Description: Code to compare two blobs using the adaptive matcher
+ * Author:		Ray Smith
+ * Created:		Wed Apr 21 09:31:02 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.
+ *
+ **********************************************************************/
+
+#include "mfcpch.h"
+#include          "blobcmp.h"
+#include          "tfacep.h"
+#include          "paircmp.h"
+
+#define EXTERN
+
+/**********************************************************************
+ * compare_blob_pairs
+ *
+ * A blob processor to compare pairs of selected blobs.
+ **********************************************************************/
+
+BOOL8 compare_blob_pairs(             //blob processor
+                         BLOCK *,
+                         ROW *row,    //row it came from
+                         WERD *,
+                         PBLOB *blob  //blob to compare
+                        ) {
+  static ROW *prev_row = NULL;   //other in pair
+  static PBLOB *prev_blob = NULL;
+  float rating;                  //from matcher
+
+  if (prev_row == NULL || prev_blob == NULL) {
+    prev_row = row;
+    prev_blob = blob;
+  }
+  else {
+    rating = compare_blobs (prev_blob, prev_row, blob, row);
+    tprintf ("Rating=%g\n", rating);
+    prev_row = NULL;
+    prev_blob = NULL;
+  }
+  return TRUE;
+}
+
+
+/**********************************************************************
+ * compare_blobs
+ *
+ * Compare 2 blobs and return the rating.
+ **********************************************************************/
+
+float compare_blobs(               //match 2 blobs
+                    PBLOB *blob1,  //first blob
+                    ROW *row1,     //row it came from
+                    PBLOB *blob2,  //other blob
+                    ROW *row2) {
+  PBLOB *bn_blob1;               //baseline norm
+  PBLOB *bn_blob2;
+  DENORM denorm1, denorm2;
+  float rating;                  //match result
+
+  bn_blob1 = blob1->baseline_normalise (row1, &denorm1);
+  bn_blob2 = blob2->baseline_normalise (row2, &denorm2);
+  rating = compare_bln_blobs (bn_blob1, &denorm1, bn_blob2, &denorm2);
+  delete bn_blob1;
+  delete bn_blob2;
+  return rating;
+}
+
+
+/**********************************************************************
+ * compare_bln_blobs
+ *
+ * Compare 2 baseline normalised blobs and return the rating.
+ **********************************************************************/
+
+float compare_bln_blobs(               //match 2 blobs
+                        PBLOB *blob1,  //first blob
+                        DENORM *denorm1,
+                        PBLOB *blob2,  //other blob
+                        DENORM *denorm2) {
+  TBLOB *tblob1;                 //tessblobs
+  TBLOB *tblob2;
+  TEXTROW tessrow1, tessrow2;    //tess rows
+  float rating;                  //match result
+
+  tblob1 = make_tess_blob (blob1, TRUE);
+  make_tess_row(denorm1, &tessrow1); 
+  tblob2 = make_tess_blob (blob2, TRUE);
+  make_tess_row(denorm2, &tessrow2); 
+  rating = compare_tess_blobs (tblob1, &tessrow1, tblob2, &tessrow2);
+  free_blob(tblob1); 
+  free_blob(tblob2); 
+
+  return rating;
+}

data/vendor/tesseract-2.04/ccmain/paircmp.h

@@ -0,0 +1,43 @@
+/**********************************************************************
+ * File:        paircmp.h  (Formerly paircmp.h)
+ * Description: Code to compare two blobs using the adaptive matcher
+ * Author:		Ray Smith
+ * Created:		Wed Apr 21 09:31:02 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           PAIRCMP_H
+#define           PAIRCMP_H
+
+#include          "ocrblock.h"
+#include          "varable.h"
+#include          "notdll.h"
+
+BOOL8 compare_blob_pairs(             //blob processor
+                         BLOCK *,
+                         ROW *row,    //row it came from
+                         WERD *,
+                         PBLOB *blob  //blob to compare
+                        );
+float compare_blobs(               //match 2 blobs
+                    PBLOB *blob1,  //first blob
+                    ROW *row1,     //row it came from
+                    PBLOB *blob2,  //other blob
+                    ROW *row2);
+float compare_bln_blobs(               //match 2 blobs
+                        PBLOB *blob1,  //first blob
+                        DENORM *denorm1,
+                        PBLOB *blob2,  //other blob
+                        DENORM *denorm2);
+#endif