VolField.cpp

Go to the documentation of this file.

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

///VolField.cpp

#include "VolField.h"
#include <mathGutz.h>
#include <util/simPow.h>

using namespace gutz;
using namespace glift;
using namespace std;

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// VolField
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// Construct
///////////////////////////////////////////////////////////////////////////
VolField::VolField()
: SimBase(),
NrroSPVec(),        ///empty field
_on(false),         /// nothing to have on  
_up(false),         /// doesn't need update
_bricked(false),    /// no bricks yet
_texquality(BEST),  ///best quality texture
_texUnit(-1)
{}

VolField::VolField(Nrro *n)
: SimBase(),
NrroSPVec(1,NrroSP(n)), ///the original data 
_on(true),              ///on by default
_up(true),              ///needs update
_bricked(false),        ///not bricked
_texquality(BEST),      ///best quality texture
_texUnit(-1)
{}    

VolField::VolField(NrroSP n)
: SimBase(),
NrroSPVec(1,n), 
_on(true), 
_up(true),
_bricked(false),
_texquality(BEST),
_texUnit(-1)
{}

void VolField::setNrro(NrroSP nrro, unsigned int n)
{
   for(int i=int(size())-1; i<int(n); ++i)
   {
      NrroSPVec::push_back(NrroSP());
      derr("setNrro(), inserting NULL nrro objects");
   }
   NrroSPVec::operator[](n) = nrro; 
}

///////////////////////////////////////////////////////////////////////////
/// Update Field
///////////////////////////////////////////////////////////////////////////
void  VolField::update()
{
   /// nothing changed? nothing to do
   if(!getUpdate()) return;

   /// reset everything
   if(isBricked())
   {
      nukeBricks();
   }
   clearTex();

   /// update reset
   setUpdate(false);
}

///////////////////////////////////////////////////////////////////////////
/// Generate Texture
///////////////////////////////////////////////////////////////////////////
SingleTexSP VolField::genTexture(unsigned int n)
{       
   for(unsigned int i=g_max(int(_tex.size())-1,0); i<n; ++i)
   {
      _tex.push_back(SingleTexSP());
      derr("genTexture(),inserting null textures");
   }

   if(n == _tex.size())
      _tex.push_back(SingleTexSP());

   if(!_tex[n])
   {
      NrroSP nrro = NrroSPVec::operator[](n);
      if(!nrro.isNull())
      {
         _tex[n] = loadNrroTexture(nrro, _texquality);
      }
      else
      {
         derr("genTex(), nrro not valid, returning null texture");
      }
   }
   if(!_tex[n]) /// texture still not valid!!! badness
   {
      derr("genTex(), ERROR:: invalid texture returned!");
   }
   return _tex[n];
}

///////////////////////////////////////////////////////////////////////////
/// Generate Brick Texture
///////////////////////////////////////////////////////////////////////////
glift::SingleTexSP VolField::genBrickTexture(unsigned int n)
{
   if(isBricked())
      return genTexture(n+1);
   return genTexture(n);
}

///////////////////////////////////////////////////////////////////////////
/// Check Dims
///////////////////////////////////////////////////////////////////////////
/// check to see if our dimensions match another's exactly
bool  VolField::checkDims(SmartPtr<VolField> f)
{
   /// check every brick
   for(unsigned int i=0; i<size(); ++i)
   {
      NrroSP n1 = getNrro(i);
      NrroSP n2 = f->getNrro(i);
      /// error checking abounds
      if(n2.isNull() || n1.isNull())
      {
         derr("checkDims(), NULL nrro comparision");
      }
      /// check to make sure they are the same dimension
      if(n1->dim() != n1->dim())
      {
         return false;
      }
      /// check each axis
      for(int d=0; d<n1->dim(0); ++d)
      {
         if(n1->dim(d) != n2->dim(d))
            return false;
      }
   }
   return true;
}

///////////////////////////////////////////////////////////////////////////
/// get Brick
///////////////////////////////////////////////////////////////////////////
NrroSP  VolField::getBrick(unsigned int i)
{
   if(isBricked() && i<size())
   {
      return getNrro(i+1);
   }
   /// I don't know if this is reasonable!
   /// but I just don't want to crash!
   return getNrro(0);
}

///////////////////////////////////////////////////////////////////////////
/// num Bricks
///////////////////////////////////////////////////////////////////////////
unsigned int VolField::numBricks()
{
   if(isBricked() && size() > 1)
   {
      return size()-1;
   }
   else
   {
      return 1;
   }
}

///////////////////////////////////////////////////////////////////////////
/// nuke bricks
///////////////////////////////////////////////////////////////////////////
void VolField::nukeBricks()
{
   /// not bricked, nothing to do
   if(!isBricked()) return;

   /// pop off all nrro bricks
   /// leave 0, that's the original data
   for(unsigned int i=0; i<size()-1; ++i)
   {
      NrroSPVec::pop_back();
   }

   /// reset bricked
   setBricked(false);
}

///////////////////////////////////////////////////////////////////////////
/// Generate a nice brick
///////////////////////////////////////////////////////////////////////////
NrroSP VolField::genBrick(vec3i pos, vec3i size, NrroSP nin)
{
   /// set up the arrays we need for nrro croping
   int min[4] = {-1, 
      pos.x, 
      pos.y, 
      pos.z};
   int max[4] = {-1, 
      g_min(nin->dim(1)-1,pos.x+size.x-1), 
      g_min(nin->dim(2)-1,pos.y+size.y-1), 
      g_min(nin->dim(3)-1,pos.z+size.z-1)};

   /// crop that sucker
   NrroSP nnew = nin->crop(min,max);

   if(!nnew.isNull())
   {
      /// check if we have a remainder to pad out ?
      if((pos.x+size.x > nin->dim(1)) || 
         (pos.y+size.y > nin->dim(2)) || 
         (pos.z+size.z > nin->dim(3)))
      {
         /// arrays we need for nrro padding
         int pmin[4] = {0,0,0,0};
         int pmax[4] = {nnew->dim(0)-1, size.x-1, size.y-1, size.z-1};
         nnew = nnew->pad(pmin,pmax,Nrro::BLEED); ///pad out to brick size
      }
   }
   return nnew;
}

///////////////////////////////////////////////////////////////////////////
/// Brick, just do it
///////////////////////////////////////////////////////////////////////////
void VolField::brick(gutz::vec3i bdim)
{
   if(getUpdate()) update();
   if(isBricked()) return;

   NrroSP n = getNrro(0);

   //cerr << " dim " << n->dim() << endl;
   //cerr << " dims " << n->dim(0) << " " << n->dim(1) << " " << n->dim(2) << " " << n->dim(3) << endl;
   vec3i vsize(n->dim(1), n->dim(2), n->dim(3));

   /// how many bricks will we need?
   /// if the original volume is smaller than
   /// the maxBrick dim, we will generate exactly one
   /// brick!  it will be padded to the right power of 2

   /// TODO: this is wrong, you need on voxel of overlap,
   ///  which we have, but, that means the remainder is wrong,
   ///  we loose a voxel off the end for each brick we have!
   unsigned int nxb = vsize.x/bdim.x;
   if(vsize.x%bdim.x) nxb += 1;

   unsigned int nyb = vsize.y/bdim.y;
   if(vsize.y%bdim.y) nyb += 1;

   unsigned int nzb = vsize.z/bdim.z;
   if(vsize.z%bdim.z) nzb += 1;

   vec3i pos(0,0,0);
   /// generate bricks along z
   for(unsigned int z=0; z<nzb; ++z, pos.z+=bdim.z-1)
   {
      pos.y = 0;
      /// generate bricks along y
      for(unsigned int y=0; y<nyb; ++y, pos.y+=bdim.y-1)
      {
         pos.x = 0;
         /// generate bricks along x
         for(unsigned int x=0; x<nxb; ++x, pos.x+=bdim.x-1)
         {
            NrroSP nnew;
            if(pos + bdim > vsize) /// we have a remainder
            {
               nnew = genBrick(pos, getNextPow2(vsize - pos), n);
            }
            else
            {
               nnew = genBrick(pos, bdim, n);
            }
            NrroSPVec::push_back(nnew);
            //cerr << "brick dims " << nnew->dim(0) << " " << nnew->dim(1) << " " << nnew->dim(2) << " " << nnew->dim(3) << endl;
         }
      }
   }
   setBricked(true);
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// VolFieldVec
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// Update
///////////////////////////////////////////////////////////////////////////
void VolFieldVec::update()
{
   /// just call update on each of our children
   for(unsigned int i=0; i<size(); ++i)
   {
      if(!getField(i).isNull())
      {
         getField(i)->update();
      }
   }
}

bool VolFieldVec::needUpdate()
{
   /// check if anyone needs an update
   bool ret = false;
   for(unsigned int i=0; i<size(); ++i)
   {
      if(!getField(i).isNull())
      {
         if(getField(i)->getUpdate()) ret = true;
      }
   }
   return ret;
}

///////////////////////////////////////////////////////////////////////////
/// Add Field
///////////////////////////////////////////////////////////////////////////
void VolFieldVec::addNrro(NrroSP n)
{
   n->forceMultiChannel();
   push_back(VolFieldSP(new VolField(n)));
}


///////////////////////////////////////////////////////////////////////////
/// Get Field
///////////////////////////////////////////////////////////////////////////
VolFieldSP VolFieldVec::getField(unsigned int i)
{
   if(i<size()) 
      return operator[](i);

   derr("getFields(), WARNING:: accessing a null field");
   return VolFieldSP(0);
}


///////////////////////////////////////////////////////////////////////////
/// Set Field
///////////////////////////////////////////////////////////////////////////
void VolFieldVec::setField(unsigned int idx, VolField *f)
{
   /// TODO: see if we can use vector::insert here
   for(unsigned int i=size()-1; i<idx; ++i)
   {
      operator[](i) = VolFieldSP();
   }
   operator[](idx) = VolFieldSP(f);
}

///////////////////////////////////////////////////////////////////////////
/// Delete Field
///////////////////////////////////////////////////////////////////////////
void VolFieldVec::delField(unsigned int i)
{
   /// TODO: Need to see if we can re-pack the fields
   /// TODO: See if vector::delete does the trick
   if(i<size())
      operator[](i) = VolFieldSP();
}

///////////////////////////////////////////////////////////////////////////
/// Check Fields
///////////////////////////////////////////////////////////////////////////
bool VolFieldVec::checkFields()
{
   bool bret = true;
   ///////////////////////////////////////////////////////////
   /// Check each fields for correctness:
   for(unsigned int i=0; i<size(); ++i)
   {
      VolFieldSP f = getField(i);
      if(!f.isNull())                  ///we have a field
         if(f->isActive())            ///it is active, otherwize ignore it
            if(!checkField(i))       ///make sure all is ready
               bret = false;        ///maybe it isn't
   }
   ///////////////////////////////////////////////////////////

   ///////////////////////////////////////////////////////////
   /// an all to all check
   /// need this because all we support right now are 
   /// equal sized bricks and textures
   /// TODO: handle unequal sized fields
   for(unsigned int i=0; i<size(); ++i)
   {
      /// we only check active fields
      if(getField(i)->isActive()) 
      {
         for(unsigned int k=i+1; k<size(); ++k)
         {      
            if(getField(k)->isActive())
            {
               if(!getField(i)->checkDims(getField(k)))
               {
                  bret = false;
                  /// this is a place to handle this sort of thing
                  derr("checkFields(), dims not matching");
               } 
            }/// if k is active
         }/// for k
      }/// if i is active
   }/// for i

   return bret;
}


///////////////////////////////////////////////////////////////////////////
/// check field
///////////////////////////////////////////////////////////////////////////
/// I know this looks long, but it's mostly error checking!
bool VolFieldVec::checkField(unsigned int i)
{
   VolFieldSP f = getField(i);
   if(f.isNull())
   {
      /// this guy doesn't exist!
      derr("checkField(), null field");
      return false;
   }

   NrroSP n = f->getNrro();
   if(n.isNull())
   {
      /// this guy doesn't exist!
      derr("checkField(), null nrro");
      return false;
   }

   /// we can't handle anything but volumes and images right now
   if((Nrro::VOLUME != n->getKind()) && (Nrro::IMAGE != n->getKind()))
   {
      f->setActive(false);
      derr("checkField(), Nrro::KIND not supported");
      n->printKind();
      return false;
   }

   ////////////////////////////////////////////////////////
   /// this makes sure volumes are 4D and images are 3D
   if(((3==n->dim()) && (n->getKind() == Nrro::VOLUME)) ||
      ((2==n->dim()) && (n->getKind() == Nrro::IMAGE)))
   {
      derr("checkField(), forcing multi-channel");
      n->forceMultiChannel();
      f->setUpdate(true);
   }
   ///////////////////////////////////////////////////////

   /// we don't know how to handle things bigger than this,
   /// TODO: need a way to render time series volumes
   if(n->dim() > 4)
   {
      derr("checkField(), don't know how to handle volume with greater than 4 dims");
      f->setActive(false);
      return false;
   }

   /// check to see if we have more than 4 channels,
   /// if so we need to split them
   /// TODO: handle images the same way
   /// TODO: Maybe we shouldn't do this automatically?
   if((n->dim(0) > 4) && (n->getKind() == Nrro::VOLUME))
   {
      NrroSP n = f->getNrro();
      derr("checkField(), large number of fields, needs split");
      int lastField = 0;
      /// break out into sets of fields 4 or less
      while(n->dim(0) - lastField > 4)
      {
         int min[4] = {lastField, -1, -1, -1};
         int max[4] = {lastField+4, -1, -1, -1};
         max[0] = g_min(max[0], int(n->dim(0)-1));
         NrroSP nnew = n->crop(min, max);
         if(!nnew->isValid()) return false;
         VolFieldSP nvf(new VolField(nnew));
         nvf->setActive(f->isActive());
         push_back(nvf);
         lastField = max[0] + 1;
      }
      /// set this one inactive since
      /// we just generated a split up duplicate of it
      f->setActive(false);
      f->clearTex();
      f->nukeBricks();
   }
   return true;
}

///////////////////////////////////////////////////////////////////////////
/// BrickData
///////////////////////////////////////////////////////////////////////////
void VolFieldVec::brickData(gutz::vec3i bdims)
{
   ///TODO: Need to handle different resolution datasets somehow                
   /// hmm, really need to think that through
   for(unsigned int i=0; i<size(); ++i)
   {
      if((getField(i)->isActive()) &&       //active
         ( (!getField(i)->isBricked()) ||   //not bricked or...
         (getField(i)->getUpdate()) ) )   //something changed
      {
         getField(i)->clearTex();
         getField(i)->nukeBricks();
         getField(i)->brick(bdims);
      }
   }

}       

---

Send questions, comments, and bug reports to: