void ReadImages (VString Name, VAttrList& Images, VAttrList& history_list)
{
FILE* file; /* input file */
VAttrList list, list1; /* attribute list */
VAttrListPosn pos; /* position in list */
VImage image; /* image in list */
/* initialize results */
Images = NULL;
/* open file */
file = fopen (Name, "r");
if (!file)
{
VError ("Failed to open input file '%s'", Name);
return;
}
/* read file */
list = VReadFile (file, NULL);
if (!list)
{
VError ("Failed to read input file '%s'", Name);
fclose (file);
return;
}
/* Read History */
list1 = VReadHistory(&list);
if (list1==NULL) list1=VCreateAttrList();
history_list = VCopyAttrList(list1);
/* extract images */
for (VFirstAttr (list, &pos); VAttrExists (&pos); VNextAttr (&pos))
{
if (VGetAttrRepn (&pos) != VImageRepn) continue;
if (!Images) Images = VCreateAttrList ();
VGetAttrValue (&pos, NULL, VImageRepn, &image);
VSetAttrValue (&pos, NULL, VImageRepn, NULL);
VAppendAttr (Images, "image", NULL, VImageRepn, image);
}
if (!Images) VError ("Input file '%s' does not contain an image", Name);
/* clean-up*/
VDestroyAttrList (list);
fclose (file);
} /* ReadImages */
VGraph VCreateGraph (int size, int nfields, VRepnKind repn, int useW)
{
VGraph graph;
/* Check parameters: */
if (size < 1 || nfields < 1)
VWarning ("VCreateGraph: Invalid number of nodes or fields.");
/* Allocate memory for the VGraph, and the node table: */
graph = VMalloc (sizeof (VGraphRec));
if (graph == NULL) return NULL;
graph->table = VCalloc(size, sizeof(VNode));
if (graph->table == NULL) {
VFree(graph);
return NULL;
};
/* Initialize the VGraph: */
graph->nnodes = 0;
graph->nfields = nfields;
graph->node_repn = repn;
graph->attributes = VCreateAttrList ();
graph->lastUsed = 0;
graph->size = size;
graph->useWeights = useW;
graph->iter = 0;
return graph;
}
VBoolean VWriteObjects (FILE *file, VRepnKind repn, VAttrList attributes,
int nobjects, VPointer objects[])
{
VAttrList list;
VAttrListPosn posn;
int i;
VBoolean result;
/* Create an attribute list if none was supplied: */
list = attributes ? attributes : VCreateAttrList ();
/* Prepend to the attribute list an attribute for each object: */
for (i = nobjects - 1; i >= 0; i--)
VPrependAttr (list, VRepnName (repn), NULL, repn, objects[i]);
/* Write the attribute list: */
result = VWriteFile (file, list);
/* Remove the attributes just prepended: */
VFirstAttr (list, & posn);
for (i = 0; i < nobjects; i++)
VDeleteAttr (& posn);
if (list != attributes)
VDestroyAttrList (list);
return result;
}
int main (int argc, char **argv)
{
FILE *in_file, *out_file;
VImage image;
VAttrList list = VCreateAttrList ();
char prg[50];
sprintf(prg,"plaintov V%s", getVersion());
fprintf (stderr, "%s\n", prg);
VParseFilterCmd (VNumber (options), options, argc, argv,
& in_file, & out_file);
if (! (image = VReadPlain (in_file)))
exit (EXIT_FAILURE);
VHistory(VNumber(options),options,prg,&list,&list);
VAppendAttr (list, object_name, NULL, VImageRepn, image);
if (! VWriteFile (out_file, list))
exit (EXIT_FAILURE);
fprintf (stderr, "%s: Converted 1 file from Vista plain format"
" to Vista format.\n", argv[0]);
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[]) {
static VString cfile = "";
static VFloat tr = 2;
static VBoolean normalize = FALSE;
static VOptionDescRec options[] = {
{"in", VStringRepn, 1, (VPointer) &cfile, VRequiredOpt, NULL, "file"},
{"tr", VFloatRepn, 1, (VPointer) &tr, VRequiredOpt, NULL, "TR in seconds"},
{"normalize", VBooleanRepn, 1, (VPointer) &normalize, VOptionalOpt, NULL, "Whether to normalize"}
};
FILE *out_file = NULL;
VAttrList list = NULL;
VImage dest = NULL;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vcovariates V%s", ver);
fprintf(stderr, "%s\n", prg_name);
VParseFilterCmd(VNumber(options), options, argc, argv, NULL, &out_file);
if(tr > 500)
VError(" tr must be given in seconds, not milliseconds");
dest = VCovariates(cfile, tr, normalize);
list = VCreateAttrList();
VAppendAttr(list, "image", NULL, VImageRepn, dest);
/* Output: */
if(! VWriteFile(out_file, list))
exit(1);
fprintf(stderr, " %s: done.\n", argv[0]);
return 0;
}
int
main(int argc, char *argv[]) {
static VString filename = "";
static VBoolean fisher = FALSE;
static VShort minval = 0;
static VOptionDescRec options[] = {
{"mask", VStringRepn, 1, (VPointer) &filename, VRequiredOpt, NULL, "mask"},
{"fisher", VBooleanRepn, 1, (VPointer) &fisher, VOptionalOpt, NULL, "Whether to do fisher transform"},
{"minval", VShortRepn, 1, (VPointer) &minval, VOptionalOpt, NULL, "signal threshold"}
};
FILE *in_file, *out_file, *fp;
VAttrList list = NULL, list1 = NULL, list2 = NULL;
VAttrListPosn posn;
VImage dest = NULL, mask = NULL;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vsimmat V%s", ver);
fprintf(stderr, "%s\n", prg_name);
VParseFilterCmd(VNumber(options), options, argc, argv, &in_file, &out_file);
/*
** read mask
*/
fp = VOpenInputFile(filename, TRUE);
list1 = VReadFile(fp, NULL);
if(! list1)
VError("Error reading mask file");
fclose(fp);
for(VFirstAttr(list1, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & mask);
if(VPixelRepn(mask) != VBitRepn) {
mask = NULL;
continue;
}
}
if(mask == NULL)
VError(" no mask found");
/*
** read functional data
*/
if(!(list = VReadFile(in_file, NULL)))
exit(1);
fclose(in_file);
/*
** process
*/
dest = SimilarityMatrix(list, mask, minval, fisher);
list2 = VCreateAttrList();
VAppendAttr(list2, "matrix", NULL, VImageRepn, dest);
VHistory(VNumber(options), options, prg_name, &list, &list2);
if(! VWriteFile(out_file, list2))
exit(1);
fprintf(stderr, "%s: done.\n", argv[0]);
return 0;
}
static VAttrList VGraphEncodeAttrMethod (VPointer value, size_t *lengthp)
{
VGraph graph = value;
VAttrList list;
size_t len, nadj;
int i, slong, sfloat, spriv, nnodes;
VNode n;
VAdjacency adj;
/* Compute the file space needed for the Graph's binary data: */
len = 0;
slong = VRepnPrecision (VLongRepn) / 8;
sfloat = VRepnPrecision (VFloatRepn) / 8;
spriv = graph->nfields * VRepnPrecision (graph->node_repn) / 8;
nnodes = 0;
for (i = 1; i <= graph->size; i++) {
n = VGraphGetNode(graph, i); if (n == 0) continue;
++nnodes;
/* Count the number of adjacencies : */
for (adj = n->base.head, nadj = 0; adj; adj = adj->next) nadj++;
/* each node contains:
* an index and the number of adjacencies
* the private data area
* the list of adjacencies
* optionally reserve space for weights
*/
len += 2 * slong + nadj * slong + spriv;
if (graph->useWeights) len += (nadj+1) * sfloat;
};
*lengthp = len;
assert(nnodes == graph->nnodes); /* for debugging */
graph->nnodes = nnodes; /* just to be safe for now... */
/* Temporarily prepend several attributes to the graph's list: */
if ((list = VGraphAttrList (graph)) == NULL)
list = VGraphAttrList (graph) = VCreateAttrList ();
VPrependAttr (list, VRepnAttr, VNumericRepnDict,
VLongRepn, (VLong) graph->node_repn);
VPrependAttr (list, VNNodeFieldsAttr, NULL, VLongRepn,
(VLong) graph->nfields);
VPrependAttr (list, VNGraphSizeAttr, NULL, VLongRepn,
(VLong) graph->size);
VPrependAttr (list, VNNodeWeightsAttr, NULL, VLongRepn,
(VLong) graph->useWeights);
return list;
}
VBoolean WriteImages (VString Name, VAttrList Images, VAttrList& history_list)
{
FILE* file; /* output file */
VAttrList list; /* attribute list */
VAttrListPosn pos; /* position in list */
VImage image; /* image in list */
VBoolean success; /* success flag */
char history[]="history";
/* open file */
file = fopen (Name, "w");
if (!file)
{
VError ("Failed to open output file '%s'", Name);
return FALSE;
}
/* create list */
list = VCreateAttrList();
/* insert images */
for (VFirstAttr (Images, &pos); VAttrExists (&pos); VNextAttr (&pos))
{
VGetAttrValue (&pos, NULL, VImageRepn, &image);
VAppendAttr (list, VGetAttrName (&pos), NULL, VImageRepn, image);
}
/* Prepend history */
VPrependAttr(list, history ,NULL,VAttrListRepn,history_list);
/* write file */
success = VWriteFile (file, list);
if (!success) VError ("Failed to write output file '%s'", Name);
/* remove images */
for (VFirstAttr (list, &pos); VAttrExists (&pos); VNextAttr (&pos))
if (VGetAttrRepn (&pos) == VImageRepn)
VSetAttrValue (&pos, NULL, VImageRepn, NULL);
/* clean-up*/
VDestroyAttrList (list);
fclose (file);
return success;
} /* WriteImages */
VImage VCopyImageAttrs (VImage src, VImage dest)
{
VAttrList list;
if (src == dest)
return dest;
if (! dest) {
dest = VCreateImage (VImageNBands (src), VImageNRows (src),
VImageNColumns (src), VPixelRepn (src));
if (! dest)
return NULL;
}
/* Clone the source image's attribute list if it isn't empty: */
if (! VAttrListEmpty (VImageAttrList (src))) {
list = VImageAttrList (dest);
VImageAttrList (dest) = VCopyAttrList (VImageAttrList (src));
} else if (! VAttrListEmpty (VImageAttrList (dest))) {
list = VImageAttrList (dest);
VImageAttrList (dest) = VCreateAttrList ();
} else list = NULL;
if (list)
VDestroyAttrList (list);
/* Preserve band interpretation attributes only if the source and
destination images have the same number of bands: */
if (VImageNBands (src) > 1 && VImageNBands (dest) == VImageNBands (src)) {
VImageNFrames (dest) = VImageNFrames (src);
VImageNViewpoints (dest) = VImageNViewpoints (src);
VImageNColors (dest) = VImageNColors (src);
VImageNComponents (dest) = VImageNComponents (src);
} else {
VExtractAttr (VImageAttrList (dest), VFrameInterpAttr, NULL,
VBitRepn, NULL, FALSE);
VExtractAttr (VImageAttrList (dest), VViewpointInterpAttr, NULL,
VBitRepn, NULL, FALSE);
VExtractAttr (VImageAttrList (dest), VColorInterpAttr, NULL,
VBitRepn, NULL, FALSE);
VExtractAttr (VImageAttrList (dest), VComponentInterpAttr, NULL,
VBitRepn, NULL, FALSE);
VImageNComponents (dest) = VImageNColors (dest) =
VImageNViewpoints (dest) = 1;
VImageNFrames (dest) = VImageNBands (dest);
}
return dest;
}
VEdges VCreateEdges (int nrows, int ncolumns,
int nedge_fields, int npoint_fields)
{
VEdges edges;
/* Check parameters: */
if (nrows < 1 || ncolumns < 1)
VWarning ("VCreateEdges: Invalid number of rows or columns.");
/* Allocate memory for the VEdges, its indices, and pixel values: */
edges = VMalloc (sizeof (VEdgesRec));
/* Initialize the VEdges: */
edges->nrows = nrows;
edges->ncolumns = ncolumns;
edges->attributes = VCreateAttrList ();
edges->nedge_fields = nedge_fields;
edges->npoint_fields = npoint_fields;
edges->nedges = edges->npoints = 0;
edges->first = edges->last = NULL;
edges->free = NULL;
return edges;
}
static VAttrList VImageEncodeAttrMethod (VPointer value, size_t *lengthp)
{
VImage image = value;
VAttrList list;
size_t length;
#define OptionallyPrepend(value, name) \
if (value != 1) \
VPrependAttr (list, name, NULL, VLongRepn, (VLong) value)
/* Temporarily prepend several attributes to the image's attribute list: */
if ((list = VImageAttrList (image)) == NULL)
list = VImageAttrList (image) = VCreateAttrList ();
VPrependAttr (list, VRepnAttr, VNumericRepnDict,
VLongRepn, (VLong) VPixelRepn (image));
VPrependAttr (list, VNColumnsAttr, NULL,
VLongRepn, (VLong) VImageNColumns (image));
VPrependAttr (list, VNRowsAttr, NULL,
VLongRepn, (VLong) VImageNRows (image));
OptionallyPrepend (VImageNComponents (image), VNComponentsAttr);
OptionallyPrepend (VImageNColors (image), VNColorsAttr);
OptionallyPrepend (VImageNViewpoints (image), VNViewpointsAttr);
OptionallyPrepend (VImageNFrames (image), VNFramesAttr);
OptionallyPrepend (VImageNBands (image), VNBandsAttr);
/* Compute the file space needed for the image's binary data: */
length = VImageNPixels (image);
if (VPixelRepn (image) == VBitRepn)
length = (length + 7) / 8;
else length *= VPixelPrecision (image) / 8;
*lengthp = length;
return list;
#undef OptionallyPrepend
}
int main(int argc, char *argv[]) {
static VArgVector in_files1;
static VArgVector in_files2;
static VString out_filename;
static VShort type = 1;
static VBoolean gauss = FALSE;
static VOptionDescRec options[] = {
{"in1", VStringRepn, 0, & in_files1, VRequiredOpt, NULL, "Input files 1" },
{"in2", VStringRepn, 0, & in_files2, VRequiredOpt, NULL, "Input files 2" },
{"type", VShortRepn, 1, (VPointer) &type, VOptionalOpt, TypeDict, "output type"},
{"gaussianize", VBooleanRepn, 1, (VPointer) &gauss, VOptionalOpt, NULL, "Whether to Gaussianize"},
{"out", VStringRepn, 1, & out_filename, VRequiredOpt, NULL, "Output file" }
};
FILE *fp = NULL;
VStringConst in_filename, buf1, buf2;
VAttrList list1, list2, out_list;
VAttrListPosn posn;
VString str;
VImage src, *src1, *src2, dest = NULL;
int i, nimages, npix = 0;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vpaired_ttest V%s", ver);
fprintf(stderr, "%s\n", prg_name);
/*
** parse command line
*/
if(! VParseCommand(VNumber(options), options, & argc, argv)) {
VReportUsage(argv[0], VNumber(options), options, NULL);
exit(EXIT_FAILURE);
}
if(argc > 1) {
VReportBadArgs(argc, argv);
exit(EXIT_FAILURE);
}
if(type < 0 || type > 1)
VError(" illegal type");
/* ini */
nimages = in_files1.number;
if(in_files2.number != nimages)
VError(" inconsistent number of files %d %d", nimages, in_files2.number);
for(i = 0; i < nimages; i++) {
buf1 = ((VStringConst *) in_files1.vector)[i];
buf2 = ((VStringConst *) in_files2.vector)[i];
fprintf(stderr, "%3d: %s %s\n", i, buf1, buf2);
}
fprintf(stderr, "\n");
/* images 1 */
src1 = (VImage *) VCalloc(nimages, sizeof(VImage));
for(i = 0; i < nimages; i++) {
src1[i] = NULL;
in_filename = ((VStringConst *) in_files1.vector)[i];
fp = VOpenInputFile(in_filename, TRUE);
list1 = VReadFile(fp, NULL);
if(! list1)
VError("Error reading image");
fclose(fp);
for(VFirstAttr(list1, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & src);
if(VPixelRepn(src) != VFloatRepn)
continue;
if(VGetAttr(VImageAttrList(src), "modality", NULL, VStringRepn, &str) == VAttrFound) {
if(strcmp(str, "conimg") != 0)
continue;
}
if(i == 0)
npix = VImageNPixels(src);
else if(npix != VImageNPixels(src))
VError(" inconsistent image dimensions");
src1[i] = src;
break;
}
if(src1[i] == NULL)
VError(" no contrast image found in %s", in_filename);
}
/* images 2 */
src2 = (VImage *) VCalloc(nimages, sizeof(VImage));
for(i = 0; i < nimages; i++) {
src2[i] = NULL;
in_filename = ((VStringConst *) in_files2.vector)[i];
fp = VOpenInputFile(in_filename, TRUE);
list2 = VReadFile(fp, NULL);
if(! list2)
VError("Error reading image");
fclose(fp);
for(VFirstAttr(list2, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & src);
if(VPixelRepn(src) != VFloatRepn)
continue;
if(VGetAttr(VImageAttrList(src), "modality", NULL, VStringRepn, &str) == VAttrFound) {
if(strcmp(str, "conimg") != 0)
continue;
}
if(npix != VImageNPixels(src))
VError(" inconsistent image dimensions");
src2[i] = src;
break;
}
if(src2[i] == NULL)
VError(" no contrast image found in %s", in_filename);
}
/* make normally distributed */
if(gauss) {
VGaussianize(src1, nimages);
VGaussianize(src2, nimages);
}
/* paired t-test */
dest = PairedTest(src1, src2, dest, nimages, type);
/*
** output
*/
out_list = VCreateAttrList();
VHistory(VNumber(options), options, prg_name, &list1, &out_list);
VAppendAttr(out_list, "image", NULL, VImageRepn, dest);
fp = VOpenOutputFile(out_filename, TRUE);
if(! VWriteFile(fp, out_list))
exit(1);
fclose(fp);
fprintf(stderr, "%s: done.\n", argv[0]);
exit(0);
}
int
main(int argc, char *argv[]) {
static VArgVector in_files;
static VString out_filename;
static VString filename;
static VShort minval = 0;
static VFloat fwhm = 4.0;
static VOptionDescRec options[] = {
{"in", VStringRepn, 0, & in_files, VRequiredOpt, NULL, "Input files" },
{"out", VStringRepn, 1, & out_filename, VRequiredOpt, NULL, "Output file" },
{"design", VStringRepn, 1, (VPointer) &filename, VRequiredOpt, NULL, "Design file"},
{
"fwhm", VFloatRepn, 1, (VPointer) &fwhm, VOptionalOpt, NULL,
"FWHM of temporal Gaussian filter in seconds"
},
{"minval", VShortRepn, 1, (VPointer) &minval, VOptionalOpt, NULL, "Signal threshold"}
};
FILE *fp = NULL, *f = NULL;
VStringConst in_filename;
VString ifilename;
VAttrList list = NULL, list1 = NULL;
VAttrList out_list = NULL, history_list = NULL;
VAttrListPosn posn;
VImage design = NULL;
ListInfo *linfo;
VLong itr = 0;
VFloat sigma = 0, tr = 0;
int i, n, nimages;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vcolorglm V%s", ver);
fprintf(stderr, "%s\n", prg_name);
/*
** parse command line
*/
if(! VParseCommand(VNumber(options), options, & argc, argv)) {
VReportUsage(argv[0], VNumber(options), options, NULL);
exit(EXIT_FAILURE);
}
if(argc > 1) {
VReportBadArgs(argc, argv);
exit(EXIT_FAILURE);
}
/*
** read design matrix
*/
fp = VOpenInputFile(filename, TRUE);
list1 = VReadFile(fp, NULL);
if(! list1)
VError("Error reading design file");
fclose(fp);
n = 0;
for(VFirstAttr(list1, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & design);
if(VPixelRepn(design) != VFloatRepn /* && VPixelRepn(design) != VDoubleRepn */)
continue;
n++;
break;
}
if(n == 0)
VError(" design matrix not found ");
/*
** get pre-coloring info
*/
if(VGetAttr(VImageAttrList(design), "repetition_time", NULL, VLongRepn, &itr) != VAttrFound)
VError(" TR info missing in header");
tr = (float) itr / 1000.0;
sigma = 0;
if(tr > 0.001 && fwhm > 0.001) {
fprintf(stderr, " TR: %.3f seconds\n", tr);
sigma = fwhm / 2.35482;
sigma /= tr;
if(sigma < 0.1) {
VWarning(" 'fwhm/sigma' too small (%.3f / %.3f), will be set to zero", fwhm, sigma);
sigma = 0;
}
}
/*
** Read each input file
*/
nimages = in_files.number;
linfo = (ListInfo *) VMalloc(sizeof(ListInfo) * nimages);
for(i = 0; i < nimages; i++) {
in_filename = ((VStringConst *) in_files.vector)[i];
ifilename = VNewString(in_filename);
fprintf(stderr, " file: %s\n", ifilename);
list = GetListInfo(ifilename, &linfo[i]);
/* Create history */
if(i == 0) {
history_list = VReadHistory(&list);
if(history_list == NULL)
history_list = VCreateAttrList();
VPrependHistory(VNumber(options), options, prg_name, &history_list);
}
}
/*
** GLM
*/
out_list = VRegression(linfo, nimages, minval, design, sigma, itr);
/*
** Output:
*/
VPrependAttr(out_list, "history", NULL, VAttrListRepn, history_list);
f = VOpenOutputFile(out_filename, TRUE);
if(!f)
VError(" error opening outout file %s", out_filename);
if(! VWriteFile(f, out_list))
exit(1);
fprintf(stderr, "%s: done.\n", argv[0]);
return 0;
}
/*
** general linear regression
*/
VAttrList
VRegression(ListInfo *linfo, int nlists, VShort minval, VImage design, VFloat sigma, VLong itr) {
VAttrList out_list;
VImageInfo *xinfo;
int nbands = 0, nslices = 0, nrows = 0, ncols = 0, slice, row, col, nr, nc;
VImage src[NSLICES], res_image = NULL;
VImage beta_image[MBETA], BCOV = NULL, KX_image = NULL;
VImage res_map[ETMP];
float smooth_fwhm = 0, vx = 0, vy = 0, vz = 0;
VFloat *float_pp, df;
VRepnKind repn;
float d, err;
int i, k, l, n, m = 0, nt, fd = 0, npix = 0;
int i0 = 0, i1 = 0;
double u, sig, trace = 0, trace2 = 0, var = 0, sum = 0, nx = 0, mean = 0, sum2;
float *ptr1, *ptr2;
double x;
gsl_matrix_float *X = NULL, *XInv = NULL, *SX = NULL;
gsl_vector_float *y, *z, *beta, *ys;
gsl_vector *kernel;
gsl_matrix_float *S = NULL, *Vc = NULL, *F = NULL, *P = NULL, *Q = NULL;
gsl_matrix_float *R = NULL, *RV = NULL;
VBoolean smooth = TRUE; /* no smoothness estimation */
gsl_set_error_handler_off();
/*
** read input data
*/
nslices = nbands = nrows = ncols = 0;
for(k = 0; k < nlists; k++) {
n = linfo[k].nslices;
nr = linfo[k].nrows;
nc = linfo[k].ncols;
nt = linfo[k].ntimesteps;
nbands += nt;
if(nslices == 0)
nslices = n;
else if(nslices != n)
VError(" inconsistent image dimensions, slices: %d %d", n, nslices);
if(nrows == 0)
nrows = nr;
else if(nrows != nr)
VError(" inconsistent image dimensions, rows: %d %d", nr, nrows);
if(ncols == 0)
ncols = nc;
else if(ncols != nc)
VError(" inconsistent image dimensions, cols: %d %d", nc, ncols);
}
fprintf(stderr, " num images: %d, image dimensions: %d x %d x %d\n",
nlists, nslices, nrows, ncols);
/*
** get design dimensions
*/
m = VImageNRows(design); /* number of timesteps */
n = VImageNColumns(design); /* number of covariates */
fprintf(stderr, " ntimesteps=%d, num covariates=%d\n", m, n);
if(n >= MBETA)
VError(" too many covariates (%d), max is %d", n, MBETA);
if(m != nbands)
VError(" design dimension inconsistency: %d %d", m, nbands);
fprintf(stderr, " working...\n");
/*
** read design matrix
*/
X = gsl_matrix_float_alloc(m, n);
for(k = 0; k < m; k++) {
for(l = 0; l < n; l++) {
x = VGetPixel(design, 0, k, l);
fmset(X, k, l, (float)x);
}
}
/*
** pre-coloring, set up K-matrix, S=K, V = K*K^T with K=S
*/
S = gsl_matrix_float_alloc(m, m);
GaussMatrix((double)sigma, S);
Vc = fmat_x_matT(S, S, NULL);
/*
** compute pseudoinverse
*/
SX = fmat_x_mat(S, X, NULL);
XInv = fmat_PseudoInv(SX, NULL);
/*
** get variance estimate
*/
Q = fmat_x_mat(XInv, Vc, Q);
F = fmat_x_matT(Q, XInv, F);
BCOV = VCreateImage(1, n, n, VFloatRepn);
float_pp = VImageData(BCOV);
ptr1 = F->data;
for(i = 0; i < n * n; i++)
*float_pp++ = *ptr1++;
gsl_matrix_float_free(Q);
gsl_matrix_float_free(F);
/*
** get effective degrees of freedom
*/
R = gsl_matrix_float_alloc(m, m);
P = fmat_x_mat(SX, XInv, P);
gsl_matrix_float_set_identity(R);
gsl_matrix_float_sub(R, P);
RV = fmat_x_mat(R, Vc, NULL);
trace = 0;
for(i = 0; i < m; i++)
trace += fmget(RV, i, i);
P = fmat_x_mat(RV, RV, P);
trace2 = 0;
for(i = 0; i < m; i++)
trace2 += fmget(P, i, i);
df = (trace * trace) / trace2;
fprintf(stderr, " df= %.3f\n", df);
/*
** create output images
*/
xinfo = linfo[0].info;
out_list = VCreateAttrList();
res_image = VCreateImage(nslices, nrows, ncols, VFloatRepn);
VFillImage(res_image, VAllBands, 0);
VSetAttr(VImageAttrList(res_image), "name", NULL, VStringRepn, "RES/trRV");
VSetAttr(VImageAttrList(res_image), "modality", NULL, VStringRepn, "RES/trRV");
VSetAttr(VImageAttrList(res_image), "df", NULL, VFloatRepn, df);
VSetAttr(VImageAttrList(res_image), "patient", NULL, VStringRepn, xinfo->patient);
VSetAttr(VImageAttrList(res_image), "voxel", NULL, VStringRepn, xinfo->voxel);
VSetAttr(VImageAttrList(res_image), "repetition_time", NULL, VLongRepn, itr);
VSetAttr(VImageAttrList(res_image), "talairach", NULL, VStringRepn, xinfo->talairach);
/* neu */
VSetAttr(VImageAttrList(res_image),"indexOrigin",NULL,VStringRepn,xinfo->indexOrigin);
VSetAttr(VImageAttrList(res_image),"columnVec",NULL,VStringRepn,xinfo->columnVec);
VSetAttr(VImageAttrList(res_image),"rowVec",NULL,VStringRepn,xinfo->rowVec);
VSetAttr(VImageAttrList(res_image),"sliceVec",NULL,VStringRepn,xinfo->sliceVec);
VSetAttr(VImageAttrList(res_image),"FOV",NULL,VStringRepn,xinfo->FOV);
/*--------*/
if(xinfo->fixpoint[0] != 'N')
VSetAttr(VImageAttrList(res_image), "fixpoint", NULL, VStringRepn, xinfo->fixpoint);
if(xinfo->ca[0] != 'N') {
VSetAttr(VImageAttrList(res_image), "ca", NULL, VStringRepn, xinfo->ca);
VSetAttr(VImageAttrList(res_image), "cp", NULL, VStringRepn, xinfo->cp);
VSetAttr(VImageAttrList(res_image), "extent", NULL, VStringRepn, xinfo->extent);
}
VAppendAttr(out_list, "image", NULL, VImageRepn, res_image);
for(i = 0; i < n; i++) {
beta_image[i] = VCreateImage(nslices, nrows, ncols, VFloatRepn);
VFillImage(beta_image[i], VAllBands, 0);
VSetAttr(VImageAttrList(beta_image[i]), "patient", NULL, VStringRepn, xinfo->patient);
VSetAttr(VImageAttrList(beta_image[i]), "voxel", NULL, VStringRepn, xinfo->voxel);
VSetAttr(VImageAttrList(beta_image[i]), "repetition_time", NULL, VLongRepn, itr);
VSetAttr(VImageAttrList(beta_image[i]), "talairach", NULL, VStringRepn, xinfo->talairach);
/* neu */
VSetAttr(VImageAttrList(beta_image[i]),"indexOrigin",NULL,VStringRepn,xinfo->indexOrigin);
VSetAttr(VImageAttrList(beta_image[i]),"columnVec",NULL,VStringRepn,xinfo->columnVec);
VSetAttr(VImageAttrList(beta_image[i]),"rowVec",NULL,VStringRepn,xinfo->rowVec);
VSetAttr(VImageAttrList(beta_image[i]),"sliceVec",NULL,VStringRepn,xinfo->sliceVec);
VSetAttr(VImageAttrList(beta_image[i]),"FOV",NULL,VStringRepn,xinfo->FOV);
/*--------*/
if(xinfo->fixpoint[0] != 'N')
VSetAttr(VImageAttrList(beta_image[i]), "fixpoint", NULL, VStringRepn, xinfo->fixpoint);
if(xinfo->ca[0] != 'N') {
VSetAttr(VImageAttrList(beta_image[i]), "ca", NULL, VStringRepn, xinfo->ca);
VSetAttr(VImageAttrList(beta_image[i]), "cp", NULL, VStringRepn, xinfo->cp);
VSetAttr(VImageAttrList(beta_image[i]), "extent", NULL, VStringRepn, xinfo->extent);
}
VSetAttr(VImageAttrList(beta_image[i]), "name", NULL, VStringRepn, "BETA");
VSetAttr(VImageAttrList(beta_image[i]), "modality", NULL, VStringRepn, "BETA");
VSetAttr(VImageAttrList(beta_image[i]), "beta", NULL, VShortRepn, i + 1);
VSetAttr(VImageAttrList(beta_image[i]), "df", NULL, VFloatRepn, df);
VAppendAttr(out_list, "image", NULL, VImageRepn, beta_image[i]);
}
VSetAttr(VImageAttrList(design), "name", NULL, VStringRepn, "X");
VSetAttr(VImageAttrList(design), "modality", NULL, VStringRepn, "X");
VAppendAttr(out_list, "image", NULL, VImageRepn, design);
KX_image = Mat2Vista(SX);
VSetAttr(VImageAttrList(KX_image), "name", NULL, VStringRepn, "KX");
VSetAttr(VImageAttrList(KX_image), "modality", NULL, VStringRepn, "KX");
VAppendAttr(out_list, "image", NULL, VImageRepn, KX_image);
VSetAttr(VImageAttrList(BCOV), "name", NULL, VStringRepn, "BCOV");
VSetAttr(VImageAttrList(BCOV), "modality", NULL, VStringRepn, "BCOV");
VAppendAttr(out_list, "image", NULL, VImageRepn, BCOV);
/*
** create temporary images for smoothness estimation
*/
/* smoothness estim only for 3D images, i.e. CA/CP known */
/* if(xinfo->ca[0] == 'N')
smooth = FALSE;*/
if(smooth) {
i0 = 20;
i1 = i0 + 30;
if(i1 > m)
i1 = m;
for(i = i0; i < i1; i++) {
if(i - i0 >= ETMP)
VError(" too many tmp images");
res_map[i - i0] = VCreateImage(nslices, nrows, ncols, VFloatRepn);
VFillImage(res_map[i - i0], VAllBands, 0);
}
}
/*
** process
*/
ys = gsl_vector_float_alloc(m);
y = gsl_vector_float_alloc(m);
z = gsl_vector_float_alloc(m);
beta = gsl_vector_float_alloc(n);
kernel = GaussKernel((double)sigma);
for(k = 0; k < nlists; k++) {
src[k] = VCreateImage(linfo[k].ntimesteps, nrows, ncols, linfo[k].repn);
VFillImage(src[k], VAllBands, 0);
}
npix = 0;
for(slice = 0; slice < nslices; slice++) {
if(slice % 5 == 0)
fprintf(stderr, " slice: %3d\r", slice);
for(k = 0; k < nlists; k++) {
if(linfo[k].zero[slice] == 0)
goto next1;
fd = open(linfo[k].filename, O_RDONLY);
if(fd == -1)
VError("could not open file %s", linfo[k].filename);
nt = linfo[k].ntimesteps;
if(! VReadBandDataFD(fd, &linfo[k].info[slice], 0, nt, &src[k]))
VError(" error reading data");
close(fd);
}
repn = linfo[0].repn;
for(row = 0; row < nrows; row++) {
for(col = 0; col < ncols; col++) {
for(k = 0; k < nlists; k++)
if(VPixel(src[k], 0, row, col, VShort) < minval + 1)
goto next;
npix++;
/* read time series data */
sum = sum2 = nx = 0;
ptr1 = y->data;
for(k = 0; k < nlists; k++) {
nt = VImageNBands(src[k]);
for(i = 0; i < nt; i++) {
u = VPixel(src[k], i, row, col, VShort);
(*ptr1++) = u;
sum += u;
sum2 += u * u;
nx++;
}
}
mean = sum / nx;
sig = sqrt((double)((sum2 - nx * mean * mean) / (nx - 1.0)));
if(sig < 0.001)
continue;
/* centering and scaling, Seber, p.330 */
ptr1 = y->data;
for(i = 0; i < m; i++) {
u = ((*ptr1) - mean) / sig;
(*ptr1++) = u + 100.0;
}
/* S x y */
ys = VectorConvolve(y, ys, kernel);
/* compute beta's */
fmat_x_vector(XInv, ys, beta);
/* residuals */
fmat_x_vector(SX, beta, z);
err = 0;
ptr1 = ys->data;
ptr2 = z->data;
for(i = 0; i < m; i++) {
d = ((*ptr1++) - (*ptr2++));
err += d * d;
}
/* sigma^2 */
var = err / trace;
/* write residuals output */
VPixel(res_image, slice, row, col, VFloat) = (VFloat)var;
/* save residuals of several timesteps for smoothness estimation */
if(smooth) {
ptr1 = ys->data;
ptr2 = z->data;
err = 0;
for(i = i0; i < i1; i++) {
d = ((*ptr1++) - (*ptr2++));
err += d * d;
VPixel(res_map[i - i0], slice, row, col, VFloat) = d;
}
if (err > 0) err = sqrt(err);
for(i = i0; i < i1; i++) {
d = VPixel(res_map[i - i0], slice, row, col, VFloat);
if (err > 1.0e-6) d /= err;
else d = 0;
VPixel(res_map[i - i0], slice, row, col, VFloat) = d / err;
}
}
/* write beta output */
ptr1 = beta->data;
for(i = 0; i < n; i++)
VPixel(beta_image[i], slice, row, col, VFloat) = (VFloat)(*ptr1++);
next:
;
}
}
next1:
;
}
/*
** Smoothness estimation based on residual images
*/
if(smooth) {
smooth_fwhm = VSmoothnessEstim(res_map, i1 - i0);
sscanf(xinfo->voxel, "%f %f %f", &vx, &vy, &vz);
vx = (vx + vy + vz) / 3.0; /* voxels should be isotropic */
smooth_fwhm *= vx;
fprintf(stderr, " smoothness: %f\n", smooth_fwhm);
VSetAttr(VImageAttrList(res_image), "smoothness", NULL, VFloatRepn, smooth_fwhm);
for(i = 0; i < n; i++) {
VSetAttr(VImageAttrList(beta_image[i]), "smoothness", NULL, VFloatRepn, smooth_fwhm);
}
for(i = 0; i < i1 - i0; i++)
VDestroyImage(res_map[i]);
}
ende:
if(npix == 0)
VError(" no voxels above threshold %d found", minval);
return out_list;
}
VImage VCreateImage (int nbands, int nrows, int ncolumns, VRepnKind pixel_repn)
{
size_t row_size = ncolumns * VRepnSize (pixel_repn);
size_t data_size = nbands * nrows * row_size;
size_t row_index_size = nbands * nrows * sizeof (char *);
size_t band_index_size = nbands * sizeof (char **);
size_t pixel_size;
char *p;
VImage image;
int band, row;
#define AlignUp(v, b) ((((v) + (b) - 1) / (b)) * (b))
/* Check parameters: */
if (nbands < 1) {
VWarning ("VCreateImage: Invalid number of bands: %d", (int) nbands);
return NULL;
}
if (nrows < 1) {
VWarning ("VCreateImage: Invalid number of rows: %d", (int) nrows);
return NULL;
}
if (ncolumns < 1) {
VWarning ("VCreateImage: Invalid number of columns: %d",
(int) ncolumns);
return NULL;
}
if (pixel_repn != VBitRepn && pixel_repn != VUByteRepn &&
pixel_repn != VSByteRepn && pixel_repn != VShortRepn &&
pixel_repn != VLongRepn && pixel_repn != VFloatRepn &&
pixel_repn != VDoubleRepn) {
VWarning ("VCreateImage: Invalid pixel representation: %d",
(int) pixel_repn);
return NULL;
}
/* Allocate memory for the VImage, its indices, and pixel values, while
padding enough to ensure pixel values are appropriately aligned: */
pixel_size = VRepnSize (pixel_repn);
p = VMalloc (AlignUp (sizeof (VImageRec) + row_index_size +
band_index_size, pixel_size) + data_size);
/* Initialize the VImage: */
image = (VImage) p;
image->nbands = nbands;
image->nrows = nrows;
image->ncolumns = ncolumns;
image->flags = VImageSingleAlloc;
image->pixel_repn = pixel_repn;
image->attributes = VCreateAttrList ();
image->band_index = (VPointer **) (p += sizeof (VImageRec));
image->row_index = (VPointer *) (p += band_index_size);
image->data = (VPointer) AlignUp ((long) p + row_index_size, pixel_size);
image->nframes = nbands;
image->nviewpoints = image->ncolors = image->ncomponents = 1;
/* Initialize the indices: */
for (band = 0; band < nbands; band++)
image->band_index[band] = image->row_index + band * nrows;
for (row = 0, p = image->data; row < nbands * nrows; row++, p += row_size)
image->row_index[row] = p;
return image;
#undef AlignUp
}
static VAttrList ReadAttrList (FILE *f)
{
VAttrList sublist, list = VCreateAttrList ();
VAttrRec *a;
int ch = 0;
size_t name_size;
VBundle b;
char buf[2], *str, name_buf[VMaxAttrNameLength + 1];
/* Swallow a { marking the start of the attribute list: */
if (fscanf (f, " %1s", buf) != 1 || buf[0] != '{') {
VWarning ("VReadFile: Missing {");
goto Fail;
}
/* For each attribute up to the next "}": */
while (fscanf (f, " %[^}: \t\n]", name_buf) == 1) {
name_size = strlen (name_buf);
/* Read a : and the first character of the attribute's value: */
if (fscanf (f, " %1s", buf) != 1 || buf[0] != ':' ||
fscanf (f, " %1s", buf) != 1) {
VWarning ("VReadFile: Invalid %s attribute", name_buf);
goto Fail;
}
/* The first character of the value tells us whether its an attribute
list, quoted string, or unquoted string: */
if (buf[0] == '{') {
/* The attribute value is another list of attributes: */
ungetc ('{', f);
if (! (sublist = ReadAttrList (f)))
goto Fail;
a = VMalloc (sizeof (VAttrRec) + name_size);
a->value = sublist;
a->repn = VAttrListRepn;
} else {
/* The value doesn't start with '{' -- parse a word or string: */
if (! (str = ReadString (f, buf[0], name_buf)))
goto Fail;
while ((ch = fgetc (f)) && (ch == ' ' || ch == '\t')) ;
ungetc (ch, f);
/* If the word is followed by an '{'... */
if (ch == '{') {
/* ...then it's a typed value -- the word is it's type name
and the { is the start of it's attribute list value. */
b = VCreateBundle (str, NULL, 0, NULL);
if (! (sublist = ReadAttrList (f))) {
VFree (b);
goto Fail;
}
b->list = sublist;
a = VMalloc (sizeof (VAttrRec) + name_size);
a->repn = VBundleRepn;
a->value = b;
} else {
/* ...otherwise store it as a simple string value: */
a = VMalloc (sizeof (VAttrRec) + name_size + strlen (str) + 1);
a->repn = VStringRepn;
a->value = a->name + name_size + 1;
strcpy (a->value, str);
}
VFree(str);
}
/* Copy the attribute's name into the newly allocated node: */
strcpy (a->name, name_buf);
/* Place the new node on the end of the growing attribute list: */
a->next = NULL;
a->prev = list->prev;
if (a->prev) a->prev->next = a;
else list->next = a;
list->prev = a;
}
/* Swallow the terminating "}": */
if (fscanf (f, " %1s", buf) != 1 || buf[0] != '}') {
VWarning ("VReadFile: Missing }");
Fail: VDestroyAttrList (list);
return NULL;
}
return list;
}
VAttrList
VBayes(VImage cbeta_images[], VImage sd_images[], int nimages, VBoolean level, VBoolean zscore) {
VAttrList out_list = NULL;
VImage dest = NULL, sigma_image = NULL;
int i, j, k, npixels;
VFloat *dest_pp, *beta_pp[N], *sd_pp[N], *sigma_pp = NULL;
VFloat pmin, pmax;
double mean = 0, sigma = 0;
float rx, wsum, msum, w0, wx, s, msumold;
float result = 0;
float gmean[N], gvar[N];
float tiny = 1.0e-12;
/*
** create output image
*/
dest = VCopyImage(cbeta_images[0], NULL, VAllBands);
if(!dest)
return NULL;
VFillImage(dest, VAllBands, 0);
VSetAttr(VImageAttrList(dest), "num_images", NULL, VShortRepn, (VShort)nimages);
VSetAttr(VImageAttrList(dest), "modality", NULL, VStringRepn, "bayes_map");
VSetAttr(VImageAttrList(dest), "name", NULL, VStringRepn, "bayes");
if(level == TRUE) {
VSetAttr(VImageAttrList(dest), "modality", NULL, VStringRepn, "mean");
VSetAttr(VImageAttrList(dest), "name", NULL, VStringRepn, "mean");
sigma_image = VCopyImage(dest, NULL, VAllBands);
if(!sigma_image)
return NULL;
VFillImage(sigma_image, VAllBands, 0);
VSetAttr(VImageAttrList(sigma_image), "num_images", NULL, VShortRepn, (VShort)nimages);
VSetAttr(VImageAttrList(sigma_image), "modality", NULL, VStringRepn, "std_dev");
VSetAttr(VImageAttrList(sigma_image), "name", NULL, VStringRepn, "std_dev");
}
/*
** for each voxel
*/
pmax = VRepnMinValue(VFloatRepn);
pmin = VRepnMaxValue(VFloatRepn);
npixels = VImageNPixels(cbeta_images[0]);
for(i = 0; i < nimages; i++) {
beta_pp[i] = (VFloat *) VImageData(cbeta_images[i]);
sd_pp[i] = (VFloat *) VImageData(sd_images[i]);
}
dest_pp = (VFloat *) VImageData(dest);
if(level == TRUE)
sigma_pp = (VFloat *) VImageData(sigma_image);
for(j = 0; j < npixels; j++) {
if(j % 10000 == 0)
fprintf(stderr, "...%.2f%%\r", (float)100 * j / (float)npixels);
result = mean = sigma = 0;
/*
** read data from input images
*/
for(k = 0; k < nimages; k++) {
gmean[k] = *beta_pp[k]++; /* mean c*beta */
rx = *sd_pp[k]++; /* standard deviation of c*beta*/
gvar[k] = rx * rx; /* variation of c*beta*/
}
/* see Box,Tiao, pp.17-18 calculate probability distribution */
wsum = 0;
msum = 0;
w0 = 0;
for(k = 0; k < nimages; k++) { /* for each image */
s = gvar[k];
if(s < tiny)
goto next;
s = sqrt((double)s);
if(s < tiny)
goto next;
wx = 1.0 / (s * s);
wsum = w0 + wx;
msumold = msum;
msum = (w0 * msum + wx * gmean[k]) / wsum;
w0 = wsum;
sigma = 1.0 / sqrt(wsum);
}
if(wsum < tiny)
goto next;
/* resulting mean and std dev */
mean = msum;
sigma = 1.0 / sqrt(wsum);
if(level == TRUE) {
result = mean;
goto next;
}
/* calculate probability under distribution */
result = CumulativeNormal(mean, sigma);
/* output */
if(zscore) {
/* CHECK HERE IF "1.0-" is correct */
result = (float)p2z((double)(1.0 - result));
if(mean < 0)
result = -result;
if(result > 20)
result = 20;
if(result < -20)
result = -20;
} else {
result *= 100.0;
if(result > 100)
result = 100;
if(mean < 0)
result = -result;
}
if(result < pmin)
pmin = result;
if(result > pmax)
pmax = result;
next:
*dest_pp++ = result;
if(level)
*sigma_pp++ = sigma;
}
out_list = VCreateAttrList();
fprintf(stderr, "...100.00%%\n");
if(level == FALSE) {
fprintf(stderr, "\n min: %.3f, max: %.3f\n", pmin, pmax);
VAppendAttr(out_list, "zmap", NULL, VImageRepn, dest);
return out_list;
} else {
VAppendAttr(out_list, "mean", NULL, VImageRepn, dest);
VAppendAttr(out_list, "std_dev", NULL, VImageRepn, sigma_image);
return out_list;
}
return NULL;
}
int
main (int argc,char *argv[])
{
static VString filename = "";
static VString filename1 = "";
static VString filename2 = "";
static VShort first = 2;
static VShort length = 0;
static VShort type = 0;
static VShort minval = 0;
static VShort nproc = 4;
static VOptionDescRec options[] = {
{"in1",VStringRepn,1,(VPointer) &filename1,VRequiredOpt,NULL,"first input file"},
{"in2",VStringRepn,1,(VPointer) &filename2,VRequiredOpt,NULL,"second input file"},
{"mask",VStringRepn,1,(VPointer) &filename,VRequiredOpt,NULL,"mask"},
{"type",VShortRepn,1,(VPointer) &type,VOptionalOpt,TYPDict,"type of concordance measure"},
{"minval",VShortRepn,1,(VPointer) &minval,VOptionalOpt,NULL,"signal threshold"},
{"first",VShortRepn,1,(VPointer) &first,VOptionalOpt,NULL,"first timestep to use"},
{"length",VShortRepn,1,(VPointer) &length,VOptionalOpt,NULL,
"length of time series to use, '0' to use full length"},
{"j",VShortRepn,1,(VPointer) &nproc,VOptionalOpt,NULL,"number of processors to use, '0' to use all"}
};
FILE *out_file,*fp;
VAttrList list=NULL,list1=NULL,list2=NULL,out_list=NULL;
VAttrListPosn posn;
VImage mask=NULL,map=NULL,dest=NULL,disc=NULL;
float *A1=NULL,*A2=NULL,u=0,tiny=1.0e-6;
int b,r,c;
char *prg = "vccm2";
VParseFilterCmd (VNumber (options),options,argc,argv,NULL,&out_file);
if (type > 3) VError("illegal type");
/*
** read mask
*/
fp = VOpenInputFile (filename, TRUE);
list = VReadFile (fp, NULL);
if (! list) VError("Error reading mask file");
fclose(fp);
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {
if (VGetAttrRepn (& posn) != VImageRepn) continue;
VGetAttrValue (& posn, NULL,VImageRepn, & mask);
if (VPixelRepn(mask) == VFloatRepn || VPixelRepn(mask) == VDoubleRepn) {
mask = NULL;
continue;
}
}
if (mask == NULL) VError(" no mask found");
/* read files */
fp = VOpenInputFile (filename1, TRUE);
list1 = VReadFile (fp, NULL);
if (! list1) VError("Error reading 1st input file");
fclose(fp);
fp = VOpenInputFile (filename2, TRUE);
list2 = VReadFile (fp, NULL);
if (! list2) VError("Error reading 2nd input file");
fclose(fp);
/* get voxel map */
map = GetMap(list1,list2,mask,minval);
/* omp-stuff */
#ifdef _OPENMP
int num_procs=omp_get_num_procs();
if (nproc > 0 && nproc < num_procs) num_procs = nproc;
printf("using %d cores\n",(int)num_procs);
omp_set_num_threads(num_procs);
#endif /* _OPENMP */
/* compute corr matrices */
A1 = VCorrMatrix(list1,map,first,length);
A2 = VCorrMatrix(list2,map,first,length);
/* get concordance between two corr matrices */
dest = VCCM2(A1,A2,map,(int)type);
/* invert to get discordant map */
disc = VCreateImageLike(dest);
VFillImage(disc,VAllBands,0);
if (type < 2) {
for (b=0; b<VImageNBands(dest); b++) {
for (r=0; r<VImageNRows(dest); r++) {
for (c=0; c<VImageNColumns(dest); c++) {
if (VGetPixel(mask,b,r,c) < 1) continue;
u = VPixel(dest,b,r,c,VFloat);
if (u < tiny) continue;
VPixel(disc,b,r,c,VFloat) = 1-u;
}
}
}
}
/* output */
out_list = VCreateAttrList();
VHistory(VNumber(options),options,prg,&list,&out_list);
VAppendAttr(out_list,"concordant",NULL,VImageRepn,dest);
if (type < 2) VAppendAttr(out_list,"discordant",NULL,VImageRepn,disc);
if (! VWriteFile (out_file, out_list)) exit (1);
fprintf (stderr, "%s: done.\n", argv[0]);
return 0;
}
VAttrList
VNCM(VAttrList list,VImage mask,VShort minval,VShort first,VShort length,VFloat threshold)
{
VAttrList out_list=NULL;
VAttrListPosn posn;
VImage src[NSLICES],map=NULL;
VImage dest=NULL;
size_t b,r,c,i,j,i1,n,m,nt,last,ntimesteps,nrows,ncols,nslices;
gsl_matrix_float *mat=NULL;
float *A=NULL,*ev=NULL;
/*
** get image dimensions
*/
i = ntimesteps = nrows = ncols = 0;
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {
if (VGetAttrRepn (& posn) != VImageRepn) continue;
VGetAttrValue (& posn, NULL,VImageRepn, & src[i]);
if (VPixelRepn(src[i]) != VShortRepn) continue;
if (VImageNBands(src[i]) > ntimesteps) ntimesteps = VImageNBands(src[i]);
if (VImageNRows(src[i]) > nrows) nrows = VImageNRows(src[i]);
if (VImageNColumns(src[i]) > ncols) ncols = VImageNColumns(src[i]);
i++;
if (i >= NSLICES) VError(" too many slices");
}
nslices = i;
/* get time steps to include */
if (length < 1) length = ntimesteps-2;
last = first + length -1;
if (last >= ntimesteps) last = ntimesteps-1;
if (first < 0) first = 1;
nt = last - first + 1;
i1 = first+1;
if (nt < 2) VError(" not enough timesteps, nt= %d",nt);
fprintf(stderr,"# ntimesteps: %d, first= %d, last= %d, nt= %d\n",
(int)ntimesteps,(int)first,(int)last,(int)nt);
/* count number of voxels */
n = 0;
for (b=0; b<nslices; b++) {
if (VImageNRows(src[b]) < 2) continue;
for (r=0; r<nrows; r++) {
for (c=0; c<ncols; c++) {
if (VPixel(src[b],i1,r,c,VShort) < minval) continue;
if (VGetPixel(mask,b,r,c) < 0.5) continue;
n++;
}
}
}
fprintf(stderr," nvoxels: %ld\n",(long)n);
/*
** voxel addresses
*/
map = VCreateImage(1,5,n,VFloatRepn);
if (map == NULL) VError(" error allocating addr map");
VFillImage(map,VAllBands,0);
VPixel(map,0,3,0,VFloat) = nslices;
VPixel(map,0,3,1,VFloat) = nrows;
VPixel(map,0,3,2,VFloat) = ncols;
i = 0;
for (b=0; b<nslices; b++) {
if (VImageNRows(src[b]) < 2) continue;
for (r=0; r<nrows; r++) {
for (c=0; c<ncols; c++) {
if (VPixel(src[b],i1,r,c,VShort) < minval) continue;
if (VGetPixel(mask,b,r,c) < 0.5) continue;
VPixel(map,0,0,i,VFloat) = b;
VPixel(map,0,1,i,VFloat) = r;
VPixel(map,0,2,i,VFloat) = c;
i++;
}
}
}
/*
** avoid casting to float, copy data to matrix
*/
mat = gsl_matrix_float_calloc(n,nt);
for (i=0; i<n; i++) {
b = VPixel(map,0,0,i,VFloat);
r = VPixel(map,0,1,i,VFloat);
c = VPixel(map,0,2,i,VFloat);
float *ptr = gsl_matrix_float_ptr(mat,i,0);
int k;
j = 0;
for (k=first; k<=last; k++) {
if (j >= mat->size2) VError(" j= %d %d",j,mat->size2);
if (k >= VImageNBands(src[b])) VError(" k= %d %d",k, VImageNBands(src[b]));
*ptr++ = (float) VPixel(src[b],k,r,c,VShort);
j++;
}
}
/*
** compute similarity matrix
*/
m = (n*(n+1))/2;
fprintf(stderr," matrix computation, n= %ld...\n",(long)n);
A = (float *) calloc(m,sizeof(float));
if (!A) VError(" err allocating correlation matrix");
memset(A,0,m*sizeof(float));
size_t progress=0;
#pragma omp parallel for shared(progress) private(j) schedule(guided) firstprivate(mat,A)
for (i=0; i<n; i++) {
if (i%100 == 0) fprintf(stderr," %d00\r",(int)(++progress));
const float *arr1 = gsl_matrix_float_const_ptr(mat,i,0);
for (j=0; j<i; j++) {
const float *arr2 = gsl_matrix_float_const_ptr(mat,j,0);
const double v = Correlation(arr1,arr2,nt);
const size_t k=j+i*(i+1)/2;
if (k >= m) VError(" illegal addr k= %d, m= %d",k,m);
A[k] = (float)v;
}
}
fprintf(stderr," matrix done.\n");
gsl_matrix_float_free(mat);
/*
** eigenvector centrality
*/
ev = (float *) VCalloc(n,sizeof(float));
DegreeCentrality(A,ev,n,threshold);
dest = WriteOutput(src[0],map,nslices,nrows,ncols,ev,n);
VSetAttr(VImageAttrList(dest),"name",NULL,VStringRepn,"DegreeCM");
out_list = VCreateAttrList();
VAppendAttr(out_list,"image",NULL,VImageRepn,dest);
return out_list;
}
VAttrList
VGetContrast(VAttrList list, gsl_vector_float *con, VShort type) {
VAttrList out_list;
int nbands = 0, nrows = 0, ncols = 0, band, row, col;
VImage src = NULL, dest = NULL, std_image = NULL;
VImage beta_images[MBETA], res_image = NULL, bcov_image = NULL;
VString buf = NULL;
VAttrListPosn posn;
VString str;
int i, nbeta;
float t = 0, s = 0, tsigma = 0, z = 0, zmax = 0, zmin = 0;
float sigma, var, sum, df;
float *ptr1, *ptr2;
char *constring = NULL;
gsl_vector_float *beta = NULL, *tmp = NULL;
gsl_matrix_float *bcov = NULL;
i = 0;
for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & src);
if(VPixelRepn(src) != VFloatRepn)
continue;
VGetAttr(VImageAttrList(src), "modality", NULL, VStringRepn, &str);
if(strcmp(str, "BETA") == 0) {
beta_images[i++] = VCopyImage(src, NULL, VAllBands);
} else if(strcmp(str, "RES/trRV") == 0) {
res_image = VCopyImage(src, NULL, VAllBands);
} else if(strcmp(str, "BCOV") == 0) {
bcov_image = VCopyImage(src, NULL, VAllBands);
}
}
nbeta = VImageNRows(bcov_image);
nbands = VImageNBands(beta_images[0]);
nrows = VImageNRows(beta_images[0]);
ncols = VImageNColumns(beta_images[0]);
if(VGetAttr(VImageAttrList(beta_images[0]), "df", NULL, VFloatRepn, &df) != VAttrFound)
VError(" attribute 'df' not found");
if(nbeta > MBETA) {
fprintf(stderr, " number of betas: %d, maximum number of betas: %d\n", nbeta, MBETA);
VError(" maximum number of betas is exceeded");
}
/*
** read contrast vector
*/
if(nbeta != con->size)
VError("contrast vector has bad length (%d), correct length is %d", con->size, nbeta);
fprintf(stderr, " contrast vector:\n");
char str1[10];
constring = (char *)VMalloc(sizeof(char) * 10 * nbeta);
constring[0] = '\0';
for(i = 0; i < nbeta; i++) {
fprintf(stderr, " %.2f", fvget(con, i));
sprintf(str1, "%1.2f ", fvget(con, i));
strcat((char *)constring, (const char *)str1);
}
fprintf(stderr, "\n");
/* get variance estimation */
bcov = gsl_matrix_float_alloc(nbeta, nbeta);
ptr1 = VImageData(bcov_image);
ptr2 = bcov->data;
for(i = 0; i < nbeta * nbeta; i++)
*ptr2++ = *ptr1++;
gsl_matrix_float_transpose(bcov);
tmp = fmat_x_vector(bcov, con, tmp);
var = fskalarproduct(tmp, con);
sigma = sqrt(var);
/*
** create output data structs
*/
out_list = VCreateAttrList();
dest = VCreateImage(nbands, nrows, ncols, VFloatRepn);
VFillImage(dest, VAllBands, 0);
VCopyImageAttrs(beta_images[0], dest);
switch(type) {
case 0: /* conimg */
buf = VNewString("conimg");
break;
case 1: /* t-image */
buf = VNewString("tmap");
break;
case 2: /* zmap */
buf = VNewString("zmap");
break;
default:
VError(" illegal type");
}
fprintf(stderr, " output type: %s\n", buf);
VSetAttr(VImageAttrList(dest), "modality", NULL, VStringRepn, buf);
VSetAttr(VImageAttrList(dest), "name", NULL, VStringRepn, buf);
VSetAttr(VImageAttrList(dest), "contrast", NULL, VStringRepn, constring);
VAppendAttr(out_list, "image", NULL, VImageRepn, dest);
if(type == 0) {
std_image = VCreateImage(nbands, nrows, ncols, VFloatRepn);
VFillImage(std_image, VAllBands, 0);
VCopyImageAttrs(beta_images[0], std_image);
VSetAttr(VImageAttrList(std_image), "modality", NULL, VStringRepn, "std_dev");
VSetAttr(VImageAttrList(std_image), "name", NULL, VStringRepn, "std_dev");
VAppendAttr(out_list, "image", NULL, VImageRepn, std_image);
}
/*
** loop thru image
*/
zmax = zmin = 0;
beta = gsl_vector_float_alloc(nbeta);
for(band = 0; band < nbands; band++) {
for(row = 0; row < nrows; row++) {
for(col = 0; col < ncols; col++) {
t = z = sum = 0;
ptr1 = beta->data;
for(i = 0; i < nbeta; i++) {
*ptr1++ = VPixel(beta_images[i], band, row, col, VFloat);
}
sum = fskalarproduct(beta, con);
if(ABS(sum) < 1.0e-10)
continue;
s = VPixel(res_image, band, row, col, VFloat);
tsigma = sqrt(s) * sigma;
if(tsigma > 0.00001)
t = sum / tsigma;
else
t = 0;
if(isnan(t) || isinf(t))
t = 0;
switch(type) {
case 0: /* conimg */
z = sum;
break;
case 1: /* t-image */
z = t;
break;
case 2: /* zmap */
z = t2z_approx(t, df);
if(z > 30)
z = 30;
if(sum < 0)
z = -z;
break;
default:
;
}
if(isnan(z) || isinf(z))
z = 0;
if(z > zmax)
zmax = z;
if(z < zmin)
zmin = z;
VPixel(dest, band, row, col, VFloat) = z;
if(type == 0)
VPixel(std_image, band, row, col, VFloat) = tsigma;
}
}
}
fprintf(stderr, " min= %.3f, max= %.3f\n", zmin, zmax);
return out_list;
}
int main(int argc, char *argv[]) {
VAttrList list, out_list;
VImage src;
VImage dest = NULL;
VAttrListPosn posn;
VString str;
int nimages;
char historystr[] = "history";
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vdelcereb V%s", ver);
fprintf(stderr, "%s\n", prg_name);
/* Parse command line arguments: */
if(!VParseCommand(VNumber(options), options, &argc, argv) ||
! VIdentifyFiles(VNumber(options), options, "in", & argc, argv, 0) ||
! VIdentifyFiles(VNumber(options), options, "out", & argc, argv, -1))
goto Usage;
if(argc > 1) {
VReportBadArgs(argc, argv);
Usage:
VReportUsage(argv[0], VNumber(options), options, NULL);
exit(EXIT_FAILURE);
}
/* Read source image(s): */
if(strcmp(in_filename, "-") == 0)
in_file = stdin;
else {
in_file = fopen(in_filename, "r");
if(! in_file)
VError("Failed to open input file %s", in_filename);
}
if(!(list = VReadFile(in_file, NULL)))
exit(EXIT_FAILURE);
fclose(in_file);
/* Process image */
nimages = 0;
for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & src);
dest = VCerebellum(src);
VSetAttrValue(& posn, NULL, VImageRepn, dest);
VDestroyImage(src);
nimages++;
break;
}
/* Create outlist */
out_list = VCreateAttrList();
/* Make History */
VHistory(VNumber(options), options, prg_name, &list, &out_list);
/* Alle Attribute (ausser history:) in die neue Liste schreiben: */
for(VFirstAttr(list, &posn); VAttrExists(&posn); VNextAttr(&posn)) {
if(strncmp(VGetAttrName(&posn), historystr, strlen(historystr)) == 0)
continue;
switch(VGetAttrRepn(&posn)) {
case VImageRepn:
VGetAttrValue(&posn, NULL, VImageRepn, &src);
VAppendAttr(out_list, VGetAttrName(&posn), NULL, VImageRepn, src);
break;
case VStringRepn:
VGetAttrValue(&posn, NULL, VStringRepn, &str);
VAppendAttr(out_list, VGetAttrName(&posn), NULL, VImageRepn, str);
break;
default:
break;
}
}
/* Write the results to the output file: */
if(strcmp(out_filename, "-") == 0)
out_file = stdout;
else {
out_file = fopen(out_filename, "w");
if(! out_file)
VError("Failed to open output file %s", out_filename);
}
if(VWriteFile(out_file, out_list)) {
if(verbose >= 1)
fprintf(stderr, "%s: processed %d image%s.\n",
argv[0], nimages, nimages == 1 ? "" : "s");
fprintf(stderr, "%s: done.\n", argv[0]);
}
return 0;
}
int
main(int argc, char *argv[]) {
static VArgVector in_files;
static VString out_filename;
static VBoolean in_found, out_found;
static VOptionDescRec options[] = {
{"in", VStringRepn, 0, & in_files, & in_found, NULL, "Input files" },
{"out", VStringRepn, 1, & out_filename, & out_found, NULL, "Output file" }
};
FILE *fp = NULL;
VStringConst in_filename;
VAttrList list = NULL, out_list = NULL;
VImage *design = NULL, tmp = NULL, dest = NULL;
VAttrListPosn posn;
int i, nimages;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vcatdesign V%s", ver);
fprintf(stderr, "%s\n", prg_name);
/* Parse command line arguments: */
if(! VParseCommand(VNumber(options), options, & argc, argv) ||
! VIdentifyFiles(VNumber(options), options, "in", & argc, argv, 0) ||
! VIdentifyFiles(VNumber(options), options, "out", & argc, argv, -1))
goto Usage;
if(argc > 1) {
VReportBadArgs(argc, argv);
Usage:
VReportUsage(argv[0], VNumber(options), options, NULL);
exit(EXIT_FAILURE);
}
/* Read each input file */
nimages = in_files.number;
design = (VImage *) VMalloc(sizeof(VImage) * nimages);
for(i = 0; i < nimages; i++) {
in_filename = ((VStringConst *) in_files.vector)[i];
fprintf(stderr, " reading: %s\n", in_filename);
fp = VOpenInputFile(in_filename, TRUE);
list = VReadFile(fp, NULL);
if(! list)
VError("Error reading file %s", in_filename);
fclose(fp);
for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & tmp);
if(VPixelRepn(tmp) == VFloatRepn || VPixelRepn(tmp) == VDoubleRepn) {
design[i] = tmp;
break;
}
}
}
/* process */
dest = ConcatDesigns(design, nimages);
out_list = VCreateAttrList();
VAppendAttr(out_list, "image", NULL, VImageRepn, dest);
/* Output: */
VHistory(VNumber(options), options, prg_name, &list, &out_list);
fp = VOpenOutputFile(out_filename, TRUE);
if(!fp)
VError(" error opening outout file %s", out_filename);
if(! VWriteFile(fp, out_list))
exit(1);
fprintf(stderr, "%s: done.\n", argv[0]);
return 0;
}
VAttrList VCopyAttrList (VAttrList list)
{
VAttrList new_list = VCreateAttrList ();
size_t name_size, value_size;
VAttrRec *old_a, *new_a;
VBundle old_b, new_b;
VTypeMethods *methods;
/* For each node of the old list: */
for (old_a = list->next; old_a; old_a = old_a->next) {
/* Compute the amount of storage needed for a copy of the node: */
name_size = strlen (old_a->name);
value_size = (old_a->repn == VStringRepn) ?
strlen ((VStringConst) old_a->value) + 1 : 0;
/* Allocate that size and fill in the node's value: */
new_a = VMalloc (sizeof (VAttrRec) + name_size + value_size);
strcpy (new_a->name, old_a->name);
switch (new_a->repn = old_a->repn) {
case VAttrListRepn:
new_a->value = VCopyAttrList (old_a->value);
break;
case VBundleRepn:
old_b = old_a->value;
new_b = VCreateBundle (old_b->type_name,
VCopyAttrList (old_b->list),
old_b->length, NULL);
if (old_b->length > 0) {
new_b->data = VMalloc (old_b->length);
memcpy (new_b->data, old_b->data, old_b->length);
}
new_a->value = new_b;
break;
case VPointerRepn:
new_a->value = old_a->value;
break;
case VStringRepn:
new_a->value = (VPointer) (new_a->name + name_size + 1);
strcpy (new_a->value, old_a->value);
break;
default:
if (methods = VRepnMethods (new_a->repn))
new_a->value = (methods->copy) (old_a->value);
else VError ("VCopyAttrList: %s attribute has invalid repn %d",
old_a->name, old_a->repn);
}
/* Append it to the new list: */
new_a->next = NULL;
if (new_a->prev = new_list->prev)
new_a->prev->next = new_a;
if (! new_list->next)
new_list->next = new_a;
new_list->prev = new_a;
}
return new_list;
}
int main(int argc, char *argv[]) {
static VArgVector in_files1;
static VArgVector in_files2;
static VString out_filename;
static VOptionDescRec options[] = {
{ "in1", VStringRepn, 0, & in_files1, VRequiredOpt, NULL, "Input files 1" },
{ "in2", VStringRepn, 0, & in_files2, VRequiredOpt, NULL, "Input files 2" },
{ "out", VStringRepn, 1, & out_filename, VRequiredOpt, NULL, "Output file" }
};
FILE *fp = NULL;
VStringConst in_filename, buf1, buf2;
VAttrList list1, list2, out_list;
VAttrListPosn posn;
VImage src, *src1, *src2, dest = NULL;
int i, nimages, npix = 0;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vpaired_wilcoxtest V%s", ver);
fprintf(stderr, "%s\n", prg_name);
/*
** parse command line
*/
if(! VParseCommand(VNumber(options), options, & argc, argv)) {
VReportUsage(argv[0], VNumber(options), options, NULL);
exit(EXIT_FAILURE);
}
if(argc > 1) {
VReportBadArgs(argc, argv);
exit(EXIT_FAILURE);
}
/* number of images */
nimages = in_files1.number;
if(in_files2.number != nimages)
VError(" inconsistent number of files ");
for(i = 0; i < nimages; i++) {
buf1 = ((VStringConst *) in_files1.vector)[i];
buf2 = ((VStringConst *) in_files2.vector)[i];
fprintf(stderr, "%3d: %s %s\n", i, buf1, buf2);
}
fprintf(stderr, "\n");
/*
** read images 1
*/
src1 = (VImage *) VCalloc(nimages, sizeof(VImage));
for(i = 0; i < nimages; i++) {
src1[i] = NULL;
in_filename = ((VStringConst *) in_files1.vector)[i];
fp = VOpenInputFile(in_filename, TRUE);
list1 = VReadFile(fp, NULL);
if(! list1)
VError("Error reading image");
fclose(fp);
for(VFirstAttr(list1, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & src);
if(VPixelRepn(src) != VFloatRepn)
continue;
src1[i] = src;
break;
}
if(i == 0)
npix = VImageNPixels(src1[i]);
else if(npix != VImageNPixels(src1[i]))
VError(" inconsistent image dimensions");
if(src1[i] == NULL)
VError(" no image found in %s", in_filename);
}
/*
** read images 2
*/
src2 = (VImage *) VCalloc(nimages, sizeof(VImage));
for(i = 0; i < nimages; i++) {
src2[i] = NULL;
in_filename = ((VStringConst *) in_files2.vector)[i];
fp = VOpenInputFile(in_filename, TRUE);
list2 = VReadFile(fp, NULL);
if(! list2)
VError("Error reading image");
fclose(fp);
for(VFirstAttr(list2, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & src);
if(VPixelRepn(src) != VFloatRepn)
continue;
src2[i] = src;
break;
}
if(npix != VImageNPixels(src2[i]))
VError(" inconsistent image dimensions");
if(src2[i] == NULL)
VError(" no image found in %s", in_filename);
}
/*
** paired wilcoxon test
*/
dest = PairedWilcoxTest(src1, src2, dest, nimages);
/*
** output
*/
out_list = VCreateAttrList();
VHistory(VNumber(options), options, prg_name, &list1, &out_list);
VAppendAttr(out_list, "image", NULL, VImageRepn, dest);
fp = VOpenOutputFile(out_filename, TRUE);
if(! VWriteFile(fp, out_list))
exit(1);
fclose(fp);
fprintf(stderr, "%s: done.\n", argv[0]);
exit(0);
}
int main(int argc, char *argv[]) {
/* command line arguments */
static VString out_filename;
static VArgVector in_files;
static VString trans_filename = "";
static VBoolean in_found, out_found;
static VShort minval = 0;
static VBoolean compress = TRUE;
static VFloat resolution = 3;
static VOptionDescRec options[] = {
{ "in", VStringRepn, 0, & in_files, & in_found, NULL, "Input file" },
{ "out", VStringRepn, 1, & out_filename, & out_found, NULL, "Output file" },
{
"trans", VStringRepn, 1, &trans_filename, VRequiredOpt, NULL,
"File containing transformation matrix"
},
{
"resolution", VFloatRepn, 1, &resolution, VOptionalOpt, NULL,
"Output voxel resolution in mm"
},
{
"minval", VShortRepn, 1, &minval, VOptionalOpt, NULL,
"Signal threshold"
},
{
"compress", VBooleanRepn, 1, &compress, VOptionalOpt, NULL,
"Whether to compress empty slices"
}
};
VStringConst in_filename;
FILE *in_file, *out_file, *fp;
VAttrList list, list1, out_list;
VAttrListPosn posn;
VImage trans = NULL;
VImage *dst_image;
VImageInfo *imageInfo;
int nobject = 0, ntimesteps = 0, nbands = 0, nrows = 0, ncols = 0;
VString ca, cp, extent, str;
int found = 0;
int j, dest_nbands;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vfunctrans V%s", ver);
fprintf(stderr, "%s\n", prg_name);
/* Parse command line arguments: */
if(! VParseCommand(VNumber(options), options, & argc, argv) ||
! VIdentifyFiles(VNumber(options), options, "in", & argc, argv, 0) ||
! VIdentifyFiles(VNumber(options), options, "out", & argc, argv, -1))
goto Usage;
if(argc > 1) {
VReportBadArgs(argc, argv);
Usage:
VReportUsage(argv[0], VNumber(options), options, NULL);
exit(EXIT_FAILURE);
}
if(resolution <= 0)
VError(" 'resolution' must be an integer > 0");
/*
** Read the transformation matrix:
*/
fp = VOpenInputFile(trans_filename, TRUE);
list1 = VReadFile(fp, NULL);
if(! list1)
VError("Error reading image");
fclose(fp);
for(VFirstAttr(list1, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
if(strncmp(VGetAttrName(&posn), "transform", 9) != 0)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & trans);
break;
}
if(trans == NULL)
VError("transformation matrix not found");
/*
** check attributes
*/
if(VGetAttr(VImageAttrList(trans), "ca", NULL,
VStringRepn, (VPointer) & ca) != VAttrFound)
VError(" attribute 'ca' missing in transformation matrix ");
if(VGetAttr(VImageAttrList(trans), "cp", NULL,
VStringRepn, (VPointer) & cp) != VAttrFound)
VError(" attribute 'cp' missing in transformation matrix ");
if(VGetAttr(VImageAttrList(trans), "extent", NULL,
VStringRepn, (VPointer) & extent) != VAttrFound)
VError(" attribute 'extent' missing in transformation matrix ");
/*
** open in-file
*/
if(in_files.number < 1 || in_files.number > 1)
VError(" incorrect number of input files: %d", in_files.number);
in_filename = ((VStringConst *) in_files.vector)[0];
if(strcmp(in_filename, "-") == 0)
in_file = stdin;
else {
in_file = fopen((char *)in_filename, "r");
if(! in_file)
VError("Failed to open input file %s", in_filename);
}
/*
** read file info
*/
if(! ReadHeader(in_file))
VError("error reading header");
if(!(list = ReadAttrList(in_file)))
VError("error reading attr list");
j = 0;
for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
j++;
}
imageInfo = (VImageInfo *) VMalloc(sizeof(VImageInfo) * (j + 1));
nobject = nbands = found = 0;
for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
str = VGetAttrName(&posn);
if(strncmp(str, "history", 7) == 0) {
nobject++;
continue;
}
VImageInfoIni(&imageInfo[nbands]);
if(! VGetImageInfo(in_file, list, nobject, &imageInfo[nbands]))
VError(" error reading image info");
if(imageInfo[nbands].repn == VShortRepn) {
found = 1;
nrows = imageInfo[nbands].nrows;
ncols = imageInfo[nbands].ncolumns;
ntimesteps = imageInfo[nbands].nbands;
nbands++;
}
nobject++;
}
fclose(in_file);
if(!found)
VError(" couldn't find functional data");
/*
** process each time step
*/
dst_image = VFunctrans(in_filename, imageInfo, nbands, trans, resolution,
ntimesteps, minval, compress, &dest_nbands);
/*
** output
*/
out_list = VCreateAttrList();
VHistory(VNumber(options), options, prg_name, &list, &out_list);
for(j = 0; j < dest_nbands; j++) {
VAppendAttr(out_list, "image", NULL, VImageRepn, dst_image[j]);
}
/* Open and write the output file: */
if(strcmp(out_filename, "-") == 0)
out_file = stdout;
else {
out_file = fopen(out_filename, "w");
if(! out_file)
VError("Failed to open output file %s", out_filename);
}
if(!VWriteFile(out_file, out_list) || fclose(out_file))
VSystemError("error writing output file");
fprintf(stderr, "\n%s: done.\n", argv[0]);
return (EXIT_SUCCESS);
}
