itkTranslationTransform.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkTranslationTransform.h,v $
  Language:  C++
  Date:      $Date: 2006/11/03 20:09:08 $
  Version:   $Revision: 1.34 $

  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 __itkTranslationTransform_h
#define __itkTranslationTransform_h

#include <iostream>
#include "itkTransform.h"
#include "itkExceptionObject.h"
#include "itkMatrix.h"




namespace itk
{

template <
    class TScalarType=double,          // Data type for scalars (float or double)
    unsigned int NDimensions=3>        // Number of dimensions
class ITK_EXPORT TranslationTransform : 
          public Transform< TScalarType, NDimensions, NDimensions >
{
public:
  typedef TranslationTransform Self;
  typedef Transform< TScalarType, NDimensions, NDimensions > Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkNewMacro( Self );

  itkTypeMacro( TranslationTransform, Transform );

  itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);
  itkStaticConstMacro(ParametersDimension, unsigned int, NDimensions);

  typedef typename Superclass::ScalarType ScalarType;

  typedef typename Superclass::ParametersType ParametersType;

  typedef typename Superclass::JacobianType JacobianType;

  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;

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

  void SetParameters(const ParametersType & parameters);

  virtual const ParametersType& GetParameters(void) const;

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

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

  void Translate(const OutputVectorType &offset, 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;

  bool GetInverse(Self* inverse) const;

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

  void SetIdentity(void);

  virtual unsigned int GetNumberOfParameters(void) const 
                      { return NDimensions; }

  virtual bool IsLinear() const { return true; }

protected:
  TranslationTransform();
  ~TranslationTransform();
  void PrintSelf(std::ostream &os, Indent indent) const;

private:
  TranslationTransform(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  OutputVectorType   m_Offset;       // Offset of the transformation


}; //class TranslationTransform


// Back transform a point
template<class TScalarType, unsigned int NDimensions>
inline
typename TranslationTransform<TScalarType, NDimensions>::InputPointType
TranslationTransform<TScalarType, NDimensions>::
BackTransform(const OutputPointType &point) const {
  return point - m_Offset;
}




// Back transform a vector
template<class TScalarType, unsigned int NDimensions>
inline
typename TranslationTransform<TScalarType, NDimensions>::InputVectorType
TranslationTransform<TScalarType, NDimensions>::
BackTransform(const OutputVectorType &vect ) const 
{
  return  vect;
}




// Back transform a vnl_vector
template<class TScalarType, unsigned int NDimensions>
inline
typename TranslationTransform<TScalarType, NDimensions>::InputVnlVectorType
TranslationTransform<TScalarType, NDimensions>::
BackTransform(const OutputVnlVectorType &vect ) const 
{
  return  vect;
}


// Back Transform a CovariantVector
template<class TScalarType, unsigned int NDimensions>
inline
typename TranslationTransform<TScalarType, NDimensions>::InputCovariantVectorType
TranslationTransform<TScalarType, NDimensions>::
BackTransform(const OutputCovariantVectorType &vect) const 
{
  return vect;
}

}  // namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_TranslationTransform(_, EXPORT, x, y) namespace itk { \
  _(2(class EXPORT TranslationTransform< ITK_TEMPLATE_2 x >)) \
  namespace Templates { typedef TranslationTransform< ITK_TEMPLATE_2 x > TranslationTransform##y; } \
  }

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

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

#endif /* __itkTranslationTransform_h */

---