itkFixedCenterOfRotationAffineTransform.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkFixedCenterOfRotationAffineTransform.h,v $
  Language:  C++
  Date:      $Date: 2008-10-16 17:27:11 $
  Version:   $Revision: 1.9 $

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

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

  itkTypeMacro( FixedCenterOfRotationAffineTransform, ScalableAffineTransform );

  itkNewMacro( Self );

  itkStaticConstMacro(InputSpaceDimension, unsigned int, NDimensions);
  itkStaticConstMacro(OutputSpaceDimension, unsigned int, NDimensions);
  itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);
  itkStaticConstMacro(ParametersDimension, unsigned int,
                      NDimensions*(NDimensions+2));

  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::TranslationType           TranslationType;
  typedef typename Superclass::OffsetType                OffsetType;

  void SetCenterOfRotationComponent(const InputPointType &cor)
    { this->SetCenter( cor ); }
  InputPointType GetCenterOfRotationComponent(void) const
    { return this->GetCenter(); }

  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:
  FixedCenterOfRotationAffineTransform(const MatrixType &matrix,
                                       const OutputVectorType &offset);
  FixedCenterOfRotationAffineTransform(unsigned int outputSpaceDimension,
                                       unsigned int parametersDimension);
  FixedCenterOfRotationAffineTransform();

  virtual ~FixedCenterOfRotationAffineTransform();

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

}; //class FixedCenterOfRotationAffineTransform
  
}  // namespace itk

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

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

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

#endif /* __itkFixedCenterOfRotationAffineTransform_h */