TFRasterize2D01.h

Go to the documentation of this file.

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

   const tfSType left    = _posVec[LL][posIdx.x];
   const tfSType right   = _posVec[UR][posIdx.x];
   const tfSType bottom  = _posVec[LL][posIdx.y];
   const tfSType top     = _posVec[UR][posIdx.y];

   const tfSType width   = right - left;
   const tfSType height  = top - bottom;
   const tfSType hw      = width * tfSType(.5);
   const tfSType hh      = height * tfSType(.5);

   /// 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 = left;
   const STF::tfSType py = bottom;
   const STF::tfSType dx = 2.0f/float(ni->dim(1));
   const STF::tfSType dy = 2.0f/float(ni->dim(2));

   /// temps used in inner loop, so we are not constructing tons of stuff
   tfSType u;
   ValType o = _valVec[0];
   tfVec2 pos(-1,-1);

   /// 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[STF::ALPHA] = myEval(pos.x*pos.x + pos.y*pos.y) * _valVec[0][STF::ALPHA];
         /// update the map
         for(int i=0; i<4; ++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)); 
         }
      }
      pos.x = px;
   }
}


/// Hi this is one of the weirder things I have done, you can use this by
/// decalring your own STF::tfSType myEval(T d) //T is float or double, preferably inline
/// rasterize2D<> should be a template member function, you do this in a .cpp file:
///
/// template<class T>
/// void myClass:: #include "TFRasterize2D01.h" 
///

---

Send questions, comments, and bug reports to: