nifti_image * generate_reference_image( const char * write_image_filename , int * const Errors)
{
nifti_1_header reference_header;
memset(&reference_header,0,sizeof(reference_header));
reference_header.sizeof_hdr=sizeof(reference_header);
reference_header.regular='r';
reference_header.extents=16384;
reference_header.dim[0]=5;
reference_header.dim[1]=23;
reference_header.dim[2]=17;
reference_header.dim[3]=11;
reference_header.dim[4]=7;
reference_header.dim[5]=3;
reference_header.dim[6]=1; //This MUST be 1 anything else is invalid due to code that usees huristics to fix other possible problems;
reference_header.dim[7]=1; //This MUST be 1 anything else is invalid due to code that usees huristics to fix other possible problems;
reference_header.intent_p1=10101010.101F;
reference_header.intent_p2=987654321.0F;
reference_header.intent_p3=-1234.0F;
reference_header.intent_code=NIFTI_INTENT_ESTIMATE;
reference_header.datatype=DT_INT32;
reference_header.pixdim[0]=-1.0F; /* this is really qfac */
reference_header.pixdim[1]=0.25F;
reference_header.pixdim[2]=0.5F;
reference_header.pixdim[3]=1.0F;
reference_header.pixdim[4]=2.0F;
reference_header.pixdim[5]=4.0F;
reference_header.pixdim[6]=-2.0e10F;
reference_header.pixdim[7]=-2.0e10F;
reference_header.vox_offset=0;
reference_header.scl_slope=0.25;
reference_header.scl_inter=128;
reference_header.qform_code=NIFTI_XFORM_SCANNER_ANAT;
reference_header.quatern_b=-0.5F;
reference_header.quatern_c= 0.5F;
reference_header.quatern_d=-0.5F;
reference_header.qoffset_x=reference_header.dim[1]/2.0F;
reference_header.qoffset_y=reference_header.dim[2]/2.0F;
reference_header.qoffset_z=reference_header.dim[3]/2.0F;
reference_header.sform_code=NIFTI_XFORM_SCANNER_ANAT;
reference_header.srow_x[0]=0.5;
reference_header.srow_x[1]=0.0;
reference_header.srow_x[2]=0.0;
reference_header.srow_x[3]=0.0;
reference_header.srow_y[0]=0.0;
reference_header.srow_y[1]=1.0;
reference_header.srow_y[2]=0.0;
reference_header.srow_y[3]=0.0;
reference_header.srow_z[0]=0.0;
reference_header.srow_z[1]=0.0;
reference_header.srow_z[2]=2.0;
reference_header.srow_z[3]=0.0;
reference_header.magic[0]='n';
reference_header.magic[1]='+';
reference_header.magic[2]='1';
reference_header.magic[3]='\0';
/* String is purposfully too long */
strncpy(reference_header.intent_name,"PHANTOM_DATA to be used for regression testing the nifti reader/writer",16);
strncpy(reference_header.descrip,"This is a very long dialog here to use up more than 80 characters of space to test to see if the code is robust enough to deal appropriatly with very long and obnoxious lines.",80);
{
int nbyper;
int swapsize;
nifti_datatype_sizes(reference_header.datatype ,&nbyper,&swapsize);
reference_header.bitpix=nbyper*8;
}
nifti_image * reference_image=nifti_convert_nhdr2nim(reference_header,write_image_filename);
{
const unsigned int NumVoxels=reference_image->nx*reference_image->ny*reference_image->nz*reference_image->nt*reference_image->nu;
reference_image->data=(signed int *)calloc(NumVoxels,sizeof(signed int)) ; /*!< pointer to data: nbyper*nvox bytes */
PrintTest("Checking memory allocation",reference_image->data ==0 ,NIFTITEST_TRUE,Errors);
{
signed int i=0;
for(; i < (signed int)NumVoxels ; i++)
{
((signed int *)(reference_image->data))[i]=i;
}
}
}
PrintTest("Setting filenames",nifti_set_filenames( reference_image,write_image_filename, 0, 0 ) != 0, NIFTITEST_TRUE,Errors);
PrintTest("Setting type from names",nifti_set_type_from_names( reference_image ) != 0, NIFTITEST_TRUE,Errors);
/* PrintTest("Checking type and names",nifti_type_and_names_match( reference_image , 1 ) != 1, NIFTITEST_TRUE,Errors); */
PrintTest("Check reference_image data is non null",(reference_image->data==0),NIFTITEST_TRUE,Errors);
return reference_image;
}
// "writeImage()": writes a 3D image
void niftiManager::writeImage( const std::string& imageFilename, const ValueType dataValueType, const std::vector<std::vector<std::vector<float> > >& image, bool doZip ) const
{
if (image.empty())
{
std::cerr<< "ERROR @ niftiManager::writeImage(): image matrix is empty, image has not been written" <<std::endl;
return;
}
const size_t dimx = image.size();
const size_t dimy = image[0].size();
const size_t dimz = image[0][0].size();
nifti_1_header imageHeader;
imageHeader.sizeof_hdr = 0;
if(m_header.sizeof_hdr != 0)
{
imageHeader = m_header;
}
generateHeader( dimx, dimy, dimz, dataValueType, &imageHeader);
nifti_image* niftiImage = nifti_convert_nhdr2nim( imageHeader, NULL);
const size_t repByteSize( niftiImage->nbyper );
const size_t dataSize( niftiImage->nvox );
const size_t repType( niftiImage->datatype );
if ( dataSize != (dimx*dimy*dimz) )
{
throw std::runtime_error( "niftiManager::writeImage(): image header nvox and matrix size do not match" );
}
if ( repType != imageHeader.datatype )
{
throw std::runtime_error( "niftiManager::writeImage(): created header datatype and input argument dont match" );
}
if(niftiImage->data != NULL)
{
throw std::runtime_error( "niftiManager::writeVector(): nifti_convert_nhdr2nim had already allocated memory" );
}
niftiImage->data = malloc (dataSize * repByteSize);
for (int i=0 ; i<dimz ; ++i)
{
for (int j=0 ; j<dimy ; ++j)
{
for (int k=0 ; k<dimx ; ++k)
{
size_t voxOffset( (i*dimy*dimx) + (j*dimx) + k );
if( voxOffset >= dataSize )
{
throw std::runtime_error( "ERROR @ niftiManager::writeImage():: pointer offset was too high when loading nifti data");
}
size_t byteOffset( voxOffset * repByteSize );
void* dataPos = static_cast<unsigned char*>(niftiImage->data) + byteOffset;
if (repType == DT_UINT8)
{
unsigned char datapoint = (unsigned char)image[k][j][i];
*(static_cast<unsigned char*>(dataPos)) = datapoint;
}
else if (repType == DT_FLOAT32)
{
float datapoint = image[k][j][i];
*(static_cast<float*>(dataPos)) = datapoint;
}
else
{
throw std::runtime_error("ERROR @ niftiManager::writeImage(): image representation type not recognized (neither UINT8 nor FLOAT32)");
}
}
}
}
if( nifti_set_filenames(niftiImage, imageFilename.c_str(), 0, 1) )
{
std::stringstream errormessage;
errormessage << "ERROR @ niftiManager::writeImage(): there was an error calling nifti_set_filenames() on output image file "<< imageFilename <<std::endl;
throw std::runtime_error( errormessage.str() );
}
boost::mutex& ioMutex(boost::detail::thread::singleton<boost::mutex>::instance()) ;
ioMutex.lock();
{
nifti_image_write( niftiImage );
}
ioMutex.unlock();
// clean up
nifti_image_free( niftiImage );
if (doZip)
{ // zip file
// Variables for calling system commands
std::string gzipString("gzip -f ");
std::string sysCommand(gzipString + imageFilename);
int success(system(sysCommand.c_str()));
}
return;
}// end niftiManager::writeImage() -----------------------------------------------------------------
