SlidingTransformation.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 "Supremo.h"
#include "nifti1_io.h"
#include "Transformation.h"
 
 
 
 
 
class SlidingTransformation :public Transformation
{
public:
  typedef Transformation::PrecisionType PrecisionType;
 
  SlidingTransformation( std::shared_ptr<Transformation>transformationAIn,
    std::shared_ptr<Transformation>transformationBIn,
    nifti_image* defSpaceImage, 
    unsigned int numberOfLevels, 
    unsigned int numberOfLevelsToPerform );
  
  SlidingTransformation( const SlidingTransformation& transformToCopy );
 
  ~SlidingTransformation();
  
  virtual void InitialiseLevel( unsigned int level );
  
  void SetParameters( PrecisionType* parametersIn, bool parametersAreDisplacements );
  
  virtual nifti_image* GetDeformationVectorField( nifti_image* targetImageIn );
   
  virtual SlidingTransformation::PrecisionType* GetDVFGradientWRTTransformationParameters( nifti_image* denseDVFIn );
  
  virtual SlidingTransformation::PrecisionType* GetConstraintGradientWRTTransformationParameters();
  
  double GetConstraintValue();
  
  virtual PrecisionType* GetCopyOfParameters();
  
  std::shared_ptr<Transformation> DeepCopy();
  
  void DisplayTransformationParameters();
  
  virtual PrecisionType GetSumOfPenaltyWeights();
 
  virtual PrecisionType GetMaxTransformationParameterLength( PrecisionType* parametersIn );
 
 
  std::vector<nifti_image*> GetTransformationAsImage();
 
  void SetGapOverlapConstraintWeight( double gapOverlabConstraintWeightIn );
 
  void SetSignedDistanceMapImage( nifti_image* signedDistanceMapImageIn);
 
 
private:
  
  void ClearSignedDistanceMap();
 
  void ClearTransformedSignedDistanceMaps();
  
  void AllocateTransformedSignedDistanceMaps( nifti_image* targetImage );
 
 
  double CalculateGapOverlapConstraintTerm();
 
  bool TransformedSignedDistMapsCanBeUsedForConstraintCalculations();
  
  std::shared_ptr<Transformation> transformA;   
  std::shared_ptr<Transformation> transformB;   
  
  nifti_image* signedDistMapImage;              
  
  std::shared_ptr<ImagePyramid<PrecisionType>> defSpaceImagePyramid; 
  nifti_image* curDefSpaceImage;                
 
  int lastInitialisedLevel;                     
 
  nifti_image* signedDistMapImageTransformedA;  
  nifti_image* signedDistMapImageTransformedB;  
  
  double gapOverlapConstraintWeight;            
};