void ReadField (VString Name, VImage& X, VImage& Y, VImage& Z, VAttrList& history_list)
{
FILE* file; /* input file */
VAttrList list; /* attribute list */
VAttrListPosn pos; /* position in list */
/* initialize results */
X = Y = Z = 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 */
history_list = VCopyAttrList(VReadHistory(&list));
/* extract field images */
if (VLookupAttr (list, "X", &pos))
{
VGetAttrValue (&pos, NULL, VImageRepn, &X);
VSetAttrValue (&pos, NULL, VImageRepn, NULL);
}
else VError ("Input file '%s' does not contain an image 'X'", Name);
if (VLookupAttr (list, "Y", &pos))
{
VGetAttrValue (&pos, NULL, VImageRepn, &Y);
VSetAttrValue (&pos, NULL, VImageRepn, NULL);
}
else VError ("Input file '%s' does not contain an image 'Y'", Name);
if (VLookupAttr (list, "Z", &pos))
{
VGetAttrValue (&pos, NULL, VImageRepn, &Z);
VSetAttrValue (&pos, NULL, VImageRepn, NULL);
}
else VError ("Input file '%s' does not contain an image 'Z'", Name);
/* clean-up*/
VDestroyAttrList (list);
fclose (file);
} /* ReadField */
int
main (int argc,char *argv[])
{
static VFloat sigma = 1.5;
static VOptionDescRec options[] = {
{"sigma",VFloatRepn,1,(VPointer) &sigma,VOptionalOpt,NULL,"std dev"}
};
FILE *in_file,*out_file;
VAttrList list=NULL;
VAttrListPosn posn;
VImage src=NULL,dest=NULL;
char prg[50];
sprintf(prg,"vgauss2d V%s", getVersion());
fprintf (stderr, "%s\n", prg);
VParseFilterCmd (VNumber (options),options,argc,argv,&in_file,&out_file);
if (! (list = VReadFile (in_file, NULL))) exit (1);
fclose(in_file);
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {
if (VGetAttrRepn (& posn) != VImageRepn) continue;
VGetAttrValue (& posn, NULL,VImageRepn, & src);
dest = VFilterGauss2d (src,NULL,(double)sigma);
VSetAttrValue (& posn, NULL,VImageRepn,dest);
}
if (src == NULL) VError(" no input image found");
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 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 VLong hemi = 0;
static VOptionDescRec options[] = {
{ "hemi", VLongRepn, 1, & hemi, VOptionalOpt, HEMIDict,
"Hemisphere to retain" }
};
FILE *in_file, *out_file;
VAttrList list;
VAttrListPosn posn;
VImage isrc=NULL;
VGraph gsrc=NULL,dest=NULL;
char prg[50];
sprintf(prg,"vhemi 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);
/* Read the grey input file: */
list = VReadFile (in_file, NULL);
if (! list) VError("Error reading input image");
fclose(in_file);
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {
if (VGetAttrRepn (& posn) == VImageRepn) {
VGetAttrValue (& posn, NULL, VImageRepn, & isrc);
VImageHemi(&isrc,hemi);
VSetAttrValue (& posn, NULL,VImageRepn,isrc);
}
else if (VGetAttrRepn (& posn) == VGraphRepn) {
VGetAttrValue (& posn, NULL, VGraphRepn, & gsrc);
dest = VGraphHemi(gsrc,hemi);
VSetAttrValue (& posn, NULL,VGraphRepn,dest);
}
}
/* 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;
}
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 */
int
main (int argc,char *argv[])
{
static VShort aneighb = 1;
static VShort arepn = 1;
static VOptionDescRec options[] = {
{"n",VShortRepn,1,(VPointer) &aneighb,
VOptionalOpt,ADJDict,"neighbourhood type"},
{"repn",VShortRepn,1,(VPointer) &arepn,
VOptionalOpt,TYPEDict,"output representation type (ubyte or short)"}
};
FILE *in_file,*out_file;
VAttrList list=NULL;
VAttrListPosn posn;
VImage src=NULL,dest=NULL;
int nl=0,neighb;
VRepnKind repn;
char prg[50];
sprintf(prg,"vlabel2d V%s", getVersion());
fprintf (stderr, "%s\n", prg);
VParseFilterCmd (VNumber (options),options,argc,argv,&in_file,&out_file);
if (arepn == 0) repn = VUByteRepn;
else repn = VShortRepn;
if (aneighb == 0) neighb = 4;
else neighb = 8;
if (! (list = VReadFile (in_file, NULL))) exit (1);
fclose(in_file);
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {
if (VGetAttrRepn (& posn) != VImageRepn) continue;
VGetAttrValue (& posn, NULL,VImageRepn, & src);
dest = VLabelImage2d(src,NULL, (int) neighb,repn,&nl);
fprintf(stderr," numlabels= %d\n",nl);
VSetAttrValue (& posn, NULL,VImageRepn,dest);
}
if (src == NULL) VError(" no input image found");
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 VShort first = 0;
static VShort last = -1;
static VOptionDescRec options[] = {
{ "first", VShortRepn, 1, (VPointer) & first,
VOptionalOpt, NULL, "First slice" },
{ "last", VShortRepn, 1, (VPointer) & last,
VOptionalOpt, NULL, "Last slice " }
};
FILE *in_file, *out_file;
VAttrList list;
VAttrListPosn posn;
VImage src=NULL, result=NULL;
char prg[50];
sprintf(prg,"vselbands 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);
/* Read the input file: */
list = VReadFile (in_file, NULL);
if (! list) exit (1);
/* process */
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {
if (VGetAttrRepn (& posn) != VImageRepn) continue;
VGetAttrValue (& posn, NULL, VImageRepn, & src);
result = VSelSlices (src, NULL,first,last);
if (! result) exit (1);
VSetAttrValue (& posn, NULL, 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;
}
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 */
int main(int argc, char *argv[]) {
static VDouble d1 = 0;
static VDouble d2 = 3.0;
static VShort threshold = 155;
static VShort background = 30;
static VFloat edge = 20;
static VOptionDescRec options[] = {
{ "d1", VDoubleRepn, 1, &d1, VOptionalOpt, 0, "erosion" },
{ "d2", VDoubleRepn, 1, &d2, VOptionalOpt, 0, "dilation" },
{ "t", VShortRepn, 1, &threshold, VOptionalOpt, 0, "threshold" },
{ "background", VShortRepn, 1, &background, VOptionalOpt, 0, " image background" },
{ "edge", VFloatRepn, 1, &edge, VOptionalOpt, 0, "edge strength" }
};
VAttrList list;
VAttrListPosn posn;
VImage src = NULL, dst = NULL;
FILE *in_file, *out_file;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vbrainpeel V%s", ver);
fprintf(stderr, "%s\n", prg_name);
VParseFilterCmd(VNumber(options), options, argc, argv, &in_file, &out_file);
/* Read source image(s): */
if(!(list = VReadFile(in_file, NULL)))
return 1;
fclose(in_file);
/* Operate on each source image: */
for(VFirstAttr(list, &posn); VAttrExists(&posn); VNextAttr(&posn)) {
if(VGetAttrRepn(&posn) == VImageRepn) {
VGetAttrValue(&posn, NULL, VImageRepn, &src);
dst = VPeel(src, NULL, d1, d2, edge, threshold, background);
if(dst)
VSetAttrValue(&posn, NULL, VImageRepn, dst);
else
VError(" error in vbrainpeel");
}
}
/* Write the results to the output file: */
VHistory(VNumber(options), options, prg_name, &list, &list);
if(!VWriteFile(out_file, list))
return 1;
fprintf(stderr, " %s: done.\n", argv[0]);
return 0;
}
int main(int argc, char *argv[]) {
static VBoolean x_axis = FALSE;
static VBoolean y_axis = FALSE;
static VBoolean z_axis = FALSE;
static VOptionDescRec options[] = {
{ "x", VBooleanRepn, 1, (VPointer) &x_axis, VOptionalOpt, NULL, "Flip x-axis" },
{ "y", VBooleanRepn, 1, (VPointer) &y_axis, VOptionalOpt, NULL, "Flip y-axis" },
{ "z", VBooleanRepn, 1, (VPointer) &z_axis, VOptionalOpt, NULL, "Flip z-axis" },
};
FILE *in_file, *out_file;
VAttrList list;
VAttrListPosn posn;
VImage src = NULL, result = NULL;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vflip3d V%s", ver);
fprintf(stderr, "%s\n", prg_name);
VWarning("It is recommended to use the program vswapdim since vflip3d does not support extended header informations");
/* Parse command line arguments and identify files: */
VParseFilterCmd(VNumber(options), options, argc, argv, &in_file, &out_file);
/* Read the input file: */
list = VReadFile(in_file, NULL);
if(! list)
exit(1);
/* For each attribute read... */
for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & src);
result = Flip3dImage(src, NULL, VAllBands, x_axis, y_axis, z_axis);
if(! result)
exit(1);
VSetAttrValue(& posn, NULL, VImageRepn, result);
VDestroyImage(src);
}
/* Write out the results: */
if(! VWriteFile(out_file, list))
exit(1);
fprintf(stderr, "%s: done.\n", argv[0]);
return 0;
}
int main (int argc,char *argv[])
{
FILE *in_file, *out_file;
VAttrList list;
VAttrListPosn posn;
VImage src=NULL, dest=NULL;
char prg[50];
sprintf(prg,"vthin3d V%s", getVersion());
fprintf (stderr, "%s\n", prg);
/* Parse command line arguments and identify files: */
VParseFilterCmd (0,NULL, argc, argv, & in_file, & out_file);
/* Read the input file: */
list = VReadFile (in_file, NULL);
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);
if (VPixelRepn(src) != VBitRepn) continue;
dest = VThin3d(src, NULL,(int)26);
if (! dest) exit (1);
VSetAttrValue (& posn, NULL, VImageRepn, dest);
VDestroyImage (src);
}
/* output */
VHistory(0,NULL,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 VDouble xmin = 0;
static VDouble xmax = 255;
static VOptionDescRec options[] = {
{"min",VDoubleRepn,1,(VPointer) &xmin,VOptionalOpt,NULL,"lower threshold"},
{"max",VDoubleRepn,1,(VPointer) &xmax,VOptionalOpt,NULL,"upper threshold"},
};
FILE *in_file,*out_file;
VAttrList list=NULL;
VAttrListPosn posn;
VImage src=NULL,dest=NULL;
char prg[50];
sprintf(prg,"vbinarize V%s", getVersion());
fprintf (stderr, "%s\n", prg);
VParseFilterCmd (VNumber (options),options,argc,argv,&in_file,&out_file);
if (! (list = VReadFile (in_file, NULL))) exit (1);
fclose(in_file);
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {
if (VGetAttrRepn (& posn) != VImageRepn) continue;
VGetAttrValue (& posn, NULL,VImageRepn, & src);
dest = VBinarizeImage (src,NULL,xmin,xmax);
VSetAttrValue (& posn, NULL,VImageRepn,dest);
}
if (src == NULL) VError(" no input image found");
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 VString cfile = "";
static VOptionDescRec options[] = {
{"file", VStringRepn, 1, (VPointer) &cfile, VOptionalOpt, NULL, "file"}
};
FILE *in_file, *out_file;
VAttrList list = NULL;
VAttrListPosn posn;
VImage design = NULL, dest = NULL;
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vaddcovariates V%s", ver);
fprintf(stderr, "%s\n", prg_name);
VParseFilterCmd(VNumber(options), options, argc, argv, &in_file, &out_file);
if(!(list = VReadFile(in_file, NULL)))
exit(1);
fclose(in_file);
for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & design);
if(VPixelRepn(design) != VFloatRepn && VPixelRepn(design) != VDoubleRepn)
continue;
dest = VAddCovariates(design, cfile);
VSetAttrValue(& posn, NULL, VImageRepn, dest);
break;
}
if(design == NULL)
VError(" design matrix not found ");
/* Output: */
if(! VWriteFile(out_file, list))
exit(1);
fprintf(stderr, " %s: done.\n", argv[0]);
return 0;
}
int main(int argc, char *argv[]) {
static VFloat reso = -1.0;
static VLong itype = 0;
static VBoolean flip = TRUE;
static VBoolean reorder = TRUE;
static VOptionDescRec options[] = {
{
"reso", VFloatRepn, 1, (VPointer) &reso,
VOptionalOpt, NULL, "New voxel resolution in mm, def: -1 means min(1.0,\"best source resolution\")"
},
{
"flip", VBooleanRepn, 1, (VPointer) &flip,
VOptionalOpt, NULL, "Whether to flip to natural convention"
},
{
"reorder", VBooleanRepn, 1, (VPointer) &reorder,
VOptionalOpt, NULL, "Whether to reorder axial slices from axial source image"
},
{
"interpolation", VLongRepn, 1, & itype, VOptionalOpt, ITYPDict,
"Type of interpolation (0: linear, 1: nearest neighbour, 2: cubic spline)"
}
};
FILE *in_file, *out_file;
VAttrList list;
VAttrListPosn posn;
int nobjects = 0;
VImage src = NULL, dest = NULL, result = NULL;
int i, b, r, c, nbands, nrows, ncols;
VString str, newstr, fixpointString, caString, cpString;
float fix_c, fix_r, fix_b;
float ca_c, ca_r, ca_b;
float cp_c, cp_r, cp_b;
float x, y, z, min;
VDouble v, scale_band, scale_row, scale_col;
float scale[3], shift[3];
/* print information */
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "visotrop V%s", ver);
fprintf(stderr, "%s\n", prg_name);
fflush(stderr);
/* Parse command line arguments: */
VParseFilterCmd(VNumber(options), options, argc, argv,
& in_file, & out_file);
/* Read source image(s): */
if(!(list = VReadFile(in_file, NULL)))
exit(EXIT_FAILURE);
/* Scale each object: */
for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
switch(VGetAttrRepn(& posn)) {
case VImageRepn:
VGetAttrValue(& posn, NULL, VImageRepn, & src);
if(VGetAttr(VImageAttrList(src), "voxel", NULL,
VStringRepn, (VPointer) & str) == VAttrFound) {
sscanf(str, "%f %f %f", &x, &y, &z);
fprintf(stderr, " voxel: %f %f %f\n", x, y, z);
min = x < y ? x : y;
min = z < min ? z : min;
/* if resolution is not set, use default value 1 or
smaler value if the image resolution is better */
if(reso < 0.0)
reso = min < 1.0 ? min : 1.0;
if(reso <= 0.0)
exit(EXIT_FAILURE);
fprintf(stderr, " new resolution: %f \n", reso);
scale_col = x / reso;
scale_row = y / reso;
scale_band = z / reso;
nbands = VImageNBands(src) * scale_band;
nrows = VImageNRows(src) * scale_row;
ncols = VImageNColumns(src) * scale_col;
if(VImageNBands(src) == nbands
&& VImageNRows(src) == nrows
&& VImageNColumns(src) == ncols) {
itype = 0;
}
fprintf(stderr, " interpolation type: %s\n", ITYPDict[itype].keyword);
fprintf(stderr, " old dim: %3d %3d %3d\n",
VImageNBands(src), VImageNRows(src), VImageNColumns(src));
for(i = 0; i < 3; i++)
shift[i] = scale[i] = 0;
scale[0] = scale_band;
scale[1] = scale_row;
scale[2] = scale_col;
switch(itype) {
/* trilinear interpolation resampling */
case 0:
dest = VTriLinearScale3d(src, NULL, (int)nbands, (int)nrows, (int)ncols,
shift, scale);
break;
/* nearest neightbour resampling */
case 1:
dest = VNNScale3d(src, NULL, (int)nbands, (int)nrows, (int)ncols,
shift, scale);
break;
/* cubic spline */
case 2:
dest = VCubicSplineScale3d(src, NULL, (int)nbands, (int)nrows, (int)ncols,
shift, scale);
break;
case 3: /* no interpolation, just reshuffle */
dest = VCopyImage(src, NULL, VAllBands);
break;
default:
VError(" unknown resampling type %d", itype);
}
if(! dest)
exit(EXIT_FAILURE);
/*aa 2003/09/11 added function not to rotate siemens data*/
if(! VGetAttr(VImageAttrList(src), "orientation", NULL,
VStringRepn, (VPointer) & str) == VAttrFound)
VError(" attribute 'orientation' missing");
if(strcmp(str, "axial") == 0) {
fprintf(stderr, " new dim: %3d %3d %3d\n", nbands, nrows, ncols);
result = VCreateImage(nbands, nrows, ncols, VPixelRepn(src));
VFillImage(result, VAllBands, 0);
for(b = 0; b < nbands; b++)
for(r = 0; r < nrows; r++)
for(c = 0; c < ncols; c++) {
v = VGetPixel(dest, b, r, c);
if((flip == FALSE) && (reorder == FALSE))
VSetPixel(result, b, r, ncols - c - 1, v);
else if((flip == TRUE) && (reorder == FALSE))
VSetPixel(result, b, r, c, v);
else if((flip == FALSE) && (reorder == TRUE))
VSetPixel(result, nbands - b - 1, r, ncols - c - 1, v);
else if((flip == TRUE) && (reorder == TRUE))
VSetPixel(result, nbands - b - 1, r, c, v);
}
} else if(strcmp(str, "sagittal") == 0) {
/* re-arrange from sagittal to axial orientation */
fprintf(stderr, " new dim: %3d %3d %3d\n", nrows, ncols, nbands);
result = VCreateImage(nrows, ncols, nbands, VPixelRepn(src));
VFillImage(result, VAllBands, 0);
for(b = 0; b < nbands; b++)
for(r = 0; r < nrows; r++)
for(c = 0; c < ncols; c++) {
v = VGetPixel(dest, b, r, c);
if(flip == FALSE)
VSetPixel(result, r, c, nbands - b - 1, v);
else
VSetPixel(result, r, c, b, v);
}
} else if(strcmp(str, "coronal") == 0) {
/* re-arrange from coronal to axial orientation */
fprintf(stderr, " new dim: %3d %3d %3d\n", nrows, nbands, ncols);
result = VCreateImage(nrows, nbands, ncols, VPixelRepn(src));
VFillImage(result, VAllBands, 0);
for(b = 0; b < nbands; b++)
for(r = 0; r < nrows; r++)
for(c = 0; c < ncols; c++) {
v = VGetPixel(dest, b, r, c);
if(flip == FALSE)
VSetPixel(result, r, b, ncols - c - 1, v);
else
VSetPixel(result, r, b, c, v);
}
} else {
VError(" unknown resampling type %d", itype);
exit(EXIT_FAILURE);
}
/* copy attributes from source image */
VCopyImageAttrs(src, result);
// [TS] 08/03/27
// correct 'fixpoint', 'ca' and 'cp' if they exist in the source image
//
// NOTE:
// this is only done when no flipping or reordering is requested :-(
// (WARNING!!!!) '-flip true' actually means that no flipping is done (WHAAAAT ????)
// and therefore we test for reorder = false and flip = true
fixpointString = VMalloc(80);
caString = VMalloc(80);
cpString = VMalloc(80);
VBoolean _issueWarning = FALSE;
if(VGetAttr(VImageAttrList(src), "fixpoint", NULL, VStringRepn, (VPointer)&fixpointString) == VAttrFound) {
if(reorder == FALSE && flip == TRUE) {
sscanf(fixpointString, "%f %f %f", &fix_c, &fix_r, &fix_b);
fix_c *= scale_col;
fix_r *= scale_row;
fix_b *= scale_band;
sprintf((char *)fixpointString, "%f %f %f", fix_c, fix_r, fix_b);
VSetAttr(VImageAttrList(result), "fixpoint", NULL, VStringRepn, fixpointString);
} else {
_issueWarning = TRUE;
}
}
if(VGetAttr(VImageAttrList(src), "ca", NULL, VStringRepn, (VPointer)&caString) == VAttrFound) {
if(reorder == FALSE && flip == TRUE) {
sscanf(caString, "%f %f %f", &ca_c, &ca_r, &ca_b);
ca_c *= scale_col;
ca_r *= scale_row;
ca_b *= scale_band;
sprintf((char *)caString, "%f %f %f", ca_c, ca_r, ca_b);
VSetAttr(VImageAttrList(result), "ca", NULL, VStringRepn, caString);
} else {
_issueWarning = TRUE;
}
}
if(VGetAttr(VImageAttrList(src), "cp", NULL, VStringRepn, (VPointer)&cpString) == VAttrFound) {
if(reorder == FALSE && flip == TRUE) {
sscanf(cpString, "%f %f %f", &cp_c, &cp_r, &cp_b);
cp_c *= scale_col;
cp_r *= scale_row;
cp_b *= scale_band;
sprintf((char *)cpString, "%f %f %f", cp_c, cp_r, cp_b);
VSetAttr(VImageAttrList(result), "cp", NULL, VStringRepn, cpString);
} else {
_issueWarning = TRUE;
}
}
if(_issueWarning) {
VWarning("Attributes 'fixpoint', 'ca' and 'cp' exist but were not corrected and are therefore likely to be wrong");
VWarning("This was caused by setting -flip to false or -reorder to true");
VWarning("Please correct the values manually using vattredit");
}
/* set the attributes to the changed values */
newstr = VMalloc(80);
sprintf((char *)newstr, "%f %f %f", reso, reso, reso);
VSetAttr(VImageAttrList(result), "voxel", NULL, VStringRepn, newstr);
VSetAttr(VImageAttrList(result), "orientation", NULL, VStringRepn, "axial");
if(flip)
VSetAttr(VImageAttrList(result), "convention", NULL, VStringRepn, "natural");
else
VSetAttr(VImageAttrList(result), "convention", NULL, VStringRepn, "radiologic");
}
VSetAttrValue(& posn, NULL, VImageRepn, result);
VDestroyImage(src);
break;
default:
continue;
}
nobjects++;
}
/* Make History */
VHistory(VNumber(options), options, prg_name, &list, &list);
/* Write the results to the output file: */
if(! VWriteFile(out_file, list))
exit(EXIT_FAILURE);
fprintf(stderr, "%s: done.\n", argv[0]);
return EXIT_SUCCESS;
}
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[])
{
VString inname; /* name of input images */
VString outname; /* name of output images */
VString fieldname; /* name of deformation field */
VBoolean verbose = TRUE; /* verbose flag */
VOptionDescRec options[] = /* options of program */
{
{"in", VStringRepn, 1, &inname, VRequiredOpt, NULL, "Input image"},
{"out", VStringRepn, 1, &outname, VRequiredOpt, NULL, "Deformed output image"},
{"field", VStringRepn, 1, &fieldname, VRequiredOpt, NULL, "3D deformation field"},
{"verbose", VBooleanRepn, 1, &verbose, VOptionalOpt, NULL, "Show status messages. Optional"}
};
VAttrList in_history=NULL; /* history of input images */
VAttrList field_history=NULL; /* history of deformation field */
VAttrList In; /* input images */
VImage Dx, Dy, Dz; /* field images */
VAttrListPosn pos; /* position in list */
VImage in; /* image in list */
float fx, fy, fz; /* scaling factors */
VImage dx, dy, dz; /* scaled deformation field */
VAttrListPosn rider; /* functional data rider */
int bands, rows, columns, steps; /* size of functional data */
VImage data; /* functional data */
VShort *src, *dest; /* functional data pointer */
VBoolean success; /* success flag */
int n, t, z; /* indices */
/* print information */
char prg_name[100];
char ver[100];
getLipsiaVersion(ver, sizeof(ver));
sprintf(prg_name, "vdeform V%s", ver);
fprintf (stderr, "%s\n", prg_name); fflush (stderr);
/* parse command line */
if (!VParseCommand (VNumber (options), options, &argc, argv))
{
if (argc > 1) VReportBadArgs (argc, argv);
VReportUsage (argv[0], VNumber (options), options, NULL);
exit (1);
}
/* read input images */
if (verbose) {fprintf (stderr, "Reading input image '%s' ...\n", inname); fflush (stderr);}
ReadImages (inname, In, in_history);
if (!In) exit (2);
/* read deformation field */
if (verbose) {fprintf (stderr, "Reading 3D deformation field '%s' ...\n", fieldname); fflush (stderr);}
ReadField (fieldname, Dx, Dy, Dz, field_history);
if (!Dx || !Dy || !Dz) exit (3);
/* deform anatomical images */
for (VFirstAttr (In, &pos); VAttrExists (&pos); VNextAttr (&pos))
{
/* get image */
VGetAttrValue (&pos, NULL, VImageRepn, &in);
if (VPixelRepn (in) != VUByteRepn) break;
/* compare image and field */
if (verbose) {fprintf (stderr, "Comparing anatomical image and deformation field ...\n"); fflush (stderr);}
if (!Compatible (in, Dx)) exit (4);
if (!Compatible (in, Dy)) exit (4);
if (!Compatible (in, Dz)) exit (4);
/* deform image */
if (verbose) {fprintf (stderr, "Deforming anatomical image ...\n"); fflush (stderr);}
RTTI (in, TrilinearInverseDeform, (in, Dx, Dy, Dz));
VSetAttrValue (&pos, NULL, VImageRepn, in);
}
/* deform map images */
for (; VAttrExists (&pos); VNextAttr (&pos))
{
/* get image */
VGetAttrValue (&pos, NULL, VImageRepn, &in);
if (VPixelRepn (in) != VFloatRepn) break;
/* scale field */
if (verbose) {fprintf (stderr, "Scaling deformation field ...\n"); fflush (stderr);}
fx = (float) VImageNColumns (in) / (float) VImageNColumns (Dx);
fy = (float) VImageNRows (in) / (float) VImageNRows (Dy);
fz = (float) VImageNBands (in) / (float) VImageNBands (Dz);
TrilinearScale<VFloat> (Dx, fx, fy, fz, dx); Multiply<VFloat> (dx, fx);
TrilinearScale<VFloat> (Dy, fx, fy, fz, dy); Multiply<VFloat> (dy, fy);
TrilinearScale<VFloat> (Dz, fx, fy, fz, dz); Multiply<VFloat> (dz, fz);
/* compare image and field */
if (verbose) {fprintf (stderr, "Comparing map image and deformation field ...\n"); fflush (stderr);}
if (!Compatible (in, dx)) exit (5);
if (!Compatible (in, dy)) exit (5);
if (!Compatible (in, dz)) exit (5);
/* deform image */
if (verbose) {fprintf (stderr, "Deforming map image ...\n"); fflush (stderr);}
RTTI (in, TrilinearInverseDeform, (in, dx, dy, dz));
VSetAttrValue (&pos, NULL, VImageRepn, in);
/* clean-up */
VDestroyImage (dx);
VDestroyImage (dy);
VDestroyImage (dz);
}
/* deform functional images */
if (VAttrExists (&pos))
{
/* get data size */
bands = rows = columns = steps = 0;
for (rider = pos; VAttrExists (&rider); VNextAttr (&rider))
{
/* get image */
VGetAttrValue (&rider, NULL, VImageRepn, &data);
if (VPixelRepn (data) != VShortRepn) break;
/* store image size */
if (VImageNBands (data) > steps) steps = VImageNBands (data);
if (VImageNRows (data) > rows) rows = VImageNRows (data);
if (VImageNColumns (data) > columns) columns = VImageNColumns (data);
bands++;
}
in = VCreateImage (bands, rows, columns, VShortRepn);
/* scale field */
if (verbose) {fprintf (stderr, "Scaling deformation field ...\n"); fflush (stderr);}
fx = (float) VImageNColumns (in) / (float) VImageNColumns (Dx);
fy = (float) VImageNRows (in) / (float) VImageNRows (Dy);
fz = (float) VImageNBands (in) / (float) VImageNBands (Dz);
TrilinearScale<VFloat> (Dx, fx, fy, fz, dx); Multiply<VFloat> (dx, fx);
TrilinearScale<VFloat> (Dy, fx, fy, fz, dy); Multiply<VFloat> (dy, fy);
TrilinearScale<VFloat> (Dz, fx, fy, fz, dz); Multiply<VFloat> (dz, fz);
/* compare image and field */
if (verbose) {fprintf (stderr, "Comparing functional images and deformation field ...\n"); fflush (stderr);}
if (!Compatible (in, dx)) exit (6);
if (!Compatible (in, dy)) exit (6);
if (!Compatible (in, dz)) exit (6);
/* expand zero images */
for (rider = pos, z = 0; z < bands; z++, VNextAttr (&rider))
{
VGetAttrValue (&rider, NULL, VImageRepn, &data);
if (FunctionalZero (data))
{
FunctionalResize (data, steps, rows, columns);
VSetAttrValue (&rider, NULL, VImageRepn, data);
}
}
/* deform images */
if (verbose) {fprintf (stderr, "Deforming functional images ...\n"); fflush (stderr);}
for (t = 0; t < steps; t++)
{
/* collect data */
dest = (VShort*) VPixelPtr (in, 0, 0, 0);
for (rider = pos, z = 0; z < bands; z++, VNextAttr (&rider))
{
VGetAttrValue (&rider, NULL, VImageRepn, &data);
src = (VShort*) VPixelPtr (data, t, 0, 0);
for (n = 0; n < rows * columns; ++n)
*(dest++) = *(src++);
}
/* deform image */
if (verbose) {fprintf (stderr, "Timestep %d of %d ...\r", t + 1, steps); fflush (stderr);}
RTTI (in, TrilinearInverseDeform, (in, dx, dy, dz));
/* spread data */
src = (VShort*) VPixelPtr (in, 0, 0, 0);
for (rider = pos, z = 0; z < bands; z++, VNextAttr (&rider))
{
VGetAttrValue (&rider, NULL, VImageRepn, &data);
dest = (VShort*) VPixelPtr (data, t, 0, 0);
for (n = 0; n < rows * columns; ++n)
*(dest++) = *(src++);
}
}
/* collapse zero images */
for (rider = pos, z = 0; z < bands; z++, VNextAttr (&rider))
{
VGetAttrValue (&rider, NULL, VImageRepn, &data);
if (FunctionalZero (data))
{
FunctionalResize (data, 1, 1, 1);
VSetAttrValue (&rider, NULL, VImageRepn, data);
}
}
/* clean-up */
VDestroyImage (in);
VDestroyImage (dx);
VDestroyImage (dy);
VDestroyImage (dz);
/* proceed */
pos = rider;
}
/* check list */
if (VAttrExists (&pos))
{
VError ("Remaining image does not contain valid data");
exit (7);
}
/* Prepend History */
VPrependHistory(VNumber(options),options,prg_name,&in_history);
/* write output images */
if (verbose) {fprintf (stderr, "Writing output image '%s' ...\n", outname); fflush (stderr);}
success = WriteImages (outname, In, in_history);
if (!success) exit (8);
/* clean-up
VDestroyAttrList (inhistory);
VDestroyAttrList (fieldhistory);
VDestroyAttrList (In);
VDestroyImage (Dx);
VDestroyImage (Dy);
VDestroyImage (Dz); */
/* exit */
if (verbose) {fprintf (stderr, "Finished.\n"); fflush (stderr);}
return 0;
} /* main */
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;
}
static VBoolean ReadData (FILE *f, VAttrList list, VReadFileFilterProc *filter, long *offset)
{
VAttrListPosn posn, subposn;
VAttrList sublist;
VBundle b;
VRepnKind repn;
VBoolean read_data, data_found, length_found;
VLong data, length;
VTypeMethods *methods;
VPointer value;
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {
switch (VGetAttrRepn (& posn)) {
case VAttrListRepn:
/* Recurse on nested attribute list: */
VGetAttrValue (& posn, NULL, VAttrListRepn, & sublist);
if (! ReadData (f, sublist, filter, offset))
return FALSE;
break;
case VBundleRepn:
VGetAttrValue (& posn, NULL, VBundleRepn, & b);
repn = VLookupType (b->type_name);
/* If a filter routine was supplied, ask it whether to bother
with the binary data: */
read_data = ! filter || (*filter) (b, repn);
/* Extract any data and length attributes in the object's value: */
data_found = VLookupAttr (b->list, VDataAttr, & subposn);
if (data_found) {
if (! VGetAttrValue (& subposn, NULL, VLongRepn, & data)) {
VWarning ("VReadFile: "
"%s attribute's data attribute incorrect",
VGetAttrName (& posn));
return FALSE;
}
VDeleteAttr (& subposn);
}
length_found = VLookupAttr (b->list, VLengthAttr, & subposn);
if (length_found) {
if (! VGetAttrValue (& subposn, NULL, VLongRepn, & length)) {
VWarning ("VReadFile: "
"%s attribute's length attribute incorrect",
VGetAttrName (& posn));
return FALSE;
}
VDeleteAttr (& subposn);
}
/* None or both must be present: */
if (data_found ^ length_found) {
VWarning ("VReadFile: %s attribute has %s but not %s",
VGetAttrName (& posn),
data_found ? "data" : "length",
data_found ? "length" : "data");
return FALSE;
}
/* Read the binary data associated with the object: */
if (data_found) {
if (data < *offset) {
VWarning ("VReadFile: "
"%s attribute's data attribute incorrect",
VGetAttrName (& posn));
return FALSE;
}
if (! read_data)
data += length;
/* To seek forward to the start of the data block we first
try fseek. That will fail on a pipe, in which case we
seek by reading. */
if (data != *offset &&
fseek (f, (long) data - *offset, SEEK_CUR) == -1 &&
errno == ESPIPE &&
! MySeek (f, data - *offset)) {
VSystemWarning ("VReadFile: Seek within file failed");
return FALSE;
}
if (read_data) {
b->data = VMalloc (b->length = length);
if (fread (b->data, 1, length, f) != length) {
VWarning ("VReadFile: Read from stream failed");
return FALSE;
}
*offset = data + length;
} else
/* bug: read error occured when bundle was not read
by a filter function. FK 24/03/98 */
*offset = data;
}
/* Recurse to read binary data for sublist attributes: */
if (! ReadData (f, b->list, filter, offset))
return FALSE;
/* If the object's type is registered and has a decode method,
invoke it to decode the binary data: */
if (read_data && repn != VUnknownRepn &&
(methods = VRepnMethods (repn)) && methods->decode) {
if (! (value = (methods->decode) (VGetAttrName (& posn), b)))
return FALSE;
/* Replace the old typed value with the newly decoded one: */
VSetAttrValue (& posn, NULL, repn, value);
VDestroyBundle (b);
}
break;
default:
break;
}
}
return TRUE;
}
