itkAffineTransform.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkAffineTransform.h,v $
  Language:  C++
  Date:      $Date: 2002/10/11 20:56:04 $
  Version:   $Revision: 1.45 $

  Copyright (c) 2002 Insight 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 __itkAffineTransform_h
#define __itkAffineTransform_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 (e.g. float or double)
 unsigned int NDimensions=3>       // Number of dimensions in the input space
class AffineTransform : public Transform< TScalarType,
                                          NDimensions, 
                                          NDimensions >
{
public:
  typedef AffineTransform  Self;
  typedef Transform< TScalarType, NDimensions, NDimensions >  Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;
  
  itkTypeMacro( AffineTransform, Transform );

  itkNewMacro( Self );

  itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);
  itkStaticConstMacro(ParametersDimension, unsigned int,
                      NDimensions*(NDimensions+1));

  
  typedef typename Superclass::ParametersType  ParametersType;

  typedef typename Superclass::JacobianType  JacobianType;

  typedef typename Superclass::ScalarType ScalarType;

  typedef Vector<TScalarType,
                 itkGetStaticConstMacro(SpaceDimension)>  InputVectorType;
  typedef Vector<TScalarType,
                 itkGetStaticConstMacro(SpaceDimension)>  OutputVectorType;
  
  typedef CovariantVector<TScalarType,
                          itkGetStaticConstMacro(SpaceDimension)>  InputCovariantVectorType;
  typedef CovariantVector<TScalarType,
                          itkGetStaticConstMacro(SpaceDimension)>  OutputCovariantVectorType;
  
  typedef vnl_vector_fixed<TScalarType,
                           itkGetStaticConstMacro(SpaceDimension)> InputVnlVectorType;
  typedef vnl_vector_fixed<TScalarType,
                           itkGetStaticConstMacro(SpaceDimension)> OutputVnlVectorType;
  
  typedef Point<TScalarType,
                itkGetStaticConstMacro(SpaceDimension)> InputPointType;
  typedef Point<TScalarType,
                itkGetStaticConstMacro(SpaceDimension)> OutputPointType;
  
  typedef Matrix<TScalarType, itkGetStaticConstMacro(SpaceDimension),
                 itkGetStaticConstMacro(SpaceDimension)> MatrixType;

  typedef     OutputVectorType    OffsetType;

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

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

  void SetIdentity( void )
    { m_Matrix.SetIdentity();
    m_Offset.Fill( 0.0 ); }

  const MatrixType & GetInverse() const
    { if( m_Singular ) { throw ExceptionObject(__FILE__, __LINE__); }
    return m_Inverse; 
    }

  void SetOffset(const OffsetType &offset)
      { m_Offset = offset; return; }

  void SetMatrix(const MatrixType &matrix)
      { m_Matrix = matrix; RecomputeInverse(); return; }

  void SetParameters( const ParametersType & parameters );

  const ParametersType& GetParameters(void) const;

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

  void Translate(const OutputVectorType &offset, bool pre=0);

  void Scale(const OutputVectorType &factor, bool pre=0);
  void Scale(const TScalarType &factor, bool pre=0);

  void Rotate(int axis1, int axis2, TScalarType angle, bool pre=0);

  void Rotate2D(TScalarType angle, bool pre=0);

  void Rotate3D(const OutputVectorType &axis, TScalarType angle, bool pre=0);

  void Shear(int axis1, int axis2, TScalarType coef, 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;
  
  inline InputPointType   BackTransform(const OutputPointType  &point ) const;
  inline InputVectorType  BackTransform(const OutputVectorType &vector) const;
  inline InputVnlVectorType BackTransform(const OutputVnlVectorType &vector) const;

  inline InputCovariantVectorType BackTransform(
                              const OutputCovariantVectorType &vector) const;

  InputPointType  BackTransformPoint(const OutputPointType  &point) const;

  AffineTransform::Pointer Inverse(void) const;

  ScalarType Metric(const Self * other) const;

  ScalarType Metric(void) const;

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

  const JacobianType & GetJacobian(const InputPointType  &point ) const;

protected:
  AffineTransform(const MatrixType &matrix, const OutputVectorType &offset);
  AffineTransform();      
  
  virtual ~AffineTransform();

  void RecomputeInverse();

private:
  AffineTransform(const Self & other);
  const Self & operator=( const Self & );

  MatrixType         m_Matrix;       // Matrix of the transformation
  OffsetType         m_Offset;       // Offset of the transformation
  MatrixType         m_Inverse;      // Inverse of the matrix
  bool               m_Singular;     // Is m_Inverse singular?


}; //class AffineTransform

}  // namespace itk


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

#endif /* __itkAffineTransform_h */

---