tesseract_bin 1.0.0

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

@@ -0,0 +1,318 @@
+#ifndef           PAGEBLK_C
+#define           PAGEBLK_C
+
+#include "elst.h"
+#include "txtregn.h"
+#include "bits16.h"
+
+#include          "hpddef.h"     //must be last (handpd.dll)
+
+enum PB_TYPE
+{
+  PB_TEXT,
+  PB_RULES,
+  PB_GRAPHICS,
+  PB_IMAGE,
+  PB_SCRIBBLE,
+  PB_WEIRD
+};
+
+class DLLSYM PAGE_BLOCK;         //forward decl
+class DLLSYM TEXT_BLOCK;         //forward decl
+class DLLSYM GRAPHICS_BLOCK;     //forward decl
+class DLLSYM RULE_BLOCK;         //forward decl
+class DLLSYM IMAGE_BLOCK;        //forward decl
+class DLLSYM SCRIBBLE_BLOCK;     //forward decl
+class DLLSYM WEIRD_BLOCK;        //forward decl
+
+ELISTIZEH_S (PAGE_BLOCK)
+class DLLSYM PAGE_BLOCK:public ELIST_LINK, public POLY_BLOCK
+//page block
+{
+  public:
+    PAGE_BLOCK() {
+    }                            //empty constructor
+    PAGE_BLOCK(  //simple constructor
+               ICOORDELT_LIST *points,
+               PB_TYPE type,
+               PAGE_BLOCK_LIST *child);
+
+    PAGE_BLOCK(  //simple constructor
+               ICOORDELT_LIST *points,
+               PB_TYPE type);
+
+    ~PAGE_BLOCK () {             //destructor
+    }
+
+    void add_a_child(PAGE_BLOCK *newchild);
+
+    PB_TYPE type() {  //get type
+      return pb_type;
+    }
+
+    PAGE_BLOCK_LIST *child() {  //get children
+      return &children;
+    }
+
+    void rotate(  //rotate it
+                FCOORD rotation);
+    void move(                //move it
+              ICOORD shift);  //vector
+
+    void basic_plot(ScrollView* window, ScrollView::Color colour);
+
+    void plot(ScrollView* window, ScrollView::Color colour);
+
+    void show_attrs(DEBUG_WIN *debug);
+
+    NEWDELETE2 (PAGE_BLOCK) void pb_delete ();
+
+    void serialise(FILE *f);
+
+    static PAGE_BLOCK *de_serialise(FILE *f);
+
+    void prep_serialise() {  //set ptrs to counts
+      POLY_BLOCK::prep_serialise();
+      children.prep_serialise ();
+    }
+
+    void dump(  //write external bits
+              FILE *f) {
+      POLY_BLOCK::dump(f);
+      children.dump (f);
+    }
+
+    void de_dump(  //read external bits
+                 FILE *f) {
+      POLY_BLOCK::de_dump(f);
+      children.de_dump (f);
+    }
+
+    //note that due to the awful switched nature of the PAGE_BLOCK class,
+    //a PAGE_BLOCK_LIST cannot be de-serialised by the normal mechanism, since
+    //each element cannot be de-serialised in place.
+    //To fix this it is important to use read_poly_blocks or the code therein.
+    void serialise_asc(  //serialise to ascii
+                       FILE *f);
+    void internal_serialise_asc(  //serialise to ascii
+                                FILE *f);
+    void de_serialise_asc(  //serialise from ascii
+                          FILE *f);
+                                 //make one from ascii
+    static PAGE_BLOCK *new_de_serialise_asc(FILE *f);
+
+  private:
+    PB_TYPE pb_type;
+    PAGE_BLOCK_LIST children;
+};
+
+DLLSYM void show_all_in(PAGE_BLOCK *pblock,
+                        POLY_BLOCK *show_area,
+                        DEBUG_WIN *f);
+
+DLLSYM void delete_all_in(PAGE_BLOCK *pblock, POLY_BLOCK *delete_area);
+
+DLLSYM PAGE_BLOCK *smallest_containing(PAGE_BLOCK *pblock, POLY_BLOCK *other);
+
+class DLLSYM TEXT_BLOCK:public PAGE_BLOCK
+                                 //text block
+{
+  public:
+    TEXT_BLOCK() {
+    }                            //empty constructor
+    TEXT_BLOCK(ICOORDELT_LIST *points);
+
+    TEXT_BLOCK (ICOORDELT_LIST * points, BOOL8 backg[NUM_BACKGROUNDS]);
+
+                                 //get children
+    TEXT_REGION_LIST *regions() {
+      return &text_regions;
+    }
+
+    inT32 nregions() {
+      return text_regions.length ();
+    }
+
+    void add_a_region(TEXT_REGION *newchild);
+
+    void rotate(  //rotate it
+                FCOORD rotation);
+    void move(                //move it
+              ICOORD shift);  //vector
+
+    void plot(ScrollView* window,
+              ScrollView::Color colour,
+              ScrollView::Color region_colour,
+              ScrollView::Color subregion_colour);
+
+    void set_attrs (BOOL8 backg[NUM_BACKGROUNDS]);
+
+    void show_attrs(DEBUG_WIN *debug);
+
+    void prep_serialise() {  //set ptrs to counts
+      PAGE_BLOCK::prep_serialise();
+      text_regions.prep_serialise ();
+    }
+
+    void dump(  //write external bits
+              FILE *f) {
+      PAGE_BLOCK::dump(f);
+      text_regions.dump (f);
+    }
+
+    void de_dump(  //read external bits
+                 FILE *f) {
+      PAGE_BLOCK::de_dump(f);
+      text_regions.de_dump (f);
+    }
+
+                                 //serialise to ascii
+    make_serialise (TEXT_BLOCK) void serialise_asc (
+      FILE * f);
+    void de_serialise_asc(  //serialise from ascii
+                          FILE *f);
+
+  private:
+    BITS16 background;
+
+    TEXT_REGION_LIST text_regions;
+};
+
+DLLSYM void delete_all_tr_in(TEXT_BLOCK *tblock, POLY_BLOCK *delete_area);
+
+DLLSYM void show_all_tr_in(TEXT_BLOCK *tblock,
+                           POLY_BLOCK *show_area,
+                           DEBUG_WIN *f);
+
+class DLLSYM RULE_BLOCK:public PAGE_BLOCK
+                                 //rule block
+{
+  public:
+    RULE_BLOCK() {
+    }                            //empty constructor
+    RULE_BLOCK(ICOORDELT_LIST *points, inT8 sing, inT8 colo);
+
+    void set_attrs(inT8 sing, inT8 colo);
+
+    void show_attrs(DEBUG_WIN *debug);
+
+                                 //serialise to ascii
+    make_serialise (RULE_BLOCK) void serialise_asc (
+      FILE * f);
+    void de_serialise_asc(  //serialise from ascii
+                          FILE *f);
+
+  private:
+    inT8 multiplicity;
+    inT8 colour;
+
+};
+
+class DLLSYM GRAPHICS_BLOCK:public PAGE_BLOCK
+                                 //graphics block
+{
+  public:
+    GRAPHICS_BLOCK() {
+    }                            //empty constructor
+    GRAPHICS_BLOCK (ICOORDELT_LIST * points,
+      BOOL8 backg[NUM_BACKGROUNDS], inT8 foreg);
+
+    void set_attrs (BOOL8 backg[NUM_BACKGROUNDS], inT8 foreg);
+
+    void show_attrs(DEBUG_WIN *debug);
+
+                                 //serialise to ascii
+    make_serialise (GRAPHICS_BLOCK) void serialise_asc (
+      FILE * f);
+    void de_serialise_asc(  //serialise from ascii
+                          FILE *f);
+
+  private:
+    BITS16 background;
+    inT8 foreground;
+
+};
+
+class DLLSYM IMAGE_BLOCK:public PAGE_BLOCK
+                                 //image block
+{
+  public:
+    IMAGE_BLOCK() {
+    }                            //empty constructor
+    IMAGE_BLOCK(ICOORDELT_LIST *points, inT8 colo, inT8 qual);
+
+    void set_attrs(inT8 colo, inT8 qual);
+
+    void show_attrs(DEBUG_WIN *debug);
+
+                                 //serialise to ascii
+    make_serialise (IMAGE_BLOCK) void serialise_asc (
+      FILE * f);
+    void de_serialise_asc(  //serialise from ascii
+                          FILE *f);
+
+  private:
+    inT8 colour;
+    inT8 quality;
+
+};
+
+class DLLSYM SCRIBBLE_BLOCK:public PAGE_BLOCK
+                                 //scribble block
+{
+  public:
+    SCRIBBLE_BLOCK() {
+    }                            //empty constructor
+    SCRIBBLE_BLOCK (ICOORDELT_LIST * points,
+      BOOL8 backg[NUM_BACKGROUNDS], inT8 foreg);
+
+    void set_attrs (BOOL8 backg[NUM_BACKGROUNDS], inT8 foreg);
+
+    void show_attrs(DEBUG_WIN *debug);
+
+                                 //serialise to ascii
+    make_serialise (SCRIBBLE_BLOCK) void serialise_asc (
+      FILE * f);
+    void de_serialise_asc(  //serialise from ascii
+                          FILE *f);
+
+  private:
+    BITS16 background;
+    inT8 foreground;
+};
+
+class DLLSYM WEIRD_BLOCK:public PAGE_BLOCK
+                                 //weird block
+{
+  public:
+    WEIRD_BLOCK() {
+    }                            //empty constructor
+    WEIRD_BLOCK(ICOORDELT_LIST *points, inT32 id_no);
+
+    void set_id(inT32 id_no);
+
+    void show_attrs(DEBUG_WIN *debug);
+
+    void set_id_no(inT32 new_id) {
+      id_number = new_id;
+    }
+
+    void plot(ScrollView* window, ScrollView::Color colour);
+
+    inT32 id_no() {
+      return id_number;
+    }
+
+                                 //serialise to ascii
+    make_serialise (WEIRD_BLOCK) void serialise_asc (
+      FILE * f);
+    void de_serialise_asc(  //serialise from ascii
+                          FILE *f);
+
+  private:
+    inT32 id_number;             //unique id
+
+};
+
+void print_background(DEBUG_WIN *f, BITS16 background);
+#endif

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

@@ -0,0 +1,330 @@
+/**********************************************************************
+ * File:        pageres.cpp  (Formerly page_res.c)
+ * 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.
+ *
+ **********************************************************************/
+#include "mfcpch.h"
+#include          <stdlib.h>
+#ifdef __UNIX__
+#include          <assert.h>
+#endif
+#include          "pageres.h"
+#include          "notdll.h"
+
+ELISTIZE (BLOCK_RES)
+CLISTIZE (BLOCK_RES) ELISTIZE (ROW_RES) ELISTIZE (WERD_RES)
+/*************************************************************************
+ * PAGE_RES::PAGE_RES
+ *
+ * Constructor for page results
+ *************************************************************************/
+PAGE_RES::PAGE_RES(                            //recursive construct
+                   BLOCK_LIST *the_block_list  //real page
+                  ) {
+  BLOCK_IT block_it(the_block_list);
+  BLOCK_RES_IT block_res_it(&block_res_list);
+
+  char_count = 0;
+  rej_count = 0;
+  rejected = FALSE;
+
+  for (block_it.mark_cycle_pt ();
+  !block_it.cycled_list (); block_it.forward ()) {
+    block_res_it.add_to_end (new BLOCK_RES (block_it.data ()));
+  }
+}
+
+
+/*************************************************************************
+ * BLOCK_RES::BLOCK_RES
+ *
+ * Constructor for BLOCK results
+ *************************************************************************/
+
+BLOCK_RES::BLOCK_RES(                  //recursive construct
+                     BLOCK *the_block  //real BLOCK
+                    ) {
+  ROW_IT row_it (the_block->row_list ());
+  ROW_RES_IT row_res_it(&row_res_list);
+
+  char_count = 0;
+  rej_count = 0;
+  font_class = -1;               //not assigned
+  x_height = -1.0;
+  font_assigned = FALSE;
+  bold = FALSE;
+  italic = FALSE;
+  row_count = 0;
+
+  block = the_block;
+
+  for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
+    row_res_it.add_to_end (new ROW_RES (row_it.data ()));
+  }
+}
+
+
+/*************************************************************************
+ * ROW_RES::ROW_RES
+ *
+ * Constructor for ROW results
+ *************************************************************************/
+
+ROW_RES::ROW_RES(              //recursive construct
+                 ROW *the_row  //real ROW
+                ) {
+  WERD_IT word_it (the_row->word_list ());
+  WERD_RES_IT word_res_it(&word_res_list);
+  WERD_RES *combo = NULL;        //current combination of fuzzies
+  WERD_RES *word_res;            //current word
+  WERD *copy_word;
+
+  char_count = 0;
+  rej_count = 0;
+  whole_word_rej_count = 0;
+  font_class = -1;
+  font_class_score = -1.0;
+  bold = FALSE;
+  italic = FALSE;
+
+  row = the_row;
+
+  for (word_it.mark_cycle_pt (); !word_it.cycled_list (); word_it.forward ()) {
+    word_res = new WERD_RES (word_it.data ());
+    word_res->x_height = the_row->x_height();
+
+    if (word_res->word->flag (W_FUZZY_NON)) {
+      ASSERT_HOST (combo != NULL);
+      word_res->part_of_combo = TRUE;
+      combo->copy_on (word_res);
+    }
+    if (word_it.data_relative (1)->flag (W_FUZZY_NON)) {
+      if (combo == NULL) {
+        copy_word = new WERD;
+                                 //deep copy
+        *copy_word = *(word_it.data ());
+        combo = new WERD_RES (copy_word);
+        combo->x_height = the_row->x_height();
+        combo->combination = TRUE;
+        word_res_it.add_to_end (combo);
+      }
+      word_res->part_of_combo = TRUE;
+    }
+    else
+      combo = NULL;
+    word_res_it.add_to_end (word_res);
+  }
+}
+
+
+WERD_RES & WERD_RES::operator= ( //assign word_res
+const WERD_RES & source          //from this
+) {
+  this->ELIST_LINK::operator= (source);
+  if (source.combination) {
+    word = new WERD;
+    *word = *(source.word);      //deep copy
+  }
+  else
+    word = source.word;          //pt to same word
+
+  if (source.outword != NULL) {
+    outword = new WERD;
+    *outword = *(source.outword);//deep copy
+  }
+  else
+    outword = NULL;
+
+  denorm = source.denorm;
+  if (source.best_choice != NULL) {
+    best_choice = new WERD_CHOICE;
+    *best_choice = *(source.best_choice);
+    raw_choice = new WERD_CHOICE;
+    *raw_choice = *(source.raw_choice);
+  }
+  else {
+    best_choice = NULL;
+    raw_choice = NULL;
+  }
+  if (source.ep_choice != NULL) {
+    ep_choice = new WERD_CHOICE;
+    *ep_choice = *(source.ep_choice);
+  }
+  else
+    ep_choice = NULL;
+  reject_map = source.reject_map;
+  tess_failed = source.tess_failed;
+  tess_accepted = source.tess_accepted;
+  tess_would_adapt = source.tess_would_adapt;
+  done = source.done;
+  unlv_crunch_mode = source.unlv_crunch_mode;
+  italic = source.italic;
+  bold = source.bold;
+  font1 = source.font1;
+  font1_count = source.font1_count;
+  font2 = source.font2;
+  font2_count = source.font2_count;
+  x_height = source.x_height;
+  caps_height = source.caps_height;
+  guessed_x_ht = source.guessed_x_ht;
+  guessed_caps_ht = source.guessed_caps_ht;
+  combination = source.combination;
+  part_of_combo = source.part_of_combo;
+  reject_spaces = source.reject_spaces;
+  return *this;
+}
+
+
+WERD_RES::~WERD_RES () {
+  if (combination)
+    delete word;
+  if (outword != NULL)
+    delete outword;
+  if (best_choice != NULL) {
+    delete best_choice;
+    delete raw_choice;
+  }
+  if (ep_choice != NULL) {
+    delete ep_choice;
+  }
+}
+
+
+/*************************************************************************
+ * PAGE_RES_IT::restart_page
+ *
+ * Set things up at the start of the page
+ *************************************************************************/
+
+WERD_RES *PAGE_RES_IT::restart_page() {
+  block_res_it.set_to_list (&page_res->block_res_list);
+  block_res_it.mark_cycle_pt ();
+  prev_block_res = NULL;
+  prev_row_res = NULL;
+  prev_word_res = NULL;
+  block_res = NULL;
+  row_res = NULL;
+  word_res = NULL;
+  next_block_res = NULL;
+  next_row_res = NULL;
+  next_word_res = NULL;
+  internal_forward(TRUE);
+  return internal_forward (FALSE);
+}
+
+
+/*************************************************************************
+ * PAGE_RES_IT::internal_forward
+ *
+ * Find the next word on the page. Empty blocks and rows are skipped.
+ * The iterator maintains pointers to block, row and word for the previous,
+ * current and next words.  These are correct, regardless of block/row
+ * boundaries. NULL values denote start and end of the page.
+ *************************************************************************/
+
+WERD_RES *PAGE_RES_IT::internal_forward(BOOL8 new_block) {
+  BOOL8 found_next_word = FALSE;
+  BOOL8 new_row = FALSE;
+
+  prev_block_res = block_res;
+  prev_row_res = row_res;
+  prev_word_res = word_res;
+  block_res = next_block_res;
+  row_res = next_row_res;
+  word_res = next_word_res;
+
+  while (!found_next_word && !block_res_it.cycled_list ()) {
+    if (new_block) {
+      new_block = FALSE;
+      row_res_it.set_to_list (&block_res_it.data ()->row_res_list);
+      row_res_it.mark_cycle_pt ();
+      new_row = TRUE;
+    }
+    while (!found_next_word && !row_res_it.cycled_list ()) {
+      if (new_row) {
+        new_row = FALSE;
+        word_res_it.set_to_list (&row_res_it.data ()->word_res_list);
+        word_res_it.mark_cycle_pt ();
+      }
+      while (!found_next_word && !word_res_it.cycled_list ()) {
+        next_block_res = block_res_it.data ();
+        next_row_res = row_res_it.data ();
+        next_word_res = word_res_it.data ();
+        found_next_word = TRUE;
+        do {
+          word_res_it.forward ();
+        }
+        while (word_res_it.data ()->part_of_combo);
+      }
+      if (!found_next_word) {    //end of row reached
+        row_res_it.forward ();
+        new_row = TRUE;
+      }
+    }
+    if (!found_next_word) {      //end of block reached
+      block_res_it.forward ();
+      new_block = TRUE;
+    }
+  }
+  if (!found_next_word) {        //end of page reached
+    next_block_res = NULL;
+    next_row_res = NULL;
+    next_word_res = NULL;
+  }
+  return word_res;
+}
+
+
+/*************************************************************************
+ * PAGE_RES_IT::forward_block
+ *
+ * Move to the first word of the next block
+ * Can be followed by subsequent calls to forward() BUT at the first word in
+ * the block, the prev block, row and word are all NULL.
+ *************************************************************************/
+
+WERD_RES *PAGE_RES_IT::forward_block() {
+  if (block_res == next_block_res) {
+    block_res_it.forward ();;
+    block_res = NULL;
+    row_res = NULL;
+    word_res = NULL;
+    next_block_res = NULL;
+    next_row_res = NULL;
+    next_word_res = NULL;
+    internal_forward(TRUE);
+  }
+  return internal_forward (FALSE);
+}
+
+
+void PAGE_RES_IT::rej_stat_word() {
+  inT16 chars_in_word;
+  inT16 rejects_in_word = 0;
+
+  chars_in_word = word_res->reject_map.length ();
+  page_res->char_count += chars_in_word;
+  block_res->char_count += chars_in_word;
+  row_res->char_count += chars_in_word;
+
+  rejects_in_word = word_res->reject_map.reject_count ();
+
+  page_res->rej_count += rejects_in_word;
+  block_res->rej_count += rejects_in_word;
+  row_res->rej_count += rejects_in_word;
+  if (chars_in_word == rejects_in_word)
+    row_res->whole_word_rej_count += rejects_in_word;
+}