img_image.h

Go to the documentation of this file.

#ifndef IMG_IMAGE_H_
#define IMG_IMAGE_H_

#include "img/img_base.h"
#include "img/img_attributes.h"

namespace img {

template<int Channels=3, typename ScalarType=double, bool Safe=true> 
class Image //TODO: Safe=false prima di mettere in vcg
{
private:
  // Data is private but controlled data wiews are
  // accessible from accessors

  int _width; 
  int _height; 
  ScalarType *_data; 

// constructors
public:
  ImgAttributes<ScalarType> attributes;


  Image() // creates a 0 x 0 image
  :_width(0),_height(0),_data(NULL),attributes()
  {
    STATIC_ASSERT( Channels>0 );
    STATIC_FLOAT_OR_DOUBLE_TYPECHECK( ScalarType );
  }

  Image(const Image<Channels,ScalarType,Safe> &image) // copy constructor (deep copy)
  {
    STATIC_ASSERT( Channels>0 );
    STATIC_FLOAT_OR_DOUBLE_TYPECHECK( ScalarType );

    assert(image._width > 0);
    assert(image._height > 0);
    assert(image._data != NULL);
    if(Safe) {
      if(image._width <= 0) throw ImageException("Image(Image): Nonpositive width");
      if(image._height <= 0) throw ImageException("Image(Image): Nonpositive height");
      if(image._data == NULL) throw ImageException("Image(Image): NULL data");     
    }    
    _width = image._width;
    _height = image._height;
    _data = new ScalarType[Channels * _width * _height];
    attributes=image.attributes;

    memcpy(_data, image._data, sizeof(ScalarType) * Channels * _width * _height);
  }

  template<typename OtherScalarType, bool OtherSafe> 
  Image(const Image<Channels,OtherScalarType,OtherSafe> &image) // templated copy constructor (deep copy)
  :_width(0),_height(0),_data(NULL)
  {
    STATIC_ASSERT( Channels>0 );
    STATIC_FLOAT_OR_DOUBLE_TYPECHECK( ScalarType );

    assert(image._width > 0);
    assert(image._height > 0);
    assert(image._data != NULL);
    if(Safe || OtherSafe) {
      if(image._width <= 0) throw ImageException("Image(Image): Nonpositive width");
      if(image._height <= 0) throw ImageException("Image(Image): Nonpositive height");
      if(image._data == NULL) throw ImageException("Image(Image): NULL data");     
    }    
    _width = image._width;
    _height = image._height;
    _data = new ScalarType[Channels * _width * _height];
    attributes=image.attributes;

    if(typeid( ScalarType ) == typeid( OtherScalarType ))
      memcpy(_data, image._data, sizeof(ScalarType) * Channels * _width * _height);
    else
      for(int offset=0;offset< Channels * _width * _height; ++offset)
        _data[offset] = static_cast<ScalarType>(image._data[offset]);
  }

  Image(int arg_width,int arg_height)
  :_width(arg_width),_height(arg_height),_data(NULL),attributes()
  {
    STATIC_ASSERT( Channels>0 );
    STATIC_FLOAT_OR_DOUBLE_TYPECHECK( ScalarType );

    assert(arg_width>0);
    assert(arg_height>0);
    if(Safe) {
      if(arg_width <= 0) throw ImageException("Image(int,int): Nonpositive width");
      if(arg_height <= 0) throw ImageException("Image(int,int): Nonpositive height");
    }
    _data = new ScalarType[Channels * _width * _height];
    for(int offset=0;offset< Channels * _width * _height; ++offset)
      _data[offset] = 0.0f;
  }  

