nrro.cpp

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.cpp
// Q:Why is this sooooo harry?
// A:Gordon "jeek" Kindlman (Kindlemmon), he coded TEEM & NRRD in "ANSI C"
//   This means, that I kind of need to follow his progamatic way of thinking,
//   The nice thing is no crazy templating and dynamic casting, I added some
//   semantics "image, volume, etc..."  to this class with out subclassing, 
//   keeping in the spirit of having an object that could be any type and also
//   and "kind" of data.  This class is probably incomplete, lots of functionality
//   in TEEM, I try to keep up :)

//nrro, a nrrd object wrapper.

#include "nrro.h"
#include "nrroProbe.h"
#include <iostream>
#include <air.h>

using namespace std;
using namespace gutz;

/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
//Nrro
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////
// Construction / Destruction
/////////////////////////////////////////////////////////////////////////

Nrro::Nrro()
{
   initMembers();
   NrroDbg("Nrro(), empty nrrd object");
   _nrrd = nrrdNew();
   for(int i=0; i<MAX_NRRO_ARRAY_DIM; ++i)
   {
      _strides[i] = 0;
   }
   update();
   if(_nrrd)
      _valid = true;
}

//copy constructor
Nrro::Nrro(const Nrro &n)
{
   initMembers();
   copy(n);
   update();
   if(_nrrd)
      _valid = true;
}

//ah this looks usefull
Nrro::Nrro(const char *nrrdFileName, bool proxy)
{
   initMembers();
   if(readNrrd(nrrdFileName, proxy))
   {
      _valid = false; 
      return;
   }
   else
   {
      update();
   }
   if(_nrrd)
      _valid = true;
}

Nrro::Nrro(Nrrd* n)
{
   initMembers();
   setNrrd(n);
   update();
   if(_nrrd)
      _valid = true;
}

Nrro::Nrro(int typeEnum, int sx)
{
   initMembers();
   _nrrd = nrrdNew();
   nrrdAlloc(_nrrd, typeEnum, 1, sx);
   for(int i=0; i<dim(); ++i)
     {
       _pads[i].x = 0;
       _pads[i].y = dim(i);
     }
   update();
   if(_nrrd)
     _valid = true;
}

Nrro::Nrro(int typeEnum, int sx, int sy)
{
   initMembers();
   _nrrd = nrrdNew();
   nrrdAlloc(_nrrd, typeEnum, 2, sx, sy);
   for(int i=0; i<dim(); ++i)
     {
       _pads[i].x = 0;
       _pads[i].y = dim(i);
     }
   update();
   if(_nrrd)
     _valid = true;
}

Nrro::Nrro(int typeEnum, int sx, int sy, int sz)
{
   initMembers();
   _nrrd = nrrdNew();
   nrrdAlloc(_nrrd, typeEnum, 3, sx, sy, sz);
   for(int i=0; i<dim(); ++i)
     {
       _pads[i].x = 0;
       _pads[i].y = dim(i);
     }
   update();
   if(_nrrd)
     _valid = true;
}

Nrro::Nrro(int typeEnum, int sx, int sy, int sz, int sw)
{
   initMembers();
   _nrrd = nrrdNew();
   nrrdAlloc(_nrrd, typeEnum, 4, sx, sy, sz, sw);
   for(int i=0; i<dim(); ++i)
     {
       _pads[i].x = 0;
       _pads[i].y = dim(i);
     }
   update();
   if(_nrrd)
     _valid = true;
}

Nrro::Nrro(int typeEnum, int s1, int s2, int s3, int s4, int s5)
{
   initMembers();
   _nrrd = nrrdNew();
   nrrdAlloc(_nrrd, typeEnum, 5, s1, s2, s3, s4, s5);
   for(int i=0; i<dim(); ++i)
     {
       _pads[i].x = 0;
       _pads[i].y = dim(i);
     }
   update();
   if(_nrrd)
     _valid = true;
}

Nrro::Nrro(int typeEnum, int dim, int sz[])
{
   initMembers();
   _nrrd = nrrdNew();
   nrrdAlloc_nva(_nrrd, typeEnum, dim, sz);
   for(int i=0; i<this->dim(); ++i)
     {
       _pads[i].x = 0;
       _pads[i].y = this->dim(i);
     }
   update();
   if(_nrrd)
     _valid = true;
}

//destruct
Nrro::~Nrro()
{
   erase();
}

