tesseract_bin 1.0.0

data/vendor/tesseract-2.04/ccmain/varabled.cpp

@@ -0,0 +1,346 @@
+///////////////////////////////////////////////////////////////////////
+// File:        varabled.cpp
+// Description: Variables Editor
+// Author:      Joern Wanke
+// Created:     Wed Jul 18 10:05:01 PDT 2007
+//
+// (C) Copyright 2007, Google Inc.
+// 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.
+//
+///////////////////////////////////////////////////////////////////////
+//
+// The variables editor is used to edit all the variables used within
+// tesseract from the ui.
+#ifndef GRAPHICS_DISABLED
+#include "varabled.h"
+
+#ifdef WIN32
+#else
+#include <stdlib.h>
+#include <stdio.h>
+#endif
+
+#include <map>
+
+#include "scrollview.h"
+#include "svmnode.h"
+
+#include "varable.h"
+#include "mainblk.h"
+
+#define VARDIR        "configs/" /*variables files */
+#define MAX_ITEMS_IN_SUBMENU 30
+
+const ERRCODE NO_VARIABLES_TO_EDIT = "No Variables defined to edit";
+
+// Contains the mappings from unique VC ids to their actual pointers.
+static std::map<int, VariableContent*> vcMap;
+
+static int nrVariables = 0;
+static int writeCommands[2];
+
+ELISTIZE(VariableContent)
+
+// Constructors for the various VarTypes.
+VariableContent::VariableContent(STRING_VARIABLE* it) {
+  my_id_ = nrVariables;
+  nrVariables++;
+  var_type_ = VT_STRING;
+  sIt = it;
+  vcMap[my_id_] = this;
+}
+// Constructors for the various VarTypes.
+VariableContent::VariableContent(INT_VARIABLE* it) {
+  my_id_ = nrVariables;
+  nrVariables++;
+  var_type_ = VT_INTEGER;
+  iIt = it;
+  vcMap[my_id_] = this;
+}
+// Constructors for the various VarTypes.
+VariableContent::VariableContent(BOOL_VARIABLE* it) {
+  my_id_ = nrVariables;
+  nrVariables++;
+  var_type_ = VT_BOOLEAN;
+  bIt = it;
+  vcMap[my_id_] = this;
+}
+// Constructors for the various VarTypes.
+VariableContent::VariableContent(double_VARIABLE* it) {
+  my_id_ = nrVariables;
+  nrVariables++;
+  var_type_ = VT_DOUBLE;
+  dIt = it;
+  vcMap[my_id_] = this;
+}
+
+// Gets a VC object identified by its ID.
+VariableContent* VariableContent::GetVariableContentById(int id) {
+  return vcMap[id];
+}
+
+// Copy the first N words from the source string to the target string.
+// Words are delimited by "_".
+void VariablesEditor::GetFirstWords(
+                     const char *s,  // source string
+                     int n,          // number of words
+                     char *t         // target string
+                    ) {
+  int full_length = strlen(s);
+  int reqd_len = 0;              // No. of chars requird
+  const char *next_word = s;
+
+  while ((n > 0) && reqd_len < full_length) {
+    reqd_len += strcspn(next_word, "_") + 1;
+    next_word += reqd_len;
+    n--;
+  }
+  strncpy(t, s, reqd_len);
+  t[reqd_len] = '\0';            // ensure null terminal
+}
+
+// Getter for the name.
+const char* VariableContent::GetName() const {
+  if (var_type_ == VT_INTEGER) { return iIt->name_str(); }
+  else if (var_type_ == VT_BOOLEAN) { return bIt->name_str(); }
+  else if (var_type_ == VT_DOUBLE) { return dIt->name_str(); }
+  else if (var_type_ == VT_STRING) { return sIt->name_str(); }
+  else
+    return "ERROR: VariableContent::GetName()";
+}
+
+// Getter for the description.
+const char* VariableContent::GetDescription() const {
+  if (var_type_ == VT_INTEGER) { return iIt->info_str(); }
+  else if (var_type_ == VT_BOOLEAN) { return bIt->info_str(); }
+  else if (var_type_ == VT_DOUBLE) { return dIt->info_str(); }
+  else if (var_type_ == VT_STRING) { return sIt->info_str(); }
+  else return NULL;
+}
+
+// Getter for the value.
+const char* VariableContent::GetValue() const {
+char* msg = new char[1024];
+  if (var_type_ == VT_INTEGER) {
+    sprintf(msg, "%d", ((inT32) *(iIt)));
+  } else if (var_type_ == VT_BOOLEAN) {
+    sprintf(msg, "%d", ((BOOL8) * (bIt)));
+  } else if (var_type_ == VT_DOUBLE) {
+    sprintf(msg, "%g", ((double) * (dIt)));
+  } else if (var_type_ == VT_STRING) {
+    if (((STRING) * (sIt)).string() != NULL) {
+      sprintf(msg, "%s", ((STRING) * (sIt)).string());
+    } else {
+      return "Null";
+    }
+  }
+  return msg;
+}
+
+// Setter for the value.
+void VariableContent::SetValue(const char* val) {
+// TODO (wanke) Test if the values actually are properly converted.
+// (Quickly visible impacts?)
+  changed_ = TRUE;
+  if (var_type_ == VT_INTEGER) {
+    iIt->set_value(atoi(val));
+  } else if (var_type_ == VT_BOOLEAN) {
+    bIt->set_value(atoi(val));
+  } else if (var_type_ == VT_DOUBLE) {
+    dIt->set_value(strtod(val, NULL));
+  } else if (var_type_ == VT_STRING) {
+    sIt->set_value(val);
+  }
+}
+
+// Gets the up to the first 3 prefixes from s (split by _).
+// For example, tesseract_foo_bar will be split into tesseract,foo and bar.
+void VariablesEditor::GetPrefixes(const char* s, STRING* level_one,
+                                                 STRING* level_two,
+                                                 STRING* level_three) {
+  char* p = new char[1024];
+  GetFirstWords(s, 1, p);
+  *level_one = p;
+  GetFirstWords(s, 2, p);
+  *level_two = p;
+  GetFirstWords(s, 3, p);
+  *level_three = p;
+  delete[] p;
+}
+
+// Compare two VC objects by their name.
+int VariableContent::Compare(const void* v1, const void* v2) {
+  const VariableContent* one = *reinterpret_cast<const VariableContent* const *>(v1);
+  const VariableContent* two = *reinterpret_cast<const VariableContent* const *>(v2);
+  return strcmp(one->GetName(), two->GetName());
+}
+
+// Find all editable variables used within tesseract and create a
+// SVMenuNode tree from it.
+// TODO (wanke): This is actually sort of hackish.
+SVMenuNode* VariablesEditor::BuildListOfAllLeaves() {  // find all variables.
+  SVMenuNode* mr = new SVMenuNode();
+  VariableContent_LIST vclist;
+  VariableContent_IT vc_it(&vclist);
+  std::map<const char*, int> amount;  //to count the # of entries for a specifc char*.
+
+  INT_VARIABLE_C_IT int_it(INT_VARIABLE::get_head());
+  BOOL_VARIABLE_C_IT bool_it(BOOL_VARIABLE::get_head());
+  STRING_VARIABLE_C_IT str_it(STRING_VARIABLE::get_head());
+  double_VARIABLE_C_IT dbl_it(double_VARIABLE::get_head());
+
+  // Add all variables to a list.
+  for (int_it.mark_cycle_pt(); !int_it.cycled_list(); int_it.forward()) {
+    vc_it.add_after_then_move(new VariableContent(int_it.data()));
+  }
+
+  for (bool_it.mark_cycle_pt(); !bool_it.cycled_list(); bool_it.forward()) {
+    vc_it.add_after_then_move(new VariableContent(bool_it.data()));
+  }
+
+  for (str_it.mark_cycle_pt(); !str_it.cycled_list(); str_it.forward()) {
+    vc_it.add_after_then_move(new VariableContent(str_it.data()));
+  }
+
+  for (dbl_it.mark_cycle_pt(); !dbl_it.cycled_list(); dbl_it.forward()) {
+    vc_it.add_after_then_move(new VariableContent(dbl_it.data()));
+  }
+
+  // Count the # of entries starting with a specific prefix.
+  for (vc_it.mark_cycle_pt(); !vc_it.cycled_list(); vc_it.forward()) {
+    VariableContent* vc = vc_it.data();
+    STRING tag;
+    STRING tag2;
+    STRING tag3;
+
+    GetPrefixes(vc->GetName(), &tag, &tag2, &tag3);
+    amount[tag.string()]++;
+    amount[tag2.string()]++;
+    amount[tag3.string()]++;
+  }
+
+  vclist.sort(VariableContent::Compare);  // Sort the list alphabetically.
+
+  SVMenuNode* other = mr->AddChild("OTHER");
+
+  // go through the list again and this time create the menu structure.
+  vc_it.move_to_first();
+  for (vc_it.mark_cycle_pt(); !vc_it.cycled_list(); vc_it.forward()) {
+    VariableContent* vc = vc_it.data();
+    STRING tag;
+    STRING tag2;
+    STRING tag3;
+    GetPrefixes(vc->GetName(), &tag, &tag2, &tag3);
+
+    if (amount[tag.string()] == 1) { other->AddChild(vc->GetName(), vc->GetId(),
+                                            vc->GetValue(),
+                                            vc->GetDescription());
+    } else {  // More than one would use this submenu -> create submenu.
+      SVMenuNode* sv = mr->AddChild(tag.string());
+      if ((amount[tag.string()] <= MAX_ITEMS_IN_SUBMENU) || (amount[tag2.string()] <= 1)) {
+        sv->AddChild(vc->GetName(), vc->GetId(),
+                     vc->GetValue(), vc->GetDescription());
+      } else {  // Make subsubmenus.
+        SVMenuNode* sv2 = sv->AddChild(tag2.string());
+        sv2->AddChild(vc->GetName(), vc->GetId(),
+                      vc->GetValue(), vc->GetDescription());
+      }
+    }
+  }
+  return mr;
+}
+
+// Event listener. Waits for SVET_POPUP events and processes them.
+void VariablesEditor::Notify(const SVEvent* sve) {
+  if (sve->type == SVET_POPUP) {  // only catch SVET_POPUP!
+    char* param = sve->parameter;
+    if (sve->command_id == writeCommands[0]) {
+      WriteVars(param, false);
+    } else if (sve->command_id == writeCommands[1]) {
+      WriteVars(param, true);
+    } else {
+      VariableContent* vc = VariableContent::GetVariableContentById(
+          sve->command_id);
+      vc->SetValue(param);
+      sv_window_->AddMessage("Setting %s to %s",
+                             vc->GetName(), vc->GetValue());
+    }
+  }
+}
+
+// Integrate the variables editor as popupmenu into the existing scrollview
+// window (usually the pg editor). If sv == null, create a new empty
+// empty window and attach the variables editor to that window (ugly).
+VariablesEditor::VariablesEditor(ScrollView* sv) {
+  if (sv == NULL) {
+    const char* name = "VarEditorMAIN";
+    sv = new ScrollView(name, 1, 1, 200, 200, 300, 200);
+  }
+
+  sv_window_ = sv;
+
+  //Only one event handler per window.
+  //sv->AddEventHandler((SVEventHandler*) this);
+
+  SVMenuNode* svMenuRoot = BuildListOfAllLeaves();
+
+  STRING varfile;
+  varfile = datadir;
+  varfile += VARDIR;             // variables dir
+  varfile += "edited";           // actual name
+
+  SVMenuNode* std_menu = svMenuRoot->AddChild ("Build Config File");
+
+  writeCommands[0] = nrVariables+1;
+  std_menu->AddChild("All Variables", writeCommands[0],
+                     varfile.string(), "Config file name?");
+
+  writeCommands[1] = nrVariables+2;
+  std_menu->AddChild ("changed_ Variables Only", writeCommands[1],
+                      varfile.string(), "Config file name?");
+
+  svMenuRoot->BuildMenu(sv, false);
+}
+
+
+// Write all (changed_) variables to a config file.
+void VariablesEditor::WriteVars(char *filename,    // in this file
+                                bool changes_only  // changed_ vars only?
+                               ) {
+  FILE *fp;                      // input file
+  char msg_str[255];
+                                 // if file exists
+  if ((fp = fopen (filename, "r")) != NULL) {
+    fclose(fp);
+    sprintf (msg_str, "Overwrite file " "%s" "? (Y/N)", filename);
+    int a = sv_window_->ShowYesNoDialog(msg_str);
+    if (a == 'n') { return; }  // dont write
+  }
+
+
+  fp = fopen (filename, "w");  // can we write to it?
+  if (fp == NULL) {
+    sv_window_->AddMessage("Cant write to file " "%s" "", filename);
+    return;
+  }
+
+  for (std::map<int, VariableContent*>::iterator iter = vcMap.begin();
+                                          iter != vcMap.end();
+                                          ++iter) {
+    VariableContent* cur = iter->second;
+    if (!changes_only || cur->HasChanged()) {
+      fprintf (fp, "%-25s   %-12s   # %s\n",
+               cur->GetName(), cur->GetValue(), cur->GetDescription());
+    }
+  }
+  fclose(fp);
+}
+#endif

data/vendor/tesseract-2.04/ccmain/varabled.h

@@ -0,0 +1,125 @@
+///////////////////////////////////////////////////////////////////////
+// File:        varabled.cpp
+// Description: Variables Editor
+// Author:      Joern Wanke
+// Created:     Wed Jul 18 10:05:01 PDT 2007
+//
+// (C) Copyright 2007, Google Inc.
+// 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.
+//
+///////////////////////////////////////////////////////////////////////
+//
+// The variables editor is used to edit all the variables used within
+// tesseract from the ui.
+#ifndef GRAPHICS_DISABLED
+#ifndef VARABLED_H
+#define VARABLED_H
+
+#include "elst.h"
+#include "scrollview.h"
+#include "varable.h"
+
+class SVMenuNode;
+
+// A list of all possible variable types used.
+enum VarType {
+  VT_INTEGER,
+  VT_BOOLEAN,
+  VT_STRING,
+  VT_DOUBLE
+};
+
+// A rather hackish helper structure which can take any kind of variable input
+// (defined by VarType) and do a couple of common operations on them, like
+// comparisond or getting its value. It is used in the context of the
+// VariablesEditor as a bridge from the internal tesseract variables to the
+// ones displayed by the ScrollView server.
+class VariableContent : public ELIST_LINK {
+  public:
+    // Compare two VC objects by their name.
+    static int Compare(const void* v1, const void* v2);
+
+    // Gets a VC object identified by its ID.
+    static VariableContent* GetVariableContentById(int id);
+
+    // Constructors for the various VarTypes.
+    VariableContent() {
+    }
+    VariableContent(STRING_VARIABLE* it);
+    VariableContent(INT_VARIABLE* it);
+    VariableContent(BOOL_VARIABLE* it);
+    VariableContent(double_VARIABLE* it);
+
+
+    // Getters and Setters.
+    void SetValue(const char* val);
+    const char* GetValue() const;
+    const char* GetName() const;
+    const char* GetDescription() const;
+
+    int GetId() { return my_id_; }
+    bool HasChanged() { return changed_; }
+
+  private:
+    // The unique ID of this VC object.
+    int my_id_;
+    // Whether the variable was changed_ and thus needs to be rewritten.
+    bool changed_;
+    // The actual vartype of this VC object.
+    VarType var_type_;
+
+    STRING_VARIABLE* sIt;
+    INT_VARIABLE* iIt;
+    BOOL_VARIABLE* bIt;
+    double_VARIABLE* dIt;
+};
+
+ELISTIZEH(VariableContent)
+
+// The variables editor enables the user to edit all the variables used within
+// tesseract. It can be invoked on its own, but is supposed to be invoked by
+// the program editor.
+class VariablesEditor : public SVEventHandler {
+  public:
+    // Integrate the variables editor as popupmenu into the existing scrollview
+    // window (usually the pg editor). If sv == null, create a new empty
+    // empty window and attach the variables editor to that window (ugly).
+    VariablesEditor(ScrollView* sv = NULL);
+
+    // Event listener. Waits for SVET_POPUP events and processes them.
+    void Notify(const SVEvent* sve);
+
+  private:
+    // Gets the up to the first 3 prefixes from s (split by _).
+    // For example, tesseract_foo_bar will be split into tesseract,foo and bar.
+      void GetPrefixes(const char* s, STRING* level_one,
+                     STRING* level_two, STRING* level_three);
+
+    // Gets the first n words (split by _) and puts them in t.
+    // For example, tesseract_foo_bar with N=2 will yield tesseract_foo_.
+    void GetFirstWords(                //copy first N words
+                     const char *s,  //source string
+                     int n,          //number of words
+                     char *t         //target string
+                    );
+
+    // Find all editable variables used within tesseract and create a
+    // SVMenuNode tree from it.
+    SVMenuNode *BuildListOfAllLeaves();
+
+    // Write all (changed_) variables to a config file.
+    void WriteVars(char* filename, bool changes_only);
+
+    ScrollView* sv_window_;
+};
+
+#endif
+#endif

data/vendor/tesseract-2.04/ccmain/werdit.cpp

@@ -0,0 +1,193 @@
+/**********************************************************************
+ * File:        werdit.cpp  (Formerly wordit.c)
+ * Description: An iterator for passing over all the words in a document.
+ * Author:		Ray Smith
+ * Created:		Mon Apr 27 08:51:22 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          "werdit.h"
+
+#define EXTERN
+
+//EXTERN BOOL_VAR(wordit_linearc,FALSE,"Pass poly of linearc to Tess");
+
+/**********************************************************************
+ * WERDIT::start_page
+ *
+ * Get ready to iterate over the page by setting the iterators.
+ **********************************************************************/
+
+void WERDIT::start_page(                        //set iterators
+                        BLOCK_LIST *block_list  //blocks to check
+                       ) {
+  block_it.set_to_list (block_list);
+  block_it.mark_cycle_pt ();
+  do {
+    while (block_it.data ()->row_list ()->empty ()
+    && !block_it.cycled_list ()) {
+      block_it.forward ();
+    }
+    if (!block_it.data ()->row_list ()->empty ()) {
+      row_it.set_to_list (block_it.data ()->row_list ());
+      row_it.mark_cycle_pt ();
+      while (row_it.data ()->word_list ()->empty ()
+      && !row_it.cycled_list ()) {
+        row_it.forward ();
+      }
+      if (!row_it.data ()->word_list ()->empty ()) {
+        word_it.set_to_list (row_it.data ()->word_list ());
+        word_it.mark_cycle_pt ();
+      }
+    }
+  }
+  while (!block_it.cycled_list () && row_it.data ()->word_list ()->empty ());
+}
+
+
+/**********************************************************************
+ * WERDIT::forward
+ *
+ * Give the next word on the page, or NULL if none left.
+ * This code assumes all rows to be non-empty, but blocks are allowed
+ * to be empty as eventually we will have non-text blocks.
+ * The output is always a copy and needs to be deleted by somebody.
+ **********************************************************************/
+
+WERD *WERDIT::forward() {  //use iterators
+  WERD *word;                    //actual word
+  //      WERD                                                    *larc_word;                                                     //linearc copy
+  WERD *result;                  //output word
+  ROW *row;                      //row of word
+
+  if (word_it.cycled_list ()) {
+    return NULL;                 //finished page
+  }
+  else {
+    word = word_it.data ();
+    row = row_it.data ();
+    word_it.forward ();
+    if (word_it.cycled_list ()) {
+      row_it.forward ();         //finished row
+      if (row_it.cycled_list ()) {
+        do {
+          block_it.forward ();   //finished block
+          if (!block_it.cycled_list ()) {
+            row_it.set_to_list (block_it.data ()->row_list ());
+            row_it.mark_cycle_pt ();
+          }
+        }
+                                 //find non-empty block
+        while (!block_it.cycled_list ()
+          && row_it.cycled_list ());
+      }
+      if (!row_it.cycled_list ()) {
+        word_it.set_to_list (row_it.data ()->word_list ());
+        word_it.mark_cycle_pt ();
+      }
+    }
+
+    //              if (wordit_linearc && !word->flag(W_POLYGON))
+    //              {
+    //                      larc_word=word->larc_copy(row->x_height());
+    //                      result=larc_word->poly_copy(row->x_height());
+    //                      delete larc_word;
+    //              }
+    //              else
+    result = word->poly_copy (row->x_height ());
+    return result;
+  }
+}
+
+
+/**********************************************************************
+ * make_pseudo_word
+ *
+ * Make all the blobs inside a selection into a single word.
+ * The word is always a copy and needs to be deleted.
+ **********************************************************************/
+
+WERD *make_pseudo_word(                         //make fake word
+                       BLOCK_LIST *block_list,  //blocks to check //block of selection
+                       TBOX &selection_box,
+                       BLOCK *&pseudo_block,
+                       ROW *&pseudo_row         //row of selection
+                      ) {
+  BLOCK_IT block_it(block_list);
+  BLOCK *block;
+  ROW_IT row_it;
+  ROW *row;
+  WERD_IT word_it;
+  WERD *word;
+  PBLOB_IT blob_it;
+  PBLOB *blob;
+  PBLOB_LIST new_blobs;          //list of gathered blobs
+                                 //iterator
+  PBLOB_IT new_blob_it = &new_blobs;
+  WERD *pseudo_word;             //fabricated word
+  WERD *poly_word;               //poly copy of word
+  //      WERD                                                    *larc_word;                                                     //linearc copy
+
+  for (block_it.mark_cycle_pt ();
+  !block_it.cycled_list (); block_it.forward ()) {
+    block = block_it.data ();
+    if (block->bounding_box ().overlap (selection_box)) {
+      pseudo_block = block;
+      row_it.set_to_list (block->row_list ());
+      for (row_it.mark_cycle_pt ();
+      !row_it.cycled_list (); row_it.forward ()) {
+        row = row_it.data ();
+        if (row->bounding_box ().overlap (selection_box)) {
+          word_it.set_to_list (row->word_list ());
+          for (word_it.mark_cycle_pt ();
+          !word_it.cycled_list (); word_it.forward ()) {
+            word = word_it.data ();
+            if (word->bounding_box ().overlap (selection_box)) {
+              //                                                      if (wordit_linearc && !word->flag(W_POLYGON))
+              //                                                      {
+              //                                                              larc_word=word->larc_copy(row->x_height());
+              //                                                              poly_word=larc_word->poly_copy(row->x_height());
+              //                                                              delete larc_word;
+              //                                                      }
+              //                                                      else
+              poly_word = word->poly_copy (row->x_height ());
+              blob_it.set_to_list (poly_word->blob_list ());
+              for (blob_it.mark_cycle_pt ();
+              !blob_it.cycled_list (); blob_it.forward ()) {
+                blob = blob_it.data ();
+                if (blob->bounding_box ().
+                overlap (selection_box)) {
+                  new_blob_it.add_after_then_move (blob_it.
+                    extract
+                    ());
+                                 //steal off list
+                  pseudo_row = row;
+                }
+              }
+              delete poly_word;  //get rid of it
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!new_blobs.empty ()) {
+                                 //make new word
+    pseudo_word = new WERD (&new_blobs, 1, NULL);
+  }
+  else
+    pseudo_word = NULL;
+  return pseudo_word;
+}