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

/// TFElementSTD.cpp

#include "TFElementSTD.h"
#include <mathGutz.h>
#include <iostream>
#include "TFRasterize.h"
#include <nrro/nrroDispatch.h>

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

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// box type tf element
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// construct
///////////////////////////////////////////////////////////////////////////
TFElementBox::TFElementBox()
: _kind(RADIAL)
{
   initBox(PosType(.5), PosType(.5));
   _valVec.push_back(ValType(randval(), randval(), randval(), .5, 0.0));
}

TFElementBox::TFElementBox(const PosType center, const PosType size)
: _kind(RADIAL)
{
   initBox(center,size);
   _valVec.push_back(ValType(randval(), randval(), randval(), .5, 0.0));
}

///////////////////////////////////////////////////////////////////////////
/// build box
///////////////////////////////////////////////////////////////////////////
void TFElementBox::initBox(const PosType center, const PosType size)
{
   PosType ll = center - size/2.0;
   PosType ur = center + size/2.0;

   _posVec.push_back(ll);
   _posVec.push_back(ur);

}

///////////////////////////////////////////////////////////////////////////
/// set center
///////////////////////////////////////////////////////////////////////////
void TFElementBox::setCenter(PosType center)
{
   PosType d = center - getCenter();
   _posVec[LL] += d;
   _posVec[UR] += d; 
}

///////////////////////////////////////////////////////////////////////////
/// set Size
///////////////////////////////////////////////////////////////////////////
void TFElementBox::setSize(PosType size)
{
   PosType ds = (size - getSize())/2.0;
   _posVec[LL] -= ds;
   _posVec[UR] += ds;
}

///////////////////////////////////////////////////////////////////////////
/// set Min
///////////////////////////////////////////////////////////////////////////
void TFElementBox::setMin(PosType ll)
{
   _posVec[LL] = ll;
   updateBox();
}

///////////////////////////////////////////////////////////////////////////
/// set max
///////////////////////////////////////////////////////////////////////////
void TFElementBox::setMax(PosType ur)
{
   _posVec[UR] = ur;
   updateBox();
}

///////////////////////////////////////////////////////////////////////////
/// update box
///////////////////////////////////////////////////////////////////////////
void TFElementBox::updateBox()
{
   for(int i=0; i<_posVec[UR].size(); ++i)
   {
      /// make sure the max is UR and min is LL
      if(_posVec[UR][i] < _posVec[LL][i])
      {
         float tmp = _posVec[UR][i];
         _posVec[UR][i] = _posVec[LL][i];
         _posVec[LL][i] = tmp;
      }
      
   }
}

///////////////////////////////////////////////////////////////////////////
/// eval
///////////////////////////////////////////////////////////////////////////
TFElementBox::ValType 
TFElementBox::eval(const tfVec2 &tfpos, 
                   const gutz::vec2i &posIdx) const
{
#if 1
   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];

   if(   (left   > tfpos.x)
      || (right  < tfpos.x)
      || (bottom > tfpos.y)
      || (top    < tfpos.y) )
   {
      return STF::tfRangeType_default;
   }

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

   tfSType ev = 0;

   if(RADIAL == _kind)
   {
      const tfSType xp = (tfpos.x - (left   + hw))/hw;
      const tfSType yp = (tfpos.y - (bottom + hh))/hh;
      const tfSType ep = sqrt( xp*xp + yp*yp );
      ev = 0;//_eval->eval(ep);
   }
   if(SEPARABLE == _kind)
   {
      const tfSType wp = g_min(tfpos.x - left,   right - tfpos.x);
      const tfSType hp = g_min(tfpos.y - bottom, top - tfpos.y);
      const tfSType ep = g_min(wp/hw, hp/hh);
      ev = 0;//_eval->eval(ep);
   }
#endif

   //tfSType ev = 0;

   ValType ret = _valVec[0];
   ret[ALPHA] = ev;

   return ret;   
}

///////////////////////////////////////////////////////////////////////////
/// rasterize 2D
///////////////////////////////////////////////////////////////////////////
void TFElementBox::rasterize2D(NrroSP n, 
                               const gutz::vec2i &posIdx,
                               const int kind)
{
   _posIdx = posIdx;

   if(TF_RGBA == kind)
   {
      _valIdx = STF::tfRGBA_idx;
      //dispatchRast2D4(RGBBlendType, RGBBlendType, RGBBlendType, AlphaBlendType, n, posIdx, STF::tfRGBA_idx, this);
   }

   dispatchIter1(rasterize2D,n);

   //rasterize2D(Nrro::NrroIter<char>(0), posIdx, STF::tfRGBA_idx);
}

typedef gutz::vec3<STF::tfSType> _V3;
typedef Triangle<STF::tfSType>   TFTriangle;
typedef TriRasterInfo<STF::tfSType, TFTriangle> TFRasterInfo;

template<class T>
void TFElementBox::rasterize2D(Nrro::NrroIter<T> ni) const 
{
   const tfSType left    = _posVec[LL][_posIdx.x] * ni->dim(1);
   const tfSType right   = _posVec[UR][_posIdx.x] * ni->dim(1);
   const tfSType bottom  = _posVec[LL][_posIdx.y] * ni->dim(2);
   const tfSType top     = _posVec[UR][_posIdx.y] * ni->dim(2);

   cerr << " dims " << left << " " << bottom << "  =  " << right << " " << top << endl;

   _V3 ll(left,bottom,0);
   _V3 tll(-1,-1,0);
   _V3 lr(right,bottom,0);
   _V3 tlr(1,-1,0);
   _V3 tl(left,top,0);
   _V3 ttl(-1,1,0);
   _V3 tr(right,top,0);
   _V3 ttr(1,1,0);

   Triangle<SType> tris[2];
   tris[0].setPoints(&ll,&tl,&tr);
   tris[0].setTexCoord(0,&tll,&ttl,&ttr);
   tris[1].setPoints(&ll,&tr,&lr);
   tris[1].setTexCoord(0,&tll,&ttr,&tlr);

   TFRasterInfo ri(ni->dim(1), ni->dim(2));

   SType deleteme = 0;
   int test = 0;

   /// for each triangle
   for(int i=0; i<2; ++i)
   {
      /// set the current triangle
      if( ri.setTri( &(tris[i]) ) )
      {
         cerr << " triangle " << i << " has no renderable pixels " << endl;
         continue;
      }
      
      cerr << " dims = " << ri.minX << " " << ri.minY << " , " << ri.maxX << " " << ri.maxY << endl;
      /// go `till it's completely rasterized
      while(!ri.end())
      {
         //deleteme += SType(exp(double(ri.x() * ri.y())));
         //cerr << " pos = " << ri.x() << " " << ri.y() << endl;
         if( (ri.alpha + ri.beta + ri.gamma) > 1.01 )
         {
            cerr << " bad bary > 1 = " << ri.alpha + ri.beta + ri.gamma << endl;
         }
         if( (ri.alpha + ri.beta + ri.gamma) < -.01 )
         {
            cerr << " bad bary < 0 = " << ri.alpha + ri.beta + ri.gamma << endl;
         }
         
         ni(0, int(ri.x()), int(ri.y())) = 1;
         ni(1, int(ri.x()), int(ri.y())) = 1;
         ni(2, int(ri.x()), int(ri.y())) = 1;
         gutz::vec2<SType> tc = ri.interp2(ri.getTri()->getTex(0,0), 
                                           ri.getTri()->getTex(0,1), 
                                           ri.getTri()->getTex(0,2));
         ni(3, int(ri.x()), int(ri.y())) = T( exp(-(ri.x()*ri.x() + ri.y()*ri.y())) * 255 );

         ++ri;
         ++test;
      }
      cerr << " triangle " << i << "  =  " << test << " pixels " << endl;
      test = 0;
   }

   cerr << " rasterized " << test << "  pixels " << endl;

#if 0
   for(int i=0; i<2; ++i)
   {
      ri.setUp( &(tris[i]) );
      for(int y=ri.minY; y<=ri.maxY; ++y, ri.tIncY())
      {
         for(int x=ri.getMinX(); x<=ri.getMaxX(); ++x, ri.incX())
         {
             deleteme = ri.x();
             ++test;
         }
      }
   }
#endif
   cerr << " rasterized " << test << "  pixels " << endl;

}

#if 0


template<class T>
void #include "TFRasterize2D01.h"


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

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

#endif

---

Send questions, comments, and bug reports to: