Transformation.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 "nifti1_io.h"
#include <memory>
#include <vector>
 
 
template <class PrecisionType>
void interpolantCubicSpline( PrecisionType ratio, PrecisionType *basis )
{
  if (ratio < 0.0) ratio = 0.0; //reg_rounding error
  PrecisionType FF = ratio * ratio;
  basis[0] = (PrecisionType)((ratio * ((2.0 - ratio)*ratio - 1.0)) / 2.0);
  basis[1] = (PrecisionType)((FF * (3.0*ratio - 5.0) + 2.0) / 2.0);
  basis[2] = (PrecisionType)((ratio * ((4.0 - 3.0*ratio)*ratio + 1.0)) / 2.0);
  basis[3] = (PrecisionType)((ratio - 1.0) * FF / 2.0);
}
 
template <class PrecisionType>
void interpolantCubicSpline( PrecisionType ratio, PrecisionType *basis, PrecisionType *derivative )
{
  interpolantCubicSpline<PrecisionType>( ratio, basis );
  if (ratio < 0.0) ratio = 0.0; //reg_rounding error
  PrecisionType FF = ratio * ratio;
  derivative[0] = (PrecisionType)((4.0*ratio - 3.0*FF - 1.0) / 2.0);
  derivative[1] = (PrecisionType)((9.0*ratio - 10.0) * ratio / 2.0);
  derivative[2] = (PrecisionType)((8.0*ratio - 9.0*FF + 1) / 2.0);
  derivative[3] = (PrecisionType)((3.0*ratio - 2.0) * ratio / 2.0);
}
 
 
class Transformation
{
public:
  typedef float PrecisionType;
 
  virtual ~Transformation(){};
 
  virtual void InitialiseLevel(unsigned int level) = 0;
  
  virtual PrecisionType* GetCopyOfParameters() = 0;
 
  virtual unsigned int GetNumberOfParameters() { return this->numberOfParameters; };
 
  virtual void SetParameters( PrecisionType* paramsIn, bool parametersAreDisplacements ) = 0;
 
  virtual nifti_image* GetDeformationVectorField( nifti_image* targetImageIn ) = 0;
  
  virtual PrecisionType* GetDVFGradientWRTTransformationParameters( nifti_image* denseDVFIn ) = 0;
  
  virtual PrecisionType* GetConstraintGradientWRTTransformationParameters() = 0;
  
  virtual double GetConstraintValue() = 0;
  
  void TransformImage( nifti_image* sourceImage, nifti_image* warpedImage );
 
  void TransformImageAdjoint( nifti_image* sourceImage, nifti_image* sourceWeightsImage,
    nifti_image* warpedImage, nifti_image* warpedWeightsImage );
 
  virtual std::shared_ptr<Transformation> DeepCopy() = 0;
 
  virtual void DisplayTransformationParameters() = 0;
 
  virtual PrecisionType GetSumOfPenaltyWeights() = 0;
 
  virtual void GetImageGradientWRTDVF(nifti_image* sourceImage, nifti_image* outWarpedGradientImage);
 
  void ReorientateVectorImage(nifti_image* vectorFieldToReorientate, mat44 reorientationMatrix);
 
 
  virtual PrecisionType GetMaxTransformationParameterLength( PrecisionType* parametersIn ) = 0;
 
 
  virtual std::vector<nifti_image*> GetTransformationAsImage() = 0;
 
 
  inline PrecisionType GetPaddingValue() { return this->warpedPaddingValue; };
 
protected:
 
  bool CheckDVFImageUpdateRequired( nifti_image* targetImageIn );
 
 
  bool CheckImageGeometryEquality( nifti_image* img1, nifti_image* img2 );
 
 
  virtual void ClearDeformationVectorFieldImage();
 
  // Functions brought forward from reg-resp
  void CubicSplineTransformImage3D(nifti_image* sourceImage, nifti_image* warpedImage);
  void CubicSplineTransformImage2D( nifti_image* sourceImage, nifti_image* warpedImage );
  void NearestNeighbourTransformImage3D( nifti_image* sourceImage, nifti_image* warpedImage );
  void NearestNeighbourTransformImage2D( nifti_image* sourceImage, nifti_image* warpedImage );
  void TrilinearTransformImage( nifti_image* sourceImage, nifti_image* warpedImage );
  void BilinearTransformImage( nifti_image* sourceImage, nifti_image* warpedImage );
 
  void CubicSplineTransformImageAdjoint3D( nifti_image * sourceImage, nifti_image * sourceWeightsImage, nifti_image * warpedImage, nifti_image * warpedWeightsImage );
  void CubicSplineTransformImageAdjoint2D( nifti_image * sourceImage, nifti_image * sourceWeightsImage, nifti_image * warpedImage, nifti_image * warpedWeightsImage );
  void NearestNeighbourTransformImageAdjoint3D( nifti_image * sourceImage, nifti_image * sourceWeightsImage, nifti_image * warpedImage, nifti_image * warpedWeightsImage );
  void NearestNeighbourTransformImageAdjoint2D( nifti_image * sourceImage, nifti_image * sourceWeightsImage, nifti_image * warpedImage, nifti_image * warpedWeightsImage );
  void TrilinearTransformImageAdjoint( nifti_image * sourceImage, nifti_image * sourceWeightsImage, nifti_image * warpedImage, nifti_image * warpedWeightsImage );
  void BilinearTransformImageAdjoint( nifti_image * sourceImage, nifti_image * sourceWeightsImage, nifti_image * warpedImage, nifti_image * warpedWeightsImage );
 
  void TrilinearImageGradient( nifti_image* sourceImage, nifti_image* resultGradientImage );
  void BilinearImageGradient( nifti_image* sourceImage, nifti_image* resultGradientImage );
  void CubicSplineImageGradient3D( nifti_image* sourceImage, nifti_image* resultGradientImage );
  void CubicSplineImageGradient2D( nifti_image* sourceImage, nifti_image* resultGradientImage );
 
  bool dvfImageUpdateRequired;                 
  unsigned int numberOfParameters;             
  int interpolation;                           
  PrecisionType warpedPaddingValue;            
  nifti_image* deformationVectorFieldImage;    
};