tesseract_bin 1.0.0

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

@@ -0,0 +1,93 @@
+/**********************************************************************
+ * File:        fixxht.h  (Formerly fixxht.h)
+ * Description: Improve x_ht and look out for case inconsistencies
+ * Author:		Phil Cheatle
+ * Created:		Thu Aug  5 14:11:08 BST 1993
+ *
+ * (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           FIXXHT_H
+#define           FIXXHT_H
+
+#include          "varable.h"
+#include          "statistc.h"
+#include          "pageres.h"
+#include          "notdll.h"
+
+extern double_VAR_H (x_ht_fraction_of_caps_ht, 0.7,
+"Fract of cps ht est of xht");
+extern double_VAR_H (x_ht_variation, 0.35,
+"Err band as fract of caps/xht dist");
+extern double_VAR_H (x_ht_sub_variation, 0.5,
+"Err band as fract of caps/xht dist");
+extern BOOL_VAR_H (rej_trial_ambigs, TRUE,
+"reject x-ht ambigs when under trial");
+extern BOOL_VAR_H (x_ht_conservative_ambigs, FALSE,
+"Dont rely on ambigs + maxht");
+extern BOOL_VAR_H (x_ht_check_est, TRUE, "Cross check estimates");
+extern BOOL_VAR_H (x_ht_case_flip, FALSE, "Flip or reject suspect case");
+extern BOOL_VAR_H (x_ht_include_dodgy_blobs, TRUE,
+"Include blobs with possible noise?");
+extern BOOL_VAR_H (x_ht_limit_flip_trials, TRUE,
+"Dont do trial flips when ambigs are close to xht?");
+extern BOOL_VAR_H (rej_use_check_block_occ, TRUE,
+"Analyse rejection behaviour");
+extern STRING_VAR_H (chs_non_ambig_caps_ht,
+"!#$%&()/12346789?ABDEFGHIKLNQRT[]\\bdfhkl",
+"Reliable ascenders");
+extern STRING_VAR_H (chs_x_ht, "acegmnopqrsuvwxyz", "X height chars");
+extern STRING_VAR_H (chs_non_ambig_x_ht, "aenqr", "reliable X height chars");
+extern STRING_VAR_H (chs_ambig_caps_x, "cCmMoO05sSuUvVwWxXzZ",
+"X ht or caps ht chars");
+extern STRING_VAR_H (chs_bl_ambig_caps_x, "pPyY",
+" Caps or descender ambigs");
+extern STRING_VAR_H (chs_caps_ht,
+"!#$%&()/0123456789?ABCDEFGHIJKLMNOPQRSTUVWXYZ[]\\bdfhkl{|}",
+"Ascender chars");
+extern STRING_VAR_H (chs_desc, "gjpqy", "Descender chars");
+extern STRING_VAR_H (chs_non_ambig_bl,
+"!#$%&01246789?ABCDEFGHIKLMNORSTUVWXYZabcdehiklmnorstuvwxz",
+"Reliable baseline chars");
+extern STRING_VAR_H (chs_odd_top, "ijt", "Chars with funny ascender region");
+extern STRING_VAR_H (chs_odd_bot, "()35JQ[]\\/{}|", "Chars with funny base");
+extern STRING_VAR_H (chs_bl,
+"!#$%&()/01246789?ABCDEFGHIJKLMNOPRSTUVWXYZ[]\\abcdefhiklmnorstuvwxz{}",
+"Baseline chars");
+extern STRING_VAR_H (chs_non_ambig_desc, "gq", "Reliable descender chars");
+void re_estimate_x_ht(                     //improve for 1 word
+                      WERD_RES *word_res,  //word to do
+                      float *trial_x_ht    //new match value
+                     );
+void check_block_occ(WERD_RES *word_res);
+void check_blob_occ(char *proposed_char,
+                    inT16 blob_ht_above_baseline,
+                    float x_ht,
+                    float caps_ht,
+                    char *confirmed_char);
+float estimate_from_stats(STATS &stats);
+void improve_estimate(WERD_RES *word_res,
+                      float &est_x_ht,
+                      float &est_caps_ht,
+                      STATS &x_ht,
+                      STATS &caps_ht);
+void reject_ambigs(  //rej any accepted xht ambig chars
+                   WERD_RES *word);
+                                 //xht ambig ht stats
+void est_ambigs(WERD_RES *word_res,
+                STATS &stats,
+                float *ambig_lc_x_est,    //xht est
+                float *ambig_uc_caps_est  //caps est
+               );
+BOOL8 dodgy_blob(PBLOB *blob);
+#endif

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

@@ -0,0 +1,154 @@
+/**********************************************************************
+ * File:        imgscale.cpp  (Formerly dyn_prog.c)
+ * Description: Dynamic programming for smart scaling of images.
+ * Author:      Phil Cheatle
+ * Created:     Wed Nov 18 16:12:03 GMT 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.
+ *
+ **********************************************************************/
+
+/*************************************************************************
+ * This is really Sheelagh's code that I've hacked into a more usable form.
+ * It is used by scaleim.c  All I did to it was to change "factor" from int to
+ * float.
+ *************************************************************************/
+/************************************************************************
+ *  This version uses the result of the previous row to influence the
+ *  current row's calculation.
+ ************************************************************************/
+
+#include "mfcpch.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "errcode.h"
+
+#define f(xc, yc) ((xc - factor*yc)*(xc - factor*yc))
+
+#define g(oldyc, yc, oldxc, xc) (factor*factor*(oldyc - yc)*(oldyc - yc)/(abs(oldxc - xc) + 1))
+
+void
+dyn_exit (const char s[]) {
+  fprintf (stderr, "%s", s);
+  err_exit(); 
+}
+
+
+void dyn_prog(  //The clever bit
+              int n,
+              int *x,
+              int *y,
+              int ymax,
+              int *oldx,
+              int *oldy,
+              int oldn,
+              float factor) {
+  int i, z, j, matchflag;
+  int **ymin;
+  float **F, fz;
+
+  /* F[i][z] gives minimum over y <= z */
+
+  F = (float **) calloc (n, sizeof (float *));
+  ymin = (int **) calloc (n, sizeof (int *));
+  if ((F == NULL) || (ymin == NULL))
+    dyn_exit ("Error in calloc\n");
+
+  for (i = 0; i < n; i++) {
+    F[i] = (float *) calloc (ymax - n + i + 1, sizeof (float));
+    ymin[i] = (int *) calloc (ymax - n + i + 1, sizeof (int));
+    if ((F[i] == NULL) || (ymin[i] == NULL))
+      dyn_exit ("Error in calloc\n");
+  }
+
+  F[0][0] = f (x[0], 0);
+  /* find nearest transition of same sign (white to black) */
+  j = 0;
+  while ((j < oldn) && (oldx[j] < x[0]))
+    j += 2;
+  if (j >= oldn)
+    j -= 2;
+  else if ((j - 2 >= 0) && ((x[0] - oldx[j - 2]) < (oldx[j] - x[0])))
+    j -= 2;
+  if (abs (oldx[j] - x[0]) < factor) {
+    matchflag = 1;
+    F[0][0] += g (oldy[j], 0, oldx[j], x[0]);
+  }
+  else
+    matchflag = 0;
+  ymin[0][0] = 0;
+
+  for (z = 1; z < ymax - n + 1; z++) {
+    fz = f (x[0], z);
+    /* add penalty for deviating from previous row if necessary */
+
+    if (matchflag)
+      fz += g (oldy[j], z, oldx[j], x[0]);
+    if (fz < F[0][z - 1]) {
+      F[0][z] = fz;
+      ymin[0][z] = z;
+    }
+    else {
+      F[0][z] = F[0][z - 1];
+      ymin[0][z] = ymin[0][z - 1];
+    }
+  }
+
+  for (i = 1; i < n; i++) {
+    F[i][i] = f (x[i], i) + F[i - 1][i - 1];
+    /* add penalty for deviating from previous row if necessary */
+    if (j > 0)
+      j--;
+    else
+      j++;
+    while ((j < oldn) && (oldx[j] < x[i]))
+      j += 2;
+    if (j >= oldn)
+      j -= 2;
+    else if ((j - 2 >= 0) && ((x[i] - oldx[j - 2]) < (oldx[j] - x[i])))
+      j -= 2;
+    if (abs (oldx[j] - x[i]) < factor) {
+      matchflag = 1;
+      F[i][i] += g (oldy[j], i, oldx[j], x[i]);
+    }
+    else
+      matchflag = 0;
+    ymin[i][i] = i;
+    for (z = i + 1; z < ymax - n + i + 1; z++) {
+      fz = f (x[i], z) + F[i - 1][z - 1];
+      /* add penalty for deviating from previous row if necessary */
+      if (matchflag)
+        fz += g (oldy[j], z, oldx[j], x[i]);
+      if (fz < F[i][z - 1]) {
+        F[i][z] = fz;
+        ymin[i][z] = z;
+      }
+      else {
+        F[i][z] = F[i][z - 1];
+        ymin[i][z] = ymin[i][z - 1];
+      }
+    }
+  }
+
+  y[n - 1] = ymin[n - 1][ymax - 1];
+  for (i = n - 2; i >= 0; i--)
+    y[i] = ymin[i][y[i + 1] - 1];
+
+  for (i = 0; i < n; i++) {
+    free (F[i]);
+    free (ymin[i]);
+  }
+  free(F); 
+  free(ymin); 
+
+  return;
+}

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

