/vol/vipdata/irtk/image++/include/irtkGenericImage.h

/*=========================================================================

  Library   : Image Registration Toolkit (IRTK)
  Module    : $Id: irtkGenericImage.h 8 2009-03-02 16:12:58Z dr $
  Copyright : Imperial College, Department of Computing
              Visual Information Processing (VIP), 2008 onwards
  Date      : $Date: 2009-03-02 16:12:58 +0000 (Mon, 02 Mar 2009) $
  Version   : $Revision: 8 $
  Changes   : $Author: dr $

=========================================================================*/

#ifndef _IRTKGENERICIMAGE_H

#define _IRTKGENERICIMAGE_H

#ifdef HAS_VTK

#include <vtkStructuredPoints.h>

#endif

template <class VoxelType> class irtkGenericImage : public irtkBaseImage
{

protected:

  VoxelType ****_matrix;

public:

  irtkGenericImage();

  irtkGenericImage(char *);

  irtkGenericImage(int, int, int, int = 1);

  irtkGenericImage(const irtkGenericImage &);

  irtkGenericImage(const irtkImageAttributes &);

  template <class T> irtkGenericImage(const irtkGenericImage<T> &);

  ~irtkGenericImage(void);

  void Initialize(const irtkImageAttributes &);

  void Read (const char *);

  void Write(const char *);

  void GetMinMax(VoxelType *, VoxelType *) const;

  void GetMinMaxPad(VoxelType *, VoxelType *, VoxelType) const;

  void PutMinMax(VoxelType, VoxelType);

  VoxelType *GetPointerToVoxels(int = 0, int = 0, int = 0, int = 0) const;

  int VoxelToIndex(int, int, int, int = 0) const;

  VoxelType   Get(int, int, int, int = 0) const;

  void   Put(int, int, int, VoxelType);

  void   Put(int, int, int, int, VoxelType);

  VoxelType& operator()(int, int, int, int = 0);

  irtkGenericImage GetRegion(int z, int t) const;

  irtkGenericImage GetRegion(int x1, int y1, int z1, int x2, int y2, int z2) const;

  irtkGenericImage GetRegion(int x1, int y1, int z1, int t1, int x2, int y2, int z2, int t2) const;

  irtkGenericImage GetFrame(int t) const;

  //
  // Operators for image arithmetics
  //

  irtkGenericImage<VoxelType>& operator= (const irtkGenericImage &);
  
  template <class T> irtkGenericImage<VoxelType>& operator= (const irtkGenericImage<T> &);
  
  irtkGenericImage  operator+ (const irtkGenericImage &);

  irtkGenericImage& operator+=(const irtkGenericImage &);

  irtkGenericImage  operator- (const irtkGenericImage &);

  irtkGenericImage& operator-=(const irtkGenericImage &);

  irtkGenericImage  operator* (const irtkGenericImage &);

  irtkGenericImage& operator*=(const irtkGenericImage &);

  irtkGenericImage  operator/ (const irtkGenericImage &);

  irtkGenericImage& operator/=(const irtkGenericImage &);

  //
  // Operators for image and Type arithmetics
  //

  irtkGenericImage  operator+ (VoxelType);
  irtkGenericImage& operator+=(VoxelType);
  irtkGenericImage  operator- (VoxelType);
  irtkGenericImage& operator-=(VoxelType);
  irtkGenericImage  operator* (VoxelType);
  irtkGenericImage& operator*=(VoxelType);
  irtkGenericImage  operator/ (VoxelType);
  irtkGenericImage& operator/=(VoxelType);

  //
  // Operators for image thresholding
  //

  irtkGenericImage  operator> (VoxelType);
  irtkGenericImage& operator>=(VoxelType);
  irtkGenericImage  operator< (VoxelType);
  irtkGenericImage& operator<=(VoxelType);

  Bool operator==(const irtkGenericImage &);

  //
  // Reflections and axis flipping
  //

  void ReflectX();
  void ReflectY();
  void ReflectZ();
  void FlipXY();
  void FlipXZ();
  void FlipYZ();
  void FlipXT();
  void FlipYT();
  void FlipZT();

  //
  // Conversions from and to VTK
  //

#ifdef HAS_VTK

  int ImageToVTKScalarType();

  void ImageToVTK(vtkStructuredPoints *);

  void VTKToImage(vtkStructuredPoints *);
#endif

  double GetAsDouble(int, int, int, int = 0) const;

  void   PutAsDouble(int, int, int, double);

  void   PutAsDouble(int, int, int, int, double);

  const char *NameOfClass();
  
  void *GetScalarPointer(int = 0, int = 0, int = 0, int = 0) const;

  virtual int GetScalarType() const;
  
  virtual double GetScalarTypeMin() const;

  virtual double GetScalarTypeMax() const;

};

template <class VoxelType> inline void irtkGenericImage<VoxelType>::Put(int x, int y, int z, VoxelType val)
{
#ifdef NO_BOUNDS
  _matrix[0][z][y][x] = val;
#else
  if ((x >= _x) || (x < 0) || (y >= _y) || (y < 0) || (z >= _z) || (z < 0) || (_t != 0)) {
    cout << "irtkGenericImage<VoxelType>::Put: parameter out of range\n";
  } else {
    _matrix[0][z][y][x] = static_cast<VoxelType>(val)
  }
#endif
}

template <class VoxelType> inline void irtkGenericImage<VoxelType>::Put(int x, int y, int z, int t, VoxelType val)
{
#ifdef NO_BOUNDS
  _matrix[t][z][y][x] = val;
#else
  if ((x >= _x) || (x < 0) || (y >= _y) || (y < 0) || (z >= _z) || (z < 0) || (t >= _t) || (t < 0)) {
    cout << "irtkGenericImage<VoxelType>::Put: parameter out of range\n";
  } else {
    _matrix[t][z][y][x] = val;
  }
#endif
}

template <class VoxelType> inline void irtkGenericImage<VoxelType>::PutAsDouble(int x, int y, int z, double val)
{
  if (val > voxel_limits<VoxelType>::max()) val = voxel_limits<VoxelType>::max();
  if (val < voxel_limits<VoxelType>::min()) val = voxel_limits<VoxelType>::min();  

#ifdef NO_BOUNDS
  _matrix[0][z][y][x] = static_cast<VoxelType>(val);
#else
  if ((x >= _x) || (x < 0) || (y >= _y) || (y < 0) || (z >= _z) || (z < 0) || (_t > 0) {
    cout << "irtkGenericImage<Type>::PutAsDouble: parameter out of range\n";
  } else {
    _matrix[0][z][y][x] = static_cast<VoxelType>(val);
  }
#endif
}

template <class VoxelType> inline void irtkGenericImage<VoxelType>::PutAsDouble(int x, int y, int z, int t, double val)
{
  if (val > voxel_limits<VoxelType>::max()) val = voxel_limits<VoxelType>::max();
  if (val < voxel_limits<VoxelType>::min()) val = voxel_limits<VoxelType>::min();  

#ifdef NO_BOUNDS
  _matrix[t][z][y][x] = static_cast<VoxelType>(val);
#else
  if ((x >= _x) || (x < 0) || (y >= _y) || (y < 0) || (z >= _z) || (z < 0) || (t >= _t) || (t < 0)) {
    cout << "irtkGenericImage<Type>::PutAsDouble: parameter out of range\n";
  } else {
    _matrix[t][z][y][x] = static_cast<VoxelType>(val);
  }
#endif
}

template <class VoxelType> inline VoxelType irtkGenericImage<VoxelType>::Get(int x, int y, int z, int t) const
{
#ifdef NO_BOUNDS
  return (_matrix[t][z][y][x]);
#else
  if ((x >= _x) || (x < 0) || (y >= _y) || (y < 0) || (z >= _z) || (z < 0) || (t >= _t) || (z < t)) {
    cout << "irtkGenericImage<Type>::Get: parameter out of range\n";
    return 0;
  } else {
    return(_matrix[t][z][y][x]);
  }
#endif
}

template <class VoxelType> inline double irtkGenericImage<VoxelType>::GetAsDouble(int x, int y, int z, int t) const
{
#ifdef NO_BOUNDS
  return (static_cast<double>(_matrix[t][z][y][x]));
#else
  if ((x >= _x) || (x < 0) || (y >= _y) || (y < 0) || (z >= _z) || (z < 0) || (t >= _t) || (t < 0)) {
    cout << "irtkGenericImage<Type>::GetAsDouble: parameter out of range\n";
    return 0;
  } else {
    return (static_cast<double>(_matrix[t][z][y][x]));
  }
#endif

}

template <class VoxelType> inline VoxelType& irtkGenericImage<VoxelType>::operator()(int x, int y, int z, int t)
{
#ifdef NO_BOUNDS
  return (_matrix[t][z][y][x]);
#else
  if ((x >= _x) || (x < 0) || (y >= _y) || (y < 0) || (z >= _z) || (z < 0) || (t >= _t) || (t < 0)) {
    cout << "irtkGenericImage<Type>::(): parameter out of range\n";
    return _matrix[0][0][0][0];
  } else {
    return (_matrix[t][z][y][x]);
  }
#endif
}

template <class VoxelType> inline int irtkGenericImage<VoxelType>::VoxelToIndex(int x, int y, int z, int t) const
{
#ifdef NO_BOUNDS
  return (&(_matrix[t][z][y][x]) - &(_matrix[0][0][0][0]));
#else
  if ((x >= _x) || (x < 0) || (y >= _y) || (y < 0) || (z >= _z) || (z < 0) || (t >= _t) || (t < 0)) {
    cout << "irtkGenericImage<Type>::VoxelToIndex: parameter out of range\n";
    return 0;
  } else {
    return (&(_matrix[t][z][y][x]) - &(_matrix[0][0][0][0]));
  }
#endif
}

template <class VoxelType> inline VoxelType *irtkGenericImage<VoxelType>::GetPointerToVoxels(int x, int y, int z, int t) const
{
#ifdef NO_BOUNDS
  return &(_matrix[t][z][y][x]);
#else
  if ((x >= _x) || (x < 0) || (y >= _y) || (y < 0) || (z >= _z) || (z < 0) || (t >= _t) || (t < 0)) {
    cout << "irtkGenericImage<Type>::GetPointerToVoxels: parameter out of range\n";
    cout << x << " " << y << " " << z << " " << t << endl;
    return NULL;
  } else {
    return &(_matrix[t][z][y][x]);
  }
#endif
}

template <class VoxelType> inline void *irtkGenericImage<VoxelType>::GetScalarPointer(int x, int y, int z, int t) const
{
#ifdef NO_BOUNDS
  return &(_matrix[t][z][y][x]);
#else
  if ((x >= _x) || (x < 0) || (y >= _y) || (y < 0) || (z >= _z) || (z < 0) || (t >= _t) || (t < 0)) {
    cout << "irtkGenericImage<Type>::GetScalarPointer: parameter out of range\n";
    cout << x << " " << y << " " << z << " " << t << endl;
    return NULL;
  } else {
    return &(_matrix[t][z][y][x]);
  }
#endif
}

template <> inline int irtkGenericImage<char>::GetScalarType() const
{
   return IRTK_VOXEL_CHAR;
}

template <> inline int irtkGenericImage<unsigned char>::GetScalarType() const
{
   return IRTK_VOXEL_UNSIGNED_CHAR;
}

template <> inline int irtkGenericImage< unsigned short>::GetScalarType() const
{
   return IRTK_VOXEL_UNSIGNED_SHORT;
}

template <> inline int irtkGenericImage<short>::GetScalarType() const
{
   return IRTK_VOXEL_SHORT;
}

template <> inline int irtkGenericImage<float>::GetScalarType() const
{
   return IRTK_VOXEL_FLOAT;
}

template <> inline int irtkGenericImage<double>::GetScalarType() const
{
   return IRTK_VOXEL_DOUBLE;
}

template <class VoxelType> inline double irtkGenericImage<VoxelType>::GetScalarTypeMin() const
{
   return std::numeric_limits<VoxelType>::min();
}

template <class VoxelType> inline double irtkGenericImage<VoxelType>::GetScalarTypeMax() const
{
   return std::numeric_limits<VoxelType>::max();
}

#endif

Generated on Mon Mar 23 16:55:52 2009 for IRTK by Doxygen 1.5.4