tesseract_bin 1.0.0

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

@@ -0,0 +1,85 @@
+/**********************************************************************
+ * File:        mod128.h  (Formerly dir128.h)
+ * Description: Header for class which implements modulo arithmetic.
+ * Author:					Ray Smith
+ * Created:					Tue Mar 26 17:48:13 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           MOD128_H
+#define           MOD128_H
+
+#include          "points.h"
+
+#define MODULUS       128        /*range of directions */
+#define DIRBITS       7          //no of bits used
+#define DIRSCALE      1000       //length of vector
+
+class DLLSYM DIR128
+{
+  public:
+    DIR128() {
+    }                            //empty constructor
+
+    DIR128(                //constructor
+           inT16 value) {  //value to assign
+      value %= MODULUS;          //modulo arithmetic
+      if (value < 0)
+        value += MODULUS;        //done properly
+      dir = (inT8) value;
+    }
+    DIR128(const FCOORD fc);  //quantize vector
+
+    DIR128 & operator= (         //assign of inT16
+    inT16 value) {               //value to assign
+      value %= MODULUS;          //modulo arithmetic
+      if (value < 0)
+        value += MODULUS;        //done properly
+      dir = (inT8) value;
+      return *this;
+    }
+    inT8 operator- (             //subtraction
+      const DIR128 & minus) const//for signed result
+    {
+                                 //result
+      inT16 result = dir - minus.dir;
+
+      if (result > MODULUS / 2)
+        result -= MODULUS;       //get in range
+      else if (result < -MODULUS / 2)
+        result += MODULUS;
+      return (inT8) result;
+    }
+    DIR128 operator+ (           //addition
+      const DIR128 & add) const  //of itself
+    {
+      DIR128 result;             //sum
+
+      result = dir + add.dir;    //let = do the work
+      return result;
+    }
+    DIR128 & operator+= (        //same as +
+    const DIR128 & add) {
+      *this = dir + add.dir;     //let = do the work
+      return *this;
+    }
+    inT8 get_dir() const {  //access function
+      return dir;
+    }
+    ICOORD vector() const;  //turn to vector
+
+  private:
+    inT8 dir;                    //a direction
+};
+#endif

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

@@ -0,0 +1,176 @@
+/**********************************************************************
+ * File:        normalis.cpp  (Formerly denorm.c)
+ * Description: Code for the DENORM class.
+ * Author:		Ray Smith
+ * Created:		Thu Apr 23 09:22:43 BST 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.
+ *
+ **********************************************************************/
+
+#include "mfcpch.h"
+#include          "werd.h"
+#include          "normalis.h"
+
+/**********************************************************************
+ * DENORM::binary_search_segment
+ *
+ * Find the segment to use for the given x.
+ **********************************************************************/
+
+const DENORM_SEG *DENORM::binary_search_segment(float src_x) const {
+  int bottom, top, middle;       //binary search
+
+  bottom = 0;
+  top = segments;
+  do {
+    middle = (bottom + top) / 2;
+    if (segs[middle].xstart > src_x)
+      top = middle;
+    else
+      bottom = middle;
+  }
+  while (top - bottom > 1);
+  return &segs[bottom];
+}
+
+/**********************************************************************
+ * DENORM::scale_at_x
+ *
+ * Return scaling at a given (normalized) x coord.
+ **********************************************************************/
+
+float DENORM::scale_at_x(float src_x) const {  // In normalized coords.
+  if (segments != 0) {
+    const DENORM_SEG* seg = binary_search_segment(src_x);
+    if (seg->scale_factor > 0.0)
+      return seg->scale_factor;
+  }
+  return scale_factor;
+}
+
+/**********************************************************************
+ * DENORM::yshift_at_x
+ *
+ * Return yshift at a given (normalized) x coord.
+ **********************************************************************/
+
+float DENORM::yshift_at_x(float src_x) const {  // In normalized coords.
+  if (segments != 0) {
+    const DENORM_SEG* seg = binary_search_segment(src_x);
+    if (seg->ycoord == -MAX_INT32) {
+      if (base_is_row)
+        return source_row->base_line(x(src_x)/scale_at_x(src_x) + x_centre);
+      else
+        return m * x(src_x) + c;
+    } else {
+      return seg->ycoord;
+    }
+  }
+  return source_row->base_line (x(src_x)/scale_at_x(src_x) + x_centre);
+}
+
+/**********************************************************************
+ * DENORM::x
+ *
+ * Denormalise an x coordinate.
+ **********************************************************************/
+
+float DENORM::x(             //convert x coord
+                float src_x  //coord to convert
+               ) const {
+  return src_x / scale_at_x(src_x) + x_centre;
+}
+
+
+/**********************************************************************
+ * DENORM::y
+ *
+ * Denormalise a y coordinate.
+ **********************************************************************/
+
+float DENORM::y(                  //convert y coord
+                float src_y,      //coord to convert
+                float src_centre  //x location for base
+               ) const {
+  return (src_y - bln_baseline_offset) / scale_at_x(src_centre)
+    + yshift_at_x(src_centre);
+}
+
+
+DENORM::DENORM(float x,              //from same pieces
+               float scaling,
+               double line_m,        //default line
+               double line_c,
+               inT16 seg_count,      //no of segments
+               DENORM_SEG *seg_pts,  //actual segments
+               BOOL8 using_row,      //as baseline
+               ROW *src) {
+  x_centre = x;                  //just copy
+  scale_factor = scaling;
+  source_row = src;
+  if (seg_count > 0) {
+    segs = new DENORM_SEG[seg_count];
+    for (segments = 0; segments < seg_count; segments++) {
+      // It is possible, if infrequent that the segments may be out of order.
+      // since we are searching with a binary search, keep them in order.
+      if (segments == 0 || segs[segments - 1].xstart <=
+          seg_pts[segments].xstart) {
+        segs[segments] = seg_pts[segments];
+      } else {
+        int i;
+        for (i = 0; i < segments
+             && segs[segments - 1 - i].xstart > seg_pts[segments].xstart;
+             ++i) {
+          segs[segments - i ] = segs[segments - 1 - i];
+        }
+        segs[segments - i] = seg_pts[segments];
+      }
+    }
+  }
+  else {
+    segments = 0;
+    segs = NULL;
+  }
+  base_is_row = using_row;
+  m = line_m;
+  c = line_c;
+}
+
+
+DENORM::DENORM(const DENORM &src) {
+  segments = 0;
+  segs = NULL;
+  *this = src;
+}
+
+
+DENORM & DENORM::operator= (const DENORM & src) {
+  x_centre = src.x_centre;
+  scale_factor = src.scale_factor;
+  source_row = src.source_row;
+  if (segments > 0)
+    delete[]segs;
+  if (src.segments > 0) {
+    segs = new DENORM_SEG[src.segments];
+    for (segments = 0; segments < src.segments; segments++)
+      segs[segments] = src.segs[segments];
+  }
+  else {
+    segments = 0;
+    segs = NULL;
+  }
+  base_is_row = src.base_is_row;
+  m = src.m;
+  c = src.c;
+  return *this;
+}

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

@@ -0,0 +1,108 @@
+/**********************************************************************
+ * File:        normalis.h  (Formerly denorm.h)
+ * Description: Code for the DENORM class.
+ * Author:		Ray Smith
+ * Created:		Thu Apr 23 09:22:43 BST 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           NORMALIS_H
+#define           NORMALIS_H
+
+#include          <stdio.h>
+
+class ROW;                       //forward decl
+
+class DENORM_SEG
+{
+  public:
+    DENORM_SEG() {
+    }                            //empty
+
+    inT32 xstart;                //start of segment
+    inT32 ycoord;                //y at segment
+    float scale_factor;          //for this segment
+};
+
+class DENORM
+{
+  public:
+    DENORM() {  //constructor
+      source_row = NULL;
+      x_centre = 0.0f;
+      scale_factor = 1.0f;
+      segments = 0;
+      segs = NULL;
+      base_is_row = TRUE;
+      m = c = 0;
+    }
+    DENORM(          //constructor
+           float x,  //from same pieces
+           float scaling,
+           ROW *src) {
+      x_centre = x;              //just copy
+      scale_factor = scaling;
+      source_row = src;
+      segments = 0;
+      segs = NULL;
+      base_is_row = TRUE;
+      m = c = 0;
+    }
+    DENORM(                      //constructor
+           float x,              //from same pieces
+           float scaling,
+           double line_m,        //default line //no of segments
+           double line_c,
+           inT16 seg_count,
+           DENORM_SEG *seg_pts,  //actual segments
+           BOOL8 using_row,      //as baseline
+           ROW *src);
+    DENORM(const DENORM &);
+    DENORM & operator= (const DENORM &);
+    ~DENORM () {
+      if (segments > 0)
+        delete[]segs;
+    }
+
+    float origin() const {  //get x centre
+      return x_centre;
+    }
+    float scale() const {  //get scale
+      return scale_factor;
+    }
+    ROW *row() const {  //get row
+      return source_row;
+    }
+    float x(  //convert an xcoord
+            float src_x) const;
+    float y(                    //convert a ycoord
+            float src_y,        //coord to convert
+            float src_centre) const;  //normed x centre
+    float scale_at_x(  // Return scaling at this coord.
+            float src_x) const;
+    float yshift_at_x(  // Return yshift at this coord.
+            float src_x) const;
+
+  private:
+    const DENORM_SEG *binary_search_segment(float src_x) const;
+
+    BOOL8 base_is_row;           //using row baseline?
+    inT16 segments;              //no of segments
+    double c, m;                 //baseline
+    float x_centre;              //middle of word
+    float scale_factor;          //scaling
+    ROW *source_row;             //row it came from
+    DENORM_SEG *segs;            //array of segments
+};
+#endif