albaTransform.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaTransform
 Authors: Marco Petrone, Stefano Perticoni,Stefania Paperini
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
 
#ifndef __albaTransform_h
#define __albaTransform_h
 
#include "albaTransformBase.h"
#include "albaInteractorConstraint.h"
 
#include "albaUtility.h"
 
//------------------------------------------------------------------------------
// Forward declarations
//------------------------------------------------------------------------------
class vtkMatrix4x4;
 
//----------------------------------------------------------------------------   
//  Constants:
//----------------------------------------------------------------------------   
enum ALBA_EXPORT MATRIX_MULTIPLICATION_ID
{ 
  POST_MULTIPLY = 0, 
  PRE_MULTIPLY 
};
//#define ALBA_FLT_MAX     3.40282346638528860e38F
 
class ALBA_EXPORT albaTransform : public albaTransformBase
{
 public:
  //------------------------------------------------------------------------------
  // Events
  //------------------------------------------------------------------------------
  //ALBA_ID_DEC(UpdateEvent); // Event rised by updates of the internal matrix
   
  albaTransform();
  ~albaTransform();
 
  //----------------------------------------------------------------------------
  // Ref Sys Type:
  //----------------------------------------------------------------------------
  enum 
  {
    CUSTOM = 0, 
    GLOBAL, 
    PARENT,
    LOCAL,   
    VIEW     
  };
 
  albaTransform(const albaTransform&);
 
  albaTypeMacro(albaTransform,albaTransformBase);
  
  virtual void SetMatrix(const albaMatrix &input) {*m_Matrix=input;SetTimeStamp(input.GetTimeStamp());Modified();}
 
  void SetMatrixPointer(albaMatrix *matrix);
 
   static double PolarDecomp(const albaMatrix &M, albaMatrix &Q, albaMatrix &S, double translation[3]);
  double PolarDecomp(albaMatrix &Q, albaMatrix &S, double translation[3]) {return PolarDecomp(GetMatrix(),Q,S,translation);}
  
  void Identity();
 
  void Invert();
 
  static void GetOrientation(const albaMatrix &in_matrix,double orientation[3]);
  static void GetOrientation(const albaMatrix &in_matrix,float orientation[3]);
  void GetOrientation(double orientation[3]) { this->GetOrientation(GetMatrix(),orientation);}
  void GetOrientation(float orient[3]) {
    double temp[3]; this->GetOrientation(temp); 
    orient[0] = static_cast<float>(temp[0]); 
    orient[1] = static_cast<float>(temp[1]); 
    orient[2] = static_cast<float>(temp[2]); };
 
  static void GetOrientationWXYZ(const albaMatrix &in_matrix, double wxyz[4]);
  void GetOrientationWXYZ(double wxyz[4]) \
      { GetOrientationWXYZ(GetMatrix(),wxyz);}
  void GetOrientationWXYZ(float wxyz[3]) {
    double temp[4]; GetOrientationWXYZ(temp); 
    wxyz[0]=static_cast<float>(temp[0]); 
    wxyz[1]=static_cast<float>(temp[1]); 
    wxyz[2]=static_cast<float>(temp[2]); 
    wxyz[3]=static_cast<float>(temp[3]);};
 
  static void GetPosition(const albaMatrix &matrix,double position[3]);
  static void GetPosition(const albaMatrix &matrix,float position[3]);
  void GetPosition(double position[3]) {this->GetPosition(GetMatrix(),position);}
  void GetPosition(float position[3]) {
    double temp[3]; this->GetPosition(temp); 
    position[0] = static_cast<float>(temp[0]); 
    position[1] = static_cast<float>(temp[1]); 
    position[2] = static_cast<float>(temp[2]); };
 
  static void SetPosition(albaMatrix &matrix,double position[3]);
  void SetPosition(double position[3]) {this->SetPosition(*m_Matrix,position);}
  void SetPosition(double x,double y,double z) {this->SetPosition(*m_Matrix,x,y,z);}
  static void SetPosition(albaMatrix &matrix, double x,double y,double z) {
    double temp[3];
    temp[0]=x;temp[1]=y;temp[2]=z;
    SetPosition(matrix,temp);}
 
  static void Translate(albaMatrix &matrix,double translation[3],int premultiply);
  void Translate(double translation[3],int premultiply) {this->Translate(*m_Matrix,translation,premultiply);}
  void Translate(double x,double y,double z,int premultiply) {this->Translate(*m_Matrix,x,y,z,premultiply);}
  static void Translate(albaMatrix &matrix, double x,double y,double z,int premultiply) {
    double temp[3];
    temp[0]=x;temp[1]=y;temp[2]=z;
    Translate(matrix,temp,premultiply);}
 
  static void RotateWXYZ(const albaMatrix &source,albaMatrix &target,double angle,double x, double y, double z,int premultiply);
  void RotateWXYZ(double angle,double x, double y, double z,int premultiply) {this->RotateWXYZ(*m_Matrix,*m_Matrix,angle,x,y,z,premultiply);}
  void RotateWXYZ(double angle,double rot[3],int premultiply) {this->RotateWXYZ(*m_Matrix,*m_Matrix,angle, rot[0], rot[1], rot[2],premultiply);}
 
 
  static void RotateX(albaMatrix &matrix,double angle,int premultiply) { albaTransform::RotateWXYZ(matrix,matrix,angle, 1, 0, 0,premultiply); };
  static void RotateY(albaMatrix &matrix,double angle,int premultiply) { albaTransform::RotateWXYZ(matrix,matrix,angle, 0, 1, 0,premultiply); };
  static void RotateZ(albaMatrix &matrix,double angle,int premultiply) { albaTransform::RotateWXYZ(matrix,matrix,angle, 0, 0, 1,premultiply); };
  void RotateX(double angle,int premultiply) { this->RotateX(*m_Matrix,angle,premultiply); };
  void RotateY(double angle,int premultiply) { this->RotateY(*m_Matrix,angle,premultiply); };
  void RotateZ(double angle,int premultiply) { this->RotateZ(*m_Matrix,angle,premultiply); };
 
  void Concatenate(const albaMatrix &matrix, int premultiply);
 
  void Concatenate(albaTransformBase *trans, int premultiply) {Concatenate(trans->GetMatrix(),premultiply);}
 
  static void SetOrientation(albaMatrix &matrix,double orientation[3]);
  void SetOrientation(double orientation[3]) {this->SetOrientation(*m_Matrix,orientation);}
  void SetOrientation(double rx,double ry,double rz) {this->SetOrientation(*m_Matrix,rx,ry,rz);}
  static void SetOrientation(albaMatrix &matrix,double rx,double ry,double rz) {
    double temp[3];
    temp[0]=rx;temp[1]=ry;temp[2]=rz;
    SetOrientation(matrix,temp);}
 
  static void GetScale(const albaMatrix &matrix,double scale[3]);
  void GetScale(double scale[3]) {this->GetScale(*m_Matrix,scale);}
  void GetScale(float scale[3]) {
    double temp[3]; this->GetScale(temp); 
    scale[0] = static_cast<float>(temp[0]); 
    scale[1] = static_cast<float>(temp[1]); 
    scale[2] = static_cast<float>(temp[2]); };
 
  static void Scale(albaMatrix &matrix,double scalex,double scaley,double scalez,int premultiply);
  void Scale(double scalex,double scaley,double scalez,int premultiply) \
    { Scale(*m_Matrix,scalex,scaley,scalez,premultiply);}
 
  static void SetVersor(int axis, double versor[3], albaMatrix &matrix);
  
  static void GetVersor(int axis, const albaMatrix &matrix, double versor[3]) {albaMatrix::GetVersor(axis,matrix,versor);}
  static void GetVersor(int axis, const albaMatrix &matrix, float versor[3]) \
    { \
      double temp[3]; GetVersor(axis, matrix, temp); \
      versor[0] = static_cast<float>(temp[0]); \
      versor[1] = static_cast<float>(temp[1]); \
      versor[2] = static_cast<float>(temp[2]); };
  
  void GetVersor(int axis, double versor[3]) {GetVersor(axis,GetMatrix(),versor);}
  void GetVersor(int axis, float versor[3]) {GetVersor(axis,GetMatrix(),versor);}
 
  static void CopyRotation(const albaMatrix &source, albaMatrix &target);
  void CopyRotation(const albaMatrix &source) {this->CopyRotation(source,*m_Matrix);}
 
  static void CopyTranslation(const albaMatrix &source, albaMatrix &target);
  void CopyTranslation(const albaMatrix &source) {this->CopyTranslation(source,*m_Matrix);}
  
  static void AddVectors( double inV0[3],double inV1[3],double outSum[3] );
 
  static void BuildVector(double *p1, double *p2, double *out_vector);
 
  static void BuildVector(double coeff, const double *inVector, double *outVector, int refSysType = LOCAL, int localAxis = albaInteractorConstraint::X);
 
  static double ProjectVectorOnAxis(const double *in_vector, const double *in_axis, double *out_projection = NULL);
 
  static double ProjectVectorOnPlane(const double *in_vector, const double *in_plane_normal, double *out_projection = NULL);
 
  static void FindPerpendicularVersors(double inVersorN[3], double outVersorP[3], double outVersorQ[3]);
 
  static void MultiplyVectorByScalar(double s, double *vin, double *vout);
 
   int MatrixToAttitudeVector(const albaMatrix &matrix,
                                      double attitude_vector[3]);
 
   int MatrixToEulerCardanicAngle(const albaMatrix &matrix,
                                       int i,int j,int k,
                                       double euler_cardan[3],
                                       double tentative_euler_cardan_first,
                                       double tentative_euler_cardan_second,
                                       double tentative_euler_cardan_third);
 
   int MatrixTommuQuaternion(const albaMatrix &matrix, double quaternion[4]);
 
   int QuaternionToMatrix(double quaternion[4], albaMatrix &matrix);
 
   int HelicalAxisToMatrix(double helical_axis[3],double angle, albaMatrix &matrix);
 
   int AttitudeVectorToMatrix(double attitude_vector[3], albaMatrix &matrix);
 
   int EulerCardanicAngleToMatrix(double euler_cardan[3],
                                       int i,int j,int k,
                                       albaMatrix &matrix);
 
   int MatrixToHelicalAxis(const albaMatrix &matrix,
                                                                double helical_axis[3],double point[3],
                                                                double& phi,double& t, int intersect);
 
 
  //----------------------------------------------------------------------------
  // declarations for polar_decomp algorithm from Graphics Gems IV,
  // by Ken Shoemake <shoemake@graphics.cis.upenn.edu>
  //----------------------------------------------------------------------------
  enum mmuQuatPart {X, Y, Z, W};
 
  typedef struct {double x, y, z, w;} mmuQuat; 
  typedef mmuQuat HVect; 
  
  typedef struct {
     HVect t;  
     mmuQuat  q;  
     mmuQuat  u;  
     HVect k;  
     double f; 
  } mmuAffineParts;
  
  typedef double HMatrix[4][4]; /* Right-handed, for column vectors */
  static double PolarDecomp(HMatrix M, HMatrix Q, HMatrix S);
  static void DecompAffine(HMatrix A, mmuAffineParts *parts);
  static HVect SpectDecomp(HMatrix S, HMatrix U);
  static mmuQuat QuaternionFromMatrix(HMatrix mat);
  static void InvertAffine(mmuAffineParts *parts, mmuAffineParts *inverse);
  static mmuQuat Snuggle(mmuQuat q, HVect *k);
  //----------------------------------------------------------------------------
protected:
  virtual void InternalUpdate() {m_Matrix->SetTimeStamp(m_TimeStamp);}
private:
};
 
#endif