int main(int argc, char ** argv)
{
//-----------------------
// Input pointers
float *h_fMRI_Volumes = NULL;
float *h_Certainty = NULL;
//--------------
void* allMemoryPointers[500];
for (int i = 0; i < 500; i++)
{
allMemoryPointers[i] = NULL;
}
nifti_image* allNiftiImages[500];
for (int i = 0; i < 500; i++)
{
allNiftiImages[i] = NULL;
}
int numberOfMemoryPointers = 0;
int numberOfNiftiImages = 0;
size_t allocatedHostMemory = 0;
//--------------
// Default parameters
int OPENCL_PLATFORM = 0;
int OPENCL_DEVICE = 0;
bool DEBUG = false;
const char* FILENAME_EXTENSION = "_sm";
bool PRINT = true;
bool VERBOS = false;
size_t DATA_W, DATA_H, DATA_D, DATA_T;
float EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z;
bool CHANGE_OUTPUT_FILENAME = false;
// Settings
float EPI_SMOOTHING_AMOUNT = 6.0f;
bool MASK = false;
bool AUTO_MASK = false;
const char* MASK_NAME;
//-----------------------
// Output parameters
const char *outputFilename;
//---------------------
/* Input arguments */
FILE *fp = NULL;
// No inputs, so print help text
if (argc == 1)
{
printf("Usage:\n\n");
printf("Smoothing input.nii [options]\n\n");
printf("Options:\n\n");
printf(" -platform The OpenCL platform to use (default 0) \n");
printf(" -device The OpenCL device to use for the specificed platform (default 0) \n");
printf(" -fwhm Amount of smoothing to apply (in mm, default 6 mm) \n");
printf(" -mask Perform smoothing inside mask (normalized convolution) \n");
printf(" -automask Generate a mask and perform smoothing inside mask (normalized convolution) \n");
printf(" -output Set output filename (default input_sm.nii) \n");
printf(" -quiet Don't print anything to the terminal (default false) \n");
printf(" -verbose Print extra stuff (default false) \n");
printf("\n\n");
return EXIT_SUCCESS;
}
// Try to open file
else if (argc > 1)
{
fp = fopen(argv[1],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[1]);
return EXIT_FAILURE;
}
fclose(fp);
}
// Loop over additional inputs
int i = 2;
while (i < argc)
{
char *input = argv[i];
char *p;
if (strcmp(input,"-platform") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -platform !\n");
return EXIT_FAILURE;
}
OPENCL_PLATFORM = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("OpenCL platform must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (OPENCL_PLATFORM < 0)
{
printf("OpenCL platform must be >= 0!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-device") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -device !\n");
return EXIT_FAILURE;
}
OPENCL_DEVICE = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("OpenCL device must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (OPENCL_DEVICE < 0)
{
printf("OpenCL device must be >= 0!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-fwhm") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -fwhm !\n");
return EXIT_FAILURE;
}
EPI_SMOOTHING_AMOUNT = (float)strtod(argv[i+1], &p);
if (!isspace(*p) && *p != 0)
{
printf("Smoothing must be a float! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if ( EPI_SMOOTHING_AMOUNT <= 0.0f )
{
printf("Smoothing must be > 0.0 !\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-mask") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read name after -mask !\n");
return EXIT_FAILURE;
}
MASK = true;
MASK_NAME = argv[i+1];
i += 2;
}
else if (strcmp(input,"-automask") == 0)
{
AUTO_MASK = true;
i += 1;
}
else if (strcmp(input,"-debug") == 0)
{
DEBUG = true;
i += 1;
}
else if (strcmp(input,"-quiet") == 0)
{
PRINT = false;
i += 1;
}
else if (strcmp(input,"-verbose") == 0)
{
VERBOS = true;
i += 1;
}
else if (strcmp(input,"-output") == 0)
{
CHANGE_OUTPUT_FILENAME = true;
if ( (i+1) >= argc )
{
printf("Unable to read name after -output !\n");
return EXIT_FAILURE;
}
outputFilename = argv[i+1];
i += 2;
}
else
{
printf("Unrecognized option! %s \n",argv[i]);
return EXIT_FAILURE;
}
}
// Check if BROCCOLI_DIR variable is set
if (getenv("BROCCOLI_DIR") == NULL)
{
printf("The environment variable BROCCOLI_DIR is not set!\n");
return EXIT_FAILURE;
}
double startTime = GetWallTime();
// ---------------------
// Read data
// ---------------------
nifti_image *inputData = nifti_image_read(argv[1],1);
if (inputData == NULL)
{
printf("Could not open nifti file!\n");
return EXIT_FAILURE;
}
allNiftiImages[numberOfNiftiImages] = inputData;
numberOfNiftiImages++;
// -----------------------
// Read mask
// -----------------------
nifti_image *inputMask;
if (MASK)
{
inputMask = nifti_image_read(MASK_NAME,1);
if (inputMask == NULL)
{
printf("Could not open mask volume!\n");
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
allNiftiImages[numberOfNiftiImages] = inputMask;
numberOfNiftiImages++;
}
double endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to read the nifti file\n",(float)(endTime - startTime));
}
// Get data dimensions
DATA_W = inputData->nx;
DATA_H = inputData->ny;
DATA_D = inputData->nz;
DATA_T = inputData->nt;
// Check if mask volume has the same dimensions as the data
if (MASK)
{
size_t TEMP_DATA_W = inputMask->nx;
size_t TEMP_DATA_H = inputMask->ny;
size_t TEMP_DATA_D = inputMask->nz;
if ( (TEMP_DATA_W != DATA_W) || (TEMP_DATA_H != DATA_H) || (TEMP_DATA_D != DATA_D) )
{
printf("Input data has the dimensions %zu x %zu x %zu, while the mask volume has the dimensions %zu x %zu x %zu. Aborting! \n",DATA_W,DATA_H,DATA_D,TEMP_DATA_W,TEMP_DATA_H,TEMP_DATA_D);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
}
// Get voxel sizes
EPI_VOXEL_SIZE_X = inputData->dx;
EPI_VOXEL_SIZE_Y = inputData->dy;
EPI_VOXEL_SIZE_Z = inputData->dz;
// Calculate size, in bytes
size_t DATA_SIZE = DATA_W * DATA_H * DATA_D * DATA_T * sizeof(float);
size_t VOLUME_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
// Print some info
if (PRINT)
{
printf("Authored by K.A. Eklund \n");
printf("Data size: %zu x %zu x %zu x %zu \n", DATA_W, DATA_H, DATA_D, DATA_T);
printf("Voxel size: %f x %f x %f mm \n", EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z);
printf("Smoothing filter size: %f mm \n", EPI_SMOOTHING_AMOUNT);
}
// ------------------------------------------------
// Allocate memory on the host
startTime = GetWallTime();
// If the data is in float format, we can just copy the pointer
if ( inputData->datatype != DT_FLOAT )
{
AllocateMemory(h_fMRI_Volumes, DATA_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, allocatedHostMemory, "INPUT_DATA");
}
else
{
allocatedHostMemory += DATA_SIZE;
}
AllocateMemory(h_Certainty, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, allocatedHostMemory, "CERTAINTY");
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to allocate memory\n",(float)(endTime - startTime));
}
startTime = GetWallTime();
// Convert data to floats
if ( inputData->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputData->data;
for (size_t i = 0; i < DATA_W * DATA_H * DATA_D * DATA_T; i++)
{
h_fMRI_Volumes[i] = (float)p[i];
}
}
else if ( inputData->datatype == DT_UINT8 )
{
unsigned char *p = (unsigned char*)inputData->data;
for (size_t i = 0; i < DATA_W * DATA_H * DATA_D * DATA_T; i++)
{
h_fMRI_Volumes[i] = (float)p[i];
}
}
else if ( inputData->datatype == DT_UINT16 )
{
unsigned short int *p = (unsigned short int*)inputData->data;
for (size_t i = 0; i < DATA_W * DATA_H * DATA_D * DATA_T; i++)
{
h_fMRI_Volumes[i] = (float)p[i];
}
}
// Correct data type, just copy the pointer
else if ( inputData->datatype == DT_FLOAT )
{
h_fMRI_Volumes = (float*)inputData->data;
// Save the pointer in the pointer list
allMemoryPointers[numberOfMemoryPointers] = (void*)h_fMRI_Volumes;
numberOfMemoryPointers++;
//float *p = (float*)inputData->data;
//for (size_t i = 0; i < DATA_W * DATA_H * DATA_D * DATA_T; i++)
//{
// h_fMRI_Volumes[i] = p[i];
//}
}
else
{
printf("Unknown data type in input data, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
// Free input fMRI data, it has been converted to floats
if ( inputData->datatype != DT_FLOAT )
{
free(inputData->data);
inputData->data = NULL;
}
// Pointer has been copied to h_fMRI_Volumes and pointer list, so set the input data pointer to NULL
else
{
inputData->data = NULL;
}
// Mask is provided by user
if (MASK)
{
if ( inputMask->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputMask->data;
for (size_t i = 0; i < DATA_W * DATA_H * DATA_D; i++)
{
h_Certainty[i] = (float)p[i];
}
}
else if ( inputMask->datatype == DT_UINT16 )
{
unsigned short int *p = (unsigned short int*)inputMask->data;
for (size_t i = 0; i < DATA_W * DATA_H * DATA_D; i++)
{
h_Certainty[i] = (float)p[i];
}
}
else if ( inputMask->datatype == DT_FLOAT )
{
float *p = (float*)inputMask->data;
for (size_t i = 0; i < DATA_W * DATA_H * DATA_D; i++)
{
h_Certainty[i] = p[i];
}
}
else if ( inputMask->datatype == DT_UINT8 )
{
unsigned char *p = (unsigned char*)inputMask->data;
for (size_t i = 0; i < DATA_W * DATA_H * DATA_D; i++)
{
h_Certainty[i] = (float)p[i];
}
}
else
{
printf("Unknown data type in mask volume, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
}
// Mask is NOT provided by user, set all mask voxels to 1
else
{
for (size_t i = 0; i < DATA_W * DATA_H * DATA_D; i++)
{
h_Certainty[i] = 1.0f;
}
}
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to convert data to floats\n",(float)(endTime - startTime));
}
//------------------------
startTime = GetWallTime();
// Initialize BROCCOLI
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE,2,VERBOS); // 2 = Bash wrapper
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to initiate BROCCOLI\n",(float)(endTime - startTime));
}
// Print build info to file (always)
std::vector<std::string> buildInfo = BROCCOLI.GetOpenCLBuildInfo();
std::vector<std::string> kernelFileNames = BROCCOLI.GetKernelFileNames();
std::string buildInfoPath;
buildInfoPath.append(getenv("BROCCOLI_DIR"));
buildInfoPath.append("compiled/Kernels/");
for (int k = 0; k < BROCCOLI.GetNumberOfKernelFiles(); k++)
{
std::string temp = buildInfoPath;
temp.append("buildInfo_");
temp.append(BROCCOLI.GetOpenCLPlatformName());
temp.append("_");
temp.append(BROCCOLI.GetOpenCLDeviceName());
temp.append("_");
std::string name = kernelFileNames[k];
// Remove "kernel" and ".cpp" from kernel filename
name = name.substr(0,name.size()-4);
name = name.substr(6,name.size());
temp.append(name);
temp.append(".txt");
fp = fopen(temp.c_str(),"w");
if (fp == NULL)
{
printf("Could not open %s for writing ! \n",temp.c_str());
}
else
{
if (buildInfo[k].c_str() != NULL)
{
int error = fputs(buildInfo[k].c_str(),fp);
if (error == EOF)
{
printf("Could not write to %s ! \n",temp.c_str());
}
}
fclose(fp);
}
}
// Something went wrong...
if (!BROCCOLI.GetOpenCLInitiated())
{
printf("Initialization error is \"%s\" \n",BROCCOLI.GetOpenCLInitializationError().c_str());
printf("OpenCL error is \"%s\" \n",BROCCOLI.GetOpenCLError());
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
printf("Create kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(createKernelErrors[i]));
}
}
printf("OpenCL initialization failed, aborting! \nSee buildInfo* for output of OpenCL compilation!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
// Initialization OK
else
{
// Set all necessary pointers and values
BROCCOLI.SetInputfMRIVolumes(h_fMRI_Volumes);
BROCCOLI.SetAutoMask(AUTO_MASK);
BROCCOLI.SetInputCertainty(h_Certainty);
BROCCOLI.SetEPISmoothingAmount(EPI_SMOOTHING_AMOUNT);
BROCCOLI.SetAllocatedHostMemory(allocatedHostMemory);
BROCCOLI.SetEPIWidth(DATA_W);
BROCCOLI.SetEPIHeight(DATA_H);
BROCCOLI.SetEPIDepth(DATA_D);
BROCCOLI.SetEPITimepoints(DATA_T);
BROCCOLI.SetEPIVoxelSizeX(EPI_VOXEL_SIZE_X);
BROCCOLI.SetEPIVoxelSizeY(EPI_VOXEL_SIZE_Y);
BROCCOLI.SetEPIVoxelSizeZ(EPI_VOXEL_SIZE_Z);
// Run the actual slice timing correction
startTime = GetWallTime();
BROCCOLI.PerformSmoothingNormalizedHostWrapper();
endTime = GetWallTime();
if (VERBOS)
{
printf("\nIt took %f seconds to run the smoothing\n",(float)(endTime - startTime));
}
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
printf("Create buffer error %i is %s \n",i,BROCCOLI.GetOpenCLErrorMessage(createBufferErrors[i]));
}
}
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
printf("Create kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(createKernelErrors[i]));
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
printf("Run kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(runKernelErrors[i]));
}
}
}
// Write results to file
startTime = GetWallTime();
if (!CHANGE_OUTPUT_FILENAME)
{
WriteNifti(inputData,h_fMRI_Volumes,FILENAME_EXTENSION,ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
else
{
nifti_set_filenames(inputData, outputFilename, 0, 1);
WriteNifti(inputData,h_fMRI_Volumes,"",DONT_ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
if (AUTO_MASK)
{
nifti_image *outputNiftifMRISingleVolume = nifti_copy_nim_info(inputData);
outputNiftifMRISingleVolume->nt = 1;
outputNiftifMRISingleVolume->dim[0] = 3;
outputNiftifMRISingleVolume->dim[4] = 1;
outputNiftifMRISingleVolume->nvox = DATA_W * DATA_H * DATA_D;
allNiftiImages[numberOfNiftiImages] = outputNiftifMRISingleVolume;
numberOfNiftiImages++;
if (!CHANGE_OUTPUT_FILENAME)
{
WriteNifti(outputNiftifMRISingleVolume,h_Certainty,"_mask",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
else
{
nifti_set_filenames(outputNiftifMRISingleVolume, outputFilename, 0, 1);
WriteNifti(outputNiftifMRISingleVolume,h_Certainty,"_mask",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
}
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to write the nifti file\n",(float)(endTime - startTime));
}
// Free all memory
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
//-----------------------
// Input pointers
float *h_Input_Volume;
float *h_Displacement_Field_X, *h_Displacement_Field_Y, *h_Displacement_Field_Z;
//-----------------------
// Output pointers
float *h_Interpolated_Volume;
void *allMemoryPointers[500];
int numberOfMemoryPointers = 0;
nifti_image* allNiftiImages[500];
int numberOfNiftiImages = 0;
// Default parameters
int OPENCL_PLATFORM = 0;
int OPENCL_DEVICE = 0;
int INTERPOLATION_MODE = 1;
bool DEBUG = false;
bool PRINT = true;
bool CHANGE_OUTPUT_NAME = false;
int MM_T1_Z_CUT = 0;
const char* outputFilename;
bool VERBOS = false;
// Size parameters
int INPUT_DATA_H, INPUT_DATA_W, INPUT_DATA_D;
int REFERENCE_DATA_H, REFERENCE_DATA_W, REFERENCE_DATA_D;
float INPUT_VOXEL_SIZE_X, INPUT_VOXEL_SIZE_Y, INPUT_VOXEL_SIZE_Z;
float REFERENCE_VOXEL_SIZE_X, REFERENCE_VOXEL_SIZE_Y, REFERENCE_VOXEL_SIZE_Z;
//---------------------
/* Input arguments */
FILE *fp = NULL;
// No inputs, so print help text
if (argc == 1)
{
printf("Transforms a volume using provided displacement fields, which have to be of the same size as the reference volume. The input volume is automagically resized and rescaled to match the input volume. \n\n");
printf("Usage:\n\n");
printf("TransformVolume volume_to_transform.nii reference_volume.nii displacement_field_x.nii displacement_field_y.nii displacement_field_z.nii [options]\n\n");
printf("Options:\n\n");
printf(" -platform The OpenCL platform to use (default 0) \n");
printf(" -device The OpenCL device to use for the specificed platform (default 0) \n");
printf(" -interpolation The interpolation to use, 0 = nearest, 1 = trilinear (default 1) \n");
printf(" -zcut Number of mm to cut from the bottom of the input volume, can be negative (default 0). Should be the same as for the call to RegisterTwoVolumes\n");
printf(" -output Set output filename (default volume_to_transform_warped.nii) \n");
printf(" -quiet Don't print anything to the terminal (default false) \n");
printf("\n\n");
return EXIT_SUCCESS;
}
else if (argc < 6)
{
printf("Need one volume to warp, one reference volume and three displacement field volumes!\n\n");
return EXIT_FAILURE;
}
// Try to open files
else if (argc > 1)
{
fp = fopen(argv[1],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[1]);
return EXIT_FAILURE;
}
fclose(fp);
fp = fopen(argv[2],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[2]);
return EXIT_FAILURE;
}
fclose(fp);
fp = fopen(argv[3],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[3]);
return EXIT_FAILURE;
}
fclose(fp);
fp = fopen(argv[4],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[4]);
return EXIT_FAILURE;
}
fclose(fp);
fp = fopen(argv[5],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[5]);
return EXIT_FAILURE;
}
fclose(fp);
}
// Loop over additional inputs
int i = 6;
while (i < argc)
{
char *input = argv[i];
char *p;
if (strcmp(input,"-platform") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -platform !\n");
return EXIT_FAILURE;
}
OPENCL_PLATFORM = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("OpenCL platform must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (OPENCL_PLATFORM < 0)
{
printf("OpenCL platform must be >= 0!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-device") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -device !\n");
return EXIT_FAILURE;
}
OPENCL_DEVICE = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("OpenCL device must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (OPENCL_DEVICE < 0)
{
printf("OpenCL device must be >= 0!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-interpolation") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -interpolation !\n");
return EXIT_FAILURE;
}
INTERPOLATION_MODE = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("Interpolation mode must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
if ( (INTERPOLATION_MODE != 0) && (INTERPOLATION_MODE != 1) )
{
printf("Interpolation mode has to be 0 or 1!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-zcut") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -zcut !\n");
return EXIT_FAILURE;
}
MM_T1_Z_CUT = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("zcut must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-quiet") == 0)
{
PRINT = false;
i += 1;
}
else if (strcmp(input,"-output") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read name after -output !\n");
return EXIT_FAILURE;
}
CHANGE_OUTPUT_NAME = true;
outputFilename = argv[i+1];
i += 2;
}
else
{
printf("Unrecognized option! %s \n",argv[i]);
return EXIT_FAILURE;
}
}
// Check if BROCCOLI_DIR variable is set
if (getenv("BROCCOLI_DIR") == NULL)
{
printf("The environment variable BROCCOLI_DIR is not set!\n");
return EXIT_FAILURE;
}
// Read data
nifti_image *inputVolume = nifti_image_read(argv[1],1);
if (inputVolume == NULL)
{
printf("Could not open volume to transform!\n");
return EXIT_FAILURE;
}
allNiftiImages[numberOfNiftiImages] = inputVolume;
numberOfNiftiImages++;
nifti_image *referenceVolume = nifti_image_read(argv[2],1);
if (referenceVolume == NULL)
{
printf("Could not open reference volume!\n");
return EXIT_FAILURE;
}
allNiftiImages[numberOfNiftiImages] = referenceVolume;
numberOfNiftiImages++;
nifti_image *inputDisplacementX = nifti_image_read(argv[3],1);
if (inputDisplacementX == NULL)
{
printf("Could not open displacement X volume!\n");
return EXIT_FAILURE;
}
allNiftiImages[numberOfNiftiImages] = inputDisplacementX;
numberOfNiftiImages++;
nifti_image *inputDisplacementY = nifti_image_read(argv[4],1);
if (inputDisplacementY == NULL)
{
printf("Could not open displacement Y volume!\n");
return EXIT_FAILURE;
}
allNiftiImages[numberOfNiftiImages] = inputDisplacementY;
numberOfNiftiImages++;
nifti_image *inputDisplacementZ = nifti_image_read(argv[5],1);
if (inputDisplacementZ == NULL)
{
printf("Could not open displacement Z volume!\n");
return EXIT_FAILURE;
}
allNiftiImages[numberOfNiftiImages] = inputDisplacementZ;
numberOfNiftiImages++;
// Get data dimensions from input data
INPUT_DATA_W = inputVolume->nx;
INPUT_DATA_H = inputVolume->ny;
INPUT_DATA_D = inputVolume->nz;
INPUT_VOXEL_SIZE_X = inputVolume->dx;
INPUT_VOXEL_SIZE_Y = inputVolume->dy;
INPUT_VOXEL_SIZE_Z = inputVolume->dz;
REFERENCE_DATA_W = referenceVolume->nx;
REFERENCE_DATA_H = referenceVolume->ny;
REFERENCE_DATA_D = referenceVolume->nz;
REFERENCE_VOXEL_SIZE_X = referenceVolume->dx;
REFERENCE_VOXEL_SIZE_Y = referenceVolume->dy;
REFERENCE_VOXEL_SIZE_Z = referenceVolume->dz;
// Check if the displacement volumes have the same size
int DISPLACEMENT_DATA_W, DISPLACEMENT_DATA_H, DISPLACEMENT_DATA_D;
DISPLACEMENT_DATA_W = inputDisplacementX->nx;
DISPLACEMENT_DATA_H = inputDisplacementX->ny;
DISPLACEMENT_DATA_D = inputDisplacementX->nz;
if ( (DISPLACEMENT_DATA_W != REFERENCE_DATA_W) || (DISPLACEMENT_DATA_H != REFERENCE_DATA_H) || (DISPLACEMENT_DATA_D != REFERENCE_DATA_D) )
{
printf("Dimensions of displacement field X does not match the reference volume!\n");
return -1;
}
DISPLACEMENT_DATA_W = inputDisplacementY->nx;
DISPLACEMENT_DATA_H = inputDisplacementY->ny;
DISPLACEMENT_DATA_D = inputDisplacementY->nz;
if ( (DISPLACEMENT_DATA_W != REFERENCE_DATA_W) || (DISPLACEMENT_DATA_H != REFERENCE_DATA_H) || (DISPLACEMENT_DATA_D != REFERENCE_DATA_D) )
{
printf("Dimensions of displacement field Y does not match the reference volume!\n");
return -1;
}
DISPLACEMENT_DATA_W = inputDisplacementZ->nx;
DISPLACEMENT_DATA_H = inputDisplacementZ->ny;
DISPLACEMENT_DATA_D = inputDisplacementZ->nz;
if ( (DISPLACEMENT_DATA_W != REFERENCE_DATA_W) || (DISPLACEMENT_DATA_H != REFERENCE_DATA_H) || (DISPLACEMENT_DATA_D != REFERENCE_DATA_D) )
{
printf("Dimensions of displacement field Z does not match the reference volume!\n");
return -1;
}
// Calculate size, in bytes
int INPUT_VOLUME_SIZE = INPUT_DATA_W * INPUT_DATA_H * INPUT_DATA_D * sizeof(float);
int REFERENCE_VOLUME_SIZE = REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D * sizeof(float);
// Print some info
if (PRINT)
{
printf("Authored by K.A. Eklund \n");
printf("Input volume size: %i x %i x %i \n", INPUT_DATA_W, INPUT_DATA_H, INPUT_DATA_D);
printf("Input volume voxel size: %f x %f x %f \n", INPUT_VOXEL_SIZE_X, INPUT_VOXEL_SIZE_Y, INPUT_VOXEL_SIZE_Z);
printf("Reference volume size: %i x %i x %i \n", REFERENCE_DATA_W, REFERENCE_DATA_H, REFERENCE_DATA_D);
printf("Reference volume voxel size: %f x %f x %f \n", REFERENCE_VOXEL_SIZE_X, REFERENCE_VOXEL_SIZE_Y, REFERENCE_VOXEL_SIZE_Z);
}
// ------------------------------------------------
// Allocate memory on the host
AllocateMemory(h_Input_Volume, INPUT_VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "INPUT_VOLUME");
AllocateMemory(h_Interpolated_Volume, REFERENCE_VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "INTERPOLATED_VOLUME");
AllocateMemory(h_Displacement_Field_X, REFERENCE_VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "DISPLACEMENT_FIELD_X");
AllocateMemory(h_Displacement_Field_Y, REFERENCE_VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "DISPLACEMENT_FIELD_Y");
AllocateMemory(h_Displacement_Field_Z, REFERENCE_VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "DISPLACEMENT_FIELD_Z");
// Convert data to floats
if ( inputVolume->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputVolume->data;
for (int i = 0; i < INPUT_DATA_W * INPUT_DATA_H * INPUT_DATA_D; i++)
{
h_Input_Volume[i] = (float)p[i];
}
}
else if ( inputVolume->datatype == DT_FLOAT )
{
float *p = (float*)inputVolume->data;
for (int i = 0; i < INPUT_DATA_W * INPUT_DATA_H * INPUT_DATA_D; i++)
{
h_Input_Volume[i] = p[i];
}
}
else if ( inputVolume->datatype == DT_UINT8 )
{
unsigned char *p = (unsigned char*)inputVolume->data;
for (int i = 0; i < INPUT_DATA_W * INPUT_DATA_H * INPUT_DATA_D; i++)
{
h_Input_Volume[i] = (float)p[i];
}
}
else
{
printf("Unknown data type in volume to transform, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
if ( inputDisplacementX->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputDisplacementX->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_X[i] = (float)p[i];
}
}
else if ( inputDisplacementX->datatype == DT_FLOAT )
{
float *p = (float*)inputDisplacementX->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_X[i] = p[i];
}
}
else
{
printf("Unknown data type in displacement x volume, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
if ( inputDisplacementY->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputDisplacementY->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_Y[i] = (float)p[i];
}
}
else if ( inputDisplacementY->datatype == DT_FLOAT )
{
float *p = (float*)inputDisplacementY->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_Y[i] = p[i];
}
}
else
{
printf("Unknown data type in displacement y volume, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
if ( inputDisplacementZ->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputDisplacementZ->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_Z[i] = (float)p[i];
}
}
else if ( inputDisplacementZ->datatype == DT_FLOAT )
{
float *p = (float*)inputDisplacementZ->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_Z[i] = p[i];
}
}
else
{
printf("Unknown data type in displacement z volume, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
//------------------------
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE,2,VERBOS); // 2 = Bash wrapper
// Print build info to file (always)
std::vector<std::string> buildInfo = BROCCOLI.GetOpenCLBuildInfo();
std::vector<std::string> kernelFileNames = BROCCOLI.GetKernelFileNames();
for (int k = 0; k < BROCCOLI.GetNumberOfKernelFiles(); k++)
{
std::string temp = "buildInfo";
std::string name = kernelFileNames[k];
// Remove "kernel" and ".cpp" from kernel filename
name = name.substr(0,name.size()-4);
name = name.substr(6,name.size());
temp.append(name);
temp.append(".txt");
fp = fopen(temp.c_str(),"w");
if (fp == NULL)
{
printf("Could not open %s for writing ! \n",temp.c_str());
}
else
{
if (buildInfo[k].c_str() != NULL)
{
int error = fputs(buildInfo[k].c_str(),fp);
if (error == EOF)
{
printf("Could not write to %s ! \n",temp.c_str());
}
}
fclose(fp);
}
}
// Something went wrong...
if ( !BROCCOLI.GetOpenCLInitiated() )
{
printf("Initialization error is \"%s\" \n",BROCCOLI.GetOpenCLInitializationError().c_str());
printf("OpenCL error is \"%s\" \n",BROCCOLI.GetOpenCLError());
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
printf("Create kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(createKernelErrors[i]));
}
}
printf("OpenCL initialization failed, aborting! \nSee buildInfo* for output of OpenCL compilation!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
// Initialization OK
else
{
// Set all necessary pointers and values
BROCCOLI.SetInputT1Volume(h_Input_Volume);
BROCCOLI.SetT1Width(INPUT_DATA_W);
BROCCOLI.SetT1Height(INPUT_DATA_H);
BROCCOLI.SetT1Depth(INPUT_DATA_D);
BROCCOLI.SetT1VoxelSizeX(INPUT_VOXEL_SIZE_X);
BROCCOLI.SetT1VoxelSizeY(INPUT_VOXEL_SIZE_Y);
BROCCOLI.SetT1VoxelSizeZ(INPUT_VOXEL_SIZE_Z);
BROCCOLI.SetMNIWidth(REFERENCE_DATA_W);
BROCCOLI.SetMNIHeight(REFERENCE_DATA_H);
BROCCOLI.SetMNIDepth(REFERENCE_DATA_D);
BROCCOLI.SetMNIVoxelSizeX(REFERENCE_VOXEL_SIZE_X);
BROCCOLI.SetMNIVoxelSizeY(REFERENCE_VOXEL_SIZE_Y);
BROCCOLI.SetMNIVoxelSizeZ(REFERENCE_VOXEL_SIZE_Z);
BROCCOLI.SetMMT1ZCUT(MM_T1_Z_CUT);
BROCCOLI.SetInterpolationMode(INTERPOLATION_MODE);
BROCCOLI.SetOutputDisplacementField(h_Displacement_Field_X,h_Displacement_Field_Y,h_Displacement_Field_Z);
BROCCOLI.SetOutputInterpolatedT1Volume(h_Interpolated_Volume);
if (DEBUG)
{
BROCCOLI.SetDebug(true);
}
// Run the actual transformation
BROCCOLI.TransformVolumesNonLinearWrapper();
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
printf("Create buffer error %i is %s \n",i,BROCCOLI.GetOpenCLErrorMessage(createBufferErrors[i]));
}
}
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
printf("Create kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(createKernelErrors[i]));
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
printf("Run kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(runKernelErrors[i]));
}
}
}
// Copy information from input data
nifti_image* outputNifti = nifti_copy_nim_info(referenceVolume);
allNiftiImages[numberOfNiftiImages] = outputNifti;
numberOfNiftiImages++;
// Change filename and write transformed data to file
if (!CHANGE_OUTPUT_NAME)
{
nifti_set_filenames(outputNifti, inputVolume->fname, 0, 1);
WriteNifti(outputNifti,h_Interpolated_Volume,"_warped",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
else
{
nifti_set_filenames(outputNifti, outputFilename, 0, 1);
WriteNifti(outputNifti,h_Interpolated_Volume,"",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
// Free all memory
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
//-----------------------
// Input pointers
float *h_Input_Volume;
float *h_Displacement_Field_X, *h_Displacement_Field_Y, *h_Displacement_Field_Z;
//-----------------------
// Output pointers
float *h_Interpolated_Volume;
void *allMemoryPointers[500];
int numberOfMemoryPointers = 0;
// Default parameters
int OPENCL_PLATFORM = 0;
int OPENCL_DEVICE = 0;
bool DEBUG = false;
bool PRINT = true;
bool CHANGE_OUTPUT_NAME = false;
const char* outputFilename;
// Size parameters
int INPUT_DATA_H, INPUT_DATA_W, INPUT_DATA_D;
int REFERENCE_DATA_H, REFERENCE_DATA_W, REFERENCE_DATA_D;
float INPUT_VOXEL_SIZE_X, INPUT_VOXEL_SIZE_Y, INPUT_VOXEL_SIZE_Z;
float REFERENCE_VOXEL_SIZE_X, REFERENCE_VOXEL_SIZE_Y, REFERENCE_VOXEL_SIZE_Z;
//---------------------
/* Input arguments */
FILE *fp = NULL;
// No inputs, so print help text
if (argc == 1)
{
printf("Transforms a volume using provided displacement fields, which have to be of the same size as the reference volume. The input volume is automagically resized and rescaled to match the input volume. \n\n");
printf("Usage:\n\n");
printf("TransformVolume volume_to_transform.nii reference_volume.nii displacement_field_x.nii displacement_field_y.nii displacement_field_z.nii [options]\n\n");
printf("Options:\n\n");
printf(" -platform The OpenCL platform to use (default 0) \n");
printf(" -device The OpenCL device to use for the specificed platform (default 0) \n");
printf(" -output Set output filename (default volume_to_transform_warped.nii) \n");
printf(" -quiet Don't print anything to the terminal (default false) \n");
printf("\n\n");
return 1;
}
else if (argc < 6)
{
printf("Need one volume to warp, one reference volume and three displacement field volumes!\n\n");
return -1;
}
// Try to open files
else if (argc > 1)
{
fp = fopen(argv[1],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[1]);
return -1;
}
fclose(fp);
fp = fopen(argv[2],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[2]);
return -1;
}
fclose(fp);
fp = fopen(argv[3],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[3]);
return -1;
}
fclose(fp);
fp = fopen(argv[4],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[4]);
return -1;
}
fclose(fp);
fp = fopen(argv[5],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[5]);
return -1;
}
fclose(fp);
}
// Loop over additional inputs
int i = 6;
while (i < argc)
{
char *input = argv[i];
char *p;
if (strcmp(input,"-platform") == 0)
{
OPENCL_PLATFORM = (int)strtol(argv[i+1], &p, 10);
if (OPENCL_PLATFORM < 0)
{
printf("OpenCL platform must be >= 0!\n");
return -1;
}
i += 2;
}
else if (strcmp(input,"-device") == 0)
{
OPENCL_DEVICE = (int)strtol(argv[i+1], &p, 10);
if (OPENCL_DEVICE < 0)
{
printf("OpenCL device must be >= 0!\n");
return -1;
}
i += 2;
}
else if (strcmp(input,"-quiet") == 0)
{
PRINT = false;
i += 1;
}
else if (strcmp(input,"-output") == 0)
{
CHANGE_OUTPUT_NAME = true;
outputFilename = argv[i+1];
i += 2;
}
else
{
printf("Unrecognized option! %s \n",argv[i]);
return -1;
}
}
// Read data
nifti_image *inputVolume = nifti_image_read(argv[1],1);
if (inputVolume == NULL)
{
printf("Could not open volume to transform!\n");
return -1;
}
nifti_image *referenceVolume = nifti_image_read(argv[2],1);
if (referenceVolume == NULL)
{
printf("Could not open reference volume!\n");
return -1;
}
nifti_image *inputDisplacementX = nifti_image_read(argv[3],1);
if (inputDisplacementX == NULL)
{
printf("Could not open displacement X volume!\n");
return -1;
}
nifti_image *inputDisplacementY = nifti_image_read(argv[4],1);
if (inputDisplacementY == NULL)
{
printf("Could not open displacement Y volume!\n");
return -1;
}
nifti_image *inputDisplacementZ = nifti_image_read(argv[5],1);
if (inputDisplacementZ == NULL)
{
printf("Could not open displacement Z volume!\n");
return -1;
}
// Get data dimensions from input data
INPUT_DATA_W = inputVolume->nx;
INPUT_DATA_H = inputVolume->ny;
INPUT_DATA_D = inputVolume->nz;
INPUT_VOXEL_SIZE_X = inputVolume->dx;
INPUT_VOXEL_SIZE_Y = inputVolume->dy;
INPUT_VOXEL_SIZE_Z = inputVolume->dz;
REFERENCE_DATA_W = referenceVolume->nx;
REFERENCE_DATA_H = referenceVolume->ny;
REFERENCE_DATA_D = referenceVolume->nz;
REFERENCE_VOXEL_SIZE_X = referenceVolume->dx;
REFERENCE_VOXEL_SIZE_Y = referenceVolume->dy;
REFERENCE_VOXEL_SIZE_Z = referenceVolume->dz;
// Check if the displacement volumes have the same size
int DISPLACEMENT_DATA_W, DISPLACEMENT_DATA_H, DISPLACEMENT_DATA_D;
DISPLACEMENT_DATA_W = inputDisplacementX->nx;
DISPLACEMENT_DATA_H = inputDisplacementX->ny;
DISPLACEMENT_DATA_D = inputDisplacementX->nz;
if ( (DISPLACEMENT_DATA_W != REFERENCE_DATA_W) || (DISPLACEMENT_DATA_H != REFERENCE_DATA_H) || (DISPLACEMENT_DATA_D != REFERENCE_DATA_D) )
{
printf("Dimensions of displacement field x does not match the reference volume!\n");
return -1;
}
DISPLACEMENT_DATA_W = inputDisplacementY->nx;
DISPLACEMENT_DATA_H = inputDisplacementY->ny;
DISPLACEMENT_DATA_D = inputDisplacementY->nz;
if ( (DISPLACEMENT_DATA_W != REFERENCE_DATA_W) || (DISPLACEMENT_DATA_H != REFERENCE_DATA_H) || (DISPLACEMENT_DATA_D != REFERENCE_DATA_D) )
{
printf("Dimensions of displacement field y does not match the reference volume!\n");
return -1;
}
DISPLACEMENT_DATA_W = inputDisplacementZ->nx;
DISPLACEMENT_DATA_H = inputDisplacementZ->ny;
DISPLACEMENT_DATA_D = inputDisplacementZ->nz;
if ( (DISPLACEMENT_DATA_W != REFERENCE_DATA_W) || (DISPLACEMENT_DATA_H != REFERENCE_DATA_H) || (DISPLACEMENT_DATA_D != REFERENCE_DATA_D) )
{
printf("Dimensions of displacement field z does not match the reference volume!\n");
return -1;
}
// Calculate size, in bytes
int INPUT_VOLUME_SIZE = INPUT_DATA_W * INPUT_DATA_H * INPUT_DATA_D * sizeof(float);
int REFERENCE_VOLUME_SIZE = REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D * sizeof(float);
// Print some info
if (PRINT)
{
printf("Authored by K.A. Eklund \n");
printf("Input volume size: %i x %i x %i \n", INPUT_DATA_W, INPUT_DATA_H, INPUT_DATA_D);
printf("Input volume voxel size: %f x %f x %f \n", INPUT_VOXEL_SIZE_X, INPUT_VOXEL_SIZE_Y, INPUT_VOXEL_SIZE_Z);
printf("Reference volume size: %i x %i x %i \n", REFERENCE_DATA_W, REFERENCE_DATA_H, REFERENCE_DATA_D);
printf("Reference volume voxel size: %f x %f x %f \n", REFERENCE_VOXEL_SIZE_X, REFERENCE_VOXEL_SIZE_Y, REFERENCE_VOXEL_SIZE_Z);
}
if (PRINT)
{
printf("Input volume size in bytes: %i \n", INPUT_VOLUME_SIZE);
}
// ------------------------------------------------
// Allocate memory on the host
if (!AllocateMemory(h_Input_Volume, INPUT_VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
return -1;
}
if (!AllocateMemory(h_Interpolated_Volume, REFERENCE_VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
return -1;
}
if (!AllocateMemory(h_Displacement_Field_X, REFERENCE_VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
return -1;
}
if (!AllocateMemory(h_Displacement_Field_Y, REFERENCE_VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
return -1;
}
if (!AllocateMemory(h_Displacement_Field_Z, REFERENCE_VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
return -1;
}
// Convert data to floats
if ( inputVolume->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputVolume->data;
for (int i = 0; i < INPUT_DATA_W * INPUT_DATA_H * INPUT_DATA_D; i++)
{
h_Input_Volume[i] = (float)p[i];
}
}
else if ( inputVolume->datatype == DT_FLOAT )
{
float *p = (float*)inputVolume->data;
for (int i = 0; i < INPUT_DATA_W * INPUT_DATA_H * INPUT_DATA_D; i++)
{
h_Input_Volume[i] = p[i];
}
}
else
{
printf("Unknown data type in volume to transform, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
return -1;
}
if ( inputDisplacementX->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputDisplacementX->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_X[i] = (float)p[i];
}
}
else if ( inputDisplacementX->datatype == DT_FLOAT )
{
float *p = (float*)inputDisplacementX->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_X[i] = p[i];
}
}
else
{
printf("Unknown data type in displacement x volume, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
return -1;
}
if ( inputDisplacementY->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputDisplacementY->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_Y[i] = (float)p[i];
}
}
else if ( inputDisplacementY->datatype == DT_FLOAT )
{
float *p = (float*)inputDisplacementY->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_Y[i] = p[i];
}
}
else
{
printf("Unknown data type in displacement y volume, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
return -1;
}
if ( inputDisplacementZ->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputDisplacementZ->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_Z[i] = (float)p[i];
}
}
else if ( inputDisplacementZ->datatype == DT_FLOAT )
{
float *p = (float*)inputDisplacementZ->data;
for (int i = 0; i < REFERENCE_DATA_W * REFERENCE_DATA_H * REFERENCE_DATA_D; i++)
{
h_Displacement_Field_Z[i] = p[i];
}
}
else
{
printf("Unknown data type in displacement z volume, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
return -1;
}
//------------------------
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE);
// Something went wrong...
if (BROCCOLI.GetOpenCLInitiated() == 0)
{
printf("Get platform IDs error is %s \n",BROCCOLI.GetOpenCLErrorMessage(BROCCOLI.GetOpenCLPlatformIDsError()));
printf("Get device IDs error is %s \n",BROCCOLI.GetOpenCLErrorMessage(BROCCOLI.GetOpenCLDeviceIDsError()));
printf("Create context error is %s \n",BROCCOLI.GetOpenCLErrorMessage(BROCCOLI.GetOpenCLCreateContextError()));
printf("Get create context info error is %s \n",BROCCOLI.GetOpenCLErrorMessage(BROCCOLI.GetOpenCLContextInfoError()));
printf("Create command queue error is %s \n",BROCCOLI.GetOpenCLErrorMessage(BROCCOLI.GetOpenCLCreateCommandQueueError()));
printf("Create program error is %s \n",BROCCOLI.GetOpenCLErrorMessage(BROCCOLI.GetOpenCLCreateProgramError()));
printf("Build program error is %s \n",BROCCOLI.GetOpenCLErrorMessage(BROCCOLI.GetOpenCLBuildProgramError()));
printf("Get program build info error is %s \n",BROCCOLI.GetOpenCLErrorMessage(BROCCOLI.GetOpenCLProgramBuildInfoError()));
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
printf("Create kernel error %i is %s \n",i,BROCCOLI.GetOpenCLErrorMessage(createKernelErrors[i]));
}
}
// Print build info to file
fp = fopen("buildinfo.txt","w");
if (fp == NULL)
{
printf("Could not open buildinfo.txt! \n");
}
if (BROCCOLI.GetOpenCLBuildInfoChar() != NULL)
{
int error = fputs(BROCCOLI.GetOpenCLBuildInfoChar(),fp);
if (error == EOF)
{
printf("Could not write to buildinfo.txt! \n");
}
}
fclose(fp);
printf("OpenCL initialization failed, aborting! \nSee buildinfo.txt for output of OpenCL compilation!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
return -1;
}
// Initialization OK
else if (BROCCOLI.GetOpenCLInitiated() == 1)
{
// Set all necessary pointers and values
BROCCOLI.SetInputT1Volume(h_Input_Volume);
BROCCOLI.SetT1Width(INPUT_DATA_W);
BROCCOLI.SetT1Height(INPUT_DATA_H);
BROCCOLI.SetT1Depth(INPUT_DATA_D);
BROCCOLI.SetT1VoxelSizeX(INPUT_VOXEL_SIZE_X);
BROCCOLI.SetT1VoxelSizeY(INPUT_VOXEL_SIZE_Y);
BROCCOLI.SetT1VoxelSizeZ(INPUT_VOXEL_SIZE_Z);
BROCCOLI.SetMNIWidth(REFERENCE_DATA_W);
BROCCOLI.SetMNIHeight(REFERENCE_DATA_H);
BROCCOLI.SetMNIDepth(REFERENCE_DATA_D);
BROCCOLI.SetMNIVoxelSizeX(REFERENCE_VOXEL_SIZE_X);
BROCCOLI.SetMNIVoxelSizeY(REFERENCE_VOXEL_SIZE_Y);
BROCCOLI.SetMNIVoxelSizeZ(REFERENCE_VOXEL_SIZE_Z);
BROCCOLI.SetMMT1ZCUT(0);
BROCCOLI.SetInterpolationMode(LINEAR);
BROCCOLI.SetOutputDisplacementField(h_Displacement_Field_X,h_Displacement_Field_Y,h_Displacement_Field_Z);
BROCCOLI.SetOutputInterpolatedT1Volume(h_Interpolated_Volume);
if (DEBUG)
{
BROCCOLI.SetDebug(true);
}
for (int i = 0; i < numberOfMemoryPointers; i++)
{
printf("Pointer i is %i \n",allMemoryPointers[i]);
}
// Run the actual transformation
BROCCOLI.TransformVolumesNonParametricWrapper();
for (int i = 0; i < numberOfMemoryPointers; i++)
{
printf("Pointer i is %i \n",allMemoryPointers[i]);
}
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
printf("Create buffer error %i is %s \n",i,BROCCOLI.GetOpenCLErrorMessage(createBufferErrors[i]));
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
printf("Run kernel error %i is %s \n",i,BROCCOLI.GetOpenCLErrorMessage(runKernelErrors[i]));
}
}
}
// Create new nifti image
nifti_image *outputNifti = new nifti_image;
// Copy information from input data
outputNifti = nifti_copy_nim_info(referenceVolume);
// Change filename
if (!CHANGE_OUTPUT_NAME)
{
nifti_set_filenames(outputNifti, inputVolume->fname, 0, 1);
// Write transformed data to file
WriteNifti(outputNifti,h_Interpolated_Volume,"_warped",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
//nifti_set_filenames(outputNifti, "warped.nii", 0, 1);
//WriteNifti(outputNifti,h_Interpolated_Volume,"",DONT_ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
else
{
//nifti_set_filenames(outputNifti, outputFilename, 0, 1);
// Write transformed data to file
//WriteNifti(outputNifti,h_Interpolated_Volume,"",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
// Free all memory
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputVolume);
nifti_image_free(referenceVolume);
nifti_image_free(inputDisplacementX);
nifti_image_free(inputDisplacementY);
nifti_image_free(inputDisplacementZ);
nifti_image_free(outputNifti);
return 1;
}
int main(int argc, char ** argv)
{
//-----------------------
// Input pointers
float *h_fMRI_Volumes = NULL;
void* allMemoryPointers[500];
int numberOfMemoryPointers = 0;
nifti_image* allNiftiImages[500];
int numberOfNiftiImages = 0;
// Default parameters
int OPENCL_PLATFORM = 0;
int OPENCL_DEVICE = 0;
bool DEBUG = false;
const char* FILENAME_EXTENSION = "_stc";
bool PRINT = true;
bool VERBOS = false;
int DATA_W, DATA_H, DATA_D, DATA_T;
float EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z;
float TR;
int SLICE_ORDER = 0;
//-----------------------
// Output parameters
const char *outputFilename;
float *h_Slice_Timing_Corrected_fMRI_Volumes = NULL;
//---------------------
/* Input arguments */
FILE *fp = NULL;
// No inputs, so print help text
if (argc == 1)
{
printf("Usage:\n\n");
printf("SliceTimingCorrection input.nii [options]\n\n");
printf("Options:\n\n");
printf(" -platform The OpenCL platform to use (default 0) \n");
printf(" -device The OpenCL device to use for the specificed platform (default 0) \n");
printf(" -slicepattern The sampling pattern used during scanning, 0 = sequential 1-N (bottom-up), 1 = sequential N-1 (top-down), 2 = alternating 1-N, 3 = alternating N-1 (default 0) \n");
printf(" -output Set output filename (default input_stc.nii) \n");
printf(" -quiet Don't print anything to the terminal (default false) \n");
printf(" -verbose Print extra stuff (default false) \n");
printf("\n\n");
return EXIT_SUCCESS;
}
// Try to open file
else if (argc > 1)
{
fp = fopen(argv[1],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[1]);
return EXIT_FAILURE;
}
fclose(fp);
}
// Loop over additional inputs
int i = 2;
while (i < argc)
{
char *input = argv[i];
char *p;
if (strcmp(input,"-platform") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -platform !\n");
return EXIT_FAILURE;
}
OPENCL_PLATFORM = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("OpenCL platform must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (OPENCL_PLATFORM < 0)
{
printf("OpenCL platform must be >= 0!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-device") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -device !\n");
return EXIT_FAILURE;
}
OPENCL_DEVICE = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("OpenCL device must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (OPENCL_DEVICE < 0)
{
printf("OpenCL device must be >= 0!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-slicepattern") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -slicepattern !\n");
return EXIT_FAILURE;
}
SLICE_ORDER = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("Slice pattern must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (SLICE_ORDER < 0)
{
printf("Slice pattern must be a positive number!\n");
return EXIT_FAILURE;
}
else if ( (SLICE_ORDER != 0) && (SLICE_ORDER != 1) && (SLICE_ORDER != 2) && (SLICE_ORDER != 3) )
{
printf("Slice pattern must be 0, 1, 2 or 3!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-debug") == 0)
{
DEBUG = true;
i += 1;
}
else if (strcmp(input,"-quiet") == 0)
{
PRINT = false;
i += 1;
}
else if (strcmp(input,"-verbose") == 0)
{
VERBOS = true;
i += 1;
}
else if (strcmp(input,"-output") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read name after -output !\n");
return EXIT_FAILURE;
}
outputFilename = argv[i+1];
i += 2;
}
else
{
printf("Unrecognized option! %s \n",argv[i]);
return EXIT_FAILURE;
}
}
double startTime = GetWallTime();
// Read data
nifti_image *inputData = nifti_image_read(argv[1],1);
if (inputData == NULL)
{
printf("Could not open nifti file!\n");
return EXIT_FAILURE;
}
allNiftiImages[numberOfNiftiImages] = inputData;
numberOfNiftiImages++;
double endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to read the nifti file\n",(float)(endTime - startTime));
}
// Get data dimensions from input data
DATA_W = inputData->nx;
DATA_H = inputData->ny;
DATA_D = inputData->nz;
DATA_T = inputData->nt;
// Get voxel sizes from input data
EPI_VOXEL_SIZE_X = inputData->dx;
EPI_VOXEL_SIZE_Y = inputData->dy;
EPI_VOXEL_SIZE_Z = inputData->dz;
// Get repetition time from input data
TR = inputData->dt;
// Calculate size, in bytes
int DATA_SIZE = DATA_W * DATA_H * DATA_D * DATA_T * sizeof(float);
int VOLUME_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
// Print some info
if (PRINT)
{
printf("Authored by K.A. Eklund \n");
printf("Data size: %i x %i x %i x %i \n", DATA_W, DATA_H, DATA_D, DATA_T);
printf("Voxel size: %f x %f x %f mm \n", EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z);
printf("TR: %f s \n", TR);
}
// ------------------------------------------------
// Allocate memory on the host
startTime = GetWallTime();
AllocateMemory(h_fMRI_Volumes, DATA_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "INPUT_DATA");
AllocateMemory(h_Slice_Timing_Corrected_fMRI_Volumes, DATA_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "SLICE_TIMING_CORRECTED_DATA");
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to allocate memory\n",(float)(endTime - startTime));
}
startTime = GetWallTime();
// Convert data to floats
if ( inputData->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputData->data;
for (int i = 0; i < DATA_W * DATA_H * DATA_D * DATA_T; i++)
{
h_fMRI_Volumes[i] = (float)p[i];
}
}
else if ( inputData->datatype == DT_FLOAT )
{
float *p = (float*)inputData->data;
for (int i = 0; i < DATA_W * DATA_H * DATA_D * DATA_T; i++)
{
h_fMRI_Volumes[i] = p[i];
}
}
else
{
printf("Unknown data type in input data, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to convert data to floats\n",(float)(endTime - startTime));
}
//------------------------
startTime = GetWallTime();
// Initialize BROCCOLI
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE,2); // 2 = Bash wrapper
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to initiate BROCCOLI\n",(float)(endTime - startTime));
}
// Something went wrong...
if (!BROCCOLI.GetOpenCLInitiated())
{
printf("Initialization error is \"%s\" \n",BROCCOLI.GetOpenCLInitializationError());
printf("OpenCL error is \"%s\" \n",BROCCOLI.GetOpenCLError());
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
printf("Create kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(createKernelErrors[i]));
}
}
// Print build info to file
fp = fopen("buildinfo.txt","w");
if (fp == NULL)
{
printf("Could not open buildinfo.txt! \n");
}
if (BROCCOLI.GetOpenCLBuildInfoChar() != NULL)
{
int error = fputs(BROCCOLI.GetOpenCLBuildInfoChar(),fp);
if (error == EOF)
{
printf("Could not write to buildinfo.txt! \n");
}
}
fclose(fp);
printf("OpenCL initialization failed, aborting! \nSee buildinfo.txt for output of OpenCL compilation!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
// Initialization OK
else
{
// Set all necessary pointers and values
BROCCOLI.SetInputfMRIVolumes(h_fMRI_Volumes);
BROCCOLI.SetEPIWidth(DATA_W);
BROCCOLI.SetEPIHeight(DATA_H);
BROCCOLI.SetEPIDepth(DATA_D);
BROCCOLI.SetEPITimepoints(DATA_T);
BROCCOLI.SetEPITR(TR);
BROCCOLI.SetEPISliceOrder(SLICE_ORDER);
BROCCOLI.SetOutputSliceTimingCorrectedfMRIVolumes(h_Slice_Timing_Corrected_fMRI_Volumes);
// Run the actual slice timing correction
startTime = GetWallTime();
BROCCOLI.PerformSliceTimingCorrectionWrapper();
endTime = GetWallTime();
if (VERBOS)
{
printf("\nIt took %f seconds to run the slice timing correction\n",(float)(endTime - startTime));
}
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
printf("Create buffer error %i is %d \n",i,BROCCOLI.GetOpenCLErrorMessage(createBufferErrors[i]));
}
}
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
printf("Create kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(createKernelErrors[i]));
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
printf("Run kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(runKernelErrors[i]));
}
}
}
// Write slice timing corrected data to file
startTime = GetWallTime();
/*
// Create new nifti image
nifti_image *outputNifti = nifti_copy_nim_info(inputData);
allNiftiImages[numberOfNiftiImages] = outputNifti;
numberOfNiftiImages++;
// Copy information from input data
if (!CHANGE_OUTPUT_NAME)
{
nifti_set_filenames(outputNifti, inputData->fname, 0, 1);
}
else
{
nifti_set_filenames(outputNifti, outputFilename, 0, 1);
}
*/
WriteNifti(inputData,h_Slice_Timing_Corrected_fMRI_Volumes,FILENAME_EXTENSION,ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to write the nifti file\n",(float)(endTime - startTime));
}
// Free all memory
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_SUCCESS;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//-----------------------
// Input pointers
double *h_fMRI_Volumes_double, *h_Quadrature_Filter_1_Real_double, *h_Quadrature_Filter_2_Real_double, *h_Quadrature_Filter_3_Real_double, *h_Quadrature_Filter_1_Imag_double, *h_Quadrature_Filter_2_Imag_double, *h_Quadrature_Filter_3_Imag_double;
float *h_fMRI_Volumes, *h_Quadrature_Filter_1_Real, *h_Quadrature_Filter_2_Real, *h_Quadrature_Filter_3_Real, *h_Quadrature_Filter_1_Imag, *h_Quadrature_Filter_2_Imag, *h_Quadrature_Filter_3_Imag;
int MOTION_CORRECTION_FILTER_SIZE, NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION;
int OPENCL_PLATFORM,OPENCL_DEVICE;
float EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z;
//-----------------------
// Output pointers
double *h_Motion_Corrected_fMRI_Volumes_double, *h_Motion_Parameters_double;
float *h_Motion_Corrected_fMRI_Volumes, *h_Motion_Parameters;
//---------------------
/* Check the number of input and output arguments. */
if(nrhs<10)
{
mexErrMsgTxt("Too few input arguments.");
}
if(nrhs>10)
{
mexErrMsgTxt("Too many input arguments.");
}
if(nlhs<2)
{
mexErrMsgTxt("Too few output arguments.");
}
if(nlhs>2)
{
mexErrMsgTxt("Too many output arguments.");
}
/* Input arguments */
// The data
h_fMRI_Volumes_double = (double*)mxGetData(prhs[0]);
EPI_VOXEL_SIZE_X = (float)mxGetScalar(prhs[1]);
EPI_VOXEL_SIZE_Y = (float)mxGetScalar(prhs[2]);
EPI_VOXEL_SIZE_Z = (float)mxGetScalar(prhs[3]);
h_Quadrature_Filter_1_Real_double = (double*)mxGetPr(prhs[4]);
h_Quadrature_Filter_1_Imag_double = (double*)mxGetPi(prhs[4]);
h_Quadrature_Filter_2_Real_double = (double*)mxGetPr(prhs[5]);
h_Quadrature_Filter_2_Imag_double = (double*)mxGetPi(prhs[5]);
h_Quadrature_Filter_3_Real_double = (double*)mxGetPr(prhs[6]);
h_Quadrature_Filter_3_Imag_double = (double*)mxGetPi(prhs[6]);
NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION = (int)mxGetScalar(prhs[7]);
OPENCL_PLATFORM = (int)mxGetScalar(prhs[8]);
OPENCL_DEVICE = (int)mxGetScalar(prhs[9]);
int NUMBER_OF_DIMENSIONS = mxGetNumberOfDimensions(prhs[0]);
const int *ARRAY_DIMENSIONS_DATA = mxGetDimensions(prhs[0]);
const int *ARRAY_DIMENSIONS_FILTER = mxGetDimensions(prhs[4]);
int DATA_H, DATA_W, DATA_D, DATA_T, NUMBER_OF_MOTION_CORRECTION_PARAMETERS;
NUMBER_OF_MOTION_CORRECTION_PARAMETERS = 6;
DATA_H = ARRAY_DIMENSIONS_DATA[0];
DATA_W = ARRAY_DIMENSIONS_DATA[1];
DATA_D = ARRAY_DIMENSIONS_DATA[2];
DATA_T = ARRAY_DIMENSIONS_DATA[3];
MOTION_CORRECTION_FILTER_SIZE = ARRAY_DIMENSIONS_FILTER[0];
int DATA_SIZE = DATA_W * DATA_H * DATA_D * DATA_T * sizeof(float);
int MOTION_PARAMETERS_SIZE = NUMBER_OF_MOTION_CORRECTION_PARAMETERS * DATA_T * sizeof(float);
int FILTER_SIZE = MOTION_CORRECTION_FILTER_SIZE * MOTION_CORRECTION_FILTER_SIZE * MOTION_CORRECTION_FILTER_SIZE * sizeof(float);
int VOLUME_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
mexPrintf("Data size : %i x %i x %i x %i \n", DATA_W, DATA_H, DATA_D, DATA_T);
mexPrintf("Voxel size : %f x %f x %f \n", EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z);
mexPrintf("Filter size : %i x %i x %i \n", MOTION_CORRECTION_FILTER_SIZE,MOTION_CORRECTION_FILTER_SIZE,MOTION_CORRECTION_FILTER_SIZE);
mexPrintf("Number of iterations : %i \n", NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION);
//-------------------------------------------------
// Output to Matlab
// Create pointer for volumes to Matlab
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES[4];
ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES[2] = DATA_D;
ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES[3] = DATA_T;
plhs[0] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES,mxDOUBLE_CLASS, mxREAL);
h_Motion_Corrected_fMRI_Volumes_double = mxGetPr(plhs[0]);
NUMBER_OF_DIMENSIONS = 2;
int ARRAY_DIMENSIONS_OUT_MOTION_PARAMETERS[2];
ARRAY_DIMENSIONS_OUT_MOTION_PARAMETERS[0] = DATA_T;
ARRAY_DIMENSIONS_OUT_MOTION_PARAMETERS[1] = NUMBER_OF_MOTION_CORRECTION_PARAMETERS;
plhs[1] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_MOTION_PARAMETERS,mxDOUBLE_CLASS, mxREAL);
h_Motion_Parameters_double = mxGetPr(plhs[1]);
// ------------------------------------------------
// Allocate memory on the host
h_fMRI_Volumes = (float *)mxMalloc(DATA_SIZE);
h_Quadrature_Filter_1_Real = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_1_Imag = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_2_Real = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_2_Imag = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_3_Real = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_3_Imag = (float *)mxMalloc(FILTER_SIZE);
h_Motion_Corrected_fMRI_Volumes = (float *)mxMalloc(DATA_SIZE);
h_Motion_Parameters = (float *)mxMalloc(MOTION_PARAMETERS_SIZE);
// Pack data (reorder from y,x,z to x,y,z and cast from double to float)
pack_double2float_volumes(h_fMRI_Volumes, h_fMRI_Volumes_double, DATA_W, DATA_H, DATA_D, DATA_T);
pack_double2float_volume(h_Quadrature_Filter_1_Real, h_Quadrature_Filter_1_Real_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
pack_double2float_volume(h_Quadrature_Filter_1_Imag, h_Quadrature_Filter_1_Imag_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
pack_double2float_volume(h_Quadrature_Filter_2_Real, h_Quadrature_Filter_2_Real_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
pack_double2float_volume(h_Quadrature_Filter_2_Imag, h_Quadrature_Filter_2_Imag_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
pack_double2float_volume(h_Quadrature_Filter_3_Real, h_Quadrature_Filter_3_Real_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
pack_double2float_volume(h_Quadrature_Filter_3_Imag, h_Quadrature_Filter_3_Imag_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
//------------------------
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE);
// Something went wrong...
if (BROCCOLI.GetOpenCLInitiated() == 0)
{
printf("Initialization error is \"%s\" \n",BROCCOLI.GetOpenCLInitializationError());
printf("OpenCL error is \"%s\" \n",BROCCOLI.GetOpenCLError());
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
mexPrintf("Create kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(createKernelErrors[i]));
}
}
mexPrintf("OPENCL initialization failed, aborting \n");
// Print build info
mexPrintf("Build info \n \n %s \n", BROCCOLI.GetOpenCLBuildInfoChar());
}
else if (BROCCOLI.GetOpenCLInitiated() == 1)
{
BROCCOLI.SetEPIWidth(DATA_W);
BROCCOLI.SetEPIHeight(DATA_H);
BROCCOLI.SetEPIDepth(DATA_D);
BROCCOLI.SetEPITimepoints(DATA_T);
BROCCOLI.SetEPIVoxelSizeX(EPI_VOXEL_SIZE_X);
BROCCOLI.SetEPIVoxelSizeY(EPI_VOXEL_SIZE_Y);
BROCCOLI.SetEPIVoxelSizeZ(EPI_VOXEL_SIZE_Z);
BROCCOLI.SetInputfMRIVolumes(h_fMRI_Volumes);
BROCCOLI.SetImageRegistrationFilterSize(MOTION_CORRECTION_FILTER_SIZE);
BROCCOLI.SetLinearImageRegistrationFilters(h_Quadrature_Filter_1_Real, h_Quadrature_Filter_1_Imag, h_Quadrature_Filter_2_Real, h_Quadrature_Filter_2_Imag, h_Quadrature_Filter_3_Real, h_Quadrature_Filter_3_Imag);
BROCCOLI.SetNumberOfIterationsForMotionCorrection(NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION);
BROCCOLI.SetOutputMotionCorrectedfMRIVolumes(h_Motion_Corrected_fMRI_Volumes);
BROCCOLI.SetOutputMotionParameters(h_Motion_Parameters);
BROCCOLI.PerformMotionCorrectionWrapper();
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
mexPrintf("Create buffer error %i is %d \n",i,createBufferErrors[i]);
}
}
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
mexPrintf("Create kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(createKernelErrors[i]));
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
mexPrintf("Run kernel error for kernel '%s' is '%s' \n",BROCCOLI.GetOpenCLKernelName(i),BROCCOLI.GetOpenCLErrorMessage(runKernelErrors[i]));
}
}
}
// Unpack results to Matlab
unpack_float2double_volumes(h_Motion_Corrected_fMRI_Volumes_double, h_Motion_Corrected_fMRI_Volumes, DATA_W, DATA_H, DATA_D, DATA_T);
unpack_float2double(h_Motion_Parameters_double, h_Motion_Parameters, NUMBER_OF_MOTION_CORRECTION_PARAMETERS * DATA_T);
// Free all the allocated memory on the host
mxFree(h_fMRI_Volumes);
mxFree(h_Quadrature_Filter_1_Real);
mxFree(h_Quadrature_Filter_1_Imag);
mxFree(h_Quadrature_Filter_2_Real);
mxFree(h_Quadrature_Filter_2_Imag);
mxFree(h_Quadrature_Filter_3_Real);
mxFree(h_Quadrature_Filter_3_Imag);
mxFree(h_Motion_Corrected_fMRI_Volumes);
mxFree(h_Motion_Parameters);
return;
}
int main(int argc, char ** argv)
{
//-----------------------
// Input pointers
float *h_fMRI_Volumes = NULL;
float *h_Quadrature_Filter_1_Real = NULL;
float *h_Quadrature_Filter_2_Real = NULL;
float *h_Quadrature_Filter_3_Real = NULL;
float *h_Quadrature_Filter_1_Imag = NULL;
float *h_Quadrature_Filter_2_Imag = NULL;
float *h_Quadrature_Filter_3_Imag = NULL;
void* allMemoryPointers[500];
int numberOfMemoryPointers = 0;
nifti_image* allNiftiImages[500];
int numberOfNiftiImages = 0;
// Default parameters
int MOTION_CORRECTION_FILTER_SIZE = 7;
int NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION = 5;
int OPENCL_PLATFORM = 0;
int OPENCL_DEVICE = 0;
int NUMBER_OF_MOTION_CORRECTION_PARAMETERS = 6;
bool DEBUG = false;
const char* FILENAME_EXTENSION = "_mc";
bool PRINT = true;
bool VERBOS = false;
int DATA_W, DATA_H, DATA_D, DATA_T;
float EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z;
//-----------------------
// Output parameters
const char *outputFilename;
float *h_Quadrature_Filter_Response_1_Real = NULL;
float *h_Quadrature_Filter_Response_1_Imag = NULL;
float *h_Quadrature_Filter_Response_2_Real = NULL;
float *h_Quadrature_Filter_Response_2_Imag = NULL;
float *h_Quadrature_Filter_Response_3_Real = NULL;
float *h_Quadrature_Filter_Response_3_Imag = NULL;
float *h_Phase_Differences = NULL;
float *h_Phase_Certainties = NULL;
float *h_Phase_Gradients = NULL;
float *h_Motion_Corrected_fMRI_Volumes = NULL;
float *h_Motion_Parameters = NULL;
//---------------------
/* Input arguments */
FILE *fp = NULL;
// No inputs, so print help text
if (argc == 1)
{
printf("Usage:\n\n");
printf("MotionCorrection input.nii [options]\n\n");
printf("Options:\n\n");
printf(" -platform The OpenCL platform to use (default 0) \n");
printf(" -device The OpenCL device to use for the specificed platform (default 0) \n");
printf(" -iterations Number of iterations for the motion correction algorithm (default 5) \n");
printf(" -output Set output filename (default input_mc.nii) \n");
printf(" -quiet Don't print anything to the terminal (default false) \n");
printf(" -verbose Print extra stuff (default false) \n");
printf(" -debug Get additional debug information (default false) \n");
printf("\n\n");
return EXIT_SUCCESS;
}
// Try to open file
else if (argc > 1)
{
fp = fopen(argv[1],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[1]);
return EXIT_FAILURE;
}
fclose(fp);
}
// Loop over additional inputs
int i = 2;
while (i < argc)
{
char *input = argv[i];
char *p;
if (strcmp(input,"-platform") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -platform !\n");
return EXIT_FAILURE;
}
OPENCL_PLATFORM = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("OpenCL platform must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (OPENCL_PLATFORM < 0)
{
printf("OpenCL platform must be >= 0!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-device") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -device !\n");
return EXIT_FAILURE;
}
OPENCL_DEVICE = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("OpenCL device must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (OPENCL_DEVICE < 0)
{
printf("OpenCL device must be >= 0!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-iterations") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -iterations !\n");
return EXIT_FAILURE;
}
NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION = (int)strtol(argv[i+1], &p, 10);
if (!isspace(*p) && *p != 0)
{
printf("Number of iterations must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION <= 0)
{
printf("Number of iterations must be a positive number!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-debug") == 0)
{
DEBUG = true;
i += 1;
}
else if (strcmp(input,"-quiet") == 0)
{
PRINT = false;
i += 1;
}
else if (strcmp(input,"-verbose") == 0)
{
VERBOS = true;
i += 1;
}
else if (strcmp(input,"-output") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read name after -output !\n");
return EXIT_FAILURE;
}
outputFilename = argv[i+1];
i += 2;
}
else
{
printf("Unrecognized option! %s \n",argv[i]);
return EXIT_FAILURE;
}
}
double startTime = GetWallTime();
// Read data
nifti_image *inputData = nifti_image_read(argv[1],1);
if (inputData == NULL)
{
printf("Could not open nifti file!\n");
return EXIT_FAILURE;
}
allNiftiImages[numberOfNiftiImages] = inputData;
numberOfNiftiImages++;
double endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to read the nifti file\n",(float)(endTime - startTime));
}
// Get data dimensions from input data
DATA_W = inputData->nx;
DATA_H = inputData->ny;
DATA_D = inputData->nz;
DATA_T = inputData->nt;
// Get voxel sizes from input data
EPI_VOXEL_SIZE_X = inputData->dx;
EPI_VOXEL_SIZE_Y = inputData->dy;
EPI_VOXEL_SIZE_Z = inputData->dz;
// Calculate size, in bytes
int DATA_SIZE = DATA_W * DATA_H * DATA_D * DATA_T * sizeof(float);
int MOTION_PARAMETERS_SIZE = NUMBER_OF_MOTION_CORRECTION_PARAMETERS * DATA_T * sizeof(float);
int FILTER_SIZE = MOTION_CORRECTION_FILTER_SIZE * MOTION_CORRECTION_FILTER_SIZE * MOTION_CORRECTION_FILTER_SIZE * sizeof(float);
int VOLUME_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
// Print some info
if (PRINT)
{
printf("Authored by K.A. Eklund \n");
printf("Data size: %i x %i x %i x %i \n", DATA_W, DATA_H, DATA_D, DATA_T);
printf("Voxel size: %f x %f x %f mm \n", EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z);
printf("Number of iterations for motion correction: %i \n", NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION);
}
// ------------------------------------------------
// Allocate memory on the host
startTime = GetWallTime();
AllocateMemory(h_fMRI_Volumes, DATA_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "INPUT_DATA");
AllocateMemory(h_Motion_Corrected_fMRI_Volumes, DATA_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "MOTION_CORRECTED_DATA");
AllocateMemory(h_Quadrature_Filter_1_Real, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_1_REAL");
AllocateMemory(h_Quadrature_Filter_1_Imag, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_1_IMAG");
AllocateMemory(h_Quadrature_Filter_2_Real, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_2_REAL");
AllocateMemory(h_Quadrature_Filter_2_Imag, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_2_IMAG");
AllocateMemory(h_Quadrature_Filter_3_Real, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_3_REAL");
AllocateMemory(h_Quadrature_Filter_3_Imag, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_3_IMAG");
AllocateMemory(h_Motion_Parameters, MOTION_PARAMETERS_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "MOTION_PARAMETERS");
if (DEBUG)
{
AllocateMemory(h_Quadrature_Filter_Response_1_Real, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_RESPONSE_1_REAL");
AllocateMemory(h_Quadrature_Filter_Response_1_Imag, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_RESPONSE_1_IMAG");
AllocateMemory(h_Quadrature_Filter_Response_2_Real, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_RESPONSE_2_REAL");
AllocateMemory(h_Quadrature_Filter_Response_2_Imag, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_RESPONSE_2_IMAG");
AllocateMemory(h_Quadrature_Filter_Response_3_Real, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_RESPONSE_3_REAL");
AllocateMemory(h_Quadrature_Filter_Response_3_Imag, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "QUADRATURE_FILTER_RESPONSE_3_IMAG");
AllocateMemory(h_Phase_Differences, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "PHASE_DIFFERENCES");
AllocateMemory(h_Phase_Certainties, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "PHASE_CERTAINTIES");
AllocateMemory(h_Phase_Gradients, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "PHASE_GRADIENTS");
}
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to allocate memory\n",(float)(endTime - startTime));
}
startTime = GetWallTime();
// Convert data to floats
if ( inputData->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputData->data;
for (int i = 0; i < DATA_W * DATA_H * DATA_D * DATA_T; i++)
{
h_fMRI_Volumes[i] = (float)p[i];
}
}
else if ( inputData->datatype == DT_FLOAT )
{
float *p = (float*)inputData->data;
for (int i = 0; i < DATA_W * DATA_H * DATA_D * DATA_T; i++)
{
h_fMRI_Volumes[i] = p[i];
}
}
else
{
printf("Unknown data type in input data, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to convert data to floats\n",(float)(endTime - startTime));
}
startTime = GetWallTime();
// Read quadrature filters, three real valued and three imaginary valued
/*
std::string path = Getexepath();
path.erase(path.end()-16, path.end()); // 16 is the number of characters in 'MotionCorrection'
std::string filter1RealName = path;
std::string filter1ImagName = path;
std::string filter2RealName = path;
std::string filter2ImagName = path;
std::string filter3RealName = path;
std::string filter3ImagName = path;
*/
std::string filter1RealName;
std::string filter1ImagName;
std::string filter2RealName;
std::string filter2ImagName;
std::string filter3RealName;
std::string filter3ImagName;
filter1RealName.append("filter1_real_linear_registration.bin");
filter1ImagName.append("filter1_imag_linear_registration.bin");
filter2RealName.append("filter2_real_linear_registration.bin");
filter2ImagName.append("filter2_imag_linear_registration.bin");
filter3RealName.append("filter3_real_linear_registration.bin");
filter3ImagName.append("filter3_imag_linear_registration.bin");
ReadBinaryFile(h_Quadrature_Filter_1_Real,MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,filter1RealName.c_str(),allMemoryPointers,numberOfMemoryPointers,allNiftiImages,numberOfNiftiImages);
ReadBinaryFile(h_Quadrature_Filter_1_Imag,MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,filter1ImagName.c_str(),allMemoryPointers,numberOfMemoryPointers,allNiftiImages,numberOfNiftiImages);
ReadBinaryFile(h_Quadrature_Filter_2_Real,MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,filter2RealName.c_str(),allMemoryPointers,numberOfMemoryPointers,allNiftiImages,numberOfNiftiImages);
ReadBinaryFile(h_Quadrature_Filter_2_Imag,MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,filter2ImagName.c_str(),allMemoryPointers,numberOfMemoryPointers,allNiftiImages,numberOfNiftiImages);
ReadBinaryFile(h_Quadrature_Filter_3_Real,MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,filter3RealName.c_str(),allMemoryPointers,numberOfMemoryPointers,allNiftiImages,numberOfNiftiImages);
ReadBinaryFile(h_Quadrature_Filter_3_Imag,MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,filter3ImagName.c_str(),allMemoryPointers,numberOfMemoryPointers,allNiftiImages,numberOfNiftiImages);
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to read all binary files\n",(float)(endTime - startTime));
}
//------------------------
startTime = GetWallTime();
// Initialize BROCCOLI
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE,2); // 2 = Bash wrapper
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to initiate BROCCOLI\n",(float)(endTime - startTime));
}
// Something went wrong...
if (!BROCCOLI.GetOpenCLInitiated())
{
printf("Initialization error is \"%s\" \n",BROCCOLI.GetOpenCLInitializationError());
printf("OpenCL error is \"%s\" \n",BROCCOLI.GetOpenCLError());
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
printf("Create kernel error %i is %d \n",i,BROCCOLI.GetOpenCLErrorMessage(createKernelErrors[i]));
}
}
// Print build info to file
fp = fopen("buildinfo.txt","w");
if (fp == NULL)
{
printf("Could not open buildinfo.txt! \n");
}
if (BROCCOLI.GetOpenCLBuildInfoChar() != NULL)
{
int error = fputs(BROCCOLI.GetOpenCLBuildInfoChar(),fp);
if (error == EOF)
{
printf("Could not write to buildinfo.txt! \n");
}
}
fclose(fp);
printf("OpenCL initialization failed, aborting! \nSee buildinfo.txt for output of OpenCL compilation!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
// Initialization OK
else
{
// Set all necessary pointers and values
BROCCOLI.SetInputfMRIVolumes(h_fMRI_Volumes);
BROCCOLI.SetEPIWidth(DATA_W);
BROCCOLI.SetEPIHeight(DATA_H);
BROCCOLI.SetEPIDepth(DATA_D);
BROCCOLI.SetEPITimepoints(DATA_T);
BROCCOLI.SetEPIVoxelSizeX(EPI_VOXEL_SIZE_X);
BROCCOLI.SetEPIVoxelSizeY(EPI_VOXEL_SIZE_Y);
BROCCOLI.SetEPIVoxelSizeZ(EPI_VOXEL_SIZE_Z);
BROCCOLI.SetImageRegistrationFilterSize(MOTION_CORRECTION_FILTER_SIZE);
BROCCOLI.SetLinearImageRegistrationFilters(h_Quadrature_Filter_1_Real, h_Quadrature_Filter_1_Imag, h_Quadrature_Filter_2_Real, h_Quadrature_Filter_2_Imag, h_Quadrature_Filter_3_Real, h_Quadrature_Filter_3_Imag);
BROCCOLI.SetNumberOfIterationsForMotionCorrection(NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION);
BROCCOLI.SetOutputMotionCorrectedfMRIVolumes(h_Motion_Corrected_fMRI_Volumes);
BROCCOLI.SetOutputMotionParameters(h_Motion_Parameters);
if (DEBUG)
{
BROCCOLI.SetDebug(true);
//BROCCOLI.SetOutputQuadratureFilterResponses(h_Quadrature_Filter_Response_1_Real, h_Quadrature_Filter_Response_1_Imag, h_Quadrature_Filter_Response_2_Real, h_Quadrature_Filter_Response_2_Imag, h_Quadrature_Filter_Response_3_Real, h_Quadrature_Filter_Response_3_Imag);
BROCCOLI.SetOutputPhaseDifferences(h_Phase_Differences);
BROCCOLI.SetOutputPhaseCertainties(h_Phase_Certainties);
BROCCOLI.SetOutputPhaseGradients(h_Phase_Gradients);
}
// Run the actual motion correction
startTime = GetWallTime();
BROCCOLI.PerformMotionCorrectionWrapper();
endTime = GetWallTime();
if (VERBOS)
{
printf("\nIt took %f seconds to run the motion correction\n",(float)(endTime - startTime));
}
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
printf("Create buffer error %i is %d \n",i,BROCCOLI.GetOpenCLErrorMessage(createBufferErrors[i]));
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
printf("Run kernel error %i is %d \n",i,BROCCOLI.GetOpenCLErrorMessage(runKernelErrors[i]));
}
}
}
// Find max displacement
float maxDisplacement = 0.0f;
int maxVolume = 0;
for (int t = 1; t < DATA_T; t++)
{
float displacement = fabs(h_Motion_Parameters[t + 0*DATA_T]) + fabs(h_Motion_Parameters[t + 1*DATA_T]) + fabs(h_Motion_Parameters[t + 2*DATA_T]) + fabs(h_Motion_Parameters[t + 3*DATA_T]) + fabs(h_Motion_Parameters[t + 4*DATA_T]) + fabs(h_Motion_Parameters[t + 5*DATA_T]);
if (displacement > maxDisplacement)
{
maxDisplacement = displacement;
maxVolume = t;
}
}
if (PRINT)
{
printf("Max displacement = %f (mm) at volume %i \n",maxDisplacement,maxVolume);
}
// Print motion parameters to file
std::ofstream motion;
motion.open("motion.1D");
if ( motion.good() )
{
//motion.setf(ios::scientific);
motion.precision(6);
for (int t = 0; t < DATA_T; t++)
{
//printf("X translation for timepoint %i is %f\n",t+1,h_Motion_Parameters[t + DATA_T]);
//motion << h_Motion_Parameters[t + 0*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 1*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 2*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 3*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 4*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 5*DATA_T] << std::endl;
motion << h_Motion_Parameters[t + 4*DATA_T] << std::setw(2) << " " << -h_Motion_Parameters[t + 3*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 5*DATA_T] << std::setw(2) << " " << -h_Motion_Parameters[t + 2*DATA_T] << std::setw(2) << " " << -h_Motion_Parameters[t + 0*DATA_T] << std::setw(2) << " " << -h_Motion_Parameters[t + 1*DATA_T] << std::endl;
}
motion.close();
}
else
{
printf("Could not open motion.1D for writing!\n");
}
// Write motion corrected data to file
startTime = GetWallTime();
WriteNifti(inputData,h_Motion_Corrected_fMRI_Volumes,FILENAME_EXTENSION,ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
if (DEBUG)
{
WriteNifti(inputData,h_Phase_Differences,"_phase_differences",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Phase_Gradients,"_phase_gradients",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Phase_Certainties,"_phase_certainties",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_1_Real,"_quadrature_filter_responses_1_real",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_1_Imag,"_quadrature_filter_responses_1_imag",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_2_Real,"_quadrature_filter_responses_2_real",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_2_Imag,"_quadrature_filter_responses_2_imag",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_3_Real,"_quadrature_filter_responses_3_real",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_3_Imag,"_quadrature_filter_responses_3_imag",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
endTime = GetWallTime();
if (VERBOS)
{
printf("It took %f seconds to write the nifti file\n",(float)(endTime - startTime));
}
// Free all memory
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_SUCCESS;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//-----------------------
// Input pointers
double *h_fMRI_Volumes_double, *h_X_GLM_double, *h_xtxxt_GLM_double, *h_Contrasts_double, *h_ctxtxc_GLM_double;
float *h_fMRI_Volumes, *h_X_GLM, *h_xtxxt_GLM, *h_Contrasts, *h_ctxtxc_GLM;
double *h_Mask_double;
float *h_Mask;
int OPENCL_PLATFORM, OPENCL_DEVICE;
//-----------------------
// Output pointers
double *h_Beta_Volumes_double, *h_Residuals_double, *h_Residual_Variances_double, *h_Statistical_Maps_double;
float *h_Beta_Volumes, *h_Residuals, *h_Residual_Variances, *h_Statistical_Maps;
//---------------------
/* Check the number of input and output arguments. */
if(nrhs<8)
{
mexErrMsgTxt("Too few input arguments.");
}
if(nrhs>8)
{
mexErrMsgTxt("Too many input arguments.");
}
if(nlhs<4)
{
mexErrMsgTxt("Too few output arguments.");
}
if(nlhs>4)
{
mexErrMsgTxt("Too many output arguments.");
}
/* Input arguments */
// The data
h_fMRI_Volumes_double = (double*)mxGetData(prhs[0]);
h_Mask_double = (double*)mxGetData(prhs[1]);
h_X_GLM_double = (double*)mxGetData(prhs[2]);
h_xtxxt_GLM_double = (double*)mxGetData(prhs[3]);
h_Contrasts_double = (double*)mxGetData(prhs[4]);
h_ctxtxc_GLM_double = (double*)mxGetData(prhs[5]);
OPENCL_PLATFORM = (int)mxGetScalar(prhs[6]);
OPENCL_DEVICE = (int)mxGetScalar(prhs[7]);
int NUMBER_OF_DIMENSIONS = mxGetNumberOfDimensions(prhs[0]);
const int *ARRAY_DIMENSIONS_DATA = mxGetDimensions(prhs[0]);
const int *ARRAY_DIMENSIONS_GLM = mxGetDimensions(prhs[2]);
const int *ARRAY_DIMENSIONS_CONTRAST = mxGetDimensions(prhs[5]);
int DATA_H, DATA_W, DATA_D, DATA_T, NUMBER_OF_REGRESSORS, NUMBER_OF_TOTAL_GLM_REGRESSORS, NUMBER_OF_CONTRASTS;
DATA_H = ARRAY_DIMENSIONS_DATA[0];
DATA_W = ARRAY_DIMENSIONS_DATA[1];
DATA_D = ARRAY_DIMENSIONS_DATA[2];
DATA_T = ARRAY_DIMENSIONS_DATA[3];
NUMBER_OF_REGRESSORS = ARRAY_DIMENSIONS_GLM[1];
NUMBER_OF_TOTAL_GLM_REGRESSORS = NUMBER_OF_REGRESSORS;
NUMBER_OF_CONTRASTS = ARRAY_DIMENSIONS_CONTRAST[1];
int DATA_SIZE = DATA_W * DATA_H * DATA_D * DATA_T * sizeof(float);
int VOLUME_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
int GLM_SIZE = DATA_T * NUMBER_OF_REGRESSORS * sizeof(float);
int CONTRAST_SIZE = NUMBER_OF_REGRESSORS * NUMBER_OF_CONTRASTS * sizeof(float);
int CONTRAST_MATRIX_SIZE = NUMBER_OF_CONTRASTS * NUMBER_OF_CONTRASTS * sizeof(float);
int BETA_SIZE = DATA_W * DATA_H * DATA_D * NUMBER_OF_TOTAL_GLM_REGRESSORS * sizeof(float);
int STATISTICAL_MAPS_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
int DESIGN_MATRIX_SIZE = NUMBER_OF_TOTAL_GLM_REGRESSORS * DATA_T * sizeof(float);
mexPrintf("Data size : %i x %i x %i x %i \n", DATA_W, DATA_H, DATA_D, DATA_T);
mexPrintf("Number of regressors : %i \n", NUMBER_OF_REGRESSORS);
mexPrintf("Number of contrasts : %i \n", NUMBER_OF_CONTRASTS);
//-------------------------------------------------
// Output to Matlab
// Create pointer for volumes to Matlab
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_BETA[4];
ARRAY_DIMENSIONS_OUT_BETA[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_BETA[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_BETA[2] = DATA_D;
ARRAY_DIMENSIONS_OUT_BETA[3] = NUMBER_OF_TOTAL_GLM_REGRESSORS;
plhs[0] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_BETA,mxDOUBLE_CLASS, mxREAL);
h_Beta_Volumes_double = mxGetPr(plhs[0]);
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_RESIDUALS[4];
ARRAY_DIMENSIONS_OUT_RESIDUALS[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_RESIDUALS[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_RESIDUALS[2] = DATA_D;
ARRAY_DIMENSIONS_OUT_RESIDUALS[3] = DATA_T;
plhs[1] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_RESIDUALS,mxDOUBLE_CLASS, mxREAL);
h_Residuals_double = mxGetPr(plhs[1]);
NUMBER_OF_DIMENSIONS = 3;
int ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[3];
ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[2] = DATA_D;
plhs[2] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES,mxDOUBLE_CLASS, mxREAL);
h_Residual_Variances_double = mxGetPr(plhs[2]);
NUMBER_OF_DIMENSIONS = 3;
int ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[3];
ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[2] = DATA_D;
plhs[3] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS,mxDOUBLE_CLASS, mxREAL);
h_Statistical_Maps_double = mxGetPr(plhs[3]);
// ------------------------------------------------
// Allocate memory on the host
h_fMRI_Volumes = (float *)mxMalloc(DATA_SIZE);
h_Mask = (float *)mxMalloc(VOLUME_SIZE);
h_X_GLM = (float *)mxMalloc(GLM_SIZE);
h_xtxxt_GLM = (float *)mxMalloc(GLM_SIZE);
h_Contrasts = (float *)mxMalloc(CONTRAST_SIZE);
h_ctxtxc_GLM = (float *)mxMalloc(CONTRAST_MATRIX_SIZE);
h_Beta_Volumes = (float *)mxMalloc(BETA_SIZE);
h_Residuals = (float *)mxMalloc(DATA_SIZE);
h_Residual_Variances = (float *)mxMalloc(VOLUME_SIZE);
h_Statistical_Maps = (float *)mxMalloc(STATISTICAL_MAPS_SIZE);
// Reorder and cast data
pack_double2float_volumes(h_fMRI_Volumes, h_fMRI_Volumes_double, DATA_W, DATA_H, DATA_D, DATA_T);
pack_double2float_volume(h_Mask, h_Mask_double, DATA_W, DATA_H, DATA_D);
pack_double2float(h_X_GLM, h_X_GLM_double, NUMBER_OF_REGRESSORS * DATA_T);
pack_double2float(h_xtxxt_GLM, h_xtxxt_GLM_double, NUMBER_OF_REGRESSORS * DATA_T);
pack_double2float_image(h_Contrasts, h_Contrasts_double, NUMBER_OF_REGRESSORS, NUMBER_OF_CONTRASTS);
pack_double2float(h_ctxtxc_GLM, h_ctxtxc_GLM_double, NUMBER_OF_CONTRASTS * NUMBER_OF_CONTRASTS);
//------------------------
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE);
// Something went wrong...
if (BROCCOLI.GetOpenCLInitiated() == 0)
{
int getPlatformIDsError = BROCCOLI.GetOpenCLPlatformIDsError();
int getDeviceIDsError = BROCCOLI.GetOpenCLDeviceIDsError();
int createContextError = BROCCOLI.GetOpenCLCreateContextError();
int getContextInfoError = BROCCOLI.GetOpenCLContextInfoError();
int createCommandQueueError = BROCCOLI.GetOpenCLCreateCommandQueueError();
int createProgramError = BROCCOLI.GetOpenCLCreateProgramError();
int buildProgramError = BROCCOLI.GetOpenCLBuildProgramError();
int getProgramBuildInfoError = BROCCOLI.GetOpenCLProgramBuildInfoError();
mexPrintf("Get platform IDs error is %d \n",getPlatformIDsError);
mexPrintf("Get device IDs error is %d \n",getDeviceIDsError);
mexPrintf("Create context error is %d \n",createContextError);
mexPrintf("Get create context info error is %d \n",getContextInfoError);
mexPrintf("Create command queue error is %d \n",createCommandQueueError);
mexPrintf("Create program error is %d \n",createProgramError);
mexPrintf("Build program error is %d \n",buildProgramError);
mexPrintf("Get program build info error is %d \n",getProgramBuildInfoError);
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
mexPrintf("Create kernel error %i is %d \n",i,createKernelErrors[i]);
}
}
mexPrintf("OPENCL initialization failed, aborting \n");
}
else if (BROCCOLI.GetOpenCLInitiated() == 1)
{
BROCCOLI.SetMNIWidth(DATA_W);
BROCCOLI.SetMNIHeight(DATA_H);
BROCCOLI.SetMNIDepth(DATA_D);
BROCCOLI.SetNumberOfSubjects(DATA_T);
BROCCOLI.SetNumberOfGLMRegressors(NUMBER_OF_REGRESSORS);
BROCCOLI.SetNumberOfContrasts(NUMBER_OF_CONTRASTS);
BROCCOLI.SetInputFirstLevelResults(h_fMRI_Volumes);
BROCCOLI.SetDesignMatrix(h_X_GLM, h_xtxxt_GLM);
BROCCOLI.SetContrasts(h_Contrasts);
BROCCOLI.SetGLMScalars(h_ctxtxc_GLM);
BROCCOLI.SetMask(h_Mask);
BROCCOLI.SetOutputBetaVolumes(h_Beta_Volumes);
BROCCOLI.SetOutputResiduals(h_Residuals);
BROCCOLI.SetOutputResidualVariances(h_Residual_Variances);
BROCCOLI.SetOutputStatisticalMaps(h_Statistical_Maps);
BROCCOLI.PerformGLMFTestSecondLevelWrapper();
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
mexPrintf("Create buffer error %i is %d \n",i,createBufferErrors[i]);
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
mexPrintf("Run kernel error %i is %d \n",i,runKernelErrors[i]);
}
}
}
mexPrintf("Build info \n \n %s \n", BROCCOLI.GetOpenCLBuildInfoChar());
unpack_float2double_volumes(h_Beta_Volumes_double, h_Beta_Volumes, DATA_W, DATA_H, DATA_D, NUMBER_OF_TOTAL_GLM_REGRESSORS);
unpack_float2double_volumes(h_Residuals_double, h_Residuals, DATA_W, DATA_H, DATA_D, DATA_T);
unpack_float2double_volume(h_Residual_Variances_double, h_Residual_Variances, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_Statistical_Maps_double, h_Statistical_Maps, DATA_W, DATA_H, DATA_D);
// Free all the allocated memory on the host
mxFree(h_fMRI_Volumes);
mxFree(h_Mask);
mxFree(h_X_GLM);
mxFree(h_xtxxt_GLM);
mxFree(h_Contrasts);
mxFree(h_ctxtxc_GLM);
mxFree(h_Beta_Volumes);
mxFree(h_Residuals);
mxFree(h_Residual_Variances);
mxFree(h_Statistical_Maps);
return;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//-----------------------
// Input
double *h_First_Level_Results_double, *h_MNI_Brain_Mask_double;
float *h_First_Level_Results, *h_MNI_Brain_Mask;
unsigned short int *h_Permutation_Matrix;
double *h_X_GLM_double, *h_xtxxt_GLM_double, *h_Contrasts_double, *h_ctxtxc_GLM_double;
float *h_X_GLM, *h_xtxxt_GLM, *h_Contrasts, *h_ctxtxc_GLM;
int MNI_DATA_W, MNI_DATA_H, MNI_DATA_D, NUMBER_OF_SUBJECTS, NUMBER_OF_PERMUTATIONS;
int NUMBER_OF_GLM_REGRESSORS, NUMBER_OF_CONTRASTS, INFERENCE_MODE;
float CLUSTER_DEFINING_THRESHOLD;
int OPENCL_PLATFORM, OPENCL_DEVICE;
int NUMBER_OF_DIMENSIONS;
//-----------------------
// Output
double *h_Permutation_Distribution_double;
double *h_Beta_Volumes_double, *h_Residuals_double, *h_Residual_Variances_double, *h_Statistical_Maps_double;
int *h_Cluster_Indices, *h_Cluster_Indices_Out;
double *h_Permuted_First_Level_Results_double;
float *h_Permutation_Distribution;
float *h_Beta_Volumes, *h_Residuals, *h_Residual_Variances, *h_Statistical_Maps;
float *h_Permuted_First_Level_Results;
//---------------------
/* Check the number of input and output arguments. */
if(nrhs<12)
{
mexErrMsgTxt("Too few input arguments.");
}
if(nrhs>12)
{
mexErrMsgTxt("Too many input arguments.");
}
if(nlhs<7)
{
mexErrMsgTxt("Too few output arguments.");
}
if(nlhs>7)
{
mexErrMsgTxt("Too many output arguments.");
}
/* Input arguments */
// The data
h_First_Level_Results_double = (double*)mxGetData(prhs[0]);
h_MNI_Brain_Mask_double = (double*)mxGetData(prhs[1]);
h_X_GLM_double = (double*)mxGetData(prhs[2]);
h_xtxxt_GLM_double = (double*)mxGetData(prhs[3]);
h_Contrasts_double = (double*)mxGetData(prhs[4]);
h_ctxtxc_GLM_double = (double*)mxGetData(prhs[5]);
h_Permutation_Matrix = (unsigned short int*)mxGetData(prhs[6]);
NUMBER_OF_PERMUTATIONS = (int)mxGetScalar(prhs[7]);
INFERENCE_MODE = (int)mxGetScalar(prhs[8]);
CLUSTER_DEFINING_THRESHOLD = (float)mxGetScalar(prhs[9]);
OPENCL_PLATFORM = (int)mxGetScalar(prhs[10]);
OPENCL_DEVICE = (int)mxGetScalar(prhs[11]);
const int *ARRAY_DIMENSIONS_FIRST_LEVEL_RESULTS = mxGetDimensions(prhs[0]);
const int *ARRAY_DIMENSIONS_MNI = mxGetDimensions(prhs[1]);
const int *ARRAY_DIMENSIONS_GLM = mxGetDimensions(prhs[2]);
const int *ARRAY_DIMENSIONS_CONTRAST = mxGetDimensions(prhs[5]);
NUMBER_OF_SUBJECTS = ARRAY_DIMENSIONS_FIRST_LEVEL_RESULTS[3];
MNI_DATA_H = ARRAY_DIMENSIONS_MNI[0];
MNI_DATA_W = ARRAY_DIMENSIONS_MNI[1];
MNI_DATA_D = ARRAY_DIMENSIONS_MNI[2];
NUMBER_OF_GLM_REGRESSORS = ARRAY_DIMENSIONS_GLM[1];
NUMBER_OF_CONTRASTS = ARRAY_DIMENSIONS_CONTRAST[1];
int FIRST_LEVEL_RESULTS_DATA_SIZE = MNI_DATA_W * MNI_DATA_H * MNI_DATA_D * NUMBER_OF_SUBJECTS * sizeof(float);
int MNI_DATA_SIZE = MNI_DATA_W * MNI_DATA_H * MNI_DATA_D * sizeof(float);
int MNI_DATA_SIZE_INT = MNI_DATA_W * MNI_DATA_H * MNI_DATA_D * sizeof(int);
int GLM_SIZE = NUMBER_OF_SUBJECTS * NUMBER_OF_GLM_REGRESSORS * sizeof(float);
int CONTRAST_SIZE = NUMBER_OF_GLM_REGRESSORS * NUMBER_OF_CONTRASTS * sizeof(float);
int CONTRAST_MATRIX_SIZE = NUMBER_OF_CONTRASTS * NUMBER_OF_CONTRASTS * sizeof(float);
int DESIGN_MATRIX_SIZE = NUMBER_OF_GLM_REGRESSORS * NUMBER_OF_SUBJECTS * sizeof(float);
int BETA_DATA_SIZE = MNI_DATA_W * MNI_DATA_H * MNI_DATA_D * NUMBER_OF_GLM_REGRESSORS * sizeof(float);
int STATISTICAL_MAPS_DATA_SIZE = MNI_DATA_W * MNI_DATA_H * MNI_DATA_D * NUMBER_OF_CONTRASTS * sizeof(float);
int RESIDUAL_VARIANCES_DATA_SIZE = MNI_DATA_W * MNI_DATA_H * MNI_DATA_D * sizeof(float);
int RESIDUAL_DATA_SIZE = MNI_DATA_W * MNI_DATA_H * MNI_DATA_D * NUMBER_OF_SUBJECTS * sizeof(float);
int NULL_DISTRIBUTION_SIZE = NUMBER_OF_PERMUTATIONS * sizeof(float);
mexPrintf("First level results data size : %i x %i x %i \n", MNI_DATA_W, MNI_DATA_H, MNI_DATA_D);
mexPrintf("Number of subjects: %i \n",NUMBER_OF_SUBJECTS);
mexPrintf("Number of GLM regressors : %i \n", NUMBER_OF_GLM_REGRESSORS);
mexPrintf("Number of contrasts : %i \n", NUMBER_OF_CONTRASTS);
mexPrintf("Number of permutations : %i \n", NUMBER_OF_PERMUTATIONS);
//-------------------------------------------------
// Output to Matlab
// Create pointer for volumes to Matlab
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_BETA[4];
ARRAY_DIMENSIONS_OUT_BETA[0] = MNI_DATA_H;
ARRAY_DIMENSIONS_OUT_BETA[1] = MNI_DATA_W;
ARRAY_DIMENSIONS_OUT_BETA[2] = MNI_DATA_D;
ARRAY_DIMENSIONS_OUT_BETA[3] = NUMBER_OF_GLM_REGRESSORS;
plhs[0] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_BETA,mxDOUBLE_CLASS, mxREAL);
h_Beta_Volumes_double = mxGetPr(plhs[0]);
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_RESIDUALS[4];
ARRAY_DIMENSIONS_OUT_RESIDUALS[0] = MNI_DATA_H;
ARRAY_DIMENSIONS_OUT_RESIDUALS[1] = MNI_DATA_W;
ARRAY_DIMENSIONS_OUT_RESIDUALS[2] = MNI_DATA_D;
ARRAY_DIMENSIONS_OUT_RESIDUALS[3] = NUMBER_OF_SUBJECTS;
plhs[1] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_RESIDUALS,mxDOUBLE_CLASS, mxREAL);
h_Residuals_double = mxGetPr(plhs[1]);
NUMBER_OF_DIMENSIONS = 3;
int ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[3];
ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[0] = MNI_DATA_H;
ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[1] = MNI_DATA_W;
ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[2] = MNI_DATA_D;
plhs[2] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES,mxDOUBLE_CLASS, mxREAL);
h_Residual_Variances_double = mxGetPr(plhs[2]);
NUMBER_OF_DIMENSIONS = 3;
int ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[3];
ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[0] = MNI_DATA_H;
ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[1] = MNI_DATA_W;
ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[2] = MNI_DATA_D;
plhs[3] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS,mxDOUBLE_CLASS, mxREAL);
h_Statistical_Maps_double = mxGetPr(plhs[3]);
NUMBER_OF_DIMENSIONS = 3;
int ARRAY_DIMENSIONS_OUT_CLUSTER_INDICES[3];
ARRAY_DIMENSIONS_OUT_CLUSTER_INDICES[0] = MNI_DATA_H;
ARRAY_DIMENSIONS_OUT_CLUSTER_INDICES[1] = MNI_DATA_W;
ARRAY_DIMENSIONS_OUT_CLUSTER_INDICES[2] = MNI_DATA_D;
plhs[4] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_CLUSTER_INDICES,mxINT32_CLASS, mxREAL);
h_Cluster_Indices_Out = (int*)mxGetData(plhs[4]);
NUMBER_OF_DIMENSIONS = 2;
int ARRAY_DIMENSIONS_OUT_DISTRIBUTION[2];
ARRAY_DIMENSIONS_OUT_DISTRIBUTION[0] = NUMBER_OF_PERMUTATIONS;
ARRAY_DIMENSIONS_OUT_DISTRIBUTION[1] = 1;
plhs[5] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_DISTRIBUTION,mxDOUBLE_CLASS, mxREAL);
h_Permutation_Distribution_double = mxGetPr(plhs[5]);
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_PERMUTED[4];
ARRAY_DIMENSIONS_OUT_PERMUTED[0] = MNI_DATA_H;
ARRAY_DIMENSIONS_OUT_PERMUTED[1] = MNI_DATA_W;
ARRAY_DIMENSIONS_OUT_PERMUTED[2] = MNI_DATA_D;
ARRAY_DIMENSIONS_OUT_PERMUTED[3] = NUMBER_OF_SUBJECTS;
plhs[6] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_PERMUTED,mxDOUBLE_CLASS, mxREAL);
h_Permuted_First_Level_Results_double = mxGetPr(plhs[6]);
// ------------------------------------------------
// Allocate memory on the host
h_First_Level_Results = (float *)mxMalloc(FIRST_LEVEL_RESULTS_DATA_SIZE);
h_Permuted_First_Level_Results = (float *)mxMalloc(FIRST_LEVEL_RESULTS_DATA_SIZE);
h_MNI_Brain_Mask = (float *)mxMalloc(MNI_DATA_SIZE);
h_Cluster_Indices = (int *)mxMalloc(MNI_DATA_SIZE_INT);
h_X_GLM = (float *)mxMalloc(GLM_SIZE);
h_xtxxt_GLM = (float *)mxMalloc(GLM_SIZE);
h_Contrasts = (float *)mxMalloc(CONTRAST_SIZE);
h_ctxtxc_GLM = (float *)mxMalloc(CONTRAST_MATRIX_SIZE);
h_Beta_Volumes = (float *)mxMalloc(BETA_DATA_SIZE);
h_Residuals = (float *)mxMalloc(RESIDUAL_DATA_SIZE);
h_Residual_Variances = (float *)mxMalloc(RESIDUAL_VARIANCES_DATA_SIZE);
h_Statistical_Maps = (float *)mxMalloc(STATISTICAL_MAPS_DATA_SIZE);
h_Permutation_Distribution = (float *)mxMalloc(NULL_DISTRIBUTION_SIZE);
// Reorder and cast data
pack_double2float_volumes(h_First_Level_Results, h_First_Level_Results_double, MNI_DATA_W, MNI_DATA_H, MNI_DATA_D, NUMBER_OF_SUBJECTS);
pack_double2float_volume(h_MNI_Brain_Mask, h_MNI_Brain_Mask_double, MNI_DATA_W, MNI_DATA_H, MNI_DATA_D);
pack_double2float(h_X_GLM, h_X_GLM_double, NUMBER_OF_GLM_REGRESSORS * NUMBER_OF_SUBJECTS);
pack_double2float(h_xtxxt_GLM, h_xtxxt_GLM_double, NUMBER_OF_GLM_REGRESSORS * NUMBER_OF_SUBJECTS);
//pack_double2float(h_Contrasts, h_Contrasts_double, NUMBER_OF_GLM_REGRESSORS * NUMBER_OF_CONTRASTS);
pack_double2float_image(h_Contrasts, h_Contrasts_double, NUMBER_OF_GLM_REGRESSORS, NUMBER_OF_CONTRASTS);
pack_double2float(h_ctxtxc_GLM, h_ctxtxc_GLM_double, NUMBER_OF_CONTRASTS * NUMBER_OF_CONTRASTS);
//------------------------
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM, OPENCL_DEVICE);
// Something went wrong...
if (BROCCOLI.GetOpenCLInitiated() == 0)
{
int getPlatformIDsError = BROCCOLI.GetOpenCLPlatformIDsError();
int getDeviceIDsError = BROCCOLI.GetOpenCLDeviceIDsError();
int createContextError = BROCCOLI.GetOpenCLCreateContextError();
int getContextInfoError = BROCCOLI.GetOpenCLContextInfoError();
int createCommandQueueError = BROCCOLI.GetOpenCLCreateCommandQueueError();
int createProgramError = BROCCOLI.GetOpenCLCreateProgramError();
int buildProgramError = BROCCOLI.GetOpenCLBuildProgramError();
int getProgramBuildInfoError = BROCCOLI.GetOpenCLProgramBuildInfoError();
mexPrintf("Get platform IDs error is %d \n",getPlatformIDsError);
mexPrintf("Get device IDs error is %d \n",getDeviceIDsError);
mexPrintf("Create context error is %d \n",createContextError);
mexPrintf("Get create context info error is %d \n",getContextInfoError);
mexPrintf("Create command queue error is %d \n",createCommandQueueError);
mexPrintf("Create program error is %d \n",createProgramError);
mexPrintf("Build program error is %d \n",buildProgramError);
mexPrintf("Get program build info error is %d \n",getProgramBuildInfoError);
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
mexPrintf("Create kernel error %i is %d \n",i,createKernelErrors[i]);
}
}
mexPrintf("OPENCL initialization failed, aborting \n");
}
else if (BROCCOLI.GetOpenCLInitiated() == 1)
{
BROCCOLI.SetInputFirstLevelResults(h_First_Level_Results);
BROCCOLI.SetInputMNIBrainMask(h_MNI_Brain_Mask);
BROCCOLI.SetMNIWidth(MNI_DATA_W);
BROCCOLI.SetMNIHeight(MNI_DATA_H);
BROCCOLI.SetMNIDepth(MNI_DATA_D);
BROCCOLI.SetStatisticalTest(1); // F-test
BROCCOLI.SetInferenceMode(INFERENCE_MODE);
BROCCOLI.SetClusterDefiningThreshold(CLUSTER_DEFINING_THRESHOLD);
BROCCOLI.SetNumberOfSubjects(NUMBER_OF_SUBJECTS);
BROCCOLI.SetNumberOfPermutations(NUMBER_OF_PERMUTATIONS);
BROCCOLI.SetNumberOfGLMRegressors(NUMBER_OF_GLM_REGRESSORS);
BROCCOLI.SetNumberOfContrasts(NUMBER_OF_CONTRASTS);
BROCCOLI.SetDesignMatrix(h_X_GLM, h_xtxxt_GLM);
BROCCOLI.SetContrasts(h_Contrasts);
BROCCOLI.SetGLMScalars(h_ctxtxc_GLM);
BROCCOLI.SetPermutationMatrix(h_Permutation_Matrix);
BROCCOLI.SetOutputBetaVolumes(h_Beta_Volumes);
BROCCOLI.SetOutputResiduals(h_Residuals);
BROCCOLI.SetOutputResidualVariances(h_Residual_Variances);
BROCCOLI.SetOutputStatisticalMaps(h_Statistical_Maps);
BROCCOLI.SetOutputClusterIndices(h_Cluster_Indices);
BROCCOLI.SetOutputPermutationDistribution(h_Permutation_Distribution);
BROCCOLI.SetOutputPermutedFirstLevelResults(h_Permuted_First_Level_Results);
BROCCOLI.PerformGLMFTestSecondLevelPermutationWrapper();
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
mexPrintf("Create buffer error %i is %d \n",i,createBufferErrors[i]);
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
mexPrintf("Run kernel error %i is %d \n",i,runKernelErrors[i]);
}
}
}
// Print build info
mexPrintf("Build info \n \n %s \n", BROCCOLI.GetOpenCLBuildInfoChar());
// Unpack results to Matlab
unpack_float2double_volumes(h_Permuted_First_Level_Results_double, h_Permuted_First_Level_Results, MNI_DATA_W, MNI_DATA_H, MNI_DATA_D, NUMBER_OF_SUBJECTS);
unpack_int2int_volume(h_Cluster_Indices_Out, h_Cluster_Indices, MNI_DATA_W, MNI_DATA_H, MNI_DATA_D);
unpack_float2double_volumes(h_Beta_Volumes_double, h_Beta_Volumes, MNI_DATA_W, MNI_DATA_H, MNI_DATA_D, NUMBER_OF_GLM_REGRESSORS);
unpack_float2double_volume(h_Statistical_Maps_double, h_Statistical_Maps, MNI_DATA_W, MNI_DATA_H, MNI_DATA_D);
unpack_float2double_volume(h_Residual_Variances_double, h_Residual_Variances, MNI_DATA_W, MNI_DATA_H, MNI_DATA_D);
unpack_float2double_volumes(h_Residuals_double, h_Residuals, MNI_DATA_W, MNI_DATA_H, MNI_DATA_D, NUMBER_OF_SUBJECTS);
unpack_float2double(h_Permutation_Distribution_double, h_Permutation_Distribution, NUMBER_OF_PERMUTATIONS);
// Free all the allocated memory on the host
mxFree(h_First_Level_Results);
mxFree(h_Permuted_First_Level_Results);
mxFree(h_MNI_Brain_Mask);
mxFree(h_Cluster_Indices);
mxFree(h_X_GLM);
mxFree(h_xtxxt_GLM);
mxFree(h_Contrasts);
mxFree(h_ctxtxc_GLM);
mxFree(h_Beta_Volumes);
mxFree(h_Residuals);
mxFree(h_Residual_Variances);
mxFree(h_Statistical_Maps);
mxFree(h_Permutation_Distribution);
return;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//-----------------------
// Input pointers
double *h_fMRI_Volumes_double, *h_Quadrature_Filter_1_Real_double, *h_Quadrature_Filter_2_Real_double, *h_Quadrature_Filter_3_Real_double, *h_Quadrature_Filter_1_Imag_double, *h_Quadrature_Filter_2_Imag_double, *h_Quadrature_Filter_3_Imag_double;
float *h_fMRI_Volumes, *h_Quadrature_Filter_1_Real, *h_Quadrature_Filter_2_Real, *h_Quadrature_Filter_3_Real, *h_Quadrature_Filter_1_Imag, *h_Quadrature_Filter_2_Imag, *h_Quadrature_Filter_3_Imag;
int MOTION_CORRECTION_FILTER_SIZE, NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION;
int OPENCL_PLATFORM,OPENCL_DEVICE;
//-----------------------
// Output pointers
double *h_Motion_Corrected_fMRI_Volumes_double, *h_Motion_Parameters_double;
double *h_Quadrature_Filter_Response_1_Real_double, *h_Quadrature_Filter_Response_1_Imag_double;
double *h_Quadrature_Filter_Response_2_Real_double, *h_Quadrature_Filter_Response_2_Imag_double;
double *h_Quadrature_Filter_Response_3_Real_double, *h_Quadrature_Filter_Response_3_Imag_double;
double *h_Phase_Differences_double, *h_Phase_Certainties_double, *h_Phase_Gradients_double;
float *h_Quadrature_Filter_Response_1_Real, *h_Quadrature_Filter_Response_1_Imag;
float *h_Quadrature_Filter_Response_2_Real, *h_Quadrature_Filter_Response_2_Imag;
float *h_Quadrature_Filter_Response_3_Real, *h_Quadrature_Filter_Response_3_Imag;
float *h_Phase_Differences, *h_Phase_Certainties, *h_Phase_Gradients;
float *h_Motion_Corrected_fMRI_Volumes, *h_Motion_Parameters;
//---------------------
/* Check the number of input and output arguments. */
if(nrhs<7)
{
mexErrMsgTxt("Too few input arguments.");
}
if(nrhs>7)
{
mexErrMsgTxt("Too many input arguments.");
}
if(nlhs<8)
{
mexErrMsgTxt("Too few output arguments.");
}
if(nlhs>8)
{
mexErrMsgTxt("Too many output arguments.");
}
/* Input arguments */
// The data
h_fMRI_Volumes_double = (double*)mxGetData(prhs[0]);
h_Quadrature_Filter_1_Real_double = (double*)mxGetPr(prhs[1]);
h_Quadrature_Filter_1_Imag_double = (double*)mxGetPi(prhs[1]);
h_Quadrature_Filter_2_Real_double = (double*)mxGetPr(prhs[2]);
h_Quadrature_Filter_2_Imag_double = (double*)mxGetPi(prhs[2]);
h_Quadrature_Filter_3_Real_double = (double*)mxGetPr(prhs[3]);
h_Quadrature_Filter_3_Imag_double = (double*)mxGetPi(prhs[3]);
NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION = (int)mxGetScalar(prhs[4]);
OPENCL_PLATFORM = (int)mxGetScalar(prhs[5]);
OPENCL_DEVICE = (int)mxGetScalar(prhs[6]);
int NUMBER_OF_DIMENSIONS = mxGetNumberOfDimensions(prhs[0]);
const int *ARRAY_DIMENSIONS_DATA = mxGetDimensions(prhs[0]);
const int *ARRAY_DIMENSIONS_FILTER = mxGetDimensions(prhs[1]);
int DATA_H, DATA_W, DATA_D, DATA_T, NUMBER_OF_MOTION_CORRECTION_PARAMETERS;
NUMBER_OF_MOTION_CORRECTION_PARAMETERS = 6;
DATA_H = ARRAY_DIMENSIONS_DATA[0];
DATA_W = ARRAY_DIMENSIONS_DATA[1];
DATA_D = ARRAY_DIMENSIONS_DATA[2];
DATA_T = ARRAY_DIMENSIONS_DATA[3];
MOTION_CORRECTION_FILTER_SIZE = ARRAY_DIMENSIONS_FILTER[0];
int DATA_SIZE = DATA_W * DATA_H * DATA_D * DATA_T * sizeof(float);
int MOTION_PARAMETERS_SIZE = NUMBER_OF_MOTION_CORRECTION_PARAMETERS * DATA_T * sizeof(float);
int FILTER_SIZE = MOTION_CORRECTION_FILTER_SIZE * MOTION_CORRECTION_FILTER_SIZE * MOTION_CORRECTION_FILTER_SIZE * sizeof(float);
int VOLUME_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
mexPrintf("Data size : %i x %i x %i x %i \n", DATA_W, DATA_H, DATA_D, DATA_T);
mexPrintf("Filter size : %i x %i x %i \n", MOTION_CORRECTION_FILTER_SIZE,MOTION_CORRECTION_FILTER_SIZE,MOTION_CORRECTION_FILTER_SIZE);
mexPrintf("Number of iterations : %i \n", NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION);
//-------------------------------------------------
// Output to Matlab
// Create pointer for volumes to Matlab
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES[4];
ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES[2] = DATA_D;
ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES[3] = DATA_T;
plhs[0] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_MOTION_CORRECTED_FMRI_VOLUMES,mxDOUBLE_CLASS, mxREAL);
h_Motion_Corrected_fMRI_Volumes_double = mxGetPr(plhs[0]);
NUMBER_OF_DIMENSIONS = 2;
int ARRAY_DIMENSIONS_OUT_MOTION_PARAMETERS[2];
ARRAY_DIMENSIONS_OUT_MOTION_PARAMETERS[0] = DATA_T;
ARRAY_DIMENSIONS_OUT_MOTION_PARAMETERS[1] = NUMBER_OF_MOTION_CORRECTION_PARAMETERS;
plhs[1] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_MOTION_PARAMETERS,mxDOUBLE_CLASS, mxREAL);
h_Motion_Parameters_double = mxGetPr(plhs[1]);
NUMBER_OF_DIMENSIONS = 3;
int ARRAY_DIMENSIONS_OUT_FILTER_RESPONSE[3];
ARRAY_DIMENSIONS_OUT_FILTER_RESPONSE[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_FILTER_RESPONSE[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_FILTER_RESPONSE[2] = DATA_D;
plhs[2] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_FILTER_RESPONSE,mxDOUBLE_CLASS, mxCOMPLEX);
h_Quadrature_Filter_Response_1_Real_double = mxGetPr(plhs[2]);
h_Quadrature_Filter_Response_1_Imag_double = mxGetPi(plhs[2]);
plhs[3] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_FILTER_RESPONSE,mxDOUBLE_CLASS, mxCOMPLEX);
h_Quadrature_Filter_Response_2_Real_double = mxGetPr(plhs[3]);
h_Quadrature_Filter_Response_2_Imag_double = mxGetPi(plhs[3]);
plhs[4] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_FILTER_RESPONSE,mxDOUBLE_CLASS, mxCOMPLEX);
h_Quadrature_Filter_Response_3_Real_double = mxGetPr(plhs[4]);
h_Quadrature_Filter_Response_3_Imag_double = mxGetPi(plhs[4]);
plhs[5] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_FILTER_RESPONSE,mxDOUBLE_CLASS, mxREAL);
h_Phase_Differences_double = mxGetPr(plhs[5]);
plhs[6] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_FILTER_RESPONSE,mxDOUBLE_CLASS, mxREAL);
h_Phase_Certainties_double = mxGetPr(plhs[6]);
plhs[7] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_FILTER_RESPONSE,mxDOUBLE_CLASS, mxREAL);
h_Phase_Gradients_double = mxGetPr(plhs[7]);
// ------------------------------------------------
// Allocate memory on the host
h_fMRI_Volumes = (float *)mxMalloc(DATA_SIZE);
h_Quadrature_Filter_1_Real = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_1_Imag = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_2_Real = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_2_Imag = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_3_Real = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_3_Imag = (float *)mxMalloc(FILTER_SIZE);
h_Quadrature_Filter_Response_1_Real = (float *)mxMalloc(VOLUME_SIZE);
h_Quadrature_Filter_Response_1_Imag = (float *)mxMalloc(VOLUME_SIZE);
h_Quadrature_Filter_Response_2_Real = (float *)mxMalloc(VOLUME_SIZE);
h_Quadrature_Filter_Response_2_Imag = (float *)mxMalloc(VOLUME_SIZE);
h_Quadrature_Filter_Response_3_Real = (float *)mxMalloc(VOLUME_SIZE);
h_Quadrature_Filter_Response_3_Imag = (float *)mxMalloc(VOLUME_SIZE);
h_Phase_Differences = (float *)mxMalloc(VOLUME_SIZE);
h_Phase_Certainties = (float *)mxMalloc(VOLUME_SIZE);
h_Phase_Gradients = (float *)mxMalloc(VOLUME_SIZE);
h_Motion_Corrected_fMRI_Volumes = (float *)mxMalloc(DATA_SIZE);
h_Motion_Parameters = (float *)mxMalloc(MOTION_PARAMETERS_SIZE);
// Pack data (reorder from y,x,z to x,y,z and cast from double to float)
pack_double2float_volumes(h_fMRI_Volumes, h_fMRI_Volumes_double, DATA_W, DATA_H, DATA_D, DATA_T);
pack_double2float_volume(h_Quadrature_Filter_1_Real, h_Quadrature_Filter_1_Real_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
pack_double2float_volume(h_Quadrature_Filter_1_Imag, h_Quadrature_Filter_1_Imag_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
pack_double2float_volume(h_Quadrature_Filter_2_Real, h_Quadrature_Filter_2_Real_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
pack_double2float_volume(h_Quadrature_Filter_2_Imag, h_Quadrature_Filter_2_Imag_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
pack_double2float_volume(h_Quadrature_Filter_3_Real, h_Quadrature_Filter_3_Real_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
pack_double2float_volume(h_Quadrature_Filter_3_Imag, h_Quadrature_Filter_3_Imag_double, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE, MOTION_CORRECTION_FILTER_SIZE);
//------------------------
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE);
// Something went wrong...
if (BROCCOLI.GetOpenCLInitiated() == 0)
{
int getPlatformIDsError = BROCCOLI.GetOpenCLPlatformIDsError();
int getDeviceIDsError = BROCCOLI.GetOpenCLDeviceIDsError();
int createContextError = BROCCOLI.GetOpenCLCreateContextError();
int getContextInfoError = BROCCOLI.GetOpenCLContextInfoError();
int createCommandQueueError = BROCCOLI.GetOpenCLCreateCommandQueueError();
int createProgramError = BROCCOLI.GetOpenCLCreateProgramError();
int buildProgramError = BROCCOLI.GetOpenCLBuildProgramError();
int getProgramBuildInfoError = BROCCOLI.GetOpenCLProgramBuildInfoError();
mexPrintf("Get platform IDs error is %d \n",getPlatformIDsError);
mexPrintf("Get device IDs error is %d \n",getDeviceIDsError);
mexPrintf("Create context error is %d \n",createContextError);
mexPrintf("Get create context info error is %d \n",getContextInfoError);
mexPrintf("Create command queue error is %d \n",createCommandQueueError);
mexPrintf("Create program error is %d \n",createProgramError);
mexPrintf("Build program error is %d \n",buildProgramError);
mexPrintf("Get program build info error is %d \n",getProgramBuildInfoError);
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
mexPrintf("Create kernel error %i is %d \n",i,createKernelErrors[i]);
}
}
mexPrintf("OPENCL initialization failed, aborting \n");
}
else if (BROCCOLI.GetOpenCLInitiated() == 1)
{
BROCCOLI.SetEPIWidth(DATA_W);
BROCCOLI.SetEPIHeight(DATA_H);
BROCCOLI.SetEPIDepth(DATA_D);
BROCCOLI.SetEPITimepoints(DATA_T);
BROCCOLI.SetInputfMRIVolumes(h_fMRI_Volumes);
BROCCOLI.SetImageRegistrationFilterSize(MOTION_CORRECTION_FILTER_SIZE);
BROCCOLI.SetParametricImageRegistrationFilters(h_Quadrature_Filter_1_Real, h_Quadrature_Filter_1_Imag, h_Quadrature_Filter_2_Real, h_Quadrature_Filter_2_Imag, h_Quadrature_Filter_3_Real, h_Quadrature_Filter_3_Imag);
BROCCOLI.SetNumberOfIterationsForMotionCorrection(NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION);
BROCCOLI.SetOutputMotionCorrectedfMRIVolumes(h_Motion_Corrected_fMRI_Volumes);
BROCCOLI.SetOutputMotionParameters(h_Motion_Parameters);
//BROCCOLI.SetOutputQuadratureFilterResponses(h_Quadrature_Filter_Response_1_Real, h_Quadrature_Filter_Response_1_Imag, h_Quadrature_Filter_Response_2_Real, h_Quadrature_Filter_Response_2_Imag, h_Quadrature_Filter_Response_3_Real, h_Quadrature_Filter_Response_3_Imag);
BROCCOLI.SetOutputPhaseDifferences(h_Phase_Differences);
BROCCOLI.SetOutputPhaseCertainties(h_Phase_Certainties);
BROCCOLI.SetOutputPhaseGradients(h_Phase_Gradients);
BROCCOLI.PerformMotionCorrectionWrapper();
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
mexPrintf("Create buffer error %i is %d \n",i,createBufferErrors[i]);
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
mexPrintf("Run kernel error %i is %d \n",i,runKernelErrors[i]);
}
}
}
// Print build info
mexPrintf("Build info \n \n %s \n", BROCCOLI.GetOpenCLBuildInfoChar());
// Unpack results to Matlab
unpack_float2double_volumes(h_Motion_Corrected_fMRI_Volumes_double, h_Motion_Corrected_fMRI_Volumes, DATA_W, DATA_H, DATA_D, DATA_T);
unpack_float2double(h_Motion_Parameters_double, h_Motion_Parameters, NUMBER_OF_MOTION_CORRECTION_PARAMETERS * DATA_T);
unpack_float2double_volume(h_Quadrature_Filter_Response_1_Real_double, h_Quadrature_Filter_Response_1_Real, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_Quadrature_Filter_Response_1_Imag_double, h_Quadrature_Filter_Response_1_Imag, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_Quadrature_Filter_Response_2_Real_double, h_Quadrature_Filter_Response_2_Real, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_Quadrature_Filter_Response_2_Imag_double, h_Quadrature_Filter_Response_2_Imag, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_Quadrature_Filter_Response_3_Real_double, h_Quadrature_Filter_Response_3_Real, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_Quadrature_Filter_Response_3_Imag_double, h_Quadrature_Filter_Response_3_Imag, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_Phase_Differences_double, h_Phase_Differences, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_Phase_Certainties_double, h_Phase_Certainties, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_Phase_Gradients_double, h_Phase_Gradients, DATA_W, DATA_H, DATA_D);
// Free all the allocated memory on the host
mxFree(h_fMRI_Volumes);
mxFree(h_Quadrature_Filter_1_Real);
mxFree(h_Quadrature_Filter_1_Imag);
mxFree(h_Quadrature_Filter_2_Real);
mxFree(h_Quadrature_Filter_2_Imag);
mxFree(h_Quadrature_Filter_3_Real);
mxFree(h_Quadrature_Filter_3_Imag);
mxFree(h_Quadrature_Filter_Response_1_Real);
mxFree(h_Quadrature_Filter_Response_1_Imag);
mxFree(h_Quadrature_Filter_Response_2_Real);
mxFree(h_Quadrature_Filter_Response_2_Imag);
mxFree(h_Quadrature_Filter_Response_3_Real);
mxFree(h_Quadrature_Filter_Response_3_Imag);
mxFree(h_Phase_Differences);
mxFree(h_Phase_Certainties);
mxFree(h_Phase_Gradients);
mxFree(h_Motion_Corrected_fMRI_Volumes);
mxFree(h_Motion_Parameters);
return;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//-----------------------
// Input pointers
double *h_fMRI_Volumes_double, *h_X_GLM_double, *h_xtxxt_GLM_double, *h_Contrasts_double, *h_ctxtxc_GLM_double, *h_Whitened_Models_double;
float *h_fMRI_Volumes, *h_X_GLM, *h_xtxxt_GLM, *h_Contrasts, *h_ctxtxc_GLM, *h_Whitened_Models;
double *h_EPI_Mask_double, *h_Smoothed_EPI_Mask_double;
float *h_EPI_Mask, *h_Smoothed_EPI_Mask;
unsigned short int *h_Permutation_Matrix;
float EPI_SMOOTHING_AMOUNT, AR_SMOOTHING_AMOUNT;
float EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z;
float CLUSTER_DEFINING_THRESHOLD;
int INFERENCE_MODE, NUMBER_OF_PERMUTATIONS, OPENCL_PLATFORM, OPENCL_DEVICE;
//-----------------------
// Output pointers
double *h_Permutation_Distribution_double;
double *h_Beta_Volumes_double, *h_Residuals_double, *h_Residual_Variances_double, *h_Statistical_Maps_double;
double *h_AR1_Estimates_double, *h_AR2_Estimates_double, *h_AR3_Estimates_double, *h_AR4_Estimates_double;
double *h_Detrended_fMRI_Volumes_double;
double *h_Whitened_fMRI_Volumes_double;
double *h_Permuted_fMRI_Volumes_double;
int *h_Cluster_Indices, *h_Cluster_Indices_Out;
float *h_Permutation_Distribution;
float *h_Beta_Volumes, *h_Residuals, *h_Residual_Variances, *h_Statistical_Maps;
float *h_AR1_Estimates, *h_AR2_Estimates, *h_AR3_Estimates, *h_AR4_Estimates;
float *h_Detrended_fMRI_Volumes;
float *h_Whitened_fMRI_Volumes;
float *h_Permuted_fMRI_Volumes;
//---------------------
/* Check the number of input and output arguments. */
if(nrhs<18)
{
mexErrMsgTxt("Too few input arguments.");
}
if(nrhs>18)
{
mexErrMsgTxt("Too many input arguments.");
}
if(nlhs<13)
{
mexErrMsgTxt("Too few output arguments.");
}
if(nlhs>13)
{
mexErrMsgTxt("Too many output arguments.");
}
/* Input arguments */
// The data
h_fMRI_Volumes_double = (double*)mxGetData(prhs[0]);
h_EPI_Mask_double = (double*)mxGetData(prhs[1]);
h_Smoothed_EPI_Mask_double = (double*)mxGetData(prhs[2]);
h_X_GLM_double = (double*)mxGetData(prhs[3]);
h_xtxxt_GLM_double = (double*)mxGetData(prhs[4]);
h_Contrasts_double = (double*)mxGetData(prhs[5]);
h_ctxtxc_GLM_double = (double*)mxGetData(prhs[6]);
EPI_SMOOTHING_AMOUNT = (float)mxGetScalar(prhs[7]);
AR_SMOOTHING_AMOUNT = (float)mxGetScalar(prhs[8]);
EPI_VOXEL_SIZE_X = (float)mxGetScalar(prhs[9]);
EPI_VOXEL_SIZE_Y = (float)mxGetScalar(prhs[10]);
EPI_VOXEL_SIZE_Z = (float)mxGetScalar(prhs[11]);
h_Permutation_Matrix = (unsigned short int*)mxGetData(prhs[12]);
NUMBER_OF_PERMUTATIONS = (int)mxGetScalar(prhs[13]);
INFERENCE_MODE = (int)mxGetScalar(prhs[14]);
CLUSTER_DEFINING_THRESHOLD = (float)mxGetScalar(prhs[15]);
OPENCL_PLATFORM = (int)mxGetScalar(prhs[16]);
OPENCL_DEVICE = (int)mxGetScalar(prhs[17]);
int NUMBER_OF_DIMENSIONS = mxGetNumberOfDimensions(prhs[0]);
const int *ARRAY_DIMENSIONS_DATA = mxGetDimensions(prhs[0]);
const int *ARRAY_DIMENSIONS_GLM = mxGetDimensions(prhs[3]);
const int *ARRAY_DIMENSIONS_CONTRAST = mxGetDimensions(prhs[6]);
int DATA_H, DATA_W, DATA_D, DATA_T, NUMBER_OF_REGRESSORS, NUMBER_OF_TOTAL_GLM_REGRESSORS, NUMBER_OF_CONTRASTS;
DATA_H = ARRAY_DIMENSIONS_DATA[0];
DATA_W = ARRAY_DIMENSIONS_DATA[1];
DATA_D = ARRAY_DIMENSIONS_DATA[2];
DATA_T = ARRAY_DIMENSIONS_DATA[3];
NUMBER_OF_REGRESSORS = ARRAY_DIMENSIONS_GLM[1];
NUMBER_OF_TOTAL_GLM_REGRESSORS = NUMBER_OF_REGRESSORS;
NUMBER_OF_CONTRASTS = ARRAY_DIMENSIONS_CONTRAST[1];
int DATA_SIZE = DATA_W * DATA_H * DATA_D * DATA_T * sizeof(float);
int VOLUME_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
int VOLUME_SIZE_INT = DATA_W * DATA_H * DATA_D * sizeof(int);
int GLM_SIZE = DATA_T * NUMBER_OF_REGRESSORS * sizeof(float);
int CONTRAST_SIZE = NUMBER_OF_REGRESSORS * NUMBER_OF_CONTRASTS * sizeof(float);
int CONTRAST_MATRIX_SIZE = NUMBER_OF_CONTRASTS * NUMBER_OF_CONTRASTS * sizeof(float);
int BETA_SIZE = DATA_W * DATA_H * DATA_D * NUMBER_OF_TOTAL_GLM_REGRESSORS * sizeof(float);
int STATISTICAL_MAPS_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
int DESIGN_MATRIX_SIZE = NUMBER_OF_TOTAL_GLM_REGRESSORS * DATA_T * sizeof(float);
int NULL_DISTRIBUTION_SIZE = NUMBER_OF_PERMUTATIONS * sizeof(float);
mexPrintf("Data size : %i x %i x %i x %i \n", DATA_W, DATA_H, DATA_D, DATA_T);
mexPrintf("Number of regressors : %i \n", NUMBER_OF_REGRESSORS);
mexPrintf("Number of contrasts : %i \n", NUMBER_OF_CONTRASTS);
mexPrintf("Number of permutations : %i \n", NUMBER_OF_PERMUTATIONS);
//-------------------------------------------------
// Output to Matlab
// Create pointer for volumes to Matlab
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_BETA[4];
ARRAY_DIMENSIONS_OUT_BETA[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_BETA[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_BETA[2] = DATA_D;
ARRAY_DIMENSIONS_OUT_BETA[3] = NUMBER_OF_TOTAL_GLM_REGRESSORS;
plhs[0] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_BETA,mxDOUBLE_CLASS, mxREAL);
h_Beta_Volumes_double = mxGetPr(plhs[0]);
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_RESIDUALS[4];
ARRAY_DIMENSIONS_OUT_RESIDUALS[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_RESIDUALS[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_RESIDUALS[2] = DATA_D;
ARRAY_DIMENSIONS_OUT_RESIDUALS[3] = DATA_T;
plhs[1] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_RESIDUALS,mxDOUBLE_CLASS, mxREAL);
h_Residuals_double = mxGetPr(plhs[1]);
NUMBER_OF_DIMENSIONS = 3;
int ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[3];
ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES[2] = DATA_D;
plhs[2] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_RESIDUAL_VARIANCES,mxDOUBLE_CLASS, mxREAL);
h_Residual_Variances_double = mxGetPr(plhs[2]);
NUMBER_OF_DIMENSIONS = 3;
int ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[3];
ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS[2] = DATA_D;
plhs[3] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_STATISTICAL_MAPS,mxDOUBLE_CLASS, mxREAL);
h_Statistical_Maps_double = mxGetPr(plhs[3]);
NUMBER_OF_DIMENSIONS = 3;
int ARRAY_DIMENSIONS_OUT_AR_ESTIMATES[3];
ARRAY_DIMENSIONS_OUT_AR_ESTIMATES[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_AR_ESTIMATES[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_AR_ESTIMATES[2] = DATA_D;
plhs[4] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_AR_ESTIMATES,mxDOUBLE_CLASS, mxREAL);
h_AR1_Estimates_double = mxGetPr(plhs[4]);
plhs[5] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_AR_ESTIMATES,mxDOUBLE_CLASS, mxREAL);
h_AR2_Estimates_double = mxGetPr(plhs[5]);
plhs[6] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_AR_ESTIMATES,mxDOUBLE_CLASS, mxREAL);
h_AR3_Estimates_double = mxGetPr(plhs[6]);
plhs[7] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_AR_ESTIMATES,mxDOUBLE_CLASS, mxREAL);
h_AR4_Estimates_double = mxGetPr(plhs[7]);
NUMBER_OF_DIMENSIONS = 3;
int ARRAY_DIMENSIONS_OUT_CLUSTER_INDICES[3];
ARRAY_DIMENSIONS_OUT_CLUSTER_INDICES[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_CLUSTER_INDICES[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_CLUSTER_INDICES[2] = DATA_D;
plhs[8] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_CLUSTER_INDICES,mxINT32_CLASS, mxREAL);
h_Cluster_Indices_Out = (int*)mxGetData(plhs[8]);
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_DETRENDED_VOLUMES[3];
ARRAY_DIMENSIONS_OUT_DETRENDED_VOLUMES[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_DETRENDED_VOLUMES[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_DETRENDED_VOLUMES[2] = DATA_D;
ARRAY_DIMENSIONS_OUT_DETRENDED_VOLUMES[3] = DATA_T;
plhs[9] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_DETRENDED_VOLUMES,mxDOUBLE_CLASS, mxREAL);
h_Detrended_fMRI_Volumes_double = mxGetPr(plhs[9]);
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_WHITENED_VOLUMES[3];
ARRAY_DIMENSIONS_OUT_WHITENED_VOLUMES[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_WHITENED_VOLUMES[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_WHITENED_VOLUMES[2] = DATA_D;
ARRAY_DIMENSIONS_OUT_WHITENED_VOLUMES[3] = DATA_T;
plhs[10] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_WHITENED_VOLUMES,mxDOUBLE_CLASS, mxREAL);
h_Whitened_fMRI_Volumes_double = mxGetPr(plhs[10]);
NUMBER_OF_DIMENSIONS = 4;
int ARRAY_DIMENSIONS_OUT_PERMUTED_VOLUMES[3];
ARRAY_DIMENSIONS_OUT_PERMUTED_VOLUMES[0] = DATA_H;
ARRAY_DIMENSIONS_OUT_PERMUTED_VOLUMES[1] = DATA_W;
ARRAY_DIMENSIONS_OUT_PERMUTED_VOLUMES[2] = DATA_D;
ARRAY_DIMENSIONS_OUT_PERMUTED_VOLUMES[3] = DATA_T;
plhs[11] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_PERMUTED_VOLUMES,mxDOUBLE_CLASS, mxREAL);
h_Permuted_fMRI_Volumes_double = mxGetPr(plhs[11]);
NUMBER_OF_DIMENSIONS = 2;
int ARRAY_DIMENSIONS_OUT_DISTRIBUTION[2];
ARRAY_DIMENSIONS_OUT_DISTRIBUTION[0] = NUMBER_OF_PERMUTATIONS;
ARRAY_DIMENSIONS_OUT_DISTRIBUTION[1] = 1;
plhs[12] = mxCreateNumericArray(NUMBER_OF_DIMENSIONS,ARRAY_DIMENSIONS_OUT_DISTRIBUTION,mxDOUBLE_CLASS, mxREAL);
h_Permutation_Distribution_double = mxGetPr(plhs[12]);
// ------------------------------------------------
// Allocate memory on the host
h_fMRI_Volumes = (float *)mxMalloc(DATA_SIZE);
h_EPI_Mask = (float *)mxMalloc(VOLUME_SIZE);
h_Smoothed_EPI_Mask = (float *)mxMalloc(VOLUME_SIZE);
h_X_GLM = (float *)mxMalloc(GLM_SIZE);
h_xtxxt_GLM = (float *)mxMalloc(GLM_SIZE);
h_Contrasts = (float *)mxMalloc(CONTRAST_SIZE);
h_ctxtxc_GLM = (float *)mxMalloc(CONTRAST_MATRIX_SIZE);
h_Beta_Volumes = (float *)mxMalloc(BETA_SIZE);
h_Residuals = (float *)mxMalloc(DATA_SIZE);
h_Residual_Variances = (float *)mxMalloc(VOLUME_SIZE);
h_Statistical_Maps = (float *)mxMalloc(STATISTICAL_MAPS_SIZE);
h_AR1_Estimates = (float *)mxMalloc(VOLUME_SIZE);
h_AR2_Estimates = (float *)mxMalloc(VOLUME_SIZE);
h_AR3_Estimates = (float *)mxMalloc(VOLUME_SIZE);
h_AR4_Estimates = (float *)mxMalloc(VOLUME_SIZE);
h_Cluster_Indices = (int *)mxMalloc(VOLUME_SIZE_INT);
h_Permutation_Distribution = (float *)mxMalloc(NULL_DISTRIBUTION_SIZE);
h_Detrended_fMRI_Volumes = (float *)mxMalloc(DATA_SIZE);
h_Whitened_fMRI_Volumes = (float *)mxMalloc(DATA_SIZE);
h_Permuted_fMRI_Volumes = (float *)mxMalloc(DATA_SIZE);
// Reorder and cast data
pack_double2float_volumes(h_fMRI_Volumes, h_fMRI_Volumes_double, DATA_W, DATA_H, DATA_D, DATA_T);
pack_double2float_volume(h_EPI_Mask, h_EPI_Mask_double, DATA_W, DATA_H, DATA_D);
pack_double2float_volume(h_Smoothed_EPI_Mask, h_Smoothed_EPI_Mask_double, DATA_W, DATA_H, DATA_D);
pack_double2float(h_X_GLM, h_X_GLM_double, NUMBER_OF_REGRESSORS * DATA_T);
pack_double2float(h_xtxxt_GLM, h_xtxxt_GLM_double, NUMBER_OF_REGRESSORS * DATA_T);
//pack_double2float(h_Contrasts, h_Contrasts_double, NUMBER_OF_REGRESSORS * NUMBER_OF_CONTRASTS);
pack_double2float_image(h_Contrasts, h_Contrasts_double, NUMBER_OF_REGRESSORS, NUMBER_OF_CONTRASTS);
pack_double2float(h_ctxtxc_GLM, h_ctxtxc_GLM_double, NUMBER_OF_CONTRASTS * NUMBER_OF_CONTRASTS);
//------------------------
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE);
// Something went wrong...
if (BROCCOLI.GetOpenCLInitiated() == 0)
{
int getPlatformIDsError = BROCCOLI.GetOpenCLPlatformIDsError();
int getDeviceIDsError = BROCCOLI.GetOpenCLDeviceIDsError();
int createContextError = BROCCOLI.GetOpenCLCreateContextError();
int getContextInfoError = BROCCOLI.GetOpenCLContextInfoError();
int createCommandQueueError = BROCCOLI.GetOpenCLCreateCommandQueueError();
int createProgramError = BROCCOLI.GetOpenCLCreateProgramError();
int buildProgramError = BROCCOLI.GetOpenCLBuildProgramError();
int getProgramBuildInfoError = BROCCOLI.GetOpenCLProgramBuildInfoError();
mexPrintf("Get platform IDs error is %d \n",getPlatformIDsError);
mexPrintf("Get device IDs error is %d \n",getDeviceIDsError);
mexPrintf("Create context error is %d \n",createContextError);
mexPrintf("Get create context info error is %d \n",getContextInfoError);
mexPrintf("Create command queue error is %d \n",createCommandQueueError);
mexPrintf("Create program error is %d \n",createProgramError);
mexPrintf("Build program error is %d \n",buildProgramError);
mexPrintf("Get program build info error is %d \n",getProgramBuildInfoError);
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
mexPrintf("Create kernel error %i is %d \n",i,createKernelErrors[i]);
}
}
mexPrintf("OPENCL initialization failed, aborting \n");
}
else if (BROCCOLI.GetOpenCLInitiated() == 1)
{
BROCCOLI.SetInputfMRIVolumes(h_fMRI_Volumes);
BROCCOLI.SetEPIWidth(DATA_W);
BROCCOLI.SetEPIHeight(DATA_H);
BROCCOLI.SetEPIDepth(DATA_D);
BROCCOLI.SetEPITimepoints(DATA_T);
BROCCOLI.SetEPIVoxelSizeX(EPI_VOXEL_SIZE_X);
BROCCOLI.SetEPIVoxelSizeY(EPI_VOXEL_SIZE_Y);
BROCCOLI.SetEPIVoxelSizeZ(EPI_VOXEL_SIZE_Z);
BROCCOLI.SetEPISmoothingAmount(EPI_SMOOTHING_AMOUNT);
BROCCOLI.SetARSmoothingAmount(AR_SMOOTHING_AMOUNT);
BROCCOLI.SetEPIMask(h_EPI_Mask);
BROCCOLI.SetSmoothedEPIMask(h_Smoothed_EPI_Mask);
BROCCOLI.SetNumberOfGLMRegressors(NUMBER_OF_REGRESSORS);
BROCCOLI.SetNumberOfContrasts(NUMBER_OF_CONTRASTS);
BROCCOLI.SetDesignMatrix(h_X_GLM, h_xtxxt_GLM);
BROCCOLI.SetContrasts(h_Contrasts);
BROCCOLI.SetGLMScalars(h_ctxtxc_GLM);
BROCCOLI.SetStatisticalTest(1); // F-test
BROCCOLI.SetInferenceMode(INFERENCE_MODE);
BROCCOLI.SetClusterDefiningThreshold(CLUSTER_DEFINING_THRESHOLD);
BROCCOLI.SetNumberOfPermutations(NUMBER_OF_PERMUTATIONS);
BROCCOLI.SetPermutationMatrix(h_Permutation_Matrix);
BROCCOLI.SetOutputBetaVolumes(h_Beta_Volumes);
BROCCOLI.SetOutputResiduals(h_Residuals);
BROCCOLI.SetOutputResidualVariances(h_Residual_Variances);
BROCCOLI.SetOutputStatisticalMaps(h_Statistical_Maps);
BROCCOLI.SetOutputAREstimates(h_AR1_Estimates, h_AR2_Estimates, h_AR3_Estimates, h_AR4_Estimates);
BROCCOLI.SetOutputClusterIndices(h_Cluster_Indices);
BROCCOLI.SetOutputPermutationDistribution(h_Permutation_Distribution);
BROCCOLI.SetOutputDetrendedfMRIVolumes(h_Detrended_fMRI_Volumes);
BROCCOLI.SetOutputWhitenedfMRIVolumes(h_Whitened_fMRI_Volumes);
BROCCOLI.SetOutputPermutedfMRIVolumes(h_Permuted_fMRI_Volumes);
BROCCOLI.PerformGLMFTestFirstLevelPermutationWrapper();
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
mexPrintf("Create buffer error %i is %d \n",i,createBufferErrors[i]);
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
mexPrintf("Run kernel error %i is %d \n",i,runKernelErrors[i]);
}
}
}
mexPrintf("Build info \n \n %s \n", BROCCOLI.GetOpenCLBuildInfoChar());
unpack_float2double_volumes(h_Beta_Volumes_double, h_Beta_Volumes, DATA_W, DATA_H, DATA_D, NUMBER_OF_TOTAL_GLM_REGRESSORS);
unpack_float2double_volumes(h_Residuals_double, h_Residuals, DATA_W, DATA_H, DATA_D, DATA_T);
unpack_float2double_volume(h_Residual_Variances_double, h_Residual_Variances, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_Statistical_Maps_double, h_Statistical_Maps, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_AR1_Estimates_double, h_AR1_Estimates, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_AR2_Estimates_double, h_AR2_Estimates, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_AR3_Estimates_double, h_AR3_Estimates, DATA_W, DATA_H, DATA_D);
unpack_float2double_volume(h_AR4_Estimates_double, h_AR4_Estimates, DATA_W, DATA_H, DATA_D);
unpack_int2int_volume(h_Cluster_Indices_Out, h_Cluster_Indices, DATA_W, DATA_H, DATA_D);
unpack_float2double(h_Permutation_Distribution_double, h_Permutation_Distribution, NUMBER_OF_PERMUTATIONS);
unpack_float2double_volumes(h_Detrended_fMRI_Volumes_double, h_Detrended_fMRI_Volumes, DATA_W, DATA_H, DATA_D, DATA_T);
unpack_float2double_volumes(h_Whitened_fMRI_Volumes_double, h_Whitened_fMRI_Volumes, DATA_W, DATA_H, DATA_D, DATA_T);
unpack_float2double_volumes(h_Permuted_fMRI_Volumes_double, h_Permuted_fMRI_Volumes, DATA_W, DATA_H, DATA_D, DATA_T);
// Free all the allocated memory on the host
mxFree(h_fMRI_Volumes);
mxFree(h_EPI_Mask);
mxFree(h_Smoothed_EPI_Mask);
mxFree(h_X_GLM);
mxFree(h_xtxxt_GLM);
mxFree(h_Contrasts);
mxFree(h_ctxtxc_GLM);
mxFree(h_Beta_Volumes);
mxFree(h_Residuals);
mxFree(h_Residual_Variances);
mxFree(h_Statistical_Maps);
mxFree(h_AR1_Estimates);
mxFree(h_AR2_Estimates);
mxFree(h_AR3_Estimates);
mxFree(h_AR4_Estimates);
mxFree(h_Cluster_Indices);
mxFree(h_Permutation_Distribution);
mxFree(h_Detrended_fMRI_Volumes);
mxFree(h_Whitened_fMRI_Volumes);
mxFree(h_Permuted_fMRI_Volumes);
return;
}
int main(int argc, char **argv)
{
// Default parameters
int OPENCL_PLATFORM = 0;
int OPENCL_DEVICE = 0;
bool FOUND_PLATFORM = false;
bool FOUND_DEVICE = false;
// No inputs, so print help text
if (argc == 1)
{
printf("Usage:\n\n");
printf("GetBandwidthPerformance -platform x -device y\n\n");
printf(" -platform The OpenCL platform to use \n");
printf(" -device The OpenCL device to use for the specificed platform \n");
printf("\n\n");
return EXIT_SUCCESS;
}
// Loop over additional inputs
int i = 1;
while (i < argc)
{
char *input = argv[i];
char *p;
if (strcmp(input,"-platform") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -platform !\n");
return EXIT_FAILURE;
}
OPENCL_PLATFORM = (int)strtol(argv[i+1], &p, 10);
FOUND_PLATFORM = true;
if (!isspace(*p) && *p != 0)
{
printf("OpenCL platform must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (OPENCL_PLATFORM < 0)
{
printf("OpenCL platform must be >= 0!\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-device") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -device !\n");
return EXIT_FAILURE;
}
OPENCL_DEVICE = (int)strtol(argv[i+1], &p, 10);
FOUND_DEVICE = true;
if (!isspace(*p) && *p != 0)
{
printf("OpenCL device must be an integer! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if (OPENCL_DEVICE < 0)
{
printf("OpenCL device must be >= 0!\n");
return EXIT_FAILURE;
}
i += 2;
}
else
{
printf("Unrecognized option! %s \n",argv[i]);
return EXIT_FAILURE;
}
}
if (!FOUND_PLATFORM)
{
printf("No OpenCL platform given, aborting!\n");
return EXIT_FAILURE;
}
if (!FOUND_DEVICE)
{
printf("No OpenCL device given, aborting!\n");
return EXIT_FAILURE;
}
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE,2,false); // 2 = Bash wrapper
BROCCOLI.GetBandwidth();
return EXIT_SUCCESS;
}
int main(int argc, char ** argv)
{
//-----------------------
// Input pointers
float *h_fMRI_Volumes = NULL;
float *h_Quadrature_Filter_1_Real = NULL;
float *h_Quadrature_Filter_2_Real = NULL;
float *h_Quadrature_Filter_3_Real = NULL;
float *h_Quadrature_Filter_1_Imag = NULL;
float *h_Quadrature_Filter_2_Imag = NULL;
float *h_Quadrature_Filter_3_Imag = NULL;
void *allMemoryPointers[500];
int numberOfMemoryPointers = 0;
// Default parameters
int MOTION_CORRECTION_FILTER_SIZE = 7;
int NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION = 5;
int OPENCL_PLATFORM = 2;
int OPENCL_DEVICE = 0;
int NUMBER_OF_MOTION_CORRECTION_PARAMETERS = 6;
bool DEBUG = false;
//bool DEBUG = true;
const char* FILENAME_EXTENSION = "_mc";
bool PRINT = true;
int DATA_W, DATA_H, DATA_D, DATA_T;
float EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z;
//-----------------------
// Output parameters
const char *outputFilename;
float *h_Quadrature_Filter_Response_1_Real = NULL;
float *h_Quadrature_Filter_Response_1_Imag = NULL;
float *h_Quadrature_Filter_Response_2_Real = NULL;
float *h_Quadrature_Filter_Response_2_Imag = NULL;
float *h_Quadrature_Filter_Response_3_Real = NULL;
float *h_Quadrature_Filter_Response_3_Imag = NULL;
float *h_Phase_Differences = NULL;
float *h_Phase_Certainties = NULL;
float *h_Phase_Gradients = NULL;
float *h_Motion_Corrected_fMRI_Volumes = NULL;
float *h_Motion_Parameters = NULL;
//---------------------
/* Input arguments */
FILE *fp = NULL;
// No inputs, so print help text
if (argc == 1)
{
printf("Usage:\n\n");
printf("MotionCorrection input.nii [options]\n\n");
printf("Options:\n\n");
printf("-platform The OpenCL platform to use (default 0) \n");
printf("-device The OpenCL device to use for the specificed platform (default 0) \n");
printf("-iterations Number of iterations for the motion correction algorithm (default 5) \n");
printf("-output Set output filename (default input_mc.nii) \n");
printf("-quiet Don't print anything to the terminal (default false) \n");
printf("-debug Get additional debug information (default no) \n");
printf("\n\n");
return 1;
}
// Try to open file
else if (argc > 1)
{
fp = fopen(argv[1],"r");
if (fp == NULL)
{
printf("Could not open file %s !\n",argv[1]);
return -1;
}
fclose(fp);
}
// Loop over additional inputs
int i = 2;
while (i < argc)
{
char *input = argv[i];
char *p;
if (strcmp(input,"-platform") == 0)
{
OPENCL_PLATFORM = (int)strtol(argv[i+1], &p, 10);
if (OPENCL_PLATFORM < 0)
{
printf("OpenCL platform must be >= 0!\n");
return -1;
}
i += 2;
}
else if (strcmp(input,"-device") == 0)
{
OPENCL_DEVICE = (int)strtol(argv[i+1], &p, 10);
if (OPENCL_DEVICE < 0)
{
printf("OpenCL device must be >= 0!\n");
return -1;
}
i += 2;
}
else if (strcmp(input,"-iterations") == 0)
{
NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION = (int)strtol(argv[i+1], &p, 10);
if (NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION <= 0)
{
printf("Number of iterations must be a positive number!\n");
return -1;
}
i += 2;
}
else if (strcmp(input,"-debug") == 0)
{
DEBUG = true;
i += 1;
}
else if (strcmp(input,"-quiet") == 0)
{
PRINT = false;
i += 1;
}
else if (strcmp(input,"-output") == 0)
{
outputFilename = argv[i+1];
i += 2;
}
else
{
printf("Unrecognized option! %s \n",argv[i]);
return -1;
}
}
// Read data
nifti_image *inputData = nifti_image_read(argv[1],1);
if (inputData == NULL)
{
printf("Could not open nifti file!\n");
return -1;
}
// Get data dimensions from input data
DATA_W = inputData->nx;
DATA_H = inputData->ny;
DATA_D = inputData->nz;
DATA_T = inputData->nt;
// Get voxel sizes from input data
EPI_VOXEL_SIZE_X = inputData->dx;
EPI_VOXEL_SIZE_Y = inputData->dy;
EPI_VOXEL_SIZE_Z = inputData->dz;
// Calculate size, in bytes
int DATA_SIZE = DATA_W * DATA_H * DATA_D * DATA_T * sizeof(float);
int MOTION_PARAMETERS_SIZE = NUMBER_OF_MOTION_CORRECTION_PARAMETERS * DATA_T * sizeof(float);
int FILTER_SIZE = MOTION_CORRECTION_FILTER_SIZE * MOTION_CORRECTION_FILTER_SIZE * MOTION_CORRECTION_FILTER_SIZE * sizeof(float);
int VOLUME_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
// Print some info
if (PRINT)
{
printf("Authored by K.A. Eklund \n");
printf("OpenCL Platform: %i OpenCL Device %i\n", OPENCL_PLATFORM, OPENCL_DEVICE);
printf("Data size: %i x %i x %i x %i \n", DATA_W, DATA_H, DATA_D, DATA_T);
printf("Voxel size: %f x %f x %f mm \n", EPI_VOXEL_SIZE_X, EPI_VOXEL_SIZE_Y, EPI_VOXEL_SIZE_Z);
printf("Number of iterations for motion correction: %i \n", NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION);
}
// ------------------------------------------------
// Allocate memory on the host
if (!AllocateMemory(h_fMRI_Volumes, DATA_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Motion_Corrected_fMRI_Volumes, DATA_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_1_Real, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_1_Imag, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_2_Real, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_2_Imag, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_3_Real, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_3_Imag, FILTER_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Motion_Parameters, MOTION_PARAMETERS_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (DEBUG)
{
if (!AllocateMemory(h_Quadrature_Filter_Response_1_Real, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_Response_1_Imag, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_Response_2_Real, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_Response_2_Imag, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_Response_3_Real, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Quadrature_Filter_Response_3_Imag, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Phase_Differences, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Phase_Certainties, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
if (!AllocateMemory(h_Phase_Gradients, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers))
{
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
}
// Convert data to floats
if ( inputData->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputData->data;
for (int i = 0; i < DATA_W * DATA_H * DATA_D * DATA_T; i++)
{
h_fMRI_Volumes[i] = (float)p[i];
}
}
else
{
printf("Unknown data type in input data, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
// Read quadrature filters, three real valued and three imaginary valued
fp = fopen("filter1_real_parametric_registration.bin","rb");
if (fp != NULL)
{
fread(h_Quadrature_Filter_1_Real,sizeof(float),MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,fp);
fclose(fp);
}
else
{
printf("Could not open filter1_real_parametric_registration.bin \n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
fp = fopen("filter1_imag_parametric_registration.bin","rb");
if (fp != NULL)
{
fread(h_Quadrature_Filter_1_Imag,sizeof(float),MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,fp);
fclose(fp);
}
else
{
printf("Could not open filter1_imag_parametric_registration.bin \n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
fp = fopen("filter2_real_parametric_registration.bin","rb");
if (fp != NULL)
{
fread(h_Quadrature_Filter_2_Real,sizeof(float),MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,fp);
fclose(fp);
}
else
{
printf("Could not open filter2_real_parametric_registration.bin \n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
fp = fopen("filter2_imag_parametric_registration.bin","rb");
if (fp != NULL)
{
fread(h_Quadrature_Filter_2_Imag,sizeof(float),MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,fp);
fclose(fp);
}
else
{
printf("Could not open filter2_imag_parametric_registration.bin \n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
fp = fopen("filter3_real_parametric_registration.bin","rb");
if (fp != NULL)
{
fread(h_Quadrature_Filter_3_Real,sizeof(float),MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,fp);
fclose(fp);
}
else
{
printf("Could not open filter3_real_parametric_registration.bin \n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
fp = fopen("filter3_imag_parametric_registration.bin","rb");
if (fp != NULL)
{
fread(h_Quadrature_Filter_3_Imag,sizeof(float),MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE*MOTION_CORRECTION_FILTER_SIZE,fp);
fclose(fp);
}
else
{
printf("Could not open filter3_imag_parametric_registration.bin \n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
//------------------------
BROCCOLI_LIB BROCCOLI(OPENCL_PLATFORM,OPENCL_DEVICE);
// Something went wrong...
if (BROCCOLI.GetOpenCLInitiated() == 0)
{
printf("Get platform IDs error is %d \n",BROCCOLI.GetOpenCLPlatformIDsError());
printf("Get device IDs error is %d \n",BROCCOLI.GetOpenCLDeviceIDsError());
printf("Create context error is %d \n",BROCCOLI.GetOpenCLCreateContextError());
printf("Get create context info error is %d \n",BROCCOLI.GetOpenCLContextInfoError());
printf("Create command queue error is %d \n",BROCCOLI.GetOpenCLCreateCommandQueueError());
printf("Create program error is %d \n",BROCCOLI.GetOpenCLCreateProgramError());
printf("Build program error is %d \n",BROCCOLI.GetOpenCLBuildProgramError());
printf("Get program build info error is %d \n",BROCCOLI.GetOpenCLProgramBuildInfoError());
// Print create kernel errors
int* createKernelErrors = BROCCOLI.GetOpenCLCreateKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createKernelErrors[i] != 0)
{
printf("Create kernel error %i is %d \n",i,createKernelErrors[i]);
}
}
// Print build info to file
fp = fopen("buildinfo.txt","w");
if (fp == NULL)
{
printf("Could not open buildinfo.txt! \n");
}
if (BROCCOLI.GetOpenCLBuildInfoChar() != NULL)
{
int error = fputs(BROCCOLI.GetOpenCLBuildInfoChar(),fp);
if (error == EOF)
{
printf("Could not write to buildinfo.txt! \n");
}
}
fclose(fp);
printf("OpenCL initialization failed, aborting! \nSee buildinfo.txt for output of OpenCL compilation!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return -1;
}
// Initialization OK
else if (BROCCOLI.GetOpenCLInitiated() == 1)
{
// Set all necessary pointers and values
BROCCOLI.SetInputfMRIVolumes(h_fMRI_Volumes);
BROCCOLI.SetEPIWidth(DATA_W);
BROCCOLI.SetEPIHeight(DATA_H);
BROCCOLI.SetEPIDepth(DATA_D);
BROCCOLI.SetEPITimepoints(DATA_T);
BROCCOLI.SetEPIVoxelSizeX(EPI_VOXEL_SIZE_X);
BROCCOLI.SetEPIVoxelSizeY(EPI_VOXEL_SIZE_Y);
BROCCOLI.SetEPIVoxelSizeZ(EPI_VOXEL_SIZE_Z);
BROCCOLI.SetImageRegistrationFilterSize(MOTION_CORRECTION_FILTER_SIZE);
BROCCOLI.SetParametricImageRegistrationFilters(h_Quadrature_Filter_1_Real, h_Quadrature_Filter_1_Imag, h_Quadrature_Filter_2_Real, h_Quadrature_Filter_2_Imag, h_Quadrature_Filter_3_Real, h_Quadrature_Filter_3_Imag);
BROCCOLI.SetNumberOfIterationsForMotionCorrection(NUMBER_OF_ITERATIONS_FOR_MOTION_CORRECTION);
BROCCOLI.SetOutputMotionCorrectedfMRIVolumes(h_Motion_Corrected_fMRI_Volumes);
BROCCOLI.SetOutputMotionParameters(h_Motion_Parameters);
if (DEBUG)
{
//BROCCOLI.SetOutputQuadratureFilterResponses(h_Quadrature_Filter_Response_1_Real, h_Quadrature_Filter_Response_1_Imag, h_Quadrature_Filter_Response_2_Real, h_Quadrature_Filter_Response_2_Imag, h_Quadrature_Filter_Response_3_Real, h_Quadrature_Filter_Response_3_Imag);
BROCCOLI.SetOutputPhaseDifferences(h_Phase_Differences);
BROCCOLI.SetOutputPhaseCertainties(h_Phase_Certainties);
BROCCOLI.SetOutputPhaseGradients(h_Phase_Gradients);
}
// Run the actual motion correction
BROCCOLI.PerformMotionCorrectionWrapper();
// Print create buffer errors
int* createBufferErrors = BROCCOLI.GetOpenCLCreateBufferErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (createBufferErrors[i] != 0)
{
printf("Create buffer error %i is %d \n",i,createBufferErrors[i]);
}
}
// Print run kernel errors
int* runKernelErrors = BROCCOLI.GetOpenCLRunKernelErrors();
for (int i = 0; i < BROCCOLI.GetNumberOfOpenCLKernels(); i++)
{
if (runKernelErrors[i] != 0)
{
printf("Run kernel error %i is %d \n",i,runKernelErrors[i]);
}
}
}
// Find max displacement
float maxDisplacement = 0.0f;
int maxVolume = 0;
for (int t = 1; t < DATA_T; t++)
{
float displacement = fabs(h_Motion_Parameters[t + 0*DATA_T]) + fabs(h_Motion_Parameters[t + 1*DATA_T]) + fabs(h_Motion_Parameters[t + 2*DATA_T]) + fabs(h_Motion_Parameters[t + 3*DATA_T]) + fabs(h_Motion_Parameters[t + 4*DATA_T]) + fabs(h_Motion_Parameters[t + 5*DATA_T]);
if (displacement > maxDisplacement)
{
maxDisplacement = displacement;
maxVolume = t;
}
}
if (PRINT)
{
printf("Max displacement = %f (mm) at volume %i \n",maxDisplacement,maxVolume);
}
// Print motion parameters to file
std::ofstream motion;
motion.open("motion.1D");
if ( motion.good() )
{
//motion.setf(ios::scientific);
motion.precision(6);
for (int t = 0; t < DATA_T; t++)
{
//printf("X translation for timepoint %i is %f\n",t+1,h_Motion_Parameters[t + DATA_T]);
//motion << h_Motion_Parameters[t + 0*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 1*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 2*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 3*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 4*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 5*DATA_T] << std::endl;
motion << h_Motion_Parameters[t + 4*DATA_T] << std::setw(2) << " " << -h_Motion_Parameters[t + 3*DATA_T] << std::setw(2) << " " << h_Motion_Parameters[t + 5*DATA_T] << std::setw(2) << " " << -h_Motion_Parameters[t + 2*DATA_T] << std::setw(2) << " " << -h_Motion_Parameters[t + 0*DATA_T] << std::setw(2) << " " << -h_Motion_Parameters[t + 1*DATA_T] << std::endl;
}
motion.close();
}
else
{
printf("Could not open motion.1D for writing!\n");
}
// Write motion corrected data to file
WriteNifti(inputData,h_Motion_Corrected_fMRI_Volumes,FILENAME_EXTENSION,ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
if (DEBUG)
{
WriteNifti(inputData,h_Phase_Differences,"_phase_differences",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Phase_Gradients,"_phase_gradients",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Phase_Certainties,"_phase_certainties",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_1_Real,"_quadrature_filter_responses_1_real",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_1_Imag,"_quadrature_filter_responses_1_imag",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_2_Real,"_quadrature_filter_responses_2_real",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_2_Imag,"_quadrature_filter_responses_2_imag",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_3_Real,"_quadrature_filter_responses_3_real",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
WriteNifti(inputData,h_Quadrature_Filter_Response_3_Imag,"_quadrature_filter_responses_3_imag",ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
// Free all memory
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
nifti_image_free(inputData);
return 1;
}
