tesseract_bin 1.0.0

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

@@ -0,0 +1,313 @@
+/**********************************************************************
+ * File:        pageres.h  (Formerly page_res.h)
+ * Description: Results classes used by control.c
+ * Author:		Phil Cheatle
+ * Created:     Tue Sep 22 08:42:49 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           PAGERES_H
+#define           PAGERES_H
+
+#include          "elst.h"
+#include          "ocrblock.h"
+#include          "ocrrow.h"
+#include          "werd.h"
+#include          "ratngs.h"
+#include          "rejctmap.h"
+#include          "notdll.h"
+#include          "notdll.h"
+
+/* Forward declarations */
+
+class BLOCK_RES;
+
+ELISTIZEH (BLOCK_RES) CLISTIZEH (BLOCK_RES)
+class
+ROW_RES;
+
+ELISTIZEH (ROW_RES)
+class WERD_RES;
+
+ELISTIZEH (WERD_RES)
+/*************************************************************************
+ * PAGE_RES - Page results
+ *************************************************************************/
+class PAGE_RES                   //page result
+{
+  public:
+    inT32 char_count;
+    inT32 rej_count;
+    BLOCK_RES_LIST block_res_list;
+    BOOL8 rejected;
+
+    PAGE_RES() {
+    }                            //empty constructor
+
+    PAGE_RES(                          //simple constructor
+             BLOCK_LIST *block_list);  //real blocks
+
+    ~PAGE_RES () {               //destructor
+    }
+};
+
+/*************************************************************************
+ * BLOCK_RES - Block results
+ *************************************************************************/
+
+class BLOCK_RES:public ELIST_LINK
+                                 //page block result
+{
+  public:
+    BLOCK * block;               //real block
+    inT32 char_count;            //chars in block
+    inT32 rej_count;             //rejected chars
+    inT16 font_class;            //
+    inT16 row_count;
+    float x_height;
+    BOOL8 font_assigned;         // block already
+    //      processed
+    BOOL8 bold;                  // all bold
+    BOOL8 italic;                // all italic
+
+    ROW_RES_LIST row_res_list;
+
+    BLOCK_RES() {
+    }                            //empty constructor
+
+    BLOCK_RES(                    //simple constructor
+              BLOCK *the_block);  //real block
+
+    ~BLOCK_RES () {              //destructor
+    }
+};
+
+/*************************************************************************
+ * ROW_RES - Row results
+ *************************************************************************/
+
+class ROW_RES:public ELIST_LINK  //row result
+{
+  public:
+    ROW * row;                   //real row
+    inT32 char_count;            //chars in block
+    inT32 rej_count;             //rejected chars
+    inT32 whole_word_rej_count;  //rejs in total rej wds
+    WERD_RES_LIST word_res_list;
+    float font_class_score;
+    inT16 font_class;            //
+    inT32 italic;
+    inT32 bold;
+    inT8 font1;                  //primary font
+    inT8 font1_count;            //no of voters
+    inT8 font2;                  //secondary font
+    inT8 font2_count;            //no of voters
+
+    ROW_RES() {
+    }                            //empty constructor
+
+    ROW_RES(                //simple constructor
+            ROW *the_row);  //real row
+
+    ~ROW_RES () {                //destructor
+    }
+};
+
+/*************************************************************************
+ * WERD_RES - Word results
+ *************************************************************************/
+enum CRUNCH_MODE
+{
+  CR_NONE,
+  CR_KEEP_SPACE,
+  CR_LOOSE_SPACE,
+  CR_DELETE
+};
+
+class WERD_RES:public ELIST_LINK //word result
+{
+  public:
+    WERD * word;                 //non-bln real word
+    WERD *outword;               //bln best choice
+    //segmentation
+    DENORM denorm;               //for use on outword
+    WERD_CHOICE *best_choice;    //tess output
+    WERD_CHOICE *raw_choice;     //top choice permuter
+    WERD_CHOICE *ep_choice;      //ep text
+    REJMAP reject_map;           //best_choice rejects
+    BOOL8 tess_failed;
+    /*
+      If tess_failed is TRUE, one of the following tests failed when Tess
+      returned:
+      - The outword blob list was not the same length as the best_choice string;
+      - The best_choice string contained ALL blanks;
+      - The best_choice string was zero length
+    */
+    BOOL8 tess_accepted;         //Tess thinks its ok?
+    BOOL8 tess_would_adapt;      //Tess would adapt?
+    BOOL8 done;                  //ready for output?
+    inT8 italic;
+    inT8 bold;
+    inT8 font1;                  //primary font
+    inT8 font1_count;            //no of voters
+    inT8 font2;                  //secondary font
+    inT8 font2_count;            //no of voters
+    CRUNCH_MODE unlv_crunch_mode;
+    float x_height;              //Post match estimate
+    float caps_height;           //Post match estimate
+    BOOL8 guessed_x_ht;
+    BOOL8 guessed_caps_ht;
+    /*
+      To deal with fuzzy spaces we need to be able to combine "words" to form
+      combinations when we suspect that the gap is a non-space. The (new) text
+      ord code generates separate words for EVERY fuzzy gap - flags in the word
+      indicate whether the gap is below the threshold (fuzzy kern) and is thus
+      NOT a real word break by default, or above the threshold (fuzzy space) and
+      this is a real word break by default.
+
+      The WERD_RES list contains all these words PLUS "combination" words built
+      out of (copies of) the words split by fuzzy kerns. The separate parts have
+      their "part_of_combo" flag set true and should be IGNORED on a default
+      reading of the list.
+
+      Combination words are FOLLOWED by the sequence of part_of_combo words
+      which they combine.
+    */
+    BOOL8 combination;           //of two fuzzy gap wds
+    BOOL8 part_of_combo;         //part of a combo
+    BOOL8 reject_spaces;         //Reject spacing?
+
+    WERD_RES() {
+    }                            //empty constructor
+
+    WERD_RES(                   //simple constructor
+             WERD *the_word) {  //real word
+      word = the_word;
+      outword = NULL;
+      best_choice = NULL;
+      raw_choice = NULL;
+      ep_choice = NULL;
+      tess_failed = FALSE;
+      tess_accepted = FALSE;
+      tess_would_adapt = FALSE;
+      done = FALSE;
+      unlv_crunch_mode = CR_NONE;
+      italic = FALSE;
+      bold = FALSE;
+      font1 = -1;
+      font1_count = 0;
+      font2 = -1;
+      font2_count = 0;
+      x_height = 0.0;
+      caps_height = 0.0;
+      guessed_x_ht = TRUE;
+      guessed_caps_ht = TRUE;
+      combination = FALSE;
+      part_of_combo = FALSE;
+      reject_spaces = FALSE;
+    }
+    WERD_RES(const WERD_RES &source) {
+      *this = source;            //see operator=
+    }
+
+    ~WERD_RES ();                //destructor
+
+    WERD_RES& operator=(const WERD_RES& source);  //from this
+
+    static WERD_RES* deep_copy(const WERD_RES* src) {
+      return new WERD_RES(*src);
+    }
+
+    void copy_on(                       //copy blobs onto word
+                 WERD_RES *word_res) {  //from this word
+      word->set_flag (W_EOL, word_res->word->flag (W_EOL));
+      word->copy_on (word_res->word);
+    }
+};
+
+/*************************************************************************
+ * PAGE_RES_IT - Page results iterator
+ *************************************************************************/
+
+class PAGE_RES_IT
+{
+  public:
+    PAGE_RES * page_res;         //page being iterated
+
+    PAGE_RES_IT() {
+    }                            //empty contructor
+
+    PAGE_RES_IT(                           //empty contructor
+                PAGE_RES *the_page_res) {  //page result
+      page_res = the_page_res;
+      restart_page();  //ready to scan
+    }
+
+    WERD_RES *restart_page();  //get ready
+
+    WERD_RES *internal_forward(  //get next word
+                               BOOL8 new_block);
+
+    WERD_RES *forward() {  //get next word
+      return internal_forward (FALSE);
+    }
+
+    WERD_RES *forward_block();  //get first word in
+    //next non-empty block
+    WERD_RES *prev_word() {  //previous word
+      return prev_word_res;
+    }
+    ROW_RES *prev_row() {  //row of prev word
+      return prev_row_res;
+    }
+    BLOCK_RES *prev_block() {  //block of prev word
+      return prev_block_res;
+    }
+    WERD_RES *word() {  //current word
+      return word_res;
+    }
+    ROW_RES *row() {  //row of current word
+      return row_res;
+    }
+    BLOCK_RES *block() {  //block of cur. word
+      return block_res;
+    }
+    WERD_RES *next_word() {  //next word
+      return next_word_res;
+    }
+    ROW_RES *next_row() {  //row of next word
+      return next_row_res;
+    }
+    BLOCK_RES *next_block() {  //block of next word
+      return next_block_res;
+    }
+    void rej_stat_word();  //for page/block/row
+
+  private:
+    WERD_RES * prev_word_res;    //previous word
+    ROW_RES *prev_row_res;       //row of prev word
+    BLOCK_RES *prev_block_res;   //block of prev word
+
+    WERD_RES *word_res;          //current word
+    ROW_RES *row_res;            //row of current word
+    BLOCK_RES *block_res;        //block of cur. word
+
+    WERD_RES *next_word_res;     //next word
+    ROW_RES *next_row_res;       //row of next word
+    BLOCK_RES *next_block_res;   //block of next word
+
+    BLOCK_RES_IT block_res_it;   //iterators
+    ROW_RES_IT row_res_it;
+    WERD_RES_IT word_res_it;
+};
+#endif

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