  ~Image()
  {
    attributes.reset();
    if(_data!=NULL){
      delete [] _data;
      _data=NULL;
    }
  }

// public functions
public:
  template<typename OtherScalarType, bool OtherSafe> 
  inline Image< Channels,ScalarType,Safe> & operator =(const Image<Channels,OtherScalarType,OtherSafe> &image)
  {
    assert(image._width > 0);
    assert(image._height > 0);
    assert(image._data != NULL);
    if(Safe || OtherSafe) {
      if(image._width <= 0) throw ImageException("operator =: Nonpositive width");
      if(image._height <= 0) throw ImageException("operator =: Nonpositive height");
      if(image._data == NULL) throw ImageException("operator =: NULL data");     
    }    
    _width = image._width;
    _height = image._height;
    _data = new ScalarType[Channels * _width * _height];
    attributes=image.attributes;

    if(typeid( ScalarType ) == typeid( OtherSafe ))
      memcpy(_data, image._data, sizeof(ScalarType) * Channels * _width * _height);
    else
      for(int offset=0;offset < Channels * _width * _height; ++offset)
        _data[offset] = static_cast<ScalarType>(image._data[offset]);
    return *this;
  }

  inline void setZero(int arg_width, int arg_height)
  {
    assert(arg_width>0);
    assert(arg_height>0);
    if(Safe) {
      if(arg_width <= 0) throw ImageException("setZero: Nonpositive width");
      if(arg_height <= 0) throw ImageException("setZero: Nonpositive height");
    }
    if(_data!=NULL){
      delete [] _data;
      _data=NULL;
    }    
    _width = arg_width;
    _height = arg_height;
    _data = new ScalarType[Channels * _width * _height];
    attributes.reset();
    
    for(int offset=0;offset< Channels * _width * _height; ++offset)
      _data[offset] = 0.0f;
  }

  inline void deleteData()
  {
    if(_data!=NULL){
      delete [] _data;
      _data=NULL;
    }
    _width = 0;
    _height = 0;    
  } 


  inline void getPixel(int x, int y, ScalarType (& ret_pixel)[Channels]) const
  {
    assert( _data != NULL );
    assert( x >= 0 && x < _width );
    assert( y >= 0 && y < _height );
    if( Safe ){
      if ( _data == NULL ) throw ImageException("getPixel: NULL data");
      if ( !( x >= 0 && x < _width ) ) throw ImageException("getPixel: x out of bounds");
      if ( !( y >= 0 && y < _height ) ) throw ImageException("getPixel: y out of bounds");      
    }
    for (int channel=0;channel<Channels;++channel)
      ret_pixel[channel] = _data[ (x + y * _width) * Channels + channel ];
  }

  inline void setPixel(int x, int y, const ScalarType (& pixel)[Channels])
  {
    assert( _data != NULL );
    assert( x >= 0 && x < _width );
    assert( y >= 0 && y < _height );
    if( Safe ){
      if ( _data == NULL ) throw ImageException("setPixel: NULL data");
      if ( !( x >= 0 && x < _width ) ) throw ImageException("setPixel: x out of bounds");
      if ( !( y >= 0 && y < _height ) ) throw ImageException("setPixel: y out of bounds");      
    }
    for (int channel=0;channel<Channels;++channel)
      _data[ (x + y * _width) * Channels + channel ] = pixel[channel];
  }

  inline ScalarType getValue(int x, int y, int channel) const
  {
    assert( _data != NULL );
    assert( x >= 0 && x < _width );
    assert( y >= 0 && y < _height );
    assert( channel >=0 && channel < Channels );
    if( Safe ){
      if ( _data == NULL ) throw ImageException("getFloat: NULL data");
      if ( !( x >= 0 && x < _width ) ) throw ImageException("getFloat: x out of bounds");
      if ( !( y >= 0 && y < _height ) ) throw ImageException("getFloat: y out of bounds");
      if ( !( channel >=0 && channel < Channels ) ) throw ImageException("channel out of bounds");
    }
    return _data[ (x + y * _width) * Channels + channel ];
  }

