OMKTransform.h

Go to the documentation of this file.

/************************************************************************/
/* This file is part of openMask(c) INRIA, CNRS, Universite de Rennes 1 */
/* 1993-2002, thereinafter the Software                                 */
/*                                                                      */
/* The Software has been developped within the Siames Project.          */
/* INRIA, the University of Rennes 1 and CNRS jointly hold intellectual */
/* property rights                                                      */
/*                                                                      */
/* The Software has been registered with the Agence pour la Protection  */
/* des Programmes (APP) under registration number                       */
/* IDDN.FR.001.510008.00.S.P.2001.000.41200                             */
/*                                                                      */
/* This file may be distributed under the terms of the Q Public License */
/* version 1.0 as defined by Trolltech AS of Norway and appearing in    */
/* the file LICENSE.QPL included in the packaging of this file.         */
/*                                                                      */
/* Licensees holding valid specific licenses issued by INRIA, CNRS or   */
/* Universite Rennes 1 for the software may use this file in            */
/* acordance with that specific license                                 */
/************************************************************************/
#ifndef OMK_MATH_OMKTransform_H
#define OMK_MATH_OMKTransform_H

#include "Wm4Matrix3.h"
#include "Wm4Matrix4.h"
#include "Wm4Plane3.h"
#include "Wm4Quaternion.h"
#include "OMKTracer.h"
#include <iostream>



namespace OMK  
{
class OutgoingSynchronisationMessage ;
class IncomingSynchronisationMessage ;

namespace Type 
{
class Transform ;
} //namespace Type
} //namespace OMK



OMK_API std::ostream& operator << ( std::ostream& out, const OMK::Type::Transform& q ); 

OMK_API std::istream& operator >> ( std::istream& in, OMK::Type::Transform& q ) ;

OMK_API OMK::OutgoingSynchronisationMessage& operator << 
  ( OMK::OutgoingSynchronisationMessage& out, const OMK::Type::Transform& q ) ;

OMK_API OMK::IncomingSynchronisationMessage& operator >> 
  ( OMK::IncomingSynchronisationMessage& in, OMK::Type::Transform& q ) ;

namespace OMK  
{
namespace Type 
{
class OMK_API Transform
{
public:




  Transform() ;

  Transform( const Wm4::Vector3f& translate,
             const Wm4::Matrix3f& rotate = Wm4::Matrix3f( 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f ),
             float scale = 1.0f ) ;

  Transform( const Wm4::Vector3f& translate,
             const Wm4::Quaternionf& rotate,
             float scale = 1.0f ) ;

  Transform( const Wm4::Vector3f& translate,
             const Wm4::Matrix3f& rotate,
             const Wm4::Vector3f& scale ) ;

  Transform( const Wm4::Vector3f& translate,
             const Wm4::Quaternionf& rotate,
             const Wm4::Vector3f& scale ) ;
  
  virtual ~Transform() ;

  void resetToIdentity() { *this = sk_identity ; }

  void resetUnitScale();




  bool isIdentity() const ;

  bool isUniformScale() const ;





  void updateFlags() ;
  
  void setTranslate( const Wm4::Vector3f& translate );

  void setRotate( const Wm4::Matrix3f& rotate ) ;

  void setRotate( const Wm4::Quaternionf& rotate ) ;

  void setScale( const Wm4::Vector3f& scale ) ;

  void setUniformScale( float scale ) ;

  const Wm4::Matrix3f& getRotate() const ;

  Wm4::Quaternionf getQuaternionRotate() const ;

  const Wm4::Vector3f& getTranslate() const ;

  const Wm4::Vector3f& getScale() const ;

  float getUniformScale() const ;

  Wm4::Vector3f getRight() const ;

  Wm4::Vector3f getUp() const ;

  Wm4::Vector3f getDirection() const ;
  
  bool getOrientation( float& head, float& pitch, float& roll ) const ;

  void setOrientation( float head, float pitch, float roll ) ;
  
  float getNorm() const;

  Wm4::Vector3f applyForward( const Wm4::Vector3f& input ) const ;

  std::vector< Wm4::Vector3f > applyForward( const std::vector< Wm4::Vector3f >& input ) const ;

  Wm4::Vector3f applyInverse( const Wm4::Vector3f& input ) const ;

  std::vector< Wm4::Vector3f > applyInverse( const std::vector< Wm4::Vector3f >& input ) const ;

  Wm4::Vector3f invertVector( const Wm4::Vector3f& input ) const ;

  Wm4::Plane3f applyForward( const Wm4::Plane3f& input ) const ;

  friend Transform OMK_API product( const Transform& A, const Transform& B ) ;

  Transform inverse() const ;

  Wm4::Matrix4f getHomogeneous() const ;

  static const Transform sk_identity ;

  friend OMK_API bool operator == ( const Transform& t0, const Transform& t1 ) ;

  friend OMK_API bool operator != ( const Transform& t0, const Transform& t1 ) ;




  friend std::ostream& ::operator << ( std::ostream& out, const Transform& q ); 

  friend std::istream& ::operator >> ( std::istream& in, Transform& q ) ;

  friend OMK::OutgoingSynchronisationMessage& ::operator << 
    ( OMK::OutgoingSynchronisationMessage& out, const Transform& q ) ;

  friend OMK::IncomingSynchronisationMessage& ::operator >> 
    ( OMK::IncomingSynchronisationMessage& in, Transform& q ) ;

private:
  
  Wm4::Matrix3f _matrix ;

  Wm4::Vector3f _translate ;

  Wm4::Vector3f _scale ;

  bool _identity ;

  bool _uniformScale ;
} ;

//-------------------------------------------------------------------------
// isIdentity
//-------------------------------------------------------------------------
inline bool 
Transform::isIdentity() const 
{ 
  return _identity ; 
}

//-------------------------------------------------------------------------
// isUniformScale
//-------------------------------------------------------------------------
inline bool 
Transform::isUniformScale() const 
{ 
  return _uniformScale ;
}

//-------------------------------------------------------------------------
// getRotate
//-------------------------------------------------------------------------
inline const Wm4::Matrix3f& 
Transform::getRotate() const
{
  return _matrix ;
}

//-------------------------------------------------------------------------
// getQuaternionRotate
//-------------------------------------------------------------------------
inline Wm4::Quaternionf 
Transform::getQuaternionRotate() const 
{
  return Wm4::Quaternionf().FromRotationMatrix( _matrix ) ;
}

//-------------------------------------------------------------------------
// getTranslate
//-------------------------------------------------------------------------
inline const Wm4::Vector3f& 
Transform::getTranslate() const
{
  return _translate;
}

//-------------------------------------------------------------------------
// getScale
//-------------------------------------------------------------------------
inline const Wm4::Vector3f& 
Transform::getScale() const
{
  return _scale ;
}

//-------------------------------------------------------------------------
// getUniformScale
//-------------------------------------------------------------------------
inline float 
Transform::getUniformScale() const
{
  OMASSERTM( isUniformScale(), "Must be a Rotate and Scale tranformation with uniform scale to return the scale value, you should use isUniformScale() before calling it" ) ;
  return _scale.X() ; // same as Y and Z
}
//-------------------------------------------------------------------------
// GetRight
//-------------------------------------------------------------------------
inline Wm4::Vector3f
Transform::getRight() const
{
    return _matrix.GetColumn( 0 ) ;
}

//-------------------------------------------------------------------------
// GetUp
//-------------------------------------------------------------------------
inline Wm4::Vector3f
Transform::getUp() const
{
  return _matrix.GetColumn( 1 ) ;
}

//-------------------------------------------------------------------------
// GetDirection
//-------------------------------------------------------------------------
inline Wm4::Vector3f
Transform::getDirection() const
{
  return _matrix.GetColumn( 2 ) ;
}

//-------------------------------------------------------------------------
// GetOrientation
//-------------------------------------------------------------------------
inline bool
Transform::getOrientation( float& head, float& pitch, float& roll ) const
{
  return  _matrix.ToEulerAnglesYXZ( head, pitch, roll ) ;
}

//-------------------------------------------------------------------------
// SetOrientation
//-------------------------------------------------------------------------
inline void
Transform::setOrientation( float head, float pitch, float roll )
{
  // build the rotation matrix from the head, pitch and roll angles
  _matrix.FromEulerAnglesYXZ( head, pitch, roll ) ;
  _identity = false ;
}

}// namespace Type
}// namespace OMK

#endif // OMK_MATH_OMKTransform_H

---