Supremo.h

// ====================================================================================================   
//                                                                                                        
//   SuPReMo: Surrogate Parameterised Respiratory Motion Model                                            
//            An implementation of the generalised motion modelling and image registration framework      
//                                                                                                        
//   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.                                              
//                                                                                                        
// ====================================================================================================   
 
 
 
 
#pragma once
 
#include <memory>
#include <iostream>
#include "nifti1_io.h"
#include "ImagePyramid.h"
#include "ImageSimilarity.h"
#include "SSDImageSimilarity.h"
#include "CorrespondenceModel.h"
#include "Transformation.h"
#include "BSplineTransformation.h"
#include "SlidingTransformation.h"
#include "MoCoRecon.h"
#include "ObjectiveFunction.h"
#include "Optimiser.h"
#include "ConjugateGradientOptimiser.h"
#include "ImageAcquisition.h"
#include "NoImageAcquisition.h"
#include "LowResolutionImageAcquisition.h"
 
 
// Forward declaration
class CorrespondenceModel;
 
inline void supremo_exit(int Val, const char* fileName, int lineNumber)
{
  fprintf(stderr, "[Supremo] Exit here. File: %s:%i\n", fileName, lineNumber);
  exit(Val);
};
 
inline void supremo_print_debug(const char* message){ printf("[Supremo DEBUG] Message: %s\n", message); };
inline void supremo_print_warning(const char* message){ printf("[Supremo WARNING] Message: %s\n", message); };
inline void supremo_print_error(const char* message){ fprintf(stderr, "[Supremo ERROR] Message: %s\n", message); };
 
 
 
class Supremo
{
public:
  typedef float VoxelType;
  
  Supremo();
 
  ~Supremo();
 
  void FitMotionModelAndReconstruct();
 
 
  void SetDynamicImages(nifti_image** dynamicImagesIn, int numberOfDynamicImagesIn);
 
 
  void SetReferenceStateImage(nifti_image* referenceStateImageIn);
 
 
  void SetSurrogateSignals( float* surrogateSignalsIn, int numberOfSurrogateSignalsIn );
 
 
  void SetDefSpaceImage( nifti_image* defSpaceImageIn );
 
 
  void SetImageAcquisition( std::shared_ptr<ImageAcquisition> imageAcquisitionIn );
 
 
  void SetMotionCompensatedReconstruction( std::shared_ptr<MoCoRecon> mocoReconstructionIn );
 
  void SetInterMCROutputFolder( const std::string& outputFolder );
 
  void SetInterGradOutputFolder( const std::string& outputFolder );
 
  void SetTransformationType( t_transformationType transformationTypeIn );
 
  void SetSlidingTrafoDistanceMap( nifti_image* slidingTrafoDistanceMapIn );
 
 
  void SetSlidingGapOverlapConstraintWeight( float gapOverlapConstraintWeightIn );
 
 
  void SetBSplineCPGSpacing( float sx, float sy, float sz );
 
  void SetBSplineBendingEnergy( float be );
 
  void SetBSplineLinearEnergy( float le );
 
  inline void SetNumberOfPyramidLevels( unsigned int numberOfLevelsIn )
  {
    this->numberOfLevels = numberOfLevelsIn;
  }
 
  inline void SetNumberOfPyramidLevelsToPerform( unsigned int numberOfLevelsToPerformIn )
  {
    this->numberOfLevelsToPerform = numberOfLevelsToPerformIn;
  }
 
  inline void SetMaxModelFittingIterationNumber( unsigned int maxModelFittingIterations )
  {
    this->maxModelFitIterationNumber = maxModelFittingIterations;
  }
 
 
  inline void SetMaxSwitchIterationNumber( unsigned int maxSwitchIterations )
  {
    this->maxSwitchIterationNumber = maxSwitchIterations;
  }
 
  inline void SetInputRCMImages(const std::vector<nifti_image*>& inputRCMImgs)
  {
    this->inputRCMImages = inputRCMImgs;
  };
 
 
 
  std::vector<nifti_image*> GetCorrespondenceModelAsImage();
 
 
  nifti_image* GetMotionCompensatedReconstructedImage() { return this->finalMoCoReconImage; }
 
  
  std::vector<nifti_image*> SimulateDynamicImages();
 
 
  std::vector<nifti_image*> GenerateDVFsFromCorrespondenceModel();
 
 
private:
  void Initialise(); 
 
 
  void CheckParameters();
 
  void DisplayCurrentLevelParameters( unsigned int level );
 
 
  void SaveInterMCRToImage(nifti_image* mcrImage);
 
  unsigned int numberOfSurrogateSignals;          
  unsigned int numberOfDynamicImages;             
  
  nifti_image ** allDynamicImages;                
  nifti_image * referenceStateImage;              
  nifti_image * finalMoCoReconImage;              
  
  std::vector<std::vector<float> > surrogateSignals; 
  
  nifti_image* defSpaceImage;                     
    
  std::vector<nifti_image*> inputRCMImages;       
 
  unsigned int maxSwitchIterationNumber;          
  unsigned int maxModelFitIterationNumber;        
 
  unsigned int numberOfLevels;                    
  unsigned int numberOfLevelsToPerform;           
  unsigned int currentLevel;                      
 
  t_transformationType transformationType;        
 
  float bSplineCPGSpacing[3];                     
  float bSplineBendingEnergyWeight;               
  float bSplineLinearEnergyWeight;                
 
  nifti_image* slidingSignedDistanceMapImage;     
  float slidingGapOverlapConstraintWeight;        
 
  std::string outputInterMCRFolder;               
  std::string outputInterGradientFolder;          
 
  bool initialised;                               
 
  // Image pyramids
  std::shared_ptr<ImagePyramid<VoxelType> > referenceStatePyramid;            
  std::vector<std::shared_ptr<ImagePyramid<VoxelType> > > allDynamicPyramids; 
 
  // Temporary image pointers
  nifti_image* currentReferenceStateImage;
 
  std::shared_ptr<Transformation> transform;                  
  std::shared_ptr<CorrespondenceModel> correspondenceModel;   
  std::shared_ptr<ImageSimilarity> similarityMeasure;         
  std::shared_ptr<ImageAcquisition> imageAcquisition;         
  std::shared_ptr<MoCoRecon> mocoReconstructor;               
 
  std::string levelID;                                        
};