Commit cafaa76d authored by Marc Modat's avatar Marc Modat

LNCC has been refactored, as well as all other measures. Measures can be combined.

parent ce8fe198
This diff is collapsed.
......@@ -207,9 +207,8 @@ int main(int argc, char **argv)
// Compute the determinant
if(flag->inputCPPFlag){
if( controlPointImage->intent_code==NIFTI_INTENT_VECTOR &&
strcmp(controlPointImage->intent_name,"NREG_VEL_STEP")==0){
reg_spline_GetJacobianDetFromVelocityField(jacobianImage,
if(controlPointImage->intent_p1==SPLINE_VEL_GRID){
reg_spline_GetJacobianDetFromVelocityField(jacobianImage,
controlPointImage);
}
else{
......
......@@ -923,4 +923,4 @@ int main(int argc, char **argv)
free( param );
return 0;
}
\ No newline at end of file
}
......@@ -13,12 +13,13 @@
#ifndef _MM_RESAMPLE_CPP
#define _MM_RESAMPLE_CPP
#include <limits>
#include "_reg_ReadWriteImage.h"
#include "_reg_resampling.h"
#include "_reg_globalTransformation.h"
#include "_reg_localTransformation.h"
#include "_reg_tools.h"
#include "reg_resample.h"
typedef struct{
......@@ -340,10 +341,11 @@ int main(int argc, char **argv)
#ifndef NDEBUG
printf("[NiftyReg DEBUG] Computation of the deformation field from the CPP image\n");
#endif
if(controlPointImage->intent_code==NIFTI_INTENT_VECTOR &&
strcmp(controlPointImage->intent_name,"NREG_VEL_STEP")==0){
if(controlPointImage->intent_p1==SPLINE_VEL_GRID){
reg_spline_getDeformationFieldFromVelocityGrid(controlPointImage,
deformationFieldImage);
deformationFieldImage,
false // the number of step is not automatically updated
);
}
else{
reg_tools_multiplyValueToImage(deformationFieldImage,deformationFieldImage,0.f);
......@@ -397,12 +399,38 @@ int main(int argc, char **argv)
(size_t)resultImage->dim[3] * (size_t)resultImage->dim[4];
resultImage->data = (void *)calloc(resultImage->nvox, resultImage->nbyper);
reg_resampleImage(floatingImage,
resultImage,
deformationFieldImage,
NULL,
param->interpolation,
param->paddingValue);
if(floatingImage->dim[4]==6 || floatingImage->dim[4]==7){
#ifndef _NDEBUG
printf("[NiftyReg DEBUG] DTI-based resampling\n");
#endif
// Compute first the Jacobian matrices
mat33 *jacobian = (mat33 *)malloc(deformationFieldImage->nx *
deformationFieldImage->ny *
deformationFieldImage->nz *
sizeof(mat33));
reg_defField_getJacobianMatrix(deformationFieldImage,
jacobian);
// resample the DTI image
bool timepoints[7]; for(int i=0;i<7;++i) timepoints[i]=true;
if(floatingImage->dim[4]==7) timepoints[0]=false;
reg_resampleImage(floatingImage,
resultImage,
deformationFieldImage,
NULL,
param->interpolation,
std::numeric_limits<float>::quiet_NaN(),
timepoints,
jacobian
);
}
else{
reg_resampleImage(floatingImage,
resultImage,
deformationFieldImage,
NULL,
param->interpolation,
param->paddingValue);
}
memset(resultImage->descrip, 0, 80);
strcpy (resultImage->descrip,"Warped image using NiftyReg (reg_resample)");
reg_io_WriteImageFile(resultImage,param->outputResultName);
......
......@@ -35,7 +35,6 @@ typedef struct{
char *operationImageName;
char *rmsImageName;
float operationValue;
float smoothValue;
float smoothValueX;
float smoothValueY;
float smoothValueZ;
......@@ -47,8 +46,9 @@ typedef struct{
bool floatFlag;
bool downsampleFlag;
bool rmsImageFlag;
bool smoothValueFlag;
bool smoothSplineFlag;
bool smoothGaussianFlag;
bool smoothMeanFlag;
bool binarisedImageFlag;
bool thresholdImageFlag;
bool nanMaskFlag;
......@@ -70,9 +70,9 @@ void Usage(char *exec)
printf("\t-in <filename>\tFilename of the input image image (mandatory)\n");
printf("* * OPTIONS * *\n");
printf("\t-out <filename>\t\tFilename out the output image [output.nii]\n");
printf("\t-smo <float>\t\tThe input image is smoothed using a cubic b-spline kernel\n");
printf("\t-float\t\t\tThe input image is converted to float\n");
printf("\t-down\t\t\tThe input image is downsampled 2 times\n");
printf("\t-smoS <float> <float> <float>\tThe input image is smoothed using a cubic b-spline kernel\n");
printf("\t-smoG <float> <float> <float>\tThe input image is smoothed using Gaussian kernel\n");
printf("\t-add <filename/float>\tThis image (or value) is added to the input\n");
printf("\t-sub <filename/float>\tThis image (or value) is subtracted to the input\n");
......@@ -175,9 +175,11 @@ int main(int argc, char **argv)
else if(strcmp(argv[i], "-float") == 0){
flag->floatFlag=1;
}
else if(strcmp(argv[i], "-smo") == 0){
param->smoothValue=atof(argv[++i]);
flag->smoothValueFlag=1;
else if(strcmp(argv[i], "-smoS") == 0){
param->smoothValueX=atof(argv[++i]);
param->smoothValueY=atof(argv[++i]);
param->smoothValueZ=atof(argv[++i]);
flag->smoothSplineFlag=1;
}
else if(strcmp(argv[i], "-smoG") == 0){
param->smoothValueX=atof(argv[++i]);
......@@ -185,6 +187,12 @@ int main(int argc, char **argv)
param->smoothValueZ=atof(argv[++i]);
flag->smoothGaussianFlag=1;
}
else if(strcmp(argv[i], "-smoM") == 0){
param->smoothValueX=atof(argv[++i]);
param->smoothValueY=atof(argv[++i]);
param->smoothValueZ=atof(argv[++i]);
flag->smoothMeanFlag=1;
}
else if(strcmp(argv[i], "-bin") == 0){
flag->binarisedImageFlag=1;
}
......@@ -215,20 +223,6 @@ int main(int argc, char **argv)
//\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\//
if(flag->smoothValueFlag){
nifti_image *smoothImg = nifti_copy_nim_info(image);
smoothImg->data = (void *)malloc(smoothImg->nvox * smoothImg->nbyper);
memcpy(smoothImg->data, image->data, smoothImg->nvox*smoothImg->nbyper);
float spacing[3];spacing[0]=spacing[1]=spacing[2]=param->smoothValue;
reg_tools_CubicSplineKernelConvolution(smoothImg, spacing);
if(flag->outputImageFlag)
reg_io_WriteImageFile(smoothImg, param->outputImageName);
else reg_io_WriteImageFile(smoothImg, "output.nii");
nifti_image_free(smoothImg);
}
//\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\//
if(flag->floatFlag){
reg_tools_changeDatatype<float>(image);
if(flag->outputImageFlag)
......@@ -248,16 +242,36 @@ int main(int argc, char **argv)
//\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\//
if(flag->smoothGaussianFlag){
if(flag->smoothGaussianFlag || flag->smoothSplineFlag || flag->smoothMeanFlag){
nifti_image *smoothImg = nifti_copy_nim_info(image);
smoothImg->data = (void *)malloc(smoothImg->nvox * smoothImg->nbyper);
memcpy(smoothImg->data, image->data, smoothImg->nvox*smoothImg->nbyper);
bool boolX[8]={1,1,0,0,0,0,0,0};
reg_gaussianSmoothing(smoothImg,param->smoothValueX,boolX);
bool boolY[8]={1,0,1,0,0,0,0,0};
reg_gaussianSmoothing(smoothImg,param->smoothValueY,boolY);
bool boolZ[8]={1,0,0,1,0,0,0,0};
reg_gaussianSmoothing(smoothImg,param->smoothValueZ,boolZ);
float *kernelSize = new float[smoothImg->nt*smoothImg->nu];
bool *timePoint = new bool[smoothImg->nt*smoothImg->nu];
for(int i=0;i<smoothImg->nt*smoothImg->nu;++i) timePoint[i]=true;
bool boolX[3]={1,0,0};
for(int i=0; i<smoothImg->nt*smoothImg->nu;++i) kernelSize[i]=param->smoothValueX;
if(flag->smoothMeanFlag)
reg_tools_kernelConvolution(smoothImg,kernelSize,2,timePoint,boolX);
else if(flag->smoothSplineFlag)
reg_tools_kernelConvolution(smoothImg,kernelSize,1,timePoint,boolX);
else reg_tools_kernelConvolution(smoothImg,kernelSize,0,timePoint,boolX);
bool boolY[3]={0,1,0};
for(int i=0; i<smoothImg->nt*smoothImg->nu;++i) kernelSize[i]=param->smoothValueY;
if(flag->smoothMeanFlag)
reg_tools_kernelConvolution(smoothImg,kernelSize,2,timePoint,boolY);
else if(flag->smoothSplineFlag)
reg_tools_kernelConvolution(smoothImg,kernelSize,1,timePoint,boolY);
else reg_tools_kernelConvolution(smoothImg,kernelSize,0,timePoint,boolY);
bool boolZ[3]={0,0,1};
for(int i=0; i<smoothImg->nt*smoothImg->nu;++i) kernelSize[i]=param->smoothValueZ;
if(flag->smoothMeanFlag)
reg_tools_kernelConvolution(smoothImg,kernelSize,2,timePoint,boolZ);
else if(flag->smoothSplineFlag)
reg_tools_kernelConvolution(smoothImg,kernelSize,1,timePoint,boolZ);
else reg_tools_kernelConvolution(smoothImg,kernelSize,0,timePoint,boolZ);
delete []kernelSize;
delete []timePoint;
if(flag->outputImageFlag)
reg_io_WriteImageFile(smoothImg, param->outputImageName);
else reg_io_WriteImageFile(smoothImg, "output.nii");
......
This diff is collapsed.
......@@ -148,15 +148,12 @@ void reg_io_writePNGfile(nifti_image *image, const char *filename)
// Rescale the image intensites if they are outside of the range
if(minValue<0 || maxValue>255){
float newMinValue[1]={0};
float newMaxValue[1]={255};
float lowThrValue[1]={-std::numeric_limits<float>::max()};
float higThrValue[1]={std::numeric_limits<float>::max()};
float newMinValue=0;
float newMaxValue=255;
reg_intensityRescale(image,
0,
newMinValue,
newMaxValue,
lowThrValue,
higThrValue);
newMaxValue);
printf("[NiftyReg WARNING] reg_writePNGfile: the image intensities have been rescaled from [%g %g] to [0 255].\n",
minValue, maxValue);
}
......
......@@ -28,10 +28,11 @@ endforeach(NAME)
set(LIST _reg_globalTransformation)
set(LIST ${LIST} _reg_localTransformation)
set(LIST ${LIST} _reg_resampling)
set(LIST ${LIST} _reg_mutualinformation)
set(LIST ${LIST} _reg_nmi)
set(LIST ${LIST} _reg_ssd)
set(LIST ${LIST} _reg_KLdivergence)
set(LIST ${LIST} _reg_lncc)
set(LIST ${LIST} _reg_dti)
set(LIST ${LIST} _reg_blockMatching)
set(LIST ${LIST} _reg_femTransformation)
foreach(NAME ${LIST})
......@@ -83,7 +84,7 @@ if(USE_CUDA)
set(LIST _reg_globalTransformation)
set(LIST ${LIST} _reg_blockMatching)
set(LIST ${LIST} _reg_localTransformation)
set(LIST ${LIST} _reg_mutualinformation)
set(LIST ${LIST} _reg_nmi)
set(LIST ${LIST} _reg_ssd)
set(LIST ${LIST} _reg_resampling)
set(LIST ${LIST} _reg_tools)
......@@ -111,7 +112,7 @@ if(USE_CUDA)
else(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
cuda_add_library(${NAME} _reg_base.h _reg_base.cpp ${NAME}.h ${NAME}.cpp ${NAME}_sym.h ${NAME}_sym.cpp ${NAME}2.h ${NAME}2.cpp ${NAME}_gpu.h ${NAME}_gpu.cpp)
endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
target_link_libraries(${NAME} _reg_localTransformation _reg_resampling _reg_globalTransformation _reg_KLdivergence _reg_ssd _reg_mutualinformation _reg_lncc _reg_optimiser _reg_tools _reg_ReadWriteImage _reg_optimiser_gpu _reg_localTransformation_gpu _reg_resampling_gpu _reg_globalTransformation_gpu _reg_mutualinformation_gpu _reg_ssd_gpu _reg_tools_gpu _reg_common_gpu)
target_link_libraries(${NAME} _reg_localTransformation _reg_resampling _reg_globalTransformation _reg_KLdivergence _reg_ssd _reg_nmi _reg_dti _reg_lncc _reg_optimiser _reg_tools _reg_ReadWriteImage _reg_optimiser_gpu _reg_localTransformation_gpu _reg_resampling_gpu _reg_globalTransformation_gpu _reg_nmi_gpu _reg_ssd_gpu _reg_tools_gpu _reg_common_gpu)
install(FILES ${NAME}_gpu.h ${NAME}_gpu.cpp DESTINATION include COMPONENT Development)
#-----------------------------------------------------------------------------
else(USE_CUDA)
......@@ -121,7 +122,7 @@ else(USE_CUDA)
else(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
add_library(${NAME} _reg_base.h _reg_base.cpp ${NAME}.h ${NAME}.cpp ${NAME}2.h ${NAME}2.cpp ${NAME}_sym.h ${NAME}_sym.cpp)
endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
target_link_libraries(${NAME} _reg_localTransformation _reg_resampling _reg_globalTransformation _reg_lncc _reg_KLdivergence _reg_ssd _reg_mutualinformation _reg_optimiser _reg_tools _reg_ReadWriteImage)
target_link_libraries(${NAME} _reg_localTransformation _reg_resampling _reg_globalTransformation _reg_lncc _reg_dti _reg_KLdivergence _reg_ssd _reg_nmi _reg_optimiser _reg_tools _reg_ReadWriteImage)
#-----------------------------------------------------------------------------
endif(USE_CUDA)
#-----------------------------------------------------------------------------
......@@ -141,7 +142,7 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
else(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
add_library(${NAME} ${NAME}.h ${NAME}.cpp ${NAME}_sym.h ${NAME}_sym.cpp)
endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
target_link_libraries(${NAME} _reg_localTransformation _reg_blockMatching _reg_resampling _reg_globalTransformation _reg_ssd _reg_mutualinformation _reg_tools _reg_ReadWriteImage)
target_link_libraries(${NAME} _reg_localTransformation _reg_blockMatching _reg_resampling _reg_globalTransformation _reg_ssd _reg_nmi _reg_tools _reg_ReadWriteImage)
install(TARGETS ${NAME}
RUNTIME DESTINATION bin COMPONENT RuntimeLibraries
LIBRARY DESTINATION lib COMPONENT RuntimeLibraries
......
......@@ -229,13 +229,29 @@ void reg_aladin<T>::InitialiseRegistration()
// SMOOTH THE INPUT IMAGES IF REQUIRED
for(unsigned int l=0; l<this->LevelsToPerform; l++){
if(this->ReferenceSigma!=0.0){
bool smoothAxis[8]={false,true,true,true,false,false,false,false};
reg_gaussianSmoothing<T>(this->ReferencePyramid[l], this->ReferenceSigma, smoothAxis);
if(this->ReferenceSigma!=0.0){
// Only the first image is smoothed
bool *active = new bool[this->ReferencePyramid[l]->nt];
float *sigma = new float[this->ReferencePyramid[l]->nt];
active[0]=true;
for(int i=1;i<this->ReferencePyramid[l]->nt;++i)
active[i]=false;
sigma[0]=this->ReferenceSigma;
reg_tools_kernelConvolution(this->ReferencePyramid[l], sigma, 0, active);
delete []active;
delete []sigma;
}
if(this->FloatingSigma!=0.0){
bool smoothAxis[8]={false,true,true,true,false,false,false,false};
reg_gaussianSmoothing<T>(this->FloatingPyramid[l], this->FloatingSigma, smoothAxis);
if(this->FloatingSigma!=0.0){
// Only the first image is smoothed
bool *active = new bool[this->FloatingPyramid[l]->nt];
float *sigma = new float[this->FloatingPyramid[l]->nt];
active[0]=true;
for(int i=1;i<this->FloatingPyramid[l]->nt;++i)
active[i]=false;
sigma[0]=this->FloatingSigma;
reg_tools_kernelConvolution(this->FloatingPyramid[l], sigma, 0, active);
delete []active;
delete []sigma;
}
}
......
......@@ -18,7 +18,7 @@
#include "_reg_resampling.h"
#include "_reg_blockMatching.h"
#include "_reg_globalTransformation.h"
#include "_reg_mutualinformation.h"
#include "_reg_nmi.h"
#include "_reg_ssd.h"
#include "_reg_tools.h"
#include "float.h"
......
This diff is collapsed.
......@@ -15,7 +15,9 @@
#include "_reg_resampling.h"
#include "_reg_globalTransformation.h"
#include "_reg_localTransformation.h"
#include "_reg_mutualinformation.h"
#include "_reg_nmi.h"
#include "_reg_dti.h"
#include "_reg_measure.h"
#include "_reg_ssd.h"
#include "_reg_KLdivergence.h"
#include "_reg_lncc.h"
......@@ -29,14 +31,25 @@ template <class T>
class reg_base : public InterfaceOptimiser
{
protected:
// Optimiser related variables
reg_optimiser<T> *optimiser;
size_t maxiterationNumber;
size_t perturbationNumber;
bool optimiseX;
bool optimiseY;
bool optimiseZ;
// Optimiser related function
virtual void SetOptimiser();
// Measure related variables
reg_ssd *measure_ssd;
reg_kld *measure_kld;
reg_dti *measure_dti;
reg_lncc *measure_lncc;
reg_nmi *measure_nmi;
reg_multichannel_nmi *measure_multichannel_nmi;
char *executableName;
int referenceTimePoint;
int floatingTimePoint;
......@@ -57,9 +70,6 @@ protected:
T gradientSmoothingSigma;
T similarityWeight;
bool additive_mc_nmi;
bool useSSD;
bool useKLD;
T useLNCC;
bool useConjGradient;
bool useApproxGradient;
bool verbose;
......@@ -80,14 +90,8 @@ protected:
nifti_image *voxelBasedMeasureGradientImage;
unsigned int currentLevel;
unsigned int *referenceBinNumber;
unsigned int *floatingBinNumber;
unsigned int totalBinNumber;
double *probaJointHistogram;
double *logJointHistogram;
double entropies[4];
bool approxParzenWindow;
T *maxSSD;
mat33 *forwardJacobianMatrix;
double bestWMeasure;
double currentWMeasure;
......@@ -97,8 +101,6 @@ protected:
virtual void ClearDeformationField();
virtual void AllocateWarpedGradient();
virtual void ClearWarpedGradient();
virtual void AllocateJointHistogram();
virtual void ClearJointHistogram();
virtual void AllocateVoxelBasedMeasureGradient();
virtual void ClearVoxelBasedMeasureGradient();
virtual T InitialiseCurrentLevel(){return 0.;}
......@@ -108,6 +110,7 @@ protected:
virtual double ComputeSimilarityMeasure();
virtual void GetVoxelBasedGradient();
virtual void SmoothGradient(){return;}
virtual void InitialiseSimilarity();
// Virtual empty functions that have to be filled
virtual void GetDeformationField()
......@@ -148,11 +151,27 @@ public:
reg_base(int refTimePoint,int floTimePoint);
virtual ~reg_base();
// Optimisation related functions
void SetMaximalIterationNumber(unsigned int);
void NoOptimisationAlongX(){this->optimiseX=false;}
void NoOptimisationAlongY(){this->optimiseY=false;}
void NoOptimisationAlongZ(){this->optimiseZ=false;}
void SetPerturbationNumber(size_t v){this->perturbationNumber=v;}
void UseConjugateGradient();
void DoNotUseConjugateGradient();
void UseApproximatedGradient();
void DoNotUseApproximatedGradient();
// Measure of similarity related functions
// void ApproximateParzenWindow();
// void DoNotApproximateParzenWindow();
virtual void UseNMISetReferenceBinNumber(int,int);
virtual void UseNMISetFloatingBinNumber(int,int);
virtual void UseMultiChannelNMI(int timepointNumber, int *timepoint);
virtual void UseSSD(int timepoint);
virtual void UseKLDivergence(int timepoint);
virtual void UseDTI(bool *timepoint);
virtual void UseLNCC(int timepoint, float stdDevKernel);
void SetReferenceImage(nifti_image *);
void SetFloatingImage(nifti_image *);
void SetReferenceMask(nifti_image *);
......@@ -167,32 +186,19 @@ public:
void SetWarpedPaddingValue(T);
void SetLevelNumber(unsigned int);
void SetLevelToPerform(unsigned int);
void UseConjugateGradient();
void DoNotUseConjugateGradient();
void UseApproximatedGradient();
void DoNotUseApproximatedGradient();
void PrintOutInformation();
void DoNotPrintOutInformation();
void DoNotUsePyramidalApproach();
void UseNeareatNeighborInterpolation();
void UseLinearInterpolation();
void UseCubicSplineInterpolation();
void SetReferenceBinNumber(int, unsigned int);
void SetFloatingBinNumber(int, unsigned int);
void ApproximateParzenWindow();
void DoNotApproximateParzenWindow();
void UseSSD();
void DoNotUseSSD();
void UseKLDivergence();
void DoNotUseKLDivergence();
void UseLNCC(T);
void DoNotUseLNCC();
void SetAdditiveMC(){this->additive_mc_nmi=true;}
virtual void CheckParameters();
virtual void CheckParameters();
void Run();
virtual void Initisalise();
virtual nifti_image **GetWarpedImage(){return NULL;} // Need to be filled
virtual void Initisalise();
nifti_image **GetWarpedImage(){return NULL;} // Need to be filled
virtual char * GetExecutableName(){return this->executableName;}
virtual bool GetSymmetricStatus(){return false;}
// Function required for the NiftyReg pluggin in NiftyView
void SetProgressCallbackFunction(void (*funcProgCallback)(float pcntProgress,
......
/*
* _reg_ssd.cpp
*
*
* Created by Marc Modat on 19/05/2009.
* Copyright (c) 2009, University College London. All rights reserved.
* Centre for Medical Image Computing (CMIC)
* See the LICENSE.txt file in the nifty_reg root folder
*
*/
#include "_reg_dti.h"
/* *************************************************************** */
/* *************************************************************** */
reg_dti::reg_dti()
: reg_ssd::reg_ssd()
{
#ifndef NDEBUG
printf("[NiftyReg DEBUG] reg_dti constructor called\n");
#endif
}
/* *************************************************************** */
/* *************************************************************** */
reg_dti::~reg_dti()
{
}
/* *************************************************************** */
/* *************************************************************** */
//void reg_dti::InitialiseMeasure(nifti_image *refImgPtr,
// nifti_image *floImgPtr,
// int *maskRefPtr,
// nifti_image *warFloImgPtr,
// nifti_image *warFloGraPtr,
// nifti_image *forVoxBasedGraPtr,
// int *maskFloPtr,
// nifti_image *warRefImgPtr,
// nifti_image *warRefGraPtr,
// nifti_image *bckVoxBasedGraPtr)
//{
// // Set the pointers using the parent class function
// reg_measure::InitialiseMeasure(refImgPtr,
// floImgPtr,
// maskRefPtr,
// warFloImgPtr,
// warFloGraPtr,
// forVoxBasedGraPtr,
// maskFloPtr,
// warRefImgPtr,
// warRefGraPtr,
// bckVoxBasedGraPtr);
//}
/* *************************************************************** */
/* *************************************************************** */
template<class DTYPE>
double reg_getDTIMeasure()
{
return 0.;
}
/* *************************************************************** */
//double reg_dti::GetSimilarityMeasureValue()
//{
// return 0.;
//}
/* *************************************************************** */
/* *************************************************************** */
template <class DTYPE>
void reg_getVoxelBasedDTIMeasureGradient()
{
return;
}
/* *************************************************************** */
//void reg_dti::GetVoxelBasedSimilarityMeasureGradient()
//{
//}
/* *************************************************************** */
/* *************************************************************** */
/**
* @file _reg_ssd.h
* @brief File that contains sum squared difference related function
* @author Marc Modat
* @date 19/05/2009
*
* Created by Marc Modat on 19/05/2009.
* Copyright (c) 2009, University College London. All rights reserved.
* Centre for Medical Image Computing (CMIC)
* See the LICENSE.txt file in the nifty_reg root folder
*
*/
#ifndef _REG_DTI_H
#define _REG_DTI_H
//#include "_reg_measure.h"
#include "_reg_ssd.h" // HERE
/* \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ */
/* \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ */
/// @brief DTI related measure of similarity class
class reg_dti : public reg_ssd
{
public:
/// @brief reg_dti class constructor
reg_dti();
// /// @brief Initialise the reg_dti object
// void InitialiseMeasure(nifti_image *refImgPtr,
// nifti_image *floImgPtr,
// int *maskRefPtr,
// nifti_image *warFloImgPtr,
// nifti_image *warFloGraPtr,
// nifti_image *forVoxBasedGraPtr,
// int *maskFloPtr = NULL,
// nifti_image *warRefImgPtr = NULL,
// nifti_image *warRefGraPtr = NULL,