itkIterativeReconstructionAndRegistrationMethod.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 itkIterativeReconstructionAndRegistrationMethod_h
#define itkIterativeReconstructionAndRegistrationMethod_h

#include <itkProcessObject.h>
#include "itkImageReconstructionMethod.h"
#include <itkImageRegistrationFilter.h>
#include <itkDataObjectDecorator.h>
#include <itkReconstructionAndRegistrationUpdateCommand.h>


namespace itk
{

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

  typedef itk::ReconstructionAndRegistrationUpdateCommand     ReconstructionAndRegistrationUpdateCommandType;
  typedef ReconstructionAndRegistrationUpdateCommand::Pointer ReconstructionAndRegistrationUpdateCommandPointer;
  
  itkNewMacro(Self);
  
  itkTypeMacro(IterativeReconstructionAndRegistrationMethod, ProcessObject);


  typedef itk::ImageReconstructionMethod<IntensityType> ImageReconstructionMethodType;

  typedef typename ImageReconstructionMethodType::Pointer                   ImageReconstructionMethodPointer;
  typedef typename ImageReconstructionMethodType::InputProjectionVolumeType InputProjectionVolumeType;
  typedef typename ImageReconstructionMethodType::ReconstructionType        ReconstructionType;

  typedef typename ReconstructionType::RegionType  ReconstructionRegionType;
  typedef typename ReconstructionType::SizeType    ReconstructionSizeType;
  typedef typename ReconstructionType::IndexType   ReconstructionIndexType;
  typedef typename ReconstructionType::SpacingType ReconstructionSpacingType;
  typedef typename ReconstructionType::PointType   ReconstructionPointType;
  typedef typename ReconstructionType::Pointer     ReconstructionPointer;

  typedef typename ImageReconstructionMethodType::OptimizerType          ReconstructionOptimizerType;
  typedef typename ReconstructionOptimizerType::Pointer                  ReconstructionOptimizerPointer;

  typedef typename ImageReconstructionMethodType::MetricType             ReconstructionMetricType;
  typedef typename ReconstructionMetricType::Pointer                     ReconstructionMetricPointer;

  typedef typename ImageReconstructionMethodType::ProjectionGeometryType ProjectionGeometryType;
  typedef typename ProjectionGeometryType::Pointer                       ProjectionGeometryPointer;

  
  typedef itk::ImageRegistrationFilter<ReconstructionType, ReconstructionType, 3, double, float>  RegistrationFilterType;  

  typedef typename RegistrationFilterType::Pointer       ImageRegistrationFilterPointer;
  typedef typename RegistrationFilterType::TransformType TransformType;


  typedef ReconstructionType                                              ReconstructionAndRegistrationOutputType;
  typedef typename ReconstructionAndRegistrationOutputType::Pointer       ReconstructionAndRegistrationOutputPointer;
  typedef typename ReconstructionAndRegistrationOutputType::ConstPointer  ReconstructionAndRegistrationOutputConstPointer;
  
  typedef  DataObjectDecorator< TransformType >    TransformOutputType;
  typedef typename TransformOutputType::Pointer    TransformOutputPointer;
  typedef typename TransformOutputType::ConstPointer    TransformOutputConstPointer;
  
  itkSetObjectMacro( RegistrationFilter, RegistrationFilterType );
  itkGetObjectMacro( RegistrationFilter, RegistrationFilterType );

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

  itkSetObjectMacro( ReconstructionAndRegistrationUpdateCommand, ReconstructionAndRegistrationUpdateCommandType );
  itkGetObjectMacro( ReconstructionAndRegistrationUpdateCommand, ReconstructionAndRegistrationUpdateCommandType );

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

  void SetFixedReconEstimate( ReconstructionType *im3D);
  void SetMovingReconEstimate( ReconstructionType *im3D);

  void SetReconstructedVolumeSize(ReconstructionSizeType &reconSize);
  void SetReconstructedVolumeSpacing(ReconstructionSpacingType &reconSpacing);
  void SetReconstructedVolumeOrigin(ReconstructionPointType &reconOrigin);

  void SetProjectionGeometry(ProjectionGeometryType *geometry) {
    m_FixedImageReconstructor->SetProjectionGeometry(geometry);
    m_MovingImageReconstructor->SetProjectionGeometry(geometry);
    this->Modified();
  }

  void SetFixedReconstructionMetric(ReconstructionMetricType *metric) {
    m_FixedImageReconstructor->SetMetric(metric);
    this->Modified();
  }
  void SetMovingReconstructionMetric(ReconstructionMetricType *metric) {
    m_MovingImageReconstructor->SetMetric(metric);
    this->Modified();
  }

  void SetFixedReconstructionOptimizer(ReconstructionOptimizerType *optimizer) {
    m_FixedImageReconstructor->SetOptimizer(optimizer);
    this->Modified();
  }
  void SetMovingReconstructionOptimizer(ReconstructionOptimizerType *optimizer) {
    m_MovingImageReconstructor->SetOptimizer(optimizer);
    this->Modified();
  }

  void SetNumberOfReconRegnIterations(unsigned int n) {
    m_NumberOfReconRegnIterations = n;
    this->Modified();
  }
  void GetNumberOfReconRegnIterations(void) {
    return m_NumberOfReconRegnIterations;
  }

  virtual void Initialise() throw (ExceptionObject);

  const ReconstructionType* GetReconOutput(unsigned int output) const;
  const ReconstructionType* GetFixedReconOutput(void) const {return GetReconOutput(0);}
  const ReconstructionType* GetMovingReconOutput(void) const {return GetReconOutput(1);}

  const TransformType* GetTransformationOutput(void) const;

  const ReconstructionAndRegistrationOutputType *GetReconstructedVolume() const;

  void GraftNthOutput(unsigned int idx, const itk::DataObject *graft);

  unsigned long GetMTime() const;  
    
protected:
  IterativeReconstructionAndRegistrationMethod();
  virtual ~IterativeReconstructionAndRegistrationMethod() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

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

  void StartOptimization(void);

  void  GenerateData ();


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

  bool m_FlagInitialised;

  /* 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;

  // Pointers to the source and target reconstructors
  ImageReconstructionMethodPointer m_FixedImageReconstructor;
  ImageReconstructionMethodPointer m_MovingImageReconstructor;

  // Pointer to the registration filter
  ImageRegistrationFilterPointer m_RegistrationFilter;

  ReconstructionAndRegistrationUpdateCommandPointer m_ReconstructionAndRegistrationUpdateCommand;

};


} // end namespace itk

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

#endif