TFBase.h

Go to the documentation of this file.

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

// TFBase.h

// a base interface for transfer functions

#ifndef __SIMIAN_TRANSFER_FUNCTION_BASE_DOT_H
#define __SIMIAN_TRANSFER_FUNCTION_BASE_DOT_H

#include <simBase/simBase.h>
#include <volume/Volume.h>
#include <smartptr.h>
#include "TFParams.h"
#include "TFElement.h"
#include "TFImage.h"
#include <nrro/nrro.h>


//////////////////////////////////////////////////////////////////////////
/// a generic ND transfer function.
///   Handles basic TFElement management and various TF generation 
///   methods.
//////////////////////////////////////////////////////////////////////////
class TFGeneric : public SimBase, public gutz::Counted {
public:
   typedef STF::tfDomainType PosType;
   typedef STF::tfRangeType  ValType;

   TFGeneric();
   TFGeneric(VolumeSP vol);
   virtual ~TFGeneric();

   ///////////////////////////////////////////
   ///@name Evaluate 
   ///  Evaluate the transfer function at some arbitrary position
   ///@{
   virtual ValType eval(const PosType &tfpos);
   ///@}

   //////////////////////////////////////////////////////
   ///@name Domain
   ///@{

   ///////////////////////////////////////////
   /// dimension of transfer function domain
   /// how many axies does the transfer function have???
   virtual int sizeDomain() const  { return 0;}
   
   ///////////////////////////////////////////
   /// how many bins will discrete TF maps have?
   /// default is 256 for all TF domain axes.
   virtual PosType getDomainRes() const            {return _res;}
   /// notice that you are passing a gutz::vec, so you
   ///  can have a different number of bins for each axis
   virtual void    setDomainRes(const PosType &res){_res = res;}
   
   ///@}
   //////////////////////////////////////////////////////


   ///////////////////////////////////////////
   ///@name Range
   /// dimension of transfer function range,
   ///  ex. 4 is probably standard for RGBA output
   ///@{
   virtual int sizeRange() const   { return 0;} 
   ///@}

   ///////////////////////////////////////////
   ///@name Volume stuff
   ///@{
   virtual void     setVolume(VolumeSP v) { _vol = v;   }
   virtual VolumeSP getVolume() const     { return _vol;}
   ///@}

   ///////////////////////////////////////////
   ///@name Transfer function elements
   ///@{
   TFElementListSP  getTFElts() const               { return _elts; }
   void             setTFElts(TFElementListSP _tfe) { _elts = _tfe;}
   void             addTFElt(TFEltSP tfelt)         { _elts->push_back(tfelt); }
   void             addTFElement(TFElement *tfelt)  { addTFElt( TFEltSP(tfelt) ); }
   ///@}

   ///////////////////////////////////////////
   /// reimplemented from SimBase, needed since changes are dependent on
   /// sub-objects like TFElements
   virtual int   getChangeID();

   ////////////////////////////////////////////
   /// Generate a 2D tf image (map) from a pair 
   ///  of axies (axiesIdx) of the tfdomain ...
   ///  ... with some size, type, specific values in your choice of order,
   ///  ... and your choice of how many values (channels) it should have
   /// kind is from STF::TF_4MAP_KINDS
   /// type is from Nrro::NRRO_TYPES
   ////////////////////////////////////////////
   TFImageSP  get2DMap(
      gutz::vec2i axesIdx,                          /// idicies of domain axes
      const gutz::vec2i size = gutz::vec2i_neg_one, /// size of map
      int type = Nrro::UCHAR,                       /// what data type?
      int kind = STF::TF_RGBA);                     /// type of TFimage (which channels?)

protected:
   ///////////////////////////////////////////
   /// update the transfer function, checks to see if any of the elements
   /// changed and updates if it needs to. You can call this whenever you
   /// want.
   virtual void     update();

   TFImageSP getImage(const gutz::vec2i &ai);
   void      setImage(const TFImageSP im);

   VolumeSP _vol;
   TFElementListSP _elts;

   PosType _res;

   /// cache generated tf images...
   TFImageSPMap _images;
};

typedef gutz::SmartPtr<TFGeneric> TFGenericSP;

//////////////////////////////////////////////////////////////////////////
//// a double indirection tf class so that you can dynamically change the 
//// tf and those changes will be reflected everywhere,
////   holds an actual transfer function (one that implements the interface)
////   allows you access to that guy. Unfortunately, you shouldn't copy
////   this, you would have to make a specific sub class that knew what
////   kind of tf actually implemented the interface; ie. copy won't copy
////   the transfer function interface, just the pointer!!!
////
//// If you use a transfer function somewhere use one of these and stay in
//// synch with it, ie. assume it is volitle.  If you implement a new TF type
//// implement the TFBaseIF, so that users can plug it into one of these
//// DO NOT Subclass this guy, only the (user) interface!
////  TODO: should we rethink the name of this thing??? seems like we 
////    should be more expicit about the double indirection nature...
///////////////////////////////////////////////////////////////////////////
class TFBaseSP : 
   public gutz::SmartPtrRef<TFGeneric>,
   public SimBase
{
public:
   typedef gutz::SmartPtrRef<TFGeneric> btype;
   
   TFBaseSP() 
      : btype(new TFGeneric()), 
      _lastChanged((*_ref)->getChangeID()) 
   {}
   
   TFBaseSP(VolumeSP vol) 
      : btype(new TFGeneric(vol)), 
      _lastChanged((*_ref)->getChangeID()) 
   {}
   
   TFBaseSP(TFGeneric *tf) 
      : btype(tf), 
      _lastChanged((*_ref)->getChangeID()) 
   {}

   ///we are not really a reference, we are a double indirection
   /// thingy, not really a pointer pointer, not really a ref either.
   /// this means that we have to copy the pointer inside the
   /// ref for copy and assignment so that changes are reflected
   /// everywhere.
   TFBaseSP(const TFBaseSP &tfbsp) : btype() 
   { 
      assign(const_cast<btype::type*>(tfbsp._ref));
      _lastChanged = (*_ref)->getChangeID();
   }

   TFBaseSP &operator=(const TFBaseSP &tfbsp) 
   { 
      assign(const_cast<btype::type*>(tfbsp._ref));
      setChanged();
      _lastChanged = -1;
      return *this; 
   }

   virtual ~TFBaseSP() {}

   /// if you are keeping track of changes yourself
   /// use this function, if you want to use this object
   /// as an observer, DO NOT use this one, use
   /// the functions below
   virtual int  getChangeID()               
   {
      if(_lastChanged != (*_ref)->getChangeID())
         setChanged();
      _lastChanged = (*_ref)->getChangeID();
      return SimBase::getChangeID();
   }

   /// if you have one of thses objects, you don't need to 
   /// keep track of the change id yourself. use these
   /// functions to see if the tf has changed since the last
   /// time you called "updateChanged()"
   bool tfChanged() const { return _lastChanged != (*_ref)->getChangeID(); }
   void updateChanged()   { _lastChanged = (*_ref)->getChangeID(); }

protected:
   int _lastChanged;
};

#endif

---

Send questions, comments, and bug reports to: