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

/// TFBlend.h

/// TF Element blend strategies, for combining multiple overlapping 
/// elements in the tf data domian.

#ifndef __SIMIAN_TF_BLEND_DOT_H
#define __SIMIAN_TF_BLEND_DOT_H

#include "TFParams.h"
//#include <smartptr.h>

#if 0
/////////////////////////////////////////////////////////////////////////
/// blend op interface
class TFBlendOP : public gutz::Counted {
public:
   typedef STF::tfSType     SType; ///scalar type
   typedef STF::tfRangeType VType; ///vector type

   virtual ~TFBlendOP() {}

   /// blend o[i] over u[i]
   virtual SType blend(const VType &o, const VType &u, const int i) const = 0;

protected:
   TFBlendOP() {}
   TFBlendOP &operator=(const TFBlendOP &) {} /// not used
};

typedef gutz::SmartPtr<TFBlendOP> TFBlendOPSP;
#endif

/////////////////////////////////////////////////////////////////////////
//// summation
class TFBlendSum
{
public:
   typedef STF::tfSType     SType;
   typedef STF::tfRangeType VType;

   TFBlendSum() {}
   ~TFBlendSum() {}

   static
   SType blend(const VType &o, const VType &u, const int i)
   {
      return o[i] + u[i];
   }
   
protected:
};

/////////////////////////////////////////////////////////////////////////
/// alpha blend
class TFBlendOverAlpha 
{
public:
   typedef STF::tfSType     SType;
   typedef STF::tfRangeType VType;

   TFBlendOverAlpha() {}
   ~TFBlendOverAlpha() {}

   static
   SType blend(const VType &o, const VType &u, const int i)
   {
      if(i != STF::ALPHA)
         return o[i]*o[STF::ALPHA] + u[i]*(1.0f - o[STF::ALPHA]);
      return o[i] + u[i]*(1.0f - o[STF::ALPHA]);
   }

};


#if 0
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
/// an array of blend ops
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////

class TFBlend {
public:
   /// default
   TFBlend()
   {
      _boVec[0] = new TFBlendSum();
      for(int i=1; i<STF::TF_MAX_R; ++i)
         _boVec[i] = new TFBlendSum();
   }
   /// copy
   TFBlend(const TFBlend &b)
   { for(int i=0; i<STF::TF_MAX_R; ++i) _boVec[i] = b._boVec[i]; }
   ~TFBlend() {}
   /// assign
   TFBlend &operator=(const TFBlend &b)
   { for(int i=0; i<STF::TF_MAX_R; ++i) _boVec[i] = b._boVec[i]; return *this; }

   /// [] accessor, since we really are an array
   TFBlendOPSP &operator[](int i) { return _boVec[i]; }
   const TFBlendOPSP &operator[](int i) const { return _boVec[i]; }

   /// size should be the same as the max range dim
   int size() { return STF::TF_MAX_R; }

   /// set get a blendOP in the array
   void        setBlendOP(int idx, TFBlendOP *op) { _boVec[idx] = op; }
   TFBlendOPSP getBlendOP(int idx) const          {return _boVec[idx];}
protected:
   TFBlendOPSP _boVec[STF::TF_MAX_R];

};

#endif

#endif

---

Send questions, comments, and bug reports to: