tesseract_bin 1.0.0

data/vendor/tesseract-2.04/viewer/svpaint.cpp

@@ -0,0 +1,220 @@
+// Copyright 2007 Google Inc. All Rights Reserved.
+//
+// Author: Joern Wanke
+//
+// Simple drawing program to illustrate ScrollView capabilities.
+//
+// Functionality:
+// - The menubar is used to select from different sample styles of input.
+// - With the RMB it is possible to change the RGB values in different
+//   popup menus.
+// - A LMB click either draws point-to-point, point or text.
+// - A LMB dragging either draws a line, a rectangle or ellipse.
+
+
+#include "scrollview.h"
+#include "svmnode.h"
+#include <stdlib.h>
+#include <iostream>
+
+// The current color values we use, initially white (== ScrollView::WHITE).
+int rgb[3] = { 255, 255, 255 };
+
+class SVPaint : public SVEventHandler {
+ public:
+   SVPaint(const char* server_name);
+// This is the main event handling function that we need to overwrite, defined
+// in SVEventHandler.
+   void Notify(const SVEvent* sv_event);
+ private:
+// The Handler take care of the SVET_POPUP, SVET_MENU, SVET_CLICK and
+// SVET_SELECTION events.
+   void PopupHandler(const SVEvent* sv_event);
+   void MenuBarHandler(const SVEvent* sv_event);
+   void ClickHandler(const SVEvent* sv_event);
+   void SelectionHandler(const SVEvent* sv_event);
+
+// Convenience functions to build little menus.
+   SVMenuNode* BuildPopupMenu();
+   SVMenuNode* BuildMenuBar();
+
+// Our window.
+   ScrollView* window_;
+
+// The mode we are in when an SVET_CLICK or an SVET_SELECTION event occurs.
+   int click_mode_;
+   int drag_mode_;
+
+// In the point-to-point drawing mode, we need to set a start-point the first
+// time we call it (e.g. call SetCursor).
+   bool has_start_point_;
+};
+
+// Build a sample popup menu.
+SVMenuNode* SVPaint::BuildPopupMenu() {
+  SVMenuNode* root = new SVMenuNode();  // Empty root node
+  // Initial color is white, so we  all values to 255.
+  root->AddChild("R",                   // Shown caption.
+                  1,                    // assoc. command_id.
+                 "255",                 // initial value.
+                 "Red Color Value?");  // Shown description.
+  root->AddChild("G", 2, "255", "Green Color Value?");
+  root->AddChild("B", 3, "255", "Blue Color Value?");
+  return root;
+}
+
+// Build a sample menu bar.
+SVMenuNode* SVPaint::BuildMenuBar() {
+  SVMenuNode* root = new SVMenuNode();  // Empty root node
+
+  // Create some submenus and add them to the root.
+  SVMenuNode* click = root->AddChild("Clicking");
+  SVMenuNode* drag = root->AddChild("Dragging");
+  
+  // Put some nodes into the submenus.
+  click->AddChild("Point to Point Drawing",  // Caption.
+                  1);                       // command_id.
+  click->AddChild("Point Drawing", 2);
+  click->AddChild("Text Drawing", 3);
+  drag->AddChild("Line Drawing", 4);
+  drag->AddChild("Rectangle Drawing", 5);
+  drag->AddChild("Ellipse Drawing", 6);
+  return root;
+}
+
+// Takes care of the SVET_POPUP events.
+// In our case, SVET_POPUP is used to set RGB values.
+void SVPaint::PopupHandler(const SVEvent* sv_event) {
+  // Since we only have the RGB values as popup items,
+  // we take a shortcut to not bloat up code:
+  rgb[sv_event->command_id - 1] = atoi(sv_event->parameter);
+  window_->Pen(rgb[0], rgb[1], rgb[2]);
+}
+
+// Takes care of the SVET_MENU events.
+// In our case, we change either the click_mode_ (commands 1-3)
+// or the drag_mode_ (commands 4-6).
+void SVPaint::MenuBarHandler(const SVEvent* sv_event) {
+  if ((sv_event->command_id > 0) && (sv_event->command_id < 4)) { 
+  click_mode_ = sv_event->command_id;	
+  has_start_point_ = false;
+  } else { drag_mode_ = sv_event->command_id; }
+}
+
+// Takes care of the SVET_CLICK events.
+// Depending on the click_mode_ we are in, either do Point-to-Point drawing,
+// point drawing, or draw text.
+void SVPaint::ClickHandler(const SVEvent* sv_event) {
+  switch (click_mode_) {
+  case 1: //Point to Point
+    if (has_start_point_) { window_->DrawTo(sv_event->x, sv_event->y);
+    } else {
+        has_start_point_ = true; 
+        window_->SetCursor(sv_event->x, sv_event->y);
+    }
+    break;
+  case 2: //Point Drawing..simulated by drawing a 1 pixel line.
+    window_->Line(sv_event->x, sv_event->y, sv_event->x, sv_event->y);
+    break;
+  case 3: //Text
+    // We show a modal input dialog on our window, then draw the input and
+    // finally delete the input pointer.
+    char* p = window_->ShowInputDialog("Text:");
+    window_->Text(sv_event->x, sv_event->y, p);
+    delete p;
+    break;
+  }
+}
+
+// Takes care of the SVET_SELECTION events.
+// Depending on the drag_mode_ we are in, either draw a line, a rectangle or
+// an ellipse.
+void SVPaint::SelectionHandler(const SVEvent* sv_event) {
+  switch (drag_mode_) {
+  //FIXME inversed x_size, y_size
+    case 4: //Line
+      window_->Line(sv_event->x, sv_event->y, 
+                    sv_event->x - sv_event->x_size,
+                    sv_event->y - sv_event->y_size);
+      break;
+    case 5: //Rectangle
+      window_->Rectangle(sv_event->x, sv_event->y,
+                         sv_event->x - sv_event->x_size,
+                         sv_event->y - sv_event->y_size);
+      break;
+    case 6: //Ellipse
+      window_->Ellipse(sv_event->x - sv_event->x_size,
+                       sv_event->y - sv_event->y_size,
+                       sv_event->x_size, sv_event->y_size);
+      break;
+    }
+}
+
+// The event handling function from ScrollView which we have to overwrite.
+// We handle CLICK, SELECTION, MENU and POPUP and throw away all other events.
+void SVPaint::Notify(const SVEvent* sv_event) {
+  if (sv_event->type == SVET_CLICK) { ClickHandler(sv_event); }  
+  else if (sv_event->type == SVET_SELECTION) { SelectionHandler(sv_event); }
+  else if (sv_event->type == SVET_MENU) { MenuBarHandler(sv_event); }
+  else if (sv_event->type == SVET_POPUP) { PopupHandler(sv_event); }
+  else {} //throw other events away
+}
+
+// Builds a new window, initializes the variables and event handler and builds
+// the menu.
+SVPaint::SVPaint(const char *server_name) {
+  window_ = new ScrollView("ScrollView Paint Example",  // window caption
+                            0, 0,                       // x,y window position
+                            500, 500,                   // window size
+  		                    500, 500,                   // canvas size
+                            false,      // whether the Y axis is inversed.
+                                        // this is included due to legacy 
+                                        // reasons for tesseract and enables
+                                        // us to have (0,0) as the LOWER left
+                                        // of the coordinate system.
+                            server_name);               // the server address.
+
+  // Set the start modes to point-to-point and line drawing.
+  click_mode_ = 1;
+  drag_mode_ = 4;
+  has_start_point_ = false;
+
+  // Bild our menus and add them to the window. The flag illustrates whether
+  // this is a menu bar.
+  SVMenuNode* popup_menu = BuildPopupMenu();
+  popup_menu->BuildMenu(window_,false);
+	
+  SVMenuNode* bar_menu = BuildMenuBar();
+  bar_menu->BuildMenu(window_,true);
+
+  // Set the initial color values to White (could also be done by
+  // passing (rgb[0], rgb[1], rgb[2]).
+  window_->Pen(ScrollView::WHITE);
+  window_->Brush(ScrollView::WHITE);
+
+  // Adds the event handler to the window. This actually ensures that Notify
+  // gets called when events occur.
+  window_->AddEventHandler(this);
+
+  // Set the window visible (calling this is important to actually render
+  // everything. Without this call, the window would also be drawn, but the
+  // menu bars would be missing.
+  window_->SetVisible(true);
+
+  // Rest this thread until its window is destroyed.
+  // Note that a special eventhandling thread was created when constructing
+  // the window. Due to this, the application will not deadlock here.
+  window_->AwaitEvent(SVET_DESTROY);
+  // We now have 3 Threads running:
+  // (1) The MessageReceiver thread which fetches messages and distributes them
+  // (2) The EventHandler thread which handles all events for window_
+  // (3) The main thread which waits on window_ for a DESTROY event (blocked)
+}
+
+// If a parameter is given, we try to connect to the given server.
+// This enables us to test the remote capabilites of ScrollView.
+int main(int argc, char** argv) {
+	const char* server_name;
+	if (argc > 1) { server_name = argv[1]; } else { server_name = "localhost"; }
+	SVPaint svp(server_name);
+}

