Exemple #1
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;
}
Exemple #2
0
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;
}
Exemple #3
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;
}
Exemple #4
0
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;
}
Exemple #5
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 */
Exemple #6
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;
}
Exemple #7
0
CVImage::CVImage( VAttrListPosn &posn )
{
	VImage image;

	for ( ; VAttrExists ( & posn ) && ( VGetAttrRepn ( & posn ) == VImageRepn ); VNextAttr ( & posn ) ) {
		const VBoolean result = VGetAttrValue ( &posn, NULL, VImageRepn, &image );
		assert( result );

		if( !images.empty() && !fit( image ) )break;
		else addImage( image );
	}
}
Exemple #8
0
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;
    }
}
Exemple #9
0
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;
}
Exemple #10
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 */
Exemple #11
0
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;
}
Exemple #12
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;
}
Exemple #13
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;
}
Exemple #14
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;
}
Exemple #15
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;
}
Exemple #16
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;
}
Exemple #17
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;
}
Exemple #18
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;
}
Exemple #19
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;
}
Exemple #20
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;
}
Exemple #21
0
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;
}
Exemple #22
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;
}
Exemple #23
0
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;
}
Exemple #24
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;
}
Exemple #25
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;
}
Exemple #26
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 ) );
}
Exemple #27
0
VImage
SimilarityMatrix(VAttrList list, VImage mask, VShort minval, VShort fisher) {
    VAttrListPosn posn;
    VImage src[NSLICES], dest = NULL, map = NULL;
    int b, r, c, i, j, n, ntimesteps, nrows, ncols, nslices;
    double u, x, y, smin, smax, tiny = 1.0e-6;
    gsl_matrix_float *mat = 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;
    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], 0, r, c, VShort) < minval)
                    continue;
                if(VGetPixel(mask, b, r, c) < 0.1)
                    continue;
                n++;
            }
        }
    }
    fprintf(stderr, " n: %d\n", n);
    /*
    ** voxel addresses
    */
    map = VCreateImage(1, 5, n, VFloatRepn);
    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], 0, r, c, VShort) < minval)
                    continue;
                if(VGetPixel(mask, b, r, c) < 0.1)
                    continue;
                VPixel(map, 0, 0, i, VFloat) = b;
                VPixel(map, 0, 1, i, VFloat) = r;
                VPixel(map, 0, 2, i, VFloat) = c;
                i++;
            }
        }
    }
    /* ini output image */
    if(n < 8000)
        dest = VCreateImage(1, n, n, VFloatRepn);
    else if(n >= 8000 && n < 10000)
        dest = VCreateImage(1, n, n, VShortRepn);
    else
        dest = VCreateImage(1, n, n, VSByteRepn);
    VFillImage(dest, VAllBands, 0);
    smin = VPixelMinValue(dest);
    smax = VPixelMaxValue(dest);
    /*
    ** avoid casting to float, copy data to matrix
    */
    mat = gsl_matrix_float_calloc(n, ntimesteps);
    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 = 0; k < ntimesteps; 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++;
        }
    }
    /*
    ** main process loop
    */
    for(i = 0; i < n; i++) {
        if(i % 50 == 0)
            fprintf(stderr, " i: %4d\r", i);
        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);
            u = Correlation(arr1, arr2, ntimesteps);
            /* Fisher r-to-z transform */
            if(fisher) {
                x = 1 + u;
                y = 1 - u;
                if(x < tiny)
                    x = tiny;
                if(y < tiny)
                    y = tiny;
                u = 0.5 * log(x / y);
            }
            if(VPixelRepn(dest) != VFloatRepn) {
                u *= smax;
                if(u < smin)
                    u = smin;
                if(u > smax)
                    u = smax;
            }
            VSetPixel(dest, 0, i, j, u);
            VSetPixel(dest, 0, j, i, u);
        }
    }
    VCopyImageAttrs(src[0], dest);
    VSetAttr(VImageAttrList(dest), "similarity_metric", NULL, VStringRepn, "corr_pearson");
    VSetAttr(VImageAttrList(dest), "name", NULL, VStringRepn, "similarity_matrix");
    VSetAttr(VImageAttrList(dest), "map", NULL, VImageRepn, map);
    return dest;
}
Exemple #28
0
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;
}
Exemple #29
0
/*
** slicetime correction for non-constant TR
*/
void
VSlicetime_NC(VAttrList list, VShort minval, VFloat tdel,
              VBoolean slicetime_correction, float *onset_array, VString filename) {
    FILE *fp = NULL;
    VImage src;
    VAttrListPosn posn;
    VString buf, str;
    int b, r, c, i, j, nt = 0, mt = 0, val, del = 0;
    double xmin, xmax, sum, nx, estim_tr = 0;
    double *xx = NULL, *yy = NULL, xi, yi, slicetime = 0, u = 0;
    gsl_interp_accel *acc = NULL;
    gsl_spline *spline = NULL;
    xmin = (VShort) VRepnMinValue(VShortRepn);
    xmax = (VShort) VRepnMaxValue(VShortRepn);
    buf = VMalloc(LEN);
    /*
    ** read scan times from file, non-constant TR
    */
    if(strlen(filename) > 2) {
        fp = fopen(filename, "r");
        if(!fp)
            VError(" error opening file %s", filename);
        i = 0;
        while(!feof(fp)) {
            for(j = 0; j < LEN; j++)
                buf[j] = '\0';
            fgets(buf, LEN, fp);
            if(buf[0] == '%' || buf[0] == '#')
                continue;
            if(strlen(buf) < 2)
                continue;
            i++;
        }
        rewind(fp);
        nt = i;
        fprintf(stderr, " num timesteps: %d\n", nt);
        xx = (double *) VCalloc(nt, sizeof(double));
        yy = (double *) VCalloc(nt, sizeof(double));
        i = 0;
        sum = 0;
        while(!feof(fp)) {
            for(j = 0; j < LEN; j++)
                buf[j] = '\0';
            fgets(buf, LEN, fp);
            if(buf[0] == '%' || buf[0] == '#')
                continue;
            if(strlen(buf) < 2)
                continue;
            if(sscanf(buf, "%lf", &u) != 1)
                VError(" line %d: illegal input format", i + 1);
            xx[i] = u * 1000.0;  /* convert to millisec */
            if(i > 1)
                sum += xx[i] - xx[i - 1];
            i++;
        }
        fclose(fp);
        estim_tr = sum / (double)(nt - 2);
        fprintf(stderr, " average scan interval = %.3f sec\n", estim_tr / 1000.0);
    }
    /*
    ** process data
    */
    b = -1;
    for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) {
        if(VGetAttrRepn(& posn) != VImageRepn)
            continue;
        VGetAttrValue(& posn, NULL, VImageRepn, & src);
        if(VPixelRepn(src) != VShortRepn)
            continue;
        VSetAttr(VImageAttrList(src), "repetition_time", NULL, VLongRepn, (VLong)estim_tr);
        VExtractAttr(VImageAttrList(src), "MPIL_vista_0", NULL, VStringRepn, &str, FALSE);
        b++;
        if(VImageNRows(src) < 2)
            continue;
        /*
        ** get header info
        */
        if(VGetAttr(VImageAttrList(src), "slice_time", NULL,
                    VDoubleRepn, (VPointer) & slicetime) != VAttrFound && slicetime_correction && onset_array == NULL)
            VError(" 'slice_time' info missing");
        if(onset_array != NULL)
            slicetime = onset_array[b];
        if(nt != VImageNBands(src))
            VError(" inconsistent number of time steps, %d %d",
                   nt, VImageNBands(src));
        if(acc == NULL && slicetime_correction) {
            acc = gsl_interp_accel_alloc();
            spline = gsl_spline_alloc(gsl_interp_akima, nt);
            for(i = 0; i < 5; i++) {
                if(xx[i] / 1000.0 > tdel)
                    break;
            }
            del = i;
            fprintf(stderr, " The first %.2f secs (%d timesteps) will be replaced.\n", tdel, del);
        }
        /*
        ** loop through all voxels in current slice
        */
        if(slicetime_correction)
            fprintf(stderr, " slice: %3d,  %10.3f ms\r", b, slicetime);
        for(r = 0; r < VImageNRows(src); r++) {
            for(c = 0; c < VImageNColumns(src); c++) {
                if(VPixel(src, 0, r, c, VShort) < minval)
                    continue;
                /* replace first few time steps by average */
                if(del > 0) {
                    mt = del + 10;
                    if(mt > nt)
                        mt = nt;
                    sum = nx = 0;
                    for(i = del; i < mt; i++) {
                        sum += VPixel(src, i, r, c, VShort);
                        nx++;
                    }
                    if(nx < 1)
                        continue;
                    val = sum / nx;
                    for(i = 0; i < del; i++) {
                        VPixel(src, i, r, c, VShort) = val;
                    }
                }
                if(!slicetime_correction)
                    continue;
                /* correct for slicetime offsets using cubic spline interpolation */
                for(i = 0; i < nt; i++) {
                    yy[i] = VPixel(src, i, r, c, VShort);
                }
                gsl_spline_init(spline, xx, yy, nt);
                for(i = 1; i < nt; i++) {
                    xi = xx[i] - slicetime;
                    yi = gsl_spline_eval(spline, xi, acc);
                    val = (int)(yi + 0.49);
                    if(val > xmax)
                        val = xmax;
                    if(val < xmin)
                        val = xmin;
                    VPixel(src, i, r, c, VShort) = val;
                }
            }
        }
    }
    fprintf(stderr, "\n");
}
Exemple #30
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;
}