MNCAPI int minc_format_convert(const char *input,const char *output)
{
int old_fd;
int new_fd;
int flags;
struct mi2opts opts;
old_fd = miopen((char *)input, NC_NOWRITE);
if (old_fd < 0) {
perror(input);
return MI_ERROR;
}
flags = NC_CLOBBER|MI2_CREATE_V2;
memset(&opts,0,sizeof(struct mi2opts));
opts.struct_version = MI2_OPTS_V1;
new_fd = micreatex((char *)output, flags, &opts);
if (new_fd < 0) {
perror(output);
exit MI_ERROR;
}
micopy(old_fd, new_fd);
miclose(old_fd);
miclose(new_fd);
return MI_NOERROR;
}
/* Test MINC API's
*/
int
main(int argc, char **argv)
{
int stat;
struct testinfo info;
milog_init("mincapi"); /* Disable error messages completely. */
milog_set_verbosity(0);
ncopts &= ~(NC_FATAL | NC_VERBOSE);
test1(&info, dimtab1, 3);
test2(&info, dimtab1, 3);
test3(&info, dimtab1, 3);
test4(&info, dimtab1, 3);
test5(&info, dimtab1, 3);
/* test6(&info, dimtab1, 3); */
test7(&info, dimtab1, 3);
stat = miicv_free(rand());
if (stat >= 0) {
FUNC_ERROR("miicv_free");
}
if (miclose(info.fd) != MI_NOERROR) {
FUNC_ERROR("miclose");
}
if (miclose(info.fd) != MI_ERROR) {
FUNC_ERROR("miclose");
}
if (miclose(rand()) != MI_ERROR) {
FUNC_ERROR("miclose");
}
unlink(info.name); /* Delete the temporary file. */
free(info.name); /* Free the temporary filename */
icv_tests();
fprintf(stderr, "**** Tests completed with ");
if (errors == 0) {
fprintf(stderr, "no errors\n");
}
else {
fprintf(stderr, "%ld error%s\n", errors, (errors == 1) ? "" : "s");
}
return (errors);
}
int main()
{
int cdf, cdf2;
int img;
int dim[MAX_VAR_DIMS];
int dim2[MAX_VAR_DIMS];
long start[MAX_VAR_DIMS];
long count[MAX_VAR_DIMS];
double image[256*256];
int i, j, k, ioff;
char filename[256];
char filename2[256];
set_ncopts(NC_VERBOSE|NC_FATAL);
snprintf(filename, sizeof(filename), "test_minc-%d.mnc", getpid());
snprintf(filename2, sizeof(filename2), "test_minc2-%d.mnc", getpid());
cdf=micreate(filename, NC_CLOBBER);
count[2]=5;
count[1]=3;
count[0]=7;
dim[2]=ncdimdef(cdf, MIzspace, count[2]);
dim[1]=ncdimdef(cdf, MIxspace, count[1]);
dim[0]=ncdimdef(cdf, MIyspace, count[0]);
dim2[0]=ncdimdef(cdf, MItime, NC_UNLIMITED);
dim2[1]=dim[0];
dim2[2]=dim[1];
img=ncvardef(cdf, MIimage, NC_SHORT, 3, dim);
(void) ncvardef(cdf, "testvar", NC_FLOAT, 2, dim2);
(void) miattputstr(cdf, img, MIsigntype, MI_SIGNED);
for (j=0; j<count[0]; j++) {
for (i=0; i<count[1]; i++) {
ioff=(j*count[1]+i)*count[2];
for (k=0; k<count[2]; k++)
image[ioff+k]=ioff+k+10;
}
}
cdf2=micreate(filename2,NC_CLOBBER);
(void) ncdimdef(cdf2, "junkdim", NC_UNLIMITED);
(void) micopy_all_var_defs(cdf, cdf2, 1, &img);
(void) ncendef(cdf2);
(void) ncendef(cdf);
(void) miset_coords(3,0L,start);
(void) mivarput(cdf, img, start, count, NC_DOUBLE, NULL, image);
(void) micopy_all_var_values(cdf, cdf2, 1, &img);
(void) miclose(cdf2);
(void) miclose(cdf);
unlink(filename);
unlink(filename2);
return(0);
}
MNCAPI int
minc_save_done(int fd)
{
miattputstr(fd, ncvarid(fd, MIimage), MIcomplete, MI_TRUE);
miclose(fd);
return (MINC_STATUS_OK);
}
/* Test MINC API's
*/
int main(int argc, char **argv)
{
struct testinfo info;
if(argc>1)
info.attribute_size=atoi(argv[1]);
else
info.attribute_size=100000;
printf("Running test with attribute size=%d\n",info.attribute_size);
test1(&info, dimtab1, 3);
test2(&info, dimtab1, 3);
test3(&info, dimtab1, 3);
if (miclose(info.fd) != MI_NOERROR) {
FUNC_ERROR("miclose");
}
unlink(info.name); /* Delete the temporary file. */
free(info.name); /* Free the temporary filename */
return (errors);
}
/* get info from a model file (steps, starts, etc */
int get_model_file_info(char *dst, char *key, char *nextArg)
{
int mincid;
char *fname;
/* Get pointer to volume definition structure */
Volume_Definition *vd = (Volume_Definition *) dst;
/* Check for following argument */
if(nextArg == NULL){
(void)fprintf(stderr, "\"%s\" option requires an additional argument\n", key);
exit(EXIT_FAILURE);
}
fname = nextArg;
/* check that the file exists */
if(!file_exists(fname)){
fprintf(stderr, "Couldn't find -like file %s.\n\n", fname);
exit(EXIT_FAILURE);
}
/* get volume definition from input filename */
mincid = miopen(fname, NC_NOWRITE);
get_vol_def(mincid, vd);
/* Close the file */
miclose(mincid);
return TRUE;
}
/* ----------------------------- MNI Header -----------------------------------
@NAME : close_volume
@INPUT : icvid - id of open icv
@OUTPUT : (none)
@RETURNS : (nothing)
@DESCRIPTION: Routine to close a minc file and free the associated icv
@METHOD :
@GLOBALS :
@CALLS :
@CREATED : March 16, 1994 (Peter Neelin)
@MODIFIED :
---------------------------------------------------------------------------- */
static void close_volume(int icvid)
{
int mincid;
/* Get the minc file id and close the file */
ncopts = 0;
if (miicv_inqint(icvid, MI_ICV_CDFID, &mincid) != MI_ERROR) {
(void) miclose(mincid);
}
ncopts = NC_OPTS_VAL;
/* Free the icv */
(void) miicv_free(icvid);
}
int main(int argc, char **argv)
{
int cdf;
int img, img2;
int dim[MAX_VAR_DIMS];
long start[MAX_VAR_DIMS];
long count[MAX_VAR_DIMS];
double image[256*256];
int i, itype, jtype;
int cflag = 0;
char filename[256];
#if MINC2
if (argc == 2 && !strcmp(argv[1], "-2")) {
cflag = MI2_CREATE_V2;
}
#endif /* MINC2 */
snprintf(filename, sizeof(filename), "test_minc_types-%d.mnc", getpid());
ncopts=NC_VERBOSE|NC_FATAL;
for (itype=0; itype<ntypes; itype++) {
for (jtype=0; jtype<ntypes; jtype++) {
cdf=micreate(filename, NC_CLOBBER | cflag);
count[2]=256;
count[1]=20;
count[0]=7;
dim[2]=ncdimdef(cdf, MIzspace, count[2]);
dim[1]=ncdimdef(cdf, MIxspace, count[1]);
dim[0]=ncdimdef(cdf, MIyspace, count[0]);
img=ncvardef(cdf, MIimage, types[itype].type, 1, dim);
(void) miattputstr(cdf, img, MIsigntype, types[itype].sign);
img2=ncvardef(cdf, "image2", types[jtype].type, 1, dim);
(void) miattputstr(cdf, img2, MIsigntype, types[jtype].sign);
image[0]=10.0;
image[1]=2.0*(-FLT_MAX);
image[2]=2.0*FLT_MAX;
image[3]=3.2;
image[4]=3.7;
image[5]=(-3.2);
image[6]=(-3.7);
#if 0
for (j=0; j<count[0]; j++) {
for (i=0; i<count[1]; i++) {
ioff=(j*count[1]+i)*count[2];
for (k=0; k<count[2]; k++)
image[ioff+k]=ioff+k+10;
}
}
#endif
(void) ncendef(cdf);
(void) miset_coords(3,0L,start);
(void) mivarput(cdf, img, start, count, NC_DOUBLE, NULL, image);
(void) mivarget(cdf, img, start, count, types[jtype].type,
types[jtype].sign, image);
(void) mivarput(cdf, img2, start, count, types[jtype].type,
types[jtype].sign, image);
(void) mivarget(cdf, img2, start, count, NC_DOUBLE, NULL, image);
(void) printf("Image 1 : %s %s\n",types[itype].sign,
types[itype].ctype);
(void) printf("Image 2 : %s %s\n",types[jtype].sign,
types[jtype].ctype);
for (i=0;i<count[0];i++)
(void) printf(" image[%d] = %g\n",(int) i, image[i]);
(void) miclose(cdf);
}
}
unlink(filename);
return(0);
}
int main(int argc, char **argv)
{
int icv, cdfid, img, max, min, dimvar;
static int dim[MAX_VAR_DIMS];
static struct { long len; char *name;} diminfo[] = {
{ 7, MIzspace },
{ 9, MIyspace },
{ 2, MIxspace }
};
/* static struct { long len; char *name;} diminfo[]=
{3, MIzspace, 4, MIyspace, 5, MIxspace}; */
static int numdims=sizeof(diminfo)/sizeof(diminfo[0]);
static long coord[]={0,0,0};
static long count[]={3,4,5};
double dvalue;
short int ivalue[]={
111, 113, 115, 117, 119,
121, 123, 125, 127, 129,
131, 133, 135, 137, 139,
141, 143, 145, 147, 149,
211, 213, 215, 217, 219,
221, 223, 225, 227, 229,
231, 233, 235, 237, 239,
241, 243, 245, 247, 249,
311, 313, 315, 317, 319,
321, 323, 325, 327, 329,
331, 333, 335, 337, 339,
341, 343, 345, 347, 349
};
int i, j, k;
int cflag = 0;
#if MINC2
if (argc == 2 && !strcmp(argv[1], "-2")) {
cflag = MI2_CREATE_V2;
}
#endif /* MINC2 */
icv=miicv_create();
miicv_setint(icv, MI_ICV_XDIM_DIR, MI_ICV_NEGATIVE);
miicv_setint(icv, MI_ICV_YDIM_DIR, MI_ICV_NEGATIVE);
miicv_setint(icv, MI_ICV_ZDIM_DIR, MI_ICV_NEGATIVE);
miicv_setint(icv, MI_ICV_NUM_IMGDIMS, 3);
miicv_setint(icv, MI_ICV_DIM_SIZE+0, 5);
miicv_setint(icv, MI_ICV_DIM_SIZE+1, 4);
miicv_setint(icv, MI_ICV_DIM_SIZE+2, 3);
miicv_setint(icv, MI_ICV_DO_DIM_CONV, TRUE);
miicv_setint(icv, MI_ICV_KEEP_ASPECT, FALSE);
miicv_setint(icv, MI_ICV_DO_NORM, TRUE);
cdfid=micreate("test.mnc", NC_CLOBBER | cflag);
for (i=0; i<numdims; i++) {
dim[i]=ncdimdef(cdfid, diminfo[i].name, diminfo[i].len);
dimvar=micreate_std_variable(cdfid, diminfo[i].name, NC_DOUBLE,
0, &dim[i]);
miattputdbl(cdfid, dimvar, MIstep, 0.8);
miattputdbl(cdfid, dimvar, MIstart, 22.0);
}
img=micreate_std_variable(cdfid, MIimage, NC_SHORT,
numdims, dim);
max=micreate_std_variable(cdfid, MIimagemax, NC_DOUBLE, 1, dim);
min=micreate_std_variable(cdfid, MIimagemin, NC_DOUBLE, 1, dim);
ncendef(cdfid);
for (i=0; i<diminfo[0].len; i++) {
dvalue = 200;
coord[0]=i;
ncvarput1(cdfid, max, coord, &dvalue);
dvalue = -dvalue;
ncvarput1(cdfid, min, coord, &dvalue);
}
coord[0]=0;
miicv_attach(icv, cdfid, img);
miicv_inqdbl(icv, MI_ICV_ADIM_START, &dvalue);
printf("adim start = %g", dvalue);
miicv_inqdbl(icv, MI_ICV_ADIM_STEP, &dvalue);
printf(", step = %g\n", dvalue);
miicv_inqdbl(icv, MI_ICV_BDIM_START, &dvalue);
printf("bdim start = %g", dvalue);
miicv_inqdbl(icv, MI_ICV_BDIM_STEP, &dvalue);
printf(", step = %g\n", dvalue);
miicv_inqdbl(icv, MI_ICV_NORM_MAX, &dvalue);
printf("norm : max = %g", dvalue);
miicv_inqdbl(icv, MI_ICV_NORM_MIN, &dvalue);
printf(", min = %g\n", dvalue);
miicv_put(icv, coord, count, ivalue);
miicv_get(icv, coord, count, ivalue);
for (i=0; i<3; i++) {
for (j=0; j<4; j++) {
for (k=0; k<5; k++) {
printf("%5d",ivalue[i*20+j*5+k]);
}
printf("\n");
}
}
miclose(cdfid);
miicv_free(icv);
return 0;
}
int
main(int argc, char **argv)
{
/* NIFTI stuff */
nifti_image *nii_ptr;
nifti_image nii_rec;
int nii_dimids[MAX_NII_DIMS];
int nii_dir[MAX_NII_DIMS];
int nii_map[MAX_NII_DIMS];
unsigned long nii_lens[MAX_NII_DIMS];
int nii_ndims;
static int nifti_filetype;
static int nifti_datatype;
static int nifti_signed = 1;
/* MINC stuff */
int mnc_fd; /* MINC file descriptor */
nc_type mnc_type; /* MINC data type as read */
int mnc_ndims; /* MINC image dimension count */
int mnc_dimids[MAX_VAR_DIMS]; /* MINC image dimension identifiers */
long mnc_dlen; /* MINC dimension length value */
double mnc_dstep; /* MINC dimension step value */
int mnc_icv; /* MINC image conversion variable */
int mnc_vid; /* MINC Image variable ID */
long mnc_start[MAX_VAR_DIMS]; /* MINC data starts */
long mnc_count[MAX_VAR_DIMS]; /* MINC data counts */
int mnc_signed; /* MINC if output voxels are signed */
double real_range[2]; /* MINC real range (min, max) */
double input_valid_range[2]; /* MINC valid range (min, max) */
double output_valid_range[2]; /* Valid range of output data. */
double nifti_slope; /* Slope to be applied to output voxels. */
double nifti_inter; /* Intercept to be applied to output voxels. */
double total_valid_range; /* Overall valid range (max - min). */
double total_real_range; /* Overall real range (max - min). */
/* Other stuff */
char out_str[1024]; /* Big string for filename */
char att_str[1024]; /* Big string for attribute values */
int i; /* Generic loop counter the first */
int j; /* Generic loop counter the second */
char *str_ptr; /* Generic ASCIZ string pointer */
int r; /* Result code. */
static int vflag = 0; /* Verbose flag (default is quiet) */
static ArgvInfo argTable[] = {
{NULL, ARGV_HELP, NULL, NULL,
"Output voxel data type specification"},
{"-byte", ARGV_CONSTANT, (char *)DT_INT8, (char *)&nifti_datatype,
"Write voxel data in 8-bit signed integer format."},
{"-short", ARGV_CONSTANT, (char *)DT_INT16, (char *)&nifti_datatype,
"Write voxel data in 16-bit signed integer format."},
{"-int", ARGV_CONSTANT, (char *)DT_INT32, (char *)&nifti_datatype,
"Write voxel data in 32-bit signed integer format."},
{"-float", ARGV_CONSTANT, (char *)DT_FLOAT32, (char *)&nifti_datatype,
"Write voxel data in 32-bit floating point format."},
{"-double", ARGV_CONSTANT, (char *)DT_FLOAT64, (char *)&nifti_datatype,
"Write voxel data in 64-bit floating point format."},
{"-signed", ARGV_CONSTANT, (char *)1, (char *)&nifti_signed,
"Write integer voxel data in signed format."},
{"-unsigned", ARGV_CONSTANT, (char *)0, (char *)&nifti_signed,
"Write integer voxel data in unsigned format."},
{NULL, ARGV_HELP, NULL, NULL,
"Output file format specification"},
{"-dual", ARGV_CONSTANT, (char *)FT_NIFTI_DUAL,
(char *)&nifti_filetype,
"Write NIfTI-1 two-file format (.img and .hdr)"},
{"-ASCII", ARGV_CONSTANT, (char *)FT_NIFTI_ASCII,
(char *)&nifti_filetype,
"Write NIfTI-1 ASCII header format (.nia)"},
{"-nii", ARGV_CONSTANT, (char *)FT_NIFTI_SINGLE,
(char *)&nifti_filetype,
"Write NIfTI-1 one-file format (.nii)"},
{"-analyze", ARGV_CONSTANT, (char *)FT_ANALYZE,
(char *)&nifti_filetype,
"Write an Analyze two-file format file (.img and .hdr)"},
{NULL, ARGV_HELP, NULL, NULL,
"Other options"},
{"-quiet", ARGV_CONSTANT, (char *)0,
(char *)&vflag,
"Quiet operation"},
{"-verbose", ARGV_CONSTANT, (char *)1,
(char *)&vflag,
"Quiet operation"},
{NULL, ARGV_END, NULL, NULL, NULL}
};
ncopts = 0; /* Clear global netCDF error reporting flag */
/* Default NIfTI file type is "NII", single binary file
*/
nifti_filetype = FT_UNSPECIFIED;
nifti_datatype = DT_UNKNOWN;
if (ParseArgv(&argc, argv, argTable, 0) || (argc < 2)) {
fprintf(stderr, "Too few arguments\n");
return usage();
}
if (!nifti_signed) {
switch (nifti_datatype) {
case DT_INT8:
nifti_datatype = DT_UINT8;
break;
case DT_INT16:
nifti_datatype = DT_UINT16;
break;
case DT_INT32:
nifti_datatype = DT_UINT32;
break;
}
}
switch (nifti_datatype){
case DT_INT8:
case DT_UINT8:
mnc_type = NC_BYTE;
break;
case DT_INT16:
case DT_UINT16:
mnc_type = NC_SHORT;
break;
case DT_INT32:
case DT_UINT32:
mnc_type = NC_INT;
break;
case DT_FLOAT32:
mnc_type = NC_FLOAT;
break;
case DT_FLOAT64:
mnc_type = NC_DOUBLE;
break;
}
if (argc == 2) {
strcpy(out_str, argv[1]);
str_ptr = strrchr(out_str, '.');
if (str_ptr != NULL && !strcmp(str_ptr, ".mnc")) {
*str_ptr = '\0';
}
}
else if (argc == 3) {
strcpy(out_str, argv[2]);
str_ptr = strrchr(out_str, '.');
if (str_ptr != NULL) {
/* See if a recognized file extension was specified. If so,
* we trim it off and set the output file type if none was
* specified. If the extension is not recognized, assume
* that we will form the filename by just adding the right
* extension for the selected output format.
*/
if (!strcmp(str_ptr, ".nii")) {
if (nifti_filetype == FT_UNSPECIFIED) {
nifti_filetype = FT_NIFTI_SINGLE;
}
*str_ptr = '\0';
}
else if (!strcmp(str_ptr, ".img") ||
!strcmp(str_ptr, ".hdr")) {
if (nifti_filetype == FT_UNSPECIFIED) {
nifti_filetype = FT_NIFTI_DUAL;
}
*str_ptr = '\0';
}
else if (!strcmp(str_ptr, ".nia")) {
if (nifti_filetype == FT_UNSPECIFIED) {
nifti_filetype = FT_NIFTI_ASCII;
}
*str_ptr = '\0';
}
}
}
else {
fprintf(stderr, "Filename argument required\n");
return usage();
}
/* Open the MINC file. It needs to exist.
*/
mnc_fd = miopen(argv[1], NC_NOWRITE);
if (mnc_fd < 0) {
fprintf(stderr, "Can't find input file '%s'\n", argv[1]);
return (-1);
}
/* Find the MINC image variable. If we can't find it, there is no
* further processing possible...
*/
mnc_vid = ncvarid(mnc_fd, MIimage);
if (mnc_vid < 0) {
fprintf(stderr, "Can't locate the image variable (mnc_vid=%d)\n", mnc_vid);
return (-1);
}
/* Find out about the MINC image variable - specifically, how many
* dimensions, and which dimensions.
*/
r = ncvarinq(mnc_fd, mnc_vid, NULL, NULL, &mnc_ndims, mnc_dimids, NULL);
if (r < 0) {
fprintf(stderr, "Can't read information from image variable\n");
return (-1);
}
if (mnc_ndims > MAX_NII_DIMS) {
fprintf(stderr, "NIfTI-1 files may contain at most %d dimensions\n",
MAX_NII_DIMS);
return (-1);
}
/* Initialize the NIfTI structure
*/
nii_ptr = &nii_rec;
init_nifti_header(nii_ptr);
/* For now we just use the mnc2nii command line as the description
* field. Probably we should use something better, perhaps a
* combination of some other standard MINC fields that might
* provide more information.
*/
str_ptr = nii_ptr->descrip;
for (i = 0; i < argc; i++) {
char *arg_ptr = argv[i];
if ((str_ptr - nii_ptr->descrip) >= MAX_NII_DESCRIP) {
break;
}
if (i != 0) {
*str_ptr++ = ' ';
}
while (*arg_ptr != '\0' &&
(str_ptr - nii_ptr->descrip) < MAX_NII_DESCRIP) {
*str_ptr++ = *arg_ptr++;
}
*str_ptr = '\0';
}
nii_ptr->fname = malloc(strlen(out_str) + 4 + 1);
nii_ptr->iname = malloc(strlen(out_str) + 4 + 1);
strcpy(nii_ptr->fname, out_str);
strcpy(nii_ptr->iname, out_str);
switch (nifti_filetype) {
case FT_ANALYZE:
strcat(nii_ptr->fname, ".hdr");
strcat(nii_ptr->iname, ".img");
break;
case FT_NIFTI_SINGLE:
strcat(nii_ptr->fname, ".nii");
strcat(nii_ptr->iname, ".nii");
break;
case FT_NIFTI_DUAL:
strcat(nii_ptr->fname, ".hdr");
strcat(nii_ptr->iname, ".img");
break;
case FT_NIFTI_ASCII:
strcat(nii_ptr->fname, ".nia");
strcat(nii_ptr->iname, ".nia");
break;
default:
fprintf(stderr, "Unknown output file type %d\n", nifti_filetype);
return (-1);
}
/* Get real voxel range for the input file.
*/
miget_image_range(mnc_fd, real_range);
/* Get the actual valid voxel value range.
*/
miget_valid_range(mnc_fd, mnc_vid, input_valid_range);
/* Find the default range for the output type. Our output file
* will use the full legal range of the output type if it is
* an integer.
*/
if (nifti_datatype == DT_UNKNOWN) {
nii_ptr->datatype = DT_FLOAT32; /* Default */
mnc_type = NC_FLOAT;
mnc_signed = 1;
}
else {
nii_ptr->datatype = nifti_datatype;
mnc_signed = nifti_signed;
}
if (vflag) {
fprintf(stderr, "MINC type %d signed %d\n", mnc_type, mnc_signed);
}
miget_default_range(mnc_type, mnc_signed, output_valid_range);
total_valid_range = input_valid_range[1] - input_valid_range[0];
total_real_range = real_range[1] - real_range[0];
if ((output_valid_range[1] - output_valid_range[0]) > total_valid_range) {
/* Empirically, forcing the valid range to be the nearest power
* of two greater than the existing valid range seems to improve
* the behavior of the conversion. This is at least in part because
* of the limited precision of the NIfTI-1 voxel scaling fields.
*/
double new_range = nearest_power_of_two(total_valid_range);
if (new_range - 1.0 >= total_valid_range) {
new_range -= 1.0;
}
if (output_valid_range[1] > total_valid_range) {
output_valid_range[0] = 0;
output_valid_range[1] = new_range;
}
else {
output_valid_range[1] = output_valid_range[0] + new_range;
}
}
else {
/* The new range can't fully represent the input range. Use the
* full available range, and warn the user that they may have a
* problem.
*/
printf("WARNING: Range of input exceeds range of output format.\n");
}
if (vflag) {
printf("Real range: %f %f Input valid range: %f %f Output valid range: %f %f\n",
real_range[0], real_range[1],
input_valid_range[0], input_valid_range[1],
output_valid_range[0], output_valid_range[1]);
}
/* If the output type is not floating point, we may need to scale the
* voxel values.
*/
if (mnc_type != NC_FLOAT && mnc_type != NC_DOUBLE) {
/* Figure out how to map pixel values into the range of the
* output datatype.
*/
nifti_slope = ((real_range[1] - real_range[0]) /
(output_valid_range[1] - output_valid_range[0]));
if (nifti_slope == 0.0) {
nifti_slope = 1.0;
}
nifti_inter = real_range[0] - (output_valid_range[0] * nifti_slope);
/* One problem with NIfTI-1 is the limited precision of the
* scl_slope and scl_inter fields (they are just 32-bits). So
* we look for possible issues and warn about that here.
*/
if (nifti_inter != (float) nifti_inter ||
nifti_slope != (float) nifti_slope) {
double epsilon_i = nifti_inter - (float) nifti_inter;
double epsilon_s = nifti_slope - (float) nifti_slope;
/* If the loss in precision is more than one part per thousand
* of the real range, flag this as a problem!
*/
if ((epsilon_i > total_real_range / 1.0e3) ||
(epsilon_s > total_real_range / 1.0e3)) {
fprintf(stderr, "ERROR: Slope and intercept cannot be represented in the NIfTI-1 header.\n");
fprintf(stderr, " slope %f (%f), intercept %f (%f)\n",
nifti_slope, (float) nifti_slope,
nifti_inter, (float) nifti_inter);
return (-1);
}
}
}
else {
nifti_slope = 0.0;
}
nii_ptr->scl_slope = nifti_slope;
nii_ptr->scl_inter = nifti_inter;
nii_ptr->nvox = 1; /* Initial value for voxel count */
/* Find all of the dimensions of the MINC file, in the order they
* will be listed in the NIfTI-1/Analyze file. We use this to build
* a map for restructuring the data according to the normal rules
* of NIfTI-1.
*/
nii_ndims = 0;
for (i = 0; i < MAX_NII_DIMS; i++) {
if (dimnames[i] == NULL) {
nii_dimids[nii_ndims] = -1;
continue;
}
nii_dimids[nii_ndims] = ncdimid(mnc_fd, dimnames[i]);
if (nii_dimids[nii_ndims] == -1) {
continue;
}
/* Make sure the dimension is actually used to define the image.
*/
for (j = 0; j < mnc_ndims; j++) {
if (nii_dimids[nii_ndims] == mnc_dimids[j]) {
nii_map[nii_ndims] = j;
break;
}
}
if (j < mnc_ndims) {
mnc_dlen = 1;
mnc_dstep = 0;
ncdiminq(mnc_fd, nii_dimids[nii_ndims], NULL, &mnc_dlen);
ncattget(mnc_fd, ncvarid(mnc_fd, dimnames[i]), MIstep, &mnc_dstep);
if (mnc_dstep < 0) {
nii_dir[nii_ndims] = -1;
mnc_dstep = -mnc_dstep;
}
else {
nii_dir[nii_ndims] = 1;
}
nii_lens[nii_ndims] = mnc_dlen;
nii_ndims++;
}
nii_ptr->dim[dimmap[i]] = (int) mnc_dlen;
nii_ptr->nvox *= mnc_dlen;
nii_ptr->pixdim[dimmap[i]] = (float) mnc_dstep;
}
/* Here we do some "post-processing" of the results. Make certain that
* the nt value is never zero, and make certain that ndim is set to
* 4 if there is a time dimension and 5 if there is a vector dimension
*/
if (nii_ptr->dim[3] > 1 && nii_ndims < 4) {
nii_ndims = 4;
}
if (nii_ptr->dim[4] > 1) {
nii_ptr->intent_code = NIFTI_INTENT_VECTOR;
nii_ndims = 5;
}
nii_ptr->ndim = nii_ndims; /* Total number of dimensions in file */
nii_ptr->nx = nii_ptr->dim[0];
nii_ptr->ny = nii_ptr->dim[1];
nii_ptr->nz = nii_ptr->dim[2];
nii_ptr->nt = nii_ptr->dim[3];
nii_ptr->nu = nii_ptr->dim[4];
nii_ptr->dx = nii_ptr->pixdim[0];
nii_ptr->dy = nii_ptr->pixdim[1];
nii_ptr->dz = nii_ptr->pixdim[2];
nii_ptr->dt = nii_ptr->pixdim[3];
nii_ptr->du = 1; /* MINC files don't define a sample size for a vector_dimension */
nii_ptr->nifti_type = nifti_filetype;
/* Load the direction_cosines and start values into the NIfTI-1
* sform structure.
*
*/
for (i = 0; i < MAX_SPACE_DIMS; i++) {
int id = ncvarid(mnc_fd, mnc_spatial_names[i]);
double start;
double step;
double dircos[MAX_SPACE_DIMS];
int tmp;
if (id < 0) {
continue;
}
/* Set default values */
start = 0.0;
step = 1.0;
dircos[DIM_X] = dircos[DIM_Y] = dircos[DIM_Z] = 0.0;
dircos[i] = 1.0;
miattget(mnc_fd, id, MIstart, NC_DOUBLE, 1, &start, &tmp);
miattget(mnc_fd, id, MIstep, NC_DOUBLE, 1, &step, &tmp);
miattget(mnc_fd, id, MIdirection_cosines, NC_DOUBLE, MAX_SPACE_DIMS,
dircos, &tmp);
ncdiminq(mnc_fd, ncdimid(mnc_fd, mnc_spatial_names[i]), NULL,
&mnc_dlen);
if (step < 0) {
step = -step;
start = start - step * (mnc_dlen - 1);
}
nii_ptr->sto_xyz.m[0][i] = step * dircos[0];
nii_ptr->sto_xyz.m[1][i] = step * dircos[1];
nii_ptr->sto_xyz.m[2][i] = step * dircos[2];
nii_ptr->sto_xyz.m[0][3] += start * dircos[0];
nii_ptr->sto_xyz.m[1][3] += start * dircos[1];
nii_ptr->sto_xyz.m[2][3] += start * dircos[2];
miattgetstr(mnc_fd, id, MIspacetype, sizeof(att_str), att_str);
/* Try to set the S-transform code correctly.
*/
if (!strcmp(att_str, MI_TALAIRACH)) {
nii_ptr->sform_code = NIFTI_XFORM_TALAIRACH;
}
else if (!strcmp(att_str, MI_CALLOSAL)) {
/* TODO: Not clear what do do here... */
nii_ptr->sform_code = NIFTI_XFORM_SCANNER_ANAT;
}
else { /* MI_NATIVE or unknown */
nii_ptr->sform_code = NIFTI_XFORM_SCANNER_ANAT;
}
}
/* So the last row is right... */
nii_ptr->sto_xyz.m[3][0] = 0.0;
nii_ptr->sto_xyz.m[3][1] = 0.0;
nii_ptr->sto_xyz.m[3][2] = 0.0;
nii_ptr->sto_xyz.m[3][3] = 1.0;
nii_ptr->sto_ijk = nifti_mat44_inverse(nii_ptr->sto_xyz);
nifti_datatype_sizes(nii_ptr->datatype,
&nii_ptr->nbyper, &nii_ptr->swapsize);
if (vflag) {
nifti_image_infodump(nii_ptr);
}
/* Now load the actual MINC data. */
nii_ptr->data = malloc(nii_ptr->nbyper * nii_ptr->nvox);
if (nii_ptr->data == NULL) {
fprintf(stderr, "Out of memory.\n");
return (-1);
}
mnc_icv = miicv_create();
miicv_setint(mnc_icv, MI_ICV_TYPE, mnc_type);
miicv_setstr(mnc_icv, MI_ICV_SIGN, (mnc_signed) ? MI_SIGNED : MI_UNSIGNED);
miicv_setdbl(mnc_icv, MI_ICV_VALID_MAX, output_valid_range[1]);
miicv_setdbl(mnc_icv, MI_ICV_VALID_MIN, output_valid_range[0]);
miicv_setdbl(mnc_icv, MI_ICV_IMAGE_MAX, real_range[1]);
miicv_setdbl(mnc_icv, MI_ICV_IMAGE_MIN, real_range[0]);
miicv_setdbl(mnc_icv, MI_ICV_DO_NORM, TRUE);
miicv_setdbl(mnc_icv, MI_ICV_USER_NORM, TRUE);
miicv_attach(mnc_icv, mnc_fd, mnc_vid);
/* Read in the entire hyperslab from the file.
*/
for (i = 0; i < mnc_ndims; i++) {
ncdiminq(mnc_fd, mnc_dimids[i], NULL, &mnc_count[i]);
mnc_start[i] = 0;
}
r = miicv_get(mnc_icv, mnc_start, mnc_count, nii_ptr->data);
if (r < 0) {
fprintf(stderr, "Read error\n");
return (-1);
}
/* Shut down the MINC stuff now that it has done its work.
*/
miicv_detach(mnc_icv);
miicv_free(mnc_icv);
miclose(mnc_fd);
if (vflag) {
/* Debugging stuff - just to check the contents of these arrays.
*/
for (i = 0; i < nii_ndims; i++) {
printf("%d: %ld %d %d\n",
i, nii_lens[i], nii_map[i], nii_dir[i]);
}
printf("bytes per voxel %d\n", nii_ptr->nbyper);
printf("# of voxels %ld\n", nii_ptr->nvox);
}
/* Rearrange the data to correspond to the NIfTI dimension ordering.
*/
restructure_array(nii_ndims,
nii_ptr->data,
nii_lens,
nii_ptr->nbyper,
nii_map,
nii_dir);
if (vflag) {
/* More debugging stuff - check coordinate transform.
*/
test_xform(nii_ptr->sto_xyz, 0, 0, 0);
test_xform(nii_ptr->sto_xyz, 10, 0, 0);
test_xform(nii_ptr->sto_xyz, 0, 10, 0);
test_xform(nii_ptr->sto_xyz, 0, 0, 10);
test_xform(nii_ptr->sto_xyz, 10, 10, 10);
}
if (vflag) {
fprintf(stdout, "Writing NIfTI-1 file...");
}
nifti_image_write(nii_ptr);
if (vflag) {
fprintf(stdout, "done.\n");
}
return (0);
}
int main(int argc, char **argv)
{
int icv, cdfid, img, max, min;
static char *typenm[]={"short", "double"};
static char *boolnm[] = {"true", "false"};
static nc_type intypes[] = {NC_SHORT, NC_DOUBLE};
static int norms[] = {TRUE, FALSE};
static nc_type outtypes[] = {NC_SHORT, NC_DOUBLE};
static int maxpresent[] = {TRUE, FALSE};
static int valpresent[] = {TRUE, FALSE};
static int dim[MAX_VAR_DIMS];
static struct { long len; char *name;} diminfo[] = {
{ 3, MIzspace },
{ 1, MIyspace },
{ 1, MIxspace }
};
static int numdims=sizeof(diminfo)/sizeof(diminfo[0]);
static long coord[]={0,0,0};
static long count[]={1,1,1};
static double max_values[] = {0.4, 0.6, 0.8};
double dvalue;
short int ivalue;
int i, intype, inorm, outtype, imax, ival;
int cflag = 0;
char filename[256];
#if MINC2
if (argc == 2 && !strcmp(argv[1], "-2")) {
cflag = MI2_CREATE_V2;
}
#endif /* MINC2 */
snprintf(filename, sizeof(filename), "test_icv_range-%d.mnc", getpid());
for (intype=0; intype<MAX_IN_TYPES; intype++) {
for (inorm=0; inorm<MAX_NORM; inorm++) {
icv=miicv_create();
miicv_setint(icv, MI_ICV_TYPE, intypes[intype]);
miicv_setint(icv, MI_ICV_DO_NORM, norms[inorm]);
miicv_setdbl(icv, MI_ICV_VALID_MAX, 20000.0);
miicv_setdbl(icv, MI_ICV_VALID_MIN, 0.0);
for (outtype=0; outtype<MAX_OUT_TYPES; outtype++) {
for (imax=0; imax<MAX_MAX; imax++) {
for (ival=0; ival<MAX_VAL; ival++) {
printf(
"in : %s, out : %s, norm : %s, imgmax : %s, valid : %s\n",
typenm[intype], typenm[outtype], boolnm[inorm],
boolnm[imax], boolnm[ival]);
cdfid=micreate(filename, NC_CLOBBER | cflag);
for (i=0; i<numdims; i++)
dim[i]=ncdimdef(cdfid, diminfo[i].name, diminfo[i].len);
img=micreate_std_variable(cdfid, MIimage, outtypes[outtype],
numdims, dim);
if (maxpresent[imax]) {
max=micreate_std_variable(cdfid, MIimagemax, NC_DOUBLE,
1, dim);
min=micreate_std_variable(cdfid, MIimagemin, NC_DOUBLE,
1, dim);
}
if (valpresent[ival]) {
dvalue = 32000;
ncattput(cdfid, img, MIvalid_max, NC_DOUBLE, 1, &dvalue);
dvalue = 0;
ncattput(cdfid, img, MIvalid_min, NC_DOUBLE, 1, &dvalue);
}
ncendef(cdfid);
if (maxpresent[imax]) {
for (i=0; i<3; i++) {
dvalue = max_values[i];
coord[0]=i;
ncvarput1(cdfid, max, coord, &dvalue);
dvalue = -dvalue;
ncvarput1(cdfid, min, coord, &dvalue);
}
coord[0]=0;
}
miicv_attach(icv, cdfid, img);
if (intypes[intype]==NC_DOUBLE) {
dvalue = 0.2;
miicv_put(icv, coord, count, &dvalue);
}
else {
ivalue = 12500;
miicv_put(icv, coord, count, &ivalue);
}
dvalue = 0;
mivarget1(cdfid, img, coord, NC_DOUBLE, MI_SIGNED, &dvalue);
printf(" file value = %g\n", dvalue);
if (intypes[intype]==NC_DOUBLE) {
miicv_get(icv, coord, count, &dvalue);
}
else {
miicv_get(icv, coord, count, &ivalue);
dvalue=ivalue;
}
printf(" icv value = %g\n", dvalue);
miclose(cdfid);
}
}
}
miicv_free(icv);
}
}
unlink(filename);
return 0;
}
int
test_icv_read(char *filename, int xsize, int ysize, double image_min,
double image_max, nc_type datatype, char *signtype)
{
int icv, cdfid, img, ndims;
static long coord[MAX_VAR_DIMS];
static long count[MAX_VAR_DIMS];
int dim[MAX_VAR_DIMS];
long dim_size;
unsigned char *image;
int i;
double min, max;
int n;
min = DBL_MAX;
max = -DBL_MAX;
image = malloc(xsize * ysize * nctypelen(datatype));
if (image == NULL) {
return (ERROR_STATUS);
}
/* Create the icv */
icv=miicv_create();
(void) miicv_setint(icv, MI_ICV_XDIM_DIR, MI_ICV_POSITIVE);
(void) miicv_setint(icv, MI_ICV_YDIM_DIR, MI_ICV_POSITIVE);
(void) miicv_setint(icv, MI_ICV_ZDIM_DIR, MI_ICV_POSITIVE);
(void) miicv_setint(icv, MI_ICV_ADIM_SIZE, xsize);
(void) miicv_setint(icv, MI_ICV_BDIM_SIZE, ysize);
(void) miicv_setint(icv, MI_ICV_KEEP_ASPECT, FALSE);
(void) miicv_setint(icv, MI_ICV_DO_DIM_CONV, TRUE);
(void) miicv_setint(icv, MI_ICV_TYPE, datatype);
(void) miicv_setstr(icv, MI_ICV_SIGN, signtype);
(void) miicv_setdbl(icv, MI_ICV_VALID_MAX, image_max);
(void) miicv_setdbl(icv, MI_ICV_VALID_MIN, image_min);
/* Open the file, attach the image variable */
cdfid=miopen(filename, NC_NOWRITE);
/* Attach image variable */
img=ncvarid(cdfid, MIimage);
(void) miicv_attach(icv, cdfid, img);
/* Get the number of dimensions and modify count and coord */
(void) ncvarinq(cdfid, img, NULL, NULL, &ndims, dim, NULL);
if (ndims!=3) {
(void) fprintf(stderr, "File must have 3 dimensions\n");
return ERROR_STATUS;
}
(void) ncdiminq(cdfid, dim[0], NULL, &dim_size);
count[0]=1;
count[1]=ysize;
count[2]=xsize;
coord[1]=0;
coord[2]=0;
/* Get the data */
for (i=0; i<dim_size; i++) {
coord[0]=i;
(void) miicv_get(icv, coord, count, image);
switch (datatype) {
case NC_BYTE:
if (!strcmp(signtype, MI_UNSIGNED)) {
for (n = 0; n < xsize*ysize; n++) {
unsigned char uc = *(((unsigned char *)image) + n);
if (uc > max) {
max = uc;
}
if (uc < min) {
min = uc;
}
}
}
else {
for (n = 0; n < xsize*ysize; n++) {
signed char sc = *(((signed char *)image) + n);
if (sc > max) {
max = sc;
}
if (sc < min) {
min = sc;
}
}
}
break;
case NC_SHORT:
if (!strcmp(signtype, MI_UNSIGNED)) {
for (n = 0; n < xsize*ysize; n++) {
unsigned short uc = *(((unsigned short *)image) + n);
if (uc > max) {
max = uc;
}
if (uc < min) {
min = uc;
}
}
}
else {
for (n = 0; n < xsize*ysize; n++) {
signed short sc = *(((signed short *)image) + n);
if (sc > max) {
max = sc;
}
if (sc < min) {
min = sc;
}
}
}
break;
case NC_INT:
if (!strcmp(signtype, MI_UNSIGNED)) {
for (n = 0; n < xsize*ysize; n++) {
unsigned int uc = *(((unsigned int *)image) + n);
if (uc > max) {
max = uc;
}
if (uc < min) {
min = uc;
}
}
}
else {
for (n = 0; n < xsize*ysize; n++) {
signed int sc = *(((signed int *)image) + n);
if (sc > max) {
max = sc;
}
if (sc < min) {
min = sc;
}
}
}
break;
case NC_FLOAT:
for (n = 0; n < xsize*ysize; n++) {
float sc = *(((float *)image) + n);
if (sc > max) {
max = sc;
}
if (sc < min) {
min = sc;
}
}
break;
case NC_DOUBLE:
for (n = 0; n < xsize*ysize; n++) {
double sc = *(((double *)image) + n);
if (sc > max) {
max = sc;
}
if (sc < min) {
min = sc;
}
}
break;
}
printf("%d %s %s %f %f\n", i, signtype, nctypename(datatype), min, max);
}
/* Close the file and free the icv */
(void) miclose(cdfid);
(void) miicv_free(icv);
free(image);
return (NORMAL_STATUS);
}
MNCAPI int
minc_load_data(char *path, void *dataptr, int datatype,
long *ct, long *cz, long *cy, long *cx,
double *dt, double *dz, double *dy, double *dx,
void **infoptr)
{
int fd; /* MINC file descriptor */
nc_type nctype; /* netCDF type */
char *signstr; /* MI_SIGNED or MI_UNSIGNED */
int length;
int dim_id[MI_S_NDIMS];
long dim_len[MI_S_NDIMS];
int i, j; /* Generic loop counters */
int var_id;
int var_ndims;
int var_dims[MAX_NC_DIMS];
int icv; /* MINC image conversion variable */
long start[MI_S_NDIMS];
long count[MI_S_NDIMS];
size_t ucount[MI_S_NDIMS];
int dir[MI_S_NDIMS]; /* Dimension "directions" */
int map[MI_S_NDIMS]; /* Dimension mapping */
int old_ncopts; /* For storing the old state of ncopts */
double *p_dtmp;
long *p_ltmp;
struct file_info *p_file;
struct att_info *p_att;
int r; /* Generic return code */
*infoptr = NULL;
fd = miopen(path, NC_NOWRITE);
if (fd < 0) {
return (MINC_STATUS_ERROR);
}
old_ncopts =get_ncopts();
set_ncopts(0);
for (i = 0; i < MI_S_NDIMS; i++) {
dim_id[i] = ncdimid(fd, minc_dimnames[i]);
if (dim_id[i] >= 0) {
ncdiminq(fd, dim_id[i], NULL, &dim_len[i]);
var_id = ncvarid(fd, minc_dimnames[i]);
ncattinq(fd, var_id, MIstep, &nctype, &length);
switch (i) {
case MI_S_T:
p_ltmp = ct;
p_dtmp = dt;
break;
case MI_S_X:
p_ltmp = cx;
p_dtmp = dx;
break;
case MI_S_Y:
p_ltmp = cy;
p_dtmp = dy;
break;
case MI_S_Z:
p_ltmp = cz;
p_dtmp = dz;
break;
default:
return (MINC_STATUS_ERROR);
}
if (nctype == NC_DOUBLE && length == 1) {
ncattget(fd, var_id, MIstep, p_dtmp);
}
else {
*p_dtmp = 0; /* Unknown/not set */
}
*p_ltmp = dim_len[i];
}
else {
dim_len[i] = 0;
}
}
set_ncopts(old_ncopts);
var_id = ncvarid(fd, MIimage);
ncvarinq(fd, var_id, NULL, &nctype, &var_ndims, var_dims, NULL);
if (var_ndims != 3 && var_ndims != 4) {
return (MINC_STATUS_ERROR);
}
/* We want the data to wind up in t, x, y, z order. */
for (i = 0; i < MI_S_NDIMS; i++) {
map[i] = -1;
}
for (i = 0; i < var_ndims; i++) {
if (var_dims[i] == dim_id[MI_S_T]) {
map[MI_S_T] = i;
}
else if (var_dims[i] == dim_id[MI_S_X]) {
map[MI_S_X] = i;
}
else if (var_dims[i] == dim_id[MI_S_Y]) {
map[MI_S_Y] = i;
}
else if (var_dims[i] == dim_id[MI_S_Z]) {
map[MI_S_Z] = i;
}
}
icv = miicv_create();
minc_simple_to_nc_type(datatype, &nctype, &signstr);
miicv_setint(icv, MI_ICV_TYPE, nctype);
miicv_setstr(icv, MI_ICV_SIGN, signstr);
miicv_attach(icv, fd, var_id);
for (i = 0; i < var_ndims; i++) {
start[i] = 0;
}
for (i = 0; i < MI_S_NDIMS; i++) {
if (map[i] >= 0) {
count[map[i]] = dim_len[i];
}
}
r = miicv_get(icv, start, count, dataptr);
if (r < 0) {
return (MINC_STATUS_ERROR);
}
if (map[MI_S_T] >= 0) {
if (*dt < 0) {
dir[MI_S_T] = -1;
*dt = -*dt;
}
else {
dir[MI_S_T] = 1;
}
}
if (map[MI_S_X] >= 0) {
if (*dx < 0) {
dir[MI_S_X] = -1;
*dx = -*dx;
}
else {
dir[MI_S_X] = 1;
}
}
if (map[MI_S_Y] >= 0) {
if (*dy < 0) {
dir[MI_S_Y] = -1;
*dy = -*dy;
}
else {
dir[MI_S_Y] = 1;
}
}
if (map[MI_S_Z] >= 0) {
if (*dz < 0) {
dir[MI_S_Z] = -1;
*dz = -*dz;
}
else {
dir[MI_S_Z] = 1;
}
}
if (var_ndims == 3) {
for (i = 1; i < MI_S_NDIMS; i++) {
map[i-1] = map[i];
dir[i-1] = dir[i];
}
}
j = 0;
for (i = 0; i < MI_S_NDIMS; i++) {
if (dim_len[i] > 0) {
ucount[j++] = dim_len[i];
}
}
restructure_array(var_ndims, dataptr, ucount, nctypelen(nctype),
map, dir);
miicv_detach(icv);
miicv_free(icv);
old_ncopts =get_ncopts();
set_ncopts(0);
/* Generate the complete infoptr array.
* This is essentially an in-memory copy of the variables and attributes
* in the file.
*/
p_file = (struct file_info *) malloc(sizeof (struct file_info));
ncinquire(fd, &p_file->file_ndims, &p_file->file_nvars,
&p_file->file_natts, NULL);
p_file->file_atts = (struct att_info *) malloc(sizeof (struct att_info) *
p_file->file_natts);
p_file->file_vars = (struct var_info *) malloc(sizeof (struct var_info) *
p_file->file_nvars);
for (i = 0; i < p_file->file_natts; i++) {
p_att = &p_file->file_atts[i];
ncattname(fd, NC_GLOBAL, i, p_att->att_name);
ncattinq(fd, NC_GLOBAL,
p_att->att_name,
&p_att->att_type,
&p_att->att_len);
p_att->att_val = malloc(p_att->att_len * nctypelen(p_att->att_type));
ncattget(fd, NC_GLOBAL, p_att->att_name, p_att->att_val);
}
for (i = 0; i < p_file->file_nvars; i++) {
struct var_info *p_var = &p_file->file_vars[i];
ncvarinq(fd, i,
p_var->var_name,
&p_var->var_type,
&p_var->var_ndims,
p_var->var_dims,
&p_var->var_natts);
p_var->var_atts = malloc(p_var->var_natts *
sizeof (struct att_info));
if (ncdimid(fd, p_var->var_name) >= 0) {
/* It's a dimension variable, have to treat it specially... */
}
for (j = 0; j < p_var->var_natts; j++) {
p_att = &p_var->var_atts[j];
ncattname(fd, i, j, p_att->att_name);
ncattinq(fd, i,
p_att->att_name,
&p_att->att_type,
&p_att->att_len);
p_att->att_val = malloc(p_att->att_len * nctypelen(p_att->att_type));
ncattget(fd, i, p_att->att_name, p_att->att_val);
}
}
*infoptr = p_file;
set_ncopts(old_ncopts);
miclose(fd);
return (MINC_STATUS_OK);
}
int main(int argc, char *argv[])
{
char *pname;
char *filename, *tempfile, *newfile;
char string[1024];
char *variable_name, *attribute_name;
int created_tempfile;
int done_redef;
int iatt;
int mincid, varid;
int variable_exists, attribute_exists;
nc_type attribute_type, new_type;
int attribute_length, new_length;
void *new_value;
int total_length, alloc_length, ival;
char *zeros;
int old_ncopts;
/* Parse the command line */
pname=argv[0];
if (ParseArgv(&argc, argv, argTable, 0) || (argc != 2)) {
(void) fprintf(stderr, "\nUsage: %s [<options>] <file.mnc>\n",
pname);
(void) fprintf(stderr, " %s [-help]\n\n", pname);
exit(EXIT_FAILURE);
}
filename = argv[1];
/* Create temp file name. First try looking for minc extension, then
a compression extension. Chop off the unwanted extension. */
(void) strncpy(string, filename, sizeof(string)-1);
tempfile = strstr(string, MINC_EXTENSION);
if (tempfile != NULL) {
tempfile += strlen(MINC_EXTENSION);
if (*tempfile == '\0')
tempfile = NULL;
}
else {
tempfile = strstr(string, GZIP_EXTENSION);
if (tempfile == NULL)
tempfile = strstr(string, BZIP_EXTENSION);
if (tempfile == NULL)
tempfile = strstr(string, BZIP2_EXTENSION);
if (tempfile == NULL)
tempfile = strstr(string, COMPRESS_EXTENSION);
if (tempfile == NULL)
tempfile = strstr(string, PACK_EXTENSION);
if (tempfile == NULL)
tempfile = strstr(string, ZIP_EXTENSION);
}
if (tempfile != NULL) {
*tempfile = '\0';
tempfile = string;
}
/* If tempfile == NULL, then either we have a minc file or we don't know
how to edit the file in place. Check that it is a minc file. */
if (tempfile == NULL) {
newfile = miexpand_file(filename, tempfile, TRUE, &created_tempfile);
if (created_tempfile) {
if (newfile != NULL) {
(void) remove(newfile);
free(newfile);
}
(void) fprintf(stderr, "Cannot edit file \"%s\" in place.\n",
filename);
exit(EXIT_FAILURE);
}
}
/* Expand the file. */
newfile = miexpand_file(filename, tempfile, FALSE, &created_tempfile);
if (newfile == NULL) {
(void) fprintf(stderr, "Error decompressing file \"%s\"\n",
filename);
exit(EXIT_FAILURE);
}
/* If a new file was created, get rid of the old one */
if (created_tempfile) {
(void) remove(filename);
}
/* Open the file */
mincid = miopen(newfile, NC_WRITE);
/* Loop through attribute list, modifying values */
done_redef = FALSE;
ncopts = NC_VERBOSE;
zeros = NULL;
alloc_length = 0;
for (iatt=0; iatt < attribute_list_size; iatt++) {
/* Get variable and attribute name */
variable_name = attribute_list[iatt].variable;
attribute_name = attribute_list[iatt].attribute;
/* Check for attribute existence */
if (strlen(variable_name) == 0) {
varid = NC_GLOBAL;
variable_exists = TRUE;
}
else {
old_ncopts = ncopts; ncopts = 0;
varid = ncvarid(mincid, variable_name);
ncopts = old_ncopts;
variable_exists = (varid != MI_ERROR);
}
attribute_type = NC_CHAR;
attribute_length = 0;
if (variable_exists) {
old_ncopts = ncopts; ncopts = 0;
attribute_exists =
(ncattinq(mincid, varid, attribute_name,
&attribute_type, &attribute_length) != MI_ERROR);
ncopts = old_ncopts;
}
else
attribute_exists = FALSE;
/* Are we inserting or deleting? */
switch (attribute_list[iatt].action) {
case Insert_attribute:
case Append_attribute:
if (attribute_list[iatt].value != NULL) {
new_type = NC_CHAR;
new_length = strlen(attribute_list[iatt].value)+1;
new_value = (void *) attribute_list[iatt].value;
}
else {
new_type = NC_DOUBLE;
new_length = attribute_list[iatt].num_doubles;
new_value = (void *) attribute_list[iatt].double_values;
}
/* For append we have to copy the entire attribute, if it
* already exists.
*/
if (attribute_list[iatt].action == Append_attribute &&
attribute_exists) {
char *tmp_value;
/* Verify that the existing type matches the newly
* requested type. Don't allow a -dappend on a
* string attribute, for example.
*/
if (new_type != attribute_type) {
fprintf(stderr,
"Can't append %s data to %s attribute %s:%s.\n",
(new_type == NC_DOUBLE) ? "double" : "string",
(attribute_type == NC_DOUBLE) ? "double" : "string",
variable_name, attribute_name);
exit(EXIT_FAILURE);
}
new_type = attribute_type;
tmp_value = malloc((attribute_length + new_length) * nctypelen(new_type));
ncattget(mincid, varid, attribute_name, tmp_value);
/* For string attributes, remove any trailing null
* character before appending.
*/
if (new_type == NC_CHAR && tmp_value[attribute_length-1] == 0) {
attribute_length--;
}
memcpy(tmp_value + attribute_length * nctypelen(new_type),
new_value,
new_length * nctypelen(new_type));
new_length += attribute_length;
new_value = (void *) tmp_value;
}
total_length = attribute_length*nctypelen(attribute_type);
if (!attribute_exists ||
(total_length < new_length*nctypelen(new_type))) {
if (! done_redef) {
done_redef = TRUE;
(void) ncredef(mincid);
}
}
else if (!done_redef && attribute_exists && (total_length > 0)) {
if (total_length > alloc_length) {
if (zeros != NULL) free(zeros);
zeros = malloc(total_length);
alloc_length = total_length;
for (ival=0; ival < alloc_length; ival++)
zeros[ival] = '\0';
}
(void) ncattput(mincid, varid, attribute_name, NC_CHAR,
total_length, zeros);
(void) ncsync(mincid);
}
if (!variable_exists) {
old_ncopts = ncopts; ncopts = 0;
varid = micreate_group_variable(mincid, variable_name);
ncopts = old_ncopts;
if (varid == MI_ERROR) {
varid = ncvardef(mincid, variable_name, NC_INT,
0, NULL);
}
variable_exists = (varid != MI_ERROR);
}
if (variable_exists) {
(void) ncattput(mincid, varid, attribute_name,
new_type, new_length, new_value);
}
break;
case Delete_attribute:
if (attribute_exists) {
if (! done_redef) {
done_redef = TRUE;
(void) ncredef(mincid);
}
(void) ncattdel(mincid, varid, attribute_name);
}
break;
default:
(void) fprintf(stderr, "Program error: unknown action %d\n",
(int) attribute_list[iatt].action);
exit(EXIT_FAILURE);
}
}
ncopts = NC_VERBOSE | NC_FATAL;
/* Close the file */
(void) miclose(mincid);
/* Free stuff */
free(newfile);
if (zeros != NULL) free(zeros);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
char *filename;
int mincid, imgid, icvid, ndims, dims[MAX_VAR_DIMS];
nc_type datatype;
int is_signed;
long start[MAX_VAR_DIMS], count[MAX_VAR_DIMS], end[MAX_VAR_DIMS];
long size;
int idim;
void *data;
double temp;
/* Check arguments */
if (ParseArgv(&argc, argv, argTable, 0) || (argc != 2)) {
(void) fprintf(stderr, "\nUsage: %s [<options>] <mincfile>\n", argv[0]);
(void) fprintf(stderr, " %s -help\n\n", argv[0]);
exit(EXIT_FAILURE);
}
filename = argv[1];
/* Check that a normalization option was specified */
if (normalize_output == VIO_BOOL_DEFAULT) {
(void) fprintf(stderr,
"Please specify either -normalize or -nonormalize\n");
(void) fprintf(stderr, "Usually -normalize is most appropriate\n");
exit(EXIT_FAILURE);
}
/* Open the file */
mincid = miopen(filename, NC_NOWRITE);
/* Inquire about the image variable */
imgid = ncvarid(mincid, MIimage);
(void) ncvarinq(mincid, imgid, NULL, NULL, &ndims, dims, NULL);
(void)miget_datatype(mincid, imgid, &datatype, &is_signed);
/* Check if arguments set */
/* Get output data type */
if (output_datatype == INT_MAX) output_datatype = datatype;
/* Get output sign */
if (output_signed == INT_MAX) {
if (output_datatype == datatype)
output_signed = is_signed;
else
output_signed = (output_datatype != NC_BYTE);
}
/* Get output range */
if (valid_range[0] == DBL_MAX) {
if ((output_datatype == datatype) && (output_signed == is_signed)) {
(void) miget_valid_range(mincid, imgid, valid_range);
}
else {
(void) miget_default_range(output_datatype, output_signed,
valid_range);
}
}
if (valid_range[0] > valid_range[1]) {
temp = valid_range[0];
valid_range[0] = valid_range[1];
valid_range[1] = temp;
}
/* Set up image conversion */
icvid = miicv_create();
(void) miicv_setint(icvid, MI_ICV_TYPE, output_datatype);
(void) miicv_setstr(icvid, MI_ICV_SIGN, (output_signed ?
MI_SIGNED : MI_UNSIGNED));
(void) miicv_setdbl(icvid, MI_ICV_VALID_MIN, valid_range[0]);
(void) miicv_setdbl(icvid, MI_ICV_VALID_MAX, valid_range[1]);
if ((output_datatype == NC_FLOAT) || (output_datatype == NC_DOUBLE)) {
(void) miicv_setint(icvid, MI_ICV_DO_NORM, TRUE);
(void) miicv_setint(icvid, MI_ICV_USER_NORM, TRUE);
}
else if (normalize_output) {
(void) miicv_setint(icvid, MI_ICV_DO_NORM, TRUE);
}
(void) miicv_attach(icvid, mincid, imgid);
/* Set input file start, count and end vectors for reading a slice
at a time */
for (idim=0; idim < ndims; idim++) {
(void) ncdiminq(mincid, dims[idim], NULL, &end[idim]);
}
(void) miset_coords(ndims, (long) 0, start);
(void) miset_coords(ndims, (long) 1, count);
size = nctypelen(output_datatype);
for (idim=ndims-2; idim < ndims; idim++) {
count[idim] = end[idim];
size *= count[idim];
}
/* Allocate space */
data = malloc(size);
/* Loop over input slices */
while (start[0] < end[0]) {
/* Read in the slice */
(void) miicv_get(icvid, start, count, data);
/* Write out the slice */
if (fwrite(data, sizeof(char), (size_t) size, stdout) != size) {
(void) fprintf(stderr, "Error writing data.\n");
exit(EXIT_FAILURE);
}
/* Increment start counter */
idim = ndims-1;
start[idim] += count[idim];
while ( (idim>0) && (start[idim] >= end[idim])) {
start[idim] = 0;
idim--;
start[idim] += count[idim];
}
} /* End loop over slices */
/* Clean up */
(void) miclose(mincid);
(void) miicv_free(icvid);
free(data);
exit(EXIT_SUCCESS);
}
int
upet_to_minc(char *hdr_fname, char *img_fname, char *out_fname,
char *prog_name)
{
char *line_ptr;
char line_buf[1024];
char *val_ptr;
int in_header;
double dbl_tmp;
int int_tmp;
struct conversion_info ci;
struct keywd_entry *ke_ptr;
int is_known;
char *argv_tmp[5];
char *out_history;
ci.hdr_fp = fopen(hdr_fname, "r"); /* Text file */
if (ci.hdr_fp == NULL) {
perror(hdr_fname);
return (-1);
}
ci.img_fp = fopen(img_fname, "rb"); /* Binary file */
if (ci.img_fp == NULL) {
perror(img_fname);
return (-1);
}
ci.mnc_fd = micreate(out_fname, NC_NOCLOBBER);
if (ci.mnc_fd < 0) {
perror(out_fname);
return (-1);
}
ci.frame_zero = -1; /* Initial frame is -1 until set. */
/* Define the basic MINC group variables.
*/
micreate_group_variable(ci.mnc_fd, MIstudy);
micreate_group_variable(ci.mnc_fd, MIacquisition);
micreate_group_variable(ci.mnc_fd, MIpatient);
ncvardef(ci.mnc_fd, "micropet", NC_SHORT, 0, NULL);
/* Fake the history here */
argv_tmp[0] = prog_name;
argv_tmp[1] = VERSIONSTR;
argv_tmp[2] = hdr_fname;
argv_tmp[3] = img_fname;
argv_tmp[4] = out_fname;
out_history = time_stamp(5, argv_tmp);
miattputstr(ci.mnc_fd, NC_GLOBAL, MIhistory, out_history);
free(out_history);
in_header = 1;
ci.frame_nbytes = 1;
ci.frame_nvoxels = 1;
/* When we read voxels, we need COMBINED_SCALE_FACTOR() to have a sane
* value for all modalities. Set defaults for these in case the modality
* does not define one of these factors. For example, a CT (modality 2)
* will not define isotope_branching_fraction or calibration_factor.
*/
ci.scale_factor = 1.0;
ci.calibration_factor = 1.0;
ci.isotope_branching_fraction = 1.0;
/* Collect the headers */
while (fgets(line_buf, sizeof(line_buf), ci.hdr_fp) != NULL) {
if (line_buf[0] == '#') /* */
continue;
line_ptr = line_buf;
while (!isspace(*line_ptr)) {
line_ptr++;
}
*line_ptr++ = '\0';
val_ptr = line_ptr;
while (*line_ptr != '\n' && *line_ptr != '\r' && *line_ptr != '\0') {
line_ptr++;
}
*line_ptr = '\0';
is_known = 0;
if (in_header) {
if (*val_ptr != '\0') {
/* Save the raw attribute into the file */
ncattput(ci.mnc_fd, ncvarid(ci.mnc_fd, "micropet"),
line_buf, NC_CHAR, strlen(val_ptr), val_ptr);
}
for (ke_ptr = vol_atts; ke_ptr->upet_kwd != NULL; ke_ptr++) {
if (!strcmp(ke_ptr->upet_kwd, line_buf)) {
is_known = 1;
if (ke_ptr->func != NULL) {
(*ke_ptr->func)(&ci, val_ptr,
ke_ptr->mnc_var,
ke_ptr->mnc_att);
}
else if (ke_ptr->mnc_var != NULL &&
ke_ptr->mnc_att != NULL) {
/* Interpret based upon type */
switch (ke_ptr->upet_type) {
case UPET_TYPE_INT:
int_tmp = atoi(val_ptr);
miattputint(ci.mnc_fd,
ncvarid(ci.mnc_fd, ke_ptr->mnc_var),
ke_ptr->mnc_att,
int_tmp);
break;
case UPET_TYPE_REAL:
dbl_tmp = atof(val_ptr);
miattputdbl(ci.mnc_fd,
ncvarid(ci.mnc_fd, ke_ptr->mnc_var),
ke_ptr->mnc_att,
dbl_tmp);
break;
case UPET_TYPE_STR:
miattputstr(ci.mnc_fd,
ncvarid(ci.mnc_fd, ke_ptr->mnc_var),
ke_ptr->mnc_att,
val_ptr);
break;
}
}
break;
}
}
}
else {
/* Not in the header any longer
*/
for (ke_ptr = frm_atts; ke_ptr->upet_kwd != NULL; ke_ptr++) {
if (!strcmp(ke_ptr->upet_kwd, line_buf)) {
is_known = 1;
if (ke_ptr->func != NULL) {
(*ke_ptr->func)(&ci, val_ptr,
ke_ptr->mnc_var,
ke_ptr->mnc_att);
}
break;
}
}
}
if (!is_known) {
if (!strcmp(line_buf, "end_of_header")) {
if (in_header) {
in_header = 0;
copy_init(&ci);
}
else {
copy_frame(&ci);
}
}
else {
message(MSG_WARNING, "Unrecognized keyword %s\n", line_buf);
}
}
}
fclose(ci.hdr_fp);
fclose(ci.img_fp);
miclose(ci.mnc_fd);
return (0);
}