AffineXform.hpp

Go to the documentation of this file.

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * 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.
 *
 */
 
#ifndef MOAB_AFFINE_XFORM_HPP
#define MOAB_AFFINE_XFORM_HPP
 
#include "moab/Forward.hpp"
#include "moab/CartVect.hpp"
#include "moab/Matrix3.hpp"
 
#include <cmath>
#include <limits>
 
namespace moab
{
 
/**
 * \brief Define an affine transformation
 * \author Jason Kraftcheck ([email protected])
 * \date August, 2006
 */
class AffineXform
{
 public:
 inline AffineXform();
 
 inline AffineXform( const double* three_by_three, const double* translation );
 
 inline AffineXform( const Matrix3& mat, const CartVect& off );
 
 /** move */
 static inline AffineXform translation( const double* vector );
 /** rotate about axis through origin */
 static inline AffineXform rotation( double radians, const double* axis );
 /** define rotation such that if applied to \c from_vec the result aligned with \c to_vec */
 static AffineXform rotation( const double* from_vec, const double* to_vec );
 /** reflect about plane through origin */
 static inline AffineXform reflection( const double* plane_normal );
 /** scale about origin */
 static inline AffineXform scale( double f );
 /** scale about origin */
 static inline AffineXform scale( const double* fractions );
 /** scale about a point */
 static inline AffineXform scale( double f, const double* point );
 /** scale about a point */
 static inline AffineXform scale( const double* fractions, const double* point );
 
 /** incorporate the passed transform into this one such that the
 * resulting transform is the cumulative affect of this initial
 * transform followed by the passed transform */
 inline void accumulate( const AffineXform& other );
 
 /** apply transform to a point */
 inline void xform_point( const double* input, double* output ) const;
 /** apply transform to a point */
 inline void xform_point( double* in_out ) const;
 
 /** apply transform to a vector */
 inline void xform_vector( const double* input, double* output ) const;
 /** apply transform to a vector */
 inline void xform_vector( double* in_out ) const;
 
 /** get transform that is the inverse of this transform */
 AffineXform inverse() const;
 
 /** get a tag that can be used to store an instance of this class */
 static ErrorCode get_tag( Tag& tag_handle_out, Interface* moab, const char* tagname = 0 );
 
 /** get 3x3 matrix portion of transform */
 const Matrix3& matrix() const
 {
 return mMatrix;
 }
 /** get translation portion of transform */
 const CartVect& offset() const
 {
 return mOffset;
 }
 
 /** Is this transform a reflection
 *
 * A relfecting transform will require the reversal of the
 * order of edges in a loop, etc. because it produces a
 * mirror-image of the input geometry. This method tests
 * if this is such a transform. A reflection may be created
 * with by an explicit transform, scaling with a negative
 * scale factor, etc. If multiple transforms are combined
 * such that the transform is no longer a reflection (e.g.
 * two reflections that are effectively a rotation), this method
 * will return false.
 */
 inline bool reflection() const;
 
 /** Does this transform do any scaling */
 inline bool scale() const;
 
 private:
 static inline AffineXform rotation( double cos_angle, double sin_angle, const CartVect& unit_axis );
 
 Matrix3 mMatrix;
 CartVect mOffset;
};
 
/** create a new transform equivalent to transform \c A followed
 * by transform \c B
 */
inline AffineXform operator*( const AffineXform& A, const AffineXform& B )
{
 AffineXform result( A );
 result.accumulate( B );
 return result;
}
 
inline AffineXform::AffineXform() : mMatrix( 1.0 ), mOffset( 0.0 ) {}
 
inline AffineXform::AffineXform( const double* three_by_three, const double* trans )
 : mMatrix( three_by_three ), mOffset( trans )
{
}
 
inline AffineXform::AffineXform( const Matrix3& mat, const CartVect& off ) : mMatrix( mat ), mOffset( off ) {}
 
inline AffineXform AffineXform::translation( const double* vector )
{
 return AffineXform( Matrix3( 1.0 ), CartVect( vector ) );
}
 
inline AffineXform AffineXform::rotation( double angle, const double* axis )
{
 CartVect a( axis );
 a.normalize();
 return AffineXform::rotation( std::cos( angle ), std::sin( angle ), a );
}
 
inline AffineXform AffineXform::rotation( double c, double s, const CartVect& a )
{
 const Matrix3 m1( c, -a[2] * s, a[1] * s, a[2] * s, c, -a[0] * s, -a[1] * s, a[0] * s, c );
 return AffineXform( m1 + ( 1.0 - c ) * outer_product( a, a ), CartVect( 0.0 ) );
}
 
inline AffineXform AffineXform::reflection( const double* plane_normal )
{
 double i = plane_normal[0];
 double j = plane_normal[1];
 double k = plane_normal[2];
 Matrix3 m( j * j + k * k - i * i, -2.0 * i * j, -2.0 * i * k, -2.0 * i * j, i * i + k * k - j * j, -2.0 * j * k,
 -2.0 * i * k, -2.0 * j * k, i * i + j * j - k * k );
 m *= 1.0 / ( i * i + j * j + k * k ); // normalize
 return AffineXform( m, CartVect( 0.0 ) );
}
 
inline AffineXform AffineXform::scale( const double* f )
{
 return AffineXform( Matrix3( CartVect( f ) ), CartVect( 0.0 ) );
}
 
inline AffineXform AffineXform::scale( double f )
{
 return AffineXform( Matrix3( CartVect( f ) ), CartVect( 0.0 ) );
}
 
inline AffineXform AffineXform::scale( double f, const double* point )
{
 double fs[] = { f, f, f };
 return AffineXform::scale( fs, point );
}
 
inline AffineXform AffineXform::scale( const double* f, const double* p )
{
 double offset[] = { p[0] * ( 1 - f[0] ), p[1] * ( 1 - f[1] ), p[2] * ( 1 - f[2] ) };
 return AffineXform( Matrix3( CartVect( f ) ), CartVect( offset ) );
}
 
inline void AffineXform::accumulate( const AffineXform& other )
{
 mMatrix = other.mMatrix * mMatrix;
 other.xform_point( mOffset.array() );
}
 
inline void AffineXform::xform_point( const double* input, double* output ) const
{
 xform_vector( input, output );
 output[0] += mOffset[0];
 output[1] += mOffset[1];
 output[2] += mOffset[2];
}
 
inline void AffineXform::xform_point( double* in_out ) const
{
 xform_vector( in_out );
 in_out[0] += mOffset[0];
 in_out[1] += mOffset[1];
 in_out[2] += mOffset[2];
}
 
inline void AffineXform::xform_vector( const double* input, double* output ) const
{
 output[0] = input[0] * mMatrix[0][0] + input[1] * mMatrix[0][1] + input[2] * mMatrix[0][2];
 output[1] = input[0] * mMatrix[1][0] + input[1] * mMatrix[1][1] + input[2] * mMatrix[1][2];
 output[2] = input[0] * mMatrix[2][0] + input[1] * mMatrix[2][1] + input[2] * mMatrix[2][2];
}
 
inline void AffineXform::xform_vector( double* in_out ) const
{
 double input[] = { in_out[0], in_out[1], in_out[2] };
 xform_vector( input, in_out );
}
 
inline AffineXform AffineXform::inverse() const
{
 Matrix3 m = mMatrix.inverse();
 return AffineXform( m, m * -mOffset );
}
 
inline bool AffineXform::reflection() const
{
 return mMatrix.determinant() < 0.0;
}
 
inline bool AffineXform::scale() const
{
 return fabs( fabs( mMatrix.determinant() ) - 1 ) > std::numeric_limits< double >::epsilon();
}
 
} // namespace moab
 
#endif