nrroExtended.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     6-25-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

//nrroExtended.cpp

#include "nrro.h"
#include <sstream>

using namespace std;
using namespace gutz;

/////////////////////////////////////////////////////////////////////////
//read Extended
/////////////////////////////////////////////////////////////////////////
void Nrro::readExtended()
{
   readKind();
   readPos();
   readPads();
   readName();
}

/////////////////////////////////////////////////////////////////////////
//write Extended
/////////////////////////////////////////////////////////////////////////
void Nrro::writeExtended()
{
   writeKind();
   writePos();
   writePads();
   writeName();
}

/////////////////////////////////////////////////////////////////////////
//kind
/////////////////////////////////////////////////////////////////////////
const std::string NRRO_KIND_KEY("kind_nrro");
const std::string KIND_NOT_SET_STR("not_set");
const std::string KIND_UNKNOWN_STR("unknown");
const std::string KIND_IMAGE_STR("Image");
const std::string KIND_TIME_STR("Time_series");
const std::string KIND_VOLUME_STR("Volume");
const std::string KIND_PROXY_STR("Proxy");

/////////////////////////////////////////////////////////////////////////
//write kind
/////////////////////////////////////////////////////////////////////////
void Nrro::writeKind()
{
   string kstr("");
   
   if(_kind == KIND_NOT_SET)
   {
      kstr = KIND_NOT_SET_STR;     
   }
   if(_kind & IMAGE)
   {
      kstr += KIND_IMAGE_STR;
   }
   if(_kind & VOLUME)
   {
      kstr += KIND_VOLUME_STR;
   }
   if(_kind & TIME_SERIES)
   {
      kstr += KIND_TIME_STR;
   }
   if(_kind & PROXY)
   {
      kstr += KIND_PROXY_STR;
   }
   if(kstr.empty())
   {
      kstr = KIND_NOT_SET_STR;
   }

   setComment(NRRO_KIND_KEY, kstr);
}
/////////////////////////////////////////////////////////////////////////
//read kind
/////////////////////////////////////////////////////////////////////////
void Nrro::readKind()
{
   //PROXY kinds cannot be read from extended,
   //this is a runtime user feature, so we don't 
   //want to invalidate existing data, by marking
   //this guy as a proxy.  But, if already is 
   //a proxy, better keep it that way.

   string kstr = getComment(NRRO_KIND_KEY);

   if(kstr.empty())
   {
      //NrroDbg("readKind(), kind not set");
      _kind = KIND_NOT_SET | (_kind & PROXY);
      return;
   }

   _kind = KIND_NOT_SET | (_kind & PROXY);

   if(kstr.find(KIND_UNKNOWN_STR) != -1)
      _kind = KIND_UNKNOWN | (_kind & PROXY);

   if(kstr.find(KIND_IMAGE_STR) != -1)
   {
      _kind |= IMAGE;
   }

   if(kstr.find(KIND_VOLUME_STR) != -1)
      _kind = VOLUME;

   if(kstr.find(KIND_TIME_STR) != -1)
      _kind |= TIME_SERIES;

}

/////////////////////////////////////////////////////////////////////////
//Pads
/////////////////////////////////////////////////////////////////////////
const std::string NRRO_PADS_KEY("unpadded_nrro");

void Nrro::writePads()
{
   ostringstream ss;
   for(int i=0; i<int(dim()); ++i)
   {
      ss << _pads[i] << ",";
   }
   string padsstr = ss.str();
   setComment(NRRO_PADS_KEY, padsstr);
}

void Nrro::readPads()
{
   string padsstr = getComment(NRRO_PADS_KEY);
   if(padsstr.empty())
   {
      //NrroDbg("readPads(), padds not set");
      //for(int i=0; i<int(dim()); ++i)
      //{
      //        _pads[i] = vec2ui(0, dim(i));
      //}
      return;
   }

   int sidx = -1; //starting point for parsing string
   bool fail = false; //did we fail to read the pads
   for(int i=0; i<int(dim()); ++i)
   {
      fail = str2vec2<unsigned int>(padsstr.substr(padsstr.find_first_not_of(" ",sidx+1)), _pads[i]) || fail;   
      sidx = padsstr.find(",",sidx+1);
   }
   if(fail)
   {
      NrroDbg("readPads(), failed to read in padds correctly!");
      //for(int i=0; i<int(dim()); ++i)
      //{
      //        _pads[i] = vec2ui(0, dim(i));
      //}
      return;
   }
}

/////////////////////////////////////////////////////////////////////////
//Position
/////////////////////////////////////////////////////////////////////////
const std::string NRRO_POS_KEY("position_nrro");

void Nrro::writePos()
{
   ostringstream ss;
   ss << _pos;
   string posstr = ss.str();
   setComment(NRRO_POS_KEY, posstr);
}

void Nrro::readPos()
{
   string posstr = getComment(NRRO_POS_KEY);
   if(posstr.empty())
   {
      //NrroDbg("readPos(), pos not set");
      //_pos = vec3f_zero;
      return;
   }
   if(str2vec3<float>(posstr, _pos))
   {
      NrroDbg("readPos(), faild to read position");
      //_pos = vec3f_zero;
   }
}

/////////////////////////////////////////////////////////////////////////
//Name
/////////////////////////////////////////////////////////////////////////
const std::string NRRO_NAME_KEY("name_nrro");

void Nrro::writeName()
{
   //nrrd key/values can't be empty
   if(_name.empty())
      _name = std::string("unnamed");

   setComment(NRRO_NAME_KEY, _name);
}

void Nrro::readName()
{
   _name = getComment(NRRO_NAME_KEY);
}

---

Send questions, comments, and bug reports to: