void ReadBinaryFile(float* pointer, int size, const char* filename, void** pointers, int& Npointers, nifti_image** niftiImages, int Nimages)
{
if (pointer == NULL)
{
printf("The provided pointer for file %s is NULL, aborting! \n",filename);
FreeAllMemory(pointers,Npointers);
FreeAllNiftiImages(niftiImages,Nimages);
exit(EXIT_FAILURE);
}
FILE *fp = NULL;
fp = fopen(filename,"rb");
if (fp != NULL)
{
fread(pointer,sizeof(float),size,fp);
fclose(fp);
}
else
{
printf("Could not open %s , aborting! \n",filename);
FreeAllMemory(pointers,Npointers);
FreeAllNiftiImages(niftiImages,Nimages);
exit(EXIT_FAILURE);
}
}
void AllocateMemory(float *& pointer, int size, void** pointers, int& Npointers, nifti_image** niftiImages, int Nimages, const char* variable)
{
pointer = (float*)malloc(size);
if (pointer != NULL)
{
pointers[Npointers] = (void*)pointer;
Npointers++;
}
else
{
printf("Could not allocate host memory for variable %s ! \n",variable);
FreeAllMemory(pointers, Npointers);
FreeAllNiftiImages(niftiImages, Nimages);
exit(EXIT_FAILURE);
}
}
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;
}
MatchedBlockPair *FindBestSet (MatchedBlockPair *matches, int numMatches, MultipleAlignment *a1, MultipleAlignment *a2, ScoreData *s) {
Vector min, max = {0.0,0.0,0.0};
MemoryManagementInfo info = {0,0};
MatchedBlockPair **list = (MatchedBlockPair **) malloc(numMatches * sizeof(MatchedBlockPair *));
double displacementRange = s->displacement * 2;
int best = 0;
int i;
int pos;
OctTreeNode *trees = (OctTreeNode *) malloc(a2->numResidues * sizeof(OctTreeNode));
double maxBonus = MAX_BONUS;
double maxPosBonus = MAX_POS_BONUS;
if (!numMatches) return 0;
for (i=0; i<a1->numResidues; i++) {
/* Currently allow missing positions only in single-structure "alignments."
* May allow farther on or remove them altogether. Currently no benefit from
* not just removing residues with no alpha carbon coordinates.
*/
if (a1->numChains > 1 || a1->residues[0].res[i].exists) {
max = a1->averages[i++];
break;
}
}
min = max;
for (; i<a1->numResidues; i++) {
/* Safety check. */
if (a1->numChains == 1 && !a1->residues[0].res[i].exists) continue;
if (a1->averages[i].x < min.x) {
min.x = a1->averages[i].x;
}
else if (a1->averages[i].x > max.x) {
max.x = a1->averages[i].x;
}
if (a1->averages[i].y < min.y) {
min.y = a1->averages[i].y;
}
else if (a1->averages[i].y > max.y) {
max.y = a1->averages[i].y;
}
if (a1->averages[i].z < min.z) {
min.z = a1->averages[i].z;
}
else if (a1->averages[i].z > max.z) {
max.z = a1->averages[i].z;
}
}
for (i=0; i<a2->numResidues; i++) {
InitOctTreeNode(&trees[i], &min, &max);
}
for (i=0; i<numMatches; i++) {
Vector v, first;
MatchedBlockPair *match = &matches[i];
match->bestPreviousMatch = -1;
/* In this case, don't allow it to be added without a previous strand,
* unless it's the first strand.
*/
if (s->firstStrandLocked) {
if (i) {
match->bestAssembledScore = -5000;
}
else {
/* Otherwise, keep previous assembled score. Means I can
* just insert into old alignments without changing scores.
*/
match->bestAssembledScore -= match->score;
}
}
else
match->bestAssembledScore = 0;
transformVect(&first, &match->m, &a2->averages[match->p2]);
for (pos=4; pos<match->p2; pos++) {
int hits, j;
transformVect(&v, &match->m, &a2->averages[pos]);
hits = GetEntries((void**)list, &trees[pos], &v, displacementRange);
for (j=0; j < hits; j++) {
Vector v1, v2;
MatchedBlockPair *match2 = list[j];
double score, invCosHalfTest, angle, displacement;
if (match2->p1 + match2->len > match->p1) {
continue;
}
if (match2->p2 + match2->len > a2->conflictMap[match->p2][0]) {
if (match2->p2 + match2->len-1 == a2->conflictMap[match->p2][0] ||
a2->conflictMap[match->p2][match2->p2 + match2->len-1 - a2->conflictMap[match->p2][0]])
continue;
}
if (match2->p1 + match2->len > a1->conflictMap[match->p1][0]) {
if (match2->p1 + match2->len-1 == a1->conflictMap[match->p1][0] ||
a1->conflictMap[match->p1][match2->p1 + match2->len-1 - a1->conflictMap[match->p1][0]])
continue;
}
score = match2->bestAssembledScore;
if (score + maxBonus < match->bestAssembledScore) continue;
invCosHalfTest = invHalfCosQuat(&match->q, &match2->q);
if (invCosHalfTest < s->angleCos) continue;
angle = 0;
if (invCosHalfTest<1) angle = 2*acos(invCosHalfTest);
score += AngleScore(angle);
if (score + maxPosBonus < match->bestAssembledScore) continue;
subVect(&v1, &match2->last, &v);
transformVect(&v2, &match2->m, &a2->averages[match->p2]);
subVect(&v2, &first, &v2);
displacement = (lengthVect(&v1) + lengthVect(&v2))/2;
if (displacement > s->displacement) continue;
score += DisplacementScore(displacement);
if (score < match->bestAssembledScore) continue;
match->bestAssembledScore = (float) score;
match->bestPreviousMatch = (int)(match2 - matches);
}
}
if (match->bestAssembledScore < 0) continue;
match->bestAssembledScore += match->score;
if (match->bestAssembledScore > matches[best].bestAssembledScore)
best = i;
pos = match->p2 + match->len-1;
AddEntry(&trees[pos], &match->last, &info);
}
FreeAllMemory(&info);
free(trees);
free(list);
if (!s->lastStrandLocked)
return &matches[best];
else
return &matches[numMatches-1];
}
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_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_Volume = 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
const char* FILENAME_EXTENSION = "_roi";
bool PRINT = true;
bool VERBOS = false;
size_t DATA_W, DATA_H, DATA_D, DATA_T;
float VOXEL_SIZE_X, VOXEL_SIZE_Y, VOXEL_SIZE_Z;
bool CHANGE_OUTPUT_FILENAME = false;
// Settings
float RADIUS = 5.0f;
float RADIUSV = 5.0f;
float XCOORDINATE = 0.0f;
float YCOORDINATE = 0.0f;
float ZCOORDINATE = 0.0f;
float XCOORDINATEV = 0.0f;
float YCOORDINATEV = 0.0f;
float ZCOORDINATEV = 0.0f;
bool MMRADIUS = false;
bool VOXELSRADIUS = false;
bool MMCOORDINATE = false;
bool VOXELSCOORDINATE = false;
//-----------------------
// Output parameters
const char *outputFilename;
//---------------------
/* Input arguments */
FILE *fp = NULL;
// No inputs, so print help text
if (argc == 1)
{
printf("Usage:\n\n");
printf("MakeROI input.nii [options]\n\n");
printf("Options:\n\n");
printf(" -coordinate Center of ROI (x,y,z), in mm \n");
printf(" -coordinatev Center of ROI (x,y,z), in voxels \n");
printf(" -radius Radius of ROI, in millimeters \n");
printf(" -radiusv Radius of ROI, in voxels \n");
printf(" -output Set filename of nifti file \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,"-coordinate") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read first value after -coordinate !\n");
return EXIT_FAILURE;
}
if ( (i+2) >= argc )
{
printf("Unable to read second value after -coordinate !\n");
return EXIT_FAILURE;
}
if ( (i+3) >= argc )
{
printf("Unable to read third value after -coordinate !\n");
return EXIT_FAILURE;
}
MMCOORDINATE = true;
XCOORDINATE = (float)strtod(argv[i+1], &p);
YCOORDINATE = (float)strtod(argv[i+2], &p);
ZCOORDINATE = (float)strtod(argv[i+3], &p);
i += 4;
}
else if (strcmp(input,"-coordinatev") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read first value after -coordinatev !\n");
return EXIT_FAILURE;
}
if ( (i+2) >= argc )
{
printf("Unable to read second value after -coordinatev !\n");
return EXIT_FAILURE;
}
if ( (i+3) >= argc )
{
printf("Unable to read third value after -coordinatev !\n");
return EXIT_FAILURE;
}
VOXELSCOORDINATE = true;
XCOORDINATEV = (float)strtod(argv[i+1], &p);
YCOORDINATEV = (float)strtod(argv[i+2], &p);
ZCOORDINATEV = (float)strtod(argv[i+3], &p);
i += 4;
}
else if (strcmp(input,"-radius") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -radius !\n");
return EXIT_FAILURE;
}
RADIUS = (float)strtod(argv[i+1], &p);
MMRADIUS = true;
if (!isspace(*p) && *p != 0)
{
printf("Radius must be a float! You provided %s \n",argv[i+1]);
return EXIT_FAILURE;
}
else if ( RADIUS <= 0.0f )
{
printf("Radius must be > 0.0 !\n");
return EXIT_FAILURE;
}
i += 2;
}
else if (strcmp(input,"-radiusv") == 0)
{
if ( (i+1) >= argc )
{
printf("Unable to read value after -radiusv !\n");
return EXIT_FAILURE;
}
RADIUSV = (float)strtod(argv[i+1], &p);
VOXELSRADIUS = true;
if ( RADIUSV <= 0.0f )
{
printf("Radius must be > 0 !\n");
return EXIT_FAILURE;
}
i += 2;
}
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;
}
}
double startTime = GetWallTime();
if (!MMCOORDINATE && !VOXELSCOORDINATE)
{
printf("Have to define center in mm or in voxels!\n");
return EXIT_FAILURE;
}
if (MMCOORDINATE && VOXELSCOORDINATE)
{
printf("Cannot define center in both mm and in voxels!\n");
return EXIT_FAILURE;
}
if (!MMRADIUS && !VOXELSRADIUS)
{
printf("Have to define radius in mm or in voxels!\n");
return EXIT_FAILURE;
}
if (MMRADIUS && VOXELSRADIUS)
{
printf("Cannot define radius in both mm and in voxels!\n");
return EXIT_FAILURE;
}
// ---------------------
// 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
DATA_W = inputData->nx;
DATA_H = inputData->ny;
DATA_D = inputData->nz;
DATA_T = inputData->nt;
XCOORDINATE = (float)DATA_W - XCOORDINATE - 1.0f;
YCOORDINATE = (float)DATA_H - YCOORDINATE - 1.0f;
if (VOXELSCOORDINATE)
{
//XCOORDINATEV = (float)DATA_W - XCOORDINATE - 1.0f;
//YCOORDINATEV = (float)DATA_H - YCOORDINATE - 1.0f;
//ZCOORDINATE -= 1.0f;
}
// Get voxel sizes
VOXEL_SIZE_X = inputData->dx;
VOXEL_SIZE_Y = inputData->dy;
VOXEL_SIZE_Z = inputData->dz;
// Calculate size, in bytes
size_t DATA_SIZE = DATA_W * DATA_H * DATA_D * 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 \n", DATA_W, DATA_H, DATA_D);
printf("Voxel size: %f x %f x %f mm \n", VOXEL_SIZE_X, VOXEL_SIZE_Y, VOXEL_SIZE_Z);
}
// ------------------------------------------------
// Allocate memory on the host
startTime = GetWallTime();
AllocateMemory(h_Volume, DATA_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, allocatedHostMemory, "INPUT_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 (size_t i = 0; i < DATA_W * DATA_H * DATA_D; i++)
{
h_Volume[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; i++)
{
h_Volume[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; i++)
{
h_Volume[i] = (float)p[i];
}
}
// Correct data type, just copy the pointer
else if ( inputData->datatype == DT_FLOAT )
{
float *p = (float*)inputData->data;
for (size_t i = 0; i < DATA_W * DATA_H * DATA_D; i++)
{
h_Volume[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));
}
//------------------------
if (MMRADIUS)
{
for (int x = 0; x < DATA_W; x++)
{
for (int y = 0; y < DATA_H; y++)
{
for (int z = 0; z < DATA_D; z++)
{
float distance = sqrt( ((float) x - XCOORDINATE)*((float) x - XCOORDINATE)*VOXEL_SIZE_X*VOXEL_SIZE_X + ((float) y - YCOORDINATE)*((float) y - YCOORDINATE)*VOXEL_SIZE_Y*VOXEL_SIZE_Y + ((float) z - ZCOORDINATE)*((float) z - ZCOORDINATE)*VOXEL_SIZE_Z*VOXEL_SIZE_Z );
if ( distance <= RADIUS )
{
h_Volume[x + y * DATA_W + z * DATA_W * DATA_H] = 1.0f;
}
else
{
h_Volume[x + y * DATA_W + z * DATA_W * DATA_H] = 0.0f;
}
}
}
}
}
else if (VOXELSRADIUS)
{
for (int x = 0; x < DATA_W; x++)
{
for (int y = 0; y < DATA_H; y++)
{
for (int z = 0; z < DATA_D; z++)
{
float distance = sqrt( ((float) x - XCOORDINATE)*((float) x - XCOORDINATE) + ((float) y - YCOORDINATE)*((float) y - YCOORDINATE) + ((float) z - ZCOORDINATE)*((float) z - ZCOORDINATE) );
if ( distance <= RADIUSV )
{
h_Volume[x + y * DATA_W + z * DATA_W * DATA_H] = 1.0f;
}
else
{
h_Volume[x + y * DATA_W + z * DATA_W * DATA_H] = 0.0f;
}
}
}
}
}
//------------------------
// Write results to file
nifti_image *outputNifti = nifti_copy_nim_info(inputData);
outputNifti->nt = 1;
outputNifti->dim[0] = 3;
outputNifti->dim[4] = 1;
outputNifti->nvox = DATA_W * DATA_H * DATA_D;
allNiftiImages[numberOfNiftiImages] = outputNifti;
numberOfNiftiImages++;
startTime = GetWallTime();
if (!CHANGE_OUTPUT_FILENAME)
{
WriteNifti(outputNifti,h_Volume,FILENAME_EXTENSION,ADD_FILENAME,DONT_CHECK_EXISTING_FILE);
}
else
{
nifti_set_filenames(outputNifti, outputFilename, 0, 1);
WriteNifti(outputNifti,h_Volume,"",DONT_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_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;
}
int main(int argc, char **argv)
{
//-----------------------
// Input pointers
float *h_Volume;
void* allMemoryPointers[500];
int numberOfMemoryPointers = 0;
nifti_image* allNiftiImages[500];
int numberOfNiftiImages = 0;
int OPENCL_PLATFORM = 0;
int OPENCL_DEVICE = 0;
// Size parameters
int DATA_H, DATA_W, DATA_D;
float VOXEL_SIZE_X, VOXEL_SIZE_Y, VOXEL_SIZE_Z;
//---------------------
/* Input arguments */
FILE *fp = NULL;
// No inputs, so print help text
if (argc == 1)
{
printf("\nThe function renders a volume using direct volume rendering.\n\n");
printf("Usage:\n\n");
printf("RenderVolume volume.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(" -verbose Print extra stuff (default false) \n");
printf(" -debug Get additional debug information saved as nifti files (default no). Warning: This will use a lot of extra memory! \n");
printf("\n\n");
return EXIT_SUCCESS;
}
// 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);
}
// 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
{
printf("Unrecognized option! %s \n",argv[i]);
return EXIT_FAILURE;
}
}
// Read first volume
// -----------------------------------
nifti_image *inputVolume = nifti_image_read(argv[1],1);
if (inputVolume == NULL)
{
printf("Could not open volume to render!\n");
return EXIT_FAILURE;
}
allNiftiImages[numberOfNiftiImages] = inputVolume;
numberOfNiftiImages++;
// -----------------------------------
// Get data dimensions from input data
DATA_W = inputVolume->nx;
DATA_H = inputVolume->ny;
DATA_D = inputVolume->nz;
// Get voxel sizes from input data
VOXEL_SIZE_X = inputVolume->dx;
VOXEL_SIZE_Y = inputVolume->dy;
VOXEL_SIZE_Z = inputVolume->dz;
int VOLUME_SIZE = DATA_W * DATA_H * DATA_D * sizeof(float);
// Print some info
printf("Authored by K.A. Eklund \n");
printf("Volume size: %i x %i x %i \n", DATA_W, DATA_H, DATA_D);
printf("Volume voxel size: %f x %f x %f mm \n", VOXEL_SIZE_X, VOXEL_SIZE_Y, VOXEL_SIZE_Z);
// ------------------------------------------------
// Allocate memory on the host
AllocateMemory(h_Volume, VOLUME_SIZE, allMemoryPointers, numberOfMemoryPointers, allNiftiImages, numberOfNiftiImages, "INPUT_VOLUME");
// Convert data to floats
if ( inputVolume->datatype == DT_SIGNED_SHORT )
{
short int *p = (short int*)inputVolume->data;
for (int i = 0; i < DATA_W * DATA_H * DATA_D; i++)
{
h_Volume[i] = (float)p[i];
}
}
else if ( inputVolume->datatype == DT_UINT8 )
{
unsigned char *p = (unsigned char*)inputVolume->data;
for (int i = 0; i < DATA_W * DATA_H * DATA_D; i++)
{
h_Volume[i] = (float)p[i];
}
}
else if ( inputVolume->datatype == DT_FLOAT )
{
float *p = (float*)inputVolume->data;
for (int i = 0; i < DATA_W * DATA_H * DATA_D; i++)
{
h_Volume[i] = p[i];
}
}
else
{
printf("Unknown data type in input volume, aborting!\n");
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_FAILURE;
}
//------------------------
// First initialize OpenGL context, so we can properly setup the OpenGL / OpenCL interop.
InitGL(&argc, argv);
// Create OpenCL context, get device info, select device, select options for image/texture and CL-GL interop
//createCLContext(argc, (const char**)argv);
createCLContext(OPENCL_PLATFORM, OPENCL_DEVICE);
cl_int error;
// create a command-queue
cqCommandQueue = clCreateCommandQueue(cxGPUContext, cdDevices[uiDeviceUsed], 0, &ciErrNum);
//oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
//clGetDeviceInfo(cdDevices[uiDeviceUsed], CL_DEVICE_IMAGE_SUPPORT, sizeof(g_bImageSupport), &g_bImageSupport, NULL);
g_bImageSupport = true;
// Read the kernel code from file
std::fstream kernelFile("volumeRender.cl",std::ios::in);
std::ostringstream oss;
oss << kernelFile.rdbuf();
std::string src = oss.str();
const char *srcstr = src.c_str();
// Create program and build the code for the selected device
cpProgram = clCreateProgramWithSource(cxGPUContext, 1, (const char**)&srcstr, NULL, &error);
printf("Create program with source error is %i \n",error);
// build the program
std::string buildOpts = "-cl-fast-relaxed-math";
buildOpts += g_bImageSupport ? " -DIMAGE_SUPPORT" : "";
ciErrNum = clBuildProgram(cpProgram, 0, NULL, buildOpts.c_str(), NULL, NULL);
printf("Build program error is %i \n",error);
if (ciErrNum != CL_SUCCESS)
{
printf("Building failed!\n");
// write out standard error, Build Log and PTX, then cleanup and return error
//shrlogEx(LOGBOTH | ERRORMSG, ciErrNum, STDERROR);
//oclLogBuildInfo(cpProgram, oclGetFirstDev(cxGPUContext));
//oclLogPtx(cpProgram, oclGetFirstDev(cxGPUContext), "oclVolumeRender.ptx");
Cleanup(EXIT_FAILURE);
}
// create the kernel
ckKernel = clCreateKernel(cpProgram, "d_render", &error);
printf("Create kernel error is %i \n",error);
//oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
// Init OpenCL
initCLVolume(h_Volume, DATA_W, DATA_H, DATA_D);
// init timer 1 for fps measurement
//shrDeltaT(1);
// Create buffers and textures,
// and then start main GLUT rendering loop for processing and rendering,
// or otherwise run No-GL Q/A test sequence
initPixelBuffer();
glutMainLoop();
// Normally unused return path
Cleanup(EXIT_SUCCESS);
// Free all memory
FreeAllMemory(allMemoryPointers,numberOfMemoryPointers);
FreeAllNiftiImages(allNiftiImages,numberOfNiftiImages);
return EXIT_SUCCESS;
}
CLTALoadOnlyAlloc::~CLTALoadOnlyAlloc()
{
FreeAllMemory();
}
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;
}
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;
}
