itkMatrixOffsetTransformBase.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMatrixOffsetTransformBase.h,v $
  Language:  C++
  Date:      $Date: 2009-11-28 15:58:04 $
  Version:   $Revision: 1.25 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkMatrixOffsetTransformBase_h
#define __itkMatrixOffsetTransformBase_h

#include <iostream>

#include "itkMatrix.h"
#include "itkTransform.h"
#include "itkExceptionObject.h"
#include "itkMacro.h"

namespace itk
{


template <
  class TScalarType=double,         // Data type for scalars 
  unsigned int NInputDimensions=3,  // Number of dimensions in the input space
  unsigned int NOutputDimensions=3> // Number of dimensions in the output space
class MatrixOffsetTransformBase 
  : public Transform< TScalarType, NInputDimensions, NOutputDimensions >
{
public:
  typedef MatrixOffsetTransformBase             Self;
  typedef Transform< TScalarType,
                     NInputDimensions,
                     NOutputDimensions >        Superclass;
  typedef SmartPointer<Self>                    Pointer;
  typedef SmartPointer<const Self>              ConstPointer;
  
  itkTypeMacro( MatrixOffsetTransformBase, Transform );

  itkNewMacro( Self );

  itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions);
  itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions);
  itkStaticConstMacro(ParametersDimension, unsigned int,
                      NOutputDimensions*(NInputDimensions+1));

  
  typedef typename Superclass::ParametersType                  ParametersType;
  typedef typename Superclass::ParametersValueType             ParametersValueType;

  typedef typename Superclass::JacobianType                    JacobianType;

  typedef typename Superclass::ScalarType                      ScalarType;

  typedef Vector<TScalarType,
                 itkGetStaticConstMacro(InputSpaceDimension)>  InputVectorType;
  typedef Vector<TScalarType,
                 itkGetStaticConstMacro(OutputSpaceDimension)> OutputVectorType;
  typedef typename OutputVectorType::ValueType                 OutputVectorValueType;
  
  typedef CovariantVector<TScalarType,
                          itkGetStaticConstMacro(InputSpaceDimension)>  
                                                    InputCovariantVectorType;
  typedef CovariantVector<TScalarType,
                          itkGetStaticConstMacro(OutputSpaceDimension)>  
                                                    OutputCovariantVectorType;
  
  typedef vnl_vector_fixed<TScalarType,
                           itkGetStaticConstMacro(InputSpaceDimension)> 
                                                    InputVnlVectorType;
  typedef vnl_vector_fixed<TScalarType,
                           itkGetStaticConstMacro(OutputSpaceDimension)> 
                                                    OutputVnlVectorType;
  
  typedef Point<TScalarType,
                itkGetStaticConstMacro(InputSpaceDimension)>   
                                                    InputPointType;
  typedef typename InputPointType::ValueType        InputPointValueType;
  typedef Point<TScalarType,
                itkGetStaticConstMacro(OutputSpaceDimension)>  
                                                    OutputPointType;
  typedef typename OutputPointType::ValueType       OutputPointValueType;
  
  typedef Matrix<TScalarType, itkGetStaticConstMacro(OutputSpaceDimension),
                 itkGetStaticConstMacro(InputSpaceDimension)>  
                                                    MatrixType;
  typedef typename MatrixType::ValueType            MatrixValueType;

  typedef Matrix<TScalarType, itkGetStaticConstMacro(InputSpaceDimension),
                 itkGetStaticConstMacro(OutputSpaceDimension)> 
                                                    InverseMatrixType;

  typedef InputPointType                            CenterType;

  typedef OutputVectorType                          OffsetType;
  typedef typename OffsetType::ValueType            OffsetValueType;

  typedef OutputVectorType                          TranslationType;

  typedef typename TranslationType::ValueType       TranslationValueType;

  typedef typename Superclass::InverseTransformBaseType InverseTransformBaseType;
  typedef typename InverseTransformBaseType::Pointer    InverseTransformBasePointer;

  virtual void SetIdentity( void );

  virtual void SetMatrix(const MatrixType &matrix)
    {
    m_Matrix = matrix; this->ComputeOffset();
    this->ComputeMatrixParameters();
    m_MatrixMTime.Modified(); this->Modified(); return;
    }

  const MatrixType & GetMatrix() const
    { return m_Matrix; }

  void SetOffset(const OutputVectorType &offset)
    {
    m_Offset = offset; this->ComputeTranslation();
    this->Modified(); return;
    }

  const OutputVectorType & GetOffset(void) const
    { return m_Offset; }

  void SetCenter(const InputPointType & center)
    {
    m_Center = center; this->ComputeOffset();
    this->Modified(); return;
    }

  const InputPointType & GetCenter() const
    { return m_Center; }

  void SetTranslation(const OutputVectorType & translation)
    {
    m_Translation = translation; this->ComputeOffset();
    this->Modified(); return;
    }

  const OutputVectorType & GetTranslation(void) const
    {
    return m_Translation;
    }

  void SetParameters( const ParametersType & parameters );

  const ParametersType& GetParameters(void) const;

  virtual void SetFixedParameters( const ParametersType & );

  virtual const ParametersType& GetFixedParameters(void) const;


  void Compose(const Self * other, bool pre=0);

  OutputPointType     TransformPoint(const InputPointType & point) const;
  OutputVectorType    TransformVector(const InputVectorType & vector) const;
  OutputVnlVectorType TransformVector(const InputVnlVectorType & vector) const;
  OutputCovariantVectorType TransformCovariantVector(
                                const InputCovariantVectorType &vector) const;
  
  const JacobianType & GetJacobian(const InputPointType & point ) const;

  bool GetInverse(Self * inverse) const;

  virtual InverseTransformBasePointer GetInverseTransform() const;

  const InverseMatrixType & GetInverseMatrix( void ) const;

  virtual bool IsLinear() const { return true; }