//assignment operator
void Nrro::operator=(const Nrro &n)
{
   copy(n);
   setModified(true);
   update();
}

void Nrro::initMembers()
{  
   _nrrd = 0;
   _valid = false;
   _modified = true;
   _kind = KIND_NOT_SET;
   _pos = vec3f_zero;
   _pads = arrayo1v2ui(MAX_NRRO_ARRAY_DIM, vec2ui(0,0));
}


/////////////////////////////////////////////////////////////////////////
// Update
/////////////////////////////////////////////////////////////////////////
//this is where we update cached values.
void Nrro::update()
{
   if(!_modified) return;
   if(!_nrrd) 
   {
      _valid = false;
      return;
   }
   
   setStrides();   
   /// update size
   _size = dim(0);
   for(int i=1; i<int(dim()); ++i)
   {
      _size *= dim(i);
   }
   /// min max depends on size!!
   updateMinMax();
   writeExtended();

   setModified(false);
}

/////////////////////////////////////////////////////////////////////////
// axis Size Real
/////////////////////////////////////////////////////////////////////////
float Nrro::axisSizeNPad(int a) const
{
   return float(_nrrd->axis[a].spacing * float(dimNPad(a)-1));
}

/////////////////////////////////////////////////////////////////////////
// size, total number of elementes in nrro
/////////////////////////////////////////////////////////////////////////
int Nrro::size() const
{
   return _size;
}


/////////////////////////////////////////////////////////////////////////
// get Size()
/////////////////////////////////////////////////////////////////////////
gutz::vec3f Nrro::getSizeV3() const
{
   //// sigh, we have to handle symantics here
   /// 2D image, or 3D time series image
   if( ( (dim() == 2)&&(IMAGE & _kind) ) 
      || ( (dim() == 3)&&(IMAGE & _kind)&&(TIME_SERIES & _kind) ))
   {
      return vec3f(axisSizeNPad(0), axisSizeNPad(1), 0.0f);
   }
   /// regular n-channel image, or 4D time series image
   else if(((dim() == 3) && (IMAGE & _kind)) 
      || ((dim()==4)&&(IMAGE & _kind)&&(TIME_SERIES & _kind)))
   {
      return vec3f(axisSizeNPad(1),axisSizeNPad(2),0.0f);
   }
   /// 3D volume or 4D time series volume
   if(((dim() == 3) && (VOLUME & _kind)) 
      || ((dim()==4)&&(VOLUME & _kind)&&(TIME_SERIES & _kind)))
   {
      return vec3f(axisSizeNPad(0),axisSizeNPad(1),axisSizeNPad(2));
   }
   /// 4D volume or 5D time series volume
   else if(((dim() == 4) && (VOLUME & _kind)) 
      || ((dim()==5)&&(VOLUME & _kind)&&(TIME_SERIES & _kind)))
   {
      return vec3f(axisSizeNPad(1),axisSizeNPad(2),axisSizeNPad(3));
   }
   else
   {
      NrroDbg("getSize(), size only valid for 3D & 4D(3+fields) volumes");
      return vec3f_zero;
   }
}

/////////////////////////////////////////////////////////////////////////
// deep copy
/////////////////////////////////////////////////////////////////////////
void Nrro::copy(const Nrro &n)
{
   erase();

   if(n._valid && n._nrrd)
   {
      if( nrrdCopy( _nrrd, (n._nrrd) ) )
      {
         char *nerr = biffGetDone(NRRD);
         cerr << "nrroDat: nrrd copy failed : " << nerr << endl; 
         _valid = false;
      }
      for(int i=0; i<MAX_NRRO_ARRAY_DIM; ++i)
      {
         _strides[i] = n._strides[i];
      }
      _pos = n._pos;
      _valid = true;
      _pads = n._pads;
      _kind = n._kind;
   }
}

/////////////////////////////////////////////////////////////////////////
// erase
/////////////////////////////////////////////////////////////////////////
void Nrro::erase()
{
   if(_nrrd)
   {
      nrrdNuke(_nrrd);
      _valid = false;
      for(int i=0; i<MAX_NRRO_ARRAY_DIM; ++i)
      {
         _strides[i] = 0;
      }
   }
   _nrrd = nrrdNew();
}

