tesseract_bin 1.0.0

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

@@ -0,0 +1,223 @@
+/**********************************************************************
+ * File:			imgbmp.c  (Formerly lz.c)
+ * Description:	bmp image reader/writer.
+ * Author:		Ray Smith
+ * Created:		Tue Jan 06 15:31:25 GMT 1998
+ *
+ * (C) Copyright 1998, Ray Smith.
+ ** 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          <stdio.h>
+#include          "img.h"
+#include          "imgbmp.h"
+
+typedef struct
+{                                // bmfh
+  char bfType1;                  //'B'
+  char bfType2;                  //'M'
+} BMPHEADER0;
+typedef struct
+{                                // bmfh
+  uinT32 bfSize;                 //filesize
+  uinT16 bfReserved1;            //zero
+  uinT16 bfReserved2;            //zero
+  uinT32 bfOffBits;              //offset to bitmap
+} BMPHEADER;
+
+typedef struct
+{                                // bmih
+  uinT32 biSize;                 //size of struct
+  inT32 biWidth;                 //image width
+  inT32 biHeight;                //image height
+  uinT16 biPlanes;               //1
+  uinT16 biBitCount;             //bpp
+  uinT32 biCompression;          //0 for uncompressed
+  uinT32 biSizeImage;            //image size
+  inT32 biXPelsPerMeter;         //res in pp metre
+  inT32 biYPelsPerMeter;
+  uinT32 biClrUsed;              //0 or actual size of colour table
+  uinT32 biClrImportant;         //usually 0
+} BMPHEADER2;
+
+typedef struct
+{                                // rgbq
+  uinT8 rgbBlue;
+  uinT8 rgbGreen;
+  uinT8 rgbRed;
+  uinT8 rgbReserved;             //0
+} WIN32_RGBQUAD;
+
+/**********************************************************************
+ * open_bmp_image
+ *
+ * Read the header of a bmp format image and prepare to read the rest.
+ **********************************************************************/
+
+inT8 open_bmp_image(               //read header
+                    int fd,        //file to read
+                    inT32 *xsize,  //size of image
+                    inT32 *ysize,
+                    inT8 *bpp,     //bits per pixel
+                    inT8 *photo,
+                    inT32 *res     //resolution
+                   ) {
+  uinT32 nread;                  //current bits
+  BMPHEADER0 head0;              //first part of header
+  BMPHEADER head1;               //first part of header
+  BMPHEADER2 head2;              //first part of header
+
+  *photo = 1;
+  nread = read (fd, &head0, sizeof (head0));
+  if (nread != sizeof (head0))
+    return -1;
+  nread = read (fd, &head1, sizeof (head1));
+  if (nread != sizeof (head1))
+    return -1;
+  nread = read (fd, &head2, sizeof (head2));
+  if (nread != sizeof (head2))
+    return -1;
+
+  if (head0.bfType1 != 'B')
+    return -1;
+  if (head0.bfType2 != 'M')
+    return -1;
+  lseek (fd, head1.bfOffBits, SEEK_SET);
+  *bpp = head2.biBitCount;
+  *xsize = head2.biWidth;
+  *ysize = head2.biHeight;
+  *res = 300;                    //make up resolution
+  return -2;                     //success
+}
+
+
+/**********************************************************************
+ * read_bmp_image
+ *
+ * Read a whole lz format image and close the file.
+ **********************************************************************/
+
+inT8 read_bmp_image(                //read header
+                    int fd,         //file to read
+                    uinT8 *pixels,  //pixels of image
+                    inT32 xsize,    //size of image
+                    inT32 ysize,
+                    inT8 bpp,       //bits per pixel
+                    inT32           //bytes per line
+                   ) {
+  uinT32 bpl;                    //bytes per line
+  uinT32 wpl;                    //words per line
+  uinT32 nread;                  //current bits
+  inT32 index;                   //to cols
+
+  bpl = (xsize * bpp + 7) / 8;   //bytes per line
+  wpl = (bpl + 3) / 4;
+  wpl *= 4;
+  for (index = 0; index < ysize; index++) {
+    nread = read (fd, pixels + bpl * (ysize - 1 - index), bpl);
+    if (nread != bpl)
+      return -1;
+    if (wpl != bpl)
+      lseek (fd, wpl - bpl, SEEK_CUR);
+  }
+  return 0;
+}
+
+
+/**********************************************************************
+ * write_bmp_image
+ *
+ * Write a whole lz format image and close the file.
+ **********************************************************************/
+
+inT8 write_bmp_image(                //write whole image
+                     int fd,         //file to write on
+                     uinT8 *pixels,  //image pixels
+                     inT32 xsize,    //size of image
+                     inT32 ysize,
+                     inT8 bpp,       //bits per pixel
+                     inT8,
+                     inT32 res       //resolution
+                    ) {
+  uinT32 bpl;                    //bytes per line
+  uinT32 wpl;                    //words per line
+  uinT32 nread;                  //current bits
+  inT32 cols;                    //entries in table
+  inT32 index;                   //to cols
+  BMPHEADER0 head0;              //first part of header
+  BMPHEADER head1;               //first part of header
+  BMPHEADER2 head2;              //first part of header
+  WIN32_RGBQUAD coltab[256];     //colour table
+
+  if (bpp == 24)
+    cols = 0;
+  else
+    cols = 1 << bpp;             //size of colour table
+  bpl = (xsize * bpp + 7) / 8;   //bytes per line
+  wpl = (bpl + 3) / 4;
+
+  head2.biSize = sizeof (head2); //size of struct
+  head2.biWidth = xsize;         //image width
+  head2.biHeight = ysize;        //image height
+  head2.biPlanes = 1;            //1
+  head2.biBitCount = bpp;        //bpp
+  head2.biCompression = 0;       //0 for uncompressed
+                                 //image size
+  head2.biSizeImage = wpl * 4 * ysize;
+                                 //res in pp metre
+  head2.biXPelsPerMeter = (uinT32) (res * 39.37);
+  head2.biYPelsPerMeter = (uinT32) (res * 39.37);
+  head2.biClrUsed = cols;        //0 or actual size of colour table
+  head2.biClrImportant = 0;      //usually 0
+
+  head0.bfType1 = 'B';
+  head0.bfType2 = 'M';
+  head1.bfReserved1 = 0;         //zero
+  head1.bfReserved2 = 0;         //zero
+                                 //offset to bitmap
+  head1.bfOffBits = sizeof (head0) + sizeof (head1) + sizeof (head2) + sizeof (WIN32_RGBQUAD) * cols;
+                                 //filesize
+  head1.bfSize = head1.bfOffBits + head2.biSizeImage;
+
+  for (index = 0; index < cols; index++) {
+    coltab[index].rgbBlue = index * 255 / (cols - 1);
+    coltab[index].rgbGreen = coltab[index].rgbBlue;
+    coltab[index].rgbRed = coltab[index].rgbBlue;
+    coltab[index].rgbReserved = 0;
+  }
+
+  nread = write (fd, &head0, sizeof (head0));
+  if (nread != sizeof (head0))
+    return -1;
+  nread = write (fd, &head1, sizeof (head1));
+  if (nread != sizeof (head1))
+    return -1;
+  nread = write (fd, &head2, sizeof (head2));
+  if (nread != sizeof (head2))
+    return -1;
+  nread = write (fd, coltab, cols * sizeof (WIN32_RGBQUAD));
+  if (nread != cols * sizeof (WIN32_RGBQUAD))
+    return -1;
+  for (index = 0; index < ysize; index++) {
+    nread = write (fd, pixels + bpl * (ysize - 1 - index), wpl * 4);
+    if (nread != wpl * 4)
+      return -1;
+  }
+  close(fd);  //done it
+  return 0;
+}

data/vendor/tesseract-2.04/image/imgbmp.h

@@ -0,0 +1,50 @@
+/**********************************************************************
+ * File:			imgbmp.c  (Formerly lz.c)
+ * Description:	bmp image reader/writer.
+ * Author:		Ray Smith
+ * Created:		Tue Jan 06 20:15:52 GMT 1998
+ *
+ * (C) Copyright 1998, Ray Smith.
+ ** 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           IMGBMP_H
+#define           IMGBMP_H
+
+#include          "host.h"
+
+inT8 open_bmp_image(               //read header
+                    int fd,        //file to read
+                    inT32 *xsize,  //size of image
+                    inT32 *ysize,
+                    inT8 *bpp,     //bits per pixel
+                    inT8 *photo,
+                    inT32 *res     //resolution
+                   );
+inT8 read_bmp_image(                //read header
+                    int fd,         //file to read
+                    uinT8 *pixels,  //pixels of image
+                    inT32 xsize,    //size of image
+                    inT32 ysize,
+                    inT8 bpp,       //bits per pixel
+                    inT32           //bytes per line
+                   );
+inT8 write_bmp_image(                //write whole image
+                     int fd,         //file to write on
+                     uinT8 *pixels,  //image pixels
+                     inT32 xsize,    //size of image
+                     inT32 ysize,
+                     inT8 bpp,       //bits per pixel
+                     inT8,
+                     inT32           //resolution
+                    );
+#endif

data/vendor/tesseract-2.04/image/imgerrs.h

@@ -0,0 +1,35 @@
+/**********************************************************************
+ * File:        imgerrs.h  (Formerly imgerr.h)
+ * Description: Definitions of errors related to IMAGE operations.
+ * Author:      Ray Smith
+ * Created:     Tue Aug 14 10:10:53 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.
+ *
+ **********************************************************************/
+
+#ifndef           IMGERRS_H
+#define           IMGERRS_H
+
+#include          "errcode.h"
+
+const ERRCODE BADIMAGETYPE = "Unrecognized image type";
+const ERRCODE CANTREADIMAGETYPE = "Can't read this image type";
+const ERRCODE CANTWRITEIMAGETYPE = "Can't write this image type";
+const ERRCODE IMAGEUNDEFINED = "Attempt to operate on undefined image";
+const ERRCODE BADIMAGECOORDS = "Coordinates in image out of bounds";
+const ERRCODE BADIMAGESEEK = "Can't seek backwards in a buffered image!";
+const ERRCODE BADIMAGESIZE = "Illegal image size";
+const ERRCODE BADIMAGEFORMAT = "Illegal image format";
+const ERRCODE BADBPP = "Only 1,2,4,5,6,8 bpp are supported";
+const ERRCODE BADWINDOW = "Convolution window must have odd dimensions";
+#endif

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