  inline void setValue(int x, int y, int channel, ScalarType value)
  {
    assert( _data != NULL );
    assert( x >= 0 && x < _width );
    assert( y >= 0 && y < _height );
    assert( channel >=0 && channel < Channels );
    if( Safe ){
      if ( _data == NULL ) throw ImageException("setFloat: NULL data");
      if ( !( x >= 0 && x < _width ) ) throw ImageException("setFloat: x out of bounds");
      if ( !( y >= 0 && y < _height ) ) throw ImageException("setFloat: y out of bounds");      
      if ( !( channel >=0 && channel < Channels ) ) throw ImageException("channel out of bounds");
    }
    _data[(x + y * _width) * Channels + channel] = value;
  }

  inline void getPixelAsClamped(int x, int y, ScalarType (& ret_pixel)[Channels]) const
  {
    getPixel(x<0?0:(x<_width?x:_width-1), y<0?0:(y<_height?y:_height-1), ret_pixel);
  }

  inline float getValueAsClamped(int x, int y, int channel) const
  {
    return getValue(x<0?0:(x<_width?x:_width-1), y<0?0:(y<_height?y:_height-1),channel);
  }

  inline void nearestPixel(float x, float y, ScalarType (& ret_pixel)[Channels]) const
  {
  getPixel(static_cast<int>(floor(x+0.5f)),static_cast<int>(floor(y+0.5f)), ret_pixel);
  }

//  inline void bilinearPixel(float x, float y, const ScalarType[] &pixel) const
//  {
//    assert( _data != NULL );
//    assert( x >= 0.0f && x <= _width-1.0f );
//    assert( y >= 0.0f && y <= _height-1.0f );
//    if( SAFE ){
//      if ( _data == NULL ) throw ImageException("bilinearPixel: NULL data");
//      if ( !( x >= 0.0f && x <= _width-1.0f ) ) throw ImageException("bilinearPixel: x out of bounds");
//      if ( !( y >= 0.0f && y <= _height-1.0f ) ) throw ImageException("bilinearPixel: y out of bounds");      
//    }    
//    
//  int x1 = static_cast<int>(floor(x));
//    int y1 = static_cast<int>(floor(y));
//  float a = 1.0f;
//  float b = 1.0f;
//  
//  if( x1 == _width )
//      x1--;
//  else
//      a = x - x1;
//  if( y1 == _height )
//      y1--;
//  else
//      b = y - y1;
//    
//  float a1 = (1.0f - a);
//    float b1 = (1.0f - b);
//    
//  int i = x1 + y1 * _width;
//
//  return _data[i] * a1 * b1
//         + _data[i + 1] * a * b1 
//         + _data[i + _width] * a1 * b + 
//         _data[i + _width + 1] * a * b;  
//  }

// accessors
public:
  inline int width() const
  {
    return _width;
  }

  inline int height() const
  {
    return _height;
  }

  inline void setWidth(int width)
  {
     assert(width > 0);
     if(Safe){
       if(width <= 0) throw ImageException("setWidth: Nonpositive width");
    }
    _width=width;
  }

   inline void setHeight(int height)
  {
    assert(height > 0);
    if(Safe){
       if(height <= 0) throw ImageException("setHeight: Nonpositive height");
    }
    _height=height;
  }

  inline ScalarType* dataValues() const
  {
    return _data;
  }

  inline int dataValuesSize() const
  {
    return _width * _height * Channels;
  }


  inline void setValues(ScalarType* data)
  {
    assert(data!=NULL);
    if(Safe){
      if(data == NULL) throw ImageException("setValues: NULL data");
    }
    _data = data;
  }

  inline bool isInside(int x, int y) const
  {
    return x >= 0 && x < _width && y >= 0 && y < _height;
  }

  inline bool isInside(float x, float y) const
  {
    return x >= 0.0f && x <= _width-1.0f && y >= 0.0f && y <= _height-1.0f;
  }

  inline bool isValid() const
  {
    return _data != NULL && _width > 0 && _height > 0;
  }

  inline int channels() const
  {
    return Channels;
  }

  inline void setRawValue(int i, ScalarType value)
  {
     _data[i] = value;
  }
  
};

} //end namespace img

#endif /*IMG_IMAGE_H_*/