nrro.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     9-17-02
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2002 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

//nrro.h

/// nrro, a nrrd object wrapper.

#ifndef __NRRO_DOT_H
#define __NRRO_DOT_H

#include <nrrd.h>
#include <arrayGutz.h>
#include <mathGutz.h>
#include <smartptr.h>
#include <iostream>
#include <vector>
#include <string>
#include "nrroKernel.h"

#define MAX_NRRO_ARRAY_DIM 8

class NrroProbe;

/////////////////////////////////////////////////////////////////////////
/// NRRO,  NRRd Object, "Not Really Raster Object"
///
///  TODO: move to GUTZ ??? \n
///  TODO: only node centered data?
///        this means that a axis of length 1 has spatial size 0 ...
///        no matter the spacing!
///
///
/////////////////////////////////////////////////////////////////////////

class Nrro : public gutz::Counted {
public:
   Nrro(); //<Empty Nrro 
   Nrro(int typeEnum, int sx);  //< 1D
   Nrro(int typeEnum, int sx, int sy); //< 2D
   Nrro(int typeEnum, int sx, int sy, int sz); //< 3D
   Nrro(int typeEnum, int sx, int sy, int sz, int sw); //< 4D
   Nrro(int typeEnum, int s1, int s2, int s3, int s4, int s5); //< 5D
   Nrro(int typeEnum, int dim, int sz[]); //< ND
   Nrro(const Nrro &n); //<Copy Constructor
   Nrro(const char* nrrdFileName, bool proxy = false);//<Read Nrrd from file
   Nrro(Nrrd* n); //<Wrap a Nrrd in a Nrro
   virtual ~Nrro(); //<Destruction

   ////////////////////////////////////////////////////
   /// assignment
   void operator=(const Nrro &n);

   ////////////////////////////////////////////////////
   /// does this nrro contain any usefull information?
   bool          isValid() const    {return _valid;}
   ////////////////////////////////////////////////////
   ///@name Modified - should be Depricated
   ///@{

   /// has it been changed?
   bool          isModified() const           {return _modified;}
   void          setModified(bool mod = true) {_modified = mod;}
   
   ///@}

   /// bring it up to date. isModified() will be false after.
   /// Updates: strides, extended format, minmax
   /// only worry about this if you change something about this
   /// nrro, like values or it's size.
   virtual void  update();

   /////////////////////////////////////////////////////
   ///@name Kinds of Nrros 
   /// for more symantic meaning, 
   /// without subclassing, this might not be a good idea?
   /// This class tries to be smart about guessing what
   /// kind of nrrd it is, see <nrroKind.cpp> for rules
   /// These can be "or'ed" together for instance: 
   /// \code IMAGE | TIME_SERIES | PROXY \endcode 
   ///  is a movie (time series image) with no data, 
   ///  just info on it's size and dimensions etc....
   ///@{

   enum  NRRO_KINDS{
      KIND_NOT_SET = 0,     ///< We dont know, and haven't even guessed yet
      KIND_UNKNOWN = 1<<0,  ///< just a Nrro, no symantics, default if no guess 
      IMAGE        = 1<<1,  ///< a 2D image, may have multiple channels
      VOLUME       = 1<<2,  ///< a 3D volume (mutually exclusive with IMAGE)
      TIME_SERIES  = 1<<3,  ///< a time series of ...
      PROXY        = 1<<4,  ///< no data read, just info on the volume 
      KIND_LAST    = 1<<5 | 1<<0
   };
   int       getKind() const   {return _kind;}
   /// guess what kind of data we have
   int       guessKind() const; 
   /// set the kind of data, 
   ///  to make it a proxy try:
   /// setKind(getKind() | Nrro::PROXY);
   ///  to make it "not" a PROXY try
   /// setKind(getKind() & (~Nrro::PROXY))
   void      setKind(int kind) {_kind = kind;}
   /// print kind to std::err
   void      printKind() const;

   ///@}
   /////////////////////////////////////////////////////