@@ -0,0 +1,321 @@
+/**********************************************************************
+ * File:        imgio.c  (Formerly imageio.c)
+ * Description: Controls image input/output and selection of format.
+ * Author:      Ray Smith
+ * Created:     Mon Jun 11 11:47:26 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          <fcntl.h>
+#include          <sys/types.h>
+#include          <sys/stat.h>
+#include          <string.h>
+#include          "scanutils.h"
+#include          "stderr.h"
+#include          "fileerr.h"
+#include          "imgerrs.h"
+#include          "memry.h"
+#include          "imgs.h"
+#include          "imgbmp.h"
+#include          "imgtiff.h"
+#include          "imgio.h"
+
+#define DEFAULTIMAGETYPE  "tif"  //default to im files
+
+typedef struct
+{
+  const char *string;            //extension
+  IMAGE_OPENER opener;           //opening function
+  IMAGE_READER reader;           //reading function
+  IMAGE_WRITER writer;           //writing function
+} IMAGETYPE;                     //image type record
+
+static IMAGETYPE imagetypes[] = { {
+    "TIF",
+    open_tif_image,
+    read_tif_image,
+    write_moto_tif
+  },
+  {
+    "itf",
+    open_tif_image,
+    read_tif_image,
+    write_inverse_tif
+  },
+  {
+    "tif",
+    open_tif_image,
+    read_tif_image,
+    write_intel_tif
+  },
+  {
+    "bmp",
+    open_bmp_image,
+    read_bmp_image,
+    write_bmp_image
+  },
+};                               //image readers/writers
+
+#define MAXIMAGETYPES   (sizeof(imagetypes)/sizeof(IMAGETYPE))
+
+/**********************************************************************
+ * name_to_image_type
+ *
+ * Convert a file name to an image type, picking defaults if it is
+ * has no extension, and complaining if the extension is not supported.
+ **********************************************************************/
+
+static inT8 name_to_image_type(                  //get image type
+                               const char *name  //name of image
+                              ) {
+  const char *nametype;          //type part of name
+  inT8 type;                     //imagetypes index
+
+  nametype = strrchr (name, '.');//find extension
+  if (nametype != NULL)
+    nametype++;                  //ptr to extension
+  else
+    nametype = DEFAULTIMAGETYPE; //had none
+
+                                 //find type of image
+  for (type = 0; type < MAXIMAGETYPES && strcmp (imagetypes[type].string, nametype); type++);
+  if (type >= MAXIMAGETYPES) {
+                                 //unrecognized type
+    BADIMAGETYPE.error ("name_to_image_type", TESSLOG, name);
+    return -1;
+  }
+  return type;
+}
+
+
+/**********************************************************************
+ * read_header
+ *
+ * Read the header of an image, typed according to the extension of
+ * the name.  Return is 0 for success, -1 for failure.
+ **********************************************************************/
+
+inT8 IMAGE::read_header(                  //get file header
+                        const char *name  //name of image
+                       ) {
+  inT8 type;                     //image type
+
+  destroy();  //destroy old image
+                                 //get type
+  type = name_to_image_type (name);
+  if (type < 0 || imagetypes[type].opener == NULL) {
+    CANTREADIMAGETYPE.error ("IMAGE::read_header", TESSLOG, name);
+    return -1;                   //read not supported
+  }
+  #ifdef __UNIX__
+  if ((fd = open (name, O_RDONLY)) < 0)
+  #endif
+  #if defined (__MSW32__) || defined (__MAC__)
+    if ((fd = open (name, O_RDONLY | O_BINARY)) < 0)
+  #endif
+  {
+    CANTOPENFILE.error ("IMAGE::read_header", TESSLOG, name);
+    return -1;                   //failed
+  }
+  lineskip =
+    (*imagetypes[type].opener) (fd, &xsize, &ysize, &bpp, &photo_interp,
+    &res);
+  if (lineskip == -1) {
+                                 //get header
+    bpp = 0;                     //still empty
+    close(fd);
+    fd = -1;
+    return -1;                   //failed
+  }
+  if (res <= 0)
+    res = image_default_resolution;
+  //      fprintf(stderr,"Image size=(%d,%d), bpp=%d\n",
+  //              xsize,ysize,bpp);
+                                 //bytes per line
+  xdim = COMPUTE_IMAGE_XDIM (xsize, bpp);
+  bps = bpp == 24 ? 8 : bpp;
+  bytespp = (bpp + 7) / 8;
+                                 //funtion to read with
+  reader = imagetypes[type].reader;
+  return 0;                      //success
+}
+
+
+/**********************************************************************
+ * read
+ *
+ * Read a previously opened image file into memory.
+ * If buflines is 0, the whole image is read in one go.
+ * If buflines>0, memory space is reserved for reading just that many
+ * lines at once.
+ * As soon as a request is made to get a line past the end of the buffer,
+ * the buffer is re-read with a 50% overlap.
+ * Backward seeks are not allowed.
+ * Read returns -1 in case of failure or 0 if successful.
+ **********************************************************************/
+
+inT8 IMAGE::read(                //get rest of image
+                 inT32 buflines  //size of buffer
+                ) {
+  inT32 row;                     //image row
+  BOOL8 failed;                  //read failed
+
+  if (fd < 0 || image != NULL)
+    IMAGEUNDEFINED.error ("IMAGE::read", ABORT, NULL);
+
+  if (buflines <= 0 || buflines > ysize || reader == NULL)
+    buflines = ysize;            //default to all
+  bufheight = buflines;
+  image =
+    (uinT8 *) alloc_big_mem ((size_t) (xdim * bufheight * sizeof (uinT8)));
+  if (image == NULL) {
+    MEMORY_OUT.error ("IMAGE::read", TESSLOG, NULL);
+    destroy();
+    return -1;
+  }
+  captured = FALSE;
+  ymax = ysize;
+  ymin = ysize - buflines;       //amount of image read
+  if (reader != NULL && lineskip < 0)
+    failed = (*reader) (fd, image, xsize, ysize, bpp, xdim) < 0;
+  else {
+    if (lineskip == 0)
+      failed =::read (fd, (char *) image,
+        (size_t) (xdim * bufheight)) != xdim * bufheight;
+    else {
+      for (failed = FALSE, row = 0; row < bufheight && !failed; row++) {
+        failed =::read (fd, (char *) image + row * xdim,
+          (size_t) xdim) != xdim;
+        failed |= lseek (fd, lineskip, SEEK_CUR) < 0;
+      }
+    }
+  }
+  if (failed) {
+    READFAILED.error ("IMAGE::read", TESSLOG, NULL);
+    destroy();
+    return -1;                   //read failed
+  }
+  if (ymin <= 0) {
+    close(fd);  //finished reading
+    fd = -1;                     //not open now
+  }
+  return 0;                      //success
+}
+
+
+/**********************************************************************
+ * bufread
+ *
+ * Read a bit more of an image into the buffer.
+ **********************************************************************/
+
+inT8 IMAGE::bufread(         //read more into buffer
+                    inT32 y  //required coord
+                   ) {
+  inT32 readtop;                 //no of lines copied
+  inT32 linestoread;             //no of lines to read
+  inT32 row;                     //row to read
+  BOOL8 failed;                  //read failed
+
+                                 //copy needed?
+  if (y + bufheight / 2 >= ymin) {
+                                 //no of lines to move
+    readtop = y + bufheight / 2 - ymin + 1;
+                                 //copy inside it
+    copy_sub_image (this, 0, ymin, xsize, readtop, this, 0, ymax - readtop, TRUE);
+  }
+  else
+    readtop = 0;
+  ymax = y + bufheight / 2;      //new top of image
+  ymin = ymax - bufheight;       //possible bottom
+  if (ymin < 0)
+    ymin = 0;                    //clip to image size
+  linestoread = ymax - ymin - readtop;
+  if (lineskip == 0)
+    failed =::read (fd, (char *) (image + xdim * readtop),
+      (size_t) (xdim * linestoread)) != xdim * linestoread;
+  else {
+    for (failed = FALSE, row = 0; row < linestoread && !failed; row++) {
+      failed =::read (fd, (char *) (image + (readtop + row) * xdim),
+        (size_t) xdim) != xdim;
+      failed |= lseek (fd, lineskip, SEEK_CUR) < 0;
+    }
+  }
+  if (failed) {
+    READFAILED.error ("IMAGE::bufread", TESSLOG, NULL);
+    return -1;                   //read failed
+  }
+  if (ymin <= 0) {
+    close(fd);  //finished reading
+    fd = -1;                     //not open now
+  }
+  return 0;                      //success
+}
+
+
+/**********************************************************************
+ * write
+ *
+ * Write an image to a file in a format determined by the name.
+ **********************************************************************/
+
+inT8 IMAGE::write(                  //write image
+                  const char *name  //name to write
+                 ) {
+  inT8 type;                     //type of image
+
+  if (bpp == 0 || image == NULL || bufheight != ysize)
+    IMAGEUNDEFINED.error ("IMAGE::write", ABORT, NULL);
+  if (fd >= 0) {
+    close(fd);  //close old file
+    fd = -1;                     //no longer open
+  }
+                                 //get image type
+  type = name_to_image_type (name);
+  if (type < 0 || imagetypes[type].writer == NULL) {
+    CANTWRITEIMAGETYPE.error ("IMAGE::write", TESSLOG, name);
+    return -1;                   //write not supported
+  }
+  #ifdef __UNIX__
+  if ((fd = creat (name, 0666)) < 0)
+  #endif
+  #ifdef __MSW32__
+    if ((fd = open (name, _O_CREAT | _O_WRONLY | _O_BINARY, _S_IWRITE)) < 0)
+  #endif
+  #ifdef __MAC__
+      if ((fd = creat (name, O_WRONLY | O_BINARY)) < 0)
+  #endif
+  {
+    CANTCREATEFILE.error ("IMAGE::write", TESSLOG, name);
+    return -1;                   //failed
+  }
+  if (res <= 0)
+    res = image_default_resolution;
+  if ((*imagetypes[type].writer) (fd, image, xsize, ysize, bpp, photo_interp,
+  res) < 0) {
+                                 //get header
+                                 //write failed
+    WRITEFAILED.error ("IMAGE::write", TESSLOG, name);
+    close(fd);
+    fd = -1;
+    return -1;                   //failed
+  }
+  return 0;                      //success
+}

data/vendor/tesseract-2.04/image/imgio.h

@@ -0,0 +1,22 @@
+/**********************************************************************
+ * File:        imgio.h  (Formerly imageio.h)
+ * Description: Header file for image input/output functions.
+ * Author:      Ray Smith
+ * Created:     Mon Jun 11 12:55:34 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.
+ *
+ **********************************************************************/
+
+#ifndef           IMGIO_H
+#define           IMGIO_H
+#endif