itkScaleTransform.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkScaleTransform.h,v $
  Language:  C++
  Date:      $Date: 2003/11/25 23:50:25 $
  Version:   $Revision: 1.21 $

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

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

namespace itk
{

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

  itkTypeMacro( ScaleTransform, 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 FixedArray<TScalarType, itkGetStaticConstMacro(SpaceDimension)> ScaleType;

  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;
  
  void SetParameters(const ParametersType & parameters);

  const ParametersType & GetParameters( void ) const;

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

  void SetScale( const ScaleType & scale )
    { this->Modified(); m_Scale = scale; }

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

  void Scale(const ScaleType & scale, bool pre=false );

  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;
    
  typename ScaleTransform::Pointer Inverse(void) const;

  void SetIdentity( void )
    { m_Scale.Fill( 1.0 ); }


  itkSetMacro( Center, InputPointType );
  itkGetConstMacro( Center, InputPointType );


  itkGetConstMacro( Scale, ScaleType );


protected:
  ScaleTransform();

  ~ScaleTransform();

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

  
private:
  ScaleTransform(const Self & other); //purposely not implemented
  const Self & operator=( const Self & ); //purposely not implemented

  ScaleType   m_Scale;  // Scales of the transformation

  InputPointType   m_Center; // Scaling center

}; //class ScaleTransform

}  // namespace itk


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

#endif /* __itkScaleTransform_h */

---