tesseract_bin 1.0.0

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

@@ -0,0 +1,441 @@
+/**********************************************************************
+ * File:        poutline.cpp  (Formerly outline.c)
+ * Description: Code for OUTLINE class.
+ * Author:		Ray Smith
+ * Created:		Wed Oct 23 10:52:04 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.
+ *
+ **********************************************************************/
+
+#include "mfcpch.h"
+#include          "poutline.h"
+
+ELISTIZE_S (OUTLINE)
+/**********************************************************************
+ * OUTLINE::OUTLINE
+ *
+ * Constructor to build a OUTLINE from a compact LOOP.
+ **********************************************************************/
+OUTLINE::OUTLINE (               //constructor
+const ICOORD & startpt,          //start position
+inT8 * compactloop,              //from Tess format
+BOOL8 invert,                    //reverse it
+ICOORD bot_left,                 //bounding box
+ICOORD top_right):
+box (bot_left, top_right),
+start(startpt) {
+  ICOORD pos;                    //current point
+  ICOORD vec;                    //vector to next
+  POLYPT *polypt;                //new point
+  inT8 *vector;                  //compact loop
+  POLYPT_IT it = &outline;       //iterator
+
+  pos = startpt;
+  vector = compactloop;
+  do {
+                                 //vector to next
+    vec = ICOORD (*vector, *(vector + 1));
+                                 //make a new one
+    polypt = new POLYPT (FCOORD (pos), FCOORD (vec));
+                                 //add to list
+    it.add_after_then_move (polypt);
+    pos += vec;                  //move to next
+    vector += 2;
+  }
+  while (pos != startpt);
+  if (invert)
+    reverse();  //now reverse it
+}
+
+
+/**********************************************************************
+ * OUTLINE::OUTLINE
+ *
+ * Constructor to build an OUTLINE from a list of POLYPTs.
+ **********************************************************************/
+
+OUTLINE::OUTLINE(                    //constructor
+                 POLYPT_IT *polypts  //input list
+                ) {
+  POLYPT_IT other_it = *polypts; //end of list
+
+  polypts->move_to_first ();
+  other_it.move_to_last ();
+                                 //put in outline
+  outline.assign_to_sublist (polypts, &other_it);
+  compute_bb();
+}
+
+
+/**********************************************************************
+ * OUTLINE::compute_bb
+ *
+ * Compute the bounding box from the outline points.
+ **********************************************************************/
+
+void OUTLINE::compute_bb() {  //constructor
+  ICOORD ibl, itr;               //integer bb
+  FCOORD botleft;                //bounding box
+  FCOORD topright;
+  FCOORD pos;                    //current pos;
+  POLYPT_IT polypts = &outline;  //iterator
+
+  botleft = polypts.data ()->pos;
+  topright = botleft;
+  start = ICOORD ((inT16) botleft.x (), (inT16) botleft.y ());
+  do {
+    pos = polypts.data ()->pos;
+    if (pos.x () < botleft.x ())
+                                 //get bounding box
+      botleft = FCOORD (pos.x (), botleft.y ());
+    if (pos.y () < botleft.y ())
+      botleft = FCOORD (botleft.x (), pos.y ());
+    if (pos.x () > topright.x ())
+      topright = FCOORD (pos.x (), topright.y ());
+    if (pos.y () > topright.y ())
+      topright = FCOORD (topright.x (), pos.y ());
+    polypts.forward ();
+  }
+  while (!polypts.at_first ());
+  ibl = ICOORD ((inT16) botleft.x (), (inT16) botleft.y ());
+  itr = ICOORD ((inT16) topright.x () + 1, (inT16) topright.y () + 1);
+  box = TBOX (ibl, itr);
+}
+
+
+/**********************************************************************
+ * OUTLINE::area
+ *
+ * Compute the area from the outline points.
+ **********************************************************************/
+
+float OUTLINE::area() {  //constructor
+  FCOORD origin;                 //startpt
+  FCOORD prev_vec;               //previous value of vec
+  FCOORD vec;                    //from start to current
+  float total;                   //total area
+  POLYPT_IT poly_it = polypts ();//iterator
+                                 //child outline itertr
+  OUTLINE_IT child_it(&children);
+
+  origin = poly_it.data ()->pos;
+  poly_it.forward ();
+  vec = poly_it.data ()->pos - origin;
+  poly_it.forward ();
+  total = 0.0f;
+  while (!poly_it.at_first ()) {
+    prev_vec = vec;
+    vec = poly_it.data ()->pos - origin;
+    total += prev_vec * vec;
+    poly_it.forward ();
+  }
+  total /= 2;
+  for (child_it.mark_cycle_pt (); !child_it.cycled_list ();
+  child_it.forward ()) {
+                                 //add ares of childrein
+    total += child_it.data ()->area ();
+  }
+  return total;
+}
+
+
+/**********************************************************************
+ * OUTLINE::operator<
+ *
+ * Return TRUE if the left operand is inside the right one.
+ **********************************************************************/
+
+BOOL8
+OUTLINE::operator< (             //winding number
+OUTLINE & other                  //other outline
+) {
+  inT16 count;                   //winding count
+  POLYPT_IT it = &outline;       //iterator
+
+  if (!box.overlap (other.box))
+    return FALSE;                //can't be contained
+
+  do {
+    count = other.winding_number (FCOORD (it.data ()->pos));
+    //get winding number
+    if (count != INTERSECTING)
+      return count != 0;
+    it.forward ();
+  }
+  while (!it.at_first ());
+
+                                 //switch lists
+  it.set_to_list (&other.outline);
+  do {
+                                 //try other way round
+    count = winding_number (FCOORD (it.data ()->pos));
+    if (count != INTERSECTING)
+      return count == 0;
+    it.forward ();
+  }
+  while (!it.at_first ());
+  return TRUE;
+}
+
+
+/**********************************************************************
+ * OUTLINE::winding_number
+ *
+ * Return the winding number of the outline around the given point.
+ **********************************************************************/
+
+inT16 OUTLINE::winding_number(                     //winding number
+                              const FCOORD &point  //point to wind around
+                             ) {
+  inT16 count;                   //winding count
+  POLYPT *polypt;                //current point
+  FCOORD vec;                    //to current point
+  float cross;                   //cross product
+  POLYPT_IT it = &outline;       //iterator
+
+  count = 0;
+  do {
+    polypt = it.data ();
+    vec = polypt->pos - point;
+                                 //crossing the line
+    if (vec.y () <= 0 && vec.y () + polypt->vec.y () > 0) {
+      cross = vec * polypt->vec; //cross product
+      if (cross > 0)
+        count++;                 //crossing right half
+      else if (cross == 0)
+        return INTERSECTING;     //going through point
+    }
+    else if (vec.y () > 0 && vec.y () + polypt->vec.y () <= 0) {
+      cross = vec * polypt->vec;
+      if (cross < 0)
+        count--;                 //crossing back
+      else if (cross == 0)
+        return INTERSECTING;     //illegal
+    }
+    it.forward ();
+  }
+  while (!it.at_first ());
+  return count;                  //winding number
+}
+
+
+/**********************************************************************
+ * OUTLINE::reverse
+ *
+ * Reverse the direction of an outline.
+ **********************************************************************/
+
+void OUTLINE::reverse() {  //reverse direction
+  POLYPT_LIST back_list;         //reversed list
+  POLYPT_IT dest_it = &back_list;//destination
+  POLYPT_IT src_it = &outline;   //source list
+  POLYPT *polypt;                //current point
+
+  do {
+    polypt = src_it.extract ();
+                                 //copy in reverse
+    dest_it.add_after_then_move (polypt);
+    src_it.backward ();
+  }
+  while (!src_it.empty ());
+  dest_it.move_to_first ();
+  do {
+    polypt = dest_it.data ();
+    polypt->vec = dest_it.data_relative (1)->pos - polypt->pos;
+    //vector to next
+    dest_it.forward ();
+  }
+  while (!dest_it.at_first ());
+  dest_it.backward ();
+  src_it.set_to_list (&back_list);
+                                 //put it back
+  outline.assign_to_sublist (&src_it, &dest_it);
+}
+
+
+/**********************************************************************
+ * OUTLINE::move
+ *
+ * Move OUTLINE by vector
+ **********************************************************************/
+
+void OUTLINE::move(                  // reposition OUTLINE
+                   const FCOORD vec  // by vector
+                  ) {
+                                 //child outline itertr
+  OUTLINE_IT child_it(&children);
+  POLYPT_IT poly_it(&outline);  //outline point itertr
+
+  box.move (vec);
+
+  start.set_x ((inT16) floor (start.x () + vec.x () + 0.5));
+  // ?? Why ICOORD?
+  start.set_y ((inT16) floor (start.y () + vec.y () + 0.5));
+  // ?? Why ICOORD?
+
+  for (poly_it.mark_cycle_pt (); !poly_it.cycled_list (); poly_it.forward ())
+    poly_it.data ()->pos += vec;
+
+  for (child_it.mark_cycle_pt (); !child_it.cycled_list ();
+    child_it.forward ())
+  child_it.data ()->move (vec);  // move child outlines
+}
+
+
+/**********************************************************************
+ * OUTLINE::scale
+ *
+ * Scale OUTLINE by vector
+ **********************************************************************/
+
+void OUTLINE::scale(               // scale OUTLINE
+                    const float f  // by multiplier
+                   ) {
+                                 //child outline itertr
+  OUTLINE_IT child_it(&children);
+  POLYPT_IT poly_it(&outline);  //outline point itertr
+  POLYPT *pt;
+
+  box.scale (f);
+
+                                 // ?? Why ICOORD?
+  start.set_x ((inT16) floor (start.x () * f + 0.5));
+                                 // ?? Why ICOORD?
+  start.set_y ((inT16) floor (start.y () * f + 0.5));
+
+  for (poly_it.mark_cycle_pt (); !poly_it.cycled_list (); poly_it.forward ()) {
+    pt = poly_it.data ();
+    pt->pos *= f;
+    pt->vec *= f;
+  }
+
+  for (child_it.mark_cycle_pt (); !child_it.cycled_list ();
+    child_it.forward ())
+  child_it.data ()->scale (f);   //scale child outlines
+}
+
+
+/**********************************************************************
+ * OUTLINE::scale
+ *
+ * Scale OUTLINE by vector
+ **********************************************************************/
+
+void OUTLINE::scale(                     // scale OUTLINE
+                    const FCOORD vector  //by fcoord
+                   ) {
+                                 //child outline itertr
+  OUTLINE_IT child_it(&children);
+  POLYPT_IT poly_it(&outline);  //outline point itertr
+  POLYPT *pt;
+
+  box.scale (vector);
+
+  start.set_x ((inT16) floor (start.x () * vector.x () + 0.5));
+  // ?? Why ICOORD?
+  start.set_y ((inT16) floor (start.y () * vector.y () + 0.5));
+  // ?? Why ICOORD?
+
+  for (poly_it.mark_cycle_pt (); !poly_it.cycled_list (); poly_it.forward ()) {
+    pt = poly_it.data ();
+    pt->pos =
+      FCOORD (pt->pos.x () * vector.x (), pt->pos.y () * vector.y ());
+    pt->vec =
+      FCOORD (pt->vec.x () * vector.x (), pt->vec.y () * vector.y ());
+  }
+
+  for (child_it.mark_cycle_pt (); !child_it.cycled_list ();
+    child_it.forward ())
+                                 //scale child outlines
+  child_it.data ()->scale (vector);
+}
+
+/**********************************************************************
+ * OUTLINE::rotate
+ *
+ * Rotate OUTLINE by the given vector
+ **********************************************************************/
+
+void OUTLINE::rotate(
+                     const FCOORD vector  //by fcoord
+                    ) {
+                                 //child outline itertr
+  OUTLINE_IT child_it(&children);
+  POLYPT_IT poly_it(&outline);  //outline point itertr
+  POLYPT *pt;
+  box.rotate(vector);
+
+  start.rotate(vector);
+
+  for (poly_it.mark_cycle_pt (); !poly_it.cycled_list (); poly_it.forward ()) {
+    pt = poly_it.data ();
+    pt->pos.rotate(vector);
+    pt->vec.rotate(vector);
+  }
+
+  for (child_it.mark_cycle_pt (); !child_it.cycled_list ();
+    child_it.forward ())
+                                 //scale child outlines
+    child_it.data ()->rotate(vector);
+}
+
+
+/**********************************************************************
+ * OUTLINE::plot
+ *
+ * Draw the outline in the given colour.
+ **********************************************************************/
+
+#ifndef GRAPHICS_DISABLED
+void OUTLINE::plot(                //draw it
+                   ScrollView* window,  //window to draw in
+                   ScrollView::Color colour   //colour to draw in
+                  ) {
+  POLYPT *polypt;                //current point
+  POLYPT_IT it = &outline;       //iterator
+
+  window->Pen(colour);
+  polypt = it.data ();
+  int startx = polypt->pos.x ();
+  int starty = polypt->pos.y ();
+  do {
+    it.forward ();
+    polypt = it.data ();
+    window->Line(startx,starty,polypt->pos.x (),polypt->pos.y ());
+    startx = polypt->pos.x ();
+    starty = polypt->pos.y ();
+  }
+  while (!it.at_first ());
+}
+#endif
+
+
+/**********************************************************************
+ * OUTLINE::operator=
+ *
+ * Assignment - deep copy data
+ **********************************************************************/
+
+OUTLINE & OUTLINE::operator= (   //assignment
+const OUTLINE & source           //from this
+) {
+  box = source.box;
+  start = source.start;
+  if (!outline.empty())
+    outline.clear();
+  outline.deep_copy(&source.outline, &POLYPT::deep_copy);
+  if (!children.empty())
+    children.clear();
+  children.deep_copy(&source.children, &OUTLINE::deep_copy);
+  return *this;
+}

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

@@ -0,0 +1,125 @@
+/**********************************************************************
+ * File:        poutline.h  (Formerly outline.h)
+ * Description: OUTLINE class definition.
+ * Author:		Ray Smith
+ * Created:		Wed Oct 23 10:42:40 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           POUTLINE_H
+#define           POUTLINE_H
+
+#include          "scrollview.h"
+#include          "polyvert.h"
+#include          "rect.h"
+#include          "blckerr.h"
+
+#define INTERSECTING    MAX_INT16//no winding number
+
+class OUTLINE;                   //forward declaration
+
+ELISTIZEH_S (OUTLINE)
+class OUTLINE:public ELIST_LINK
+{
+  public:
+    OUTLINE() {  //empty constructor
+    }
+    OUTLINE(                        //constructor
+            const ICOORD &startpt,  //start point
+            inT8 *compactloop,      //from Tess format
+            BOOL8 reverse,          //reverse it
+            ICOORD bot_left,        //bounding box
+            ICOORD top_right);
+    OUTLINE(                      //constructor
+            POLYPT_IT *poly_it);  //from list of pts
+
+    OUTLINE_LIST *child() {  //get child list
+      return &children;
+    }
+
+                                 //access function
+    const TBOX &bounding_box() const {
+      return box;
+    }
+    void compute_bb();  //set bounding box
+
+                                 //get start position
+    const ICOORD &start_pos() const {
+      return start;
+    }
+    float area();  //return area
+    POLYPT_LIST *polypts() {  //get poly
+      return &outline;
+    }
+
+    BOOL8 operator< (            //containment test
+      OUTLINE & other);
+    BOOL8 operator> (            //containment test
+    OUTLINE & other) {
+      return other < *this;      //use the < to do it
+    }
+    inT16 winding_number(                        //get winding number
+                         const FCOORD &testpt);  //around this point
+    void reverse();  //reverse it
+
+    void move(                    // reposition outline
+              const FCOORD vec);  // by FLOAT vector
+
+    void scale(                 // scale outline
+               const float f);  // by multiplier
+    void scale(                    // scale outline
+               const FCOORD vec);  // by FLOAT vector
+
+    void rotate(               // rotate outline
+        const FCOORD vector);  // by fcoord
+
+    void plot(                 //draw one
+              ScrollView* window,   //window to draw in
+              ScrollView::Color colour);  //colour to draw it
+
+    void prep_serialise() {  //set ptrs to counts
+      outline.prep_serialise ();
+      children.prep_serialise ();
+    }
+
+    void dump(  //write external bits
+              FILE *f) {
+      outline.dump (f);
+      children.dump (f);
+    }
+
+    void de_dump(  //read external bits
+                 FILE *f) {
+      outline.de_dump (f);
+      children.de_dump (f);
+    }
+
+                                 //assignment
+    make_serialise(OUTLINE)
+
+    OUTLINE& operator=(const OUTLINE& source);
+
+    static OUTLINE* deep_copy(const OUTLINE* src) {
+      OUTLINE* outline = new OUTLINE;
+      *outline = *src;
+      return outline;
+    }
+
+  private:
+    TBOX box;                     //boudning box
+    ICOORD start;                //start coord
+    POLYPT_LIST outline;         //outline points
+    OUTLINE_LIST children;       //child elements
+};
+#endif

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

@@ -0,0 +1,147 @@
+/**********************************************************************
+ * File:        quadlsq.cpp  (Formerly qlsq.c)
+ * Description: Code for least squares approximation of quadratics.
+ * Author:		Ray Smith
+ * Created:		Wed Oct  6 15:14:23 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          <stdio.h>
+#include          <math.h>
+#include          "errcode.h"
+#include          "quadlsq.h"
+
+const ERRCODE EMPTY_QLSQ = "Can't delete from an empty QLSQ";
+
+#define EXTERN
+
+/**********************************************************************
+ * QLSQ::clear
+ *
+ * Function to initialize a QLSQ.
+ **********************************************************************/
+
+void QLSQ::clear() {  //initialize
+  a = 0;
+  b = 0;
+  c = 0;
+  n = 0;                         //no elements
+  sigx = 0;                      //update accumulators
+  sigy = 0;
+  sigxx = 0;
+  sigxy = 0;
+  sigyy = 0;
+  sigxxx = 0;
+  sigxxy = 0;
+  sigxxxx = 0;
+}
+
+
+/**********************************************************************
+ * QLSQ::add
+ *
+ * Add an element to the accumulator.
+ **********************************************************************/
+
+void QLSQ::add(           //add an element
+               double x,  //xcoord
+               double y   //ycoord
+              ) {
+  n++;                           //count elements
+  sigx += x;                     //update accumulators
+  sigy += y;
+  sigxx += x * x;
+  sigxy += x * y;
+  sigyy += y * y;
+  sigxxx += (long double) x *x * x;
+  sigxxy += (long double) x *x * y;
+  sigxxxx += (long double) x *x * x * x;
+}
+
+
+/**********************************************************************
+ * QLSQ::remove
+ *
+ * Delete an element from the acculuator.
+ **********************************************************************/
+
+void QLSQ::remove(           //delete an element
+                  double x,  //xcoord
+                  double y   //ycoord
+                 ) {
+  if (n <= 0)
+                                 //illegal
+    EMPTY_QLSQ.error ("QLSQ::remove", ABORT, NULL);
+  n--;                           //count elements
+  sigx -= x;                     //update accumulators
+  sigy -= y;
+  sigxx -= x * x;
+  sigxy -= x * y;
+  sigyy -= y * y;
+  sigxxx -= (long double) x *x * x;
+  sigxxy -= (long double) x *x * y;
+  sigxxxx -= (long double) x *x * x * x;
+}
+
+
+/**********************************************************************
+ * QLSQ::fit
+ *
+ * Fit the given degree of polynomial and store the result.
+ **********************************************************************/
+
+void QLSQ::fit(            //fit polynomial
+               int degree  //degree to fit
+              ) {
+  long double cubetemp;          //intermediates
+  long double squaretemp;
+  long double top96, bottom96;   /*accurate top & bottom */
+
+  if (n >= 4 && degree >= 2) {
+    cubetemp = sigxxx * n - (long double) sigxx *sigx;
+
+    top96 =
+      cubetemp * ((long double) sigxy * n - (long double) sigx * sigy);
+
+    squaretemp = (long double) sigxx *n - (long double) sigx *sigx;
+
+    top96 += squaretemp * ((long double) sigxx * sigy - sigxxy * n);
+
+    bottom96 = cubetemp * cubetemp;
+
+    bottom96 -= squaretemp * (sigxxxx * n - (long double) sigxx * sigxx);
+
+    a = top96 / bottom96;
+
+    top96 = ((long double) sigxx * sigx - sigxxx * n) * a
+      + (long double) sigxy *n - (long double) sigx *sigy;
+    bottom96 = (long double) sigxx *n - (long double) sigx *sigx;
+    b = top96 / bottom96;
+
+    c = (sigy - a * sigxx - b * sigx) / n;
+  }
+  else if (n == 0 || degree < 0) {
+    a = b = c = 0;
+  }
+  else {
+    a = 0;
+    if (n > 1 && degree > 0) {
+      b = (sigxy * n - sigx * sigy) / (sigxx * n - sigx * sigx);
+    }
+    else
+      b = 0;
+    c = (sigy - b * sigx) / n;
+  }
+}