protected:
  MatrixOffsetTransformBase(const MatrixType &matrix,
                            const OutputVectorType &offset);
  MatrixOffsetTransformBase(unsigned int outputDims,
                            unsigned int paramDims);
  MatrixOffsetTransformBase();
  
  virtual ~MatrixOffsetTransformBase();

  void PrintSelf(std::ostream &s, Indent indent) const;

  const InverseMatrixType & GetVarInverseMatrix( void ) const
    { return m_InverseMatrix; }
  void SetVarInverseMatrix(const InverseMatrixType & matrix) const
    { m_InverseMatrix = matrix; m_InverseMatrixMTime.Modified(); }
  bool InverseMatrixIsOld(void) const
    {
    if(m_MatrixMTime != m_InverseMatrixMTime)
      {
      return true;
      }
    else
      {
      return false;
      }
    }

  virtual void ComputeMatrixParameters(void);

  virtual void ComputeMatrix(void);
  void SetVarMatrix(const MatrixType & matrix)
    { m_Matrix = matrix; m_MatrixMTime.Modified(); }

  virtual void ComputeTranslation(void);
  void SetVarTranslation(const OutputVectorType & translation)
    { m_Translation = translation; }

  virtual void ComputeOffset(void);
  void SetVarOffset(const OutputVectorType & offset)
    { m_Offset = offset; }

  void SetVarCenter(const InputPointType & center)
    { m_Center = center; }

private:

  MatrixOffsetTransformBase(const Self & other);
  const Self & operator=( const Self & );

 
  MatrixType                  m_Matrix;         // Matrix of the transformation
  OutputVectorType            m_Offset;         // Offset of the transformation
  mutable InverseMatrixType   m_InverseMatrix;  // Inverse of the matrix
  mutable bool                m_Singular;       // Is m_Inverse singular?

  InputPointType              m_Center;
  OutputVectorType            m_Translation;

  TimeStamp                   m_MatrixMTime;
  mutable TimeStamp           m_InverseMatrixMTime;

}; //class MatrixOffsetTransformBase

}  // namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_MatrixOffsetTransformBase(_, EXPORT, x, y) namespace itk { \
  _(3(class EXPORT MatrixOffsetTransformBase< ITK_TEMPLATE_3 x >)) \
  namespace Templates { typedef MatrixOffsetTransformBase< ITK_TEMPLATE_3 x > MatrixOffsetTransformBase##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkMatrixOffsetTransformBase+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkMatrixOffsetTransformBase.txx"
#endif

#endif /* __itkMatrixOffsetTransformBase_h */