BSplineTransformation.h

// ====================================================================================================   
//                                                                                                        
//   niftyMoMo: 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 "_reg_localTrans.h"
#include "_reg_resampling.h"
#include "nifti1_io.h"
#include "Transformation.h"

namespace NiftyMoMo {

template<class DTYPE>
inline void get_BSplineBasisValues( DTYPE basis, DTYPE *values )
{
  DTYPE FF = basis*basis;
  DTYPE FFF = FF*basis;
  DTYPE MF = static_cast<DTYPE>(1.0 - basis);
  values[0] = static_cast<DTYPE>((MF) *(MF) *(MF) / (6.0));
  values[1] = static_cast<DTYPE>((3.0*FFF - 6.0*FF + 4.0) / 6.0);
  values[2] = static_cast<DTYPE>((-3.0*FFF + 3.0*FF + 3.0*basis + 1.0) / 6.0);
  values[3] = static_cast<DTYPE>(FFF / 6.0);
}


class BSplineTransformation :public Transformation
{
public:
  typedef Transformation::PrecisionType PrecisionType;

  BSplineTransformation( nifti_image* referenceImageIn, 
                         unsigned int numberOfLevelsToPerform, 
                         float* finalControlPointGridSpacing );
  
  BSplineTransformation( const BSplineTransformation& transformToCopy );


  ~BSplineTransformation();
  
  virtual void InitialiseLevel( unsigned int level );
  
  void SetParameters( PrecisionType* paramsIn, bool parametersAreDisplacements );
  
  virtual nifti_image* GetDeformationVectorField(const nifti_image * const targetImageIn );
   
  virtual BSplineTransformation::PrecisionType* GetDVFGradientWRTTransformationParameters( nifti_image* denseDVFIn );
  
  virtual BSplineTransformation::PrecisionType* GetConstraintGradientWRTTransformationParameters();
  
  double GetConstraintValue();
  
  virtual PrecisionType* GetParameters();
  
  virtual unsigned int GetNumberOfParameters();
  
  void SetLinearEnergyWeight( double linearEnergyWeightIn );
  
  void SetBendingEnergyWeight( double bendingEnergyWeightIn );
  
  std::shared_ptr<Transformation> DeepCopy();
  
  void DisplayTransformationParameters();
  
  virtual PrecisionType GetSumOfPenaltyWeights();

  virtual PrecisionType GetMaxTransformationParameterLength( PrecisionType* parametersIn );


  nifti_image* GetTransformationAsImage();

protected:

  void CPGToDVF2D( nifti_image *denseVectorFieldImage );

  void CPGToDVF3D( nifti_image *denseVectorFieldImage );

  void DVFToCPG2D( nifti_image *controlPointGridImage,
                   nifti_image *denseVectorFieldImage,
                   bool normaliseKernel );
  
  void DVFToCPG3D( nifti_image *controlPointGridImage,
                   nifti_image *denseVectorFieldImage,
                   bool normaliseKernel );


  // *  Vectors which are stored along the 5th (u) dimension will be reoriented
  // *  \param vectorFieldToReorientate Vector image to be reorientated
  // *  \param reorientationMatrix 4 x 4 Matrix used to reorientate vectors
  // */
  //void ReorientateVectorImage( nifti_image* vectorFieldToReorientate, mat44 reorientationMatrix );

  nifti_image* controlPointGridImage;          
  double bendingEnergyWeight;                  
  double linearEnergyWeight;                   

private:
  int lastInitialisedLevel;                    
};

}