TFRasterize.cpp

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

/// TFRasterize.cpp

#include "TFElement.h"
#include <limits>

using namespace STF;
using namespace std;
using namespace gutz;

typedef tfSType TFT;

#if 0
/// a generic rasterization algorithm
template<class T>
void TFElement::rasterize2D(Nrro::NrroIter<T> ni, 
                            const gutz::vec2i &posIdx, 
                            const STF::tfRangeIdx &valIdx) const
{
   /// we will use float precicion for now
   vec2<T> mmm; /// min & max for the map

   if(numeric_limits<T>::epsilon()) /// float/double type
   {
      mmm = vec2<T>(T(0.0),T(1.0));
   }
   else /// integral type
   {
      mmm = vec2<T>(numeric_limits<T>::min(), numeric_limits<T>::max());
   }

   /// complete bounding box
   const PosType bmin = getMinBox();
   const PosType bmax = getMaxBox();

   /// bounding box for the current axies
   const int minX = clamp(0, int(bmin[posIdx.x] * ni->dim(1)), ni->dim(1));
   const int minY = clamp(0, int(bmin[posIdx.y] * ni->dim(2)), ni->dim(2));
   const int maxX = clamp(0, int(bmax[posIdx.x] * ni->dim(1)), ni->dim(1));
   const int maxY = clamp(0, int(bmax[posIdx.y] * ni->dim(2)), ni->dim(2));

   /// tf domain positions and deltas for rasterization
   const STF::tfSType px = minX/float(ni->dim(1));
   const STF::tfSType py = minY/float(ni->dim(2));
   const STF::tfSType dx = 1.0f/float(ni->dim(1));
   const STF::tfSType dy = 1.0f/float(ni->dim(2));

   /// temps used in inner loop, so we are not constructing tons of stuff
   tfSType u;
   ValType o;
   tfVec2 pos(px,py);

   /// Rasterize!!!
   for(int y = minY; y<= maxY; ++y, pos.y+=dy)  /// y axis
   {
      for(int x = minX; x<= maxX; ++x, pos.x+=dx) /// x axis
      {
         /// over values (values from this element)
         o = eval(pos, posIdx);
#if 1
         /// update the map
         for(int i=0; i<ni->dim(0); ++i) /// for each element in map
         {
            /// get existing map value in tfDomain extents
            u = g_affine(T(mmm.x), ni(i,x,y), T(mmm.y), TFT(0.0), TFT(1.0));
            /// combine over (o) and under (u) values
            //_blend[valIdx[i]]->blend(o,u,valIdx[i]);
            /// update map in map type extents
            ni(i,x,y) = g_affine(TFT(0.0), o[valIdx[i]], TFT(1.0), T(mmm.x), T(mmm.y)); 
         }
#endif
      }
      pos.x = px;
   }

}

//// a helper #def for declaring specific instantiations of the 
//// templateed rasterize2D function
#define genRasterize2D(T) \
   template \
   void TFElement::rasterize2D(Nrro::NrroIter<##T##> ni, \
                               const gutz::vec2i &posIdx, \
                               const STF::tfRangeIdx &valIdx) const

//// need these declared since rasterize2D is defined in a .cpp file
//// we need them to build!
genRasterize2D(char);
genRasterize2D(unsigned char);
genRasterize2D(short);
genRasterize2D(unsigned short);
genRasterize2D(int);
genRasterize2D(unsigned int);
genRasterize2D(float);
genRasterize2D(double);




#endif

---

Send questions, comments, and bug reports to: