pnm_image.H

Go to the documentation of this file.

/*
 * Copyright 1998, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
/**********************************************************************
 * image.H
 **********************************************************************/
#ifndef IMAGE_H_HAS_BEEN_INCLUDED
#define IMAGE_H_HAS_BEEN_INCLUDED

#define OUTSIDE_GLUE_CORE

#include "std/config.H"
#include <math.h>
#include "std/list.H"
#include "std/strings.H"
#include "mlib/point2i.H"

namespace InSpace {

//
//  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;

typedef const class Image cImage;
/**********************************************************************
 * 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 DllImpExp Image {
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);

   str_ptr      _file;

 public:
   Image() : _width(0), _height(0), _bpp(1), _data(0), _no_delete(0) {}
   Image(Cstr_ptr& file) :
      _width(0),
      _height(0),
      _bpp(1),
      _data(0),
      _no_delete(0)
     {
      if (file)
         load_file(file);
   }
   Image(cImage &img) { *this = img; }
   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(1), _data(0), _no_delete(0) {
      resize(w,h,bpp);
   }

   void operator=(const Image &img) {
      if (img._file) {
         _data = 0; clear();
         load_file(img._file);
      } else {
         set(img._width, img._height, img._bpp, img.copy(), true);
      }
   }

   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);
         clear();
      } else {
         clear();
         _width = w;
         _height = h;
         _bpp = bpp;
         _data = data;
         _no_delete = nd;
      }
   }

   void clear() {
      if (!_no_delete)
         delete [] _data;
      _width = _height = 0;
      _bpp = 1;
      _data  = 0;
      _no_delete = 0;
      _file = str_ptr::null_str();
   }

   int 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;
   }

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

   virtual ~Image() { clear(); }

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

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

   void expand_power2();
   int  resize_rows_mult_4();
   int  load_file(Cstr_ptr &file);

   int  read_png(Cstr_ptr &file);
   int  write_png(char* file) const;

   int  read_pnm (Cstr_ptr &file);
   int  read_pnm (istream &in);
   int  read_pgm (istream& in, bool ascii);
   int  read_ppm (istream& in, bool ascii);
   int  write_pnm(char* file,  bool ascii=false) const;
   int  write_pnm(ostream &os, bool ascii) 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);
   }
   friend ostream & operator<<(ostream &os, cImage &img);
   friend istream & operator>>(istream &is,  Image &img);
};


}
#endif  // IMAGE_H_HAS_BEEN_INCLUDED
/* end of file image.H */

---