img.h

Go to the documentation of this file.

/**********************************************************************
 * File:        img.h  (Formerly image.h)
 * Description: Class definition for the IMAGE class.
 * Author:      Ray Smith
 * Created:     Thu Jun 07 13:42:37 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           IMG_H
#define           IMG_H

#include          "memry.h"

struct Pix;

#define MAXIMAGEWIDTH   (900*14) 

#define MAXIMAGEHEIGHT    (900*14)

#define COMPUTE_IMAGE_XDIM(xsize,bpp) ((bpp)>8 ? ((xsize)*(bpp)+7)/8 :((xsize)+8/(bpp)-1)/(8/(bpp)))

typedef inT8 (*IMAGE_OPENER) (int, inT32 *, inT32 *, inT8 *, inT8 *, inT32 *);
typedef inT8 (*IMAGE_READER) (int, uinT8 *, inT32, inT32, inT8, inT32);
typedef inT8 (*IMAGE_WRITER) (int, uinT8 *, inT32, inT32, inT8, inT8, inT32);

typedef uinT8 *COLOUR_PIX;
enum COLOUR_PIX_NAME
{
  RED_PIX,
  GREEN_PIX,
  BLUE_PIX
};

class DLLSYM IMAGELINE;

class DLLSYM IMAGE
{
  public:
    IMAGE();  //constructor

    ~IMAGE () {                  //destructor
      destroy();  //free memory
    }

    IMAGE & operator= (          //assignment
      IMAGE & source);

    inT8 create(inT32 x,
                inT32 y,
                inT8 bits_per_pixel);

    inT8 capture(uinT8 *pixels,
                 inT32 x,
                 inT32 y,
                 inT8 bits_per_pixel);

    void destroy();

    inT32 get_xsize() {
      return xsize;
    }
    inT32 get_ysize() {
      return ysize;
    }
    inT8 get_bpp() {
      return bpp;
    }
    inT8 get_bps() {
      return bps;
    }
    BOOL8 white_high() {
      return photo_interp;
    }
    uinT8 get_white_level() {
      return (1 << bpp) - 1;
    }
    inT32 get_res() {
      return res;
    }
    void set_res(inT32 resolution) {
      res = resolution;
    }
    uinT8 *get_buffer() {
      return image;
    }

    uinT8 pixel(inT32 x,
                inT32 y);

    void fast_get_line(inT32 x,
                       inT32 y,
                       inT32 width,
                       IMAGELINE *linebuf);

    void get_line(inT32 x,
                  inT32 y,
                  inT32 width,
                  IMAGELINE *linebuf,
                  inT32 margins);
    void get_column(inT32 x,
                    inT32 y,
                    inT32 height,
                    IMAGELINE *linebuf,
                    inT32 margins);

    void fast_put_line(inT32 x,
                       inT32 y,
                       inT32 width,
                       IMAGELINE *linebuf);

    void put_line(inT32 x,
                  inT32 y,
                  inT32 width,
                  IMAGELINE *linebuf,
                  inT32 margins);
    void put_column(inT32 x,
                    inT32 y,
                    inT32 height,
                    IMAGELINE *linebuf,
                    inT32 margins);

    void check_legal_access(inT32 x,
                            inT32 y,
                            inT32 xext);


    Pix* ToPix();
    void FromPix(const Pix* src_pix);

    void convolver (
      inT32 win_width,
      inT32 win_height,
      void (*convolve) (
      uinT8 ** pixels,           
      uinT8 bytespp,             
      inT32 win_wd,              
      inT32 win_ht,              
      uinT8 ret_white_value,     
      uinT8 * result             
      ));

                                 //copy rectangle
    friend DLLSYM void copy_sub_image(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 //shift to match bpp
                                      inT32 ydest,
                                      BOOL8 adjust_grey);

                                 //enlarge rectangle
    friend DLLSYM void enlarge_sub_image(IMAGE *source,       //source image
                                         inT32 xstart,        //scaled coords
                                         inT32 ystart,
                                         IMAGE *dest,         //destination image
                                         inT32 xdest,         //destination coords
                                         inT32 ydest,
                                         inT32 xext,          //extent to copy
                                         inT32 yext,
                                         inT32 scale,         //scale factor
                                         BOOL8 adjust_grey);  //shift to match bpp

                                 //reduce rectangle
    friend DLLSYM void fast_reduce_sub_image(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,         //scale factor
                                             BOOL8 adjust_grey);  //shift to match bpp

                                 //reduce rectangle
    friend DLLSYM void reduce_sub_image(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,         //scale factor
                                        BOOL8 adjust_grey);  //shift to match bpp

  private:
    inT8 bpp;                    
    inT8 bps;                    
    inT8 bytespp;                
    inT8 lineskip;               
    BOOL8 captured;              
    inT8 photo_interp;           
    inT32 xsize, ysize;          
    inT32 res;                   
    uinT8 *image;                
    inT32 xdim;                  
    inT32 bufheight;             
    int fd;                      
    IMAGE_READER reader;         
    inT32 ymin;                  
    inT32 ymax;                  

    inT8 bufread(inT32 y);
};

class DLLSYM IMAGELINE           //one line of image
{
  public:
    uinT8 * pixels;              
    inT8 bpp;                    

    COLOUR_PIX operator[] (
    inT32 index) {
      return &pixels[index * 3]; //coercion access op
    }

    IMAGELINE() {
      linewidth = 0;
      line = NULL;
      pixels = line;
      bpp = 8;
    }
    void init(                //setup size
              inT32 width) {  //size of line
      if (width <= 0)
        width = MAXIMAGEWIDTH;
      if (width > linewidth) {
        if (line != NULL)
          free_mem(line);
        linewidth = width;
        line = (uinT8 *) alloc_mem (linewidth * sizeof (uinT8));
      }
      pixels = line;
      bpp = 8;
    }
    ~IMAGELINE () {              //destructor
      if (line != NULL)
        free_mem(line);
    }

    void set_bpp(inT8 new_bpp) {
      if (new_bpp <= 8)
        bpp = 8;
      else
        bpp = 24;
    }

    void init() {
      if (line == NULL)
        init (0);
      else {
        pixels = line;
        bpp = 8;
      }
    }

    friend void IMAGE::get_line(inT32 x,
                                inT32 y,
                                inT32 width,
                                IMAGELINE *linebuf,
                                inT32 margins);
    friend void IMAGE::get_column(inT32 x,
                                  inT32 y,
                                  inT32 height,
                                  IMAGELINE *linebuf,
                                  inT32 margins);

    friend void IMAGE::put_line(inT32 x,
                                inT32 y,
                                inT32 width,
                                IMAGELINE *linebuf,
                                inT32 margins);

    friend void IMAGE::put_column(inT32 x,
                                  inT32 y,
                                  inT32 height,
                                  IMAGELINE *linebuf,
                                  inT32 margins);

    friend void IMAGE::fast_get_line(inT32 x,
                                     inT32 y,
                                     inT32 width,
                                     IMAGELINE *linebuf);

    friend void IMAGE::fast_put_line(inT32 x,
                                     inT32 y,
                                     inT32 width,
                                     IMAGELINE *linebuf);

  private:
    uinT8 * line;                
    inT32 linewidth;             
};
#endif