int main(int argc, char **argv) {
static VString filename = "";
static VLong neighb = 2;
static VLong iter = 1;
static VOptionDescRec options[] = {
{
"n", VLongRepn, 1, &neighb, VOptionalOpt, TYPDict,
"type of neighbourhood used for smoothing"
},
{
"iter", VLongRepn, 1, &iter, VOptionalOpt, NULL,
"number of iterations"
},
{
"image", VStringRepn, 1, &filename, VOptionalOpt, NULL,
"grey value image"
},
};
FILE *in_file, *out_file, *fp;
VAttrList list, list1;
VImage src = NULL, dest, image = NULL;
VAttrListPosn posn;
/* Parse command line arguments: */
VParseFilterCmd(VNumber(options), options, argc, argv, &in_file, &out_file);
/* Read transformation image: */
fp = VOpenInputFile(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, & image);
if(VPixelRepn(image) != VUByteRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & image);
break;
}
if(image == NULL)
VError(" image not found");
/* Read source image(s): */
if(!(list = VReadFile(in_file, NULL)))
exit(1);
for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & src);
dest = VTopSmoothImage3d(src, image, NULL, neighb, iter);
if(dest == NULL)
exit(1);
VSetAttrValue(& posn, NULL, VImageRepn, dest);
VDestroyImage(src);
}
/* Write the results to the output file: */
if(VWriteFile(out_file, list))
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;
}
void VParseFilterCmd (int noptions, VOptionDescRec opts[],
int argc, char **argv, FILE **inp, FILE **outp)
{
static VStringConst in_file, out_file;
static VBoolean in_found, out_found;
static VOptionDescRec io_opts[] = {
{ "in", VStringRepn, 1, & in_file, & in_found, NULL, "Input file" },
{ "out", VStringRepn, 1, & out_file, & out_found, NULL, "Output file" }
};
int i, n;
VOptionDescRec options[100];
/* Check that number of options will not overflow the options array. */
if (noptions >= 98) {
VWarning("VParseFilterCmd: Too many options allowed");
noptions = 98;
}
/* Copy options into a new list and add the "in" and "out" options. */
n = 0;
if (inp)
options[n++] = io_opts[0];
if (outp)
options[n++] = io_opts[1];
for (i = 0; i < noptions; i++, n++)
options[n] = opts[i];
/* Parse command line arguments and identify the input and output files: */
if (! VParseCommand (n, options, & argc, argv) ||
(inp && ! VIdentifyFiles (n, options, "in", & argc, argv, 0)) ||
(outp && ! VIdentifyFiles (n, options, "out", & argc, argv, 1)))
goto Usage;
/* Any remaining unparsed arguments are erroneous: */
if (argc > 1) {
VReportBadArgs (argc, argv);
Usage: VReportUsage (argv[0], n, options,
inp ? (outp ? "[infile] [outfile]" : "[infile]") :
(outp ? "[outfile]" : NULL));
exit (EXIT_FAILURE);
}
/* Open the input and output files: */
if (inp)
*inp = VOpenInputFile (in_file, TRUE);
if (outp)
*outp = VOpenOutputFile (out_file, TRUE);
}
VImage read_attribute_template(VString filename) {
VImage attribute_image;
FILE *attribute_input_file = VOpenInputFile(filename, TRUE);
VAttrList attribute_list = VReadFile(attribute_input_file, NULL);
fclose(attribute_input_file);
if(!attribute_list)
VError("Error reading image");
VAttrListPosn position;
for (VFirstAttr(attribute_list, &position); VAttrExists(&position); VNextAttr(&position)) {
if (VGetAttrRepn(&position) != VImageRepn)
continue;
VGetAttrValue(&position,NULL,VImageRepn,&attribute_image);
break;
}
return attribute_image;
}
VAttrList
GetListInfo(VString in_filename, ListInfo *linfo) {
VAttrList list = NULL;
VAttrListPosn posn;
FILE *in_file = NULL;
VString str, voxel = NULL;
VRepnKind repn = VShortRepn;
int ntimesteps, nrows, ncols;
int id, j, itr, found, nobject, nbands;
VImageInfo *imageInfo = NULL;
in_file = VOpenInputFile(in_filename, TRUE);
if(!in_file)
VError("error opening file %s", in_filename);
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));
itr = ntimesteps = nrows = ncols = 0;
nobject = nbands = found = id = 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");
linfo->ntimesteps = linfo->nrows = linfo->ncols = 0;
if(imageInfo[nbands].repn == VShortRepn) {
found = 1;
repn = imageInfo[nbands].repn;
if(imageInfo[nbands].nbands > ntimesteps)
ntimesteps = imageInfo[nbands].nbands;
if(imageInfo[nbands].nrows > nrows)
nrows = imageInfo[nbands].nrows;
if(imageInfo[nbands].ncolumns > ncols)
ncols = imageInfo[nbands].ncolumns;
if(voxel == NULL)
voxel = imageInfo[nbands].voxel;
/* check if slice contains non-zero data */
linfo->zero[nbands] = 1;
if(imageInfo[nbands].nrows < 2)
linfo->zero[nbands] = 0;
linfo->info[id] = imageInfo[nbands];
itr = imageInfo[nbands].repetition_time;
id++;
nbands++;
}
nobject++;
}
fclose(in_file);
if(!found)
VError(" couldn't find functional data");
linfo->ntimesteps = ntimesteps;
linfo->nrows = nrows;
linfo->ncols = ncols;
linfo->nslices = id;
linfo->itr = itr;
linfo->repn = repn;
linfo->voxel = voxel;
linfo->filename = VNewString(in_filename);
return list;
}
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;
}
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;
}
int
main (int argc,char *argv[])
{
static VString filename = "";
static VShort first = 2;
static VShort length = 0;
static VFloat threshold = 0.5;
static VShort minval = 0;
static VShort nproc = 4;
static VOptionDescRec options[] = {
{"mask",VStringRepn,1,(VPointer) &filename,VOptionalOpt,NULL,"mask"},
{"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"},
{"threshold",VFloatRepn,1,(VPointer) &threshold,VOptionalOpt,NULL,"threshold"},
{"j",VShortRepn,1,(VPointer) &nproc,VOptionalOpt,NULL,"number of processors to use, '0' to use all"}
};
FILE *in_file,*out_file,*fp;
VAttrList list=NULL,list1=NULL,out_list=NULL;
VAttrListPosn posn;
VImage mask=NULL;
char *prg = "vncm";
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 && VPixelRepn(mask) != VUByteRepn && VPixelRepn(mask) != VShortRepn) {
mask = NULL;
continue;
}
}
if (mask == NULL) VError(" no mask found");
/*
** read functional data
*/
if (! (list = VReadFile (in_file, NULL))) exit (1);
fclose(in_file);
/* 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 */
/*
** process
*/
out_list = VNCM(list,mask,minval,first,length,threshold);
VHistory(VNumber(options),options,prg,&list,&out_list);
if (! VWriteFile (out_file, out_list)) exit (1);
fprintf (stderr, "%s: done.\n", argv[0]);
return 0;
}
int main(int argc, char *argv[])
{
static VLong op = 0;
static VLong dim = 1;
static VShort radius = 2;
static VString mask_filename=" ";
static VOptionDescRec options[] = {
{ "op", VLongRepn, 1, &op, VOptionalOpt, OPDict,
"type of operation" },
{ "dim", VLongRepn, 1, &dim, VOptionalOpt, DIMDict,
"dim of structuring element (2D or 3D)" },
{ "radius", VShortRepn, 1,(VPointer) & radius,
VOptionalOpt, NULL,"radius of structuring element" },
{ "file", VStringRepn, 1, & mask_filename, VOptionalOpt, NULL,
"File containing structuring element" }
};
FILE *in_file, *out_file, *mask_file;
VAttrList list, list2;
VAttrListPosn posn;
VImage src=NULL, se=NULL, result, tmp;
char prg[50];
sprintf(prg,"vgreymorph3d V%s", getVersion());
fprintf (stderr, "%s\n", prg);
/* Parse command line arguments and identify files: */
VParseFilterCmd(VNumber(options),options,argc,argv,&in_file,&out_file);
if (strlen(mask_filename) < 2) {
if (dim == 0)
se = VGenSphere2d(radius);
else if (dim == 1)
se = VGenSphere3d(radius);
else
VError("illegal choice of parameter 'dim' (%d), must be 2 or 3",dim);
}
else {
mask_file = VOpenInputFile (mask_filename, TRUE);
list2 = VReadFile (mask_file, NULL);
if (! list2)
VError("Error reading structuring element");
fclose(mask_file);
for (VFirstAttr (list2,&posn); VAttrExists (& posn); VNextAttr (& posn)) {
if (VGetAttrRepn (& posn) != VImageRepn) continue;
VGetAttrValue (& posn, NULL, VImageRepn, & se);
if (VPixelRepn(se) != VBitRepn)
VError("Structuring element must be of type VBit");
}
}
/* Read the input file: */
list = VReadFile (in_file, 0); if (! list) exit(1);
fclose(in_file);
/* For each attribute read... */
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr(& posn)) {
if (VGetAttrRepn (& posn) != VImageRepn) continue;
VGetAttrValue (& posn, NULL, VImageRepn, & src);
switch (op) {
case 0:
result = VGreyDilation3d(src,se,NULL);
break;
case 1:
result = VGreyErosion3d(src,se,NULL);
break;
case 2:
tmp = VGreyErosion3d(src,se,NULL);
result = VGreyDilation3d(tmp,se,NULL);
VDestroyImage(tmp);
break;
case 3:
tmp = VGreyDilation3d(src,se,NULL);
result = VGreyErosion3d(tmp,se,NULL);
VDestroyImage(tmp);
break;
}
if (! result) exit(1);
VSetAttrValue(&posn, 0, VImageRepn, result);
VDestroyImage (src);
}
/* Write out the results: */
VHistory(VNumber(options),options,prg,&list,&list);
if (! VWriteFile (out_file, list)) exit(1);
fprintf(stderr, "%s: done.\n", argv[0]);
return 0;
}
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;
}
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);
}
int main(int argc, char *argv[]) {
static VArgVector in_files1;
static VArgVector in_files2;
static VArgVector mask_file;
static VArgVector report_file;
static VOptionDescRec options[] = {
{ "in1", VStringRepn, 0, & in_files1, VRequiredOpt, NULL, "Input files 1" },
{ "in2", VStringRepn, 0, & in_files2, VRequiredOpt, NULL, "Input files 2" },
{ "report", VStringRepn, 0, & report_file, VRequiredOpt, NULL, "Report file" },
{ "mask", VStringRepn, 0, & mask_file, VRequiredOpt, NULL, "Mask file(s)" }
};
FILE *fp = NULL;
VStringConst in_filename;
VAttrList list1, list2, list3;
VAttrListPosn posn;
VString str;
VImage src, *src1, *src2, *mask;
int i, nimages = 0, mimages = 0;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vROIpaired_ttest V%s", ver);
fprintf(stderr, "%s\n", prg_name);
if(!VParseCommand(VNumber(options), options, & argc, argv)) {
VReportUsage(argv[0], VNumber(options), options, NULL);
exit(0);
}
/* get number of input images */
nimages = in_files1.number;
if(in_files2.number != nimages)
VError(" inconsistent number of files: in1: %d, in2: %d ",
nimages, in_files2.number);
mimages = mask_file.number;
if(nimages != mimages && mimages > 1)
VError(" inconsistent number of files, images: %d, masks: %d", nimages, mimages);
/* images 1 */
src1 = (VImage *) VMalloc(sizeof(VImage) * nimages);
for(i = 0; i < nimages; i++) {
src1[i] = NULL;
in_filename = ((VStringConst *) in_files1.vector)[i];
fp = VOpenInputFile(in_filename, TRUE);
if(!fp)
VError("Error opening file %s", in_filename);
list1 = VReadFile(fp, NULL);
if(! list1)
VError("Error reading file %s", in_filename);
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;
}
src1[i] = src;
break;
}
if(src1[i] == NULL)
VError(" no contrast image found in %s", in_filename);
}
/* images 2 */
src2 = (VImage *) VMalloc(sizeof(VImage) * nimages);
for(i = 0; i < nimages; i++) {
src2[i] = NULL;
in_filename = ((VStringConst *) in_files2.vector)[i];
fp = VOpenInputFile(in_filename, TRUE);
if(!fp)
VError("Error opening file %s", in_filename);
list2 = VReadFile(fp, NULL);
if(! list2)
VError("Error reading file %s", in_filename);
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;
}
src2[i] = src;
break;
}
if(src2[i] == NULL)
VError(" no contrast image found in %s", in_filename);
}
for(i = 0; i < nimages; i++) {
fprintf(stderr, "%3d: %s %s\n", i,
((VStringConst *) in_files1.vector)[i],
((VStringConst *) in_files2.vector)[i]);
}
fprintf(stderr, "\n");
/* mask images */
mask = (VImage *) VMalloc(sizeof(VImage) * mimages);
for(i = 0; i < mimages; i++) {
mask[i] = NULL;
in_filename = ((VStringConst *) mask_file.vector)[i];
fp = VOpenInputFile(in_filename, TRUE);
if(!fp)
VError("Error opening file %s", in_filename);
list3 = VReadFile(fp, NULL);
if(! list3)
VError("Error reading file", in_filename);
fclose(fp);
for(VFirstAttr(list3, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & src);
if(VPixelRepn(src) != VUByteRepn)
mask[i] = VConvertImageCopy(src, NULL, VAllBands, VUByteRepn);
else
mask[i] = src;
break;
}
if(mask[i] == NULL)
VError(" mask %d not found", i);
}
/* open report_file */
fp = NULL;
in_filename = ((VStringConst *) report_file.vector)[0];
fp = fopen(in_filename, "w");
if(!fp)
VError(" error opening file %s", in_filename);
/* paired t-test in ROIs */
VROIpaired_ttest(src1, src2, mask, nimages, mimages, fp);
exit(0);
}
