albaMatrix.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaMatrix
 Authors: Marco Petrone
 
 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 __albaMatrix_h
#define __albaMatrix_h
 
#include "albaReferenceCounted.h"
#include "albaMTime.h"
#include "vtkType.h"
 
typedef double (*albaMatrixElements)[4];
 
//------------------------------------------------------------------------------
// Forward declarations
//------------------------------------------------------------------------------
#ifdef ALBA_USE_VTK
class vtkMatrix4x4;
#endif
class albaVect3d;
 
 
class ALBA_EXPORT albaMatrix : public albaReferenceCounted
{
public:
  albaTypeMacro(albaMatrix,albaReferenceCounted);
  virtual void Print(std::ostream& os, const int indent=0) const;
 
  albaMatrix();
  virtual ~albaMatrix();
 
  albaMatrix(const albaMatrix &mat);
 
  albaMatrix &operator=(const albaMatrix &mat);
 
  bool operator==(const albaMatrix& mat) const;
 
  bool Equals(const albaMatrix *mat) const;
 
  void DeepCopy(const albaMatrix* mat) {*this=*mat;}
 
#ifdef ALBA_USE_VTK
 
  albaMatrix(vtkMatrix4x4 *mat);
 
  void SetVTKMatrix(vtkMatrix4x4 *mat,albaTimeStamp t=0);
 
  void DeepCopy(vtkMatrix4x4 *mat);
 
  vtkMatrix4x4 *GetVTKMatrix() const {return m_VTKMatrix;}
 
  bool operator==(vtkMatrix4x4 *mat) const;  
#endif
 
  albaMatrixElements GetElements() const;
 
  void SetElement(const int i, const int j, double value) {GetElements()[i][j]=value;Modified();}
 
  double GetElement(const int i, const int j) const {return GetElements()[i][j];}
 
  vtkMTimeType GetMTime() const;
 
  void Modified();
  
  void SetTimeStamp(albaTimeStamp t) {if (!albaEquals(m_TimeStamp,t)){m_TimeStamp=t; Modified();}};
  albaTimeStamp GetTimeStamp() const {return m_TimeStamp;};
 
  static void GetVersor(const int axis, const albaMatrix &matrix, double versor[3]);
  void GetVersor(const int axis, double versor[3]) const {GetVersor(axis,(*this),versor);}
 
  void CopyRotation(const albaMatrix &source) {CopyRotation(source,*this);}
  static void CopyRotation(const albaMatrix &source, albaMatrix &target);
 
  void Zero() { albaMatrix::Zero(*GetElements()); Modified(); }
  static void Zero(double elements[16]);
 
  void Identity() { albaMatrix::Identity(*GetElements()); Modified();}
  static void Identity(double elements[16]);
 
   bool IsIdentity();
 
  static void Invert(const albaMatrix &in, albaMatrix &out) {albaMatrix::Invert(*in.GetElements(),*out.GetElements()); out.Modified();}
   albaMatrix *Invert() { albaMatrix::Invert(*this, *this); return this; }
  static void Invert(const double inElements[16], double outElements[16]);
  
  static double Determinant(const double Elements[16]);
  double Determinant() const {return Determinant(*GetElements());};
 
  static void Adjoint(const double inElements[16], double outElements[16]);
  void Adjoint(const albaMatrix &inMat, albaMatrix &outMat) {Adjoint(*(inMat.GetElements()),*(outMat.GetElements()));outMat.Modified();};
  void Adjoint() {Adjoint(*GetElements(),*GetElements());Modified();}
 
  static void Transpose(const albaMatrix &in, albaMatrix &out) 
    {albaMatrix::Transpose(*in.GetElements(),*out.GetElements()); out.Modified(); }
  void Transpose() { albaMatrix::Transpose(*this,*this); }
  static void Transpose(const double inElements[16], double outElements[16]);
 
  void MultiplyPoint(const double in[4], double out[4]) const
    {albaMatrix::MultiplyPoint(*GetElements(),in,out); }
 
   albaVect3d MultiplyPoint(albaVect3d point);
 
 
  static void MultiplyPoint(const double Elements[16], 
                            const double in[4], double out[4]);
 
  static void Multiply4x4(const albaMatrix &a, const albaMatrix &b, albaMatrix &c) {
    albaMatrix::Multiply4x4(*a.GetElements(),*b.GetElements(),*c.GetElements());c.Modified();};
  static void Multiply4x4(const double a[16], const double b[16], 
                          double c[16]);
 
  double *operator[](const unsigned int i) {return &(GetElements()[i][0]);Modified();}
 
  const double *operator[](unsigned int i) const { return &(GetElements()[i][0]); }  
 
   operator vtkMatrix4x4*() const {
      return GetVTKMatrix();
   }
 
  //double *operator[][](const unsigned int i,const unsigned int j) {return &(GetElements()[i][j]);}
  
  static void PointMultiply(const double Elements[16], 
                            const float in[4], float out[4]);
  static void PointMultiply(const double Elements[16], 
                            const double in[4], double out[4]);
   
   void SetFromDirectionCosines(const double orientation[6]);
protected:
  albaTimeStamp m_TimeStamp;
 
#ifdef ALBA_USE_VTK
  vtkMatrix4x4 *m_VTKMatrix; 
#else
  double m_Elements[4][4]; 
  albaMTime m_MTime;
#endif
  
};
 
#endif