@@ -0,0 +1,361 @@
+/**********************************************************************
+ * File:        pdblock.c  (Formerly pdblk.c)
+ * Description: PDBLK 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          "pdblock.h"
+#include          "svshowim.h"
+
+#include          "hpddef.h"     //must be last (handpd.dll)
+
+#define BLOCK_LABEL_HEIGHT  150  //char height of block id
+
+CLISTIZE (PDBLK)
+/**********************************************************************
+ * PDBLK::PDBLK
+ *
+ * Constructor for a simple rectangular block.
+ **********************************************************************/
+PDBLK::PDBLK (                   //rectangular block
+inT16 xmin,                      //bottom left
+inT16 ymin, inT16 xmax,          //top right
+inT16 ymax):    box (ICOORD (xmin, ymin), ICOORD (xmax, ymax)) {
+                                 //boundaries
+  ICOORDELT_IT left_it = &leftside;
+  ICOORDELT_IT right_it = &rightside;
+
+  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));
+}
+
+
+/**********************************************************************
+ * PDBLK::set_sides
+ *
+ * Sets left and right vertex lists
+ **********************************************************************/
+
+void PDBLK::set_sides(                       //set vertex lists
+                      ICOORDELT_LIST *left,  //left vertices
+                      ICOORDELT_LIST *right  //right vertices
+                     ) {
+                                 //boundaries
+  ICOORDELT_IT left_it = &leftside;
+  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);
+}
+
+
+/**********************************************************************
+ * PDBLK::contains
+ *
+ * Return TRUE if the given point is within the block.
+ **********************************************************************/
+
+BOOL8 PDBLK::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 ()) {
+                                 //get rectangle
+    it.bounding_box (bleft, tright);
+                                 //inside rect
+    if (pt.x () >= bleft.x () && pt.x () <= tright.x ()
+      && pt.y () >= bleft.y () && pt.y () <= tright.y ())
+      return TRUE;               //is inside
+  }
+  return FALSE;                  //not inside
+}
+
+
+/**********************************************************************
+ * PDBLK::move
+ *
+ * Reposition block
+ **********************************************************************/
+
+void PDBLK::move(                  // reposition block
+                 const ICOORD vec  // by vector
+                ) {
+  ICOORDELT_IT it(&leftside);
+
+  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);
+}
+
+
+/**********************************************************************
+ * PDBLK::plot
+ *
+ * Plot the outline of a block in the given colour.
+ **********************************************************************/
+
+#ifndef GRAPHICS_DISABLED
+void PDBLK::plot(                //draw outline
+                 ScrollView* window,  //window to draw in
+                 inT32 serial,   //serial number
+                 ScrollView::Color colour   //colour to draw in
+                ) {
+  ICOORD startpt;                //start of outline
+  ICOORD endpt;                  //end of outline
+  ICOORD prevpt;                 //previous point
+  ICOORDELT_IT it = &leftside;   //iterator
+
+                                 //set the colour
+  window->Pen(colour);
+  window->TextAttributes("Times", BLOCK_LABEL_HEIGHT, false, false, false);
+
+  if (hand_poly != NULL) {
+    hand_poly->plot(window, colour, serial);
+  } else if (!leftside.empty ()) {
+    startpt = *(it.data ());     //bottom left corner
+    //              tprintf("Block %d bottom left is (%d,%d)\n",
+    //                      serial,startpt.x(),startpt.y());
+    char temp_buff[34];
+    #ifdef __UNIX__
+    sprintf(temp_buff, INT32FORMAT, serial);
+    #else
+    ultoa (serial, temp_buff, 10);
+    #endif
+    window->Text(startpt.x (), startpt.y (), temp_buff);
+
+    window->SetCursor(startpt.x (), startpt.y ());
+    do {
+      prevpt = *(it.data ());    //previous point
+      it.forward ();             //move to next point
+                                 //draw round corner
+    window->DrawTo(prevpt.x (), it.data ()->y ());
+    window->DrawTo(it.data ()->x (), it.data ()->y ());
+    }
+    while (!it.at_last ());      //until end of list
+    endpt = *(it.data ());       //end point
+
+                                 //other side of boundary
+    window->SetCursor(startpt.x (), startpt.y ());
+    it.set_to_list (&rightside);
+    prevpt = startpt;
+    for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
+                                 //draw round corner
+    window->DrawTo(prevpt.x (), it.data ()->y ());
+    window->DrawTo(it.data ()->x (), it.data ()->y ());
+      prevpt = *(it.data ());    //previous point
+    }
+                                 //close boundary
+    window->DrawTo(endpt.x(), endpt.y());
+  }
+}
+#endif
+
+
+/**********************************************************************
+ * PDBLK::show
+ *
+ * Show the image corresponding to a block as its set of rectangles.
+ **********************************************************************/
+
+#ifndef GRAPHICS_DISABLED
+void PDBLK::show(               //show image block
+                 IMAGE *image,  //image to show
+                 ScrollView* 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 ()) {
+                                 //get rectangle
+    it.bounding_box (bleft, tright);
+    //              tprintf("Drawing a block with a bottom left of (%d,%d)\n",
+    //                      bleft.x(),bleft.y());
+                                 //show it
+    sv_show_sub_image (image, bleft.x (), bleft.y (), tright.x () - bleft.x (), tright.y () - bleft.y (), window, bleft.x (), bleft.y ());
+  }
+}
+#endif
+
+
+/**********************************************************************
+ * PDBLK::operator=
+ *
+ * Assignment - duplicate the block structure, but with an EMPTY row list.
+ **********************************************************************/
+
+PDBLK & PDBLK::operator= (       //assignment
+const PDBLK & source             //from this
+) {
+  //      this->ELIST_LINK::operator=(source);
+  if (!leftside.empty ())
+    leftside.clear ();
+  if (!rightside.empty ())
+    rightside.clear ();
+  leftside.deep_copy(&source.leftside, &ICOORDELT::deep_copy);
+  rightside.deep_copy(&source.rightside, &ICOORDELT::deep_copy);
+  box = source.box;
+  return *this;
+}
+
+
+/**********************************************************************
+ * BLOCK_RECT_IT::BLOCK_RECT_IT
+ *
+ * Construct a block rectangle iterator.
+ **********************************************************************/
+
+BLOCK_RECT_IT::BLOCK_RECT_IT (
+//iterate rectangles
+PDBLK * blkptr                   //from block
+):left_it (&blkptr->leftside), right_it (&blkptr->rightside) {
+  block = blkptr;                //remember block
+                                 //non empty list
+  if (!blkptr->leftside.empty ()) {
+    start_block();  //ready for iteration
+  }
+}
+
+
+/**********************************************************************
+ * BLOCK_RECT_IT::set_to_block
+ *
+ * Start a new block.
+ **********************************************************************/
+
+void BLOCK_RECT_IT::set_to_block(                  //start (new) block
+                                 PDBLK *blkptr) {  //block to start
+  block = blkptr;                //remember block
+                                 //set iterators
+  left_it.set_to_list (&blkptr->leftside);
+  right_it.set_to_list (&blkptr->rightside);
+  if (!blkptr->leftside.empty ())
+    start_block();  //ready for iteration
+}
+
+
+/**********************************************************************
+ * BLOCK_RECT_IT::start_block
+ *
+ * Restart a block.
+ **********************************************************************/
+
+void BLOCK_RECT_IT::start_block() {  //start (new) block
+  left_it.move_to_first ();
+  right_it.move_to_first ();
+  left_it.mark_cycle_pt ();
+  right_it.mark_cycle_pt ();
+  ymin = left_it.data ()->y ();  //bottom of first box
+  ymax = left_it.data_relative (1)->y ();
+  if (right_it.data_relative (1)->y () < ymax)
+                                 //smallest step
+    ymax = right_it.data_relative (1)->y ();
+}
+
+
+/**********************************************************************
+ * BLOCK_RECT_IT::forward
+ *
+ * Move to the next rectangle in the block.
+ **********************************************************************/
+
+void BLOCK_RECT_IT::forward() {  //next rectangle
+  if (!left_it.empty ()) {       //non-empty list
+    if (left_it.data_relative (1)->y () == ymax)
+      left_it.forward ();        //move to meet top
+    if (right_it.data_relative (1)->y () == ymax)
+      right_it.forward ();
+                                 //last is special
+    if (left_it.at_last () || right_it.at_last ()) {
+      left_it.move_to_first ();  //restart
+      right_it.move_to_first ();
+                                 //now at bottom
+      ymin = left_it.data ()->y ();
+    }
+    else {
+      ymin = ymax;               //new bottom
+    }
+                                 //next point
+    ymax = left_it.data_relative (1)->y ();
+    if (right_it.data_relative (1)->y () < ymax)
+                                 //least step forward
+      ymax = right_it.data_relative (1)->y ();
+  }
+}
+
+
+/**********************************************************************
+ * BLOCK_LINE_IT::get_line
+ *
+ * Get the the start and width of a line in the block.
+ **********************************************************************/
+
+inT16 BLOCK_LINE_IT::get_line(             //get a line
+                              inT16 y,     //line to get
+                              inT16 &xext  //output extent
+                             ) {
+  ICOORD bleft;                  //bounding box
+  ICOORD tright;                 //of block & rect
+
+                                 //get block box
+  block->bounding_box (bleft, tright);
+  if (y < bleft.y () || y >= tright.y ()) {
+    //              block->print(stderr,FALSE);
+    BADBLOCKLINE.error ("BLOCK_LINE_IT::get_line", ABORT, "Y=%d", y);
+  }
+
+                                 //get rectangle box
+  rect_it.bounding_box (bleft, tright);
+                                 //inside rectangle
+  if (y >= bleft.y () && y < tright.y ()) {
+                                 //width of line
+    xext = tright.x () - bleft.x ();
+    return bleft.x ();           //start of line
+  }
+  for (rect_it.start_block (); !rect_it.cycled_rects (); rect_it.forward ()) {
+                                 //get rectangle box
+    rect_it.bounding_box (bleft, tright);
+                                 //inside rectangle
+    if (y >= bleft.y () && y < tright.y ()) {
+                                 //width of line
+      xext = tright.x () - bleft.x ();
+      return bleft.x ();         //start of line
+    }
+  }
+  LOSTBLOCKLINE.error ("BLOCK_LINE_IT::get_line", ABORT, "Y=%d", y);
+  return 0;                      //dummy to stop warning
+}