THD_3dim_dataset * Voxelwise_Operations(THD_3dim_dataset *dset,
byte *voxmask, char *prefix)
{
TOY_UD ud;
char *stmp;
THD_3dim_dataset *oset=NULL;
ENTRY("Voxelwise_Operations");
/* Here we will perform an fft on each voxel's time series */
/* and compute the power in the first sixth of the spectrum, */
/* and the total power; two values per voxel in total to output */
/* Setup user data structure */
ud.nfft = 128;
stmp = modify_afni_prefix(prefix,NULL,".pow"); /* modify prefix */
/* go for it */
oset = MAKER_4D_to_typed_fbuc(
dset , /* input dataset */
stmp , /* output prefix */
MRI_short , /* output datum */
0 , /* samples to skip from beginning of time series*/
1 , /* pass linearly detrended time series */
2 , /* number of values expected in output */
toy_tsfunc, /* timeseries processor */
(void *)(&ud), /* user data for tsfunc */
voxmask, /* byte mask of voxels to process */
0 /* Allow auto scaling of output */
) ;
EDIT_BRICK_LABEL(oset , 0, "FFTpow6");
EDIT_BRICK_LABEL(oset , 1, "FFTpow");
RETURN(oset);
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *old_dset , *new_dset ; /* input and output datasets */
THD_3dim_dataset *mask_dset=NULL ;
float mask_bot=666.0 , mask_top=-666.0 ;
byte *cmask=NULL ; int ncmask=0 ;
byte *mmm = NULL ;
int mcount=0, verb=0;
int nopt, nbriks, ii ;
int addBriks = 0 ; /* n-1 sub-bricks out */
int fullBriks = 0 ; /* n sub-bricks out */
int tsout = 0 ; /* flag to output a time series (not a stat bucket) */
int numMultBriks,methIndex,brikIndex;
/*----- Help the pitiful user? -----*/
/* bureaucracy */
mainENTRY("3dTstat main"); machdep(); AFNI_logger("3dTstat",argc,argv);
PRINT_VERSION("3dTstat"); AUTHOR("KR Hammett & RW Cox");
/*--- scan command line for options ---*/
if (argc == 1) { usage_3dTstat(1); exit(0); } /* Bob's help shortcut */
nopt = 1 ;
nbriks = 0 ;
nmeths = 0 ;
verb = 0;
while( nopt < argc && argv[nopt][0] == '-' ){
if (strcmp(argv[nopt], "-h") == 0 || strcmp(argv[nopt], "-help") == 0) {
usage_3dTstat(strlen(argv[nopt]) > 3 ? 2:1);
exit(0);
}
if( strcmp(argv[nopt],"-verb") == 0 ){
verb++ ; nopt++ ; continue ;
}
/*-- methods --*/
if( strcasecmp(argv[nopt],"-centromean") == 0 ){ /* 01 Nov 2010 */
meth[nmeths++] = METH_CENTROMEAN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-bmv") == 0 ){
meth[nmeths++] = METH_BMV ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-median") == 0 ){
meth[nmeths++] = METH_MEDIAN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-nzmedian") == 0 ){
meth[nmeths++] = METH_NZMEDIAN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-DW") == 0 ){
meth[nmeths++] = METH_DW ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-zcount") == 0 ){
meth[nmeths++] = METH_ZCOUNT ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-nzcount") == 0 ){
meth[nmeths++] = METH_NZCOUNT ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-MAD") == 0 ){
meth[nmeths++] = METH_MAD ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-mean") == 0 ){
meth[nmeths++] = METH_MEAN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-sum") == 0 ){
meth[nmeths++] = METH_SUM ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-sos") == 0 ){
meth[nmeths++] = METH_SUM_SQUARES ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-abssum") == 0 ){
meth[nmeths++] = METH_ABSSUM ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-slope") == 0 ){
meth[nmeths++] = METH_SLOPE ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-stdev") == 0 ||
strcasecmp(argv[nopt],"-sigma") == 0 ){
meth[nmeths++] = METH_SIGMA ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-cvar") == 0 ){
meth[nmeths++] = METH_CVAR ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-cvarinv") == 0 ){
meth[nmeths++] = METH_CVARINV ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-stdevNOD") == 0 ||
strcasecmp(argv[nopt],"-sigmaNOD") == 0 ){ /* 07 Dec 2001 */
meth[nmeths++] = METH_SIGMA_NOD ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-cvarNOD") == 0 ){ /* 07 Dec 2001 */
meth[nmeths++] = METH_CVAR_NOD ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-cvarinvNOD") == 0 ){
meth[nmeths++] = METH_CVARINVNOD ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-min") == 0 ){
meth[nmeths++] = METH_MIN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-max") == 0 ){
meth[nmeths++] = METH_MAX ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-absmax") == 0 ){
meth[nmeths++] = METH_ABSMAX ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-signed_absmax") == 0 ){
meth[nmeths++] = METH_SIGNED_ABSMAX ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argmin") == 0 ){
meth[nmeths++] = METH_ARGMIN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argmin1") == 0 ){
meth[nmeths++] = METH_ARGMIN1 ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argmax") == 0 ){
meth[nmeths++] = METH_ARGMAX ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argmax1") == 0 ){
meth[nmeths++] = METH_ARGMAX1 ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argabsmax") == 0 ){
meth[nmeths++] = METH_ARGABSMAX ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argabsmax1") == 0 ){
meth[nmeths++] = METH_ARGABSMAX1;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-duration") == 0 ){
meth[nmeths++] = METH_DURATION ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-onset") == 0 ){
meth[nmeths++] = METH_ONSET ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-offset") == 0 ){
meth[nmeths++] = METH_OFFSET ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-centroid") == 0 ){
meth[nmeths++] = METH_CENTROID ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-centduration") == 0 ){
meth[nmeths++] = METH_CENTDURATION ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-nzmean") == 0 ){
meth[nmeths++] = METH_NZMEAN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strncmp(argv[nopt],"-mask",5) == 0 ){
if( mask_dset != NULL )
ERROR_exit("Cannot have two -mask options!\n") ;
if( nopt+1 >= argc )
ERROR_exit("-mask option requires a following argument!\n");
mask_dset = THD_open_dataset( argv[++nopt] ) ;
if( mask_dset == NULL )
ERROR_exit("Cannot open mask dataset!\n") ;
if( DSET_BRICK_TYPE(mask_dset,0) == MRI_complex )
ERROR_exit("Cannot deal with complex-valued mask dataset!\n");
nopt++ ; continue ;
}
if( strncmp(argv[nopt],"-mrange",5) == 0 ){
if( nopt+2 >= argc )
ERROR_exit("-mrange option requires 2 following arguments!\n");
mask_bot = strtod( argv[++nopt] , NULL ) ;
mask_top = strtod( argv[++nopt] , NULL ) ;
if( mask_top < mask_top )
ERROR_exit("-mrange inputs are illegal!\n") ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-cmask") == 0 ){ /* 16 Mar 2000 */
if( nopt+1 >= argc )
ERROR_exit("-cmask option requires a following argument!\n");
cmask = EDT_calcmask( argv[++nopt] , &ncmask, 0 ) ;
if( cmask == NULL ) ERROR_exit("Can't compute -cmask!\n");
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-autocorr") == 0 ){
meth[nmeths++] = METH_AUTOCORR ;
if( ++nopt >= argc ) ERROR_exit("-autocorr needs an argument!\n");
meth[nmeths++] = atoi(argv[nopt++]);
if (meth[nmeths - 1] == 0) {
addBriks++;
} else {
nbriks+=meth[nmeths - 1] ;
}
continue ;
}
if( strcasecmp(argv[nopt],"-autoreg") == 0 ){
meth[nmeths++] = METH_AUTOREGP ;
if( ++nopt >= argc ) ERROR_exit("-autoreg needs an argument!\n");
meth[nmeths++] = atoi(argv[nopt++]);
if (meth[nmeths - 1] == 0) {
addBriks++;
} else {
nbriks+=meth[nmeths - 1] ;
}
continue ;
}
if( strcasecmp(argv[nopt],"-accumulate") == 0 ){ /* 4 Mar 2008 [rickr] */
meth[nmeths++] = METH_ACCUMULATE ;
meth[nmeths++] = -1; /* flag to add N (not N-1) output bricks */
fullBriks++;
tsout = 1; /* flag to output a timeseries */
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-l2norm") == 0 ){ /* 07 Jan 2013 [rickr] */
meth[nmeths++] = METH_L2_NORM ;
nbriks++ ;
nopt++ ; continue ;
}
/*-- prefix --*/
if( strcasecmp(argv[nopt],"-prefix") == 0 ){
if( ++nopt >= argc ) ERROR_exit("-prefix needs an argument!\n");
MCW_strncpy(prefix,argv[nopt],THD_MAX_PREFIX) ;
if( !THD_filename_ok(prefix) )
ERROR_exit("%s is not a valid prefix!\n",prefix);
nopt++ ; continue ;
}
/*-- tdiff --*/
if( strcasecmp(argv[nopt],"-tdiff") == 0 ){ /* 25 May 2011 */
do_tdiff = 1 ; nopt++ ; continue ;
}
/*-- nscale --*/
if( strcasecmp(argv[nopt],"-nscale") == 0 ){ /* 25 May 2011 */
nscale = 1 ; nopt++ ; continue ;
}
/*-- datum --*/
if( strcasecmp(argv[nopt],"-datum") == 0 ){
if( ++nopt >= argc ) ERROR_exit("-datum needs an argument!\n");
if( strcasecmp(argv[nopt],"short") == 0 ){
datum = MRI_short ;
} else if( strcasecmp(argv[nopt],"float") == 0 ){
datum = MRI_float ;
} else if( strcasecmp(argv[nopt],"byte") == 0 ){
datum = MRI_byte ;
} else {
ERROR_exit("-datum of type '%s' is not supported!\n",
argv[nopt] ) ;
}
nopt++ ; continue ;
}
/* base percentage for duration calcs */
if (strcasecmp (argv[nopt], "-basepercent") == 0) {
if( ++nopt >= argc ) ERROR_exit("-basepercent needs an argument!\n");
basepercent = strtod(argv[nopt], NULL);
if(basepercent>1) basepercent /= 100.0; /* assume integer percent if >1*/
nopt++; continue;
}
/*-- Quien sabe'? --*/
ERROR_message("Unknown option: %s\n",argv[nopt]) ;
suggest_best_prog_option(argv[0], argv[nopt]);
exit(1);
}
if (argc < 2) {
ERROR_message("Too few options, use -help for details");
exit(1);
}
/*--- If no options selected, default to single stat MEAN -- KRH ---*/
if (nmeths == 0) nmeths = 1;
if (nbriks == 0 && addBriks == 0 && fullBriks == 0) nbriks = 1;
/*----- read input dataset -----*/
if( nopt >= argc ) ERROR_exit(" No input dataset!?") ;
old_dset = THD_open_dataset( argv[nopt] ) ;
if( !ISVALID_DSET(old_dset) )
ERROR_exit("Can't open dataset %s\n",argv[nopt]);
nopt++ ;
if( nopt < argc )
WARNING_message("Trailing datasets on command line ignored: %s ...",argv[nopt]) ;
if( DSET_NVALS(old_dset) == 1 ){
WARNING_message("Input dataset has 1 sub-brick ==> -tdiff is turned off") ;
do_tdiff = 0 ;
}
/* no input volumes is bad, 1 volume applies to only certain methods */
/* 2 Nov 2010 [rickr] */
if( DSET_NVALS(old_dset) == 0 ) {
ERROR_exit("Time series is of length 0?\n") ;
}
else if( DSET_NVALS(old_dset) == 1 || (do_tdiff && DSET_NVALS(old_dset)==2) ) {
int methOK, OK = 1;
/* see if each method is valid for nvals == 1 */
for( methIndex = 0; methIndex < nmeths; methIndex++ ) {
methOK = 0;
for( ii = 0; ii < NUM_1_INPUT_METHODS; ii++ ) {
if( meth[methIndex] == valid_1_input_methods[ii] ) {
methOK = 1;
break;
}
}
if( ! methOK )
ERROR_exit("Can't use dataset with %d values per voxel!" ,
DSET_NVALS(old_dset) ) ;
}
/* tell the library function that this case is okay */
g_thd_maker_allow_1brick = 1;
}
if( DSET_NUM_TIMES(old_dset) < 2 ){
WARNING_message("Input dataset is not 3D+time; assuming TR=1.0") ;
EDIT_dset_items( old_dset ,
ADN_ntt , DSET_NVALS(old_dset) ,
ADN_ttorg , 0.0 ,
ADN_ttdel , 1.0 ,
ADN_tunits , UNITS_SEC_TYPE ,
NULL ) ;
}
/* If one or more of the -autocorr/-autoreg options was called with */
/* an argument of 0, then I'll now add extra BRIKs for the N-1 data */
/* output points for each. */
nbriks += ((DSET_NVALS(old_dset)-1) * addBriks);
nbriks += ((DSET_NVALS(old_dset) ) * fullBriks);
/* ------------- Mask business -----------------*/
if( mask_dset == NULL ){
mmm = NULL ;
if( verb )
INFO_message("%d voxels in the entire dataset (no mask)\n",
DSET_NVOX(old_dset)) ;
} else {
if( DSET_NVOX(mask_dset) != DSET_NVOX(old_dset) )
ERROR_exit("Input and mask datasets are not same dimensions!\n");
mmm = THD_makemask( mask_dset , 0 , mask_bot, mask_top ) ;
mcount = THD_countmask( DSET_NVOX(old_dset) , mmm ) ;
if( mcount <= 0 ) ERROR_exit("No voxels in the mask!\n") ;
if( verb ) INFO_message("%d voxels in the mask\n",mcount) ;
DSET_delete(mask_dset) ;
}
if( cmask != NULL ){
if( ncmask != DSET_NVOX(old_dset) )
ERROR_exit("Input and cmask datasets are not same dimensions!\n");
if( mmm != NULL ){
for( ii=0 ; ii < DSET_NVOX(old_dset) ; ii++ )
mmm[ii] = (mmm[ii] && cmask[ii]) ;
free(cmask) ;
mcount = THD_countmask( DSET_NVOX(old_dset) , mmm ) ;
if( mcount <= 0 ) ERROR_exit("No voxels in the mask+cmask!\n") ;
if( verb ) INFO_message("%d voxels in the mask+cmask\n",mcount) ;
} else {
mmm = cmask ;
mcount = THD_countmask( DSET_NVOX(old_dset) , mmm ) ;
if( mcount <= 0 ) ERROR_exit("No voxels in the cmask!\n") ;
if( verb ) INFO_message("%d voxels in the cmask\n",mcount) ;
}
}
/*------------- ready to compute new dataset -----------*/
new_dset = MAKER_4D_to_typed_fbuc(
old_dset , /* input dataset */
prefix , /* output prefix */
datum , /* output datum */
0 , /* ignore count */
0 , /* can't detrend in maker function KRH 12/02*/
nbriks , /* number of briks */
STATS_tsfunc , /* timeseries processor */
NULL, /* data for tsfunc */
mmm,
nscale
) ;
if( new_dset != NULL ){
tross_Copy_History( old_dset , new_dset ) ;
tross_Make_History( "3dTstat" , argc,argv , new_dset ) ;
for (methIndex = 0,brikIndex = 0; methIndex < nmeths;
methIndex++, brikIndex++) {
if ((meth[methIndex] == METH_AUTOCORR) ||
(meth[methIndex] == METH_ACCUMULATE) ||
(meth[methIndex] == METH_AUTOREGP)) {
numMultBriks = meth[methIndex+1];
/* note: this looks like it should be NV-1 4 Mar 2008 [rickr] */
if (numMultBriks == 0) numMultBriks = DSET_NVALS(old_dset)-1;
/* new flag for NVALS [rickr] */
if (numMultBriks == -1) numMultBriks = DSET_NVALS(old_dset);
for (ii = 1; ii <= numMultBriks; ii++) {
char tmpstr[25];
if (meth[methIndex] == METH_AUTOREGP) {
sprintf(tmpstr,"%s[%d](%d)",meth_names[meth[methIndex]],
numMultBriks,ii);
} else {
sprintf(tmpstr,"%s(%d)",meth_names[meth[methIndex]],ii);
}
EDIT_BRICK_LABEL(new_dset, (brikIndex + ii - 1), tmpstr) ;
}
methIndex++;
brikIndex += numMultBriks - 1;
} else {
EDIT_BRICK_LABEL(new_dset, brikIndex, meth_names[meth[methIndex]]) ;
}
}
if( tsout ) /* then change output to a time series */
EDIT_dset_items( new_dset ,
ADN_ntt , brikIndex ,
ADN_ttorg , DSET_TIMEORIGIN(old_dset) ,
ADN_ttdel , DSET_TIMESTEP(old_dset) ,
ADN_tunits , DSET_TIMEUNITS(old_dset) ,
NULL ) ;
DSET_write( new_dset ) ;
WROTE_DSET( new_dset ) ;
} else {
ERROR_exit("Unable to compute output dataset!\n") ;
}
exit(0) ;
}
/*! compute the overall minimum and maximum voxel values for a dataset */
int main( int argc , char * argv[] )
{
THD_3dim_dataset * old_dset , * new_dset ; /* input and output datasets */
int nopt, nbriks;
int slow_flag, quick_flag, min_flag, max_flag, mean_flag,
automask,count_flag, sum_flag, var_flag, absolute_flag;
int positive_flag, negative_flag, zero_flag, nan_flag, perc_flag, vol_flag;
byte * mmm=NULL ;
int mmvox=0 ;
int nxyz, i;
float *dvec = NULL, mmin=0.0, mmax=0.0;
int N_mp;
double *mpv=NULL, *perc = NULL;
double mp =0.0f, mp0 = 0.0f, mps = 0.0f, mp1 = 0.0f, di =0.0f ;
byte *mmf = NULL;
MRI_IMAGE *anat_im = NULL;
char *mask_dset_name=NULL;
/*----- Read command line -----*/
mainENTRY("3dBrickStat main"); machdep(); AFNI_logger("3dBrickStat",argc,argv);
nopt = 1 ;
min_flag = 0;
max_flag = -1;
mean_flag = 0;
sum_flag = 0;
var_flag = 0;
slow_flag = 0;
quick_flag = -1;
automask = 0;
count_flag = 0;
vol_flag = 0;
positive_flag = -1;
negative_flag = -1;
absolute_flag = 0;
zero_flag = -1;
nan_flag = -1;
perc_flag = 0;
mmin = 1.0;
mmax = -1.0;
mask_dset_name = NULL;
datum = MRI_float;
while( nopt < argc && argv[nopt][0] == '-' ){
if( strcmp(argv[nopt],"-help") == 0 ||
strcmp(argv[nopt],"-h") == 0){
usage_3dBrickStat(strlen(argv[nopt])> 3 ? 2:1);
exit(0);
}
if( strcmp(argv[nopt],"-ver") == 0 ){
PRINT_VERSION("3dBrickStat"); AUTHOR("Daniel Glen");
nopt++; continue;
}
if( strcmp(argv[nopt],"-quick") == 0 ){
quick_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-percentile") == 0 ){
perc_flag = 1;
++nopt;
if (nopt + 2 >= argc) {
ERROR_exit( "** Error: Need 3 parameter after -percentile\n");
}
mp0 = atof(argv[nopt])/100.0f; ++nopt;
mps = atof(argv[nopt])/100.0f; ++nopt;
mp1 = atof(argv[nopt])/100.0f;
if (mps == 0.0f) {
ERROR_exit( "** Error: step cannot be 0" );
}
if (mp0 < 0 || mp0 > 100 || mp1 < 0 || mp1 > 100) {
ERROR_exit( "** Error: p0 and p1 must be >=0 and <= 100" );
}
nopt++; continue;
}
if( strcmp(argv[nopt],"-median") == 0 ){
perc_flag = 1;
mp0 = 0.50f;
mps = 0.01f;
mp1 = 0.50f;
nopt++; continue;
}
if( strcmp(argv[nopt],"-slow") == 0 ){
slow_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-min") == 0 ){
min_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-max") == 0 ){
max_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-sum") == 0 ){
sum_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-mean") == 0 ){
mean_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-var") == 0 ){
if (var_flag) {
ERROR_message("Looks like -stdev is already used.\n"
"-var and -stdev are mutually exclusive");
exit (1);
}
var_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-stdev") == 0 ){
if (var_flag) {
ERROR_message("Looks like -var is already used.\n"
"-var and -stdev are mutually exclusive");
exit (1);
}
var_flag = 2;
nopt++; continue;
}
if( strcmp(argv[nopt],"-count") == 0 ){
count_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-volume") == 0 ){
vol_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-positive") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 1;
negative_flag = 0;
zero_flag = 0;
nopt++; continue;
}
if( strcmp(argv[nopt],"-negative") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 0;
negative_flag = 1;
zero_flag = 0;
nopt++; continue;
}
if( strcmp(argv[nopt],"-zero") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 0;
negative_flag = 0;
zero_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-non-positive") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 0;
negative_flag = 1;
zero_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-non-negative") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 1;
negative_flag = 0;
zero_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-non-zero") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 1;
negative_flag = 1;
zero_flag = 0;
nopt++; continue;
}
if( strcmp(argv[nopt],"-absolute") == 0 ){
absolute_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-nan") == 0 ){
if(nan_flag!=-1) {
ERROR_exit( "Can not use both -nan -nonan options");
}
nan_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-nonan") == 0 ){
if(nan_flag!=-1) {
ERROR_exit( "Can not use both -nan -nonan options");
}
nan_flag = 0;
nopt++; continue;
}
if( strcmp(argv[nopt],"-autoclip") == 0 ||
strcmp(argv[nopt],"-automask") == 0 ){
if( mmm != NULL ){
ERROR_exit(" ERROR: can't use -autoclip/mask with -mask!");
}
automask = 1 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mrange") == 0 ){
if (nopt+2 >= argc) {
ERROR_exit(" ERROR: Need two values after -mrange");
}
mmin = atof(argv[++nopt]);
mmax = atof(argv[++nopt]);
if (mmax < mmin) {
ERROR_exit(
"1st value in -mrange %s %s should be the smallest one",
argv[nopt-1], argv[nopt]);
}
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mvalue") == 0 ){
if (nopt+1 >= argc) {
ERROR_exit(" ERROR: Need 1 value after -mvalue");
}
mmin = atof(argv[++nopt]);
mmax = mmin ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mask") == 0 ){
if( mask_dset_name != NULL )
ERROR_exit(" ERROR: can't have 2 -mask options!");
mask_dset_name = argv[++nopt];
nopt++ ; continue ;
}
ERROR_message( " Error - unknown option %s", argv[nopt]);
suggest_best_prog_option(argv[0], argv[nopt]);
exit(1);
}
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
ERROR_message("Too few options");
usage_3dBrickStat(0);
exit(1) ;
}
if (mask_dset_name) {
int ninmask = 0;
THD_3dim_dataset * mask_dset ;
if( automask ){
ERROR_exit(" ERROR: can't use -mask with -automask!");
}
mask_dset = THD_open_dataset(mask_dset_name) ;
CHECK_OPEN_ERROR(mask_dset,mask_dset_name) ;
mmm = THD_makemask( mask_dset , 0 , mmin, mmax ) ;
mmvox = DSET_NVOX( mask_dset ) ;
ninmask = THD_countmask (mmvox, mmm);
if (!ninmask) {
ERROR_exit(" No voxels in mask !");
}
/* text output program, so avoid extras 26 Dec 2013 [rickr] */
/* INFO_message("%d voxels in mask\n", ninmask); */
DSET_delete(mask_dset) ;
}
if(((mmm!=NULL) && (quick_flag))||(automask &&quick_flag)) {
if(quick_flag==1)
WARNING_message( "+++ Warning - can't have quick option with mask");
quick_flag = 0;
slow_flag = 1;
}
/* if max_flag is not set by user, check if other user options set */
if(max_flag==-1) {
if(min_flag || mean_flag || count_flag || vol_flag || sum_flag
|| perc_flag || var_flag)
max_flag = 0;
else
max_flag = 1; /* otherwise check only for max */
}
if((var_flag==1)||(mean_flag==1)||(count_flag==1)||
(vol_flag==1)||(absolute_flag==1) ||
(positive_flag!=-1)||(nan_flag!=-1)||
(sum_flag == 1)||(perc_flag == 1) || (var_flag==2)) {
/* mean flag or count_flag implies slow */
slow_flag = 1;
}
/* check slow and quick options */
if((slow_flag)&&(quick_flag!=1)) /* if user asked for slow give it to him */
quick_flag = 0;
else
quick_flag = 1;
if((max_flag==0)&&(min_flag==0)) /* if the user only asked for mean */
quick_flag = 0; /* no need to do quick way */
if((quick_flag) &&
((absolute_flag==1)||(positive_flag==1)||(negative_flag==1)||(zero_flag==1)))
WARNING_message( " Warning - ignoring +/-/0/abs flags for quick computations");
if(positive_flag==-1) { /* if no +/-/0 options set, allow all voxels */
positive_flag = 1;
negative_flag = 1;
zero_flag = 1;
}
/*----- read input dataset -----*/
if( nopt >= argc ){
ERROR_exit(" No input dataset!?");
}
old_dset = THD_open_dataset( argv[nopt] ) ;
CHECK_OPEN_ERROR(old_dset,argv[nopt]) ;
nxyz = DSET_NVOX(old_dset) ;
if( mmm != NULL && mmvox != nxyz ){
ERROR_exit(" Mask and input datasets not the same size!") ;
}
if(automask && mmm == NULL ){
mmm = THD_automask( old_dset ) ;
for(i=0;i<nxyz;i++) {
if(mmm[i]!=0) ++mmvox;
}
}
if(quick_flag)
Print_Header_MinMax(min_flag, max_flag, old_dset);
if(slow_flag!=1)
exit(0);
/* ZSS do some diddlyiddly sorting - DO not affect Daniel's function later on*/
if (perc_flag == 1) {
DSET_mallocize (old_dset);
DSET_load (old_dset);
if (DSET_NVALS(old_dset) != 1) {
ERROR_exit( "-percentile can only be used on one sub-brick only.\n"
"Use sub-brick selectors '[.]' to specify sub-brick of interest.\n");
}
/* prep for input and output of percentiles */
if (mp0 > mp1) {
N_mp = 1;
} else {
/* allocate one above ceiling to prevent truncation error (and crash),
N_mp is recomputed anyway 16 Mar 2009 [rickr] */
N_mp = (int)((double)(mp1-mp0)/(double)mps) + 2;
}
mpv = (double *)malloc(sizeof(double)*N_mp);
perc = (double *)malloc(sizeof(double)*N_mp);
if (!mpv || !perc) {
ERROR_message("Failed to allocate for mpv or perc");
exit(1);
}
N_mp = 0;
mp = mp0;
do {
mpv[N_mp] = mp; ++N_mp; mp += mps;
} while (mp <= mp1+.00000001);
if (!Percentate (DSET_ARRAY(old_dset, 0), mmm, nxyz,
DSET_BRICK_TYPE(old_dset,0), mpv, N_mp,
0, perc,
zero_flag, positive_flag, negative_flag )) {
ERROR_message("Failed to compute percentiles.");
exit(1);
}
/* take care of brick factor */
if (DSET_BRICK_FACTOR(old_dset,0)) {
for (i=0; i<N_mp; ++i) {
perc[i] = perc[i]*DSET_BRICK_FACTOR(old_dset,0);
}
}
for (i=0; i<N_mp; ++i) {
fprintf(stdout,"%.1f %f ", mpv[i]*100.0f, perc[i]);
}
free(mpv); mpv = NULL;
free(perc); perc = NULL;
}
Max_func(min_flag, max_flag, mean_flag,count_flag,
positive_flag, negative_flag, zero_flag, absolute_flag,
nan_flag, sum_flag, var_flag, vol_flag,old_dset, mmm, mmvox);
if(mmm!=NULL)
free(mmm);
exit(0);
/* unused code time series method for extracting data */
#if 0
EDIT_dset_items( old_dset ,
ADN_ntt , DSET_NVALS(old_dset) ,
ADN_ttorg , 0.0 ,
ADN_ttdel , 1.0 ,
ADN_tunits , UNITS_SEC_TYPE ,
NULL ) ;
nbriks = 1;
/*------------- ready to compute new min, max -----------*/
new_dset = MAKER_4D_to_typed_fbuc(
old_dset , /* input dataset */
"temp" , /* output prefix */
datum , /* output datum */
0 , /* ignore count */
0 , /* can't detrend in maker function KRH 12/02*/
nbriks , /* number of briks */
Max_tsfunc , /* timeseries processor */
NULL, /* data for tsfunc */
NULL, /* mask */
0 /* Allow auto scaling of output */
) ;
if(min_flag)
printf("%-13.6g ", minvalue);
if(max_flag)
printf("%-13.6g", maxvalue);
printf("\n");
exit(0) ;
#endif
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *old_dset=NULL , *new_dset=NULL ;
char *prefix = "Filtered" ;
int hh=0 ;
int nvals , nopt ;
if( argc < 2 || strcasecmp(argv[1],"-help") == 0 ){
printf(
"\n"
"3dTfilter takes as input a dataset, filters the time series in\n"
"each voxel as ordered by the user, and outputs a new dataset.\n"
"The data in each voxel is processed separately.\n"
"\n"
"The user (you?) specifies the filter functions to apply.\n"
"They are applied in the order given on the command line:\n"
" -filter rank -filter adaptive:7\n"
"means to do the following operations\n"
" (1) turn the data into ranks\n"
" (2) apply the adaptive mean filter to the ranks\n"
"\n"
"Notes:\n"
"------\n"
"** This program is a work in progress, and more capabilities\n"
" will be added as time allows, as the need arises, and as\n"
" the author's whims bubble to the surface of his febrile brain.\n"
"\n"
"** This program is for people who have Sisu.\n"
"\n"
"Options:\n"
"--------\n"
"\n"
" -input inputdataset\n"
"\n"
" -prefix outputdataset\n"
"\n"
" -filter FunctionName\n"
" At least one '-filter' option is required!\n"
" The FunctionName values that you can give are:\n"
"\n"
" rank = smallest value is replaced by 0,\n"
" next smallest value by 1, and so forth.\n"
" ** This filter is pretty useless.\n"
"\n"
" adaptive:H = adaptive mean filter with half-width of\n"
" 'H' time points (H > 0).\n"
" ** At most one 'adaptive' filter can be used!\n"
" ** The filter 'footprint' is 2*H+1 points.\n"
" ** This filter does local smoothing over the\n"
" 'footprint', with values far away from\n"
" the local median being weighted less.\n"
"\n"
" detrend:P = (least squares) detrend with polynomials of up\n"
" order 'P' for P=0, 1, 2, ....\n"
" ** At most one 'detrend' filter can be used!\n"
"\n"
" despike = apply the 'NEW25' despiking algorithm, as in\n"
" program 3dDespike.\n"
"\n"
"Example:\n"
"--------\n"
" 3dTfilter -input fred.nii -prefix fred.af.nii -filter adaptive:7\n"
"\n"
"-------\n"
"Author: The Programmer with No Name\n"
"-------\n"
"\n"
) ;
exit(0) ;
}
/* bureaucracy */
mainENTRY("3dTfilter main"); machdep(); AFNI_logger("3dTfilter",argc,argv);
PRINT_VERSION("3dTfilter"); AUTHOR("Thorby Baslim");
/*--- scan command line for options ---*/
nopt = 1 ;
while( nopt < argc && argv[nopt][0] == '-' ){
/*-- prefix --*/
if( strcasecmp(argv[nopt],"-prefix") == 0 ){
if( ++nopt >= argc ) ERROR_exit("%s needs an argument!",argv[nopt-1]);
prefix = strdup(argv[nopt]) ;
if( !THD_filename_ok(prefix) )
ERROR_exit("%s is not a valid prefix!",prefix);
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-input") == 0 ||
strcasecmp(argv[nopt],"-inset") == 0 ){
if( ++nopt >= argc ) ERROR_exit("%s needs an argument!",argv[nopt-1]);
if( old_dset != NULL ) ERROR_exit("you can't have 2 input datasets!") ;
old_dset = THD_open_dataset(argv[nopt]) ;
CHECK_OPEN_ERROR(old_dset,argv[nopt]) ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-filter") == 0 ){
if( ++nopt >= argc ) ERROR_exit("%s needs an argument!",argv[nopt-1]);
if( strcasecmp(argv[nopt],"rank") == 0 ){
ADD_FILTER(rank_order_float) ;
INFO_message("Filter #%d = rank",nffunc) ;
} else if( strncasecmp(argv[nopt],"adaptive:",9) == 0 ){
char *cpt=argv[nopt]+9 ;
if( hh > 0 )
ERROR_exit("You can't use more than one 'adaptive' filter :(") ;
if( !isdigit(*cpt) )
ERROR_exit("'%s' is not a valid 'adaptive' filter name",argv[nopt]) ;
hh = (int)strtod(cpt,NULL) ;
if( hh > 29 )
WARNING_message("Very long filter '%s' will be very slow",argv[nopt]) ;
else if( hh <= 0 )
ERROR_exit("'%s' is not a legal 'adaptive' filter name",argv[nopt]) ;
ADD_FILTER(adaptive_filter) ;
INFO_message("Filter #%d = adaptive:%d",nffunc,hh) ;
} else if( strncasecmp(argv[nopt],"detrend:",8) == 0 ){
char *cpt=argv[nopt]+8 ;
if( polort > 0 )
ERROR_exit("You can't use more than one 'detrend' filter :(") ;
if( !isdigit(*cpt) )
ERROR_exit("'%s' is not a valid 'detrend' filter name",argv[nopt]) ;
polort = (int)strtod(cpt,NULL) ;
if( polort < 0 )
ERROR_exit("'%s' is not a legal 'detrend' filter name",argv[nopt]) ;
ADD_FILTER(polort_filter) ;
INFO_message("Filter #%d = detrend:%d",nffunc,polort) ;
} else if( strcasecmp(argv[nopt],"despike") == 0 ){
ADD_FILTER(DES_despike25) ;
INFO_message("Filter #%d = despike",nffunc) ;
} else {
ERROR_exit("Unkown filter type '%s'",argv[nopt]) ;
}
nopt++ ; continue ;
}
ERROR_exit("Unknown option: '%s'",argv[nopt]) ;
}
if( nffunc == 0 ) ERROR_exit("No -filter options given !? :(") ;
if( old_dset == NULL ){
if( nopt >= argc ) ERROR_exit("no input dataset?") ;
old_dset = THD_open_dataset(argv[nopt]) ;
CHECK_OPEN_ERROR(old_dset,argv[nopt]) ;
}
nvals = DSET_NVALS(old_dset) ;
if( nvals < 2 ) ERROR_exit("Input dataset too short to filter!") ;
if( hh > 0 ) setup_adaptive_filter( hh , nvals ) ;
INFO_message("Load input dataset") ;
DSET_load(old_dset) ; CHECK_LOAD_ERROR(old_dset) ;
/** do the work **/
INFO_message("Start processing") ;
new_dset = MAKER_4D_to_typed_fbuc(
old_dset , /* input dataset */
prefix , /* output prefix */
MRI_float , /* output datum */
0 , /* ignore count */
0 , /* don't detrend */
nvals , /* number of briks */
FILTER_tsfunc , /* timeseries processor */
NULL, /* data for tsfunc */
NULL, /* mask */
0 /* Allow auto scaling of output */
) ;
DSET_unload(old_dset) ;
if( new_dset != NULL ){
tross_Copy_History( old_dset , new_dset ) ;
tross_Make_History( "3dTfilter" , argc,argv , new_dset ) ;
if( DSET_NUM_TIMES(old_dset) > 1 )
EDIT_dset_items( new_dset ,
ADN_ntt , DSET_NVALS(old_dset) ,
ADN_ttorg , DSET_TIMEORIGIN(old_dset) ,
ADN_ttdel , DSET_TR(old_dset) ,
ADN_tunits , UNITS_SEC_TYPE ,
NULL ) ;
DSET_write( new_dset ) ; WROTE_DSET( new_dset ) ;
} else {
ERROR_exit("Unable to compute output dataset!\n") ;
}
exit(0) ;
}
int
main (int argc, char *argv[])
{
THD_3dim_dataset *old_dset, *new_dset, *I0_dset; /* input and output datasets */
int nopt, nbriks, nvox;
int i;
MRI_IMAGE *grad1Dptr = NULL;
MRI_IMAGE *anat_im = NULL;
MRI_IMAGE *data_im = NULL;
double fac;
short *sar = NULL, *tempsptr = NULL, tempval;
byte *maskptr = NULL, *tempbptr = NULL;
char tempstr[25];
/*----- Read command line -----*/
if (argc < 2 || strcmp (argv[1], "-help") == 0)
{
printf ("Usage: 3dDTtoDWI [options] gradient-file I0-dataset DT-dataset\n"
"Computes multiple gradient images from 6 principle direction tensors and\n"
" corresponding gradient vector coordinates applied to the I0-dataset.\n"
" The program takes three parameters as input : \n"
" a 1D file of the gradient vectors with lines of ASCII floats Gxi,Gyi,Gzi.\n"
" Only the non-zero gradient vectors are included in this file (no G0 line).\n"
" The I0 dataset is a volume without any gradient applied.\n"
" The DT dataset is the 6-sub-brick dataset containing the diffusion tensor data,\n"
" Dxx, Dxy, Dyy, Dxz, Dyz, Dzz (lower triangular row-wise order)\n"
" Options:\n"
" -prefix pname = Use 'pname' for the output dataset prefix name.\n"
" [default='DWI']\n"
" -automask = mask dataset so that the gradient images are computed only for\n"
" high-intensity (presumably brain) voxels. The intensity level is\n"
" determined the same way that 3dClipLevel works.\n\n"
" -datum type = output dataset type [float/short/byte] (default is float).\n"
" -help = show this help screen.\n"
" Example:\n"
" 3dDTtoDWI -prefix DWI -automask tensor25.1D 'DT+orig[26]' DT+orig.\n\n"
" The output is a n sub-brick bucket dataset containing computed DWI images.\n"
" where n is the number of vectors in the gradient file + 1\n"
"\n");
printf ("\n" MASTER_SHORTHELP_STRING);
exit (0);
}
mainENTRY ("3dDTtoDWI main");
machdep ();
AFNI_logger ("3dDTtoDWI", argc, argv);
PRINT_VERSION("3dDTtoDWI") ;
nopt = 1;
datum = MRI_float;
while (nopt < argc && argv[nopt][0] == '-')
{
/*-- prefix --*/
if (strcmp (argv[nopt], "-prefix") == 0)
{
if (++nopt >= argc)
{
fprintf (stderr, "*** Error - prefix needs an argument!\n");
exit (1);
}
MCW_strncpy (prefix, argv[nopt], THD_MAX_PREFIX); /* change name from default prefix */
/* check file name to be sure not to overwrite - mod drg 12/9/2004 */
if (!THD_filename_ok (prefix))
{
fprintf (stderr, "*** Error - %s is not a valid prefix!\n", prefix);
exit (1);
}
nopt++;
continue;
}
/*-- datum --*/
if (strcmp (argv[nopt], "-datum") == 0)
{
if (++nopt >= argc)
{
fprintf (stderr, "*** Error - datum needs an argument!\n");
exit (1);
}
if (strcmp (argv[nopt], "short") == 0)
{
datum = MRI_short;
}
else if (strcmp (argv[nopt], "float") == 0)
{
datum = MRI_float;
}
else if (strcmp (argv[nopt], "byte") == 0)
{
datum = MRI_byte;
}
else
{
fprintf (stderr, "-datum of type '%s' is not supported!\n",
argv[nopt]);
exit (1);
}
nopt++;
continue;
}
if (strcmp (argv[nopt], "-automask") == 0)
{
automask = 1;
nopt++;
continue;
}
fprintf(stderr, "*** Error - unknown option %s\n", argv[nopt]);
exit(1);
}
/*----- read input datasets -----*/
if (nopt >= argc)
{
fprintf (stderr, "*** Error - No input dataset!?\n");
exit (1);
}
/* first input dataset - should be gradient vector file of ascii floats Gx,Gy,Gz */
/* read gradient vector 1D file */
grad1Dptr = mri_read_1D (argv[nopt]);
if (grad1Dptr == NULL)
{
fprintf (stderr, "*** Error reading gradient vector file\n");
exit (1);
}
if (grad1Dptr->ny != 3)
{
fprintf (stderr, "*** Error - Only 3 columns of gradient vectors allowed\n");
fprintf (stderr, "%d columns found\n", grad1Dptr->nx);
mri_free (grad1Dptr);
exit (1);
}
if (grad1Dptr->nx < 6)
{
fprintf (stderr, "*** Error - Must have at least 6 gradient vectors\n");
fprintf (stderr, "%d columns found\n", grad1Dptr->nx);
mri_free (grad1Dptr);
exit (1);
}
nbriks = grad1Dptr->nx + 1; /* number of gradients specified here from file */
nopt++;
/* open I0 dataset - idealized no gradient image */
I0_dset = THD_open_dataset (argv[nopt]);
CHECK_OPEN_ERROR(I0_dset,argv[nopt]) ;
DSET_mallocize (I0_dset);
DSET_load (I0_dset); /* load dataset */
data_im = DSET_BRICK (I0_dset, 0); /* set pointer to the 0th sub-brik of the dataset */
fac = DSET_BRICK_FACTOR(I0_dset, 0); /* get scale factor for each sub-brik*/
if(fac==0.0) fac=1.0;
if((data_im->kind != MRI_float)) {
fprintf (stderr, "*** Error - Can only open float datasets. Use 3dcalc to convert.\n");
mri_free (grad1Dptr);
mri_free (data_im);
exit (1);
}
I0_ptr = mri_data_pointer(data_im) ; /* pointer to I0 data */
nopt++;
/* Now read in all the MRI volumes for each gradient vector */
/* assumes first one is no gradient */
old_dset = THD_open_dataset (argv[nopt]);
CHECK_OPEN_ERROR(old_dset,argv[nopt]) ;
/* expect at least 6 values per voxel - 6 sub-briks as input dataset */
if (DSET_NVALS (old_dset) <6)
{
fprintf (stderr,
"*** Error - Dataset must have at least 6 sub-briks to describe the diffusion tensor\n");
mri_free (grad1Dptr);
mri_free (data_im);
exit (1);
}
InitGlobals (grad1Dptr->nx + 1); /* initialize all the matrices and vectors */
Computebmatrix (grad1Dptr, BMAT_NZ); /* compute bij=GiGj */
INFO_message("The maximum magnitude of the bmatrix appears to be: %.2f", MAX_BVAL);
if (automask)
{
DSET_mallocize (old_dset);
DSET_load (old_dset); /* get B0 (anatomical image) from dataset */
/*anat_im = THD_extract_float_brick( 0, old_dset ); */
anat_im = DSET_BRICK (old_dset, 0); /* set pointer to the 0th sub-brik of the dataset */
maskptr = mri_automask_image (anat_im); /* maskptr is a byte pointer for volume */
/* convert byte mask to same format type as dataset */
nvox = DSET_NVOX (old_dset);
sar = (short *) calloc (nvox, sizeof (short));
/* copy maskptr values to far ptr */
tempsptr = sar;
tempbptr = maskptr;
for (i = 0; i < nvox; i++)
{
*tempsptr++ = (short) *tempbptr++;
tempval = *(tempsptr - 1);
}
free (maskptr);
/*old_dset->dblk->malloc_type = DATABLOCK_MEM_MALLOC; *//* had to set this? */
EDIT_add_brick (old_dset, MRI_short, 0.0, sar); /* add sub-brik to end */
}
/* temporarily set artificial timing to 1 second interval */
EDIT_dset_items (old_dset,
ADN_ntt, DSET_NVALS (old_dset),
ADN_ttorg, 0.0,
ADN_ttdel, 1.0, ADN_tunits, UNITS_SEC_TYPE, NULL);
/*------------- ready to compute new dataset -----------*/
new_dset = MAKER_4D_to_typed_fbuc (old_dset, /* input dataset */
prefix, /* output prefix */
datum, /* output datum */
0, /* ignore count */
0, /* can't detrend in maker function KRH 12/02 */
nbriks, /* number of briks */
DTtoDWI_tsfunc, /* timeseries processor */
NULL, /* data for tsfunc */
NULL, /* mask */
0 /* Allow auto scaling of output */
);
FreeGlobals ();
mri_free (grad1Dptr);
if (automask)
{
mri_free (anat_im);
DSET_unload_one (old_dset, 0);
sar = NULL;
}
if (new_dset != NULL)
{
tross_Copy_History (old_dset, new_dset);
for(i=0;i<nbriks;i++) {
sprintf(tempstr,"grad%3.3d", i);
EDIT_dset_items (new_dset, ADN_brick_label_one + i, tempstr, ADN_none);
}
tross_Make_History ("3dDTtoDWI", argc, argv, new_dset);
DSET_write (new_dset);
fprintf(stderr,"--- Output dataset %s\n", DSET_BRIKNAME(new_dset));
}
else
{
fprintf (stderr, "*** Error - Unable to compute output dataset!\n");
exit (1);
}
exit (0);
}
static char * DELAY_main( PLUGIN_interface * plint )
{
hilbert_data_V2 uda,*ud;
MRI_IMAGE * tsim;
MCW_idcode * idc ; /* input dataset idcode */
THD_3dim_dataset * old_dset , * new_dset ; /* input and output datasets */
char *tmpstr , * str , *nprfxstr; /* strings from user */
int ntime, nvec ,nprfx, i;
float * vec , fs , T ;
/* Allocate as much character space as Bob specifies in afni.h + a bit more */
tmpstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char));
nprfxstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char));
if (tmpstr == NULL || nprfxstr == NULL)
return "********************\n"
"Could not Allocate\n"
"a teeni weeni bit of\n"
"Memory ! \n"
"********************\n";
ud = &uda; /* ud now points to an allocated space */
ud->errcode = 0; /*reset error flag */
/*--------------------------------------------------------------------*/
/*----- Check inputs from AFNI to see if they are reasonable-ish -----*/
/*--------- go to first input line ---------*/
PLUTO_next_option(plint) ;
idc = PLUTO_get_idcode(plint) ; /* get dataset item */
old_dset = PLUTO_find_dset(idc) ; /* get ptr to dataset */
if( old_dset == NULL )
return "*************************\n"
"Cannot find Input Dataset\n"
"*************************" ;
ud->dsetname = DSET_FILECODE (old_dset);
ud->nsamp = DSET_NUM_TIMES (old_dset);
ud->Navg = 1 ; /* Navg does not play a role for the p value, averaging increases sensitivity */
ud->Nort = PLUTO_get_number(plint) ; /* Should be two by default, for mean and linear trend */
ud->Nfit = 2 ; /* Always 2 for phase and amplitude for this plugin */
/*--------- go to 2nd input line, input time series ---------*/
PLUTO_next_option(plint) ;
tsim = PLUTO_get_timeseries(plint);
if (tsim == NULL) return "No Timeseries Input";
ud->ln = (int)tsim -> nx; /* number of points in each vector */
nvec = tsim -> ny; /* number of vectors */
ud->rvec = (float *) MRI_FLOAT_PTR(tsim); /* vec[i+j*nx] = ith point of jth vector */
/* for i=0 .. ntime-1 and j=0 .. nvec-1 */
if (is_vect_null (ud->rvec,ud->ln) == 1) /* check if ref vect is all zeroes */
{
return "Reference vector is all zeros";
}
ud->refname = tsim->name;
ud->ignore = PLUTO_get_number(plint) ; /* get number item */
str = PLUTO_get_string(plint) ;
ud->Dsamp = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ) ;
/*--------- go to 3rd input line, sampling frequency, and stimulus period ---------*/
PLUTO_next_option(plint) ;
ud->fs = PLUTO_get_number(plint) ; /* get number item */
ud->T = PLUTO_get_number(plint) ; /* get number item */
ud->co = PLUTO_get_number(plint) ; /* get number item */
str = PLUTO_get_string(plint) ;
ud->biasrem = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ) ;
/*--------- go to 4th input line, delay units and wrp option---------*/
PLUTO_next_option(plint) ;
ud->Nseg = (int)PLUTO_get_number(plint) ; /* get number item */
ud->Pover = (int)PLUTO_get_number(plint) ; /* get number item */
str = PLUTO_get_string(plint) ; /* get string item (the method) */
ud->unt = (int)PLUTO_string_index( str , /* find it in list it is from */
NUM_METHOD_STRINGS ,
method_strings ) ;
str = PLUTO_get_string(plint) ;
ud->wrp = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ) ;
/*--------- go to 5th input line Output prefix ---------*/
PLUTO_next_option(plint) ;
ud->new_prefix = PLUTO_get_string(plint) ; /* get string item (the output prefix) */
/* check to see if the field is empty */
if (ud->new_prefix == NULL)
nprfx = 0;
else
nprfx = 1;
/* check if the size is larger than 0. I did not want to check for this unless it's allocated */
if (nprfx == 1 && (int)strlen (ud->new_prefix) == 0)
nprfx = 0;
if (nprfx == 0) /* now create the new name and make new_prefix point to it */
{
sprintf (nprfxstr,"%s.DEL",DSET_PREFIX (old_dset));
ud->new_prefix = nprfxstr;
/*printf ("New prefix is set to be : %s\n\a",ud->new_prefix);*/
}
if( ! PLUTO_prefix_ok(ud->new_prefix) ) /* check if it is OK */
return "************************\n"
"Output Prefix is illegal\n"
"************************" ;
str = PLUTO_get_string(plint) ; /* write delays to file ? */
ud->out = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings );
ud->strout = PLUTO_get_string(plint) ; /* strout is for the outiflename, which will be used after the debugging section */
if (ud->strout == NULL) /* if no output name is given, use the new_prefix */
{ud->strout = ud->new_prefix;}
else
{
if((int)strlen (ud->strout) == 0) ud->strout = ud->new_prefix;
}
str = PLUTO_get_string(plint) ;
ud->outts = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings );
/* ------------------Done with user parameters ---------------------------- */
ud->nxx = (int)old_dset->daxes->nxx; /* get data set dimensions */
ud->nyy = (int)old_dset->daxes->nyy;
ud->nzz = (int)old_dset->daxes->nzz;
/* No need for users to set these options ...*/
ud->dtrnd = 0;
if (ud->ln != (ud->nsamp - ud->ignore))
{
ud->errcode = ERROR_BADLENGTH;
return "***************************\n"
"Bad time series length \n"
"Check reference time series\n"
" or the ignore parameter \n"
"***************************\n";
}
if ((ud->unt < 0) || (ud->unt > 2)) /* unt error Check */
{
ud->errcode = ERROR_WRONGUNIT;
return "***********************\n"
" internal error: (ziad)\n"
"unt values out of bound\n"
"***********************\n"; /*unt must be between 0 and 2 */
}
if ((ud->wrp < 0) || (ud->wrp > 1)) /* wrp error Check */
{
ud->errcode = ERROR_WARPVALUES;
return "***********************\n"
" internal error: (ziad)\n"
"wrp values out of bound\n"
"***********************\n"; /* wrp must be between 0 and 1*/
}
if (ud->fs < 0.0) { /* fs error Check */
ud->errcode = ERROR_FSVALUES;
return "***********************\n"
" internal error: (ziad)\n"
"fs value is negative !\n"
"***********************\n"; /* fs must be >= 0*/
}
if (ud->T < 0.0) { /* T error Check */
ud->errcode = ERROR_TVALUES;
return "***********************\n"
" internal error: (ziad)\n"
"T value is negative !\n"
"***********************\n"; /*T must be >= 0 */
}
if ((ud->T == 0.0) && (ud->unt > 0)) /* unt error Check */
{
ud->errcode = ERROR_TaUNITVALUES;
return "***********************\n"
" internal error: (ziad)\n"
"T and unt val. mismatch\n"
"***********************\n"; /*T must be specified, and > 0 in order to use polar units*/
}
if ((ud->wrp == 1) && (ud->T == 0.0)) /* wrp error Check */
{
ud->errcode = ERROR_TaWRAPVALUES;
return "***********************\n"
" internal error: (ziad)\n"
"wrp and T val. mismatch\n"
"***********************\n"; /*T must be specified, and > 0 in order to use polar warp*/
}
if ((ud->out == NOPE) && (ud->outts == YUP))
{
ud->errcode = ERROR_OUTCONFLICT;
return"***********************\n"
"error: \n"
"Write flag must be on\n"
"to use Write ts\n"
"***********************\n";
}
/* Open the logfile, regardless of the ascii output files */
sprintf ( tmpstr , "%s.log" , ud->strout);
ud->outlogfile = fopen (tmpstr,"w");
if (ud->out == YUP) /* open outfile */
{
ud->outwrite = fopen (ud->strout,"w");
if (ud->outts == YUP)
{
sprintf ( tmpstr , "%s.ts" , ud->strout);
ud->outwritets = fopen (tmpstr,"w");
}
if ((ud->outwrite == NULL) || (ud->outlogfile == NULL) ||\
(ud->outwritets == NULL && ud->outts == YUP) )
{
ud->errcode = ERROR_FILEOPEN;
return "***********************\n"
"Could Not Write Outfile\n"
"***********************\n";
}
}
/* Write out user variables to Logfile */
write_ud (ud); /* writes user data to a file */
/*show_ud (ud,0); */ /* For some debugging */
/*------------- ready to compute new dataset -----------*/
new_dset = MAKER_4D_to_typed_fbuc ( old_dset , /* input dataset */
ud->new_prefix , /* output prefix */
-1, /* negative value indicating data type is like original brick */
ud->ignore , /* ignore count */
1 , /* detrend = ON Let BOB do it*/
NBUCKETS, /*Number of values at each voxel*/
DELAY_tsfuncV2 , /* timeseries processor (bucket version)*/
(void *)ud, /* data for tsfunc */
NULL, 0 ) ;
/* Setup the label, keywords and types of subbricks */
i = 0;
while (i < NBUCKETS)
{
switch (i)
{
case DELINDX: /* delay value in results vector */
EDIT_BRICK_LABEL (new_dset,i,"Delay");
EDIT_BRICK_ADDKEY (new_dset,i,"D");
++i;
break;
case COVINDX: /* covariance value in results vector */
EDIT_BRICK_LABEL (new_dset,i,"Covariance");
EDIT_BRICK_ADDKEY (new_dset,i,"I");
++i;
break;
case COFINDX: /* cross correlation coefficient value in results vector */
EDIT_BRICK_LABEL (new_dset,i,"Corr. Coef.");
EDIT_BRICK_ADDKEY (new_dset,i,"r");
/* Here you must modify either ud->Nfit or ud->Nort or most likely ud->nsamp based on ud->Navg */
EDIT_BRICK_TO_FICO (new_dset,i,ud->nsamp - ud->ignore,ud->Nfit,ud->Nort);
++i;
break;
case VARINDX: /* FMRI time course variance value in results vector */
EDIT_BRICK_LABEL (new_dset,i,"Variance");
EDIT_BRICK_ADDKEY (new_dset,i,"S2");
++i;
break;
default :
return "*********************\n"
"Internal Error (ziad)\n"
" Bad i value \n"
"*********************\n";
break;
}
}
if (!AFNI_noenv("AFNI_AUTOMATIC_FDR")) {
THD_create_all_fdrcurves( new_dset );
}
PLUTO_add_dset( plint , new_dset , DSET_ACTION_MAKE_CURRENT ) ;
if (ud->out == YUP) /* close outfile and outlogfile*/
{
fclose (ud->outlogfile);
fclose (ud->outwrite);
if (ud->outts == YUP) fclose (ud->outwritets);
}
else
{
if (ud->outlogfile != NULL) fclose (ud->outlogfile); /* close outlogfile */
}
free (tmpstr);
free (nprfxstr);
return NULL ; /* null string returned means all was OK */
}