   /////////////////////////////////////////////////////
   ///@name Nrro Types
   ///@{

   /// Let's go ahead and redefine all of the nrrd types
   /// ... so we don't have to dig through all of gk's .h
   /// use Nrro::CHAR, for example
   enum  NRRO_TYPES  {
      UNKNOWN     = nrrdTypeUnknown,
      CHAR        = nrrdTypeChar,
      UCHAR       = nrrdTypeUChar,
      SHORT       = nrrdTypeShort,
      USHORT      = nrrdTypeUShort,
      INT         = nrrdTypeInt,
      UINT        = nrrdTypeUInt,
      FLOAT       = nrrdTypeFloat,
      DOUBLE      = nrrdTypeDouble,
      BLOCK       = nrrdTypeBlock,
      TYPE_LAST   = nrrdTypeLast
   }; /////////////////////////////////////////////////
   ////////////////////////////////////////////////////
   /// Type of nrrd contained here.
   ///   From nrrdEnums.h, same as above
   /// You'll need this to get the correct iterator.
   int           getType()  const {if(_nrrd)return _nrrd->type; return UNKNOWN;}
   void          printType() const;

   ///@}
   /////////////////////////////////////////////////////


   ////////////////////////////////////////////////////
   ///@name  Read & Save
   ///@{

   ///read returns 0 if read, 1 if error
   /// proxy nrro's don't have data, just dimension and type info
   virtual int   readNrrd(const char *nrrdFileName, bool proxy = false);
   ///save returns 0 if read, 1 if error
   virtual int   saveNrrd(const char *nrrdFileName);

   ///@}
   ////////////////////////////////////////////////////

   //////////////////////////////////////////////////
   ///@name get/set the nrrd for direct nrrd hacking! 
   ///   Yummy, be very carefull here
   ///@{
   Nrrd*         getNrrd()  const {assert(_nrrd); return _nrrd;}
   void          setNrrd(Nrrd *n);
   ///@}

   //////////////////////////////////////////////////
   ///@name get the data for even more direct hacking um..
   ///@{
   void*         getData() const  {return _nrrd->data;}
   ///@}

   ////////////////////////////////////////////////////
   ///@name Dimensions & axis info
   ///@{

   /// how many axies does this object contain?
   int  dim() const              {return _nrrd->dim;}
   /// how many values along an axis?
   int  dim(int a) const         {return _nrrd->axis[a].size;}
   /// how many values are not from pading?
   int  dimNPad(int a) const     {return _pads[a].y - _pads[a].x + 1;}
   /// what is the physical length of the axis?
   float         axisSize(int a) const    {return float(dim(a)-1) * axisSpacing(a);}
   /// what is the physical length, ignoring paded values?
   float         axisSizeNPad(int a) const;
   /// what is the physical spacing between values along an axis
   float         axisSpacing(int a) const {return float(_nrrd->axis[a].spacing);}
   void          setAxisSpacing(int a, float s) {_nrrd->axis[a].spacing = s;}
   /// what is the name of the axis
   char*         axisName(int a) const    {return _nrrd->axis[a].label;}
   /// what are the units of the axis
   char*         axisUnit(int a) const    {return _nrrd->axis[a].unit;}
   /// ranges of unpadded values along an axis
   gutz::vec2ui  axisValNPad(int a) const {return _pads[a];}
   /// total size of data
   int  size() const;
   /// strides for accessing fast!
   int           getStride(int a) const   { return _strides[a]; }
   /// min/max values in nrro, r.x = min, r.y = max <nrroGinsu.cpp>
   gutz::vec2d   getMinMax() const { return _minmax; }

   ///@}
   ////////////////////////////////////////////////////

   ////////////////////////////////////////////////////
   ///@name Position & size
   /// only meaningfull if nrro has a spatial position & size
   ///@{
   gutz::vec3f   getPos() const           {return _pos;}
   void          setPos(gutz::vec3f pos)  {_pos = pos;}
   /// ignores padded part, doesn't work for time series 4D vols
   gutz::vec3f   getSizeV3() const;
   ///@}

