itkMatrixOffsetTransformBase.h

Go to the documentation of this file.

/*

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMatrixOffsetTransformBase.h,v $
  Language:  C++
  Date:      $Date: 2005/08/11 16:44:08 $
  Version:   $Revision: 1.13 $

  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::JacobianType                    JacobianType;

  typedef typename Superclass::ScalarType                      ScalarType;

  typedef Vector<TScalarType,
                 itkGetStaticConstMacro(InputSpaceDimension)>  InputVectorType;
  typedef Vector<TScalarType,
                 itkGetStaticConstMacro(OutputSpaceDimension)> OutputVectorType;
  
  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 Point<TScalarType,
                itkGetStaticConstMacro(OutputSpaceDimension)>  
                                                    OutputPointType;
  
  typedef Matrix<TScalarType, itkGetStaticConstMacro(OutputSpaceDimension),
                 itkGetStaticConstMacro(InputSpaceDimension)>  
                                                    MatrixType;

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

  typedef InputPointType                            CenterType;

  typedef OutputVectorType                          OffsetType;

  typedef OutputVectorType                          TranslationType;

  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;

  const InverseMatrixType & GetInverseMatrix( void ) const;

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;

  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


#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMatrixOffsetTransformBase.txx"
#endif

#endif /* __itkMatrixOffsetTransformBase_h */

---