image.H

Go to the documentation of this file.

/**********************************************************************
 * image.H
 **********************************************************************/
#ifndef IMAGE_H_HAS_BEEN_INCLUDED
#define IMAGE_H_HAS_BEEN_INCLUDED

#include "std/fstream.H"
#include <cmath>
#include "std/support.H"
#include "mlib/points.H"
#include "mlib/point2i.H"

//
//  getPower2Size - returns smallest power of two that is >= size
//
inline unsigned int
getPower2Size(int n)
{
   return (1 << ((n>0) ? (int)ceil(log((double) n)/log(2.0)) : 0));
}

typedef unsigned int  uint;
typedef unsigned char uchar;

/**********************************************************************
 * Image:
 *
 *    Contains an image stored bottom-up (the first row in the image is
 *    the row that appears at the bottom of the image) that can be read or
 *    written in pnm or png format
 *    
 **********************************************************************/
class Image {
 protected:
   uint         _width;         // width
   uint         _height;        // height
   uint         _bpp;           // bytes per pixel
   uchar*       _data;          // pixel data
   bool         _no_delete;

   enum { PNG_BYTES_TO_CHECK = 8 };
   FILE* open_png(char* file);

 public:
   Image() : _width(0), _height(0), _bpp(0), _data(0), _no_delete(0) {}
   Image(Cstr_ptr& file) :
      _width(0),
      _height(0),
      _bpp(0),
      _data(0),
      _no_delete(false) {
      if (file)
         load_file(**file);
   }
   Image(uint w, uint h, uint bpp, uchar* data, bool nd=1) {
      set(w,h,bpp,data,nd);
   }
   Image(uint w, uint h, uint bpp) :
      _width(0), _height(0), _bpp(0), _data(0), _no_delete(false) {
      resize(w,h,bpp);
   }
   virtual ~Image() { clear(); }

   void set(int w, int h, uint bpp, uchar* data, bool nd=1) {
      if (bpp < 1 || bpp > 4) {
         err_msg("Image::Image: %d bytes/pixel not supported", bpp);
      } else {
         clear();
         _width = w;
         _height = h;
         _bpp = bpp;
         _data = data;
         _no_delete = nd;
      }
   }

   void freedata() {
      if (!_no_delete) {
         delete [] _data;
      }
      _data = 0;
   }
   
   void clear() {
      freedata();
      _width = _height = _bpp = 0;
      _no_delete = 0;
   }

   bool resize(uint w, uint h, uint b) {
      // if current size is different from
      // desired size:
      //   let go current data (if any)
      //   set new width, height and bpp
      //   allocate new data
      //   but don't initialize it
      if (_width != w || _height != h || _bpp != b) {
         _width = w;
         _height = h;
         _bpp = b;
         if (!_no_delete)
            delete [] _data;
         _data = 0;
         _no_delete = 0;
         if ((_data = new uchar [ size() ]) == 0) {
            err_ret("Image::resize: can't allocate data");
            return 0;
         }
      }
      return 1;
   }
   bool resize(uint w, uint h) { return resize(w,h,_bpp); }

   int copy_tile(const Image& tile, uint i, uint j);

   // accessors:
   uint      width()    const { return _width; }
   uint      height()   const { return _height; }
   uint      bpp()      const { return _bpp; }
   uint      size()     const { return _width*_height*_bpp; }
   uint      row_size() const { return _width*_bpp; }
   mlib::Point2i   dims()     const { return mlib::Point2i(_width,_height); }
   uchar*    data()     const { return _data; }
   uchar*    row(int k) const { return _data + k*row_size(); }
   uchar*    copy();

   uchar pixel(uint x, uint y) const {
      if (x >= _width || y >= _height)
         return 0;
      return row(y)[x * _bpp];
   }
   uint pixel_rgba(uint x, uint y) const;   
   uint pixel_r(uint x, uint y) const;
   uint pixel_g(uint x, uint y) const;
   uint pixel_b(uint x, uint y) const;      
   uint pixel_a(uint x, uint y) const;

   bool empty() const { return !(_width && _height && _bpp && _data); }

   // expand the image so dimensions are each a power of 2.
   // return true if anything changed:
   bool expand_power2();

   int  resize_rows_mult_4();
   int  load_file(char* file);
   int  read_png(char* file);
   int  read_png(FILE* fp);
   int  write_png(char* file) const;

   int  read_pnm(char* file);
   int  read_pgm(istream& in, bool ascii);
   int  read_ppm(istream& in, bool ascii);
   int  write_pnm(char* file) const;

   static int write_png(int w, int h, uint bpp, uchar* data, Cstr_ptr& file) {
      Image img(w,h,bpp,data,1);
      return img.write_png(**file);
   }
};

#endif  // IMAGE_H_HAS_BEEN_INCLUDED

/* end of file image.H */

---