itkSimultaneousReconstructionAndRegistrationMethod.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 itkSimultaneousReconstructionAndRegistrationMethod_h
#define itkSimultaneousReconstructionAndRegistrationMethod_h

#include <itkProcessObject.h>
#include <itkImage.h>
#include <itkSimultaneousReconstructionRegistrationMetric.h>
#include <itkSingleValuedNonLinearOptimizer.h>
#include <itkProjectionGeometry.h>
#include <itkSimultaneousReconAndRegnUpdateCommand.h>


namespace itk
{

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

  typedef itk::SimultaneousReconAndRegnUpdateCommand     SimultaneousReconAndRegnUpdateCommandType;
  typedef SimultaneousReconAndRegnUpdateCommand::Pointer SimultaneousReconAndRegnUpdateCommandPointer;
  
  itkNewMacro(Self);
  
  itkTypeMacro(SimultaneousReconstructionAndRegistrationMethod, ProcessObject);

  // Some convenient typedefs.

  typedef Image<IntensityType, 3>                         InputProjectionVolumeType;
  typedef typename InputProjectionVolumeType::Pointer     InputProjectionVolumePointer;
  typedef typename InputProjectionVolumeType::RegionType  InputProjectionVolumeRegionType;
  typedef typename InputProjectionVolumeType::PixelType   InputProjectionVolumePixelType;
  typedef typename InputProjectionVolumeType::SizeType    InputProjectionVolumeSizeType;
  typedef typename InputProjectionVolumeType::SpacingType InputProjectionVolumeSpacingType;
  typedef typename InputProjectionVolumeType::PointType   InputProjectionVolumePointType;

  typedef Image<IntensityType, 3>                   ReconstructionType;
  typedef typename ReconstructionType::Pointer      ReconstructionPointer;
  typedef typename ReconstructionType::RegionType   ReconstructionRegionType;
  typedef typename ReconstructionType::PixelType    ReconstructionPixelType;
  typedef typename ReconstructionType::SizeType     ReconstructionSizeType;
  typedef typename ReconstructionType::SpacingType  ReconstructionSpacingType;
  typedef typename ReconstructionType::PointType    ReconstructionPointType;
  typedef typename ReconstructionType::IndexType    ReconstructionIndexType;

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

  typedef SimultaneousReconstructionRegistrationMetric<IntensityType> MetricType;
  typedef typename MetricType::Pointer                                MetricPointer;

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

  typedef typename MetricType::ParametersType    ParametersType;

  typedef ReconstructionType                               ReconstructionOutputType;
  typedef typename ReconstructionOutputType::Pointer       ReconstructionOutputPointer;
  typedef typename ReconstructionOutputType::ConstPointer  ReconstructionOutputConstPointer;
  
  itkSetObjectMacro( Optimizer,  OptimizerType );
  itkGetObjectMacro( Optimizer,  OptimizerType );

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

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

  itkSetObjectMacro( SimultaneousReconAndRegnUpdateCommand, SimultaneousReconAndRegnUpdateCommandType );
  itkGetObjectMacro( SimultaneousReconAndRegnUpdateCommand, SimultaneousReconAndRegnUpdateCommandType );

  void SetReconEstimate( ReconstructionType *im3D);

  void UpdateReconstructionEstimate( ReconstructionType *im3D);
  void UpdateReconstructionEstimateWithAverage( ReconstructionType *im3D);
  void UpdateInitialParameters(void);

  bool SetInputFixedImageProjections( InputProjectionVolumeType *imFixedProjections);
  bool SetInputMovingImageProjections( InputProjectionVolumeType *imMovingProjections);

  void SetReconstructedVolumeSize(ReconstructionSizeType &reconSize) {m_ReconstructedVolumeSize = reconSize;};
  void SetReconstructedVolumeSpacing(ReconstructionSpacingType &reconSpacing) {m_ReconstructedVolumeSpacing = reconSpacing;};
  void SetReconstructedVolumeOrigin(ReconstructionPointType &reconOrigin) {m_ReconstructedVolumeOrigin = reconOrigin;};

  virtual void Initialise() throw (ExceptionObject);

  InputProjectionVolumeType *GetInput();
  ReconstructionOutputType *GetOutput();

  ReconstructionOutputType *GetReconstructedVolume() const;

  virtual DataObjectPointer MakeOutput(unsigned int idx);

  unsigned long GetMTime() const;  

  void SetFlagUpdateReconEstimateWithAverage( bool flag) {m_FlagUpdateReconEstimateWithAverage = flag; this->Modified();}
  bool GetFlagUpdateReconEstimateWithAverage( void ) {return m_FlagUpdateReconEstimateWithAverage;}

  void SetNumberOfReconRegnIterations(unsigned int n) {
    m_NumberOfReconRegnIterations = n;
    this->Modified();
  }
  void GetNumberOfReconRegnIterations(void) {
    return m_NumberOfReconRegnIterations;
  }
    
protected:
  SimultaneousReconstructionAndRegistrationMethod();
  virtual ~SimultaneousReconstructionAndRegistrationMethod() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual void GenerateOutputInformation() {};
  
  void StartReconstruction(void);

  void StartOptimization(void);

  void  GenerateData ();


private:
  SimultaneousReconstructionAndRegistrationMethod(const Self&); // purposely not implemented
  void operator=(const Self&);            // purposely not implemented
  
  bool                             m_FlagInitialised;

  OptimizerPointer                 m_Optimizer;
  MetricPointer                    m_Metric;
  ProjectionGeometryPointer        m_ProjectionGeometry;

  InputProjectionVolumePointer     m_ProjectionImagesFixed;
  InputProjectionVolumePointer     m_ProjectionImagesMoving;
  ReconstructionPointer            m_EnhancedAsOneReconstructor;

  ParametersType                   m_InitialParameters;
  ParametersType                   m_LastParameters;
    
  ReconstructionSizeType           m_ReconstructedVolumeSize;
  ReconstructionSpacingType        m_ReconstructedVolumeSpacing;
  ReconstructionPointType          m_ReconstructedVolumeOrigin;

  /* Flag indicating whether to update the 3D reconstruction estimate volume with the average of
      the existing estimate and the supplied volume. */
  bool m_FlagUpdateReconEstimateWithAverage;

  // The number of combined registration-reconstruction iterations to perform
  unsigned int m_NumberOfReconRegnIterations;

  SimultaneousReconAndRegnUpdateCommandPointer m_SimultaneousReconAndRegnUpdateCommand;

};


} // end namespace itk

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

#endif