Volytope.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     9-20-02
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2002 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

//Volytope.cpp

#include "Volytope.h"
#include <algorithm>

using namespace glift;
using namespace gutz;
using namespace std;

////////////////////////////////////////////////////////////////////
/// Construction
////////////////////////////////////////////////////////////////////

Volytope::Volytope(unsigned int nElements, 
                   unsigned int nTcoords,
                   unsigned int nPrims)
                   : SimBase(),
                   _verts(new VA_ITYPE(nElements,V_TYPE(0))),
                   _edges(new EA_ITYPE(nElements,E_TYPE(0)))
{
   for(unsigned int i=0; i<nTcoords; ++i)
      _tcoords.push_back(new TA_ITYPE(nElements,TC_TYPE(0)));   
   setSizes();
}

////////////////////////////////////////////////////////////////////
/// Destruction
////////////////////////////////////////////////////////////////////

Volytope::~Volytope()
{
   if(_verts) delete _verts;
   if(_edges) delete _edges;
   for(unsigned int i=0; i< _tcoords.size(); ++i)
   {
      if(_tcoords.back()) delete _tcoords.back();
      _tcoords.pop_back();
   }
}

////////////////////////////////////////////////////////////////////
/// Assignment
////////////////////////////////////////////////////////////////////

void Volytope::operator=(const Volytope &v)
{
   if(_verts) delete _verts;
   _verts = new VA_ITYPE(*v._verts);
   if(_edges) delete _edges;
   _edges = new EA_ITYPE(*v._edges);
   for(unsigned int i=0; i<_tcoords.size(); ++i)
   {
      if(_tcoords.back()) delete _tcoords.back();
      _tcoords.pop_back();
   }
   for(unsigned int i=0; i<v._tcoords.size(); ++i)
      _tcoords.push_back(new TA_ITYPE(*v._tcoords[i]));
   for(unsigned int i=0; i<_textures.size(); ++i)
      _textures.pop_back();
   for(unsigned int i=0; i<v._textures.size(); ++i)
      _textures.push_back(v._textures[i]);
   setSizes();
}

////////////////////////////////////////////////////////////////////
/// Set Data
////////////////////////////////////////////////////////////////////

void Volytope::setData(VA_RTYPE   *verts,
                       TA_RTYPE   *tcoords,
                       EA_RTYPE   *edges)
{ 
   if(_verts)   delete _verts;
   _verts = new VA_ITYPE(*verts); 
   if(_tcoords[0]) delete _tcoords[0];
   _tcoords[0] = new TA_ITYPE(*tcoords); 
   if(_edges)   delete _edges;
   _edges = new EA_ITYPE(*edges); 

   setSizes();
}

////////////////////////////////////////////////////////////////////
/// generate verticies
////////////////////////////////////////////////////////////////////

Volytope::VA_RTYPE  Volytope::genVerts(int nVerts) 
{
   if(_verts) delete _verts;
   _verts = new VA_ITYPE(nVerts, V_TYPE(0));
   return VA_RTYPE(*_verts);
}

////////////////////////////////////////////////////////////////////
/// generate Tcoords
////////////////////////////////////////////////////////////////////

Volytope::TA_RTYPE  Volytope::genTcoords(int tNum)       
{
   for(int i = _tcoords.size() -1; i < tNum; ++i)
      _tcoords.push_back(0);
   if(_tcoords[tNum]) delete _tcoords[tNum];
   _tcoords[tNum] = new TA_ITYPE(_verts->size(), TC_TYPE(0));
   return TA_RTYPE(*(_tcoords[tNum]));
}

////////////////////////////////////////////////////////////////////
/// generate Edges
////////////////////////////////////////////////////////////////////

Volytope::EA_RTYPE  Volytope::genEdges(int nEdges)               
{ 
   if(_edges) delete _edges;
   _edges = new EA_ITYPE(nEdges, E_TYPE(0));    
   return EA_RTYPE(*_edges);
}

////////////////////////////////////////////////////////////////////
/// get Texture coordinates
////////////////////////////////////////////////////////////////////

const Volytope::TA_RTYPE Volytope::getTcoords(unsigned int tNum) const 
{
   if(tNum < _tcoords.size())
      return TA_RTYPE(*(_tcoords[tNum]));
   return TA_RTYPE(0,0);
}

Volytope::TA_RTYPE       Volytope::getTcoords(unsigned int tNum)       
{
   if(tNum < _tcoords.size())
      return TA_RTYPE(*_tcoords[tNum]);
   return TA_RTYPE(0,0);
}


////////////////////////////////////////////////////////////////////
/// set Sizes
////////////////////////////////////////////////////////////////////
void Volytope::setSizes()
{
   _max = gutz::vec3f_min;
   _min = gutz::vec3f_max;
   _center = gutz::vec3f_zero;
   for(int i=0; i<_verts->size(); ++i) 
   {
      for(int j=0; j<3; ++j)
      {
         _max[j] = g_max(_max[j], (*_verts)[i][j]);
         _min[j] = g_min(_min[j], (*_verts)[i][j]);
         _center[j] += (*_verts)[i][j];
      }
   }
   _center /= float(_verts->size());
}

////////////////////////////////////////////////////////////////////
/// set Point distance
////////////////////////////////////////////////////////////////////
void  Volytope::setPointDist(gutz::vec3f pt)
{
   /// well that idea didn't work!
   //_dist = 1e10f;
   //for(int i=0; i<_verts->size(); ++i)
   //{
   //   _dist = MIN( _dist, ((*_verts)[i] - pt).norm() );
   //}
   /// this seems to work
   _dist = (getCenter() - pt).norm();
}

////////////////////////////////////////////////////////////////////
/// add Texture
////////////////////////////////////////////////////////////////////

void Volytope::addTexture(glift::SingleTex *tex)  
{
   _textures.push_back(SingleTexSP(tex));
}

////////////////////////////////////////////////////////////////////
/// Scale
////////////////////////////////////////////////////////////////////
void Volytope::scale(gutz::vec3f scale)
{
   if(!_verts) return;
   for(int i=0; i<_verts->size(); ++i)
   {
      (*_verts)[i] *= scale;
   }
   setSizes();
}

////////////////////////////////////////////////////////////////////
/// Translate
////////////////////////////////////////////////////////////////////
void Volytope::translate(gutz::vec3f trans)
{
   if(!_verts) return;
   for(int i=0; i<_verts->size(); ++i)
   {
      (*_verts)[i] += trans;
   }
   setSizes();
}


////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
/// VolytopeVec
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
/// Set field
////////////////////////////////////////////////////////////////////

void VolytopeVec::setField(VolFieldSP f)
{
   if(!f) return;
   if(!f->isActive()) return;

   if(f->size() != size())
   {
      derr("setField(), current number of volytopes and fields do not match");
      return;
   }

   for(unsigned int i=0; i<f->size(); ++i)
   {
      getVoly(i)->loadField(f, i);
   }
}

////////////////////////////////////////////////////////////////////
/// Bounding box max
////////////////////////////////////////////////////////////////////
gutz::vec3f   VolytopeVec::getBoxMax() const
{
   vec3f bmax(-1e10f,-1e10f,-1e10f);

   for(unsigned int i=0; i<size(); ++i)
   {
      VolytopeSP vt = getVoly(i);
      if(!vt.isNull())
      {
         vec3f vtmax = vt->getBoxMax();
         for(int k=0; k<3; ++k)
         {
            bmax[k] = g_max(bmax[k], vtmax[k]);
         }
      }
   }
   return bmax;
}

////////////////////////////////////////////////////////////////////
/// Bounding box min
////////////////////////////////////////////////////////////////////
gutz::vec3f   VolytopeVec::getBoxMin() const
{
   vec3f bmin(1e10f,1e10f,1e10f);

   for(unsigned int i=0; i<size(); ++i)
   {
      VolytopeSP vt = getVoly(i);
      if(!vt.isNull())
      {
         vec3f vtmin = vt->getBoxMin();
         for(int k=0; k<3; ++k)
         {
            bmin[k] = g_min(bmin[k], vtmin[k]);
         }
      }
   }
   return bmin;
}

////////////////////////////////////////////////////////////////////
/// set Size
////////////////////////////////////////////////////////////////////
void   VolytopeVec::setSize(float sz)
{
   /// first figure out the scale factor
   vec3f bmin = getBoxMin();
   vec3f bmax = getBoxMax();
   vec3f vtsize = bmax - bmin;

   /// find the largest axis
   unsigned int a = 0;
   for(int i=1; i<3; ++i) a = vtsize[a] < vtsize[i] ? i : a;

   /// scale so the largest axis
   vec3f scl(sz/vtsize[a]);

   scale(scl);

   /// keep track of what we did to the volys
   _scale *= vec3f_one/scl;
}

////////////////////////////////////////////////////////////////////
/// Center
////////////////////////////////////////////////////////////////////
void VolytopeVec::center()
{
   /// first figure out the dimensions
   vec3f bmin = getBoxMin();
   vec3f bmax = getBoxMax();
   vec3f vtsize = bmax - bmin;

   /// the amount to translate
   vec3f trans = -bmin - vtsize/2.0f;

   translate(trans);
}

////////////////////////////////////////////////////
/// transformations
////////////////////////////////////////////////////////////////////
/// Center
////////////////////////////////////////////////////////////////////
void VolytopeVec::scale(gutz::vec3f scl)
{
   for(unsigned int i=0; i<size(); ++i)
   {
      VolytopeSP vt = getVoly(i);
      if(!vt.isNull())
      {
         vt->scale(scl);
      }
   }
}

////////////////////////////////////////////////////////////////////
/// Center
////////////////////////////////////////////////////////////////////
void VolytopeVec::translate(gutz::vec3f trans)
{
   for(unsigned int i=0; i<size(); ++i)
   {
      VolytopeSP vt = getVoly(i);
      if(!vt.isNull())
      {
         vt->translate(trans);
      }
   }
}

////////////////////////////////////////////////////////////////////
/// Sort from point
////////////////////////////////////////////////////////////////////

struct gtvsp
{
   bool operator()(const VolytopeSP &s1, const VolytopeSP &s2)
   {
      if(s1.isNull()) return true;
      if(s2.isNull()) return false;
      return (s1->getPointDist() > s2->getPointDist());                 
   }
};

VolytopeVec VolytopeVec::sortFromPoint(gutz::vec3f pt)
{
   for(unsigned int i=0; i<size(); ++i)
   {
      VolytopeSP vt = getVoly(i);
      if(!vt.isNull())
      {
         vt->setPointDist(pt);
      }
   }

   VolytopeVec vret = (*this);
   sort(vret.begin(), vret.end(), gtvsp());
   return vret;
}

---

Send questions, comments, and bug reports to: