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 ; /* 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) ;
}
int main(int argc, char *argv[]) {
int i,j,k,l,m,n,mm,ii;
int idx;
int iarg;
THD_3dim_dataset *insetTIME = NULL;
// THD_3dim_dataset *inset0 = NULL;
THD_3dim_dataset *MASK=NULL;
char *prefix="REHO" ;
char in_name[300];
char in_mask[300];
THD_3dim_dataset *outset=NULL;
char outname[300];
int NIFTI_OUT=0;
int DTYPE=0;
int HAVE_MASK = 0;
int ***mskd; // define mask of where time series are nonzero
double temp_sum;
// FILE *fout0, *fout1;
int Nvox=-1; // tot number vox
int Dim[4]={0,0,0,0};
float fbot = -1., ftop = -1;
float delF = -1;
float *allF=NULL;
float **allPar=NULL;
int Npar=NRSFC; // currently... see list below
char *namePar[NRSFC]={"ALFF", "MALFF", "FALFF",
"RSFA", "MRSFA", "FRSFA"};
int MIN_full=0, MAX_full=-1; // indices of full spect
int MIN_bp=0, MAX_bp = -1; // indices of lff/bp region
mainENTRY("3dAmpToRSFC"); machdep();
// ****************************************************************
// ****************************************************************
// load AFNI stuff
// ****************************************************************
// ****************************************************************
// INFO_message("version: NU");
/** scan args **/
if (argc == 1) { usage_AmpToRSFC(1); exit(0); }
iarg = 1;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-help") == 0 ||
strcmp(argv[iarg],"-h") == 0 ) {
usage_AmpToRSFC(strlen(argv[iarg])>3 ? 2:1);
exit(0);
}
if( strncmp(argv[iarg],"-band",5) == 0 ){
if( ++iarg >= argc-1 ) ERROR_exit("need 2 arguments after -band!") ;
fbot = strtod(argv[iarg++],NULL) ;
ftop = strtod(argv[iarg++],NULL) ;
continue ;
}
if( strcmp(argv[iarg],"-mask") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-mask'");
HAVE_MASK=1;
sprintf(in_mask,"%s", argv[iarg]);
MASK = THD_open_dataset(in_mask) ;
if( (MASK == NULL ))
ERROR_exit("Can't open time series dataset '%s'.",in_mask);
DSET_load(MASK); CHECK_LOAD_ERROR(MASK);
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-prefix") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-prefix'");
prefix = strdup(argv[iarg]) ;
if( !THD_filename_ok(prefix) )
ERROR_exit("Illegal name after '-prefix'");
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_amp") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-in_amp'");
sprintf(in_name,"%s", argv[iarg]);
DTYPE = 1; // for amps
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_pow") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-in_pow'");
sprintf(in_name,"%s", argv[iarg]);
DTYPE = 2; // for pow
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mask") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-mask'");
HAVE_MASK=1;
sprintf(in_mask,"%s", argv[iarg]);
MASK = THD_open_dataset(in_mask) ;
if( (MASK == NULL ))
ERROR_exit("Can't open time series dataset '%s'.",in_mask);
DSET_load(MASK); CHECK_LOAD_ERROR(MASK);
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-nifti") == 0) {
NIFTI_OUT=1;
iarg++ ; continue ;
}
ERROR_message("Bad option '%s'\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
// ---------------------------------------------------------------
// TEST BASIC INPUT PROPERTIES
if (iarg < 3) {
ERROR_message("Too few options. Try -help for details.\n");
exit(1);
}
if( !DTYPE ) {
ERROR_message("Think somebody forgot to specify an input file"
" using '-in_amp ...' or '-in_pow ...'.");
exit(12);
}
else{
insetTIME = THD_open_dataset(in_name) ;
if( (insetTIME == NULL ))
ERROR_exit("Can't open time series dataset '%s'.",in_name);
DSET_load(insetTIME); CHECK_LOAD_ERROR(insetTIME);
Nvox = DSET_NVOX(insetTIME) ;
Dim[0] = DSET_NX(insetTIME); Dim[1] = DSET_NY(insetTIME);
Dim[2] = DSET_NZ(insetTIME); Dim[3]= DSET_NVALS(insetTIME);
delF = DSET_TR(insetTIME);
}
if( (fbot<0) || (ftop<0) ) {
ERROR_message("Think somebody forgot to specify upper and lower"
" frequency bounds using '-band ... ...'.");
exit(11);
}
if( fbot > ftop )
ERROR_exit("Can't have ftop < fbot! Try entering frequency"
"band limits again");
if( MASK )
if ( Dim[0] != DSET_NX(MASK) || Dim[1] != DSET_NY(MASK) ||
Dim[2] != DSET_NZ(MASK) ) {
ERROR_message("Mask and inset don't appear to have the same "
"dimensions.\n");
exit(1);
}
// ****************************************************************
// ****************************************************************
// pre-stuff, make storage
// ****************************************************************
// ****************************************************************
// array of freqs-- starts at delta F, not zero, as the current
// input data sets must!
allF = (float *)calloc(Dim[3], sizeof(float));
// will be the output
allPar = calloc(Npar,sizeof(allPar));
for(i=0 ; i<Npar ; i++)
allPar[i] = calloc(Nvox,sizeof(float));
// MASK
mskd = (int ***) calloc( Dim[0], sizeof(int **) );
for ( i = 0 ; i < Dim[0] ; i++ )
mskd[i] = (int **) calloc( Dim[1], sizeof(int *) );
for ( i = 0 ; i < Dim[0] ; i++ )
for ( j = 0 ; j < Dim[1] ; j++ )
mskd[i][j] = (int *) calloc( Dim[2], sizeof(int) );
if( (mskd == NULL) || (allF == NULL) || (allPar == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure (mask).\n\n");
exit(33);
}
// *************************************************************
// *************************************************************
// Beginning of main loops
// *************************************************************
// *************************************************************
// Populate freq bands. For now, delF is constant. Later.... who
// knows, so make flexible
allF[0] = DSET_TIMEORIGIN(insetTIME);
if( allF[0] < EPS_V )
ERROR_exit("The t-axis (here, frequency) origin is 0!"
"\n\t-> but you shouldn't have a baseline 0-frequency!");
for( i=1 ; i<Dim[3] ; i++ )
allF[i] = allF[i-1] + delF;
// fill in rest of freq ranges; MIN_full=0 already
MAX_full = Dim[3]-1;
// these should be in order, so we can pass through like this.
for( i=0 ; i<Dim[3] ; i++ ) {
ii = Dim[3] - 1 - i;
if( allF[ii] >= fbot )
MIN_bp = ii;
if( allF[i] <= ftop )
MAX_bp = i;
}
if(MAX_bp < MIN_bp) // shouldn't happen...
ERROR_exit("Something went horribly wrong with reading in the "
"bandpass limits! bot:%f, top:%f",MIN_bp, MAX_bp);
INFO_message("Actual BP range: indices [%d, %d] -> "
"freqs [%.4f, %.4f]", MIN_bp, MAX_bp,
allF[MIN_bp], allF[MAX_bp]);
INFO_message("Full freq range: indices [%d, %d] -> "
"freqs [%.4f, %.4f]", MIN_full, MAX_full,
allF[MIN_full], allF[MAX_full]);
// go through once: define data vox
idx = 0;
for( k=0 ; k<Dim[2] ; k++ )
for( j=0 ; j<Dim[1] ; j++ )
for( i=0 ; i<Dim[0] ; i++ ) {
if( HAVE_MASK ) {
if( THD_get_voxel(MASK,idx,0)>0 )
mskd[i][j][k] = 1;
}
else {
temp_sum = 0.;
for ( l=0 ; l<Dim[3] ; l++ )
temp_sum+= abs(THD_get_voxel(insetTIME,idx,l));
if ( temp_sum > EPS_V )
mskd[i][j][k] = 1;
}
idx++;
}
INFO_message("Done masking.");
Spect_to_RSFC( insetTIME,
DTYPE,
Dim,
mskd,
MIN_bp, MAX_bp,
MIN_full, MAX_full,
allPar,
Npar
);
INFO_message("Done calculating parameters.");
// **************************************************************
// **************************************************************
// Store and output
// **************************************************************
// **************************************************************
for( m=0; m<Npar ; m++) {
outset = EDIT_empty_copy(insetTIME) ;
if(NIFTI_OUT)
sprintf(outname,"%s_%s.nii.gz",prefix, namePar[m]);
else
sprintf(outname,"%s_%s",prefix, namePar[m]);
INFO_message(" writing: %s %s", prefix, outname);
EDIT_dset_items( outset,
ADN_nvals , 1 ,
ADN_datum_all , MRI_float ,
ADN_prefix , outname ,
ADN_none ) ;
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outset)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outset));
EDIT_substitute_brick(outset, 0, MRI_float, allPar[m]);
allPar[m]=NULL;
THD_load_statistics(outset);
tross_Make_History("3dAmpToRSFC", argc, argv, outset);
THD_write_3dim_dataset(NULL, NULL, outset, True);
if(outset) {
DSET_delete(outset);
free(outset);
}
}
// ************************************************************
// ************************************************************
// Freeing
// ************************************************************
// ************************************************************
if(allF)
free(allF);
if(MASK) {
DSET_delete(MASK);
free(MASK);
}
if(insetTIME) {
DSET_delete(insetTIME);
free(insetTIME);
}
if(mskd) {
for( i=0 ; i<Dim[0] ; i++)
for( j=0 ; j<Dim[1] ; j++)
free(mskd[i][j]);
for( i=0 ; i<Dim[0] ; i++)
free(mskd[i]);
free(mskd);
}
if(allPar) { // have freed other parts of this above
free(allPar);
}
return 0;
}
