tesseract_bin 1.0.0

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

@@ -0,0 +1,181 @@
+/**********************************************************************
+ * File:        pdblock.h  (Formerly pdblk.h)
+ * Description: Page block class definition.
+ * Author:					Ray Smith
+ * Created:					Thu Mar 14 17:32:01 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           PDBLOCK_H
+#define           PDBLOCK_H
+
+#include          "img.h"
+#include          "strngs.h"
+#include          "pageblk.h"
+
+#include          "hpddef.h"     //must be last (handpd.dll)
+
+class DLLSYM PDBLK;              //forward decl
+
+CLISTIZEH (PDBLK)
+class DLLSYM PDBLK               //page block
+{
+  friend class BLOCK_RECT_IT;    //block iterator
+
+                                 //block label
+  friend void scan_hpd_blocks(const char *name,
+                              PAGE_BLOCK_LIST *page_blocks,  //head of full pag
+                              inT32 &block_no,               //no of blocks
+                              PDBLK_C_IT *block_it);
+  friend BOOL8 read_vec_file(              //read uscan output
+                             STRING name,  //basename of file
+                             inT32 xsize,  //page size //output list
+                             inT32 ysize,
+                             PDBLK_CLIST *blocks);
+  friend BOOL8 read_pd_file(              //read uscan output
+                            STRING name,  //basename of file
+                            inT32 xsize,  //page size //output list
+                            inT32 ysize,
+                            PDBLK_CLIST *blocks);
+
+  public:
+    PDBLK() {  //empty constructor
+      hand_block = NULL;
+      hand_poly = NULL;
+    }
+    PDBLK(             //simple constructor
+          inT16 xmin,  //bottom left
+          inT16 ymin,
+          inT16 xmax,  //top right
+          inT16 ymax);
+
+    void set_sides(                         //set vertex lists
+                   ICOORDELT_LIST *left,    //list of left vertices
+                   ICOORDELT_LIST *right);  //list of right vertices
+
+    ~PDBLK () {                  //destructor
+    }
+
+    TEXT_REGION *text_region() {
+      return hand_block;
+    }
+    POLY_BLOCK *poly_block() {
+      return hand_poly;
+    }
+    void set_poly_block(  //set the poly block
+                        POLY_BLOCK *blk) {
+      hand_poly = blk;
+    }
+    void bounding_box(                            //get box
+                      ICOORD &bottom_left,        //bottom left
+                      ICOORD &top_right) const {  //topright
+      bottom_left = box.botleft ();
+      top_right = box.topright ();
+    }
+                                 //get real box
+    const TBOX &bounding_box() const {
+      return box;
+    }
+
+    BOOL8 contains(  //is pt inside block
+                   ICOORD pt);
+
+    void move(                    // reposition block
+              const ICOORD vec);  // by vector
+
+    void plot(                 //draw histogram
+              ScrollView* window,   //window to draw in
+              inT32 serial,    //serial number
+              ScrollView::Color colour);  //colour to draw in
+
+    void show(                 //show image
+              IMAGE *image,    //image to show
+              ScrollView* window);  //window to show in
+
+    PDBLK & operator= (          //assignment
+      const PDBLK & source);     //from this
+
+  protected:
+    TEXT_REGION * hand_block;    //if it exists
+    POLY_BLOCK *hand_poly;       //wierd as well
+    ICOORDELT_LIST leftside;     //left side vertices
+    ICOORDELT_LIST rightside;    //right side vertices
+    TBOX box;                     //bounding box
+};
+
+class DLLSYM BLOCK_RECT_IT       //rectangle iterator
+{
+  public:
+    BLOCK_RECT_IT(                 //constructor
+                  PDBLK *blkptr);  //block to iterate
+
+                                 //start (new) block
+    NEWDELETE2 (BLOCK_RECT_IT) void set_to_block (
+      PDBLK * blkptr);           //block to iterate
+
+    void start_block();  //start iteration
+
+    void forward();  //next rectangle
+
+    BOOL8 cycled_rects() {  //test end
+      return left_it.cycled_list () && right_it.cycled_list ();
+    }
+
+    void bounding_box(                   //current rectangle
+                      ICOORD &bleft,     //bottom left
+                      ICOORD &tright) {  //top right
+                                 //bottom left
+      bleft = ICOORD (left_it.data ()->x (), ymin);
+                                 //top right
+      tright = ICOORD (right_it.data ()->x (), ymax);
+    }
+
+  private:
+    inT16 ymin;                  //bottom of rectangle
+    inT16 ymax;                  //top of rectangle
+    PDBLK *block;                //block to iterate
+    ICOORDELT_IT left_it;        //boundary iterators
+    ICOORDELT_IT right_it;
+};
+
+class DLLSYM BLOCK_LINE_IT       //rectangle iterator
+{
+  public:
+    BLOCK_LINE_IT (              //constructor
+      PDBLK * blkptr)            //from block
+    :rect_it (blkptr) {
+      block = blkptr;            //remember block
+    }
+
+                                 //start (new) block
+    NEWDELETE2 (BLOCK_LINE_IT) void set_to_block (
+    PDBLK * blkptr) {            //block to start
+      block = blkptr;            //remember block
+                                 //set iterator
+      rect_it.set_to_block (blkptr);
+    }
+
+    inT16 get_line(               //get a line
+                   inT16 y,       //line to get
+                   inT16 &xext);  //output extent
+
+  private:
+    PDBLK * block;               //block to iterate
+    BLOCK_RECT_IT rect_it;       //rectangle iterator
+};
+
+int decreasing_top_order(  //
+                         const void *row1,
+                         const void *row2);
+#endif

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

@@ -0,0 +1,54 @@
+/**********************************************************************
+ * File:        pdclass.h  (Formerly pdstruct.h)
+ * Description: Data structures for read_vec_file.
+ * Author:		Ray Smith
+ * Created:		Tue Nov  3 11:42:08 GMT 1992
+ *
+ * (C) Copyright 1992, 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           PDCLASS_H
+#define           PDCLASS_H
+
+#include          "points.h"
+
+struct VEC_HEADER
+{
+  inT32 filesize;                //bytes in file
+  inT16 bytesize;                //sizeof a byte
+  inT16 arraysize;               //no of blocks
+  inT16 width;                   //of image
+  inT16 height;
+  inT16 res;                     //not set
+  inT16 bpp;
+};
+
+struct BLOCK_HEADER
+{
+  uinT8 type;                    //block type
+  uinT8 valid;                   //useable flag
+  uinT8 charsize;                //blob size
+  uinT8 downsamplerate;          //??
+  uinT8 subtype;                 //??
+  uinT8 temp;                    //??
+  uinT16 offset;                 //index in vectors
+  uinT16 order;                  //block number
+  uinT16 entries;                //no of vectors
+};
+
+struct VEC_ENTRY
+{
+  ICOORD start;                  //start of vector
+  ICOORD end;                    //in clockwise dir
+};
+#endif

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

@@ -0,0 +1,102 @@
+/**********************************************************************
+ * File:        points.c  (Formerly coords.c)
+ * Description: Member functions for coordinate classes.
+ * Author:					Ray Smith
+ * Created:					Fri Mar 15 08:58:17 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"     //precompiled headers
+#include          "serialis.h"
+#include          "points.h"
+
+ELISTIZE_S (ICOORDELT)           //turn to list
+bool FCOORD::normalise() {  //Convert to unit vec
+  float len = length ();
+
+  if (len < 0.0000000001) {
+    return false;
+  }
+  xcoord /= len;
+  ycoord /= len;
+  return true;
+}
+
+// The fortran/basic sgn function returns -1, 0, 1 if x < 0, x == 0, x > 0
+// respectively.
+static int sign(int x) {
+  if (x < 0)
+    return -1;
+  else
+    return x > 0 ? 1 : 0;
+}
+
+// Setup for iterating over the pixels in a vector by the well-known
+// Bresenham rendering algorithm.
+// Starting with major/2 in the accumulator, on each step add major_step,
+// and then add minor to the accumulator. When the accumulator >= major
+// subtract major and step a minor step.
+
+void ICOORD::setup_render(ICOORD* major_step, ICOORD* minor_step,
+                          int* major, int* minor) {
+  int abs_x = abs(xcoord);
+  int abs_y = abs(ycoord);
+  if (abs_x >= abs_y) {
+    // X-direction is major.
+    major_step->xcoord = sign(xcoord);
+    major_step->ycoord = 0;
+    minor_step->xcoord = 0;
+    minor_step->ycoord = sign(ycoord);
+    *major = abs_x;
+    *minor = abs_y;
+  } else {
+    // Y-direction is major.
+    major_step->xcoord = 0;
+    major_step->ycoord = sign(ycoord);
+    minor_step->xcoord = sign(xcoord);
+    minor_step->ycoord = 0;
+    *major = abs_y;
+    *minor = abs_x;
+  }
+}
+
+
+void ICOORD::serialise_asc(         //convert to ascii
+                           FILE *f  //file to write
+                          ) {
+  serialise_INT32(f, xcoord);
+  serialise_INT32(f, ycoord);
+}
+
+
+void ICOORD::de_serialise_asc(         //convert from ascii
+                              FILE *f  //file to write
+                             ) {
+  xcoord = (inT16) de_serialise_INT32 (f);
+  ycoord = (inT16) de_serialise_INT32 (f);
+}
+
+
+void ICOORDELT::serialise_asc(         //convert to ascii
+                              FILE *f  //file to write
+                             ) {
+  ((ICOORD *) this)->serialise_asc (f);
+}
+
+
+void ICOORDELT::de_serialise_asc(         //convert from ascii
+                                 FILE *f  //file to write
+                                ) {
+  ((ICOORD *) this)->de_serialise_asc (f);
+}

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

@@ -0,0 +1,299 @@
+/**********************************************************************
+ * File:        points.h  (Formerly coords.h)
+ * Description: Coordinate class definitions.
+ * Author:					Ray Smith
+ * Created:					Fri Mar 15 08:32:45 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           POINTS_H
+#define           POINTS_H
+
+#include          <stdio.h>
+#include          <math.h>
+#include          "elst.h"
+//#include                                      "ipeerr.h"
+
+class FCOORD;
+
+class DLLSYM ICOORD              //integer coordinate
+{
+  friend class FCOORD;
+
+  public:
+    ICOORD() {  //empty constructor
+      xcoord = ycoord = 0;       //default zero
+    }
+    ICOORD(              //constructor
+           inT16 xin,    //x value
+           inT16 yin) {  //y value
+      xcoord = xin;
+      ycoord = yin;
+    }
+    ~ICOORD () {                 //destructor
+    }
+
+                                 //access function
+    NEWDELETE2 (ICOORD) inT16 x () const
+    {
+      return xcoord;
+    }
+    inT16 y() const {  //access_function
+      return ycoord;
+    }
+
+    void set_x(  //rewrite function
+               inT16 xin) {
+      xcoord = xin;              //write new value
+    }
+    void set_y(              //rewrite function
+               inT16 yin) {  //value to set
+      ycoord = yin;
+    }
+
+    float sqlength() const {  //find sq length
+      return (float) (xcoord * xcoord + ycoord * ycoord);
+    }
+
+    float length() const {  //find length
+      return (float) sqrt (sqlength ());
+    }
+
+    float pt_to_pt_sqdist(  //sq dist between pts
+                          const ICOORD &pt) const {
+      ICOORD gap;
+
+      gap.xcoord = xcoord - pt.xcoord;
+      gap.ycoord = ycoord - pt.ycoord;
+      return gap.sqlength ();
+    }
+
+    float pt_to_pt_dist(  //Distance between pts
+                        const ICOORD &pt) const {
+      return (float) sqrt (pt_to_pt_sqdist (pt));
+    }
+
+    float angle() const {  //find angle
+      return (float) atan2 ((double) ycoord, (double) xcoord);
+    }
+
+    BOOL8 operator== (           //test equality
+    const ICOORD & other) {
+      return xcoord == other.xcoord && ycoord == other.ycoord;
+    }
+    BOOL8 operator!= (           //test inequality
+    const ICOORD & other) {
+      return xcoord != other.xcoord || ycoord != other.ycoord;
+    }
+    friend ICOORD operator! (    //rotate 90 deg anti
+      const ICOORD &);
+    friend ICOORD operator- (    //unary minus
+      const ICOORD &);
+    friend ICOORD operator+ (    //add
+      const ICOORD &, const ICOORD &);
+    friend ICOORD & operator+= ( //add
+      ICOORD &, const ICOORD &);
+    friend ICOORD operator- (    //subtract
+      const ICOORD &, const ICOORD &);
+    friend ICOORD & operator-= ( //subtract
+      ICOORD &, const ICOORD &);
+    friend inT32 operator% (     //scalar product
+      const ICOORD &, const ICOORD &);
+    friend inT32 operator *(  //cross product
+                            const ICOORD &,
+                            const ICOORD &);
+    friend ICOORD operator *(  //multiply
+                             const ICOORD &,
+                             inT16);
+    friend ICOORD operator *(  //multiply
+                             inT16,
+                             const ICOORD &);
+    friend ICOORD & operator*= ( //multiply
+      ICOORD &, inT16);
+    friend ICOORD operator/ (    //divide
+      const ICOORD &, inT16);
+                                 //divide
+    friend ICOORD & operator/= (ICOORD &, inT16);
+    void rotate(                    //rotate
+                const FCOORD& vec);  //by vector
+
+    // Setup for iterating over the pixels in a vector by the well-known
+    // Bresenham rendering algorithm.
+    // Starting with major/2 in the accumulator, on each step move by
+    // major_step, and then add minor to the accumulator. When
+    // accumulator >= major subtract major and also move by minor_step.
+    void setup_render(ICOORD* major_step, ICOORD* minor_step,
+                      int* major, int* minor);
+
+    void serialise_asc(  //serialise to ascii
+                       FILE *f);
+    void de_serialise_asc(  //serialise from ascii
+                          FILE *f);
+
+  protected:
+    inT16 xcoord;                //x value
+    inT16 ycoord;                //y value
+};
+
+class DLLSYM ICOORDELT:public ELIST_LINK, public ICOORD
+                                 //embedded coord list
+{
+  public:
+    ICOORDELT() {  //empty constructor
+    }
+    ICOORDELT (                  //constructor
+                                 //from ICOORD
+    ICOORD icoord):ICOORD (icoord) {
+    }
+    ICOORDELT(              //constructor
+              inT16 xin,    //x value
+              inT16 yin) {  //y value
+      xcoord = xin;
+      ycoord = yin;
+    }
+
+    /* Note that prep_serialise() dump() and de_dump() dont need to do anything
+    more than terminate recursion. */
+
+    void prep_serialise() const {  //set ptrs to counts
+    }
+
+    void dump(  //write external bits
+              FILE *) const {
+    }
+
+    void de_dump(  //read external bits
+                 FILE *) {
+    }
+
+                                 //serialise to ascii
+    make_serialise(ICOORDELT)
+
+    static ICOORDELT* deep_copy(const ICOORDELT* src) {
+      ICOORDELT* elt = new ICOORDELT;
+      *elt = *src;
+      return elt;
+    }
+
+    void serialise_asc(FILE * f);
+    void de_serialise_asc(  //serialise from ascii
+                          FILE *f);
+
+};
+
+ELISTIZEH_S (ICOORDELT)
+class DLLSYM FCOORD
+{
+  public:
+    FCOORD() {
+    }                            //empty constructor
+    FCOORD(               //constructor
+           float xvalue,  //coords to set
+           float yvalue) {
+      xcoord = xvalue;           //set coords
+      ycoord = yvalue;
+    }
+    FCOORD(                  //make from ICOORD
+           ICOORD icoord) {  //coords to set
+      xcoord = icoord.xcoord;
+      ycoord = icoord.ycoord;
+    }
+
+    float x() const {  //get coords
+      return xcoord;
+    }
+    float y() const {
+      return ycoord;
+    }
+    void set_x(  //rewrite function
+               float xin) {
+      xcoord = xin;              //write new value
+    }
+    void set_y(              //rewrite function
+               float yin) {  //value to set
+      ycoord = yin;
+    }
+
+    float sqlength() const {  //find sq length
+      return xcoord * xcoord + ycoord * ycoord;
+    }
+
+    float length() const {  //find length
+      return (float) sqrt (sqlength ());
+    }
+
+    float pt_to_pt_sqdist(  //sq dist between pts
+                          const FCOORD &pt) const {
+      FCOORD gap;
+
+      gap.xcoord = xcoord - pt.xcoord;
+      gap.ycoord = ycoord - pt.ycoord;
+      return gap.sqlength ();
+    }
+
+    float pt_to_pt_dist(  //Distance between pts
+                        const FCOORD &pt) const {
+      return (float) sqrt (pt_to_pt_sqdist (pt));
+    }
+
+    float angle() const {  //find angle
+      return (float) atan2 (ycoord, xcoord);
+    }
+
+    bool normalise();  //Convert to unit vec
+
+    BOOL8 operator== (           //test equality
+    const FCOORD & other) {
+      return xcoord == other.xcoord && ycoord == other.ycoord;
+    }
+    BOOL8 operator!= (           //test inequality
+    const FCOORD & other) {
+      return xcoord != other.xcoord || ycoord != other.ycoord;
+    }
+                                 //rotate 90 deg anti
+    friend FCOORD operator! (const FCOORD &);
+                                 //unary minus
+    friend FCOORD operator- (const FCOORD &);
+                                 //add
+    friend FCOORD operator+ (const FCOORD &, const FCOORD &);
+                                 //add
+    friend FCOORD & operator+= (FCOORD &, const FCOORD &);
+                                 //subtract
+    friend FCOORD operator- (const FCOORD &, const FCOORD &);
+                                 //subtract
+    friend FCOORD & operator-= (FCOORD &, const FCOORD &);
+                                 //scalar product
+    friend float operator% (const FCOORD &, const FCOORD &);
+                                 //cross product
+    friend float operator *(const FCOORD &, const FCOORD &);
+    friend FCOORD operator *(const FCOORD &, float);
+    //multiply
+    friend FCOORD operator *(float, const FCOORD &);
+    //multiply
+                                 //multiply
+    friend FCOORD & operator*= (FCOORD &, float);
+    friend FCOORD operator/ (const FCOORD &, float);
+    //divide
+    void rotate(                    //rotate
+                const FCOORD vec);  //by vector
+                                 //divide
+    friend FCOORD & operator/= (FCOORD &, float);
+
+  private:
+    float xcoord;                //2 floating coords
+    float ycoord;
+};
+
+#include          "ipoints.h"    /*do inline funcs */
+#endif