itkMatrixBasedSimulReconRegnMetric.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 itkMatrixBasedSimulReconRegnMetric_h
#define itkMatrixBasedSimulReconRegnMetric_h

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

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


namespace itk
{
  
template <class IntensityType = double>
class ITK_EXPORT MatrixBasedSimulReconRegnMetric : public SingleValuedCostFunction
{
public:

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

  itkNewMacro(Self);

  itkTypeMacro(MatrixBasedSimulReconRegnMetric, SingleValuedCostFunction);

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

  typedef itk::ForwardAndBackwardProjectionMatrix< double, double >     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 typename AffineTransformerType::Pointer                       AffineTransformerPointer;
  typedef typename EulerAffineTransformType::Pointer                    EulerAffineTransformPointer;

  typedef itk::ProjectionGeometry< double >                             ProjectionGeometryType;

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

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

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

  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 SetEulerTransform( EulerAffineTransformPointer inEuler ) { m_EulerAffineTransform = inEuler; }

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

  void SetEulerTransformFDMLambda( double &lambdaVal ) { m_lambdaVal = lambdaVal; }
  void SetEulerTransformFDMDifference( double &diffFDMVal ) { m_FDMDiff = diffFDMVal; }
  void SetEulerTransformFDMDifferenceEpsilon( double &epsilonVal ) { m_epsilonVal = epsilonVal; }


  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;

#if 0
  const InputVolumeType *GetReconstructedVolume(void) {
    return m_FwdAndBackProjDiffFilter->GetPointerToInputVolume();
  }

  void SetParametersAddress( const ParametersType & parameters ) const;
  void SetDerivativesAddress( const DerivativeType & derivatives ) const;

  void SetParameters( const ParametersType & parameters ) const;

  void SetIterativeReconEstimateFile( std::string filename ) {
    fileOutputCurrentEstimate = filename;
  }

  void SetIterativeReconEstimateSuffix( std::string suffix ) {
    suffixOutputCurrentEstimate = suffix;
  }
#endif

  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:

  MatrixBasedSimulReconRegnMetric();
  virtual ~MatrixBasedSimulReconRegnMetric() {};

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

#if 0

  std::string fileOutputCurrentEstimate;
  std::string suffixOutputCurrentEstimate;
#endif

  VectorType                                                  m_EstimatedVolumeVector;
  VectorType                                                  m_TransformationParameterVector;
  VectorType                                                  m_inProjOne, m_inProjTwo;

  MatrixProjectorPointerType                                  m_MatrixProjector;
  AffineTransformerPointer                                    m_AffineTransformer;
  EulerAffineTransformPointer                                 m_EulerAffineTransform;

  InputVolumePointer                                          m_inVolume;
  InputProjectionPointer                                      m_inProjTemp;

  unsigned int                                                m_paraNumber;
  unsigned long int                                           m_totalSize3D;
  unsigned long int                                           m_totalSize2D;
  unsigned int                                                m_ProjectionNumber;
  double                                                      m_lambdaVal;
  double                                                      m_FDMDiff;
  double                                                      m_epsilonVal;

  InputVolumeSizeType                                         m_InVolumeSize;
  InputVolumeSpacingType                                      m_InVolumeSpacing;
  InputVolumePointType                                        m_InVolumeOrigin;

  InputProjectionSizeType                                     m_InProjectionSize;

  ProjectionGeometryType::Pointer                             m_Geometry; 


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

} // end namespace itk

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

#endif