/* ----------------------------- MNI Header -----------------------------------
@NAME : setup_input_icv
@INPUT : icvid - id of icv to set up
@OUTPUT : (nothing)
@RETURNS : (nothing)
@DESCRIPTION: Routine to set up an icv
@METHOD :
@GLOBALS :
@CALLS :
@CREATED : August 26, 1993 (Peter Neelin)
@MODIFIED :
---------------------------------------------------------------------------- */
static void setup_input_icv(int icvid)
{
/* Set desired type */
(void) miicv_setint(icvid, MI_ICV_TYPE, NC_BYTE);
(void) miicv_setstr(icvid, MI_ICV_SIGN, MI_UNSIGNED);
/* Set range of values */
(void) miicv_setint(icvid, MI_ICV_VALID_MIN, 0);
(void) miicv_setint(icvid, MI_ICV_VALID_MAX, 255);
/* Do normalization so that all pixels are on same scale */
(void) miicv_setint(icvid, MI_ICV_DO_NORM, TRUE);
/* Make sure that any out of range values are mapped to lowest value
of type (for input only) */
(void) miicv_setint(icvid, MI_ICV_DO_FILLVALUE, TRUE);
/* We want to ensure that images have X, Y and Z dimensions in the
positive direction, giving patient left on left and for drawing from
bottom up. If we wanted patient right on left and drawing from
top down, we would set to MI_ICV_NEGATIVE. */
(void) miicv_setint(icvid, MI_ICV_DO_DIM_CONV, TRUE);
(void) miicv_setint(icvid, MI_ICV_DO_SCALAR, TRUE);
(void) miicv_setint(icvid, MI_ICV_XDIM_DIR, MI_ICV_POSITIVE);
(void) miicv_setint(icvid, MI_ICV_YDIM_DIR, MI_ICV_POSITIVE);
(void) miicv_setint(icvid, MI_ICV_ZDIM_DIR, MI_ICV_POSITIVE);
}
/* ----------------------------- MNI Header -----------------------------------
@NAME : setup_output_icv
@INPUT : icvid - id of icv to set up
@OUTPUT : (nothing)
@RETURNS : (nothing)
@DESCRIPTION: Routine to set up an icv
@METHOD :
@GLOBALS :
@CALLS :
@CREATED : August 26, 1993 (Peter Neelin)
@MODIFIED :
---------------------------------------------------------------------------- */
static void setup_output_icv(int icvid)
{
/* Set desired type */
(void) miicv_setint(icvid, MI_ICV_TYPE, NC_BYTE);
(void) miicv_setstr(icvid, MI_ICV_SIGN, MI_UNSIGNED);
/* Set range of values */
(void) miicv_setint(icvid, MI_ICV_VALID_MIN, 0);
(void) miicv_setint(icvid, MI_ICV_VALID_MAX, 255);
/* No normalization so that pixels are scaled to the slice */
(void) miicv_setint(icvid, MI_ICV_DO_NORM, FALSE);
}
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
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_save_data(int fd, void *dataptr, int datatype,
long st, long sz, long sy, long sx,
long ct, long cz, long cy, long cx)
{
nc_type nctype;
char *signstr;
int i;
int var_id;
int var_ndims;
int var_dims[MAX_NC_DIMS];
int icv;
long start[MI_S_NDIMS];
long count[MI_S_NDIMS];
int old_ncopts;
int r;
double min, max;
long slice_size;
long index;
int dtbytes; /* Length of datatype in bytes */
old_ncopts =get_ncopts();
set_ncopts(0);
var_id = ncvarid(fd, MIimage);
ncvarinq(fd, var_id, NULL, NULL, &var_ndims, var_dims, NULL);
set_ncopts(old_ncopts);
if (var_ndims < 2 || var_ndims > 4) {
return (MINC_STATUS_ERROR);
}
r = minc_simple_to_nc_type(datatype, &nctype, &signstr);
if (r == MINC_STATUS_ERROR) {
return (MINC_STATUS_ERROR);
}
dtbytes = nctypelen(nctype);
/* Update the image-min and image-max values */
if (ct > 0) {
slice_size = cz * cy * cx;
index = st;
for (i = 0; i < ct; i++) {
find_minmax((char *) dataptr + (dtbytes * slice_size * i),
slice_size, datatype, &min, &max);
mivarput1(fd, ncvarid(fd, MIimagemin), &index,
NC_DOUBLE, MI_SIGNED, &min);
mivarput1(fd, ncvarid(fd, MIimagemax), &index,
NC_DOUBLE, MI_SIGNED, &max);
index++;
}
}
else {
slice_size = cy * cx;
index = sz;
for (i = 0; i < cz; i++) {
find_minmax((char *) dataptr + (dtbytes * slice_size * i),
slice_size, datatype, &min, &max);
mivarput1(fd, ncvarid(fd, MIimagemin), &index,
NC_DOUBLE, MI_SIGNED, &min);
mivarput1(fd, ncvarid(fd, MIimagemax), &index,
NC_DOUBLE, MI_SIGNED, &max);
index++;
}
}
/* We want the data to wind up in t, x, y, z order. */
icv = miicv_create();
if (icv < 0) {
return (MINC_STATUS_ERROR);
}
r = miicv_setint(icv, MI_ICV_TYPE, nctype);
if (r < 0) {
return (MINC_STATUS_ERROR);
}
r = miicv_setstr(icv, MI_ICV_SIGN, signstr);
if (r < 0) {
return (MINC_STATUS_ERROR);
}
r = miicv_setint(icv, MI_ICV_DO_NORM, 1);
if (r < 0) {
return (MINC_STATUS_ERROR);
}
r = miicv_setint(icv, MI_ICV_DO_FILLVALUE, 1);
if (r < 0) {
return (MINC_STATUS_ERROR);
}
r = miicv_attach(icv, fd, var_id);
if (r < 0) {
return (MINC_STATUS_ERROR);
}
i = 0;
switch (var_ndims) {
case 4:
count[i] = ct;
start[i] = st;
i++;
/* fall through */
case 3:
count[i] = cz;
start[i] = sz;
i++;
/* fall through */
case 2:
count[i] = cy;
start[i] = sy;
i++;
count[i] = cx;
start[i] = sx;
i++;
break;
}
r = miicv_put(icv, start, count, dataptr);
if (r < 0) {
return (MINC_STATUS_ERROR);
}
miicv_detach(icv);
miicv_free(icv);
return (MINC_STATUS_OK);
}
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 *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);
}
void icv_tests(void)
{
/* Some random ICV tests */
int icv;
int stat;
int i;
double min, max;
icv = miicv_create();
if (icv < 0) {
FUNC_ERROR("miicv_create");
}
for (i = NC_BYTE; i <= NC_DOUBLE; i++) {
stat = miicv_setint(icv, MI_ICV_TYPE, i);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setstr(icv, MI_ICV_SIGN, MI_UNSIGNED);
stat = miicv_inqdbl(icv, MI_ICV_VALID_MAX, &max);
if (stat < 0) {
FUNC_ERROR("miicv_inqdbl");
}
stat = miicv_inqdbl(icv, MI_ICV_VALID_MIN, &min);
if (stat < 0) {
FUNC_ERROR("miicv_inqdbl");
}
switch (i) {
case NC_BYTE:
if (min != 0 || max != UCHAR_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_SHORT:
if (min != 0 || max != USHRT_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_INT:
if (min != 0 || max != UINT_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_FLOAT:
if (min != -FLT_MAX || max != FLT_MAX) {
fprintf(stderr, "Type %d min %g max %g, header min %g max %g\n",
i, min, max, FLT_MIN, FLT_MAX);
errors++;
}
break;
case NC_DOUBLE:
if (min != -DBL_MAX || max != DBL_MAX) {
fprintf(stderr, "Type %d min %g max %g, header min %g max %g\n",
i, min, max, DBL_MIN, DBL_MAX);
errors++;
}
break;
}
stat = miicv_setstr(icv, MI_ICV_SIGN, MI_SIGNED);
if (stat < 0) {
FUNC_ERROR("miicv_setstr");
}
stat = miicv_inqdbl(icv, MI_ICV_VALID_MAX, &max);
if (stat < 0) {
FUNC_ERROR("miicv_inqdbl");
}
stat = miicv_inqdbl(icv, MI_ICV_VALID_MIN, &min);
if (stat < 0) {
FUNC_ERROR("miicv_inqdbl");
}
switch (i) {
case NC_BYTE:
if (min != SCHAR_MIN || max != SCHAR_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_SHORT:
if (min != SHRT_MIN || max != SHRT_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_INT:
if (min != INT_MIN || max != INT_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_FLOAT:
if (min != -FLT_MAX || max != FLT_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
case NC_DOUBLE:
if (min != -DBL_MAX || max != DBL_MAX) {
fprintf(stderr, "Type %d min %g max %g\n", i, min, max);
errors++;
}
break;
}
}
#if 0
/* For some reason we're allowed to set MI_ICV_TYPE to an illegal value.
*/
stat = miicv_setint(icv, MI_ICV_TYPE, 1000);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
#endif
stat = miicv_setint(icv, MI_ICV_NUM_IMGDIMS, MI_MAX_IMGDIMS + 1);
if (stat >= 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_NUM_IMGDIMS, MI_MAX_IMGDIMS);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
miicv_free(icv);
}
int
test7(struct testinfo *ip, struct dimdef *dims, int ndims)
{
size_t total;
long coords[3];
long lengths[3];
void *buf_ptr;
int *int_ptr;
int i, j, k;
int stat;
int icv;
total = 1;
for (i = 0; i < ndims; i++) {
total *= dims[i].length;
}
buf_ptr = malloc(total * sizeof (float));
if (buf_ptr == NULL) {
fprintf(stderr, "Oops, malloc failed\n");
return (-1);
}
icv = miicv_create();
if (icv < 0) {
FUNC_ERROR("miicv_create");
}
/* Test range conversion. */
stat = miicv_setint(icv, MI_ICV_DO_DIM_CONV, 0);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_DO_RANGE, 1);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setstr(icv, MI_ICV_SIGN, MI_UNSIGNED);
if (stat < 0) {
FUNC_ERROR("miicv_setstr");
}
stat = miicv_setint(icv, MI_ICV_TYPE, NC_INT);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_VALID_MAX, 1000);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_setint(icv, MI_ICV_VALID_MIN, -1000);
if (stat < 0) {
FUNC_ERROR("miicv_setint");
}
stat = miicv_attach(icv, ip->fd, ip->imgid);
if (stat < 0) {
FUNC_ERROR("miicv_attach");
}
coords[TST_X] = 0;
coords[TST_Y] = 0;
coords[TST_Z] = 0;
lengths[TST_X] = dims[TST_X].length;
lengths[TST_Y] = dims[TST_Y].length;
lengths[TST_Z] = dims[TST_Z].length;
stat = miicv_get(icv, coords, lengths, buf_ptr);
if (stat < 0) {
FUNC_ERROR("miicv_get");
}
int_ptr = (int *) buf_ptr;
for (i = 0; i < dims[TST_X].length; i++) {
for (j = 0; j < dims[TST_Y].length; j++) {
for (k = 0; k < dims[TST_Z].length; k++, int_ptr++) {
int tmp = (i * 10000) + (j * 100) + (k);
int rng = (XSIZE * 10000) / 1000;
/* Round tmp properly. */
tmp = (tmp + (rng / 2)) / rng;
if (*int_ptr != tmp) {
fprintf(stderr, "5. Data error at (%d,%d,%d) %d != %d\n",
i,j,k, *int_ptr, tmp);
errors++;
}
}
}
}
stat = miicv_detach(icv);
if (stat < 0) {
FUNC_ERROR("miicv_detach");
}
/* Free the ICV */
stat = miicv_free(icv);
if (stat < 0) {
FUNC_ERROR("miicv_free");
}
free(buf_ptr);
return (0);
}