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;
}
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[])
{
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;
}
VBoolean VLookupAttr (VAttrList list, VStringConst name, VAttrListPosn *posn)
{
for (VFirstAttr (list, posn); VAttrExists (posn); VNextAttr (posn))
if (strcmp (VGetAttrName (posn), name) == 0)
return TRUE;
return FALSE;
}
VImage VImageManager::vtimestep( VAttrList list, VImage dest, int step )
{
VFillImage( dest, VAllBands, 0 );
VPointer src_pp = NULL;
VPointer dest_pp = NULL;
VAttrListPosn posn;
VShort *ptr1 = NULL;
VShort *ptr2 = NULL;
VString str;
VImage src;
int n = 0;
int npixels = 0;
bool revert = false;
for ( VFirstAttr ( list, & posn ); VAttrExists ( & posn ); VNextAttr ( & posn ) ) {
if ( VGetAttrRepn ( & posn ) != VImageRepn )
continue;
VGetAttrValue ( &posn, NULL, VImageRepn, &src );
if ( VPixelRepn( src ) != VShortRepn )
continue;
if ( ( VGetAttr ( VImageAttrList ( src ), "MPIL_vista_0", NULL,
VStringRepn, ( VPointer ) & str ) != VAttrFound ) &&
( VGetAttr ( VImageAttrList ( src ), "repetition_time", NULL,
VStringRepn, ( VPointer ) & str ) != VAttrFound ) )
continue;
/* doch nicht rumdrehen!
if (VGetAttr (VImageAttrList (src), "extent", NULL,
VStringRepn, (VPointer) & str) != VAttrFound)
revert = true;
*/
if ( n == 0 )
VCopyImageAttrs ( src, dest );
if ( VImageNRows( src ) > 1 ) {
if ( VSelectBand ( "vtimestep", src, step, &npixels, &src_pp ) == FALSE )
VError( "err reading data" );
int destBand = ( revert ) ? VImageNBands( dest ) - n - 1 : n;
dest_pp = VPixelPtr( dest, destBand, 0, 0 );
ptr1 = ( VShort * ) src_pp;
ptr2 = ( VShort * ) dest_pp;
memcpy ( ptr2, ptr1, npixels * sizeof( VShort ) );
}
n++;
}
return dest;
}
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 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 VPointer VGraphEncodeDataMethod (VPointer value, VAttrList list,
size_t length, VBoolean *free_itp)
{
VGraph graph = value;
VAttrListPosn posn;
VNode n;
size_t len;
VPointer p, ptr;
VAdjacency adj;
int i, nadj;
#define pack(repn, cnt, dest) \
if (! VPackData (repn, cnt, dest, VMsbFirst, &len, &p, NULL)) return NULL; \
p = (char *) p + len; length -= len; len = length;
/* Remove the attributes prepended by the VGraphEncodeAttrsMethod: */
for (VFirstAttr (list, & posn);
strcmp (VGetAttrName (& posn), VRepnAttr) != 0; VDeleteAttr (& posn));
VDeleteAttr (& posn);
/* Allocate a buffer for the encoded data: */
if (length == 0) {
*free_itp = FALSE;
return value; /* we may return anything != 0 here */
};
p = ptr = VMalloc (length);
len = length;
/* Pack each node: */
for (i = 1; i <= graph->size; i++) {
n = VGraphGetNode(graph, i); if (n == 0) continue;
/* Count the number of adjacencies : */
for (adj = n->base.head, nadj = 0; adj; adj = adj->next) nadj++;
/* Pack the header */
pack(VLongRepn, 1, &i);
pack(VLongRepn, 1, &nadj);
/* Pack the adjacencies : */
for (adj = n->base.head; adj; adj = adj->next) {
pack(VLongRepn, 1, &adj->id);
if (graph->useWeights) { pack(VFloatRepn, 1, &adj->weight); };
};
/* Pack the node itself: */
if (graph->useWeights) { pack(VFloatRepn, 1, &(n->base.weight)); };
pack(graph->node_repn, graph->nfields, n->data);
}
*free_itp = TRUE;
return ptr;
}
void
VReleaseStorage(VAttrList list) {
VImage src;
VAttrListPosn posn;
for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
if(VGetAttrRepn(& posn) != VImageRepn)
continue;
VGetAttrValue(& posn, NULL, VImageRepn, & src);
VDestroyImage(src);
src = NULL;
}
}
int VReadObjects (FILE *file, VRepnKind repn, VAttrList *attributes,
VPointer **objects)
{
VAttrList list;
VAttrListPosn posn;
int i, nobjects = 0;
VPointer *vector;
/* Read the file's contents: */
list = VReadFile (file, NULL);
if (! list)
return FALSE;
/* Count the objects found: */
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn))
nobjects += (VGetAttrRepn (& posn) == repn);
if (nobjects == 0) {
VWarning ("VReadObjects: No %s objects present in stream",
VRepnName (repn));
VDestroyAttrList (list);
return FALSE;
}
/* Allocate a vector of that many object pointers: */
vector = VMalloc (nobjects * sizeof (VPointer));
/* Extract the objects from the attribute list and place them in the
vector: */
for (VFirstAttr (list, & posn), i = 0; VAttrExists (& posn); )
if (VGetAttrRepn (& posn) == repn) {
VGetAttrValue (& posn, NULL, repn, vector + i);
VDeleteAttr (& posn);
i++;
} else VNextAttr (& posn);
/* Return the objects and the remaining attributes: */
*attributes = list;
*objects = vector;
return nobjects;
}
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;
}
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;
}
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;
}
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;
}
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;
}
static VPointer VImageEncodeDataMethod (VPointer value, VAttrList list,
size_t length, VBoolean *free_itp)
{
VImage image = value;
VAttrListPosn posn;
size_t len;
VPointer ptr;
/* Remove the attributes prepended by the VImageEncodeAttrsMethod: */
for (VFirstAttr (list, & posn);
strcmp (VGetAttrName (& posn), VRepnAttr) != 0;
VDeleteAttr (& posn)) ;
VDeleteAttr (& posn);
/* Pack and return pixel data: */
if (! VPackData (VPixelRepn (image), VImageNPixels (image),
VImageData (image), VMsbFirst, & len, & ptr, free_itp))
return NULL;
if (len != length)
VError ("VImageEncodeDataMethod: Encoded data has unexpected length");
return ptr;
}
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;
}
static VBoolean WriteAttrList (FILE *f, VAttrList list, int indent, VList *data_list, long *offset)
{
VAttrListPosn posn;
int i;
/* Write the { marking the beginning of the attribute list: */
FailTest (fputs ("{\n", f));
/* Write each attribute in the list: */
for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn))
if (! WriteAttr (f, & posn, indent, data_list, offset))
return FALSE;
/* Write the } marking the end of the attribute list: */
for (i = indent - 1; i > 0; i--)
FailTest (fputc ('\t', f));
FailTest (fputc ('}', f));
return TRUE;
Fail:
VWarning ("VWriteFile: Write to stream failed");
return FALSE;
}
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;
}
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
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;
}
float *
VCorrMatrix(VAttrList list,VImage map,VShort first,VShort length)
{
VAttrListPosn posn;
VImage src[NSLICES];
size_t b,r,c,i,j,i1,n,m,nt,last,ntimesteps,nrows,ncols,nslices;
gsl_matrix_float *mat=NULL;
float *A=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);
/* number of voxels */
n = VImageNColumns(map);
fprintf(stderr," ntimesteps: %d, first= %d, last= %d, nt= %d, nvoxels: %ld\n",
(int)ntimesteps,(int)first,(int)last,(int)nt,(long)n);
/*
** avoid casting to float, copy data to matrix
*/
mat = gsl_matrix_float_calloc(n,nt);
if (!mat) VError(" err allocating mat");
for (i=0; i<n; i++) {
b = VPixel(map,0,0,i,VShort);
r = VPixel(map,0,1,i,VShort);
c = VPixel(map,0,2,i,VShort);
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," compute correlation matrix...\n");
A = (float *) VCalloc(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] = v;
}
}
fprintf(stderr," matrix done.\n");
gsl_matrix_float_free(mat);
return A;
}
VImage
GetMap(VAttrList list1,VAttrList list2,VImage mask,VShort minval)
{
VAttrListPosn posn;
VImage src1[NSLICES],src2[NSLICES],map=NULL;
size_t b,r,c,i,n;
int nrows,ncols,nslices,nrows2,ncols2,nslices2;
/*
** get image dimensions
*/
i = nrows = ncols = 0;
for (VFirstAttr (list1, & posn); VAttrExists (& posn); VNextAttr (& posn)) {
if (VGetAttrRepn (& posn) != VImageRepn) continue;
VGetAttrValue (& posn, NULL,VImageRepn, & src1[i]);
if (VPixelRepn(src1[i]) != VShortRepn) continue;
if (VImageNRows(src1[i]) > nrows) nrows = VImageNRows(src1[i]);
if (VImageNColumns(src1[i]) > ncols) ncols = VImageNColumns(src1[i]);
i++;
if (i >= NSLICES) VError(" too many slices");
}
nslices = i;
i = nrows2 = ncols2 = 0;
for (VFirstAttr (list2, & posn); VAttrExists (& posn); VNextAttr (& posn)) {
if (VGetAttrRepn (& posn) != VImageRepn) continue;
VGetAttrValue (& posn, NULL,VImageRepn, & src2[i]);
if (VPixelRepn(src2[i]) != VShortRepn) continue;
if (VImageNRows(src2[i]) > nrows2) nrows2 = VImageNRows(src2[i]);
if (VImageNColumns(src2[i]) > ncols2) ncols2 = VImageNColumns(src2[i]);
i++;
if (i >= NSLICES) VError(" too many slices");
}
nslices2 = i;
if (nslices2 != nslices) VError(" inconsistent number of slices: %d %d",nslices,nslices2);
if (nrows2 != nrows) VError(" inconsistent number of rows: %d %d",nrows,nrows2);
if (ncols2 != ncols) VError(" inconsistent number of cols: %d %d",ncols,ncols2);
/* count number of voxels */
n = 0;
for (b=0; b<nslices; b++) {
if (VImageNRows(src1[b]) < 2) continue;
if (VImageNRows(src2[b]) < 2) continue;
for (r=0; r<nrows; r++) {
for (c=0; c<ncols; c++) {
if (VPixel(src1[b],0,r,c,VShort) < minval) continue;
if (VPixel(src2[b],0,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,VShortRepn);
if (map == NULL) VError(" error allocating addr map");
VFillImage(map,VAllBands,0);
VCopyImageAttrs (src1[0],map);
VPixel(map,0,3,0,VShort) = nslices;
VPixel(map,0,3,1,VShort) = nrows;
VPixel(map,0,3,2,VShort) = ncols;
i = 0;
for (b=0; b<nslices; b++) {
if (VImageNRows(src1[b]) < 2) continue;
if (VImageNRows(src2[b]) < 2) continue;
for (r=0; r<nrows; r++) {
for (c=0; c<ncols; c++) {
if (VPixel(src1[b],0,r,c,VShort) < minval) continue;
if (VPixel(src2[b],0,r,c,VShort) < minval) continue;
if (VGetPixel(mask,b,r,c) < 0.5) continue;
VPixel(map,0,0,i,VShort) = b;
VPixel(map,0,1,i,VShort) = r;
VPixel(map,0,2,i,VShort) = c;
i++;
}
}
}
return map;
}
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;
}
void VImageManager::init( VAttrList list )
{
VAttrListPosn posn;
int nbands = 0;
int nrows = 0;
int ncols = 0;
int timeSlices = 2;
VImage src;
VString str;
for ( VFirstAttr ( list, & posn ); VAttrExists ( & posn ); VNextAttr ( & posn ) ) {
if ( VGetAttrRepn ( & posn ) != VImageRepn )
continue;
VGetAttrValue ( &posn, NULL, VImageRepn, &src );
if ( VPixelRepn( src ) != VShortRepn )
continue;
// check if we have a functional data image
if ( ( VGetAttr ( VImageAttrList ( src ), "MPIL_vista_0", NULL,
VStringRepn, ( VPointer ) & str ) == VAttrFound ) ||
( VGetAttr ( VImageAttrList ( src ), "repetition_time", NULL,
VStringRepn, ( VPointer ) & str ) == VAttrFound ) ) {
if ( VImageNRows( src ) > nrows )
nrows = VImageNRows( src );
if ( VImageNColumns( src ) > ncols )
ncols = VImageNColumns( src );
if ( VImageNBands( src ) > timeSlices )
timeSlices = VImageNBands( src );
nbands++;
}
}
if ( nbands == 0 )
VError( "No raw data found" );
// now loading the vimages
int currentTimeSlice = 0; // curr slice
for ( currentTimeSlice = 0; currentTimeSlice < timeSlices; currentTimeSlice++ ) {
VImage dest = VCreateImage( nbands, nrows, ncols, VShortRepn );
vtimestep( list, dest, currentTimeSlice );
m_imageList.append( dest );
}
prepareScaleValue();
// creating data arrays
int size = ncols * nbands;
m_coronarData = new unsigned char[size];
memset( m_coronarData, 0, size * sizeof( unsigned char ) );
size = ncols * nrows;
m_axialData = new unsigned char[size];
memset( m_axialData, 0, size * sizeof( unsigned char ) );
size = nbands * nrows;
m_sagittalData = new unsigned char[size];
memset( m_sagittalData, 0, size * sizeof( unsigned char ) );
}
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;
}