data/vendor/tesseract-2.04/viewer/svutil.cpp

@@ -0,0 +1,347 @@
+///////////////////////////////////////////////////////////////////////
+// File:        svutil.cpp
+// Description: ScrollView Utilities
+// Author:      Joern Wanke
+// Created:     Thu Nov 29 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.
+//
+///////////////////////////////////////////////////////////////////////
+//
+// SVUtil contains the SVSync and SVNetwork classes, which are used for
+// thread/process creation & synchronization and network connection.
+
+#ifndef GRAPHICS_DISABLED
+
+#include "svutil.h"
+
+#ifdef WIN32
+#include <windows.h>
+#include <winsock.h>
+#else
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#ifdef __linux__
+#include <sys/prctl.h>
+#endif
+#endif
+
+#include <iostream>
+
+const int kBufferSize = 65536;
+const int kMaxMsgSize = 4096;
+
+// Signals a thread to exit.
+void SVSync::ExitThread() {
+#ifdef WIN32
+  //ExitThread(0);
+#else
+  pthread_exit(0);
+#endif
+}
+
+// Starts a new process.
+void SVSync::StartProcess(const char* executable, const char* args) {
+#ifdef WIN32
+  std::string proc;
+  proc.append(executable);
+  proc.append(" ");
+  proc.append(args);
+  std::cout << "Starting " << proc << std::endl;
+  STARTUPINFO start_info;
+  PROCESS_INFORMATION proc_info;
+  GetStartupInfo(&start_info);
+  if (!CreateProcess(NULL, const_cast<char*>(proc.c_str()), NULL, NULL, FALSE,
+                CREATE_NO_WINDOW | DETACHED_PROCESS, NULL, NULL,
+                &start_info, &proc_info))
+    return;
+#else
+  int pid = fork();
+  if (pid != 0) {   // The father process returns
+  } else {
+#ifdef __linux__
+    // Make sure the java process terminates on exit, since its
+    // broken socket detection seems to be useless.
+    prctl(PR_SET_PDEATHSIG, 2, 0, 0, 0);
+#endif
+    char* mutable_args = strdup(args);
+    int argc = 1;
+    for (int i = 0; mutable_args[i]; ++i) {
+      if (mutable_args[i] == ' ') {
+        ++argc;
+      }
+    }
+    char** argv = new char*[argc + 2];
+    argv[0] = strdup(executable);
+    argv[1] = mutable_args;
+    argc = 2;
+    bool inquote = false;
+    for (int i = 0; mutable_args[i]; ++i) {
+      if (!inquote && mutable_args[i] == ' ') {
+        mutable_args[i] = '\0';
+        argv[argc++] = mutable_args + i + 1;
+      } else if (mutable_args[i] == '"') {
+        inquote = !inquote;
+        mutable_args[i] = ' ';
+      }
+    }
+    argv[argc] = NULL;
+    execvp(executable, argv);
+  }
+#endif
+}
+
+SVSemaphore::SVSemaphore() {
+#ifdef WIN32
+  semaphore_ = CreateSemaphore(0, 0, 10, 0);
+#else
+  sem_init(&semaphore_, 0, 0);
+#endif
+}
+
+void SVSemaphore::Signal() {
+#ifdef WIN32
+  ReleaseSemaphore(semaphore_, 1, NULL);
+#else
+  sem_post(&semaphore_);
+#endif
+}
+
+void SVSemaphore::Wait() {
+#ifdef WIN32
+  WaitForSingleObject(semaphore_, INFINITE);
+#else
+  sem_wait(&semaphore_);
+#endif
+}
+
+SVMutex::SVMutex() {
+#ifdef WIN32
+  mutex_ = CreateMutex(0, FALSE, 0);
+#else
+  pthread_mutex_init(&mutex_, NULL);
+#endif
+}
+
+void SVMutex::Lock() {
+#ifdef WIN32
+  WaitForSingleObject(mutex_, INFINITE);
+#else
+  pthread_mutex_lock(&mutex_);
+#endif
+}
+
+void SVMutex::Unlock() {
+#ifdef WIN32
+  ReleaseMutex(mutex_);
+#else
+  pthread_mutex_unlock(&mutex_);
+#endif
+}
+
+// Create new thread.
+
+void SVSync::StartThread(void *(*func)(void*), void* arg) {
+#ifdef WIN32
+  LPTHREAD_START_ROUTINE f = (LPTHREAD_START_ROUTINE) func;
+  DWORD threadid;
+  HANDLE newthread = CreateThread(
+  NULL,          // default security attributes
+  0,             // use default stack size
+  f,             // thread function
+  arg,           // argument to thread function
+  0,             // use default creation flags
+  &threadid);    // returns the thread identifier
+#else
+  pthread_t helper;
+  pthread_create(&helper, NULL, func, arg);
+#endif
+}
+
+// Place a message in the message buffer (and flush it).
+void SVNetwork::Send(const char* msg) {
+  mutex_send_->Lock();
+  msg_buffer_out_.append(msg);
+  mutex_send_->Unlock();
+}
+
+// Send the whole buffer.
+void SVNetwork::Flush() {
+  mutex_send_->Lock();
+  while (msg_buffer_out_.size() > 0) {
+    int i = send(stream_, msg_buffer_out_.c_str(), msg_buffer_out_.length(), 0);
+    msg_buffer_out_.erase(0, i);
+  }
+  mutex_send_->Unlock();
+}
+
+// Receive a message from the server.
+// This will always return one line of char* (denoted by \n).
+char* SVNetwork::Receive() {
+  char* result = NULL;
+#ifdef WIN32
+  if (has_content) { result = strtok (NULL, "\n"); }
+#else
+  if (buffer_ptr_ != NULL) { result = strtok_r(NULL, "\n", &buffer_ptr_); }
+#endif
+
+  // This means there is something left in the buffer and we return it.
+  if (result != NULL) { return result;
+  // Otherwise, we read from the stream_.
+  } else {
+    buffer_ptr_ = NULL;
+    has_content = false;
+
+    // The timeout length is not really important since we are looping anyway
+    // until a new message is delivered.
+    struct timeval tv;
+    tv.tv_sec = 10;
+    tv.tv_usec = 0;
+
+    // Set the flags to return when the stream_ is ready to be read.
+    fd_set readfds;
+    FD_ZERO(&readfds);
+    FD_SET(stream_, &readfds);
+
+    int i = select(stream_+1, &readfds, NULL, NULL, &tv);
+
+    // The stream_ died.
+    if (i == 0) { return NULL; }
+
+    // Read the message buffer.
+    i = recv(stream_, msg_buffer_in_, kMaxMsgSize, 0);
+
+    // Server quit (0) or error (-1).
+    if (i <= 0) { return NULL; }
+    msg_buffer_in_[i] = '\0';
+    has_content = true;
+#ifdef WIN32
+    return strtok(msg_buffer_in_,"\n");
+#else
+    // Setup a new string tokenizer.
+    return strtok_r(msg_buffer_in_, "\n", &buffer_ptr_);
+#endif
+  }
+}
+
+// Close the connection to the server.
+void SVNetwork::Close() {
+#ifdef WIN32
+  closesocket(stream_);
+#else
+  close(stream_);
+#endif
+}
+
+// Set up a connection to hostname on port.
+SVNetwork::SVNetwork(const char* hostname, int port) {
+  mutex_send_ = new SVMutex();
+  struct sockaddr_in address;
+  struct hostent *name;
+
+  msg_buffer_in_ = new char[kMaxMsgSize + 1];
+  msg_buffer_in_[0] = '\0';
+
+  has_content = false;
+
+  buffer_ptr_ = NULL;
+
+// Get the host data depending on the OS.
+#ifdef WIN32
+  WSADATA wsaData;
+  WSAStartup(MAKEWORD(1, 1), &wsaData);
+  name = gethostbyname(hostname);
+#elif defined(__linux__)
+  struct hostent hp;
+  int herr;
+  char *buffer = new char[kBufferSize];
+  gethostbyname_r(hostname, &hp, buffer, kBufferSize, &name, &herr);
+  delete[] buffer;
+#else
+  name = gethostbyname(hostname);
+#endif
+
+  // Fill in the appropriate variables to be able to connect to the server.
+  address.sin_family = name->h_addrtype;
+  memcpy((char *) &address.sin_addr.s_addr,
+         name->h_addr_list[0], name->h_length);
+  address.sin_port = htons(port);
+
+  stream_ = socket(AF_INET, SOCK_STREAM, 0);
+
+  // If server is not there, we will start a new server as local child process.
+  if (connect(stream_, (struct sockaddr *) &address, sizeof(address)) < 0) {
+    const char* scrollview_path = getenv("SCROLLVIEW_PATH");
+    if (scrollview_path == NULL) {
+#ifdef SCROLLVIEW_PATH
+#define _STR(a) #a
+#define _XSTR(a) _STR(a)
+      scrollview_path = _XSTR(SCROLLVIEW_PATH);
+#undef _XSTR
+#undef _STR
+#else
+      scrollview_path = ".";
+#endif
+    }
+    // The following ugly ifdef is to enable the output of the java runtime
+    // to be sent down a black hole on non-windows to ignore all the
+    // exceptions in piccolo. Ideally piccolo would be debugged to make
+    // this unnecessary.
+    // Also the path has to be separated by ; on windows and : otherwise.
+#ifdef WIN32
+    const char* prog = "java -Xms512m -Xmx1024m";
+    const char* cmd_template = "-Djava.library.path=%s -cp %s/ScrollView.jar;"
+        "%s/piccolo-1.2.jar;%s/piccolox-1.2.jar"
+        " com.google.scrollview.ScrollView";
+#else
+    const char* prog = "sh";
+    const char* cmd_template = "-c \"trap 'kill %1' 0 1 2 ; java "
+        "-Xms1024m -Xmx2048m -Djava.library.path=%s -cp %s/ScrollView.jar:"
+        "%s/piccolo-1.2.jar:%s/piccolox-1.2.jar"
+        " com.google.scrollview.ScrollView"
+        " >/dev/null 2>&1 & wait\"";
+#endif
+    int cmdlen = strlen(cmd_template) + 4*strlen(scrollview_path) + 1;
+    char* cmd = new char[cmdlen];
+    snprintf(cmd, cmdlen, cmd_template, scrollview_path, scrollview_path,
+             scrollview_path, scrollview_path);
+
+    SVSync::StartProcess(prog, cmd);
+    delete [] cmd;
+
+    // Wait for server to show up.
+    // Note: There is no exception handling in case the server never turns up.
+    while (connect(stream_, (struct sockaddr *) &address,
+                   sizeof(address)) < 0) {
+      std::cout << "ScrollView: Waiting for server...\n";
+#ifdef WIN32
+      Sleep(1000);
+#else
+      sleep(1);
+#endif
+    }
+  }
+}
+
+SVNetwork::~SVNetwork() {
+  delete[] msg_buffer_in_;
+  delete mutex_send_;
+}
+
+#endif  // GRAPHICS_DISABLED

data/vendor/tesseract-2.04/viewer/svutil.h

@@ -0,0 +1,138 @@
+///////////////////////////////////////////////////////////////////////
+// File:        svutil.h
+// Description: ScrollView Utilities
+// Author:      Joern Wanke
+// Created:     Thu Nov 29 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.
+//
+///////////////////////////////////////////////////////////////////////
+//
+// SVUtil contains the SVSync, SVSemaphore, SVMutex and SVNetwork
+// classes, which are used for thread/process creation & synchronization
+// and network connection.
+
+#ifndef TESSERACT_VIEWER_SVUTIL_H__
+#define TESSERACT_VIEWER_SVUTIL_H__
+#include <stdio.h>
+#ifdef WIN32
+#include <windows.h>
+#define snprintf _snprintf
+#if (_MSC_VER <= 1400)
+#define vsnprintf _vsnprintf
+#endif
+#pragma warning(disable:4786)
+#else
+#include <pthread.h>
+#include <semaphore.h>
+#endif
+
+#include <string>
+
+#ifndef MAX
+#define MAX(a, b)  ((a > b) ? a : b)
+#endif
+
+#ifndef MIN
+#define MIN(a, b)  ((a < b) ? a : b)
+#endif
+
+// The SVSync class provides functionality for Thread & Process Creation
+class SVSync {
+ public:
+  // Create new thread.
+  static void StartThread(void *(*func)(void*), void* arg);
+  // Signals a thread to exit.
+  static void ExitThread();
+  // Starts a new process.
+  static void StartProcess(const char* executable, const char* args);
+};
+
+// A semaphore class which encapsulates the main signalling
+// and wait abilities of semaphores for windows and unix.
+class SVSemaphore {
+ public:
+  // Sets up a semaphore.
+  SVSemaphore();
+  // Signal a semaphore.
+  void Signal();
+  // Wait on a semaphore.
+  void Wait();
+ private:
+#ifdef WIN32
+  HANDLE semaphore_;
+#else
+  sem_t semaphore_;
+#endif
+};
+
+// A mutex which encapsulates the main locking and unlocking
+// abilites of mutexes for windows and unix.
+class SVMutex {
+ public:
+  // Sets up a new mutex.
+  SVMutex();
+  // Locks on a mutex.
+  void Lock();
+  // Unlocks on a mutex.
+  void Unlock();
+ private:
+#ifdef WIN32
+  HANDLE mutex_;
+#else
+  pthread_mutex_t mutex_;
+#endif
+};
+
+// The SVNetwork class takes care of the remote connection for ScrollView
+// This means setting up and maintaining a remote connection, sending and
+// receiving messages and closing the connection.
+// It is designed to work on both Linux and Windows.
+class SVNetwork {
+ public:
+  // Set up a connection to hostname on port.
+  SVNetwork(const char* hostname, int port);
+
+  // Destructor.
+  ~SVNetwork();
+
+  // Put a message in the messagebuffer to the server and try to send it.
+  void Send(const char* msg);
+
+  // Receive a message from the server.
+  // This will always return one line of char* (denoted by \n).
+  char* Receive();
+
+  // Close the connection to the server.
+  void Close();
+
+  // Flush the buffer.
+  void Flush();
+
+ private:
+  // The mutex for access to Send() and Flush().
+  SVMutex* mutex_send_;
+  // The actual stream_ to the server.
+  int stream_;
+  // Stores the last received message-chunk from the server.
+  char* msg_buffer_in_;
+
+  // Stores the messages which are supposed to go out.
+  std::string msg_buffer_out_;
+
+  bool has_content; // Win32 (strtok)
+  // Where we are at in our msg_buffer_in_
+  char* buffer_ptr_;  // Unix (strtok_r)
+};
+
+#endif  // TESSERACT_VIEWER_SVUTIL_H__
+