nrroKernel.cpp

Go to the documentation of this file.

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

//nrroKernel.cpp

#include "nrroKernel.h"
#include <iostream>

using namespace std;



/////////////////////////////////////////////////////////////////////
//usefull predefined kernels
/////////////////////////////////////////////////////////////////////

const double CatRomParam[NrroKernel::MAX_PARMS] = {1, 0.0, 0.5};
const NrroKernel CatmulRomKernel(NrroKernel::Cubic, CatRomParam);

const double BSplineParam[NrroKernel::MAX_PARMS] = {1, 1.0, 0.0};
const NrroKernel BSplineKernel(NrroKernel::Cubic, BSplineParam);

const NrroKernel BoxKernel(NrroKernel::Box);

const NrroKernel TentKernel(NrroKernel::Tent);

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// NrroKernel
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

NrroKernel::NrroKernel(int kind, const double *params)
: _kind(kind)
{

   _params[0] = 1;
   _spareParams[0] = 1;
   for(int i=1; i<MAX_PARMS; ++i)
   {
      _spareParams[i] = 0;
      _params[i] = 0;
   }
   if(params)
   {
      for(int j=1; j<MAX_PARMS; ++j)
      {
         _params[j] = params[j];
      }
   }
   else if(Cubic == kind) //using default, catmul-rom
   {
      for(int j=1; j<MAX_PARMS; ++j)
      {
         _params[j] = CatRomParam[j];
      }
   }

   if(Tent == kind)  //using cubic DD for tent DD
   {
      _spareParams[1] = 1.0;
      _spareParams[2] = 0.0;
   }

}

//copy constructor
NrroKernel::NrroKernel(const NrroKernel &nk)
: _kind(nk._kind)
{
   for(int i=0; i<MAX_PARMS; ++i)
   {
      _params[i] = nk._params[i];
      _spareParams[i] = nk._spareParams[i];
   }
}

//assignment operator
void NrroKernel::operator=(const NrroKernel &nk)
{
   _kind = nk._kind;

   for(int i=0; i<MAX_PARMS; ++i)
   {
      _params[i] = nk._params[i];
      _spareParams[i] = nk._spareParams[i];
   }
}

NrroKernel::~NrroKernel()
{

}

///////////////////////////////////////////////////////////////////////////
//getGageKernelType
///////////////////////////////////////////////////////////////////////////
int NrroKernel::getGageKernelType(int type) const
{

   switch(type)
   {
   case VALUE:
      return gageKernel00;
   case DERIV:
      return gageKernel11;
   case DERIV2:
      return gageKernel22;
   };

   return 0;
}

///////////////////////////////////////////////////////////////////////////
//getNrrdKernel
///////////////////////////////////////////////////////////////////////////
NrrdKernel *NrroKernel::getNrrdKernel(int type) const
{
   switch(_kind)
   {
   case Box:
      switch(type)
      {
      case VALUE:
         return nrrdKernelBox;
      case DERIV:
         return nrrdKernelCentDiff;
      case DERIV2:
         return nrrdKernelBCCubicDD;
      };
   case Tent:
      switch(type)
      {
      case VALUE:
         return nrrdKernelTent;
      case DERIV:
         return nrrdKernelCentDiff;
      case DERIV2:
         return nrrdKernelBCCubicDD;
      }
   case Cubic:
      switch(type)
      {
      case VALUE:
         return nrrdKernelBCCubic;
      case DERIV:
         return nrrdKernelBCCubicD;
      case DERIV2:
         return nrrdKernelBCCubicDD;
      }
   case Quartic:
      switch(type)
      {
      case VALUE:
         return nrrdKernelAQuartic;
      case DERIV:
         return nrrdKernelAQuarticD;
      case DERIV2:
         return nrrdKernelAQuarticDD;
      }
   case Gaussian:
      switch(type)
      {
      case VALUE:
         return nrrdKernelGaussian;
      case DERIV:
         return nrrdKernelGaussianD;
      case DERIV2:
         return nrrdKernelGaussianDD;
      };
      break;
   default:
      cerr << "NrroKernel::getNrrdKernel, Error, Kernel Type Unknown" << endl;
   }

   return 0;
}

const double *NrroKernel::getParams(int type) const
{
   if((Box == _kind || Tent == _kind) && DERIV2 == type)
   {
      return _spareParams;
   }

   return _params;
}

---

Send questions, comments, and bug reports to: