/* ----------------------------- MNI Header -----------------------------------
@NAME : get_full_range
@INPUT : mincid - id of the input minc file
@OUTPUT : range - 2-value array giving real range of input values
@RETURNS : (nothing)
@DESCRIPTION: Routine to get the full real range of an input file.
@METHOD :
@GLOBALS :
@CALLS :
@CREATED : December 8, 1994 (Peter Neelin)
@MODIFIED :
---------------------------------------------------------------------------- */
static void get_full_range(int mincid, double range[2])
{
char *string;
int varid;
int ivar, idim, ndims;
int dim[MAX_VAR_DIMS];
double sign, *extreme, *values;
long start[MAX_VAR_DIMS], count[MAX_VAR_DIMS], num_values;
long ivalue, length;
/* Loop over image-min and image-max variables */
range[0] = 0.0;
range[1] = 1.0;
for (ivar=0; ivar < 2; ivar++) {
if (ivar==0) {
string = MIimagemin;
sign = -1.0;
extreme = &range[0];
}
else {
string = MIimagemax;
sign = +1.0;
extreme = &range[1];
}
ncopts = 0;
varid = ncvarid(mincid, string);
ncopts = NCOPTS_DEFAULT;
if (varid != MI_ERROR) {
(void) ncvarinq(mincid, varid, NULL, NULL, &ndims, dim, NULL);
num_values = 1;
for (idim=0; idim < ndims; idim++) {
(void) ncdiminq(mincid, dim[idim], NULL, &length);
start[idim] = 0;
count[idim] = length;
num_values *= length;
}
if (num_values > 0) {
values = malloc(num_values * sizeof(*values));
(void) mivarget(mincid, varid, start, count,
NC_DOUBLE, NULL, values);
*extreme = values[0];
for (ivalue=0; ivalue < num_values; ivalue++) {
if ((values[ivalue] * sign) > (*extreme * sign))
*extreme = values[ivalue];
}
free(values);
}
} /* If variable is found */
} /* Loop over image-min/max */
return;
}
int
test3(struct testinfo *ip, struct dimdef *dims, int ndims)
{
/* Try to read the data back. */
size_t total;
long coords[3];
long lengths[3];
void *buf_ptr;
int *int_ptr;
int i, j, k;
int stat;
total = 1;
for (i = 0; i < ndims; i++) {
total *= dims[i].length;
}
buf_ptr = malloc(total * sizeof (int));
if (buf_ptr == NULL) {
fprintf(stderr, "Oops, malloc failed\n");
return (-1);
}
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 = mivarget(ip->fd, ip->imgid, coords, lengths, NC_INT, MI_SIGNED,
buf_ptr);
if (stat < 0) {
FUNC_ERROR("mivarget");
}
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 tmp = (i * 10000) + (j * 100) + k;
if (*int_ptr != tmp) {
fprintf(stderr, "1. Data error at (%d,%d,%d)\n", i,j,k);
errors++;
}
int_ptr++;
}
}
}
free(buf_ptr);
return (0);
}
/* ----------------------------- MNI Header -----------------------------------
@NAME : get_block_min_and_max
@INPUT : reshape_info - information for reshaping volume
block_start - start of current block
block_count - count for current block
minmax_buffer - buffer space for getting min and max
values
@OUTPUT : minimum - input minimum for block
maximum - input maximum for block
@RETURNS : (none)
@DESCRIPTION: Gets the min and max for the input file for a given output
block.
@METHOD :
@GLOBALS :
@CALLS :
@CREATED : October 25, 1994 (Peter Neelin)
@MODIFIED :
---------------------------------------------------------------------------- */
static void get_block_min_and_max(Reshape_info *reshape_info,
long *block_start,
long *block_count,
double *minmax_buffer,
double *minimum,
double *maximum)
{
int iloop;
long num_min_values, num_max_values, ivalue;
int inmincid, inimgid, varid, icvid;
long minmax_start[MAX_VAR_DIMS], minmax_count[MAX_VAR_DIMS];
long input_block_start[MAX_VAR_DIMS], input_block_count[MAX_VAR_DIMS];
double *extreme;
long num_values;
char *varname;
double sign, default_extreme;
/* Get input minc id, image id and icv id*/
inmincid = reshape_info->inmincid;
inimgid = ncvarid(inmincid, MIimage);
icvid = reshape_info->icvid;
/* Is the icv doing the normalization? */
if (reshape_info->do_icv_normalization) {
(void) miicv_inqdbl(icvid, MI_ICV_NORM_MIN, minimum);
(void) miicv_inqdbl(icvid, MI_ICV_NORM_MAX, maximum);
return;
}
/* Translate output block count to input count */
translate_output_to_input(reshape_info, block_start, block_count,
input_block_start, input_block_count);
truncate_input_vectors(reshape_info, input_block_start, input_block_count);
/* Get number of min and max values */
get_num_minmax_values(reshape_info, block_start, block_count,
&num_min_values, &num_max_values);
/* Loop over image-min and image-max getting block min and max */
for (iloop=0; iloop < 2; iloop++) {
/* Get varid and pointer to min or max value */
switch (iloop) {
case 0:
num_values = num_min_values;
varname = MIimagemin;
extreme = minimum;
sign = -1.0;
default_extreme = 0.0;
break;
case 1:
num_values = num_max_values;
varname = MIimagemax;
extreme = maximum;
sign = +1.0;
default_extreme = 1.0;
break;
}
/* Get values from file */
if (num_values > 0) {
varid = ncvarid(inmincid, varname);
(void) mitranslate_coords(inmincid,
inimgid, input_block_start,
varid, minmax_start);
(void) mitranslate_coords(inmincid,
inimgid, input_block_count,
varid, minmax_count);
(void) mivarget(reshape_info->inmincid, varid,
minmax_start, minmax_count,
NC_DOUBLE, NULL, minmax_buffer);
*extreme = minmax_buffer[0];
for (ivalue=1; ivalue < num_values; ivalue++) {
if ((minmax_buffer[ivalue] * sign) > (*extreme * sign))
*extreme = minmax_buffer[ivalue];
}
}
else {
*extreme = default_extreme;
}
if (reshape_info->need_fillvalue &&
(reshape_info->fillvalue == NOFILL) &&
(0.0 > (*extreme * sign)))
*extreme = 0.0;
}
}
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);
}
static int
test3(struct testinfo *ip, struct dimdef *dims, int ndims)
{
/* Try to read the data back. */
size_t total;
long coords[3];
long lengths[3];
void *buf_ptr;
int *int_ptr;
int i, j, k;
int stat;
int varid;
int att_length;
nc_type att_datatype;
char *att;
total = 1;
for (i = 0; i < ndims; i++) {
total *= dims[i].length;
}
buf_ptr = malloc(total * sizeof (int));
if (buf_ptr == NULL) {
fprintf(stderr, "Oops, malloc failed\n");
return (-1);
}
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 = mivarget(ip->fd, ip->imgid, coords, lengths, NC_INT, MI_SIGNED,
buf_ptr);
if (stat < 0) {
FUNC_ERROR("mivarget");
}
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 tmp = (i * 10000) + (j * 100) + k;
if (*int_ptr != tmp) {
fprintf(stderr, "1. Data error at (%d,%d,%d)\n", i,j,k);
errors++;
}
int_ptr++;
}
}
}
free(buf_ptr);
varid = ncvarid(ip->fd, "test");
if(varid<0)
FUNC_ERROR("ncvarid");
if ((ncattinq(ip->fd, varid, "test", &att_datatype, &att_length) == MI_ERROR) ||
(att_datatype != NC_CHAR))
FUNC_ERROR("ncattinq");
if(att_length!=ip->attribute_size)
FUNC_ERROR("Wrong attribute length!");
att=malloc(att_length);
if(miattgetstr(ip->fd, varid, "test", att_length, att)==NULL)
FUNC_ERROR("miattgetstr");
if(memcmp(att,ip->large_attribute,att_length)!=0)
FUNC_ERROR("Attribute contents mismath!");
free(att);
return (0);
}
int main(int argc, char *argv[])
{
char **infiles, *outfiles[3];
int nfiles, nout;
char *arg_string;
Norm_Data norm_data;
Average_Data average_data;
Loop_Options *loop_options;
double *vol_mean, vol_total, nvols, global_mean, total_weight;
int ifile, iweight;
int weights_specified;
int first_mincid, dimid, varid, dim[MAX_VAR_DIMS];
int ndims;
long start, count;
int old_ncopts;
int strlength;
char dimname[MAX_NC_NAME];
/* Save time stamp and args */
arg_string = time_stamp(argc, argv);
/* Get arguments */
if (ParseArgv(&argc, argv, argTable, 0) || (argc < 2)) {
(void) fprintf(stderr,
"\nUsage: %s [options] [<in1.mnc> ...] <out.mnc>\n",
argv[0]);
(void) fprintf(stderr,
" %s -help\n\n", argv[0]);
exit(EXIT_FAILURE);
}
outfiles[0] = outfiles[1] = outfiles[2] = NULL;
outfiles[0] = argv[argc-1];
nout = 1;
if( sdfile != NULL )
outfiles[nout++] = sdfile;
if( weightfile != NULL )
outfiles[nout++] = weightfile;
first_mincid = MI_ERROR;
/* Get the list of input files either from the command line or
from a file, or report an error if both are specified */
nfiles = argc - 2;
if (filelist == NULL) {
infiles = &argv[1];
}
else if (nfiles <= 0) {
infiles = read_file_names(filelist, &nfiles);
if (infiles == NULL) {
(void) fprintf(stderr,
"Error reading in file names from file \"%s\"\n",
filelist);
exit(EXIT_FAILURE);
}
}
else {
(void) fprintf(stderr,
"Do not specify both -filelist and input file names\n");
exit(EXIT_FAILURE);
}
/* Make sure that we have something to process */
if (nfiles == 0) {
(void) fprintf(stderr, "No input files specified\n");
exit(EXIT_FAILURE);
}
/* Set default value of copy_all_header */
if (copy_all_header == DEFAULT_BOOLEAN) {
copy_all_header = (nfiles <= 1);
}
/* Are we averaging over a dimension? */
average_data.averaging_over_dimension = (averaging_dimension != NULL);
/* Check for weights and width-weighting */
weights_specified = weights.numvalues > 0;
if (weights_specified && width_weighted) {
(void) fprintf(stderr,
"%s: Please do not specify weights and width-weighting.\n",
argv[0]);
exit(EXIT_FAILURE);
}
/* Default is no weighting */
average_data.num_weights = 0;
average_data.weights = NULL;
/* Check for weights */
if (weights_specified) {
if (averaging_dimension == NULL) {
if (weights.numvalues != nfiles) {
(void) fprintf(stderr,
"%s: Number of weights does not match number of files.\n",
argv[0]);
exit(EXIT_FAILURE);
}
}
else {
if (nfiles > 1) {
(void) fprintf(stderr,
"%s: Only one input file allowed with -weights and -avgdim.\n",
argv[0]);
exit(EXIT_FAILURE);
}
/* Check that the dimension size matches the number of weights */
first_mincid = miopen(infiles[0], NC_NOWRITE);
dimid = ncdimid(first_mincid, averaging_dimension);
(void) ncdiminq(first_mincid, dimid, NULL, &count);
if (weights.numvalues != count) {
(void) fprintf(stderr,
"%s: Number of weights does not match size of dimension.\n",
argv[0]);
}
}
/* Save the weights */
average_data.num_weights = weights.numvalues;
average_data.weights =
malloc(sizeof(*average_data.weights) * average_data.num_weights);
for (iweight=0; iweight < average_data.num_weights; iweight++) {
average_data.weights[iweight] = weights.values[iweight];
}
free(weights.values);
}
/* Check for width weighting */
if (width_weighted) {
/* Check for errors */
if (averaging_dimension == NULL) {
(void) fprintf(stderr,
"%s: Please specify -avgdim with -width_weighted.\n",
argv[0]);
exit(EXIT_FAILURE);
}
if (nfiles > 1) {
(void) fprintf(stderr,
"%s: Use -width_weighted with only one input file.\n",
argv[0]);
exit(EXIT_FAILURE);
}
/* Open the file */
first_mincid = miopen(infiles[0], NC_NOWRITE);
/* Get the dimension id */
dimid = ncdimid(first_mincid, averaging_dimension);
/* Look for the width variable */
strlength = MAX_NC_NAME - strlen(WIDTH_SUFFIX) - 1;
(void) strncpy(dimname, averaging_dimension, strlength);
dimname[strlength] = '\0';
(void) strcat(dimname, WIDTH_SUFFIX);
old_ncopts = ncopts; ncopts = 0;
varid = ncvarid(first_mincid, dimname);
(void) ncvarinq(first_mincid, varid, NULL, NULL, &ndims, dim, NULL);
ncopts = old_ncopts;
if (varid != MI_ERROR) {
/* Check that things match up */
if ((ndims != 1) || (dim[0] != dimid)) {
(void) fprintf(stderr,
"%s: Dimension width variable does not match avgdim.\n",
argv[0]);
}
/* Get the size of the dimension */
(void) ncdiminq(first_mincid, dim[0], NULL, &count);
average_data.num_weights = count;
average_data.weights =
malloc(sizeof(*average_data.weights) * average_data.num_weights);
/* Read in the widths */
start = 0;
(void) mivarget(first_mincid, varid, &start, &count, NC_DOUBLE, NULL,
average_data.weights);
}
} /* If width_weighted */
/* Check that weights sum to non-zero. We don't need to normalize them,
since a running sum is done in the averaging. */
if (average_data.num_weights > 0) {
total_weight = 0.0;
for (iweight=0; iweight < average_data.num_weights; iweight++) {
total_weight += average_data.weights[iweight];
}
if (total_weight == 0.0) {
(void) fprintf(stderr, "%s: Weights sum to zero.\n", argv[0]);
exit(EXIT_FAILURE);
}
}
/* If we don't have weights, each input will get a weight of 1 */
if (average_data.num_weights == 0)
total_weight = nfiles;
/* Check the cumulative weight thresholding */
if (weight_thresh > 0.0 && weight_thresh_fraction > 0.0){
(void) fprintf(stderr,
"Do not specify both -min_weight -min_weight_fraction\n");
exit(EXIT_FAILURE);
}
else if( weight_thresh_fraction > 0.0 ){
weight_thresh = weight_thresh_fraction * total_weight;
}
average_data.weight_thresh = weight_thresh;
/* Check for binarization */
if (binarize) {
if (normalize == TRUE) {
(void) fprintf(stderr,
"%s: Normalization and binarization cannot both be specified\n",
argv[0]);
exit(EXIT_FAILURE);
}
normalize = FALSE;
if (binvalue != -DBL_MAX) {
binrange[0] = binvalue - 0.5;
binrange[1] = binvalue + 0.5;
}
if (binrange[0] > binrange[1]) {
(void) fprintf(stderr,
"%s: Please specify a binarization range with min less than max\n",
argv[0]);
exit(EXIT_FAILURE);
}
average_data.binrange[0] = binrange[0];
average_data.binrange[1] = binrange[1];
}
average_data.binarize = binarize;
/* Store the ignore above/below values */
average_data.ignore_below = ignore_below;
average_data.ignore_above = ignore_above;
/* Check for no specification of normalization */
#ifdef NO_DEFAULT_NORM
if (normalize == -1) {
(void) fprintf(stderr, "\n%s: %s\n\n%s\n%s\n%s\n%s\n%s\n\n", argv[0],
"Please specify either -norm or -nonorm.",
"The default setting for normalization is being changed from \"-norm\" to",
"\"-nonorm\". To prevent undetected problems with data, this program will ",
"not work unless one of these flags is explicitly given on the command-line",
"(ie. no default is permitted). The new default will come into effect some",
"time in the future."
);
exit(EXIT_FAILURE);
}
#endif
/* Do normalization if needed */
average_data.norm_factor =
malloc(sizeof(*average_data.norm_factor) * nfiles);
if (normalize) {
vol_mean = malloc(sizeof(*vol_mean) * nfiles);
loop_options = create_loop_options();
set_loop_verbose(loop_options, FALSE);
#if MINC2
set_loop_v2format(loop_options, minc2_format);
#endif /* MINC2 */
set_loop_accumulate(loop_options, TRUE, 0, NULL, NULL);
set_loop_buffer_size(loop_options, (long) 1024 * max_buffer_size_in_kb);
set_loop_check_dim_info(loop_options, check_dimensions);
vol_total = 0.0;
nvols = 0;
if (verbose) {
(void) fprintf(stderr, "Normalizing:");
(void) fflush(stderr);
}
for (ifile=0; ifile < nfiles; ifile++) {
norm_data.threshold_set = FALSE;
norm_data.sum0 = 0.0;
norm_data.sum1 = 0.0;
if (verbose) {
(void) fprintf(stderr, ".");
(void) fflush(stderr);
}
if (first_mincid != MI_ERROR) {
set_loop_first_input_mincid(loop_options, first_mincid);
first_mincid = MI_ERROR;
}
voxel_loop(1, &infiles[ifile], 0, NULL, NULL, loop_options,
do_normalization, (void *) &norm_data);
if (norm_data.sum0 > 0.0) {
vol_mean[ifile] = norm_data.sum1 / norm_data.sum0;
vol_total += vol_mean[ifile];
nvols++;
}
else {
vol_mean[ifile] = 0.0;
}
if (debug) {
(void) fprintf(stderr, "Volume %d mean = %.15g\n",
ifile, vol_mean[ifile]);
}
}
free_loop_options(loop_options);
if (verbose) {
(void) fprintf(stderr, "Done\n");
(void) fflush(stderr);
}
if (nvols > 0)
global_mean = vol_total / nvols;
else
global_mean = 0.0;
for (ifile=0; ifile < nfiles; ifile++) {
if (vol_mean[ifile] > 0.0)
average_data.norm_factor[ifile] = global_mean / vol_mean[ifile];
else
average_data.norm_factor[ifile] = 0.0;
if (debug) {
(void) fprintf(stderr, "Volume %d norm factor = %.15g\n",
ifile, average_data.norm_factor[ifile]);
}
}
free(vol_mean);
}
else {
for (ifile=0; ifile < nfiles; ifile++) {
average_data.norm_factor[ifile] = 1.0;
}
}
/* Do averaging */
average_data.need_sd = (sdfile != NULL);
average_data.need_weight = (weightfile != NULL);
loop_options = create_loop_options();
if (first_mincid != MI_ERROR) {
set_loop_first_input_mincid(loop_options, first_mincid);
first_mincid = MI_ERROR;
}
set_loop_verbose(loop_options, verbose);
set_loop_clobber(loop_options, clobber);
set_loop_datatype(loop_options, datatype, is_signed,
valid_range[0], valid_range[1]);
set_loop_accumulate(loop_options, TRUE, 1, start_average, finish_average);
set_loop_copy_all_header(loop_options, copy_all_header);
set_loop_dimension(loop_options, averaging_dimension);
set_loop_buffer_size(loop_options, (long) 1024 * max_buffer_size_in_kb);
set_loop_check_dim_info(loop_options, check_dimensions);
voxel_loop(nfiles, infiles, nout, outfiles, arg_string, loop_options,
do_average, (void *) &average_data);
free_loop_options(loop_options);
/* Free stuff */
free(average_data.weights);
free(average_data.norm_factor);
exit(EXIT_SUCCESS);
}