@@ -0,0 +1,32 @@
+/**********************************************************************
+ * File:        imgscale.h  (Formerly dyn_prog.h)
+ * Description: Dynamic programming for smart scaling of images.
+ * Author:      Phil Cheatle
+ * Created:     Wed Nov 18 16:12:03 GMT 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           IMGSCALE_H
+#define           IMGSCALE_H
+
+void dyn_prog(  //The clever bit
+              int n,
+              int *x,
+              int *y,
+              int ymax,
+              int *oldx,
+              int *oldy,
+              int oldn,
+              float factor);
+#endif

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

@@ -0,0 +1,391 @@
+/**********************************************************************
+ * File:        matmatch.cpp  (Formerly matrix_match.c)
+ * Description: matrix matching routines for Tessedit
+ * Author:      Chris Newton
+ * Created:     Wed Nov 24 15:57:41 GMT 1993
+ *
+ * (C) Copyright 1993, 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          <math.h>
+#include          <string.h>
+#include          <ctype.h>
+#ifdef __UNIX__
+#include          <assert.h>
+#endif
+#include          "tessvars.h"
+#include          "stderr.h"
+#include          "img.h"
+//#include          "evnts.h"
+//#include          "showim.h"
+#include          "hosthplb.h"
+#include          "scrollview.h"
+//#include          "evnts.h"
+#include          "adaptions.h"
+#include          "matmatch.h"
+#include          "secname.h"
+#include "svshowim.h"
+
+#define EXTERN
+
+EXTERN BOOL_VAR (tessedit_display_mm, FALSE, "Display matrix matches");
+EXTERN BOOL_VAR (tessedit_mm_debug, FALSE,
+"Print debug information for matrix matcher");
+EXTERN INT_VAR (tessedit_mm_prototype_min_size, 3,
+"Smallest number of samples in a cluster for a prototype to be used");
+
+// Colours for displaying the match
+#define BB_COLOUR 0
+#define BW_COLOUR 1
+#define WB_COLOUR 3
+#define UB_COLOUR 5
+#define BU_COLOUR 7
+#define UU_COLOUR 9
+#define WU_COLOUR 11
+#define UW_COLOUR 13
+#define WW_COLOUR 15
+
+#define BINIM_BLACK 0
+#define BINIM_WHITE 1
+
+float matrix_match(  // returns match score
+                   IMAGE *image1,
+                   IMAGE *image2) {
+  ASSERT_HOST (image1->get_bpp () == 1 && image2->get_bpp () == 1);
+
+  if (image1->get_xsize () >= image2->get_xsize ())
+    return match1 (image1, image2);
+  else
+    return match1 (image2, image1);
+}
+
+
+float match1(  /* returns match score */
+             IMAGE *image_w,
+             IMAGE *image_n) {
+  inT32 x_offset;
+  inT32 y_offset;
+  inT32 x_size = image_w->get_xsize ();
+  inT32 y_size;
+  inT32 x_size2 = image_n->get_xsize ();
+  inT32 y_size2;
+  IMAGE match_image;
+  IMAGELINE imline_w;
+  IMAGELINE imline_n;
+  IMAGELINE match_imline;
+  inT32 x;
+  inT32 y;
+  float sum = 0.0;
+
+  x_offset = (image_w->get_xsize () - image_n->get_xsize ()) / 2;
+
+  ASSERT_HOST (x_offset >= 0);
+  match_imline.init (x_size);
+
+  sum = 0;
+
+  if (image_w->get_ysize () < image_n->get_ysize ()) {
+    y_size = image_n->get_ysize ();
+    y_size2 = image_w->get_ysize ();
+    y_offset = (y_size - y_size2) / 2;
+
+    if (tessedit_display_mm && !tessedit_mm_use_prototypes)
+      tprintf ("I1 (%d, %d), I2 (%d, %d), MI (%d, %d)\n", x_size,
+        image_w->get_ysize (), x_size2, image_n->get_ysize (),
+        x_size, y_size);
+
+    match_image.create (x_size, y_size, 4);
+
+    for (y = 0; y < y_offset; y++) {
+      image_n->fast_get_line (0, y, x_size2, &imline_n);
+      for (x = 0; x < x_size2; x++) {
+        if (imline_n.pixels[x] == BINIM_BLACK) {
+          sum += -1;
+          match_imline.pixels[x] = UB_COLOUR;
+        }
+        else {
+          match_imline.pixels[x] = UW_COLOUR;
+        }
+      }
+      match_image.fast_put_line (x_offset, y, x_size2, &match_imline);
+    }
+
+    for (y = y_offset + y_size2; y < y_size; y++) {
+      image_n->fast_get_line (0, y, x_size2, &imline_n);
+      for (x = 0; x < x_size2; x++) {
+        if (imline_n.pixels[x] == BINIM_BLACK) {
+          sum += -1.0;
+          match_imline.pixels[x] = UB_COLOUR;
+        }
+        else {
+          match_imline.pixels[x] = UW_COLOUR;
+        }
+      }
+      match_image.fast_put_line (x_offset, y, x_size2, &match_imline);
+    }
+
+    for (y = y_offset; y < y_offset + y_size2; y++) {
+      image_w->fast_get_line (0, y - y_offset, x_size, &imline_w);
+      image_n->fast_get_line (0, y, x_size2, &imline_n);
+      for (x = 0; x < x_offset; x++) {
+        if (imline_w.pixels[x] == BINIM_BLACK) {
+          sum += -1.0;
+          match_imline.pixels[x] = BU_COLOUR;
+        }
+        else {
+          match_imline.pixels[x] = WU_COLOUR;
+        }
+      }
+
+      for (x = x_offset + x_size2; x < x_size; x++) {
+        if (imline_w.pixels[x] == BINIM_BLACK) {
+          sum += -1.0;
+          match_imline.pixels[x] = BU_COLOUR;
+        }
+        else {
+          match_imline.pixels[x] = WU_COLOUR;
+        }
+      }
+
+      for (x = x_offset; x < x_offset + x_size2; x++) {
+        if (imline_n.pixels[x - x_offset] == imline_w.pixels[x]) {
+          sum += 1.0;
+          if (imline_w.pixels[x] == BINIM_BLACK)
+            match_imline.pixels[x] = BB_COLOUR;
+          else
+            match_imline.pixels[x] = WW_COLOUR;
+        }
+        else {
+          sum += -1.0;
+          if (imline_w.pixels[x] == BINIM_BLACK)
+            match_imline.pixels[x] = BW_COLOUR;
+          else
+            match_imline.pixels[x] = WB_COLOUR;
+        }
+      }
+
+      match_image.fast_put_line (0, y, x_size, &match_imline);
+    }
+  }
+  else {
+    y_size = image_w->get_ysize ();
+    y_size2 = image_n->get_ysize ();
+    y_offset = (y_size - y_size2) / 2;
+
+    if (tessedit_display_mm && !tessedit_mm_use_prototypes)
+      tprintf ("I1 (%d, %d), I2 (%d, %d), MI (%d, %d)\n", x_size,
+        image_w->get_ysize (), x_size2, image_n->get_ysize (),
+        x_size, y_size);
+
+    match_image.create (x_size, y_size, 4);
+
+    for (y = 0; y < y_offset; y++) {
+      image_w->fast_get_line (0, y, x_size, &imline_w);
+      for (x = 0; x < x_size; x++) {
+        if (imline_w.pixels[x] == BINIM_BLACK) {
+          sum += -1;
+          match_imline.pixels[x] = BU_COLOUR;
+        }
+        else {
+          match_imline.pixels[x] = WU_COLOUR;
+        }
+      }
+      match_image.fast_put_line (0, y, x_size, &match_imline);
+    }
+
+    for (y = y_offset + y_size2; y < y_size; y++) {
+      image_w->fast_get_line (0, y, x_size, &imline_w);
+      for (x = 0; x < x_size; x++) {
+        if (imline_w.pixels[x] == BINIM_BLACK) {
+          sum += -1;
+          match_imline.pixels[x] = BU_COLOUR;
+        }
+        else {
+          match_imline.pixels[x] = WU_COLOUR;
+        }
+      }
+      match_image.fast_put_line (0, y, x_size, &match_imline);
+    }
+
+    for (y = y_offset; y < y_offset + y_size2; y++) {
+      image_w->fast_get_line (0, y, x_size, &imline_w);
+      image_n->fast_get_line (0, y - y_offset, x_size2, &imline_n);
+      for (x = 0; x < x_offset; x++) {
+        if (imline_w.pixels[x] == BINIM_BLACK) {
+          sum += -1.0;
+          match_imline.pixels[x] = BU_COLOUR;
+        }
+        else {
+          match_imline.pixels[x] = WU_COLOUR;
+        }
+      }
+
+      for (x = x_offset + x_size2; x < x_size; x++) {
+        if (imline_w.pixels[x] == BINIM_BLACK) {
+          sum += -1.0;
+          match_imline.pixels[x] = BU_COLOUR;
+        }
+        else {
+          match_imline.pixels[x] = WU_COLOUR;
+        }
+      }
+
+      for (x = x_offset; x < x_offset + x_size2; x++) {
+        if (imline_n.pixels[x - x_offset] == imline_w.pixels[x]) {
+          sum += 1.0;
+          if (imline_w.pixels[x] == BINIM_BLACK)
+            match_imline.pixels[x] = BB_COLOUR;
+          else
+            match_imline.pixels[x] = WW_COLOUR;
+        }
+        else {
+          sum += -1.0;
+          if (imline_w.pixels[x] == BINIM_BLACK)
+            match_imline.pixels[x] = BW_COLOUR;
+          else
+            match_imline.pixels[x] = WB_COLOUR;
+        }
+      }
+
+      match_image.fast_put_line (0, y, x_size, &match_imline);
+    }
+  }
+
+#ifndef GRAPHICS_DISABLED
+  if (tessedit_display_mm && !tessedit_mm_use_prototypes) {
+    tprintf ("Match score %f\n", 1.0 - sum / (x_size * y_size));
+    display_images(image_w, image_n, &match_image);
+  }
+#endif
+
+  if (tessedit_mm_debug)
+    tprintf ("Match score %f\n", 1.0 - sum / (x_size * y_size));
+
+  return (1.0 - sum / (x_size * y_size));
+}
+
+
+/*************************************************************************
+ * display_images()
+ *
+ * Show a pair of images, plus the match image
+ *
+ *************************************************************************/
+
+#ifndef GRAPHICS_DISABLED
+void display_images(IMAGE *image_w, IMAGE *image_n, IMAGE *match_image) {
+  ScrollView* w_im_window;
+  ScrollView* n_im_window;
+  ScrollView* match_window;
+  inT16 i;
+
+  w_im_window = new ScrollView("Image 1", 20, 100,
+      10 * image_w->get_xsize (), 10 * image_w->get_ysize (),
+      image_w->get_xsize (), image_w->get_ysize ());
+
+  sv_show_sub_image (image_w,
+    0, 0,
+    image_w->get_xsize (), image_w->get_ysize (),
+    w_im_window, 0, 0);
+
+  w_im_window->Pen(255,0,0);
+  for (i = 1; i < image_w->get_xsize (); i++) {
+     w_im_window->Line(i, 0, i, image_w->get_ysize ());
+  }
+  for (i = 1; i < image_w->get_ysize (); i++) {
+    w_im_window->Line(0, i, image_w->get_xsize (), i);
+  }
+
+  n_im_window = new ScrollView ("Image 2", 240, 100,
+      10 * image_n->get_xsize (), 10 * image_n->get_ysize (),
+      image_n->get_xsize (), image_n->get_ysize ());
+
+  sv_show_sub_image (image_n,
+    0, 0,
+    image_n->get_xsize (), image_n->get_ysize (),
+    n_im_window, 0, 0);
+
+  n_im_window->Pen(255,0,0);
+  for (i = 1; i < image_n->get_xsize (); i++) {
+     n_im_window->Line(i, 0, i, image_n->get_ysize ());
+  }
+  for (i = 1; i < image_n->get_ysize (); i++) {
+    n_im_window->Line(0, i, image_n->get_xsize (), i);
+  }
+
+  match_window = new ScrollView ("Match Result", 460, 100,
+       10 * match_image->get_xsize (), 10 * match_image->get_ysize (),
+       match_image->get_xsize (), match_image->get_ysize ());
+
+  match_window->Clear();
+  sv_show_sub_image (match_image,
+    0, 0,
+    match_image->get_xsize (), match_image->get_ysize (),
+    match_window, 0, 0);
+
+  match_window->Pen(255,0,0);
+  for (i = 1; i < match_image->get_xsize (); i++) {
+     match_window->Line(i, 0, i, match_image->get_ysize ());
+  }
+  for (i = 1; i < match_image->get_ysize (); i++) {
+     match_window->Line(0, i, match_image->get_xsize (), i);
+  }
+  SVEvent* sve = match_window->AwaitEvent(SVET_DESTROY);
+  delete sve;
+
+  delete w_im_window;
+  delete n_im_window;
+  delete match_window;
+}
+
+
+/*************************************************************************
+ * display_image()
+ *
+ * Show a single image
+ *
+ *************************************************************************/
+
+ScrollView* display_image(IMAGE *image,
+                     const char *title,
+                     inT32 x,
+                     inT32 y,
+                     BOOL8 wait) {
+  ScrollView* im_window;
+  inT16 i;
+
+  im_window = new ScrollView (title, x, y,
+      10 * image->get_xsize (), 10 * image->get_ysize (),
+      image->get_xsize (),  image->get_ysize ());
+
+  sv_show_sub_image (image,
+    0, 0,
+    image->get_xsize (), image->get_ysize (), im_window, 0, 0);
+
+  im_window->Pen(255,0,0);
+  for (i = 1; i < image->get_xsize (); i++) {
+    im_window->SetCursor(i, 0);
+    im_window->DrawTo(i, image->get_ysize());
+  }
+  for (i = 1; i < image->get_ysize (); i++) {
+    im_window->SetCursor(0, i);
+    im_window->DrawTo(image->get_xsize(),i);
+  }
+
+  if (wait) { delete im_window->AwaitEvent(SVET_CLICK); }
+
+  return im_window;
+}
+#endif