tesseract_bin 1.0.0

data/vendor/tesseract-2.04/image/imgs.cpp

@@ -0,0 +1,1764 @@
+/**********************************************************************
+ * File:        imgs.c  (Formerly images.c)
+ * Description: Main image manipulation functions.
+ * Author:      Ray Smith
+ * Created:     Thu Jun 07 16:25:02 BST 1990
+ *
+ * (C) Copyright 1990, 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"     //precompiled headers
+#ifdef __MSW32__
+#include          <io.h>
+#else
+#include          <unistd.h>
+#endif
+#include          <string.h>
+#ifdef __UNIX__
+#include          <assert.h>
+#endif
+
+// Include automatically generated configuration file if running autoconf.
+#ifdef HAVE_CONFIG_H
+#include "config_auto.h"
+#endif
+
+#ifdef HAVE_LIBLEPT
+// Include leptonica library only if autoconf (or makefile etc) tell us to.
+#include "allheaders.h"
+#endif
+
+#include          "stderr.h"
+#include          "tprintf.h"
+#include          "imgerrs.h"
+#include          "memry.h"
+#include          "imgs.h"
+#include          "imgio.h"
+#include          "imgunpk.h"
+
+#define FIXED_COLOURS   32       /*number of fixed colours */
+#define MIN_4BIT      48         /*4bpp range */
+#define MAX_4BIT      64
+#define MIN_6BIT      64         /*6bpp range */
+#define MAX_6BIT      128
+#define BLACK_PIX     0
+
+static uinT8 grey_scales[FIXED_COLOURS] = {
+  0, 255, 76, 227, 151, 179, 28, 104,
+  149, 72, 215, 67, 53, 44, 156, 137,
+  110, 153, 79, 181, 166, 218, 55, 81,
+  129, 105, 179, 149, 168, 69, 84, 126
+};
+
+#undef EXTERN
+#define EXTERN
+
+EXTERN INT_VAR (image_default_resolution, 300, "Image resolution dpi");
+
+/**********************************************************************
+ * IMAGE
+ *
+ * Contructor for an IMAGE class. Makes the image definitely illegal.
+ **********************************************************************/
+
+IMAGE::IMAGE() {  //construct an image
+  bpp = 0;                       //all illegal
+  fd = -1;
+  image = NULL;
+  photo_interp = 1;
+  res = image_default_resolution;
+}
+
+
+/**********************************************************************
+ * IMAGE::operator=
+ *
+ * Assign an IMAGE to another. The dest becomes the owner of the memory.
+ **********************************************************************/
+
+IMAGE & IMAGE::operator= (       //assignment
+IMAGE & source                   //source image
+) {
+  destroy();
+  bpp = source.bpp;
+  photo_interp = source.photo_interp;
+  bps = source.bps;
+  bytespp = (bpp + 7) / 8;
+  lineskip = source.lineskip;    //copy everything
+  captured = source.captured;
+  xsize = source.xsize;
+  ysize = source.ysize;
+  res = source.res;
+  image = source.image;
+  xdim = source.xdim;
+  bufheight = source.bufheight;
+  fd = source.fd;
+  reader = source.reader;
+  ymin = source.ymin;
+  ymax = source.ymax;
+
+  source.captured = TRUE;        //source now captured
+  source.fd = -1;
+
+  return *this;
+}
+
+
+/**********************************************************************
+ * create
+ *
+ * Create an image (allocate memory) of a specific size and bpp.
+ **********************************************************************/
+
+inT8 IMAGE::create(                     //get rest of image
+                   inT32 x,             //x size required
+                   inT32 y,             //ysize required
+                   inT8 bits_per_pixel  //bpp required
+                  ) {
+  uinT8 *pixels;                 //memory for image
+
+  xdim = check_legal_image_size (x, y, bits_per_pixel);
+  if (xdim < 0)
+    return -1;
+  pixels = (uinT8 *) alloc_big_zeros ((size_t) (xdim * y * sizeof (uinT8)));
+  if (pixels == NULL) {
+    MEMORY_OUT.error ("IMAGE::create", ABORT, "Size=(%d,%d)", xdim, y);
+    return -1;
+  }
+                                 //allocate to image
+  this->capture (pixels, x, y, bits_per_pixel);
+  captured = FALSE;
+  res = image_default_resolution;
+  return 0;                      //success
+}
+
+
+/**********************************************************************
+ * destroy
+ *
+ * Destroy an image, freeing memory and closing any open file.
+ **********************************************************************/
+
+void IMAGE::destroy() {  //get rid of image
+  if (image != NULL && !captured) {
+    free_big_mem(image);
+  }
+  image = NULL;
+  if (fd >= 0) {
+    close(fd);
+    fd = -1;
+  }
+  bpp = 0;
+}
+
+
+/**********************************************************************
+ * capture
+ *
+ * Assign a given memory area to an image to use as an image of
+ * given size and bpp.
+ **********************************************************************/
+
+inT8 IMAGE::capture(                     //get rest of image
+                    uinT8 *pixels,       //image memory
+                    inT32 x,             //x size required
+                    inT32 y,             //ysize required
+                    inT8 bits_per_pixel  //bpp required
+                   ) {
+  destroy();
+  xdim = check_legal_image_size (x, y, bits_per_pixel);
+  if (xdim < 0)
+    return -1;
+  xsize = x;
+  ysize = y;
+  bufheight = y;
+  bpp = bits_per_pixel;
+  bps = bpp == 24 ? 8 : bpp;
+  photo_interp = 1;
+  bytespp = (bpp + 7) / 8;
+  image = pixels;                //assign image area
+  ymin = 0;
+  ymax = bufheight;              //read it all
+  captured = TRUE;
+  res = image_default_resolution;
+  return 0;                      //success
+}
+
+
+/**********************************************************************
+ * pixel
+ *
+ * Get a single pixel out of the image.
+ **********************************************************************/
+
+uinT8 IMAGE::pixel(          //get rest of image
+                   inT32 x,  //x coord
+                   inT32 y   //y coord
+                  ) {
+  if (x < 0)
+    x = 0;                       //silently clip
+  else if (x >= xsize)
+    x = xsize - 1;
+  if (y < 0)
+    y = 0;
+  else if (y >= ysize)
+    y = ysize - 1;
+  check_legal_access (x, y, 1);
+  switch (bpp) {
+    case 5:
+    case 6:
+    case 8:
+      return image[(ymax - 1 - y) * xdim + x];
+    case 4:
+      return bpp4table[image[(ymax - 1 - y) * xdim + x / 2]][x & 1];
+    case 2:
+      return bpp2table[image[(ymax - 1 - y) * xdim + x / 4]][x & 3];
+    case 1:
+      return bpp1table[image[(ymax - 1 - y) * xdim + x / 8]][x & 7];
+    default:
+      tprintf ("Unexpected bits per pixel %d\n", bpp);
+      return 0;
+  }
+}
+
+
+/**********************************************************************
+ * check_legal_image_size
+ *
+ * Check that the supplied image sizes are legal.  If they are,
+ * the xdim is returned, else -1.
+ **********************************************************************/
+
+inT32 check_legal_image_size(                     //get rest of image
+                             inT32 x,             //x size required
+                             inT32 y,             //ysize required
+                             inT8 bits_per_pixel  //bpp required
+                            ) {
+  if (x <= 0 || y <= 0) {
+    BADIMAGESIZE.error ("check_legal_image_size", TESSLOG, "(%d,%d)", x, y);
+    return -1;                   //failed
+  }
+  if (bits_per_pixel != 1 && bits_per_pixel != 2
+    && bits_per_pixel != 4 && bits_per_pixel != 5
+  && bits_per_pixel != 6 && bits_per_pixel != 8 && bits_per_pixel != 24) {
+    BADBPP.error ("check_legal_image_size", TESSLOG, "%d", bits_per_pixel);
+    return -1;
+  }
+                                 //bytes per line
+  return COMPUTE_IMAGE_XDIM (x, bits_per_pixel);
+}
+
+
+/**********************************************************************
+ * copy_sub_image
+ *
+ * Copy a portion of one image to a portion of another image.
+ * If the bpps are different, the position of the most significant
+ * bit is preserved.
+ **********************************************************************/
+
+DLLSYM void copy_sub_image(                   //copy rectangle
+                           IMAGE *source,     //source image
+                           inT32 xstart,      //start coords
+                           inT32 ystart,
+                           inT32 xext,        //extent to copy
+                           inT32 yext,
+                           IMAGE *dest,       //destination image
+                           inT32 xdest,       //destination coords
+                           inT32 ydest,
+                           BOOL8 adjust_grey  //shift to new bpp
+                          ) {
+  IMAGELINE copyline;            //copy of line
+  uinT8 *copy;                   //source pointer
+  inT8 shift;                    //shift factor
+  inT32 pixel;                   //pixel index
+  inT32 y;                       //line index
+  inT32 yoffset;                 //current adjusted offset
+  inT32 bytesize;                //no of bytes to copy
+  inT32 srcppb;                  //pixels per byte
+  BOOL8 aligned;
+
+  if (xstart < 0 || ystart < 0 || xdest < 0 || ydest < 0)
+    return;
+  if (xext <= 0)
+    xext = source->xsize;        //default to all
+  if (xext > source->xsize - xstart)
+                                 //clip to smallest
+      xext = source->xsize - xstart;
+  if (xext > dest->xsize - xdest)
+    xext = dest->xsize - xdest;
+  if (yext <= 0)
+    yext = source->ysize;        //default to all
+  if (yext > source->ysize - ystart)
+                                 //clip to smallest
+      yext = source->ysize - ystart;
+  if (yext > dest->ysize - ydest)
+    yext = dest->ysize - ydest;
+  if (xext <= 0 || yext <= 0)
+    return;                      //nothing to do
+
+  srcppb = 8 / source->bpp;      //pixels per byte
+  if (source->bpp == dest->bpp || !adjust_grey)
+    shift = 0;                   //no adjustment
+  else {
+    shift = source->bps - dest->bps;
+    if (shift < 0)
+      shift = -shift;            //keep positive
+  }
+  aligned = source->bpp == dest->bpp;
+  if (aligned && srcppb != 0) {
+    aligned = xstart % srcppb == 0
+      && xdest % srcppb == 0
+      && (xext % srcppb == 0 || xdest + xext == dest->xsize);
+  }
+  for (y = 0; y < yext; y++) {
+    if (ystart >= ydest)
+      yoffset = y;               //top down
+    else
+      yoffset = yext - y - 1;    //bottom up
+    source->check_legal_access (xstart, ystart + yoffset, xext);
+    dest->check_legal_access (xdest, ydest + yoffset, xext);
+    if (aligned) {
+      bytesize = COMPUTE_IMAGE_XDIM (xext, source->bpp);
+      //get bytes per line
+      if (srcppb == 0)
+                                 //do cheap move
+        memmove (dest->image + (dest->ymax - 1 - ydest - yoffset) * dest->xdim + xdest * 3, source->image + (source->ymax - 1 - ystart - yoffset) * source->xdim + xstart * 3, (unsigned) bytesize);
+      else
+                                 //do cheap move
+        memmove (dest->image + (dest->ymax - 1 - ydest - yoffset) * dest->xdim + xdest / srcppb, source->image + (source->ymax - 1 - ystart - yoffset) * source->xdim + xstart / srcppb, (unsigned) bytesize);
+    }
+    else {
+      if (shift == 0) {
+        source->fast_get_line (xstart, ystart + yoffset, xext,
+          &copyline);
+      }
+      else if (source->bpp < dest->bpp) {
+        source->get_line (xstart, ystart + yoffset, xext, &copyline, 0);
+        if (source->bpp <= shift
+        && (source->bpp == 1 || source->bpp == 4)) {
+          if (source->bpp == 1) {
+            for (pixel = 0, copy = copyline.pixels; pixel < xext;
+              pixel++, copy++)
+            if (*copy)
+              *copy = 0xff;
+          }
+          else {
+            for (pixel = 0, copy = copyline.pixels; pixel < xext;
+              pixel++, copy++)
+                                 //scale up
+            *copy = (*copy << shift) | *copy;
+          }
+        }
+        else {
+          for (pixel = 0, copy = copyline.pixels; pixel < xext;
+            pixel++)
+          *copy++ <<= shift;     //scale up
+        }
+      }
+      else {
+        source->get_line (xstart, ystart + yoffset, xext, &copyline, 0);
+        if (source->bpp == 24) {
+          for (pixel = 0, copy = copyline.pixels + 1; pixel < xext;
+          pixel++) {
+            *copy >>= shift;
+            copy += 3;
+          }
+        }
+        else {
+          for (pixel = 0, copy = copyline.pixels; pixel < xext;
+            pixel++)
+          *copy++ >>= shift;     //scale down
+        }
+      }
+      dest->put_line (xdest, ydest + yoffset, xext, &copyline, 0);
+    }
+  }
+}
+
+
+/**********************************************************************
+ * enlarge_sub_image
+ *
+ * Enlarge a portion of one image to a portion of another image.
+ * If the bpps are different, the position of the most significant
+ * bit is preserved.
+ **********************************************************************/
+
+DLLSYM void enlarge_sub_image(                   //enlarge rectangle
+                              IMAGE *source,     //source image
+                              inT32 xstart,      //scaled start coords
+                              inT32 ystart,
+                              IMAGE *dest,       //destination image
+                              inT32 xdest,       //dest coords
+                              inT32 ydest,
+                              inT32 xext,        //destination extent
+                              inT32 yext,
+                              inT32 scale,       //scale factor
+                              BOOL8 adjust_grey  //shift to new bpp
+                             ) {
+  inT8 shift;                    //shift factor
+  uinT8 pixel;                   //current pixel
+  inT32 srcext;                  //source extent
+  inT32 xoffset;                 //column index
+  inT32 yoffset;                 //line index
+  inT32 xindex, yindex;          //index in super pixel
+  inT32 startxindex;             //initial x index
+  inT32 xscale;                  //x scale factor
+  uinT8 *src;                    //source pixels
+  uinT8 *destpix;                //dest pixels
+  IMAGELINE copyline;            //copy of line
+  IMAGELINE bigline;             //expanded line
+
+  if (xstart < 0 || ystart < 0 || xdest < 0 || ydest < 0)
+    return;
+
+  if (xext <= 0)
+    xext = dest->xsize;          //default to all
+  if (xext > source->xsize * scale - xstart)
+                                 //clip to smallest
+    xext = source->xsize * scale - xstart;
+  if (xext > dest->xsize - xdest)
+    xext = dest->xsize - xdest;
+  if (yext <= 0)
+    yext = dest->ysize;          //default to all
+  if (yext > source->ysize * scale - ystart)
+    yext = source->ysize * scale - ystart;
+  if (yext > dest->ysize - ydest)
+    yext = dest->ysize - ydest;
+  if (xext <= 0 || yext <= 0)
+    return;                      //nothing to do
+
+  xindex = xstart % scale;       //offset in super pixel
+  startxindex = xindex;
+  yindex = ystart % scale;
+                                 //no of source pixels
+  srcext = (xext + xindex + scale - 1) / scale;
+  xstart /= scale;               //actual start
+  ystart /= scale;
+  if (adjust_grey) {
+    shift = dest->bps - source->bps;
+  }
+  else
+    shift = 0;                   //no adjustment
+  bigline.init (xext * 3);
+  bigline.bpp = dest->bpp == 24 ? source->bpp : dest->bpp;
+
+  for (yoffset = 0; yoffset < yext; ystart++) {
+    source->check_legal_access (xstart, ystart, srcext);
+    dest->check_legal_access (xdest, ydest + yoffset, xext);
+    source->fast_get_line (xstart, ystart, srcext, &copyline);
+    src = copyline.pixels;
+    destpix = bigline.pixels;
+    xscale = scale;              //enlargement factor
+    if (source->bpp == 24 && dest->bpp == 24) {
+      for (xoffset = 0, xindex = startxindex; xoffset < xext;
+      src += source->bytespp) {
+        xoffset += xscale - xindex;
+        if (xoffset > xext)
+          xscale -= xoffset - xext;
+        for (; xindex < xscale; xindex++) {
+          *destpix++ = *src;
+          *destpix++ = *(src + 1);
+          *destpix++ = *(src + 2);
+        }
+        xindex = 0;
+      }
+    }
+    else {
+      if (source->bpp == 24)
+        src++;
+      for (xoffset = 0, xindex = startxindex; xoffset < xext;
+      src += source->bytespp) {
+        xoffset += xscale - xindex;
+        if (xoffset > xext)
+                                 //clip to dest limit
+            xscale -= xoffset - xext;
+        if (shift == 0)
+          pixel = *src;
+        else if (shift > 0)
+          pixel = *src << shift;
+        else
+          pixel = *src >> (-shift);
+        for (; xindex < xscale; xindex++)
+          *destpix++ = pixel;    //duplicate pixel
+        xindex = 0;
+      }
+    }
+    for (; yoffset < yext && yindex < scale; yindex++, yoffset++) {
+      dest->put_line (xdest, ydest + yoffset, xext, &bigline, 0);
+    }
+    yindex = 0;
+  }
+}
+
+
+/**********************************************************************
+ * fast_reduce_sub_image
+ *
+ * Reduce a portion of one image to a portion of another image.
+ * If the bpps are different, the position of the most significant
+ * bit is preserved.
+ * This is a fast but dirty version, which simply sub-samples.
+ * It does not smooth as it reduces.
+ **********************************************************************/
+
+DLLSYM void fast_reduce_sub_image(                   //reduce rectangle
+                                  IMAGE *source,     //source image
+                                  inT32 xstart,      //start coords
+                                  inT32 ystart,
+                                  inT32 xext,        //extent to copy
+                                  inT32 yext,
+                                  IMAGE *dest,       //destination image
+                                  inT32 xdest,       //destination coords
+                                  inT32 ydest,
+                                  inT32 scale,       //reduction factor
+                                  BOOL8 adjust_grey  //shift to new bpp
+                                 ) {
+  inT8 shift;                    //shift factor
+  inT32 xfactor;                 //run on x coord
+  inT32 divisor;                 //total cell area
+  inT32 xindex, yindex;          //into averaging square
+  inT32 xcoord;                  //current x coord
+  inT32 destext;                 //destination size
+  inT32 yoffset;                 //current adjusted offset
+  uinT8 *pixel;                  //ptr to source pixels
+  inT32 *sums;                   //ptr to sums array
+  IMAGELINE copyline;            //copy of line
+  inT32 *linesums;               //averaging sums
+
+  if (xstart < 0 || ystart < 0 || xdest < 0 || ydest < 0)
+    return;
+  if (xext <= 0)
+    xext = source->xsize;        //default to all
+  if (xext > source->xsize - xstart)
+                                 //clip to smallest
+      xext = source->xsize - xstart;
+  if (xext > (dest->xsize - xdest) * scale)
+    xext = (dest->xsize - xdest) * scale;
+  if (yext <= 0)
+    yext = source->ysize;        //default to all
+  if (yext > source->ysize - ystart)
+                                 //clip to smallest
+      yext = source->ysize - ystart;
+  if (yext > (dest->ysize - ydest) * scale)
+    yext = (dest->ysize - ydest) * scale;
+  if (xext <= 0 || yext <= 0)
+    return;                      //nothing to do
+
+  xfactor = xext % scale;        //left overs
+  if (xfactor == 0)
+    xfactor = scale;
+                                 //destination pixels
+  destext = (xext + scale - 1) / scale;
+  if (adjust_grey)
+                                 //shift factor
+    shift = dest->bps - source->bps;
+  else
+    shift = 0;                   //no adjustment
+  linesums = new inT32[destext * source->bytespp];
+
+  for (yoffset = 0; yoffset < yext; ydest++) {
+    source->check_legal_access (xstart, ystart + yoffset, xext);
+    dest->check_legal_access (xdest, ydest, destext);
+    for (xindex = destext * source->bytespp - 1; xindex >= 0; xindex--)
+      linesums[xindex] = 0;      //zero sums
+    for (yindex = 0; yindex < scale
+    && ystart + yoffset < source->ysize; yindex += 3) {
+      source->fast_get_line (xstart, ystart + yoffset, xext, &copyline);
+      pixel = copyline.pixels;   //start of line
+      if (source->bpp == 24) {
+        for (xcoord = 1, sums = linesums; xcoord < destext;
+        xcoord++, sums += 3) {
+          for (xindex = 0; xindex < scale; xindex += 2) {
+            *sums += *pixel++;
+            *(sums + 1) += *pixel++;
+            *(sums + 2) += *pixel++;
+            pixel += 3;
+          }
+          if (scale & 1)
+            pixel -= 3;          //correct position
+        }
+        for (xindex = 0; xindex < xfactor; xindex += 2) {
+          *sums += *pixel++;
+          *(sums + 1) += *pixel++;
+          *(sums + 2) += *pixel++;
+          pixel += 3;
+        }
+      }
+      else {
+        for (xcoord = 1, sums = linesums; xcoord < destext;
+        xcoord++, sums++) {
+          for (xindex = 0; xindex < scale; xindex += 2) {
+            *sums += *pixel;
+            pixel += 2;
+          }
+          if (scale & 1)
+            pixel--;             //correct position
+        }
+        for (xindex = 0; xindex < xfactor; xindex += 2) {
+          *sums += *pixel;
+          pixel += 2;
+        }
+      }
+      yoffset += 3;              //every 3 lines
+    }
+    if (yindex > scale)
+      yoffset -= yindex - scale; //back on right scale
+    copyline.init ();            //set pixels back to array
+    copyline.bpp = source->bpp;
+    pixel = copyline.pixels;
+                                 //pixels in block
+    divisor = ((yindex + 2) / 3) * ((scale + 1) / 2);
+    if (shift <= 0) {
+      divisor <<= (-shift);      //do greyscale correction
+      for (sums = linesums, xindex = (destext - 1) * source->bytespp;
+        xindex > 0; xindex--)
+                                 //turn to destination value
+      *pixel++ = (uinT8) (*sums++ / divisor);
+      for (xindex = source->bytespp; xindex > 0; xindex--)
+        *pixel++ = *sums++
+          / (((yindex + 2) / 3) * ((xfactor + 1) / 2) << (-shift));
+      //lastone different
+    }
+    else {
+      for (sums = linesums, xindex = (destext - 1) * source->bytespp;
+        xindex > 0; xindex--)
+      *pixel++ = (uinT8) ((*sums++ << shift) / divisor);
+      //destination value
+      for (xindex = source->bytespp; xindex > 0; xindex--)
+                                 //last one different
+        *pixel++ = (*(sums++) << shift) / (((yindex + 2) / 3) * ((xfactor + 1) / 2));
+    }
+                                 //put in destination
+    dest->put_line (xdest, ydest, destext, &copyline, 0);
+  }
+  delete linesums;
+}
+
+
+/**********************************************************************
+ * reduce_sub_image
+ *
+ * Reduce a portion of one image to a portion of another image.
+ * If the bpps are different, the position of the most significant
+ * bit is preserved.
+ **********************************************************************/
+
+DLLSYM void reduce_sub_image(                   //reduce rectangle
+                             IMAGE *source,     //source image
+                             inT32 xstart,      //start coords
+                             inT32 ystart,
+                             inT32 xext,        //extent to copy
+                             inT32 yext,
+                             IMAGE *dest,       //destination image
+                             inT32 xdest,       //destination coords
+                             inT32 ydest,
+                             inT32 scale,       //reduction factor
+                             BOOL8 adjust_grey  //shift to new bpp
+                            ) {
+  inT8 shift;                    //shift factor
+  inT32 xfactor;                 //run on x coord
+  inT32 divisor;                 //total cell area
+  inT32 div2;                    //total cell area divided by 2
+  inT32 xindex, yindex;          //into averaging square
+  inT32 xcoord;                  //current x coord
+  inT32 destext;                 //destination size
+  inT32 yoffset;                 //current adjusted offset
+  uinT8 *pixel;                  //ptr to source pixels
+  inT32 *sums;                   //ptr to sums array
+  IMAGELINE copyline;            //copy of line
+  inT32 *linesums;               //averaging sums
+
+  if (xstart < 0 || ystart < 0 || xdest < 0 || ydest < 0)
+    return;
+  if (xext <= 0)
+    xext = source->xsize;        //default to all
+  if (xext > source->xsize - xstart)
+                                 //clip to smallest
+      xext = source->xsize - xstart;
+  if (xext > (dest->xsize - xdest) * scale)
+    xext = (dest->xsize - xdest) * scale;
+  if (yext <= 0)
+    yext = source->ysize;        //default to all
+  if (yext > source->ysize - ystart)
+                                 //clip to smallest
+      yext = source->ysize - ystart;
+  if (yext > (dest->ysize - ydest) * scale)
+    yext = (dest->ysize - ydest) * scale;
+  if (xext <= 0 || yext <= 0)
+    return;                      //nothing to do
+
+  xfactor = xext % scale;        //left overs
+  if (xfactor == 0)
+    xfactor = scale;
+                                 //destination pixels
+  destext = (xext + scale - 1) / scale;
+  if (adjust_grey)
+                                 //shift factor
+    shift = dest->bps - source->bps;
+  else
+    shift = 0;                   //no adjustment
+  linesums = new inT32[destext * source->bytespp];
+
+  for (yoffset = 0; yoffset < yext; ydest++) {
+    source->check_legal_access (xstart, ystart + yoffset, xext);
+    dest->check_legal_access (xdest, ydest, destext);
+    for (xindex = 0; xindex < (destext) * source->bytespp; xindex++)
+      linesums[xindex] = 0;      //zero sums
+    for (yindex = 0; yindex < scale && ystart + yoffset < source->ysize;
+    yindex++) {
+      source->fast_get_line (xstart, ystart + yoffset, xext, &copyline);
+      pixel = copyline.pixels;   //start of line
+      if (source->bpp == 24) {
+        for (xcoord = 1, sums = linesums; xcoord < destext;
+        xcoord++, sums += 3) {
+          for (xindex = 0; xindex < scale; xindex++) {
+            *sums += *pixel++;
+            *(sums + 1) += *pixel++;
+            *(sums + 2) += *pixel++;
+          }
+        }
+        for (xindex = 0; xindex < xfactor; xindex++) {
+          *sums += *pixel++;
+          *(sums + 1) += *pixel++;
+          *(sums + 2) += *pixel++;
+        }
+      }
+      else {
+        for (xcoord = 1, sums = linesums; xcoord < destext;
+        xcoord++, sums++) {
+          for (xindex = 0; xindex < scale; xindex++)
+            *sums += *pixel++;
+        }
+        for (xindex = 0; xindex < xfactor; xindex++)
+          *sums += *pixel++;
+      }
+      yoffset++;                 //next line
+    }
+    copyline.init ();            //set pixels back to array
+    copyline.set_bpp (source->bpp);
+    pixel = copyline.pixels;
+    divisor = yindex * scale;
+    if (divisor == 0) {
+      tprintf
+        ("Impossible:divisor=0!, yindex=%d, scale=%d, yoffset=%d,yext=%d\n",
+        yindex, scale, yoffset, yext);
+      break;
+    }
+    if (shift <= 0) {
+      divisor <<= (-shift);      //do greyscale correction
+      div2 = divisor / 2;
+      for (sums = linesums, xindex = (destext - 1) * source->bytespp;
+        xindex > 0; xindex--)
+      *pixel++ = (uinT8) ((div2 + *sums++) / divisor);
+      //turn to destination value
+      div2 = (yindex * xfactor << (-shift)) / 2;
+      for (xindex = source->bytespp; xindex > 0; xindex--)
+        *pixel++ =
+          (uinT8) ((div2 + *sums++) / (yindex * xfactor << (-shift)));
+      //lastone different
+    }
+    else {
+      div2 = divisor / 2;
+      for (sums = linesums, xindex = (destext - 1) * source->bytespp;
+        xindex > 0; xindex--)
+      *pixel++ = (uinT8) ((div2 + (*sums++ << shift)) / divisor);
+      //destination value
+      div2 = (yindex * xfactor) / 2;
+      for (xindex = source->bytespp; xindex > 0; xindex--)
+        *pixel++ =
+          (uinT8) ((div2 + (*sums++ << shift)) / (yindex * xfactor));
+      //last one different
+    }
+                                 //put in destination
+    dest->put_line (xdest, ydest, destext, &copyline, 0);
+  }
+  delete linesums;
+}
+
+
+/**********************************************************************
+ * invert_image
+ *
+ * Invert the given image (the slow way.)
+ **********************************************************************/
+
+DLLSYM void invert_image(              /*invert the image */
+                         IMAGE *image  /*image ot invert */
+                        ) {
+  uinT8 mask;                    //bit mask
+  uinT8 bytespp;                 //bytes per pixel
+  inT32 xsize, ysize;            /*size of image */
+  inT32 xindex, yindex;          /*index into image */
+  uinT8 *pixel;                  /*current pixel */
+  IMAGELINE line;                /*line of image */
+
+  bytespp = image->get_bpp () == 24 ? 3 : 1;
+  xsize = image->get_xsize ();   /*find sizes */
+  ysize = image->get_ysize ();
+                                 //pixel mask
+  mask = (1 << image->get_bpp ()) - 1;
+                                 /*do each line */
+  for (yindex = ysize - 1; yindex >= 0; yindex--) {
+    image->fast_get_line (0, yindex, xsize, &line);
+    for (pixel = line.pixels, xindex = xsize * bytespp; xindex > 0;
+      xindex--) {
+      *pixel = (*pixel) ^ mask;  //invert image only
+      ++pixel;
+    }
+                                 /*put it back */
+    image->fast_put_line (0, yindex, xsize, &line);
+  }
+}
+
+
+/**********************************************************************
+ * bias_sub_image
+ *
+ * Add a constant to a portion of an image.
+ **********************************************************************/
+
+DLLSYM void bias_sub_image(                //bias rectangle
+                           IMAGE *source,  //source image
+                           inT32 xstart,   //start coords
+                           inT32 ystart,
+                           inT32 xext,     //extent to copy
+                           inT32 yext,
+                           uinT8 bias      //number to add
+                          ) {
+  IMAGELINE copyline;            //copy of line
+  uinT8 *copy;                   //source pointer
+  inT32 pixel;                   //pixel index
+  inT32 y;                       //line index
+  uinT8 bytespp;                 //bytes per pixel
+
+  if (xstart < 0 || ystart < 0)
+    return;
+  if (xext <= 0)
+    xext = source->get_xsize (); //default to all
+  if (xext > source->get_xsize () - xstart)
+                                 //clip to smallest
+    xext = source->get_xsize () - xstart;
+  if (yext <= 0)
+    yext = source->get_ysize (); //default to all
+  if (yext > source->get_ysize () - ystart)
+                                 //clip to smallest
+    yext = source->get_ysize () - ystart;
+  if (xext <= 0 || yext <= 0)
+    return;                      //nothing to do
+
+  bytespp = source->get_bpp () == 24 ? 3 : 1;
+  for (y = 0; y < yext; y++) {
+    source->check_legal_access (xstart, ystart + y, xext);
+    source->fast_get_line (xstart, ystart + y, xext, &copyline);
+    for (pixel = xext * bytespp, copy = copyline.pixels; pixel > 0;
+      pixel--, copy++)
+    *copy += bias;               //add bias
+
+    source->fast_put_line (xstart, ystart + y, xext, &copyline);
+  }
+}
+
+
+/**********************************************************************
+ * starbase_to_normal
+ *
+ * Copy a portion of one image to a portion of another image.
+ * This function maps the colour tables used on the screen to
+ * greyscale values in the way "normally" expected.
+ **********************************************************************/
+
+DLLSYM void starbase_to_normal(                     //copy rectangle
+                               IMAGE *source,       //source image
+                               inT32 xstart,        //start coords
+                               inT32 ystart,
+                               inT32 xext,          //extent to copy
+                               inT32 yext,
+                               IMAGE *dest,         //destination image
+                               inT32 xdest,         //destination coords
+                               inT32 ydest,
+                               BOOL8 preserve_grey  //shift to new bpp
+                              ) {
+  IMAGELINE copyline;            //copy of line
+  uinT8 *copy;                   //source pointer
+  inT8 shift4;                   //shift factor
+  inT8 shift6;                   //shift factor
+  inT8 colour_shift;             //shift of colours
+  uinT8 white_level;             //dest white value
+  inT32 pixel;                   //pixel index
+  inT32 y;                       //line index
+  inT32 yoffset;                 //current adjusted offset
+  inT8 srcppb;                   //pixels per byte
+
+  if (xstart < 0 || ystart < 0 || xdest < 0 || ydest < 0)
+    return;
+  if (xext <= 0)
+    xext = source->get_xsize (); //default to all
+  if (xext > source->get_xsize () - xstart)
+                                 //clip to smallest
+    xext = source->get_xsize () - xstart;
+  if (xext > dest->get_xsize () - xdest)
+    xext = dest->get_xsize () - xdest;
+  if (yext <= 0)
+    yext = source->get_ysize (); //default to all
+  if (yext > source->get_ysize () - ystart)
+                                 //clip to smallest
+    yext = source->get_ysize () - ystart;
+  if (yext > dest->get_ysize () - ydest)
+    yext = dest->get_ysize () - ydest;
+  if (xext <= 0 || yext <= 0)
+    return;                      //nothing to do
+
+                                 //pixels per byte
+  srcppb = 8 / source->get_bpp ();
+  shift4 = 4 - dest->get_bpp (); //for different bpps
+  shift6 = 6 - dest->get_bpp ();
+                                 //for grey preserve
+  colour_shift = 8 - dest->get_bpp ();
+  white_level = dest->get_white_level ();
+  for (y = 0; y < yext; y++) {
+    if (ystart >= ydest)
+      yoffset = y;               //top down
+    else
+      yoffset = yext - y - 1;    //bottom up
+    source->check_legal_access (xstart, ystart + yoffset, xext);
+    dest->check_legal_access (xdest, ydest + yoffset, xext);
+    source->get_line (xstart, ystart + yoffset, xext, &copyline, 0);
+    for (pixel = 0, copy = copyline.pixels; pixel < xext; pixel++) {
+      if (*copy < FIXED_COLOURS && preserve_grey)
+        *copy = grey_scales[*copy] >> colour_shift;
+      else if (*copy < FIXED_COLOURS) {
+        if (*copy == BLACK_PIX)
+          *copy = white_level;   //black->white
+        else
+          *copy = 0;             //others->black
+      }
+      else if (*copy >= MIN_4BIT && *copy < MAX_4BIT) {
+        if (shift4 < 0)
+          *copy = (*copy - MIN_4BIT) << (-shift4);
+        else
+          *copy = (*copy - MIN_4BIT) >> shift4;
+      }
+      else if (*copy >= MIN_6BIT && *copy < MAX_6BIT) {
+        if (shift6 < 0)
+          *copy = (*copy - MIN_6BIT) << (-shift6);
+        else
+          *copy = (*copy - MIN_6BIT) >> shift6;
+      }
+      else {
+        *copy = white_level;     //white the rest
+      }
+      copy++;
+    }
+    dest->put_line (xdest, ydest + yoffset, xext, &copyline, 0);
+  }
+}
+
+
+/**********************************************************************
+ * fast_get_line
+ *
+ * Get a line of image into the supplied image line buffer.
+ * The image is converted to 8bpp by simple assignment.
+ * If the image is aleady 8 or 6bpp, no copy is done and a pointer
+ * to the correct image section is put in the line buffer.
+ **********************************************************************/
+
+void IMAGE::fast_get_line(                    //get image line
+                          inT32 x,            //coord to start at
+                          inT32 y,            //line to get
+                          inT32 width,        //no of pixels to get
+                          IMAGELINE *linebuf  //line to copy to
+                         ) {
+  if (width > 0 && bpp > 4) {
+    check_legal_access(x, y, width);
+                                 //get pointer only
+    linebuf->pixels = image + xdim * (ymax - 1 - y) + x * bytespp;
+  }
+  else
+                                 //just copy it
+    this->get_line (x, y, width, linebuf, 0);
+  linebuf->bpp = bpp;
+}
+
+
+/**********************************************************************
+ * get_line
+ *
+ * Get a line of image into the supplied image line buffer.
+ * The image is converted to 8bpp by simple assignment.
+ **********************************************************************/
+
+void IMAGE::get_line(                     //get image line
+                     inT32 x,             //coord to start at
+                     inT32 y,             //line to get
+                     inT32 width,         //no of pixels to get
+                     IMAGELINE *linebuf,  //line to copy to
+                     inT32 margins        //size of margins
+                    ) {
+  uinT8 *src;                    //source pointer
+  uinT8 *dest;                   //destination pointer
+  uinT8 *unpacksrc;              //unpacking pointer
+  inT8 bit;                      //bit index
+  inT8 pixperbyte;               //pixels per byte
+  uinT8 white;                   //white colour
+  inT32 pixel;                   //pixel index
+
+                                 //test coords
+  this->check_legal_access (x, y, width);
+  if (width > xsize - x)
+    width = xsize - x;           //clip to image
+  width *= bytespp;
+  linebuf->init (width + margins * bytespp * 2);
+  linebuf->bpp = bpp;
+                                 //start of line
+  src = image + xdim * (ymax - 1 - y);
+  dest = linebuf->line;          //destination line
+  linebuf->pixels = dest;
+  white = (1 << bpp) - 1;        //max value of pixel
+  for (pixel = margins * bytespp; pixel > 0; pixel--) {
+    *dest++ = white;             //margins are white
+  }
+  if (width > 0) {
+    if (bpp > 4) {
+      src += x;                  //offset
+                                 //easy way
+      memmove (dest, src, (unsigned) width);
+    }
+    else if (bpp == 4) {
+      src += x / 2;              //offset on line
+      if (x & 1) {
+                                 //get coded nibble
+        *dest++ = bpp4table[*src++][1];
+        width--;
+      }
+      while (width >= 2) {
+                                 //get coded bits
+        unpacksrc = bpp4table[*src++];
+        *dest++ = *unpacksrc++;
+        *dest++ = *unpacksrc++;  //copy nibbles
+        width -= 2;
+      }
+      if (width) {
+                                 //get coded nibble
+        *dest++ = bpp4table[*src++][0];
+      }
+    }
+    else if (bpp == 2) {
+      pixperbyte = 4;
+      src += x / 4;              //offset on line
+      bit = (inT8) (x % 4);      //offset in byte
+      width += bit;
+      while (width > 0) {        //until all done
+        if (width < pixperbyte)
+                                 //less on last byte
+          pixperbyte = (inT8) width;
+                                 //get coded bits
+        unpacksrc = &bpp2table[*src++][bit];
+        for (; bit < pixperbyte; bit++)
+          *dest++ = *unpacksrc++;//copy bytes
+        width -= pixperbyte;
+        bit = 0;
+      }
+    }
+    else {
+      pixperbyte = 8;
+      src += x / 8;              //offset on line
+      bit = (inT8) (x % 8);      //offset in byte
+      width += bit;
+      while (width > 0) {        //until all done
+        if (width < pixperbyte)
+                                 //less on last byte
+          pixperbyte = (inT8) width;
+                                 //get coded bits
+        unpacksrc = &bpp1table[*src++][bit];
+        for (; bit < pixperbyte; bit++)
+          *dest++ = *unpacksrc++;//copy bytes
+        width -= pixperbyte;
+        bit = 0;
+      }
+    }
+  }
+  for (pixel = margins * bytespp; pixel > 0; pixel--) {
+    *dest++ = white;             //margins are white
+  }
+}
+
+
+/**********************************************************************
+ * get_column
+ *
+ * Get a column of image into the supplied image line buffer.
+ * The image is converted to 8bpp by simple assignment.
+ **********************************************************************/
+
+void IMAGE::get_column(                     //get image column
+                       inT32 x,             //coord to start at
+                       inT32 y,             //line to get
+                       inT32 height,        //no of pixels to get
+                       IMAGELINE *linebuf,  //line to copy to
+                       inT32 margins        //size of margins
+                      ) {
+  uinT8 *src;                    //source pointer
+  uinT8 *dest;                   //destination pointer
+  inT8 bit;                      //bit index
+  inT8 pixperbyte;               //pixels per byte
+  uinT8 white;                   //white colour
+  inT32 pixel;                   //pixel index
+
+                                 //test coords
+  this->check_legal_access (x, y, 1);
+                                 //test coords
+  this->check_legal_access (x, y + height - 1, 1);
+  if (height > ysize - y)
+    height = ysize - y;          //clip to image
+  linebuf->init (height * bytespp + margins * bytespp * 2);
+                                 //start of line
+  src = image + xdim * (ymax - 1 - y);
+  dest = linebuf->line;          //destination line
+  linebuf->pixels = dest;
+  white = (1 << bpp) - 1;        //max value of pixel
+  for (pixel = margins * bytespp; pixel > 0; pixel--) {
+    *dest++ = white;             //margins are white
+  }
+  if (height > 0) {
+    if (bpp == 24) {
+      src += x * bytespp;        //offset
+      for (; height > 0; --height) {
+        *dest++ = *src;          //copy bytes
+        *dest++ = *(src + 1);
+        *dest++ = *(src + 2);
+        src -= xdim;
+      }
+    }
+    else if (bpp > 4) {
+      src += x;
+      for (; height > 0; --height) {
+        *dest++ = *src;          //copy bytes
+        src -= xdim;
+      }
+    }
+    else if (bpp == 4) {
+      src += x / 2;              //offset on line
+      if (x & 1) {
+        for (; height > 0; --height) {
+                                 //get coded nibble
+          *dest++ = bpp4table[*src][1];
+          src -= xdim;
+        }
+      }
+      else {
+        for (; height > 0; --height) {
+                                 //get coded nibble
+          *dest++ = bpp4table[*src][0];
+          src -= xdim;
+        }
+      }
+    }
+    else if (bpp == 2) {
+      pixperbyte = 4;
+      src += x / 4;              //offset on line
+      bit = (inT8) (x % 4);      //offset in byte
+      for (; height > 0; --height) {
+                                 //get coded bits
+        *dest++ = bpp2table[*src][bit];
+        src -= xdim;
+      }
+    }
+    else {
+      pixperbyte = 8;
+      src += x / 8;              //offset on line
+      bit = (inT8) (x % 8);      //offset in byte
+      for (; height > 0; --height) {
+                                 //get coded bits
+        *dest++ = bpp1table[*src][bit];
+        src -= xdim;
+      }
+    }
+  }
+  for (pixel = margins * bytespp; pixel > 0; pixel--) {
+    *dest++ = white;             //margins are white
+  }
+}
+
+
+/**********************************************************************
+ * fast_put_line
+ *
+ * Put a line buffer back into the image.
+ * If the line buffer merely points back into the image, nothing is done.
+ * Otherwise, put_line is used to copy the line back.
+ **********************************************************************/
+
+void IMAGE::fast_put_line(                    //put image line
+                          inT32 x,            //coord to start at
+                          inT32 y,            //line to get
+                          inT32 width,        //no of pixels to put
+                          IMAGELINE *linebuf  //line to copy to
+                         ) {
+  if (width > 0 && (bpp <= 4 || linebuf->pixels == linebuf->line))
+                                 //just copy it
+    put_line (x, y, width, linebuf, 0);
+}
+
+
+/**********************************************************************
+ * put_line
+ *
+ * Put the supplied line buffer into the image.
+ * The image is converted from 8bpp by simple assignment.
+ **********************************************************************/
+
+void IMAGE::put_line(                     //put image line
+                     inT32 x,             //coord to start at
+                     inT32 y,             //line to get
+                     inT32 width,         //no of pixels to get
+                     IMAGELINE *linebuf,  //line to copy to
+                     inT32 margins        //margins in buffer
+                    ) {
+  uinT8 *src;                    //source pointer
+  uinT8 *dest;                   //destination pointer
+  inT8 bit;                      //bit index
+  uinT8 pixel;                   //collected bits
+  inT8 pixperbyte;               //pixels in a byte
+  inT8 bytesperpix;              //in source
+
+  this->check_legal_access (x, y, width);
+  if (width > xsize - x)
+    width = xsize - x;           //clip to image
+  if (width <= 0)
+    return;                      //nothing to do
+                                 //source line
+  src = linebuf->pixels + margins;
+                                 //start of line
+  dest = image + xdim * (ymax - 1 - y);
+
+  if (linebuf->bpp == 24) {
+    src++;
+    bytesperpix = 3;
+  }
+  else
+    bytesperpix = 1;
+  if (bpp == 24 && linebuf->bpp == 24) {
+    dest += x * bytespp;
+    width *= bytespp;
+    memmove (dest, src - 1, (unsigned) width);
+  }
+  else if (bpp == 24) {
+    src--;
+    dest += x * bytespp;
+    while (width > 0) {
+      pixel = *src++;
+      *dest++ = pixel;
+      *dest++ = pixel;
+      *dest++ = pixel;
+      width--;
+    }
+  }
+  else if (bpp > 4) {
+    dest += x;                   //offset
+    if (linebuf->bpp == 24) {
+      while (width > 0) {
+        *dest++ = *src;
+        src += 3;
+        width--;
+      }
+    }
+    else
+                                 //easy way
+      memmove (dest, src, (unsigned) width);
+  }
+  else if (bpp == 4) {
+    dest += x / 2;               //offset on line
+    if (x & 1) {
+      *dest &= 0xf0;             //clean odd byte
+      *dest++ |= *src & 0x0f;    //and copy it
+      src += bytesperpix;
+      width--;
+    }
+    while (width >= 2) {
+      pixel = *src << 4;         //left pixel
+      src += bytesperpix;
+      pixel |= *src & 0x0f;      //right pixel
+      src += bytesperpix;
+      *dest++ = pixel;
+      width -= 2;
+    }
+    if (width) {
+      *dest &= 0x0f;             //clean odd byte
+      *dest |= *src << 4;
+    }
+  }
+  else if (bpp == 2) {
+    pixperbyte = 4;
+    dest += x / 4;               //offset on line
+    bit = (inT8) (x % 4);        //offset in byte
+    width += bit;
+    pixel = *dest >> (8 - bit - bit);
+    while (width >= 4) {         //until all done
+      for (; bit < 4; bit++) {
+        pixel <<= 2;             //make space for new one
+        pixel |= *src & 3;
+        src += bytesperpix;
+      }
+      *dest++ = pixel;           //new pixel
+      width -= 4;
+      bit = 0;
+    }
+    if (width > 0) {             //until all done
+      for (bit = 0; bit < width; bit++) {
+        pixel <<= 2;             //make space for new one
+        pixel |= *src & 3;
+        src += bytesperpix;
+      }
+      pixel <<= (8 - bit - bit); //shift rest
+                                 //keep trainling bits
+      pixel |= *dest & ((1 << (8 - bit - bit)) - 1);
+      *dest++ = pixel;           //new pixel
+    }
+  }
+  else {
+    pixperbyte = 8;
+    dest += x / 8;               //offset on line
+    bit = (inT8) (x % 8);        //offset in byte
+    width += bit;
+    pixel = *dest >> (8 - bit);
+    while (width >= 8) {         //until all done
+      for (; bit < 8; bit++) {
+        pixel <<= 1;             //make space for new one
+        pixel |= *src & 1;
+        src += bytesperpix;
+      }
+      *dest++ = pixel;           //new pixel
+      width -= 8;
+      bit = 0;
+    }
+    width -= bit;
+    if (width > 0) {             //until all done
+      while (width > 0) {
+        pixel <<= 1;             //make space for new one
+        pixel |= *src & 1;
+        src += bytesperpix;
+        bit++;
+        width--;
+      }
+      pixel <<= (8 - bit);       //shift rest
+                                 //keep trainling bits
+      pixel |= *dest & ((1 << (8 - bit)) - 1);
+      *dest++ = pixel;           //new pixel
+    }
+  }
+}
+
+
+/**********************************************************************
+ * put_column
+ *
+ * Put the supplied column buffer into the image.
+ * The image is converted from 8bpp by simple assignment.
+ **********************************************************************/
+
+void IMAGE::put_column(                     //put image column
+                       inT32 x,             //coord to start at
+                       inT32 y,             //line to get
+                       inT32 height,        //no of pixels to get
+                       IMAGELINE *linebuf,  //line to copy to
+                       inT32 margins        //margins in buffer
+                      ) {
+  uinT8 *src;                    //source pointer
+  uinT8 *dest;                   //destination pointer
+  inT8 bit;                      //bit index
+  uinT8 pixel;                   //collected bits
+  inT8 bytesperpix;              //in source
+
+  this->check_legal_access (x, y, 1);
+  this->check_legal_access (x, y + height - 1, 1);
+  if (height > ysize - y)
+    height = ysize - y;          //clip to image
+  if (height <= 0)
+    return;                      //nothing to do
+                                 //source line
+  src = linebuf->pixels + margins;
+                                 //start of line
+  dest = image + xdim * (ymax - 1 - y);
+
+  if (linebuf->bpp == 24) {
+    src++;
+    bytesperpix = 3;
+  }
+  else
+    bytesperpix = 1;
+
+  if (bpp == 24 && linebuf->bpp == 24) {
+    dest += x * bytesperpix;
+    src--;
+    for (; height > 0; --height) {
+      *dest = *src++;
+      *(dest + 1) = *src++;
+      *(dest + 2) = *src++;
+      dest -= xdim;
+    }
+  }
+  else if (bpp == 24) {
+    src--;
+    dest += x * bytesperpix;
+    for (; height > 0; --height) {
+      pixel = *src++;
+      *dest = pixel;
+      *(dest + 1) = pixel;
+      *(dest + 2) = pixel;
+      dest -= xdim;
+    }
+  }
+  else if (bpp > 4) {
+    dest += x;                   //offset
+    for (; height > 0; --height) {
+      *dest = *src;
+      src += bytesperpix;
+      dest -= xdim;
+    }
+  }
+  else if (bpp == 4) {
+    dest += x / 2;               //offset on line
+    if (x & 1) {
+      for (; height > 0; --height) {
+        *dest &= 0xf0;           //clean odd byte
+        *dest |= *src & 0x0f;    //and copy it
+        src += bytesperpix;
+        dest -= xdim;
+      }
+    }
+    else {
+      for (; height > 0; --height) {
+        *dest &= 0x0f;           //clean odd byte
+        *dest |= *src << 4;
+        src += bytesperpix;
+        dest -= xdim;
+      }
+    }
+  }
+  else if (bpp == 2) {
+    dest += x / 4;               //offset on line
+    bit = (inT8) (x % 4);        //offset in byte
+    bit = 6 - bit - bit;         //bit shift
+    pixel = ~(3 << bit);         //mask
+    for (; height > 0; --height) {
+                                 //change 2 bits
+      *dest = (*dest & pixel) | ((*src & 3) << bit);
+      src += bytesperpix;
+      dest -= xdim;
+    }
+  }
+  else {
+    dest += x / 8;               //offset on line
+    bit = (inT8) (x % 8);        //offset in byte
+    bit = 7 - bit;
+    pixel = ~(1 << bit);
+    for (; height > 0; --height) {
+                                 //change 1 bit
+      *dest = (*dest & pixel) | ((*src & 1) << bit);
+      src += bytesperpix;
+      dest -= xdim;
+    }
+  }
+}
+
+
+/**********************************************************************
+ * check_legal_access
+ *
+ * Check that x,y are within the bounds of the image.
+ * Call bufread if necessary to get the image into memory.
+ **********************************************************************/
+
+void IMAGE::check_legal_access(            //check coords are legal
+                               inT32 x,    //coords to check
+                               inT32 y,
+                               inT32 xext  //xextent
+                              ) {
+  if (x < 0 || x >= xsize || y < 0 || y >= ysize || x + xext > xsize)
+    BADIMAGECOORDS.error ("IMAGE::check_legal_access",
+      ABORT, "(%d+%d,%d)", x, xext, y);
+  if (y >= ymax)
+    BADIMAGESEEK.error ("IMAGE::check_legal_access", ABORT, "(%d,%d)", x, y);
+  if (y < ymin)
+    bufread(y);  //read some more
+}
+
+#ifdef HAVE_LIBLEPT
+// ONLY available if you have Leptonica installed.
+/**********************************************************************
+ * ToPix
+ *
+ * Make a Pix from this image.
+ **********************************************************************/
+Pix* IMAGE::ToPix() {
+  int width = this->get_xsize();
+  int height = this->get_ysize();
+  int bpp = this->get_bpp();
+  Pix* pix = pixCreate(width, height, bpp == 24 ? 32 : bpp);
+  uint32* data = pixGetData(pix);
+  IMAGELINE line;
+  if (bpp == 24) {
+    line.init(width * 3);
+    line.set_bpp(24);
+  } else {
+    line.init(width);
+  }
+  switch (bpp) {
+  case 1:
+    for (int y = height - 1 ; y >= 0; --y) {
+      this->get_line(0, y, width, &line, 0);
+      for (int x = 0; x < width; ++x) {
+        if (line.pixels[x])
+          CLEAR_DATA_BIT(data, x);
+        else
+          SET_DATA_BIT(data, x);
+      }
+      data += pixGetWpl(pix);
+    }
+    break;
+
+  case 8:
+    // Greyscale just copies the bytes in the right order.
+    for (int y = height - 1 ; y >= 0; --y) {
+      this->get_line(0, y, width, &line, 0);
+      for (int x = 0; x < width; ++x)
+        SET_DATA_BYTE(data, x, line.pixels[x]);
+      data += pixGetWpl(pix);
+    }
+    break;
+
+  case 24:
+    // Put the colors in the correct places in the line buffer.
+    for (int y = height - 1 ; y >= 0; --y) {
+      this->get_line(0, y, width, &line, 0);
+      for (int x = 0; x < width; ++x, ++data) {
+        SET_DATA_BYTE(data, COLOR_RED, line[x][RED_PIX]);
+        SET_DATA_BYTE(data, COLOR_GREEN, line[x][GREEN_PIX]);
+        SET_DATA_BYTE(data, COLOR_BLUE, line[x][BLUE_PIX]);
+      }
+    }
+    break;
+
+  default:
+    tprintf("Cannot convert image to Pix with bpp = %d\n", bpp);
+  }
+  return pix;
+}
+
+/**********************************************************************
+ * FromPix
+ *
+ * Copy from the given Pix into this image.
+ **********************************************************************/
+void IMAGE::FromPix(const Pix* src_pix) {
+  // Leptonica doesn't const its inputs, but we don't change the input.
+  Pix* pix = const_cast<Pix*>(src_pix);
+  Pix* destroy_this_pix = NULL;
+
+  int depth = pixGetDepth(pix);
+  if (depth > 1 && depth < 8) {
+    // Convert funny depths to 8 bit.
+    destroy_this_pix = pixConvertTo8(pix, false);
+    pix = destroy_this_pix;
+    depth = pixGetDepth(pix);
+  }
+  int width = pixGetWidth(pix);
+  int height = pixGetHeight(pix);
+  const uint32* data = pixGetData(pix);
+  this->create(width, height, depth == 32 ? 24 : depth);
+  // For each line in the image, fill the IMAGELINE class and put it into the
+  // destination image. Note that Tesseract stores images with the
+  // bottom at y=0 and 0 is always black in grey and binary.
+  IMAGELINE line;
+  if (depth == 32) {
+    line.init(width * 3);
+    line.set_bpp(24);
+  } else {
+    line.init(width);
+  }
+  switch (depth) {
+  case 1:
+    // Binary images just flip the data bit.
+    for (int y = height - 1 ; y >= 0; --y) {
+      for (int x = 0; x < width; ++x)
+        line.pixels[x] = GET_DATA_BIT(data, x) ^ 1;
+      this->put_line(0, y, width, &line, 0);
+      data += pixGetWpl(pix);
+    }
+    break;
+
+  case 8:
+    // Greyscale just copies the bytes in the right order.
+    for (int y = height - 1 ; y >= 0; --y) {
+      for (int x = 0; x < width; ++x)
+        line.pixels[x] = GET_DATA_BYTE(data, x);
+      this->put_line(0, y, width, &line, 0);
+      data += pixGetWpl(pix);
+    }
+    break;
+
+  case 32:
+    // Put the colors in the correct places in the line buffer.
+    for (int y = height - 1 ; y >= 0; --y) {
+      for (int x = 0; x < width; ++x, ++data) {
+        line[x][RED_PIX] = GET_DATA_BYTE(data, COLOR_RED);
+        line[x][GREEN_PIX] = GET_DATA_BYTE(data, COLOR_GREEN);
+        line[x][BLUE_PIX] = GET_DATA_BYTE(data, COLOR_BLUE);
+      }
+      this->put_line(0, y, width, &line, 0);
+    }
+    break;
+
+  default:
+    tprintf("Cannot convert Pix to image with bpp = %d\n", depth);
+  }
+  if (destroy_this_pix != NULL)
+    pixDestroy(&destroy_this_pix);
+}
+#endif  // HAVE_LIBLEPT
+
+/*************************************************************************
+ * convolver()
+ *
+ * Calls the specified function for each pixel in the image, passing in an m x n
+ * window of the image, centred on the pixel.  The convolution function returns
+ * a new value for the pixel, based on the window.
+ *
+ * At the edges of the image, the window is padded to white pixels.
+ *************************************************************************/
+
+void
+IMAGE::convolver (               //Map fn over window
+inT32 win_width,                 //Window width
+inT32 win_height,                //Window height
+void (*convolve) (               //Conv Function
+uinT8 ** pixels,                 //Of window
+uinT8 bytespp,                   //1 or 3 for colour
+inT32 win_wd,                    //Window width
+inT32 win_ht,                    //Window height
+uinT8 ret_white_value,           //White value to RETURN
+uinT8 * result)                  //Ptr to result pix
+) {
+  IMAGELINE new_row;             //Replacement pixels
+  IMAGELINE *old_rows;           //Rows being processed
+  inT32 oldest_imline;           //Next imline to replace
+  uinT8 **window;                //ptrs to pixel rows
+  uinT8 **winmax;                //ptrs to pixel rows
+  uinT8 **win;                   //ptrs to pixel rows
+  inT32 current_row;             //Row being calculated
+  inT32 current_col;             //Col being calculated
+  inT32 row = 0;                 //Next row to get
+
+  inT32 i, j;
+  uinT8 *pix;
+  uinT8 *max;
+  inT32 xmargin = win_width / 2;
+  inT32 ymargin = win_height / 2;
+  uinT8 white = get_white_level ();
+  const uinT8 max_white = 255;
+  float white_scale = (float) 255 / get_white_level ();
+
+  if (((win_width % 2) == 0) ||
+    ((win_height % 2) == 0) ||
+    (win_height < 3) ||
+    (win_width < 3) || (win_height > ysize / 2) || (win_width > xsize / 2))
+    BADWINDOW.error ("IMAGE::convolver",
+      ABORT, "(%d x %d)", win_width, win_height);
+
+  new_row.init (xsize * bytespp);
+  new_row.set_bpp (bpp);
+  old_rows = new IMAGELINE[win_height];
+  for (i = 0; i < win_height; i++) {
+    old_rows[i].init ((xsize + 2 * xmargin) * bytespp);
+    old_rows[i].set_bpp (bpp);
+  }
+
+  window = (uinT8 **) alloc_mem (win_height * sizeof (uinT8 *));
+  winmax = window + win_height;
+
+  /* Make bottom border */
+  for (oldest_imline = 0; oldest_imline < ymargin; oldest_imline++) {
+    pix = old_rows[oldest_imline].pixels;
+    max = pix + (xsize + 2 * xmargin) * bytespp;
+    while (pix < max)
+      *pix++ = max_white;
+  }
+  /* Initialise remaining rows but one*/
+  for (; oldest_imline < win_height - 1; oldest_imline++) {
+    get_line (0, row++, xsize, &old_rows[oldest_imline], xmargin);
+    if (max_white != white) {
+      pix = old_rows[oldest_imline].pixels;
+      max = pix + (xsize + 2 * xmargin) * bytespp;
+      while (pix < max) {
+        *pix = (uinT8) (*pix * white_scale);
+        ++pix;
+      }
+    }
+  }
+
+  /* Image Processing */
+
+  for (current_row = 0; current_row < ysize;) {
+    /* Get next row and re-initialise window array */
+    if (row < ysize) {
+      get_line (0, row++, xsize, &old_rows[oldest_imline], xmargin);
+      if (max_white != white) {
+        pix = old_rows[oldest_imline].pixels;
+        max = pix + (xsize + 2 * xmargin) * bytespp;
+        while (pix < max) {
+          *pix = (uinT8) (*pix * white_scale);
+          ++pix;
+        }
+      }
+    }
+    else {
+      pix = old_rows[oldest_imline].pixels;
+      max = pix + (xsize + 2 * xmargin) * bytespp;
+      while (pix < max)
+        *pix++ = max_white;
+    }
+    oldest_imline++;
+    if (oldest_imline >= win_height)
+      oldest_imline = 0;
+
+    /* Process line */
+    pix = new_row.pixels;
+    for (current_col = 0; current_col < xsize;) {
+      /* Set up window ptrs */
+      if (current_col == 0) {
+        j = oldest_imline;
+        for (i = 0; i < win_height; i++) {
+          window[i] = old_rows[j++].pixels;
+          if (j >= win_height)
+            j = 0;
+        }
+      }
+      else {
+        for (win = window; win < winmax; (*win++) += bytespp);
+        //Move along rows
+      }
+
+      convolve(window, bytespp, win_width, win_height, white, pix);
+      pix += bytespp;
+      current_col++;
+    }
+
+    put_line (0, current_row, xsize, &new_row, 0);
+    new_row.init ();
+    new_row.set_bpp (bpp);
+    current_row++;
+  }
+}