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

//VolytopeStd.h

#include "VolytopeStd.h"
#include <assert.h>
#include <string>
#include <sstream>

using namespace gutz;
using namespace std;

///////////////////////////////////////////////////////////////////
//=================================================================
//  VolyCube
//=================================================================
///////////////////////////////////////////////////////////////////

VolyCube::VolyCube(vec3f origin, vec3f size, vec3f lltex, vec3f urtex)
: Volytope(string("VolyCube")),
_origin(origin),
_size(size)
{
   genVerts(8);
   genTcoords(0);
   genEdges(12);

   setDims(_origin, _size);
   setTcoords(lltex, urtex, 0);
}

VolyCube::VolyCube(NrroSP nrro)
:Volytope(string("VolyCube")),
_origin(vec3f_neg_half),
_size(vec3f_one)
{
   genVerts(8);
   genTcoords(0);
   genEdges(12);

   if(nrro.isNull())
   {
      derr("VolyCube(NrroSP), invalid nrro!");
      setTcoords(vec3f_zero, vec3f_one, 0);
      setDims(_origin, _size);
      return;
   }

   nrro->forceMultiChannel();

   setNrroDims(nrro);
   setNrroTcoords(nrro,0);
}

///////////////////////////////////////////////////////////////////
/// VolyCube from field
///////////////////////////////////////////////////////////////////
VolyCube::VolyCube(VolFieldSP f, unsigned int brickNum)
{
   genVerts(8);
   genTcoords(0);
   genEdges(12);

   if(f->getBrick(brickNum).isNull())
   {
      derr("VolyCube(VolFieldSP), invalid nrro!");
      setTcoords(vec3f_zero, vec3f_one, 0);
      setDims(_origin, _size);
      return;
   }

   f->getBrick(brickNum)->forceMultiChannel();

   setNrroDims(f->getBrick(brickNum));
   setNrroTcoords(f->getBrick(brickNum),0);
   addTexture(f->genBrickTexture(brickNum));
}


///////////////////////////////////////////////////////////////////
/// set dims
///////////////////////////////////////////////////////////////////
void VolyCube::setDims(vec3f origin, vec3f size)
{
   //assert(_verts); assert(_tcoords[0]); assert(_edges);

   arrayw1v3f v = getVerts();
   arrayw1v2i e = getEdges();

   v[0] = origin;
   v[1] = origin + size * vec3f_x;
   v[2] = origin + size * vec3f_y;
   v[3] = origin + size * vec3f_xy;
   v[4] = origin + size * vec3f_z;
   v[5] = origin + size * vec3f_xz;
   v[6] = origin + size * vec3f_yz;
   v[7] = origin + size * vec3f_xyz;

   e[0]  = vec2i(0,1);
   e[1]  = vec2i(0,2);
   e[2]  = vec2i(0,4);
   e[3]  = vec2i(1,3);
   e[4]  = vec2i(1,5);
   e[5]  = vec2i(2,3);
   e[6]  = vec2i(2,6);
   e[7]  = vec2i(3,7);
   e[8]  = vec2i(4,5);
   e[9]  = vec2i(4,6);
   e[10] = vec2i(5,7);
   e[11] = vec2i(6,7);

   setSizes();
}

///////////////////////////////////////////////////////////////////
/// set tcoords
///////////////////////////////////////////////////////////////////
void VolyCube::setTcoords(gutz::vec3f lltex, gutz::vec3f urtex, unsigned int texNum)
{
   arrayw1v3f t = getTcoords(texNum);

   t[0] = lltex;
   t[1] = vec3f(urtex.x, lltex.y, lltex.z);
   t[2] = vec3f(lltex.x, urtex.y, lltex.z);
   t[3] = vec3f(urtex.x, urtex.y, lltex.z);
   t[4] = vec3f(lltex.x, lltex.y, urtex.z);
   t[5] = vec3f(urtex.x, lltex.y, urtex.z);
   t[6] = vec3f(lltex.x, urtex.y, urtex.z);
   t[7] = urtex;
}

///////////////////////////////////////////////////////////////////
/// Load Field
///////////////////////////////////////////////////////////////////
void VolyCube::loadField(VolFieldSP f, unsigned int brickNum)
{
   loadNrro(f->getBrick(brickNum));
   addTexture(f->genTexture(brickNum));
}

///////////////////////////////////////////////////////////////////
/// Load Nrro
///////////////////////////////////////////////////////////////////
void VolyCube::loadNrro(NrroSP n)
{
   if(n.isNull())
   {
      derr("loadNrro(), invalid nrro!");
      return;
   }

   n->forceMultiChannel();
   setNrroTcoords(n, -1);
}

///////////////////////////////////////////////////////////////////
/// set Nrro Dims
///////////////////////////////////////////////////////////////////
void VolyCube::setNrroDims(NrroSP n)
{
   if(n->isValid())
   {
      _origin = n->getPos();
      
      /// see if the nrro has a better idea about it's size
      readState(n); 
      if(vec3f_neg_one == _size)
         _size = n->getSizeV3();
   }

   setDims(_origin, _size);
}

///////////////////////////////////////////////////////////////////
/// set Nrro Tcoords
///////////////////////////////////////////////////////////////////
void VolyCube::setNrroTcoords(NrroSP n, int texNum)
{
   /// get the ranges of valid data values from
   /// the nrrd for each axis
   vec2ui a1r = n->axisValNPad(1);
   vec2ui a2r = n->axisValNPad(2);
   vec2ui a3r = n->axisValNPad(3);

   /// texture coordinates lower-left & upper right
   vec3f lltex(vec3f_zero);
   vec3f urtex(vec3f_one);

   /// figure out what where the valid ranges are in
   ///  terms of texture coordnates
   lltex.x = float(AIR_AFFINE(0, a1r.x, n->dim(1), 0.0f, 1.0f));
   lltex.y = float(AIR_AFFINE(0, a2r.x, n->dim(2), 0.0f, 1.0f));
   lltex.z = float(AIR_AFFINE(0, a3r.x, n->dim(3), 0.0f, 1.0f));

   urtex.x = float(AIR_AFFINE(0, a1r.y, n->dim(1), 0.0f, 1.0f));
   urtex.y = float(AIR_AFFINE(0, a2r.y, n->dim(2), 0.0f, 1.0f));
   urtex.z = float(AIR_AFFINE(0, a3r.y, n->dim(3), 0.0f, 1.0f));

   /// Always offset texture coordinates by a half!!!!
   /// because that's the way opengl stores them?
   vec3f htex(1.0f/(2.0f*n->dim(1)), 1.0f/(2.0f*n->dim(2)), 1.0f/(2.0f*n->dim(3)));
   lltex += htex;
   urtex -= htex;

   unsigned int txnum = (unsigned int) texNum;
   if(texNum == -1)
   {
      unsigned int txnum = 0;
      while(!checkTcoords(lltex, urtex, txnum)) ++txnum;
   }
   setTcoords(lltex, urtex, txnum);
}

///////////////////////////////////////////////////////////////////
/// check texture coordinates
///////////////////////////////////////////////////////////////////
bool VolyCube::checkTcoords(gutz::vec3f lltex, gutz::vec3f urtex, unsigned int texNum)
{
   arrayw1v3f tc = getTcoords(texNum);
   return ( (lltex == tc[0]) && (urtex == tc[7]) );
}

///////////////////////////////////////////////////////////////////
/// write state
///////////////////////////////////////////////////////////////////
const std::string VC_SIZE_KEY_STR("size_VolyCube");

void VolyCube::writeState(NrroSP n)
{
   if(n.isNull()) return;

   std::ostringstream ss;
   ss << _size;
   std::string szstr = ss.str();

   n->setComment(VC_SIZE_KEY_STR, szstr);
}

///////////////////////////////////////////////////////////////////
/// read state
///////////////////////////////////////////////////////////////////
void VolyCube::readState(NrroSP n)
{
   if(n.isNull()) return;
   std::string szstr = n->getComment(VC_SIZE_KEY_STR);
   if(szstr.empty()) /// didn't find saved info
   {
      _size = vec3f_neg_one;
      return;
   }
   else /// did find it
   {
      /// read vec3 from string, check if good
      if(str2vec3<float>(szstr, _size)) 
      {
         /// not good couldn't read it
         derr("readState(), str2vec3<>() failed, size not read");
         _size = vec3f_neg_one;
         return;
      }
      return;
   }
   /// can't get here!
}

///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
/// a VolyCube factory function, from a field
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
VolytopeVec genVolyCubes(VolFieldSP f)
{
   if(!f){
      cerr << "genVolyCubes(VolFieldSP), ERROR, field invalid" << endl;
      return VolytopeVec();
   }

   VolytopeVec vtv;
   if(f->isBricked())
   {
      for(unsigned int i=0; i<f->numBricks(); ++i)
      {
         VolytopeSP vc(new VolyCube(f, i));
         vtv.push_back(vc);
      }
   }
   else // not bricked
   {
      VolytopeSP vc(new VolyCube(f,0));
      vtv.push_back(vc);
   }
   return vtv;
}

///////////////////////////////////////////////////////////////////
//=================================================================
//  VolyTet
//=================================================================
///////////////////////////////////////////////////////////////////

VolyTet::VolyTet(vec3f origin, vec3f size)
{

}

VolyTet::VolyTet(vec3f p0, vec3f p1, vec3f p2, vec3f p4)
{

}

---

Send questions, comments, and bug reports to: