albaTransformBase.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaTransformBase
 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 __albaTransformBase_h
#define __albaTransformBase_h
 
#include "albaReferenceCounted.h"
#include "albaMTime.h"
#include "albaMutexLock.h"
#include "albaMatrix.h"
#include "albaSmartPointer.h"
#include "albaEventBroadcaster.h"
 
//------------------------------------------------------------------------------
// Forward declarations
//------------------------------------------------------------------------------
class vtkLinearTransform;
class vtkALBAToLinearTransform;
 
#ifdef ALBA_EXPORTS
template class ALBA_EXPORT albaAutoPointer<albaMatrix>;
#endif
 
class ALBA_EXPORT albaTransformBase : public albaReferenceCounted, public albaEventBroadcaster
{
public:
  albaTransformBase();
  ~albaTransformBase();
 
  albaTransformBase(const albaTransformBase&);
 
  albaAbstractTypeMacro(albaTransformBase,albaReferenceCounted);
  virtual void Print(std::ostream& os, const int indent=0) const;
 
  virtual const albaMatrix &GetMatrix() {Update();return *m_Matrix;}
 
  albaMatrix *GetMatrixPointer() {Update(); return m_Matrix;}
 
  void TransformPoint(const float in[3], float out[3]) \
    { this->Update(); this->InternalTransformPoint(in,out); };
 
  void TransformPoint(const double in[3], double out[3]) \
    { this->Update(); this->InternalTransformPoint(in,out); };
 
  
  void TransformNormalAtPoint(const float point[3], const float in[3],
                              float out[3]);
  void TransformNormalAtPoint(const double point[3], const double in[3],
                              double out[3]);
 
  void TransformVectorAtPoint(const float point[3], const float in[3],
                              float out[3]);
  void TransformVectorAtPoint(const double point[3], const double in[3],
                              double out[3]);
 
  virtual void Update();
 
  void Modified();
 
  virtual void InternalTransformPoint(const double in[3], double out[3]);
  virtual void InternalTransformPoint(const float in[3], float out[3]);
 
  //virtual albaTransformBase *MakeTransform() = 0;
 
  //virtual int CircuitCheck(albaTransformBase *transform);
 
  virtual unsigned long GetMTime() {return m_MTime.GetMTime();}
 
  virtual unsigned long GetUpdateTime() {return m_UpdateTime.GetMTime();}
 
  void SetTimeStamp(albaTimeStamp t) {if (!albaEquals(m_TimeStamp,t)){m_TimeStamp=t; Modified();}}
 
  albaTimeStamp GetTimeStamp() {return m_TimeStamp;}
 
#ifdef ALBA_USE_VTK
  vtkLinearTransform *GetVTKTransform();
 
  operator vtkLinearTransform*() {return GetVTKTransform();}
#endif
 
protected:
  albaAutoPointer<albaMatrix> m_Matrix;        
  albaMTime        m_MTime;           
  albaMTime        m_UpdateTime;      
  albaMutexLock    m_UpdateMutex; 
 
  albaTimeStamp    m_TimeStamp;   
 
  #ifdef ALBA_USE_VTK
  vtkALBAToLinearTransform *m_VTKTransform; 
  #endif
 
  virtual void InternalUpdate() = 0;
 
private:
 
};
 
//------------------------------------------------------------------------------
inline void albaTransformBase::Modified()
//------------------------------------------------------------------------------
{
  m_MTime.Modified();
}
 
 
#endif