/////////////////////////////////////////////////////////////////////////
// set strides
/////////////////////////////////////////////////////////////////////////
void Nrro::setStrides()
{
   // set up strides for accessors
   if(_nrrd->dim < MAX_NRRO_ARRAY_DIM)
   {
      for(int i=0; i<_nrrd->dim; ++i)
      {
         _strides[i] = 1; /// all start with 1
      }
      for(int i=0; i<_nrrd->dim; ++i)
      {
         for(int j=i+1; j<_nrrd->dim; ++j)
         {
            _strides[j] *= _nrrd->axis[i].size; /// multiply by the one under you
         }
      }
      /// zero out all others
      for(int i=_nrrd->dim; i< MAX_NRRO_ARRAY_DIM; ++i)
      {
         _strides[i] = 0;
      }
   } 
   else
   {
      NrroDbg(" WARNING : nrrd dimension greater than max allowd for () accessor ");
   }
}

/////////////////////////////////////////////////////////////////////////
// setNrrd
/////////////////////////////////////////////////////////////////////////
void  Nrro::setNrrd(Nrrd *n)
{
   if(_nrrd)
      nrrdNuke(_nrrd);
   _nrrd = n;

   if(_nrrd)
      _valid = true;
   else
      return;

   setStrides();

   /// TODO: read out pos, tc, and pads from comments
   _pos = vec3f_zero;
   /// set the padds
   for(unsigned int i=0; i<MAX_NRRO_ARRAY_DIM; ++i)
   {
      _pads[i].x = 0;
      _pads[i].y = g_max(int(dim(i)) - 1, 0);
   }
}

/////////////////////////////////////////////////////////////////////////
// printInfo
/////////////////////////////////////////////////////////////////////////
void Nrro::printInfo() const
{
   if(!isValid())
   {
      cerr << " Nrro::printInfo(), invalid Nrro" << endl;
   }

   cerr << " Nrro::printInfo() " << endl;
   printType();
   printKind();
   cerr << "  Name: " << _name << endl;
   cerr << "  Dimension  : " << dim() << endl;
   cerr << "  Position   : " << _pos << endl;
   cerr << "  Axis Names : ";
   for(int i=0; i<dim(); ++i)
      if(axisName(i))
         cerr << axisName(i) << " ";
   cerr << endl;

   cerr << "  Axis Units : ";
   for(int i=0; i<dim(); ++i)
      if(axisUnit(i))
         cerr << axisUnit(i) << " ";
   cerr << endl;

   cerr << "  Axis Dims  : ";
   for(int i=0; i<dim(); ++i)
      cerr << dim(i) << ", ";
   cerr << endl;

   cerr << "  Spacings   : ";
   for(int i=0; i<dim(); ++i)
      cerr << axisSpacing(i) << ", ";
   cerr << endl;

   cerr << "  Axis Sizes : ";
   for(int i=0; i<dim(); ++i)
      cerr << axisSize(i) << ", ";
   cerr << endl;

   cerr << "  Unpadded Sizes : ";
   for(int i=0; i<dim(); ++i)
      cerr << axisSizeNPad(i) << ", ";
   cerr << endl;

   cerr << "  Valid Data Ranges : " << endl << "   ";
   for(int i=0; i<dim(); ++i)
      cerr << "(" << _pads[i].x << ", " << _pads[i].y << "), ";
   cerr << endl;
}

/////////////////////////////////////////////////////////////////////////
// printType
/////////////////////////////////////////////////////////////////////////
void Nrro::printType() const
{
   cerr << "  Nrro::TYPE = ";
   switch(_nrrd->type)
   {
   case UNKNOWN:
      cerr << "Unknown type" << endl;
      break;
   case CHAR:
      cerr << "char" << endl;
      break;
   case UCHAR:
      cerr << "unsigned char" << endl;
      break;
   case SHORT:
      cerr << "short" << endl;
      break;
   case USHORT:
      cerr << "unsigned short" << endl;
      break;
   case INT:
      cerr << "int" << endl;
      break;
   case UINT:
      cerr << "unsigned int" << endl;
      break;
   case FLOAT:
      cerr << "float" << endl;
      break;
   case DOUBLE:
      cerr << "double" << endl;
      break;
   case BLOCK:
      cerr << "block" << endl;
      break;
   case TYPE_LAST:
      cerr << "last type????" << endl;
   default:
      cerr << "typeEnum invalid" << endl;
   }
   return;
}

---

Send questions, comments, and bug reports to: