coordTrans.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////
// 6/26/02      Aaron Lefohn    Scientific Computing and Imaging Institute
// School of Computing          University of Utah
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
////////////////////////////////////////////////////////////////////////

#include <util/coordTrans.h>
#include <assert.h>
#include <iostream>
using namespace std;
using namespace gutz;

using namespace glift;

CoordTrans::CoordTrans()
{
   init(vec3f(1.0f), vec3f(0.0f), false, false);
}

CoordTrans::CoordTrans( const vec2f& bias,  bool relBias ) 
{ 
   init(vec3f(1.0f), vec3f(bias.s, bias.t, 0.0f), false, relBias); 
}

CoordTrans::CoordTrans( const vec3f& bias,  bool relBias) 
{ 
   init(vec3f(1.0f), bias, false, relBias); 
}

CoordTrans::CoordTrans( const vec3f& scale, const vec3f& bias, bool relScale, bool relBias )                    
{ 
   init(scale, bias, relScale, relBias); 
}

CoordTrans::CoordTrans( const mat4f& mat, bool relScale, bool relBias )
{
   m_mat = mat;
   m_relScale = relScale;
   m_relBias = relBias;
}

void CoordTrans::init( const vec3f& scale, const vec3f& bias, bool relScale, bool relBias ) 
{
   mat3f scaleMat;
   scaleMat[0] = scale.x;
   scaleMat[4] = scale.y;
   scaleMat[8] = scale.z;

   m_mat = mat4f( scaleMat, bias );
   m_relScale = relScale;
   m_relBias  = relBias;
} 

vec2f CoordTrans::apply( const vec2f& coord, const vec2f& divisor )
{
   mat4f mat = applyDivisor( arrayo1f(2, divisor.v()) );/// Make a relative transform if requested
   vec4f coordVec(coord, 0.0f, 1.0f);                     /// Homogeneous 4-vec
   coordVec = mat * coordVec;                                     /// Do the transform
   return vec2f(coordVec);                                                /// Drop the last 2 components
}

vec3f CoordTrans::apply( const vec3f& coord, const vec3f& divisor )
{
   mat4f mat = applyDivisor( arrayo1f(3, divisor.v() ) );/// Make a relative transform if requested
   vec4f coordVec(coord, 1.0f);                                   /// Homogeneous 4-vec
   coordVec = mat * coordVec;                                     /// Do the transform
   return vec3f(coordVec);                                        /// Drop the 4th component (always 1.0)
}

gutz::arrayo1f CoordTrans::apply( const arrayw1f& coord, const arrayw1f& divisor )
{
   if( (coord.size() != 2) && (coord.size() != 3) && (coord.size() != 4) ) {
      err() << "CoordTrans::transform(...) Error:\n"
         << "\tcoord.size() == " << coord.size() << ". 'coord' must be array of size 2, 3, or 4.\n";
      exit(1);
   }

   if( (divisor.size() != 2) && (divisor.size() != 3) ) {
      err() << "CoordTrans::transform(...) Error:\n"
         << "\tdivisor.size() == " << divisor.size() << ". 'divisor' must be array of size 2 or 3.\n";
      exit(1);
   }

   /// Homogeneous 4-vec
   vec4f coordVec;
   coordVec[0] = coord[0];
   coordVec[1] = coord[1];
   coordVec[2] = coord.size() > 2 ? coord[2] : 0.0f;
   coordVec[3] = coord.size() > 3 ? coord[3] : 1.0f;

   mat4f mat = applyDivisor( divisor );/// Make a relative transform if requested
   coordVec = mat * coordVec;               /// Do the transform

   switch( coord.size() ) {
   case 2: return  arrayo1f(2, coordVec.v() ); break;
   case 3: return  arrayo1f(3, coordVec.v() ); break;
   case 4: return  arrayo1f(4, coordVec.v() ); break;
   default: return arrayo1f(4, coordVec.v() ); break;
   }/// No default necessary b/c already checked above that one of these is valid.
}

mat4f CoordTrans::applyDivisor( const arrayw1f& divisor )
{
   assert( divisor.size() == 2 || divisor.size() == 3 );

   mat4f mat = m_mat;

   if( m_relScale ) {
      mat[0] /= divisor[0];
      mat[1] /= divisor[1];
      mat[2] /= divisor.size()==3 ? divisor[2] : 1.0f;
   }
   if( m_relBias ) {
      mat[12] /= divisor[0];
      mat[13] /= divisor[1];
      mat[14] /= divisor.size()==3 ? divisor[2] : 1.0f;
   }

   return mat;
}

---

Send questions, comments, and bug reports to: