---

guma_transform.cpp

Go to the documentation of this file.

/* LIBGUL - Geometry Utility Library
 * Copyright (C) 1998-1999 Norbert Irmer
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library 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 "stdafx.h"

#include <iostream>

#include "gul_types.h"
#include "gul_vector.h"
#include "gul_matrix.h"
#include "guma_lineq.h"

namespace guma {

using gul::Ptr;
using gul::rtr;
using gul::point;
using gul::normalize;
using gul::MMProduct;
using gul::cross_product;

/*-------------------------------------------------------------------
  Calculates a matrix wich transforms points given in a local coordinate
  system at a point 'B' into the world coordinate system.
  An additional point is required (both in world coordinates
  (=P) and local coordinates (=Pb)). 'Ab' must contain the coordinates
  of the origin in the local coordinate system at 'B'.
  Both coordinate systems must be orthonormal, and memory for 'T' (a 4x4
  matrix) must be reserved by the caller.
-------------------------------------------------------------------*/

template< class U >
void CommonCoordinateSystem(
       const point<U>& B, const point<U>& P, const point<U>& Ab, 
       const point<U>& Pb, Ptr< Ptr<U> >& T )
{
  point<U> a1,a2,a3,b1,b2,b3;
  Ptr< Ptr<U> > Ta,Tb;
  int i;

  Ta.reserve_pool(3);
  Tb.reserve_pool(3);
  for( i = 0; i < 3; i++ )
  {
    Ta[i].reserve_pool(3);
    Tb[i].reserve_pool(3);
  }

  normalize( &a1, B );
  normalize( &a2, P-((P*a1)*a1) );
  normalize( &a3, cross_product(a1,a2) );

  normalize( &b1, -Ab );
  normalize( &b2, P-((P*b1)*b1) );
  normalize( &b3, cross_product(b1,b2) );

  Tb[0][0] = b1[0];   Tb[0][1] = b1[1];  Tb[0][2] = b1[2];
  Tb[1][0] = b2[0];   Tb[1][1] = b2[1];  Tb[1][2] = b2[2];
  Tb[2][0] = b3[0];   Tb[2][1] = b3[1];  Tb[2][2] = b3[2];

  GaussJordan( 3, 0, Tb, Tb ); 

  Ta[0][0] = a1[0];   Ta[0][1] = a1[1];  Ta[0][2] = a1[2];
  Ta[1][0] = a2[0];   Ta[1][1] = a2[1];  Ta[1][2] = a2[2];
  Ta[2][0] = a3[0];   Ta[2][1] = a3[1];  Ta[2][2] = a3[2];

  MMProduct( 3, 3, 3, Tb, Ta, T );  

  T[3][0] = B[0];  T[3][1] = B[1]; T[3][2] = B[2]; T[3][3] = (U)1; 
  T[0][3] = T[1][3] = T[2][3] = (U)0; 
}
// template instantiation
template void CommonCoordinateSystem(
       const point<float>& B, const point<float>& P, const point<float>& Ab,  
       const point<float>& Pb, Ptr< Ptr<float> >& T );
template void CommonCoordinateSystem(
       const point<double>& B, const point<double>& P, const point<double>& Ab,  
       const point<double>& Pb, Ptr< Ptr<double> >& T );
}

---