tesseract_bin 1.0.0

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

@@ -0,0 +1,369 @@
+/**********************************************************************
+ * File:        ocrblock.cpp  (Formerly block.c)
+ * Description: BLOCK member functions and iterator functions.
+ * Author:		Ray Smith
+ * Created:		Fri Mar 15 09:41:28 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          <stdlib.h>
+#include          "blckerr.h"
+#include          "ocrblock.h"
+#include          "tprintf.h"
+
+#define BLOCK_LABEL_HEIGHT  150  //char height of block id
+
+ELISTIZE_S (BLOCK)
+/**********************************************************************
+ * BLOCK::BLOCK
+ *
+ * Constructor for a simple rectangular block.
+ **********************************************************************/
+BLOCK::BLOCK (                   //rectangular block
+const char *name,                //filename
+BOOL8 prop,                      //proportional
+inT16 kern,                      //kerning
+inT16 space,                     //spacing
+inT16 xmin,                      //bottom left
+inT16 ymin, inT16 xmax,          //top right
+inT16 ymax):
+PDBLK (xmin, ymin, xmax, ymax),
+filename(name) {  //box(ICOORD(xmin,ymin),ICOORD(xmax,ymax))
+                                 //boundaries
+  ICOORDELT_IT left_it = &leftside;
+  ICOORDELT_IT right_it = &rightside;
+
+  proportional = prop;
+  kerning = kern;
+  spacing = space;
+  font_class = -1;               //not assigned
+  cell_over_xheight_ = 2.0f;
+  hand_block = NULL;
+  hand_poly = NULL;
+  left_it.set_to_list (&leftside);
+  right_it.set_to_list (&rightside);
+                                 //make default box
+  left_it.add_to_end (new ICOORDELT (xmin, ymin));
+  left_it.add_to_end (new ICOORDELT (xmin, ymax));
+  right_it.add_to_end (new ICOORDELT (xmax, ymin));
+  right_it.add_to_end (new ICOORDELT (xmax, ymax));
+}
+
+
+/**********************************************************************
+ * BLOCK::set_sides
+ *
+ * Sets left and right vertex lists
+ **********************************************************************/
+
+//void                                                          BLOCK::set_sides(                       //set vertex lists
+//ICOORDELT_LIST             *left,                        //left vertices
+//ICOORDELT_LIST             *right                        //right vertices
+//)
+//{
+//      ICOORDELT_IT                            left_it= &leftside;                             //boundaries
+//      ICOORDELT_IT                            right_it= &rightside;
+
+//      leftside.clear();
+//      left_it.move_to_first();
+//      left_it.add_list_before(left);
+//      rightside.clear();
+//      right_it.move_to_first();
+//      right_it.add_list_before(right);
+//}
+
+/**********************************************************************
+ * BLOCK::contains
+ *
+ * Return TRUE if the given point is within the block.
+ **********************************************************************/
+
+//BOOL8                                                         BLOCK::contains(                                        //test containment
+//ICOORD                                                        pt                                                                              //point to test
+//)
+//{
+//      BLOCK_RECT_IT                           it=this;                                                                //rectangle iterator
+//      ICOORD                                          bleft,tright;                                           //corners of rectangle
+
+//      for (it.start_block();!it.cycled_rects();it.forward())
+//      {
+//              it.bounding_box(bleft,tright);                                                  //get rectangle
+//              if (pt.x()>=bleft.x() && pt.x()<=tright.x()                     //inside rect
+//              && pt.y()>=bleft.y() && pt.y()<=tright.y())
+//                      return TRUE;                                                                                            //is inside
+//      }
+//      return FALSE;                                                                                                           //not inside
+//}
+
+/**********************************************************************
+ * BLOCK::move
+ *
+ * Reposition block
+ **********************************************************************/
+
+//void                                                     BLOCK::move(                                         // reposition block
+//const ICOORD                                  vec                                                                     // by vector
+//)
+//{
+//   ROW_IT                                             row_it( &rows );
+//      ICOORDELT_IT                            it( &leftside );
+
+//      for( row_it.mark_cycle_pt(); !row_it.cycled_list(); row_it.forward() )
+//         row_it.data()->move( vec );
+
+//      for( it.mark_cycle_pt(); !it.cycled_list(); it.forward() )
+//         *(it.data()) += vec;
+
+//   it.set_to_list( &rightside );
+
+//   for( it.mark_cycle_pt(); !it.cycled_list(); it.forward() )
+//         *(it.data()) += vec;
+
+//   box.move( vec );
+//}
+
+/**********************************************************************
+ * decreasing_top_order
+ *
+ * Sort Comparator: Return <0 if row1 top < row2 top
+ **********************************************************************/
+
+int decreasing_top_order(  //
+                         const void *row1,
+                         const void *row2) {
+  return (*(ROW **) row2)->bounding_box ().top () -
+    (*(ROW **) row1)->bounding_box ().top ();
+}
+
+
+/**********************************************************************
+ * BLOCK::sort_rows
+ *
+ * Order rows so that they are in order of decreasing Y coordinate
+ **********************************************************************/
+
+void BLOCK::sort_rows() {  // order on "top"
+  ROW_IT row_it(&rows);
+
+  row_it.sort (decreasing_top_order);
+}
+
+
+/**********************************************************************
+ * BLOCK::compress
+ *
+ * Delete space between the rows. (And maybe one day, compress the rows)
+ * Fill space of block from top down, left aligning rows.
+ **********************************************************************/
+
+void BLOCK::compress() {  // squash it up
+  #define           ROW_SPACING 5
+
+  ROW_IT row_it(&rows);
+  ROW *row;
+  ICOORD row_spacing (0, ROW_SPACING);
+
+  ICOORDELT_IT icoordelt_it;
+
+  sort_rows();
+
+  box = TBOX (box.topleft (), box.topleft ());
+  box.move_bottom_edge (ROW_SPACING);
+  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
+    row = row_it.data ();
+    row->move (box.botleft () - row_spacing -
+      row->bounding_box ().topleft ());
+    box += row->bounding_box ();
+  }
+
+  leftside.clear ();
+  icoordelt_it.set_to_list (&leftside);
+  icoordelt_it.add_to_end (new ICOORDELT (box.left (), box.bottom ()));
+  icoordelt_it.add_to_end (new ICOORDELT (box.left (), box.top ()));
+  rightside.clear ();
+  icoordelt_it.set_to_list (&rightside);
+  icoordelt_it.add_to_end (new ICOORDELT (box.right (), box.bottom ()));
+  icoordelt_it.add_to_end (new ICOORDELT (box.right (), box.top ()));
+}
+
+
+/**********************************************************************
+ * BLOCK::check_pitch
+ *
+ * Check whether the block is fixed or prop, set the flag, and set
+ * the pitch if it is fixed.
+ **********************************************************************/
+
+void BLOCK::check_pitch() {  // check prop
+  //      tprintf("Missing FFT fixed pitch stuff!\n");
+  pitch = -1;
+}
+
+
+/**********************************************************************
+ * BLOCK::compress
+ *
+ * Compress and move in a single operation.
+ **********************************************************************/
+
+void BLOCK::compress(                  // squash it up
+                     const ICOORD vec  // and move
+                    ) {
+  box.move (vec);
+  compress();
+}
+
+
+/**********************************************************************
+ * BLOCK::print
+ *
+ * Print the info on a block
+ **********************************************************************/
+
+void BLOCK::print(            //print list of sides
+                  FILE *,     //file to print on
+                  BOOL8 dump  //print full detail
+                 ) {
+  ICOORDELT_IT it = &leftside;   //iterator
+
+  box.print ();
+  tprintf ("Proportional= %s\n", proportional ? "TRUE" : "FALSE");
+  tprintf ("Kerning= %d\n", kerning);
+  tprintf ("Spacing= %d\n", spacing);
+  tprintf ("Fixed_pitch=%d\n", pitch);
+  tprintf ("Filename= %s\n", filename.string ());
+
+  if (dump) {
+    tprintf ("Left side coords are:\n");
+    for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
+      tprintf ("(%d,%d) ", it.data ()->x (), it.data ()->y ());
+    tprintf ("\n");
+    tprintf ("Right side coords are:\n");
+    it.set_to_list (&rightside);
+    for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
+      tprintf ("(%d,%d) ", it.data ()->x (), it.data ()->y ());
+    tprintf ("\n");
+  }
+}
+
+
+/**********************************************************************
+ * BLOCK::plot
+ *
+ * Plot the outline of a block in the given colour.
+ **********************************************************************/
+
+//void                                                          BLOCK::plot(                                            //draw outline
+//WINDOW                                                        window,                                                         //window to draw in
+//inT32                                                         serial,                                                         //serial number
+//COLOUR                                                        colour                                                          //colour to draw in
+//)
+//{
+//      ICOORD                                          startpt;                                                                //start of outline
+//      ICOORD                                          endpt;                                                          //end of outline
+//      ICOORD                                          prevpt;                                                         //previous point
+//      ICOORDELT_IT                            it= &leftside;                                          //iterator
+//      char                                                    number[32];                                                     //block id
+
+//      line_color_index(window,colour);                                                                //set the colour
+//      text_color_index(window,colour);
+//      character_height(window,(float)BLOCK_LABEL_HEIGHT);
+//      text_font_index(window,6);
+
+//      if (!leftside.empty())
+//      {
+//              startpt= *(it.data());                                                                          //bottom left corner
+////            fprintf(stderr,"Block %d bottom left is (%d,%d)\n",
+////                    serial,startpt.x(),startpt.y());
+//              sprintf(number,"%d",serial);
+//              text2d(window,startpt.x(),startpt.y(),number,0,FALSE);
+
+//              move2d(window,startpt.x(),startpt.y());
+//              do
+//              {
+//                      prevpt= *(it.data());                                                                   //previous point
+//                      it.forward();                                                                                           //move to next point
+//                      draw2d(window,prevpt.x(),it.data()->y());                       //draw round corner
+//                      draw2d(window,it.data()->x(),it.data()->y());
+//              }
+//              while (!it.at_last());                                                                          //until end of list
+//              endpt= *(it.data());                                                                                    //end point
+
+//              move2d(window,startpt.x(),startpt.y());                         //other side of boundary
+//              it.set_to_list(&rightside);
+//              prevpt=startpt;
+//              for (it.mark_cycle_pt();!it.cycled_list();it.forward())
+//              {
+//                      draw2d(window,prevpt.x(),it.data()->y());                       //draw round corner
+//                      draw2d(window,it.data()->x(),it.data()->y());
+//                      prevpt= *(it.data());                                                                   //previous point
+//              }
+//              draw2d(window,endpt.x(),endpt.y());                                             //close boundary
+//              if (hand_block!=NULL)
+//                      hand_block->plot(window,colour,serial);
+//      }
+//}
+
+/**********************************************************************
+ * BLOCK::show
+ *
+ * Show the image corresponding to a block as its set of rectangles.
+ **********************************************************************/
+
+//void                                                          BLOCK::show(                                            //show image block
+//IMAGE                                                         *image,                                                         //image to show
+//WINDOW                                                        window                                                          //window to show in
+//)
+//{
+//      BLOCK_RECT_IT                           it=this;                                                                //rectangle iterator
+//      ICOORD                                          bleft,tright;                                           //corners of rectangle
+
+//      for (it.start_block();!it.cycled_rects();it.forward())
+//      {
+//              it.bounding_box(bleft,tright);                                                  //get rectangle
+////            fprintf(stderr,"Drawing a block with a bottom left of (%d,%d)\n",
+////                    bleft.x(),bleft.y());
+//              show_sub_image(image,bleft.x(),bleft.y(),
+//                      tright.x()-bleft.x(),tright.y()-bleft.y(),
+//                      window,bleft.x(),bleft.y());                                                    //show it
+//      }
+//}
+
+/**********************************************************************
+ * BLOCK::operator=
+ *
+ * Assignment - duplicate the block structure, but with an EMPTY row list.
+ **********************************************************************/
+
+BLOCK & BLOCK::operator= (       //assignment
+const BLOCK & source             //from this
+) {
+  this->ELIST_LINK::operator= (source);
+  this->PDBLK::operator= (source);
+  proportional = source.proportional;
+  kerning = source.kerning;
+  spacing = source.spacing;
+  filename = source.filename;    //STRINGs assign ok
+  if (!rows.empty ())
+    rows.clear ();
+  //   if ( !leftside.empty() )
+  //              leftside.clear();
+  // if ( !rightside.empty() )
+  //              rightside.clear();
+  //   leftside.deep_copy( &source.leftside );
+  //   rightside.deep_copy( &source.rightside );
+  //      box=source.box;
+  return *this;
+}

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

@@ -0,0 +1,235 @@
+/**********************************************************************
+ * File:        ocrblock.h  (Formerly block.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           OCRBLOCK_H
+#define           OCRBLOCK_H
+
+#include          "img.h"
+#include          "ocrrow.h"
+#include          "pageblk.h"
+#include          "pdblock.h"
+
+class BLOCK;                     //forward decl
+
+ELISTIZEH_S (BLOCK)
+class BLOCK:public ELIST_LINK, public 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
+                              BLOCK_IT *block_it);
+  friend BOOL8 read_vec_file(              //read uscan output
+                             STRING name,  //basename of file
+                             inT32 xsize,  //page size //output list
+                             inT32 ysize,
+                             BLOCK_LIST *blocks);
+  friend BOOL8 read_pd_file(              //read uscan output
+                            STRING name,  //basename of file
+                            inT32 xsize,  //page size //output list
+                            inT32 ysize,
+                            BLOCK_LIST *blocks);
+
+  public:
+    BLOCK() {  //empty constructor
+      hand_block = NULL;
+      hand_poly = NULL;
+    }
+    BLOCK(                   //simple constructor
+          const char *name,  //filename
+          BOOL8 prop,        //proportional
+          inT16 kern,        //kerning
+          inT16 space,       //spacing
+          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
+
+    ~BLOCK () {                  //destructor
+    }
+
+    void set_stats(                   //set space size etc.
+                   BOOL8 prop,        //proportional
+                   inT16 kern,        //inter char size
+                   inT16 space,       //inter word size
+                   inT16 ch_pitch) {  //pitch if fixed
+      proportional = prop;
+      kerning = (inT8) kern;
+      spacing = space;
+      pitch = ch_pitch;
+    }
+    void set_xheight(  //set char size
+                     inT32 height) {
+      xheight = height;
+    }
+    void set_font_class(  //set font class
+                        inT16 font) {
+      font_class = font;
+    }
+    //      TEXT_REGION*                            text_region()
+    //      {
+    //              return hand_block;
+    //      }
+    //      POLY_BLOCK*                                     poly_block()
+    //      {
+    //              return hand_poly;
+    //      }
+    BOOL8 prop() const {  //return proportional
+      return proportional;
+    }
+    inT32 fixed_pitch() const {  //return pitch
+      return pitch;
+    }
+    inT16 kern() const {  //return kerning
+      return kerning;
+    }
+    inT16 font() const {  //return font class
+      return font_class;
+    }
+    inT16 space() const {  //return spacing
+      return spacing;
+    }
+    const char *name() const {  //return filename
+      return filename.string ();
+    }
+    inT32 x_height() const {  //return xheight
+      return xheight;
+    }
+    float cell_over_xheight() const {
+      return cell_over_xheight_;
+    }
+    void set_cell_over_xheight(float ratio) {
+      cell_over_xheight_ = ratio;
+    }
+    ROW_LIST *row_list() {  //get rows
+      return &rows;
+    }
+    C_BLOB_LIST *blob_list() {  //get blobs
+      return &c_blobs;
+    }
+    C_BLOB_LIST *reject_blobs() {
+      return &rej_blobs;
+    }
+    //      void                                                    bounding_box(                                           //get box
+    //              ICOORD&                                 bottom_left,                                            //bottom left
+    //              ICOORD&                                 top_right) const                                        //topright
+    //      {
+    //              bottom_left=box.botleft();
+    //              top_right=box.topright();
+    //      }
+    //      const TBOX&                                      bounding_box() const                            //get real box
+    //      {
+    //              return box;
+    //      }
+
+    //      BOOL8                                                   contains(                                                       //is pt inside block
+    //              ICOORD                                  pt);
+
+    //      void                                                    move(                                                                   // reposition block
+    //         const ICOORD                 vec);                                                                   // by vector
+
+    void sort_rows();  //decreasing y order
+
+    void compress();  //shrink white space
+
+    void check_pitch();  //check proportional
+
+    void compress(                    //shrink white space
+                  const ICOORD vec);  //and move by vector
+
+    void print(              //print summary/table
+               FILE *fp,     //file to print on
+               BOOL8 dump);  //dump whole table
+
+    //      void                                                    plot(                                                                   //draw histogram
+    //              WINDOW                                  window,                                                         //window to draw in
+    //              inT32                                           serial,                                                         //serial number
+    //              COLOUR                                  colour);                                                                //colour to draw in
+
+    //      void                                                    show(                                                                   //show image
+    //              IMAGE                                           *image,                                                         //image to show
+    //              WINDOW                                  window);                                                                //window to show in
+
+    void prep_serialise() {  //set ptrs to counts
+      filename.prep_serialise ();
+      rows.prep_serialise ();
+      c_blobs.prep_serialise ();
+      rej_blobs.prep_serialise ();
+      leftside.prep_serialise ();
+      rightside.prep_serialise ();
+    }
+
+    void dump(  //write external bits
+              FILE *f) {
+      filename.dump (f);
+      rows.dump (f);
+      c_blobs.dump (f);
+      rej_blobs.dump (f);
+      leftside.dump (f);
+      rightside.dump (f);
+      if (hand_block != NULL)
+        hand_block->serialise (f);
+    }
+
+    void de_dump(  //read external bits
+                 FILE *f) {
+      filename.de_dump (f);
+      rows.de_dump (f);
+      c_blobs.de_dump (f);
+      rej_blobs.de_dump (f);
+      leftside.de_dump (f);
+      rightside.de_dump (f);
+      if (hand_block != NULL)
+        hand_block = TEXT_REGION::de_serialise (f);
+    }
+
+                                 //assignment
+    make_serialise (BLOCK) BLOCK & operator= (
+      const BLOCK & source);     //from this
+
+  private:
+    BOOL8 proportional;          //proportional
+    inT8 kerning;                //inter blob gap
+    inT16 spacing;               //inter word gap
+    inT16 pitch;                 //pitch of non-props
+    inT16 font_class;            //correct font class
+    inT32 xheight;               //height of chars
+    float cell_over_xheight_;    // Ratio of cell height to xheight.
+    STRING filename;             //name of block
+    //      TEXT_REGION*                            hand_block;                                                     //if it exists
+    //      POLY_BLOCK*                                     hand_poly;                                                      //wierd as well
+    ROW_LIST rows;               //rows in block
+    C_BLOB_LIST c_blobs;         //before textord
+    C_BLOB_LIST rej_blobs;       //duff stuff
+    //      ICOORDELT_LIST                          leftside;                                                       //left side vertices
+    //      ICOORDELT_LIST                          rightside;                                                      //right side vertices
+    //      TBOX                                                     box;                                                                    //bounding box
+};
+
+int decreasing_top_order(  //
+                         const void *row1,
+                         const void *row2);
+#endif