itkScalableAffineTransform.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkScalableAffineTransform.h,v $
  Language:  C++
  Date:      $Date: 2007-01-30 20:56:09 $
  Version:   $Revision: 1.3 $

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

#include "itkAffineTransform.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 ITK_EXPORT ScalableAffineTransform 
: public AffineTransform< TScalarType, NDimensions >
{
public:
  typedef ScalableAffineTransform                      Self;
  typedef AffineTransform< TScalarType, NDimensions >  Superclass;
  typedef SmartPointer<Self>                           Pointer;
  typedef SmartPointer<const Self>                     ConstPointer;

  itkTypeMacro( ScalableAffineTransform, AffineTransform );

  itkNewMacro( Self );

  itkStaticConstMacro(InputSpaceDimension, unsigned int, NDimensions);
  itkStaticConstMacro(OutputSpaceDimension, unsigned int, NDimensions);
  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 typename Superclass::InputVectorType           InputVectorType;
  typedef typename Superclass::OutputVectorType          OutputVectorType;
  typedef typename Superclass::InputCovariantVectorType     
                                                     InputCovariantVectorType;
  typedef typename Superclass::OutputCovariantVectorType    
                                                     OutputCovariantVectorType;
  typedef typename Superclass::InputVnlVectorType        InputVnlVectorType;
  typedef typename Superclass::OutputVnlVectorType       OutputVnlVectorType;
  typedef typename Superclass::InputPointType            InputPointType;
  typedef typename Superclass::OutputPointType           OutputPointType;
  typedef typename Superclass::MatrixType                MatrixType;
  typedef typename Superclass::InverseMatrixType         InverseMatrixType;
  typedef typename Superclass::CenterType                CenterType;
  typedef typename Superclass::OffsetType                OffsetType;
  typedef typename Superclass::TranslationType           TranslationType;

  void SetIdentity( void );

  virtual void SetScale( const InputVectorType & scale );
  virtual void SetScaleComponent( const InputVectorType & scale )
    { this->SetScale(scale); };

  virtual void SetScale( const double scale[NDimensions] );
  virtual void SetScaleComponent( const double scale[NDimensions] )
    { this->SetScale(scale); };

  virtual const double * GetScale() const 
    { return m_Scale; };
  virtual const double * GetScaleComponent() const 
    { return m_Scale; };

  void SetMatrixComponent(const MatrixType &matrix)
    { this->SetMatrix( matrix ); };

  const MatrixType & GetMatrixComponent() const 
    { return this->GetMatrix(); }

  void SetOffsetComponent(const OffsetType &offset)
    { this->SetTranslation( offset ); };

  const OffsetType & GetOffsetComponent(void) const 
    { return this->GetTranslation(); }


protected:
  ScalableAffineTransform(const MatrixType &matrix,
                          const OutputVectorType &offset);
  ScalableAffineTransform(unsigned int outputSpaceDimension,
                          unsigned int parametersDimension);
  ScalableAffineTransform();      

  void ComputeMatrix();

  virtual ~ScalableAffineTransform();

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

  void SetVarScale(const double * scale)
    { for(int i=0; i<InputSpaceDimension; i++) { m_Scale[i] = scale[i]; } };

private:

  ScalableAffineTransform(const Self & other);
  const Self & operator=( const Self & );
  
  double               m_Scale[NDimensions];
  InputVectorType      m_MatrixScale;

}; //class ScalableAffineTransform
  
}  // namespace itk

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

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

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

#endif /* __itkScalableAffineTransform_h */