itkSimultaneousUnconstrainedMatrixReconRegnMetric.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 itkSimultaneousUnconstrainedMatrixReconRegnMetric_h
#define itkSimultaneousUnconstrainedMatrixReconRegnMetric_h

#include <itkConceptChecking.h>
#include <itkSingleValuedCostFunction.h>

#include <itkForwardAndBackwardProjectionMatrix.h>
#include <itkEulerAffineTransformMatrixAndItsVariations.h>



namespace itk
{
  
template <class TScalarType = double, class IntensityType = float>
class ITK_EXPORT SimultaneousUnconstrainedMatrixReconRegnMetric : public SingleValuedCostFunction
{
public:

  typedef SimultaneousUnconstrainedMatrixReconRegnMetric    Self;
  typedef SingleValuedCostFunction                          Superclass;
  typedef SmartPointer<Self>                                Pointer;
  typedef SmartPointer<const Self>                          ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(SimultaneousUnconstrainedMatrixReconRegnMetric, SingleValuedCostFunction);

  // Some convenient typedefs.

  typedef itk::ForwardAndBackwardProjectionMatrix< TScalarType, IntensityType >                 MatrixProjectorType;
  typedef typename MatrixProjectorType::Pointer                                                 MatrixProjectorPointerType;

  typedef typename MatrixProjectorType::InputImageType                                          InputVolumeType;
  typedef typename MatrixProjectorType::InputImagePointer                                       InputVolumePointer;
  typedef typename MatrixProjectorType::InputImageConstPointer                                  InputVolumeConstPointer;
  typedef typename MatrixProjectorType::InputImageRegionType                                    InputVolumeRegionType;
  typedef typename MatrixProjectorType::InputImageSizeType                                      InputVolumeSizeType;
  typedef typename MatrixProjectorType::InputImageSpacingType                                   InputVolumeSpacingType;
  typedef typename MatrixProjectorType::InputImagePointType                                     InputVolumePointType;
  typedef typename MatrixProjectorType::InputImageIndexType                                     InputVolumeIndexType;

  typedef typename MatrixProjectorType::OutputImageType                                         InputProjectionType;
  typedef typename MatrixProjectorType::OutputImagePointer                                      InputProjectionPointer;
  typedef typename MatrixProjectorType::OutputImageConstPointer                                 InputProjectionConstPointer;
  typedef typename MatrixProjectorType::OutputImageSizeType                                     InputProjectionSizeType;

  typedef itk::EulerAffineTransformMatrixAndItsVariations< double >                             AffineTransformerType;
  typedef AffineTransformerType::EulerAffineTransformType                                       EulerAffineTransformType;

  typedef itk::ProjectionGeometry< float >                                                      ProjectionGeometryType;

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

  typedef typename SingleValuedCostFunction::ParametersType       ParametersType;
  typedef typename SingleValuedCostFunction::MeasureType          MeasureType;
  typedef typename SingleValuedCostFunction::DerivativeType       DerivativeType;


  void SetInputVolume( InputVolumePointer inVolume ) { m_inVolume = inVolume; }

  void SetInputVolumeVector( VectorType &inVolumeVector ) { m_EstimatedVolumeVector = inVolumeVector; }

  void SetInputTwoProjectionVectors( VectorType &inProjectionOne, VectorType &inProjectionTwo ) 
  { m_inProjOne = inProjectionOne; m_inProjTwo = inProjectionTwo; }

  void SetInputTempProjections( InputProjectionPointer tempProjection ) { m_inProjTemp = tempProjection; }

  void SetParameterNumber( const unsigned int &paraNumber ) { m_paraNumber = paraNumber; }

  void SetParameterVector( VectorType &paraVector ) { m_TransformationParameterVector = paraVector; }

  void SetTotalVoxel( const unsigned long int &totalSize3D ) { m_totalSize3D = totalSize3D; }

  void SetTotalPixel( const unsigned long int &totalSize2D ) { m_totalSize2D = totalSize2D; }

  void SetTotalProjectionNumber( const unsigned int &projNumber ) { m_ProjectionNumber = projNumber; }

  void SetTotalProjectionSize( InputProjectionSizeType &projSize ) { m_InProjectionSize = projSize; }

  void SetProjectionGeometry( ProjectionGeometryType::Pointer pGeometry ) { m_Geometry = pGeometry; }

  void SetInputVolumeSize(InputVolumeSizeType &inVolumeSize) {m_InVolumeSize = inVolumeSize;};
  void SetInputVolumeSpacing(InputVolumeSpacingType &inVolumeSpacing) {m_InVolumeSpacing = inVolumeSpacing;};
  void SetInputVolumeOrigin(InputVolumePointType &inVolumeOrigin) {m_InVolumeOrigin = inVolumeOrigin;};

  unsigned int GetNumberOfParameters(void) const;

  void Initialise(void);

  virtual void GetValueAndDerivative( const ParametersType & parameters,
                                      MeasureType & value,
                                      DerivativeType & derivative ) const;

  virtual MeasureType GetValue( const ParametersType & parameters ) const;

  virtual void GetDerivative( const ParametersType & parameters,
                              DerivativeType & derivative ) const;


protected:

  SimultaneousUnconstrainedMatrixReconRegnMetric();
  virtual ~SimultaneousUnconstrainedMatrixReconRegnMetric() {};

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

  VectorType                                                  m_EstimatedVolumeVector;
  VectorType                                                  m_TransformationParameterVector;
  VectorType                                                  m_inProjOne, m_inProjTwo;

  MatrixProjectorPointerType                                  m_MatrixProjector;
  AffineTransformerType::Pointer                              m_AffineTransformer;

  InputVolumePointer                                          m_inVolume;
  InputProjectionPointer                                      m_inProjTemp;

  unsigned int                                                m_paraNumber;
  unsigned long int                                           m_totalSize3D;
  unsigned long int                                           m_totalSize2D;
  unsigned int                                                m_ProjectionNumber;

  InputVolumeSizeType                                         m_InVolumeSize;
  InputVolumeSpacingType                                      m_InVolumeSpacing;
  InputVolumePointType                                        m_InVolumeOrigin;

  InputProjectionSizeType                                     m_InProjectionSize;

  
  // EulerAffineTransformType::ParametersType                   m_EulerAffineParameters;
  // double*                                                    pEulerAffineParameters;

  ProjectionGeometryType::Pointer                             m_Geometry; 


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

};

} // end namespace itk

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

#endif