Projection/itkEulerAffineTransformMatrixAndItsVariations.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

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

#ifndef itkEulerAffineTransformMatrixAndItsVariations_h
#define itkEulerAffineTransformMatrixAndItsVariations_h

#include <itkEulerAffineTransform.h>
#include <itkImage.h>

#include <vnl/vnl_math.h>
#include <vnl/vnl_vector.h>
#include <vnl/vnl_sparse_matrix.h>


namespace itk
{

  template <class TScalarType = double>
    class ITK_EXPORT EulerAffineTransformMatrixAndItsVariations : public Object
  {
    public:
      typedef EulerAffineTransformMatrixAndItsVariations    Self;
      typedef Object                                        Superclass;
      typedef SmartPointer<Self>                            Pointer;
      typedef SmartPointer<const Self>                      ConstPointer;

      itkNewMacro(Self);

      itkTypeMacro(EulerAffineTransformMatrixAndItsVariations, Object);

      typedef typename itk::Size<3>                                             VolumeSizeType;

      typedef typename itk::EulerAffineTransform<double, 3, 3>                  EulerAffineTransformType;
      typedef typename EulerAffineTransformType::Pointer                        EulerAffineTransformPointerType;
      typedef typename EulerAffineTransformType::ParametersType                 EulerAffineTransformParametersType;

      typedef vnl_sparse_matrix<TScalarType>              SparseMatrixType;
      typedef vnl_matrix<TScalarType>                     FullMatrixType;
      typedef vnl_vector<TScalarType>                     VectorType;

      itkSetObjectMacro( AffineTransform, EulerAffineTransformType );
      itkGetObjectMacro( AffineTransform, EulerAffineTransformType );

      void SetVolumeSize(const VolumeSizeType &r) {m_VolumeSize = r; m_FlagInitialised = false;}

      void GetAffineTransformationSparseMatrix(SparseMatrixType &R, VolumeSizeType &inSize, EulerAffineTransformParametersType &parameters);

      void GetAffineTransformationSparseMatrixT(SparseMatrixType &R, SparseMatrixType &RTrans, VolumeSizeType &inSize);

      void CalculteMatrixVectorMultiplication(SparseMatrixType &R, VectorType const& inputImageVector, VectorType &outputImageVector);

      void SetFDMDifference(const double &diffVal) {m_FDMDiffValue = diffVal;}

      void CalculteMatrixVectorGradient(VolumeSizeType &inSize, VectorType const& inputImageVector, VectorType &outputGradVector, EulerAffineTransformParametersType &parameters, unsigned int paraNum);

      void CalculteMatrixVectorGradient(FullMatrixType &jacobianMatrix, VolumeSizeType &inSize, EulerAffineTransformParametersType &parameters);


    protected:
      EulerAffineTransformMatrixAndItsVariations();
      virtual ~EulerAffineTransformMatrixAndItsVariations(void) {};
      void PrintSelf(std::ostream& os, Indent indent) const;

      VolumeSizeType                                  m_VolumeSize;
      unsigned long int                               m_input3DImageTotalSize;

      double                                          m_FDMDiffValue;

      bool                                            m_FlagInitialised;

      FullMatrixType                                  m_affineCoreMatrix;
      // FullMatrixType                               m_affineCoreMatrixInverse;

      VectorType                                      m_inputCoordinateVector;
      VectorType                                      m_outputCoordinateVector;

      EulerAffineTransformType::Pointer               m_AffineTransform;
      EulerAffineTransformType::JacobianType          m_JacobianArray;

      // SparseMatrixType const*                        pSparseAffineTransformMatrix;

      // SparseMatrixType const*                        pSparseTransposeAffineTransformMatrix;


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

  };

} // end namespace itk

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

#endif