TFElement.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"
//-------------------------------------------------------------------------

/// TFElement.h

#ifndef __TRANSFER_FUNCTION_ELEMENT_DOT_H
#define __TRANSFER_FUNCTION_ELEMENT_DOT_H

#include <smartptr.h>
#include <simBase/simBase.h>
#include <list>
#include "TFParams.h"
#include "TFEval.h"
#include "TFBlend.h"
#include <nrro/nrro.h>

/// forward decls
class TFEltView;

////////////////////////////////
/// default blend types
typedef TFBlendSum  RGBBlendType;
typedef TFBlendSum  AlphaBlendType;

//////////////////////////////////////////////////////////////////////////
/// A generic transfer function element base (classification widget spec)
/// not a concrete implementation. \n
/// see below for a double indirection element (so they can change types
///   and you can track changes to them) TFEltSP
///
/// For Collaboration with TFGeneric \n
/// See also: TFEltView, TFElementBox, TFParams.h, TFViewWidget, 
///           TFSurfaceWidget 
//////////////////////////////////////////////////////////////////////////
class TFElement : 
   public SimBase, 
   public gutz::Counted
{
public:
   virtual ~TFElement() {}

   typedef STF::tfSType      SType; ///scalar type
   typedef STF::tfDomainType PosType;
   typedef STF::tfDomainVec  PosVecType;
   typedef STF::tfRangeType  ValType;
   typedef STF::tfRangeVec   ValVecType;
   typedef STF::tfVec2       tfVec2;
   typedef STF::tfRangeVec4  tfVec4;

   //////////////////////////////////////////////////
   ///@name Views, 2D projections
   ///@{

   /// get view, returns View interface, each concrete TFElement
   ///  should have an associated view object than handles the
   ///  collaboration between 2D manipulations and the full ND 
   ///  representation of the Element.  see TFEltView for
   ///  the interface spec.
   virtual TFEltView *getView(const gutz::vec2i &axes) = 0; 
   ///@}

   //////////////////////////////////////////////////
   ///@name Evaluate
   ///@{

   ///////////////////////////////////
   /// evaluate at generic position
   virtual ValType eval(const PosType &tfpos) const = 0;
   ///@}

   ///////////////////////////////////
   // evaluate only a 2D version.
   // implys projecting out all other dimensions
   // for building separable transfer functions
   //  Although this function is virtual in this interface
   //  it should NOT be virtual in any concrete class if
   //  you are using the rasterization helper in "TFRasterize.h"
   //  otherwize rasterization will slow to a snails pace.
   //virtual ValType eval(const tfVec2 &tfpos, 
   //                     const gutz::vec2i &posIdx) const = 0;
   ///////////////////////////////////
   // evalate only a 2D version for 
   //  4 specific Range (val) values.
   // implementation optional.
   //virtual tfVec4 eval(const tfVec2 &tfpos,
   //                    const gutz::vec2i posIdx,
   //                    const gutz::vec4i valIdx) const
   //{ 
   //   ValType r = eval(tfpos,posIdx); 
   //   return tfVec4(r[valIdx.x],r[valIdx.y],r[valIdx.z],r[valIdx.w]); 
   // }

   ///////////////////////////////////
   ///@name Zero Val 
   /// The "Zero Val" is the value for "unclassified regions"
   /// this may or may not actually be zero, so 
   /// you may need to change what that value is.
   /// The zero value defaults to tfRangeType_default
   ///@{
   ValType getZeroVal() const            {return _zeroVal;}
   void    setZeroVal(const ValType &zv) { _zeroVal = zv; }
   ///@}

   ///////////////////////////////////
   ///@name evaluator strategies Depricated?
   ///@{
   TFEvalSP getEvaluator() const     {return _eval;}
   void     setEvaluator(TFEvalSP e) {_eval = e;}
   ///@}

   ///////////////////////////////////
   // blendOp strategies
   //TFBlendOPSP getBlendOP(int i) const          {return _blend.getBlendOP(i);}
   //void        setBlendOP(int i, TFBlendOP *bo) {_blend.setBlendOP(i, bo);}
   // blends "u" into and under "o"
   //void        blend(ValType &o, const ValType &u)
   //{ for(int i=0; i< STF::TF_MAX_R; ++i) _blend[i]->blend(o,u,i); }

   /////////////////////////////////// 
   ///@name Domain/Position
   /// all of the "nodes" associated with this element,
   ///  ie, verticies of polytope in tf domain
   ///@{
   PosVecType &getPosVec()               { return _posVec; }
   PosVecType  getPosVec() const         { return _posVec; }
   void        setPosVec(PosVecType &pv) { _posVec = pv; }
   PosType    &getPos(int i)             { return _posVec[i]; }
   PosType     getPos(int i) const       { return _posVec[i]; }
   void        setPos(int i, PosType p)  { _posVec[i] = p; }
   ///@}

   ///@name domain bounding box 
   ///  you can override these for speed!!
   /// should we recompute on every call?? very slow! maybe you can
   /// cache this in a subclass.
   ///@{
   virtual PosType  getMinBox() const
   {
      PosType ret(STF::tfDomainType_max);
      for(int i=0; i<int(_posVec.size()); ++i)
         vs_min(ret, _posVec[i]);
      return ret;
   }
   virtual PosType  getMaxBox() const
   {
      PosType ret(STF::tfDomainType_min);
      for(int i=0; i<int(_posVec.size()); ++i)
         vs_max(ret, _posVec[i]);
      return ret;
   }
   ///@}

   /////////////////////////////////// 
   ///@name Range/Value
   /// all of the values associated with each node,
   ///  if vec.size() == 1 then the element has a global 
   ///  definition of range.
   ///@{
   ValVecType &getValVec()       { return _valVec; }
   ValVecType  getValVec() const { return _valVec; }
   ///@}

   ///////////////////////////////////
   /// check to see if this element needs to be removed/deleted
   bool  needRemove() const {return _remove;}

   ///////////////////////////////////
   /// rasterize this element into an image.
   /// For now, the image must have 4 channels
   virtual void rasterize2D(NrroSP n, 
                            const gutz::vec2i &posIdx,
                            const int kind = STF::TF_RGBA) = 0;

   ///////////////////////////////////
   /// a generic rasterization algorithm
   /// the index vector allows you to rearrange and select
   /// which values from the domain are rasterized
   /// into the 2D image map (ni). 
   /// defined in "TFRasterize.cpp", see for more details.
/*
   template<class T> inline
      void rasterize2D(Nrro::NrroIter<T>      ni,      
                       const gutz::vec2i     &posIdx, 
                       const STF::tfRangeIdx &valIdx = STF::tfRangeIdx_ao) const;
*/
protected:
   TFElement() : _remove(false), _eval(new TFEvalGaus()) {}

   PosVecType _posVec; // position parameters
   ValVecType _valVec; // value parameters

   ValType    _zeroVal;

   TFEvalSP   _eval;
   ///TFBlend    _blend;

   bool _remove;

};

typedef gutz::SmartPtr<TFElement> TFElementSP;

//////////////////////////////////////////////////////////////////////////
/// a double indirection tf element. Uses the SmartPtrRef interface 
///   so it behaves as a pointer to an element.  Used mainly as an 
///   observer for objects that use Elements, keeps a changeID to 
///   compare against the referenced element's current changeID.  
//////////////////////////////////////////////////////////////////////////

class TFEltSP : public gutz::SmartPtrRef<TFElement>, public SimBase
{
public:
   typedef gutz::SmartPtrRef<TFElement> btype;

   TFEltSP(TFElement *e) : btype(e), _lastChanged(e->getChangeID()) {}
   TFEltSP(const TFEltSP &tfe) : btype(), _lastChanged(tfe._lastChanged)
   { assign(const_cast<btype::type*>(tfe._ref)); }

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

   /// 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();
   }

   /// see if the element we reference changed
   bool elementChanged() const { return _lastChanged != (*_ref)->getChangeID(); }
   /// set the element unchanged
   void updateChanged()  { _lastChanged = (*_ref)->getChangeID(); }

   virtual ~TFEltSP() {}

protected:
   TFEltSP() {}
   int _lastChanged;
};

//////////////////////////////////////////////////////////////////////////
/// a usefull LIST of transfer function elements
//////////////////////////////////////////////////////////////////////////
class TFElementList : 
   public std::list<TFEltSP>, 
   public gutz::Counted 
{
public:
   typedef TFElementList::iterator Iter;

   TFElementList() {}   
   virtual ~TFElementList() {}

   void addElement(TFElement *e)
   { push_back(TFEltSP(e)); }

   /// check if any element changed
   bool elementChanged()
   {
      bool ret = false;
      for(Iter i = begin(); i!=end(); ++i)
      {
         ret |= (*i).elementChanged();
      }
      return ret;
   }
   
   /// set all elements unchanged.
   void updateChanged()
   {
      for(Iter i=begin(); i!=end(); ++i)
      {
         (*i).updateChanged();
      }
   }

protected:

};

typedef TFElementList::iterator       TFElementListIter;
typedef TFElementList::const_iterator TFElementListConstIter;

typedef gutz::SmartPtr<TFElementList> TFElementListSP;


#endif

---

Send questions, comments, and bug reports to: