tesseract_bin 1.0.0

data/vendor/tesseract-2.04/ccstruct/coutln.h

@@ -0,0 +1,186 @@
+/**********************************************************************
+ * File:						coutln.c      (Formerly:  coutline.c)
+ * Description: Code for the C_OUTLINE class.
+ * Author:					Ray Smith
+ * Created:					Mon Oct 07 16:01:57 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           COUTLN_H
+#define           COUTLN_H
+
+#include          "crakedge.h"
+#include          "mod128.h"
+#include          "bits16.h"
+#include          "rect.h"
+#include          "blckerr.h"
+#include          "scrollview.h"
+
+#define INTERSECTING    MAX_INT16//no winding number
+
+                                 //mask to get step
+#define STEP_MASK       3
+
+enum C_OUTLINE_FLAGS
+{
+  COUT_INVERSE                   //White on black blob
+};
+
+class DLLSYM C_OUTLINE;          //forward declaration
+
+ELISTIZEH_S (C_OUTLINE)
+class DLLSYM C_OUTLINE:public ELIST_LINK
+{
+  public:
+    C_OUTLINE() {  //empty constructor
+      steps = NULL;
+    }
+    C_OUTLINE(                     //constructor
+              CRACKEDGE *startpt,  //from edge detector
+              ICOORD bot_left,     //bounding box //length of loop
+              ICOORD top_right,
+              inT16 length);
+    C_OUTLINE(ICOORD startpt,    //start of loop
+              DIR128 *new_steps,  //steps in loop
+              inT16 length);     //length of loop
+                                 //outline to copy
+    C_OUTLINE(C_OUTLINE *srcline, FCOORD rotation);  //and rotate
+    ~C_OUTLINE () {              //destructor
+      if (steps != NULL)
+        free_mem(steps);
+      steps = NULL;
+    }
+
+    BOOL8 flag(                               //test flag
+               C_OUTLINE_FLAGS mask) const {  //flag to test
+      return flags.bit (mask);
+    }
+    void set_flag(                       //set flag value
+                  C_OUTLINE_FLAGS mask,  //flag to test
+                  BOOL8 value) {         //value to set
+      flags.set_bit (mask, value);
+    }
+
+    C_OUTLINE_LIST *child() {  //get child list
+      return &children;
+    }
+
+                                 //access function
+    const TBOX &bounding_box() const {
+      return box;
+    }
+    void set_step(                    //set a step
+                  inT16 stepindex,    //index of step
+                  inT8 stepdir) {     //chain code
+      int shift = stepindex%4 * 2;
+      uinT8 mask = 3 << shift;
+      steps[stepindex/4] = ((stepdir << shift) & mask) |
+                           (steps[stepindex/4] & ~mask);
+      //squeeze 4 into byte
+    }
+    void set_step(                    //set a step
+                  inT16 stepindex,    //index of step
+                  DIR128 stepdir) {   //direction
+                                 //clean it
+      inT8 chaindir = stepdir.get_dir() >> (DIRBITS - 2);
+                                 //difference
+      set_step(stepindex, chaindir);
+      //squeeze 4 into byte
+    }
+
+                                 //get start position
+    const ICOORD &start_pos() const {
+      return start;
+    }
+    inT32 pathlength() const {  //get path length
+      return stepcount;
+    }
+    // Return step at a given index as a DIR128.
+    DIR128 step_dir(inT16 index) const {
+      return DIR128((inT16)(((steps[index/4] >> (index%4 * 2)) & STEP_MASK) <<
+                      (DIRBITS - 2)));
+    }
+    // Return the step vector for the given outline position.
+    ICOORD step(inT16 index) const { //index of step
+      return step_coords[(steps[index/4] >> (index%4 * 2)) & STEP_MASK];
+    }
+
+    inT32 area();  //return area
+    inT32 perimeter();  // Total perimeter of self and 1st level children.
+    inT32 outer_area();  //return area
+    inT32 count_transitions(                   //count maxima
+                            inT32 threshold);  //size threshold
+
+    BOOL8 operator< (            //containment test
+      const C_OUTLINE & other) const;
+    BOOL8 operator> (            //containment test
+      C_OUTLINE & other) const
+    {
+      return other < *this;      //use the < to do it
+    }
+    inT16 winding_number(                       //get winding number
+                         ICOORD testpt) const;  //around this point
+                                 //get direction
+    inT16 turn_direction() const;
+    void reverse();  //reverse direction
+
+    void move(                    // reposition outline
+              const ICOORD vec);  // by vector
+
+    void plot(                       //draw one
+              ScrollView* window,         //window to draw in
+              ScrollView::Color colour) const;  //colour to draw it
+
+    void prep_serialise() {  //set ptrs to counts
+      children.prep_serialise ();
+    }
+
+    void dump(  //write external bits
+              FILE *f) {
+                                 //stepcount = # bytes
+      serialise_bytes (f, (void *) steps, step_mem());
+      children.dump (f);
+    }
+
+    void de_dump(  //read external bits
+                 FILE *f) {
+      steps = (uinT8 *) de_serialise_bytes (f, step_mem());
+      children.de_dump (f);
+    }
+
+                                 //assignment
+    make_serialise (C_OUTLINE)
+
+    C_OUTLINE& operator=(const C_OUTLINE& source);
+
+    static C_OUTLINE* deep_copy(const C_OUTLINE* src) {
+      C_OUTLINE* outline = new C_OUTLINE;
+      *outline = *src;
+      return outline;
+    }
+
+    static ICOORD chain_step(int chaindir);
+
+  private:
+    int step_mem() const { return (stepcount+3) / 4; }
+
+    TBOX box;                     //boudning box
+    ICOORD start;                //start coord
+    uinT8 *steps;                //step array
+    inT16 stepcount;             //no of steps
+    BITS16 flags;                //flags about outline
+    C_OUTLINE_LIST children;     //child elements
+    static ICOORD step_coords[4];
+};
+#endif

data/vendor/tesseract-2.04/ccstruct/crakedge.h

@@ -0,0 +1,39 @@
+/**********************************************************************
+ * File:						crakedge.h      (Formerly: crkedge.h)
+ * Description: Sturctures for the Crack following edge detector.
+ * Author:					Ray Smith
+ * Created:					Fri Mar 22 16:06:38 GMT 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           CRAKEDGE_H
+#define           CRAKEDGE_H
+
+#include          "points.h"
+#include          "mod128.h"
+
+class CRACKEDGE
+{
+  public:
+    ICOORD pos;                  /*position of crack */
+    inT8 stepx;                  //edge step
+    inT8 stepy;
+    inT8 stepdir;                //chaincode
+    CRACKEDGE *prev;             /*previous point */
+    CRACKEDGE *next;             /*next point */
+
+    NEWDELETE2 (CRACKEDGE) CRACKEDGE () {
+    }                            //empty constructor
+};
+#endif

data/vendor/tesseract-2.04/ccstruct/genblob.cpp

@@ -0,0 +1,133 @@
+/**********************************************************************
+ * File:        genblob.cpp  (Formerly gblob.c)
+ * Description: Generic Blob processing routines
+ * Author:      Phil Cheatle
+ * Created:     Mon Nov 25 10:53:26 GMT 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.
+ *
+ **********************************************************************/
+
+#include "mfcpch.h"
+#include          "stepblob.h"
+#include          "polyblob.h"
+#include          "genblob.h"
+
+/**********************************************************************
+ *  blob_comparator()
+ *
+ *  Blob comparator used to sort a blob list so that blobs are in increasing
+ *  order of left edge.
+ **********************************************************************/
+
+int blob_comparator(                     //sort blobs
+                    const void *blob1p,  //ptr to ptr to blob1
+                    const void *blob2p   //ptr to ptr to blob2
+                   ) {
+  PBLOB *blob1 = *(PBLOB **) blob1p;
+  PBLOB *blob2 = *(PBLOB **) blob2p;
+
+  return blob1->bounding_box ().left () - blob2->bounding_box ().left ();
+}
+
+
+/**********************************************************************
+ *  c_blob_comparator()
+ *
+ *  Blob comparator used to sort a blob list so that blobs are in increasing
+ *  order of left edge.
+ **********************************************************************/
+
+int c_blob_comparator(                     //sort blobs
+                      const void *blob1p,  //ptr to ptr to blob1
+                      const void *blob2p   //ptr to ptr to blob2
+                     ) {
+  C_BLOB *blob1 = *(C_BLOB **) blob1p;
+  C_BLOB *blob2 = *(C_BLOB **) blob2p;
+
+  return blob1->bounding_box ().left () - blob2->bounding_box ().left ();
+}
+
+
+/**********************************************************************
+ *  gblob_bounding_box()
+ *
+ *  Return the bounding box of a generic blob.
+ **********************************************************************/
+
+TBOX gblob_bounding_box(                 //Get bounding box
+                       PBLOB *blob,     //generic blob
+                       BOOL8 polygonal  //is blob polygonal?
+                      ) {
+  if (polygonal)
+    return blob->bounding_box ();
+  else
+    return ((C_BLOB *) blob)->bounding_box ();
+}
+
+
+/**********************************************************************
+ *  gblob_sort_list()
+ *
+ *  Sort a generic blob list into order of bounding box left edge
+ **********************************************************************/
+
+void gblob_sort_list(                        //Sort a gblob list
+                     PBLOB_LIST *blob_list,  //generic blob list
+                     BOOL8 polygonal         //is list polygonal?
+                    ) {
+  PBLOB_IT b_it;
+  C_BLOB_IT c_it;
+
+  if (polygonal) {
+    b_it.set_to_list (blob_list);
+    b_it.sort (blob_comparator);
+  }
+  else {
+    c_it.set_to_list ((C_BLOB_LIST *) blob_list);
+    c_it.sort (c_blob_comparator);
+  }
+}
+
+
+/**********************************************************************
+ *  gblob_out_list()
+ *
+ *  Return the generic outline list of a generic blob.
+ **********************************************************************/
+
+OUTLINE_LIST *gblob_out_list(                 //Get outline list
+                             PBLOB *blob,     //generic blob
+                             BOOL8 polygonal  //is blob polygonal?
+                            ) {
+  if (polygonal)
+    return blob->out_list ();
+  else
+    return (OUTLINE_LIST *) ((C_BLOB *) blob)->out_list ();
+}
+
+
+/**********************************************************************
+ *  goutline_bounding_box()
+ *
+ *  Return the bounding box of a generic outline.
+ **********************************************************************/
+
+TBOX goutline_bounding_box(                   //Get bounding box
+                          OUTLINE *outline,  //generic outline
+                          BOOL8 polygonal    //is outline polygonal?
+                         ) {
+  if (polygonal)
+    return outline->bounding_box ();
+  else
+    return ((C_OUTLINE *) outline)->bounding_box ();
+}

data/vendor/tesseract-2.04/ccstruct/genblob.h

@@ -0,0 +1,52 @@
+/**********************************************************************
+ * File:        genblob.h  (Formerly gblob.h)
+ * Description: Generic Blob processing routines
+ * Author:      Phil Cheatle
+ * Created:     Mon Nov 25 10:53:26 GMT 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           GENBLOB_H
+#define           GENBLOB_H
+
+#include          "polyblob.h"
+#include          "hosthplb.h"
+#include          "rect.h"
+#include          "notdll.h"
+
+int blob_comparator(                     //sort blobs
+                    const void *blob1p,  //ptr to ptr to blob1
+                    const void *blob2p   //ptr to ptr to blob2
+                   );
+int c_blob_comparator(                     //sort blobs
+                      const void *blob1p,  //ptr to ptr to blob1
+                      const void *blob2p   //ptr to ptr to blob2
+                     );
+TBOX gblob_bounding_box(                 //Get bounding box
+                       PBLOB *blob,     //generic blob
+                       BOOL8 polygonal  //is blob polygonal?
+                      );
+void gblob_sort_list(                        //Sort a gblob list
+                     PBLOB_LIST *blob_list,  //generic blob list
+                     BOOL8 polygonal         //is list polygonal?
+                    );
+OUTLINE_LIST *gblob_out_list(                 //Get outline list
+                             PBLOB *blob,     //generic blob
+                             BOOL8 polygonal  //is blob polygonal?
+                            );
+TBOX goutline_bounding_box(                   //Get bounding box
+                          OUTLINE *outline,  //generic outline
+                          BOOL8 polygonal    //is outline polygonal?
+                         );
+#endif

data/vendor/tesseract-2.04/ccstruct/hpddef.h

@@ -0,0 +1,39 @@
+/**********************************************************************
+ * File:        hpddef.h
+ * Description: Defines for dll symbols for handpd.dll.
+ * Author:					Ray Smith
+ * Created:					Tue Apr 30 17:15:01 MDT 1996
+ *
+ * (C) Copyright 1996, Hewlett-Packard Co.
+ ** 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.
+ *
+ **********************************************************************/
+
+//This file does NOT use the usual single inclusion code as it
+//is necessary to allow it to be executed every time it is included.
+//#ifndef                                                       HPDDEF_H
+//#define                                                       HPDDEF_H
+
+#undef DLLSYM
+#ifndef __IPEDLL
+#             define DLLSYM
+#else
+#             ifdef __BUILDING_HANDPD__
+#             define DLLSYM DLLEXPORT
+#             else
+#             define DLLSYM DLLIMPORT
+#             endif
+#endif
+#if defined(__CFM68K__) && !defined(__USING_STATIC_LIBS__)
+#             pragma import on
+#endif
+
+//#endif

data/vendor/tesseract-2.04/ccstruct/hpdsizes.h

@@ -0,0 +1,8 @@
+#ifndef           HPDSIZES_H
+#define           HPDSIZES_H
+
+#define NUM_TEXT_ATTR   10
+#define NUM_BLOCK_ATTR   7
+#define MAXLENGTH 128
+#define NUM_BACKGROUNDS   8
+#endif