itkSimultaneousUnconstrainedMatrixReconRegnMethod.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 itkSimultaneousUnconstrainedMatrixReconRegnMethod_h
#define itkSimultaneousUnconstrainedMatrixReconRegnMethod_h

#include <itkProcessObject.h>
#include <itkImage.h>
#include <itkSimultaneousUnconstrainedMatrixReconRegnMetric.h>
#include <itkSingleValuedNonLinearOptimizer.h>
#include <itkProjectionGeometry.h>
#include <itkReconstructionUpdateCommand.h>

namespace itk
{

  template <class TScalarType = double, class IntensityType = float>
    class ITK_EXPORT SimultaneousUnconstrainedMatrixReconRegnMethod : public ProcessObject 
  {
    public:
      typedef SimultaneousUnconstrainedMatrixReconRegnMethod                                Self;
      typedef ProcessObject                                                                 Superclass;
      typedef SmartPointer<Self>                                                            Pointer;
      typedef SmartPointer<const Self>                                                      ConstPointer;

      typedef itk::ReconstructionUpdateCommand                                              ReconstructionUpdateCommandType;
      typedef ReconstructionUpdateCommand::Pointer                                          ReconstructionUpdateCommandPointer;

      itkNewMacro(Self);

      itkTypeMacro(SimultaneousUnconstrainedMatrixReconRegnMethod, ProcessObject);

      // Some convenient typedefs.

      typedef vnl_vector<IntensityType>                                                     VectorType;

      typedef Image<IntensityType, 3>                                                       SimultaneousUnconstrainedReconRegnType;
      typedef typename SimultaneousUnconstrainedReconRegnType::Pointer                      SimultaneousUnconstrainedReconRegnPointer;
      typedef typename SimultaneousUnconstrainedReconRegnType::RegionType                   SimultaneousUnconstrainedReconRegnRegionType;
      typedef typename SimultaneousUnconstrainedReconRegnType::PixelType                    SimultaneousUnconstrainedReconRegnPixelType;
      typedef typename SimultaneousUnconstrainedReconRegnType::SizeType                     SimultaneousUnconstrainedReconRegnSizeType;
      typedef typename SimultaneousUnconstrainedReconRegnType::SpacingType                  SimultaneousUnconstrainedReconRegnSpacingType;
      typedef typename SimultaneousUnconstrainedReconRegnType::PointType                    SimultaneousUnconstrainedReconRegnPointType;
      typedef typename SimultaneousUnconstrainedReconRegnType::IndexType                    SimultaneousUnconstrainedReconRegnIndexType;

      typedef SingleValuedNonLinearOptimizer                                                OptimizerType;
      typedef typename OptimizerType::Pointer                                               OptimizerPointer;

      typedef SimultaneousUnconstrainedMatrixReconRegnMetric<double, float>                 MetricType;
      typedef typename MetricType::Pointer                                                  MetricPointer;

      typedef itk::ProjectionGeometry<IntensityType>                                        ProjectionGeometryType;
      typedef typename ProjectionGeometryType::Pointer                                      ProjectionGeometryPointer;

      typedef typename MetricType::ParametersType                                           ParametersType;

      typedef SimultaneousUnconstrainedReconRegnType                                        SimultaneousUnconstrainedReconRegnOutputType;
      typedef typename SimultaneousUnconstrainedReconRegnOutputType::Pointer                SimultaneousUnconstrainedReconRegnOutputPointer;
      typedef typename SimultaneousUnconstrainedReconRegnOutputType::ConstPointer           SimultaneousUnconstrainedReconRegnOutputConstPointer;

      itkSetObjectMacro( Optimizer, OptimizerType );
      itkGetObjectMacro( Optimizer, OptimizerType );

      itkSetObjectMacro( Metric, MetricType );
      itkGetObjectMacro( Metric, MetricType );

      itkSetObjectMacro( ProjectionGeometry, ProjectionGeometryType );
      itkGetObjectMacro( ProjectionGeometry, ProjectionGeometryType );

      itkSetObjectMacro( ReconstructionUpdateCommand, ReconstructionUpdateCommandType );
      itkGetObjectMacro( ReconstructionUpdateCommand, ReconstructionUpdateCommandType );

      //void SetSimultaneousUnconReconRegnEstimate( SimultaneousUnconstrainedReconRegnType *im3D);

      // void UpdateSimultaneousUnconReconRegnEstimate( SimultaneousUnconstrainedReconRegnType *im3D);
      // void UpdateSimultaneousUnconReconRegnEstimateWithAverage( SimultaneousUnconstrainedReconRegnType *im3D);
      // void UpdateInitialParameters(void);

      // bool SetInputProjectionSetOne( VectorType *im2DOne);
      // bool SetInputProjectionSetTwo( VectorType *im2DTwo);

      void SetSimultaneousUnconReconRegnVolumeSize( SimultaneousUnconstrainedReconRegnSizeType &reconRegnSize )
      { m_ReconRegnVolumeSize = reconRegnSize; };
      void SetSimultaneousUnconReconRegnVolumeSpacing( SimultaneousUnconstrainedReconRegnSpacingType &reconRegnSpacing ) 
      {m_ReconRegnVolumeSpacing = reconRegnSpacing;};
      void SetSimultaneousUnconReconRegnVolumeOrigin( SimultaneousUnconstrainedReconRegnPointType &reconRegnOrigin ) 
      {m_ReconRegnVolumeOrigin = reconRegnOrigin;};

      virtual void Initialise() throw (ExceptionObject);

      // VectorType *GetInputOne();
      // VectorType *GetInputTwo();
      SimultaneousUnconstrainedReconRegnOutputType *GetOutput();

      SimultaneousUnconstrainedReconRegnOutputType *GetReconstructedVolume() const;

      virtual DataObjectPointer MakeOutput(unsigned long int idx);

      unsigned long GetMTime() const;  

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

      virtual void GenerateOutputInformation() {};

      void StartSimultaneousUnconReconRegn(void);

      void StartOptimization(void);

      void GenerateData ();


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

      bool                                                            m_FlagInitialised;

      OptimizerPointer                                                m_Optimizer;
      MetricPointer                                                   m_Metric;
      ProjectionGeometryPointer                                       m_ProjectionGeometry;

      // VectorType*                                                  m_ProjectionImageSetOne;
      // VectorType*                                                  m_ProjectionImageSetTwo;
      SimultaneousUnconstrainedReconRegnPointer                       m_VolumeEstimate;

      ParametersType                                                  m_InitialParameters;
      ParametersType                                                  m_LastParameters;

      SimultaneousUnconstrainedReconRegnSizeType                      m_ReconRegnVolumeSize;
      SimultaneousUnconstrainedReconRegnSpacingType                   m_ReconRegnVolumeSpacing;
      SimultaneousUnconstrainedReconRegnPointType                     m_ReconRegnVolumeOrigin;

      ReconstructionUpdateCommandPointer                              m_ReconstructionUpdateCommand;

  };


} // end namespace itk

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

#endif