   ////////////////////////////////////////////////////
   ////////////////////////////////////////////////////
   ///@name Ginsu : Slice and Dice 
   ///   see nrroGinsu.cpp
   ///@{

   ////////////////////////////////////////////////////
   /// Quantize, set min/max if you want to, otherwise
   ///   we'll figure out what they are
   gutz::SmartPtr<Nrro> quantize(int bits, double min = AIR_NAN, double max = AIR_NAN);

   ////////////////////////////////////////////////////
   /// slice, get a slice on axis at pos
   gutz::SmartPtr<Nrro>  slice(int axis, int pos);

   ////////////////////////////////////////////////////
   /// crop, 
   ///   set axis pos to -1 if you want it left unchanged
   gutz::SmartPtr<Nrro>  crop(int min[], int max[]);

   ////////////////////////////////////////////////////
   /// pad, pad out the volume.
   enum NRRO_BOUNDARY_BEHAVIORS{  //< what to do at the boundary when padding
      PAD   = nrrdBoundaryPad,    //< padd with a specified value
      BLEED = nrrdBoundaryBleed,  //< bleed boundary values
      WRAP  = nrrdBoundaryWrap    //< wrap to other side of axis
   }; 
   /// be sure that min and max are valid values, 
   ///  "-1" for min would pad back 1 voxel!!!!
   gutz::SmartPtr<Nrro>  pad(int min[], int max[], int bound = PAD, double padval = 0.0);

   ///////////////////////////////////////////////////
   /// pad and or crop to exact size
   gutz::SmartPtr<Nrro> cropPad(int min[], int max[], int bound = PAD, double padval = 0.0);

   ///////////////////////////////////////////////////
   /// resample. 
   /// if dims[1] == -1 leave the axis alone
   /// can use any kind of kernel, 
   /// if dims[i] == dim(i) than filter axis, but don't resize
   /// if typeOut == UKNOWN than output the same type of nrro
   gutz::SmartPtr<Nrro>  resample(int dims[], 
                                  const NrroKernel &kern = CatmulRomKernel,
                                  int bound = BLEED,
                                  int typeOut = UNKNOWN);
   gutz::SmartPtr<Nrro>  resample(float pct = 1.0f);
      
   ///////////////////////////////////////////////////
   /// insert axis
   int  insertAxis(unsigned int axis);   

   ///@}
   ////////////////////////////////////////////////////

   ////////////////////////////////////////////////////
   /// This makes all kinds of nrros multi-channel.
   /// - Images       3D: N channels + 2 spatial axes
   /// - Time Images  4D: N channels + 2 spatial + 1 time
   /// - Volumes      4D: N channels + 3 spatial axes
   /// - Time Volumes 5D: N channels + 3 spatial + 1 time
   /// - Unknown kinds are left alone. <nrroKind.cpp>
   int forceMultiChannel(); 

   ////////////////////////////////////////////////////
   ///@name Name 
   ///   like a comment, but, well, a name
   ///@{
   std::string   getName() const           {return _name;}
   void          setName(std::string name) {_name = name;}
   ///@}

   ////////////////////////////////////////////////////
   /// Print out what the nrro is, stderr right now
   void printInfo() const;

   ////////////////////////////////////////////////////
   ///@name comments
   ///  see nrroComment.cpp \n
   ///   can also be manipulated using "keys" which use
   ///   simple text strings as identifiers, 
   ///   This is how we extend the nrrd format, we save
   ///   things like the position, and pads in comments.
   ///  You must make sure key/comment pairs have valid
   ///  strings for both key and comment, if not, you
   ///  could get duplicate empty key/comment pairs
   ///@{
   int          numComments() const;
   std::string  getComment(int i);
   std::string  getComment(const std::string key);
   void         addComment(const std::string comment);
   void         addComment(const std::string key, const std::string comment);
   void         setComment(int i, const std::string comment);
   void         setComment(const std::string key, const std::string comment);
   ///@}
   
   /////////////////////////////////////////////////////
   /// ignore this class, it just represents a double
   /// for assignment.
   ///
   ///  This class represents un-typed data elements,
   /// local accessors [v() & ()] are pure doubles (LCD)
   /// they will be slow, you should use iterators for
   /// speed
   class __dbl {
   public:
      __dbl(Nrro *n, int pos) : _n(n), _pos(pos) {}
      ~__dbl(){}
      double operator=(const __dbl &vp);
      /// repeats, avoid upcast for simple assignments
      double         operator=(double v)          {return assn<double>(v);}
      float          operator=(float v)           {return assn<float>(v);}
      unsigned short operator=(unsigned short v)  {return assn<unsigned short>(v);}
      short          operator=(short v)           {return assn<short>(v);}
      unsigned int   operator=(unsigned int v)    {return assn<unsigned int>(v);}
      int            operator=(int v)             {return assn<int>(v);}
      char           operator=(char v)            {return assn<char>(v);}
      double         operator+=(double v)         {return assn<double>(val() + v);}
      double         operator-=(double v)         {return assn<double>(val() - v);}
      double         operator++()                 {return assn<double>(val() + 1);}
      double         operator--()                 {return assn<double>(val() - 1);}
      double         val() const;
      template<class T>
         T assn(T val);
      /// danger danger, auto typecast to double, fail safe
      operator double() const {return val();}
   protected:
      Nrro *_n;
      int   _pos;
   };

   /////////////////////////////////////////////////////
   ///@name Accessors.
   /// ()/v() access, use either v(), or operator(), 
   ///   they are the same thing. example: 
   /// \code
   /// Nrro n;  n(1,3,5) = n(3,1,5); /// set index[5][1][3] to value at index...
   /// \endcode
   /// or use the alias for clean looking SmartPointer code: 
   /// \code
   /// NrroSP n; n->v(1,3,5) = n->v(3,1,5); /// same as above
   /// \endcode
   /// you have accessors from 1 to 6 dimensions.
   /// remeber () access is fliped from c arrays (x,y,z) vs. [z][y][x]
   ///@{
   double v(int i1) const                        {return val<double>(i1);}
   double operator()(int i1) const               {return v(i1);}
   __dbl v(int i1)                               {return __dbl(this,i1);}
   __dbl operator()(int i1)                      {return v(i1);}
   double v(int i1, int i2) const                {return val<double>(a(i1, i2));}
   double operator()(int i1, int i2) const       {return v(i1, i2);}
   __dbl v(int i1, int i2)                       {return __dbl(this,a(i1,i2));}
   __dbl operator()(int i1, int i2)              {return v(i1,i2);}
   double v(int i1, int i2, int i3, int i4=0) const;
   double operator()(int i1, int i2, int i3, int i4=0) const {return v(i1,i2,i3,i4);}
   __dbl v(int i1, int i2, int i3, int i4=0); 
   __dbl operator()(int i1, int i2, int i3, int i4=0) {return v(i1,i2,i3,i4);} 
   double v(int i1, int i2, int i3, int i4, int i5, int i6=0) const;
   double operator()(int i1, int i2, int i3, int i4, int i5, int i6=0) const;
   __dbl v(int i1, int i2, int i3, int i4, int i5, int i6=0);
   __dbl operator()(int i1, int i2, int i3, int i4, int i5, int i6=0);
   template<class T>
   T val(int pos) const; //< const 1D value getter
   /// fast addressing
   int a(int i1, int i2=0) const                       {return i1 + i2*getStride(1);}
   int a(int i1,int i2, int i3, int i4=0) const;
   int a(int i1, int i2, int i3, int i4, int i5, int i6=0) const;
   ///@}

   ////////////////////////////////////////////////////
   /// Iterator, generic type, use gen functions
   /// TODO: need to make a const iterator too!, I think it works
   /// NOTE: this includes a -> that gives you the nrro
   /// so, this suffices as a typed nrro object. 
   /// NOTE: if you use an iterator internal to this object
   /// you shoud increment your ref count before use, then
   /// decrement after, to avoid having it nuke you!!!
   template<class T>
   class NrroIter {
   public:
      NrroIter(Nrro *n, int pos = 0);
      NrroIter(const NrroIter &ni);
      virtual ~NrroIter(){}
      T &operator*()                            {return *_d;}
      const T &operator*() const                {return *_d;}
      Nrro *operator->()                        {return _n.getPtr();}
      const Nrro *operator->() const            {return _n.getPtr();}
      NrroIter &operator=(const NrroIter &ni);  //< below
      NrroIter &operator=(int pos)              {_d = _n.getData() + pos;  return *this;}
      const NrroIter &operator+=(int dpos) const{_d += dpos; _pos += dpos; return *this;}
      NrroIter &operator+=(int dpos)            {_d += dpos; _pos += dpos; return *this;}
      const NrroIter &operator-=(int dpos) const{_d -= dpos; _pos -= dpos; return *this;}
      NrroIter &operator-=(int dpos)            {_d -= dpos; _pos -= dpos; return *this;}
      bool operator==(const NrroIter &ni) const;//< below
      bool operator!=(const NrroIter &ni) const {return (! (*this) == ni );}
      bool operator>(const NrroIter &ni) const  {return _pos > ni._pos;}
      bool operator<(const NrroIter &ni) const  {return _pos < ni._pos;}
      bool operator>=(const NrroIter &ni) const {return _pos >= ni._pos;}
      bool operator<=(const NrroIter &ni) const {return _pos <= ni._pos;}
      bool isValid() const                      
           {return ((_pos >= 0) && (_pos < int(_n->size())));}
      const NrroIter &operator++() const        {++_d; ++_pos; return *this;}
      NrroIter &operator++()                    {++_d; ++_pos; return *this;}
      const NrroIter  operator++(int) const     
           {NrroIter<T> tmp = *this; ++(*this); return tmp;}
      NrroIter  operator++(int)                 
           {NrroIter<T> tmp = *this; ++(*this); return tmp;}
      const NrroIter &operator--() const        {--_d; --_pos; return *this;}
      NrroIter &operator--()                    {--_d; --_pos; return *this;}
      const NrroIter  operator--(int) const     
           {NrroIter<T> tmp = *this; --*this; return tmp;}
      NrroIter  operator--(int)                 
           {NrroIter<T> tmp = *this; --*this; return tmp;}
      const NrroIter operator+(int dpos) const  
           {return NrroIter<T>(const_cast<Nrro*>(_n.getPtr()),_pos+dpos); } 
      NrroIter operator+(int dpos)              {return NrroIter<T>(_n,_pos+dpos); } 
      const NrroIter operator-(int dpos) const  
           {return NrroIter<T>(const_cast<Nrro*>(_n.getPtr()),_pos-dpos); }
      NrroIter operator-(int dpos)              {return NrroIter<T>(_n,_pos-dpos); }
      /// difference of Iterators
      int       operator-(const NrroIter &ni) const {return _pos - ni._pos; }
      /// this accesses in 1D from current Iterator position
      T        &operator[](int pos)             {return (*(*this + pos));}
      T         operator[](int pos) const       {return (*(*this + pos));}
      /// ()accessors are backwards from []ops, ie. (x,y,z,w) vs [w][z][y][x]
      /// they access from begining of nrro data array, not current iter pos
      T         operator()(int i1) const        {return ((T*)(_n->getData()))[i1];}
      T        &operator()(int i1)              {return ((T*)(_n->getData()))[i1];}
      T         operator()(int i1, int i2) const;
      T        &operator()(int i1, int i2);
      T         operator()(int i1, int i2, int i3, int i4=0) const;
      T        &operator()(int i1, int i2, int i3, int i4=0);
      T         operator()(int i1, int i2, int i3, int i4, int i5, int i6=0) const;
      T        &operator()(int i1, int i2, int i3, int i4, int i5, int i6=0);
      int       pos() const {return _pos;}
   protected:
      gutz::SmartPtr<Nrro> _n;
      mutable int    _pos;
      mutable T*     _d;
   private:
      NrroIter(); //not used
   };

   ////////////////////////////////////////////////////
   ///@name Get Iterators
   /// sorry but you have to explicitly ask for the right type:
   /// NrroIter<char> niter = nrro->begin<char>()
   /// see nrroDispatch.h for some short cuts to grabbing the right type
   ///@{
   template<class T>
      NrroIter<T> begin() { return NrroIter<T>(this, 0); }
   template<class T>
      NrroIter<T> last() { return NrroIter<T>(this, int(size())-1); }
   template<class T>
      const NrroIter<T> end() const { return NrroIter<T>(this,int(size())); }
   ///@}

   ////////////////////////////////////////////////////
   /// set the strides, for fast access, usually you won't have to 
   /// worry about this, when things change internally, this is 
   /// called automatically, if you muck with the dimensions yourself
   /// be sure to update the strides
   virtual void setStrides();


protected:
   /// initiallize member variables
   virtual void initMembers();
   /// erase the nrrd and other stuff
   virtual void erase();
   /// copy a nrro object
   virtual void copy(const Nrro &n);
   /// send a real error message
   inline
      void NrroErr(const char *s, const char *s2=0) const;
   /// message for debugging purposes
   inline
      void NrroDbg(const char *s, const char *s2=0) const;

   ////////////////////////////////////////////////////
   /// Extended features: <nrroExtended.cpp>
   /// this next one updates the extended nrrd format
   /// by adding things like pos and pads to the comments
   /// these can be read in with the nrro after it has
   /// been saved. These don't actually write the nrro
   /// to disk, they just update the comment fields
   virtual void    readExtended();
   virtual void    writeExtended();

   ////////////////////////////////
   ///  DATA
   ////////////////////////////////

   /// the nrrd struct, from teem
   Nrrd  *_nrrd;

   ////////////////////////////////
   ///  Extended format data
   ///  see <nrroExtended.cpp>
   ////////////////////////////////

   /// Symantics - Kind of Nrro 
   int    _kind;
   virtual void writeKind();
   virtual void readKind();

   /// if padded, where is the "real" data
   gutz::arrayo1v2ui _pads;
   virtual void writePads();
   virtual void readPads();

   /// what is the spatial position of this data,
   /// may not always be relevant
   gutz::vec3f  _pos;
   virtual void writePos();
   virtual void readPos();

   /// does he have a name
   std::string _name;
   virtual void writeName();
   virtual void readName();

   ////////////////////////////////
   ///  Other data
   ///  just some stuff we need to
   ///  keep track of while the 
   ///  nrro is in use
   ////////////////////////////////

   /// strides for easy/fast access
   int    _strides[MAX_NRRO_ARRAY_DIM];

   /// does this guy actuall contain something usefull?
   bool   _valid;
   bool   _modified;

   /// original file name
   std::string _fileName;

   /// cache some slow to compute, but likely static 
   /// values
   void updateMinMax();
   gutz::vec2d   _minmax; //< min and max values in double
   unsigned int  _size;   //< total # of elements
private:

};

//////////////////////////////////////////////////////////////////////////
/// Pre defined containers
//////////////////////////////////////////////////////////////////////////

typedef gutz::SmartPtr<Nrro>          NrroSP;
typedef std::vector<NrroSP>           NrroSPVec;
typedef std::vector<NrroSP>::iterator NrroSPVecIter;

//////////////////////////////////////////////////////////////////////////
/// Extended format keys, <nrroExtended.cpp>
//////////////////////////////////////////////////////////////////////////
extern const std::string NRRO_KIND_KEY;
extern const std::string NRRO_PADS_KEY;
extern const std::string NRRO_POS_KEY;
extern const std::string NRRO_NAME_KEY;

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
/// some implementation
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
/// send a real error message
inline
void Nrro::NrroErr(const char *s, const char *s2) const
{
   std::cerr << " -";
   if(!_name.empty())
      std::cerr << _name;
   else
      std::cerr << "Un-named Nrro";
   std::cerr << std::endl;

   std::cerr << "Error, Nrro::" << s;
   if(s2) std::cerr << " : " << s2;
   std::cerr << std::endl;
}
/// message for debugging purposes
inline
void Nrro::NrroDbg(const char *s, const char *s2) const
{
#ifdef _DEBUG
   std::cerr << " -";
   if(!_name.empty())
      std::cerr << _name;
   else
      std::cerr << "Un-named Nrro";
   std::cerr << std::endl;

   std::cerr << "Debug, Nrro::" << s;
   if(s2) std::cerr << " : " << s2;
   std::cerr << std::endl;
#endif
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
/// Public inlines
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
/// Accessors
//////////////////////////////////////////////////////////////////////////

template <class T>
inline 
T Nrro::val(int pos) const //< 1D value getter
{
   switch(getType())
   {
   case Nrro::CHAR:
      return T( ( ((char*)getData())[pos] ) );
      break;
   case Nrro::UCHAR:
      return T( ( ((unsigned char*)getData())[pos] ) );
      break;
   case Nrro::SHORT:
      return T( ( ((short*)getData())[pos] ) );
      break;
   case Nrro::USHORT:
      return T( ( ((unsigned short*)getData())[pos] ) );
      break;
   case Nrro::INT:
      return T( ( ((int*)getData())[pos]) );
      break;
   case Nrro::UINT:
      return T( ( ((unsigned int*)getData())[pos] ) );
      break;
   case Nrro::FLOAT:
      return T( ( ((float*)getData())[pos] ) );
      break;
   case Nrro::DOUBLE:
      return T( ( ((double*)getData())[pos] ) );
      break;
   }
   return 0.0;
}

inline
int Nrro::a(int i1,int i2, int i3, int i4) const
{
   return a(i1,i2) + i3*getStride(2) + i4*getStride(3);
}

inline
double Nrro::v(int i1, int i2, int i3, int i4) const
{
   return val<double>(a(i1,i2,i3,i4));
}

inline
Nrro::__dbl Nrro::v(int i1, int i2, int i3, int i4)
{
   return __dbl(this,a(i1,i2,i3,i4));
}

inline
int Nrro::a(int i1, int i2, int i3, int i4, int i5, int i6) const
{
   return a(i1,i2,i3,i4) + i5*getStride(4) + i6*getStride(5);
}

inline
double Nrro::v(int i1, int i2, int i3, int i4, int i5, int i6) const
{
   return val<double>(a(i1,i2,i3,i4,i5,i6));
}

inline
Nrro::__dbl Nrro::v(int i1, int i2, int i3, int i4, int i5, int i6)
{
   return __dbl(this,a(i1,i2,i3,i4,i5,i6));
}

inline
double Nrro::operator()(int i1, int i2, int i3, int i4, int i5, int i6) const
{
   return v(i1,i2,i3,i4,i5,i6);
}

inline
Nrro::__dbl Nrro::operator()(int i1, int i2, int i3, int i4, int i5, int i6)
{
   return v(i1,i2,i3,i4,i5,i6);
}

//////////////////////////////////////////////////////////////////////////
/// value proxy
//////////////////////////////////////////////////////////////////////////
inline
double Nrro::__dbl::val() const
{
   return _n->val<double>(_pos);
}

inline
double Nrro::__dbl::operator=(const __dbl &vp)
{
   return operator=(vp.val());
}

/// here is why I bothered to template this:
/// if you maybe know the type, you can assign it without
/// an upcast and then a down cast, for instance:
/// n.assn<char>(10); /// the nrro has char data
/// this is just a minor speed issue, 
/// but probably worth the effort.
/// TODO: use arrays of pointers instead of switches!!!
template<class T>
inline
T Nrro::__dbl::assn(T val)
{
   ///Yuk, you are doing this switch every assignment!!,
   /// and access too for that matter, slow slow.
   switch(_n->getType())
   {
   case Nrro::CHAR:
      /// to type cast reslut to requested type <class T>..
      /// cast (void*) data ptr to the real data type ptr,
      /// increment position to where it needs to be,
      /// de-reference ptr, and assign the value.
      /// cast reslut to <class T>
      /// castT( (dref((cast to (real)) + offset) ) = val)
      return T( (*( ((char*)_n->getData()) + _pos) ) = (char)val );
      break;
   case Nrro::UCHAR:
      return T((*(((char*)_n->getData()) + _pos)) = (char)val);
      break;
   case Nrro::SHORT:
      return T((*(((short*)_n->getData()) + _pos)) = (short)val);
      break;
   case Nrro::USHORT:
      return T((*(((unsigned short*)_n->getData()) + _pos)) = (unsigned short)val);
      break;
   case Nrro::INT:
      return T((*(((int*)_n->getData()) + _pos)) = (int)val);
      break;
   case Nrro::UINT:
      return T((*(((unsigned int*)_n->getData()) + _pos)) = (unsigned int)val);
      break;
   case Nrro::FLOAT:
      return T((*(((float*)_n->getData()) + _pos)) = (float)val);
      break;
   case Nrro::DOUBLE:
      return T((*(((double*)_n->getData()) + _pos)) = val);
      break;
   }
   return val;
}

//////////////////////////////////////////////////////////////////////////
/// Iterator implementation
//////////////////////////////////////////////////////////////////////////
template<class T>
Nrro::NrroIter<T>::
NrroIter(Nrro *n, int pos)
: _pos(pos), _n(gutz::SmartPtr<Nrro>(n))
{
   if(!n)
   {
      std::cerr << "NrroIter::NrroIter(), null nrro!!!" << std::endl;
      _d = 0;
   }
   else
   {
      _d = (T*)(n->getData());
   }
}

template<class T>
Nrro::NrroIter<T>::
NrroIter(const NrroIter &ni)
: _d(ni._d), _pos(ni._pos), _n(ni._n)
{}

template<class T>
Nrro::NrroIter<T> &Nrro::NrroIter<T>::
operator=(const NrroIter<T> &ni)
{
   _d = ni._d;
   _n = ni._n;
   _pos = ni._pos;
   return this;
}

template<class T>
bool Nrro::NrroIter<T>::
operator==(const NrroIter<T> &ni) const
{
   if(ni._pos != _pos) return false;
   if(ni._n != _n) return false;
   return true;
}

template<class T>
inline
T &Nrro::NrroIter<T>::
operator()(int i1, int i2, int i3, int i4, int i5, int i6)
{
   return ((T*)(_n->getData()))[ _n->a(i1,i2,i3,i4,i5,i6) ];
}

template<class T>
inline
T Nrro::NrroIter<T>::
operator()(int i1, int i2, int i3, int i4, int i5, int i6) const
{
   return ((T*)(_n->getData()))[ _n->a(i1,i2,i3,i4,i5,i6) ];
}

template<class T>
inline
T &Nrro::NrroIter<T>::
operator()(int i1, int i2)
{
   return ((T*)(_n->getData()))[ _n->a(i1,i2) ];
}

template<class T>
inline
T Nrro::NrroIter<T>::
operator()(int i1, int i2) const
{
   return ((T*)(_n->getData()))[ _n->a(i1,i2) ];
}

template<class T>
inline
T &Nrro::NrroIter<T>::
operator()(int i1, int i2, int i3, int i4)
{
   return *(((T*)(_n->getData()))+_n->a(i1,i2,i3,i4)); 
}

template<class T>
inline
T Nrro::NrroIter<T>::
operator()(int i1, int i2, int i3, int i4) const
{
   return *(((T*)(_n->getData())) + _n->a(i1,i2,i3,i4)); 
}

//template<class T, int TYPEENUM>
//const NrroIter<T> end() const;

#endif

---

Send questions, comments, and bug reports to: