static FILE * fopen_maybe( char *fname ) /* 05 Feb 2008 */
{
FILE *imfile ;
char *tname = NULL;
int tlen;
if( fname == NULL || *fname == '\0' ) return NULL ; /* bad input */
/* special case -- be sure not to fclose() stdout! */
/* ------------------------------------------------------------- */
/* test file streams with tname, where any .1D has been stripped */
/* note: the .1D suffix might come from EDIT_dset_items() */
/* problem noted by I Schwabacher 13 Nov 2012 [rickr] */
tlen = strlen(fname);
if( tlen > 3 && !strcmp(fname+tlen-3, ".1D") ) {
tname = strdup(fname);
tname[tlen-3] = '\0';
} else tname = fname;
if( strcmp(tname,"-") == 0 || strcmp(tname,"stdout") == 0
|| strcmp(tname,"stdout:") == 0 ) return stdout ;
if( strcmp(tname,"stderr" ) == 0 ||
strcmp(tname,"stderr:") == 0 ) return stderr ;
if( tname != fname ) free(tname); /* done with tname */
/* ------------------------------------------------------------- */
if( THD_is_ondisk(fname) ){ /* check for existing file */
if( !THD_ok_overwrite() ){ /* if not allowed to overwrite */
ERROR_message("(FAILED) attempt to over-write file %s",fname) ;
return NULL ;
} else {
WARNING_message("over-writing file %s",fname) ; /* tell the user */
}
}
imfile = fopen(fname,"w") ;
if( imfile == NULL ) ERROR_message("Can't open for output: %s",fname) ;
return imfile ;
}
int view_text_file(char *progname)
{
char *viewer=NULL, cmd[256];
if (!progname) {
ERROR_message("No input!");
return(0);
}
if (!THD_is_ondisk(progname)) {
ERROR_message("file %s not on disk.\n", progname);
return(0);
}
if (!(viewer = GetAfniTextEditor())) {
ERROR_message("No GUI editor defined, and guessing game failed.\n"
"Set AFNI_GUI_EDITOR in your .afnirc for this option to work.\n");
return(0);
}
/* open help file in editor*/
snprintf(cmd,250*sizeof(char),"%s %s &", viewer, progname);
system(cmd);
return(1);
}
int WB_netw_corr(int Do_r,
int Do_Z,
int HAVE_ROIS,
char *prefix,
int NIFTI_OUT,
int *NROI_REF,
int *Dim,
double ***ROI_AVE_TS,
int **ROI_LABELS_REF,
THD_3dim_dataset *insetTIME,
byte *mskd2,
int Nmask,
int argc,
char *argv[])
{
int i,j,k;
float **AVE_TS_fl=NULL; // not great, but another format of TS
char OUT_indiv0[300];
char OUT_indiv[300];
char OUT_indivZ[300];
MRI_IMAGE *mri=NULL;
THD_3dim_dataset *OUT_CORR_MAP=NULL;
THD_3dim_dataset *OUT_Z_MAP=NULL;
float *zscores=NULL;
int Nvox;
Nvox = Dim[0]*Dim[1]*Dim[2];
// make average time series per voxel
AVE_TS_fl = calloc( 1,sizeof(AVE_TS_fl));
for(i=0 ; i<1 ; i++)
AVE_TS_fl[i] = calloc(Dim[3],sizeof(float));
if( (AVE_TS_fl == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure (time series out).\n\n");
exit(123);
}
fprintf(stderr,"\nHAVE_ROIS=%d",HAVE_ROIS);
for( k=0 ; k<HAVE_ROIS ; k++) { // each netw gets own file
sprintf(OUT_indiv0,"%s_%03d_INDIV", prefix, k);
mkdir(OUT_indiv0, 0777);
for( i=0 ; i<NROI_REF[k] ; i++ ) {
fprintf(stderr,"\nNROI_REF[%d]= %d",k,NROI_REF[k]);
for( j=0 ; j<Dim[3] ; j++)
AVE_TS_fl[0][j] = (float) ROI_AVE_TS[k][i][j];
if( NIFTI_OUT )
sprintf(OUT_indiv,"%s/WB_CORR_ROI_%03d.nii.gz",
OUT_indiv0,ROI_LABELS_REF[k][i+1]);
else
sprintf(OUT_indiv,"%s/WB_CORR_ROI_%03d",
OUT_indiv0,ROI_LABELS_REF[k][i+1]);
mri = mri_float_arrays_to_image(AVE_TS_fl,Dim[3],1);
OUT_CORR_MAP = THD_Tcorr1D(insetTIME, mskd2, Nmask,
mri,
"pearson", OUT_indiv);
if(Do_r){
THD_load_statistics(OUT_CORR_MAP);
tross_Copy_History( insetTIME , OUT_CORR_MAP ) ;
tross_Make_History( "3dNetcorr", argc, argv, OUT_CORR_MAP );
if( !THD_ok_overwrite() &&
THD_is_ondisk(DSET_HEADNAME(OUT_CORR_MAP)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(OUT_CORR_MAP));
THD_write_3dim_dataset(NULL, NULL, OUT_CORR_MAP, True);
INFO_message("Wrote dataset: %s\n",DSET_BRIKNAME(OUT_CORR_MAP));
}
if(Do_Z){
if( NIFTI_OUT )
sprintf(OUT_indivZ,"%s/WB_Z_ROI_%03d.nii.gz",
OUT_indiv0,ROI_LABELS_REF[k][i+1]);
else
sprintf(OUT_indivZ,"%s/WB_Z_ROI_%03d",
OUT_indiv0,ROI_LABELS_REF[k][i+1]);
OUT_Z_MAP = EDIT_empty_copy(OUT_CORR_MAP);
EDIT_dset_items( OUT_Z_MAP,
ADN_nvals, 1,
ADN_datum_all , MRI_float ,
ADN_prefix , OUT_indivZ,
ADN_none ) ;
if( !THD_ok_overwrite() &&
THD_is_ondisk(DSET_HEADNAME(OUT_Z_MAP)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(OUT_Z_MAP));
zscores = (float *)calloc(Nvox,sizeof(float));
if( (zscores == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure (zscores).\n\n");
exit(123);
}
for( j=0 ; j<Nvox ; j++ )
if( mskd2[j] ) // control for r ==1
BOBatanhf( THD_get_voxel(OUT_CORR_MAP, j, 0) );
/*
if( THD_get_voxel(OUT_CORR_MAP, j, 0) > MAX_R )
zscores[j] = (float) atanh(MAX_R);
else if ( THD_get_voxel(OUT_CORR_MAP, j, 0) < -MAX_R )
zscores[j] = (float) atanh(-MAX_R);
else
zscores[j] = (float) atanh(THD_get_voxel(OUT_CORR_MAP, j, 0));*/
EDIT_substitute_brick(OUT_Z_MAP, 0, MRI_float, zscores);
zscores=NULL;
THD_load_statistics(OUT_Z_MAP);
tross_Copy_History(insetTIME, OUT_Z_MAP);
tross_Make_History("3dNetcorr", argc, argv, OUT_Z_MAP);
THD_write_3dim_dataset(NULL, NULL, OUT_Z_MAP, True);
INFO_message("Wrote dataset: %s\n",DSET_BRIKNAME(OUT_Z_MAP));
DSET_delete(OUT_Z_MAP);
free(OUT_Z_MAP);
OUT_Z_MAP=NULL;
}
DSET_delete(OUT_CORR_MAP);
free(OUT_CORR_MAP);
OUT_CORR_MAP=NULL;
}
}
free(zscores);
mri_free(mri);
for( i=0 ; i<1 ; i++)
free(AVE_TS_fl[i]);
free(AVE_TS_fl);
RETURN(1);
}
int main( int argc , char * argv[] )
{
int do_norm=0 , qdet=2 , have_freq=0 , do_automask=0 ;
float dt=0.0f , fbot=0.0f,ftop=999999.9f , blur=0.0f ;
MRI_IMARR *ortar=NULL ; MRI_IMAGE *ortim=NULL ;
THD_3dim_dataset **ortset=NULL ; int nortset=0 ;
THD_3dim_dataset *inset=NULL , *outset=NULL;
char *prefix="RSFC" ;
byte *mask=NULL ;
int mask_nx=0,mask_ny=0,mask_nz=0,nmask , verb=1 ,
nx,ny,nz,nvox , nfft=0 , kk ;
float **vec , **ort=NULL ; int nort=0 , vv , nopt , ntime ;
MRI_vectim *mrv ;
float pvrad=0.0f ; int nosat=0 ;
int do_despike=0 ;
// @@ non-BP variables
float fbotALL=0.0f, ftopALL=999999.9f; // do full range version
int NumDen = 0; // switch for doing numerator or denom
THD_3dim_dataset *outsetALL=NULL ;
int m, mm;
float delf; // harmonics
int ind_low,ind_high,N_ny, ctr;
float sqnt,nt_fac;
gsl_fft_real_wavetable *real1, *real2; // GSL stuff
gsl_fft_real_workspace *work;
double *series1, *series2;
double *xx1,*xx2;
float numer,denom,val;
float *alff=NULL,*malff=NULL,*falff=NULL,
*rsfa=NULL,*mrsfa=NULL,*frsfa=NULL; // values
float meanALFF=0.0f,meanRSFA=0.0f; // will be for mean in brain region
THD_3dim_dataset *outsetALFF=NULL;
THD_3dim_dataset *outsetmALFF=NULL;
THD_3dim_dataset *outsetfALFF=NULL;
THD_3dim_dataset *outsetRSFA=NULL;
THD_3dim_dataset *outsetmRSFA=NULL;
THD_3dim_dataset *outsetfRSFA=NULL;
char out_lff[300];
char out_alff[300];
char out_malff[300];
char out_falff[300];
char out_rsfa[300];
char out_mrsfa[300];
char out_frsfa[300];
char out_unBP[300];
int SERIES_OUT = 1;
int UNBP_OUT = 0;
int DO_RSFA = 1;
int BP_LAST = 0; // option for only doing filter to LFFs at very end of proc
float de_rsfa=0.0f,nu_rsfa=0.0f;
double pow1=0.0,pow2=0.0;
/*-- help? --*/
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"\n Program to calculate common resting state functional connectivity (RSFC)\n"
" parameters (ALFF, mALFF, fALFF, RSFA, etc.) for resting state time\n"
" series. This program is **heavily** based on the existing\n"
" 3dBandPass by RW Cox, with the amendments to calculate RSFC\n"
" parameters written by PA Taylor (July, 2012).\n"
" This program is part of FATCAT (Taylor & Saad, 2013) in AFNI. Importantly,\n"
" its functionality can be included in the `afni_proc.py' processing-script \n"
" generator; see that program's help file for an example including RSFC\n"
" and spectral parameter calculation via the `-regress_RSFC' option.\n"
"\n"
"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n"
"\n"
" All options of 3dBandPass may be used here (with a couple other\n"
" parameter options, as well): essentially, the motivation of this\n"
" program is to produce ALFF, etc. values of the actual RSFC time\n"
" series that you calculate. Therefore, all the 3dBandPass processing\n"
" you normally do en route to making your final `resting state time\n"
" series' is done here to generate your LFFs, from which the\n"
" amplitudes in the LFF band are calculated at the end. In order to\n"
" calculate fALFF, the same initial time series are put through the\n"
" same processing steps which you have chosen but *without* the\n"
" bandpass part; the spectrum of this second time series is used to\n"
" calculate the fALFF denominator.\n"
" \n"
" For more information about each RSFC parameter, see, e.g.: \n"
" ALFF/mALFF -- Zang et al. (2007),\n"
" fALFF -- Zou et al. (2008),\n"
" RSFA -- Kannurpatti & Biswal (2008).\n"
"\n"
"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n"
"\n"
" + USAGE: 3dRSFC [options] fbot ftop dataset\n"
"\n"
"* One function of this program is to prepare datasets for input\n"
" to 3dSetupGroupInCorr. Other uses are left to your imagination.\n"
"\n"
"* 'dataset' is a 3D+time sequence of volumes\n"
" ++ This must be a single imaging run -- that is, no discontinuities\n"
" in time from 3dTcat-ing multiple datasets together.\n"
"\n"
"* fbot = lowest frequency in the passband, in Hz\n"
" ++ fbot can be 0 if you want to do a lowpass filter only;\n"
" HOWEVER, the mean and Nyquist freq are always removed.\n"
"\n"
"* ftop = highest frequency in the passband (must be > fbot)\n"
" ++ if ftop > Nyquist freq, then it's a highpass filter only.\n"
"\n"
"* Set fbot=0 and ftop=99999 to do an 'allpass' filter.\n"
" ++ Except for removal of the 0 and Nyquist frequencies, that is.\n"
"\n"
"* You cannot construct a 'notch' filter with this program!\n"
" ++ You could use 3dRSFC followed by 3dcalc to get the same effect.\n"
" ++ If you are understand what you are doing, that is.\n"
" ++ Of course, that is the AFNI way -- if you don't want to\n"
" understand what you are doing, use Some other PrograM, and\n"
" you can still get Fine StatisticaL maps.\n"
"\n"
"* 3dRSFC will fail if fbot and ftop are too close for comfort.\n"
" ++ Which means closer than one frequency grid step df,\n"
" where df = 1 / (nfft * dt) [of course]\n"
"\n"
"* The actual FFT length used will be printed, and may be larger\n"
" than the input time series length for the sake of efficiency.\n"
" ++ The program will use a power-of-2, possibly multiplied by\n"
" a power of 3 and/or 5 (up to and including the 3rd power of\n"
" each of these: 3, 9, 27, and 5, 25, 125).\n"
"\n"
"* Note that the results of combining 3dDetrend and 3dRSFC will\n"
" depend on the order in which you run these programs. That's why\n"
" 3dRSFC has the '-ort' and '-dsort' options, so that the\n"
" time series filtering can be done properly, in one place.\n"
"\n"
"* The output dataset is stored in float format.\n"
"\n"
"* The order of processing steps is the following (most are optional), and\n"
" for the LFFs, the bandpass is done between the specified fbot and ftop,\n"
" while for the `whole spectrum' (i.e., fALFF denominator) the bandpass is:\n"
" done only to exclude the time series mean and the Nyquist frequency:\n"
" (0) Check time series for initial transients [does not alter data]\n"
" (1) Despiking of each time series\n"
" (2) Removal of a constant+linear+quadratic trend in each time series\n"
" (3) Bandpass of data time series\n"
" (4) Bandpass of -ort time series, then detrending of data\n"
" with respect to the -ort time series\n"
" (5) Bandpass and de-orting of the -dsort dataset,\n"
" then detrending of the data with respect to -dsort\n"
" (6) Blurring inside the mask [might be slow]\n"
" (7) Local PV calculation [WILL be slow!]\n"
" (8) L2 normalization [will be fast.]\n"
" (9) Calculate spectrum and amplitudes, for RSFC parameters.\n"
"\n"
"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n"
"--------\n"
"OPTIONS:\n"
"--------\n"
" -despike = Despike each time series before other processing.\n"
" ++ Hopefully, you don't actually need to do this,\n"
" which is why it is optional.\n"
" -ort f.1D = Also orthogonalize input to columns in f.1D\n"
" ++ Multiple '-ort' options are allowed.\n"
" -dsort fset = Orthogonalize each voxel to the corresponding\n"
" voxel time series in dataset 'fset', which must\n"
" have the same spatial and temporal grid structure\n"
" as the main input dataset.\n"
" ++ At present, only one '-dsort' option is allowed.\n"
" -nodetrend = Skip the quadratic detrending of the input that\n"
" occurs before the FFT-based bandpassing.\n"
" ++ You would only want to do this if the dataset\n"
" had been detrended already in some other program.\n"
" -dt dd = set time step to 'dd' sec [default=from dataset header]\n"
" -nfft N = set the FFT length to 'N' [must be a legal value]\n"
" -norm = Make all output time series have L2 norm = 1\n"
" ++ i.e., sum of squares = 1\n"
" -mask mset = Mask dataset\n"
" -automask = Create a mask from the input dataset\n"
" -blur fff = Blur (inside the mask only) with a filter\n"
" width (FWHM) of 'fff' millimeters.\n"
" -localPV rrr = Replace each vector by the local Principal Vector\n"
" (AKA first singular vector) from a neighborhood\n"
" of radius 'rrr' millimiters.\n"
" ++ Note that the PV time series is L2 normalized.\n"
" ++ This option is mostly for Bob Cox to have fun with.\n"
"\n"
" -input dataset = Alternative way to specify input dataset.\n"
" -band fbot ftop = Alternative way to specify passband frequencies.\n"
"\n"
" -prefix ppp = Set prefix name of output dataset. Name of filtered time\n"
" series would be, e.g., ppp_LFF+orig.*, and the parameter\n"
" outputs are named with obvious suffices.\n"
" -quiet = Turn off the fun and informative messages. (Why?)\n"
" -no_rs_out = Don't output processed time series-- just output\n"
" parameters (not recommended, since the point of\n"
" calculating RSFC params here is to have them be quite\n"
" related to the time series themselves which are used for\n"
" further analysis)."
" -un_bp_out = Output the un-bandpassed series as well (default is not \n"
" to). Name would be, e.g., ppp_unBP+orig.* .\n"
" with suffix `_unBP'.\n"
" -no_rsfa = If you don't want RSFA output (default is to do so).\n"
" -bp_at_end = A (probably unnecessary) switch to have bandpassing be \n"
" the very last processing step that is done in the\n"
" sequence of steps listed above; at Step 3 above, only \n"
" the time series mean and nyquist are BP'ed out, and then\n"
" the LFF series is created only after Step 9. NB: this \n"
" probably makes only very small changes for most\n"
" processing sequences (but maybe not, depending usage).\n"
"\n"
" -notrans = Don't check for initial positive transients in the data:\n"
" *OR* ++ The test is a little slow, so skipping it is OK,\n"
" -nosat if you KNOW the data time series are transient-free.\n"
" ++ Or set AFNI_SKIP_SATCHECK to YES.\n"
" ++ Initial transients won't be handled well by the\n"
" bandpassing algorithm, and in addition may seriously\n"
" contaminate any further processing, such as inter-\n"
" voxel correlations via InstaCorr.\n"
" ++ No other tests are made [yet] for non-stationary \n"
" behavior in the time series data.\n"
"\n"
"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n"
"\n"
" If you use this program, please reference the introductory/description\n"
" paper for the FATCAT toolbox:\n"
" Taylor PA, Saad ZS (2013). FATCAT: (An Efficient) Functional\n"
" And Tractographic Connectivity Analysis Toolbox. Brain \n"
" Connectivity 3(5):523-535.\n"
"____________________________________________________________________________\n"
);
PRINT_AFNI_OMP_USAGE(
" 3dRSFC" ,
" * At present, the only part of 3dRSFC that is parallelized is the\n"
" '-blur' option, which processes each sub-brick independently.\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
/*-- startup --*/
mainENTRY("3dRSFC"); machdep();
AFNI_logger("3dRSFC",argc,argv);
PRINT_VERSION("3dRSFC (from 3dBandpass by RW Cox): version THETA");
AUTHOR("PA Taylor");
nosat = AFNI_yesenv("AFNI_SKIP_SATCHECK") ;
nopt = 1 ;
while( nopt < argc && argv[nopt][0] == '-' ){
if( strcmp(argv[nopt],"-despike") == 0 ){ /* 08 Oct 2010 */
do_despike++ ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-nfft") == 0 ){
int nnup ;
if( ++nopt >= argc ) ERROR_exit("need an argument after -nfft!") ;
nfft = (int)strtod(argv[nopt],NULL) ;
nnup = csfft_nextup_even(nfft) ;
if( nfft < 16 || nfft != nnup )
ERROR_exit("value %d after -nfft is illegal! Next legal value = %d",nfft,nnup) ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-blur") == 0 ){
if( ++nopt >= argc ) ERROR_exit("need an argument after -blur!") ;
blur = strtod(argv[nopt],NULL) ;
if( blur <= 0.0f ) WARNING_message("non-positive blur?!") ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-localPV") == 0 ){
if( ++nopt >= argc ) ERROR_exit("need an argument after -localpv!") ;
pvrad = strtod(argv[nopt],NULL) ;
if( pvrad <= 0.0f ) WARNING_message("non-positive -localpv?!") ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-prefix") == 0 ){
if( ++nopt >= argc ) ERROR_exit("need an argument after -prefix!") ;
prefix = strdup(argv[nopt]) ;
if( !THD_filename_ok(prefix) ) ERROR_exit("bad -prefix option!") ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-automask") == 0 ){
if( mask != NULL ) ERROR_exit("Can't use -mask AND -automask!") ;
do_automask = 1 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mask") == 0 ){
THD_3dim_dataset *mset ;
if( ++nopt >= argc ) ERROR_exit("Need argument after '-mask'") ;
if( mask != NULL || do_automask ) ERROR_exit("Can't have two mask inputs") ;
mset = THD_open_dataset( argv[nopt] ) ;
CHECK_OPEN_ERROR(mset,argv[nopt]) ;
DSET_load(mset) ; CHECK_LOAD_ERROR(mset) ;
mask_nx = DSET_NX(mset); mask_ny = DSET_NY(mset); mask_nz = DSET_NZ(mset);
mask = THD_makemask( mset , 0 , 0.5f, 0.0f ) ; DSET_delete(mset) ;
if( mask == NULL ) ERROR_exit("Can't make mask from dataset '%s'",argv[nopt]) ;
nmask = THD_countmask( mask_nx*mask_ny*mask_nz , mask ) ;
if( verb ) INFO_message("Number of voxels in mask = %d",nmask) ;
if( nmask < 1 ) ERROR_exit("Mask is too small to process") ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-norm") == 0 ){
do_norm = 1 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-quiet") == 0 ){
verb = 0 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-no_rs_out") == 0 ){ // @@
SERIES_OUT = 0 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-un_bp_out") == 0 ){ // @@
UNBP_OUT = 1 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-no_rsfa") == 0 ){ // @@
DO_RSFA = 0 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-bp_at_end") == 0 ){ // @@
BP_LAST = 1 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-notrans") == 0 || strcmp(argv[nopt],"-nosat") == 0 ){
nosat = 1 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-ort") == 0 ){
if( ++nopt >= argc ) ERROR_exit("need an argument after -ort!") ;
if( ortar == NULL ) INIT_IMARR(ortar) ;
ortim = mri_read_1D( argv[nopt] ) ;
if( ortim == NULL ) ERROR_exit("can't read from -ort '%s'",argv[nopt]) ;
mri_add_name(argv[nopt],ortim) ;
ADDTO_IMARR(ortar,ortim) ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-dsort") == 0 ){
THD_3dim_dataset *qset ;
if( ++nopt >= argc ) ERROR_exit("need an argument after -dsort!") ;
if( nortset > 0 ) ERROR_exit("only 1 -dsort option is allowed!") ;
qset = THD_open_dataset(argv[nopt]) ;
CHECK_OPEN_ERROR(qset,argv[nopt]) ;
ortset = (THD_3dim_dataset **)realloc(ortset,
sizeof(THD_3dim_dataset *)*(nortset+1)) ;
ortset[nortset++] = qset ;
nopt++ ; continue ;
}
if( strncmp(argv[nopt],"-nodetrend",6) == 0 ){
qdet = 0 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-dt") == 0 ){
if( ++nopt >= argc ) ERROR_exit("need an argument after -dt!") ;
dt = (float)strtod(argv[nopt],NULL) ;
if( dt <= 0.0f ) WARNING_message("value after -dt illegal!") ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-input") == 0 ){
if( inset != NULL ) ERROR_exit("Can't have 2 -input options!") ;
if( ++nopt >= argc ) ERROR_exit("need an argument after -input!") ;
inset = THD_open_dataset(argv[nopt]) ;
CHECK_OPEN_ERROR(inset,argv[nopt]) ;
nopt++ ; continue ;
}
if( strncmp(argv[nopt],"-band",5) == 0 ){
if( ++nopt >= argc-1 ) ERROR_exit("need 2 arguments after -band!") ;
if( have_freq ) WARNING_message("second -band option replaces first one!") ;
fbot = strtod(argv[nopt++],NULL) ;
ftop = strtod(argv[nopt++],NULL) ;
have_freq = 1 ; continue ;
}
ERROR_exit("Unknown option: '%s'",argv[nopt]) ;
}
/** check inputs for reasonablositiness **/
if( !have_freq ){
if( nopt+1 >= argc )
ERROR_exit("Need frequencies on command line after options!") ;
fbot = (float)strtod(argv[nopt++],NULL) ;
ftop = (float)strtod(argv[nopt++],NULL) ;
}
if( inset == NULL ){
if( nopt >= argc )
ERROR_exit("Need input dataset name on command line after options!") ;
inset = THD_open_dataset(argv[nopt]) ;
CHECK_OPEN_ERROR(inset,argv[nopt]) ;
nopt++ ;
}
DSET_UNMSEC(inset) ;
if( fbot < 0.0f ) ERROR_exit("fbot value can't be negative!") ;
if( ftop <= fbot ) ERROR_exit("ftop value %g must be greater than fbot value %g!",ftop,fbot) ;
ntime = DSET_NVALS(inset) ;
if( ntime < 9 ) ERROR_exit("Input dataset is too short!") ;
if( nfft <= 0 ){
nfft = csfft_nextup_even(ntime) ;
if( verb ) INFO_message("Data length = %d FFT length = %d",ntime,nfft) ;
(void)THD_bandpass_set_nfft(nfft) ;
} else if( nfft < ntime ){
ERROR_exit("-nfft %d is less than data length = %d",nfft,ntime) ;
} else {
kk = THD_bandpass_set_nfft(nfft) ;
if( kk != nfft && verb )
INFO_message("Data length = %d FFT length = %d",ntime,kk) ;
}
if( dt <= 0.0f ){
dt = DSET_TR(inset) ;
if( dt <= 0.0f ){
WARNING_message("Setting dt=1.0 since input dataset lacks a time axis!") ;
dt = 1.0f ;
}
}
ftopALL = 1./dt ;// Aug,2016: should solve problem of a too-large
// value for THD_bandpass_vectors(), while still
// being >f_{Nyquist}
if( !THD_bandpass_OK(ntime,dt,fbot,ftop,1) ) ERROR_exit("Can't continue!") ;
nx = DSET_NX(inset); ny = DSET_NY(inset); nz = DSET_NZ(inset); nvox = nx*ny*nz;
/* check mask, or create it */
if( verb ) INFO_message("Loading input dataset time series" ) ;
DSET_load(inset) ;
if( mask != NULL ){
if( mask_nx != nx || mask_ny != ny || mask_nz != nz )
ERROR_exit("-mask dataset grid doesn't match input dataset") ;
} else if( do_automask ){
mask = THD_automask( inset ) ;
if( mask == NULL )
ERROR_message("Can't create -automask from input dataset?") ;
nmask = THD_countmask( DSET_NVOX(inset) , mask ) ;
if( verb ) INFO_message("Number of voxels in automask = %d",nmask);
if( nmask < 1 ) ERROR_exit("Automask is too small to process") ;
} else {
mask = (byte *)malloc(sizeof(byte)*nvox) ; nmask = nvox ;
memset(mask,1,sizeof(byte)*nvox) ;
// if( verb ) // @@ alert if aaaalllllll vox are going to be analyzed!
INFO_message("No mask ==> processing all %d voxels",nvox);
}
/* A simple check of dataset quality [08 Feb 2010] */
if( !nosat ){
float val ;
INFO_message(
"Checking dataset for initial transients [use '-notrans' to skip this test]") ;
val = THD_saturation_check(inset,mask,0,0) ; kk = (int)(val+0.54321f) ;
if( kk > 0 )
ININFO_message(
"Looks like there %s %d non-steady-state initial time point%s :-(" ,
((kk==1) ? "is" : "are") , kk , ((kk==1) ? " " : "s") ) ;
else if( val > 0.3210f ) /* don't ask where this threshold comes from! */
ININFO_message(
"MAYBE there's an initial positive transient of 1 point, but it's hard to tell\n") ;
else
ININFO_message("No widespread initial positive transient detected :-)") ;
}
/* check -dsort inputs for match to inset */
for( kk=0 ; kk < nortset ; kk++ ){
if( DSET_NX(ortset[kk]) != nx ||
DSET_NY(ortset[kk]) != ny ||
DSET_NZ(ortset[kk]) != nz ||
DSET_NVALS(ortset[kk]) != ntime )
ERROR_exit("-dsort %s doesn't match input dataset grid" ,
DSET_BRIKNAME(ortset[kk]) ) ;
}
/* convert input dataset to a vectim, which is more fun */
// @@ convert BP'ing ftop/bot into indices for the DFT (below)
delf = 1.0/(ntime*dt);
ind_low = (int) rint(fbot/delf);
ind_high = (int) rint(ftop/delf);
if( ntime % 2 ) // nyquist number
N_ny = (ntime-1)/2;
else
N_ny = ntime/2;
sqnt = sqrt(ntime);
nt_fac = sqrt(ntime*(ntime-1));
// @@ if BP_LAST==0:
// now we go through twice, doing LFF bandpass for NumDen==0 and
// `full spectrum' processing for NumDen==1.
// if BP_LAST==1:
// now we go through once, doing only `full spectrum' processing
for( NumDen=0 ; NumDen<2 ; NumDen++) {
//if( NumDen==1 ){ // full spectrum
// fbot = fbotALL;
// ftop = ftopALL;
//}
// essentially, just doesn't BP here, and the perfect filtering at end
// is used for both still; this makes the final output spectrum
// contain only frequencies in range of 0.01-0.08
if( BP_LAST==1 )
INFO_message("Only doing filtering to LFFs at end!");
mrv = THD_dset_to_vectim( inset , mask , 0 ) ;
if( mrv == NULL ) ERROR_exit("Can't load time series data!?") ;
if( NumDen==1 )
DSET_unload(inset) ; // @@ only unload on 2nd pass
/* similarly for the ort vectors */
if( ortar != NULL ){
for( kk=0 ; kk < IMARR_COUNT(ortar) ; kk++ ){
ortim = IMARR_SUBIM(ortar,kk) ;
if( ortim->nx < ntime )
ERROR_exit("-ort file %s is shorter than input dataset time series",
ortim->name ) ;
ort = (float **)realloc( ort , sizeof(float *)*(nort+ortim->ny) ) ;
for( vv=0 ; vv < ortim->ny ; vv++ )
ort[nort++] = MRI_FLOAT_PTR(ortim) + ortim->nx * vv ;
}
}
/* all the real work now */
if( do_despike ){
int_pair nsp ;
if( verb ) INFO_message("Testing data time series for spikes") ;
nsp = THD_vectim_despike9( mrv ) ;
if( verb ) ININFO_message(" -- Squashed %d spikes from %d voxels",nsp.j,nsp.i) ;
}
if( verb ) INFO_message("Bandpassing data time series") ;
if( (BP_LAST==0) && (NumDen==0) )
(void)THD_bandpass_vectim( mrv , dt,fbot,ftop , qdet , nort,ort ) ;
else
(void)THD_bandpass_vectim( mrv , dt,fbotALL,ftopALL, qdet,nort,ort ) ;
/* OK, maybe a little more work */
if( nortset == 1 ){
MRI_vectim *orv ;
orv = THD_dset_to_vectim( ortset[0] , mask , 0 ) ;
if( orv == NULL ){
ERROR_message("Can't load -dsort %s",DSET_BRIKNAME(ortset[0])) ;
} else {
float *dp , *mvv , *ovv , ff ;
if( verb ) INFO_message("Orthogonalizing to bandpassed -dsort") ;
//(void)THD_bandpass_vectim( orv , dt,fbot,ftop , qdet , nort,ort ) ; //@@
if( (BP_LAST==0) && (NumDen==0) )
(void)THD_bandpass_vectim(orv,dt,fbot,ftop,qdet,nort,ort);
else
(void)THD_bandpass_vectim(orv,dt,fbotALL,ftopALL,qdet,nort,ort);
THD_vectim_normalize( orv ) ;
dp = malloc(sizeof(float)*mrv->nvec) ;
THD_vectim_vectim_dot( mrv , orv , dp ) ;
for( vv=0 ; vv < mrv->nvec ; vv++ ){
ff = dp[vv] ;
if( ff != 0.0f ){
mvv = VECTIM_PTR(mrv,vv) ; ovv = VECTIM_PTR(orv,vv) ;
for( kk=0 ; kk < ntime ; kk++ ) mvv[kk] -= ff*ovv[kk] ;
}
}
VECTIM_destroy(orv) ; free(dp) ;
}
}
if( blur > 0.0f ){
if( verb )
INFO_message("Blurring time series data spatially; FWHM=%.2f",blur) ;
mri_blur3D_vectim( mrv , blur ) ;
}
if( pvrad > 0.0f ){
if( verb )
INFO_message("Local PV-ing time series data spatially; radius=%.2f",pvrad) ;
THD_vectim_normalize( mrv ) ;
THD_vectim_localpv( mrv , pvrad ) ;
}
if( do_norm && pvrad <= 0.0f ){
if( verb ) INFO_message("L2 normalizing time series data") ;
THD_vectim_normalize( mrv ) ;
}
/* create output dataset, populate it, write it, then quit */
if( (NumDen==0) ) { // @@ BP'ed version; will do filt if BP_LAST
if(BP_LAST) // do bandpass here for BP_LAST
(void)THD_bandpass_vectim(mrv,dt,fbot,ftop,qdet,0,NULL);
if( verb ) INFO_message("Creating output dataset in memory, then writing it") ;
outset = EDIT_empty_copy(inset) ;
if(SERIES_OUT){
sprintf(out_lff,"%s_LFF",prefix);
EDIT_dset_items( outset , ADN_prefix,out_lff , ADN_none ) ;
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dBandpass" , argc,argv , outset ) ;
}
for( vv=0 ; vv < ntime ; vv++ )
EDIT_substitute_brick( outset , vv , MRI_float , NULL ) ;
#if 1
THD_vectim_to_dset( mrv , outset ) ;
#else
AFNI_OMP_START ;
#pragma omp parallel
{ float *far , *var ; int *ivec=mrv->ivec ; int vv,kk ;
#pragma omp for
for( vv=0 ; vv < ntime ; vv++ ){
far = DSET_BRICK_ARRAY(outset,vv) ; var = mrv->fvec + vv ;
for( kk=0 ; kk < nmask ; kk++ ) far[ivec[kk]] = var[kk*ntime] ;
}
}
AFNI_OMP_END ;
#endif
VECTIM_destroy(mrv) ;
if(SERIES_OUT){ // @@
DSET_write(outset) ; if( verb ) WROTE_DSET(outset) ;
}
}
else{ // @@ non-BP'ed version
if( verb ) INFO_message("Creating output dataset 2 in memory") ;
// do this here because LFF version was also BP'ed at end.
if(BP_LAST) // do bandpass here for BP_LAST
(void)THD_bandpass_vectim(mrv,dt,fbotALL,ftopALL,qdet,0,NULL);
outsetALL = EDIT_empty_copy(inset) ;
if(UNBP_OUT){
sprintf(out_unBP,"%s_unBP",prefix);
EDIT_dset_items( outsetALL, ADN_prefix, out_unBP, ADN_none );
tross_Copy_History( inset , outsetALL ) ;
tross_Make_History( "3dRSFC" , argc,argv , outsetALL ) ;
}
for( vv=0 ; vv < ntime ; vv++ )
EDIT_substitute_brick( outsetALL , vv , MRI_float , NULL ) ;
#if 1
THD_vectim_to_dset( mrv , outsetALL ) ;
#else
AFNI_OMP_START ;
#pragma omp parallel
{ float *far , *var ; int *ivec=mrv->ivec ; int vv,kk ;
#pragma omp for
for( vv=0 ; vv < ntime ; vv++ ){
far = DSET_BRICK_ARRAY(outsetALL,vv) ; var = mrv->fvec + vv ;
for( kk=0 ; kk < nmask ; kk++ ) far[ivec[kk]] = var[kk*ntime] ;
}
}
AFNI_OMP_END ;
#endif
VECTIM_destroy(mrv) ;
if(UNBP_OUT){
DSET_write(outsetALL) ; if( verb ) WROTE_DSET(outsetALL) ;
}
}
}// end of NumDen loop
// @@
INFO_message("Starting the (f)ALaFFel calcs") ;
// allocations
series1 = (double *)calloc(ntime,sizeof(double));
series2 = (double *)calloc(ntime,sizeof(double));
xx1 = (double *)calloc(2*ntime,sizeof(double));
xx2 = (double *)calloc(2*ntime,sizeof(double));
alff = (float *)calloc(nvox,sizeof(float));
malff = (float *)calloc(nvox,sizeof(float));
falff = (float *)calloc(nvox,sizeof(float));
if( (series1 == NULL) || (series2 == NULL)
|| (xx1 == NULL) || (xx2 == NULL)
|| (alff == NULL) || (malff == NULL) || (falff == NULL)) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(122);
}
if(DO_RSFA) {
rsfa = (float *)calloc(nvox,sizeof(float));
mrsfa = (float *)calloc(nvox,sizeof(float));
frsfa = (float *)calloc(nvox,sizeof(float));
if( (rsfa == NULL) || (mrsfa == NULL) || (frsfa == NULL)) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(123);
}
}
work = gsl_fft_real_workspace_alloc (ntime);
real1 = gsl_fft_real_wavetable_alloc (ntime);
real2 = gsl_fft_real_wavetable_alloc (ntime);
gsl_complex_packed_array compl_freqs1 = xx1;
gsl_complex_packed_array compl_freqs2 = xx2;
// *********************************************************************
// *********************************************************************
// ************** Falafelling = ALFF/fALFF calcs *****************
// *********************************************************************
// *********************************************************************
// Be now have the BP'ed data set (outset) and the non-BP'ed one
// (outsetALL). now we'll FFT both, get amplitudes in appropriate
// ranges, and calculate: ALFF, mALFF, fALFF,
ctr = 0;
for( kk=0; kk<nvox ; kk++) {
if(mask[kk]) {
// BP one, and unBP one, either for BP_LAST or !BP_LAST
for( m=0 ; m<ntime ; m++ ) {
series1[m] = THD_get_voxel(outset,kk,m);
series2[m] = THD_get_voxel(outsetALL,kk,m);
}
mm = gsl_fft_real_transform(series1, 1, ntime, real1, work);
mm = gsl_fft_halfcomplex_unpack(series1, compl_freqs1, 1, ntime);
mm = gsl_fft_real_transform(series2, 1, ntime, real2, work);
mm = gsl_fft_halfcomplex_unpack(series2, compl_freqs2, 1, ntime);
numer = 0.0f;
denom = 0.0f;
de_rsfa = 0.0f;
nu_rsfa = 0.0f;
for( m=1 ; m<N_ny ; m++ ) {
mm = 2*m;
pow2 = compl_freqs2[mm]*compl_freqs2[mm] +
compl_freqs2[mm+1]*compl_freqs2[mm+1]; // power
//pow2*=2;// factor of 2 since ampls are even funcs
denom+= (float) sqrt(pow2); // amplitude
de_rsfa+= (float) pow2;
if( ( m>=ind_low ) && ( m<=ind_high ) ){
pow1 = compl_freqs1[mm]*compl_freqs1[mm]+
compl_freqs1[mm+1]*compl_freqs1[mm+1];
//pow1*=2;
numer+= (float) sqrt(pow1);
nu_rsfa+= (float) pow1;
}
}
if( denom>0.000001 )
falff[kk] = numer/denom;
else
falff[kk] = 0.;
alff[kk] = 2*numer/sqnt;// factor of 2 since ampl is even funct
meanALFF+= alff[kk];
if(DO_RSFA){
nu_rsfa = sqrt(2*nu_rsfa); // factor of 2 since ampls
de_rsfa = sqrt(2*de_rsfa); // are even funcs
if( de_rsfa>0.000001 )
frsfa[kk] = nu_rsfa/de_rsfa;
else
frsfa[kk]=0.;
rsfa[kk] = nu_rsfa/nt_fac;
meanRSFA+= rsfa[kk];
}
ctr+=1;
}
}
meanALFF/= ctr;
meanRSFA/= ctr;
gsl_fft_real_wavetable_free(real1);
gsl_fft_real_wavetable_free(real2);
gsl_fft_real_workspace_free(work);
// ALFFs divided by mean of brain value
for( kk=0 ; kk<nvox ; kk++ )
if(mask[kk]){
malff[kk] = alff[kk]/meanALFF;
if(DO_RSFA)
mrsfa[kk] = rsfa[kk]/meanRSFA;
}
// **************************************************************
// **************************************************************
// Store and output
// **************************************************************
// **************************************************************
outsetALFF = EDIT_empty_copy( inset ) ;
sprintf(out_alff,"%s_ALFF",prefix);
EDIT_dset_items( outsetALFF,
ADN_nvals, 1,
ADN_datum_all , MRI_float ,
ADN_prefix , out_alff,
ADN_none ) ;
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outsetALFF)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outsetALFF));
EDIT_substitute_brick(outsetALFF, 0, MRI_float, alff);
alff=NULL;
THD_load_statistics(outsetALFF);
tross_Make_History("3dRSFC", argc, argv, outsetALFF);
THD_write_3dim_dataset(NULL, NULL, outsetALFF, True);
outsetfALFF = EDIT_empty_copy( inset ) ;
sprintf(out_falff,"%s_fALFF",prefix);
EDIT_dset_items( outsetfALFF,
ADN_nvals, 1,
ADN_datum_all , MRI_float ,
ADN_prefix , out_falff,
ADN_none ) ;
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outsetfALFF)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outsetfALFF));
EDIT_substitute_brick(outsetfALFF, 0, MRI_float, falff);
falff=NULL;
THD_load_statistics(outsetfALFF);
tross_Make_History("3dRSFC", argc, argv, outsetfALFF);
THD_write_3dim_dataset(NULL, NULL, outsetfALFF, True);
outsetmALFF = EDIT_empty_copy( inset ) ;
sprintf(out_malff,"%s_mALFF",prefix);
EDIT_dset_items( outsetmALFF,
ADN_nvals, 1,
ADN_datum_all , MRI_float ,
ADN_prefix , out_malff,
ADN_none ) ;
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outsetmALFF)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outsetmALFF));
EDIT_substitute_brick(outsetmALFF, 0, MRI_float, malff);
malff=NULL;
THD_load_statistics(outsetmALFF);
tross_Make_History("3dRSFC", argc, argv, outsetmALFF);
THD_write_3dim_dataset(NULL, NULL, outsetmALFF, True);
if(DO_RSFA){
outsetRSFA = EDIT_empty_copy( inset ) ;
sprintf(out_rsfa,"%s_RSFA",prefix);
EDIT_dset_items( outsetRSFA,
ADN_nvals, 1,
ADN_datum_all , MRI_float ,
ADN_prefix , out_rsfa,
ADN_none ) ;
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outsetRSFA)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outsetRSFA));
EDIT_substitute_brick(outsetRSFA, 0, MRI_float, rsfa);
rsfa=NULL;
THD_load_statistics(outsetRSFA);
tross_Make_History("3dRSFC", argc, argv, outsetRSFA);
THD_write_3dim_dataset(NULL, NULL, outsetRSFA, True);
outsetfRSFA = EDIT_empty_copy( inset ) ;
sprintf(out_frsfa,"%s_fRSFA",prefix);
EDIT_dset_items( outsetfRSFA,
ADN_nvals, 1,
ADN_datum_all , MRI_float ,
ADN_prefix , out_frsfa,
ADN_none ) ;
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outsetfRSFA)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outsetfRSFA));
EDIT_substitute_brick(outsetfRSFA, 0, MRI_float, frsfa);
frsfa=NULL;
THD_load_statistics(outsetfRSFA);
tross_Make_History("3dRSFC", argc, argv, outsetfRSFA);
THD_write_3dim_dataset(NULL, NULL, outsetfRSFA, True);
outsetmRSFA = EDIT_empty_copy( inset ) ;
sprintf(out_mrsfa,"%s_mRSFA",prefix);
EDIT_dset_items( outsetmRSFA,
ADN_nvals, 1,
ADN_datum_all , MRI_float ,
ADN_prefix , out_mrsfa,
ADN_none ) ;
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outsetmRSFA)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outsetmRSFA));
EDIT_substitute_brick(outsetmRSFA, 0, MRI_float, mrsfa);
mrsfa=NULL;
THD_load_statistics(outsetmRSFA);
tross_Make_History("3dRSFC", argc, argv, outsetmRSFA);
THD_write_3dim_dataset(NULL, NULL, outsetmRSFA, True);
}
// ************************************************************
// ************************************************************
// Freeing
// ************************************************************
// ************************************************************
DSET_delete(inset);
DSET_delete(outsetALL);
DSET_delete(outset);
DSET_delete(outsetALFF);
DSET_delete(outsetmALFF);
DSET_delete(outsetfALFF);
DSET_delete(outsetRSFA);
DSET_delete(outsetmRSFA);
DSET_delete(outsetfRSFA);
free(inset);
free(outsetALL);
free(outset);
free(outsetALFF);
free(outsetmALFF);
free(outsetfALFF);
free(outsetRSFA);
free(outsetmRSFA);
free(outsetfRSFA);
free(rsfa);
free(mrsfa);
free(frsfa);
free(alff);
free(malff);
free(falff);
free(mask);
free(series1);
free(series2);
free(xx1);
free(xx2);
exit(0) ;
}
MRI_shindss * GRINCOR_read_input( char *fname )
{
NI_element *nel=NULL ;
char *dfname=NULL , *atr ;
NI_float_array *facar ; NI_int_array *nvar, *nnode=NULL, *ninmask=NULL;
MRI_shindss *shd ;
long long nbytes_needed , nbytes_dfname=0 ; int fdes ;
void *var ; int ids , nvmax , nvtot ;
int datum , datum_size ;
char *geometry_string=NULL ;
THD_3dim_dataset *tdset=NULL; int nvox;
int no_ivec=0 , *ivec=NULL , *nvals=NULL , nvec,ndset ; float *fac=NULL ;
NI_str_array *slabar=NULL ;
if( fname == NULL || *fname == '\0' ) GQUIT(NULL) ;
/* get data element */
if (!THD_is_ondisk(fname))
GQUIT("not on disk") ;
nelshd = nel = NI_read_element_fromfile(fname) ;
if( nel == NULL || nel->type != NI_ELEMENT_TYPE )
GQUIT("not properly formatted") ;
if( strcmp(nel->name,"3dGroupInCorr") != 0 )
GQUIT("data element name is not '3dGroupInCorr'") ;
/* no data vector ==> using all voxels */
no_ivec = ( nel->vec_num < 1 ||
nel->vec_len < 1 || nel->vec_typ[0] != NI_INT ) ;
/* number of vectors in each dataset */
atr = NI_get_attribute(nel,"nvec");
if( atr == NULL ) GQUIT("nvec attribute missing?") ;
nvec = (int)strtod(atr,NULL) ;
if( nvec < 2 || (!no_ivec && nel->vec_len != nvec) )
GQUIT("nvec attribute has illegal value") ;
/* number of datasets */
atr = NI_get_attribute(nel,"ndset");
if( atr == NULL ) GQUIT("ndset attribute missing") ;
ndset = (int)strtod(atr,NULL) ;
if( ndset < 1 ) GQUIT("ndset attribute has illegal value") ;
/* number of time points in each dataset (varies with dataset) */
atr = NI_get_attribute(nel,"nvals");
if( atr == NULL ) GQUIT("nvals attribute missing") ;
nvar = NI_decode_int_list(atr,",") ;
if( nvar == NULL || nvar->num < ndset )
GQUIT("nvals attribute doesn't match ndset") ;
nvals = nvar->ar ; nvar->ar = NULL ; NI_delete_int_array(nvar) ;
nvmax = nvtot = nvals[0] ;
for( ids=1 ; ids < ndset ; ids++ ){ /* Feb 2011 */
nvtot += nvals[ids] ;
if( nvals[ids] > nvmax ) nvmax = nvals[ids] ;
}
/* dataset labels [23 May 2010] */
atr = NI_get_attribute(nel,"dset_labels") ;
if( atr != NULL ){
slabar = NI_decode_string_list(atr,";,") ;
if( slabar == NULL || slabar->num < ndset )
GQUIT("dset_labels attribute invalid") ;
}
/* datum of datasets */
atr = NI_get_attribute(nel,"datum") ;
if( atr != NULL && strcasecmp(atr,"byte") == 0 ){
datum = 1 ; datum_size = sizeof(sbyte) ;
} else {
datum = 2 ; datum_size = sizeof(short) ;
}
/* number of bytes needed:
sizeof(datum) * number of vectors per dataset
* number of datasets
* sum of per dataset vector lengths */
nbytes_needed = 0 ;
for( ids=0 ; ids < ndset ; ids++ ) nbytes_needed += nvals[ids] ;
nbytes_needed *= ((long long)nvec) * datum_size ;
if( nbytes_needed >= twogig &&
( sizeof(void *) < 8 || sizeof(size_t) < 8 ) ) /* too much for 32-bit */
GQUIT("datafile size exceeds 2 GB -- you need a 64-bit computer!") ;
/* scale factor for each dataset */
atr = NI_get_attribute(nel,"fac") ;
if( atr == NULL ) GQUIT("fac attribute missing") ;
facar = NI_decode_float_list(atr,",") ;
if( facar == NULL || facar->num < ndset )
GQUIT("can't decode fac attribute") ;
fac = facar->ar ; facar->ar = NULL ; NI_delete_float_array(facar) ;
for( ids=0 ; ids < ndset ; ids++ ) if( fac[ids] <= 0.0f ) fac[ids] = 1.0f ;
/* grid definition */
atr = NI_get_attribute(nel,"geometry") ;
if( atr == NULL ) GQUIT("geometry attribute missing") ;
geometry_string = strdup(atr) ;
tdset = EDIT_geometry_constructor( geometry_string , "GrpInCorr" ) ;
if( tdset == NULL ) GQUIT("can't decode geometry attribute") ;
nvox = DSET_NVOX(tdset) ;
if( no_ivec && nvox != nvec )
GQUIT("geometry attribute doesn't match nvec attribute") ;
if( !no_ivec && nvox < nvec )
GQUIT("geometry attribute specifies too few voxels") ;
/* name of data file: check its size against what's needed */
#if 0
atr = NI_get_attribute(nel,"datafile") ;
if( atr != NULL ){
dfname = strdup(atr) ; nbytes_dfname = THD_filesize(dfname) ;
if( nbytes_dfname <= 0 && strstr(dfname,"/") != NULL ){
char *tnam = THD_trailname(atr,0) ;
nbytes_dfname = THD_filesize(tnam) ;
if( nbytes_dfname > 0 ){ free(dfname); dfname = strdup(tnam); }
}
}
#endif
if( nbytes_dfname <= 0 && strstr(fname,".niml") != NULL ){
if( dfname != NULL ) free(dfname) ;
dfname = strdup(fname) ; strcpy(dfname+strlen(dfname)-5,".data") ;
nbytes_dfname = THD_filesize(dfname) ;
}
if( nbytes_dfname <= 0 ){
char mess[THD_MAX_NAME+256] ;
sprintf(mess,"datafile is missing (%s)",dfname) ; GQUIT(mess) ;
} else if( nbytes_dfname < nbytes_needed ){
char mess[THD_MAX_NAME+1024] ;
sprintf(mess,"datafile %s has %s bytes but needs at least %s",
dfname ,
commaized_integer_string(nbytes_dfname) ,
commaized_integer_string(nbytes_needed) ) ;
GQUIT(mess) ;
} else {
INFO_message("EIC: data file %s found with %s bytes of data",
dfname , commaized_integer_string(nbytes_dfname) ) ;
}
fdes = open( dfname , O_RDWR ) ;
if( fdes < 0 ){
char mess[THD_MAX_NAME+256] ;
sprintf(mess,"can't open datafile (%s)",dfname) ; GQUIT(mess) ;
}
NI_set_attribute( nelshd , "datafile" , dfname ) ;
/* ivec[i] is the voxel spatial index of the i-th vector */
if( no_ivec ){
ivec = NULL ; /* means all voxels: ivec[i] == i */
} else {
ivec = (int *)nel->vec[0] ; /* copy pointer */
nel->vec[0] = NULL ; /* NULL out in element so won't be free-ed */
}
/* And stuff for LR surface pairs ZSS Jan 09*/
if ((atr=NI_get_attribute(nel,"LRpair_nnode"))) {
nnode = NI_decode_int_list(atr,",") ;
}
if ((atr=NI_get_attribute(nel,"LRpair_ninmask"))) {
ninmask = NI_decode_int_list(atr,",") ;
}
/* create output struct */
shd = (MRI_shindss *)malloc(sizeof(MRI_shindss)) ;
shd->nvals = nvals ; shd->nvals_max = nvmax ; shd->nvals_tot = nvtot ;
shd->nvec = nvec ;
shd->ndset = ndset ;
shd->geometry_string = geometry_string ;
shd->tdset = tdset ;
shd->dfname = dfname ;
shd->nvox = nvox ;
shd->nx = DSET_NX(tdset); shd->ny = DSET_NY(tdset); shd->nz = DSET_NZ(tdset);
shd->ivec = ivec ;
shd->fac = fac ;
/* and surface fields... ZSS Jan 09 */
if (nnode) {
if (nnode->num != 2) GQUIT("LRpair_nnode must have 2 values");
shd->nnode[0] = nnode->ar[0];
shd->nnode[1] = nnode->ar[1];
NI_delete_int_array(nnode); nnode=NULL;
} else {
shd->nnode[0] = shd->nnode[1] = -1 ;
}
if (ninmask) {
if (ninmask->num != 2) GQUIT("LRpair_ninmask must have 2 values");
shd->ninmask[0] = ninmask->ar[0];
shd->ninmask[1] = ninmask->ar[1];
NI_delete_int_array(ninmask); ninmask=NULL;
} else {
shd->ninmask[0] = shd->ninmask[1] = -1 ;
}
/*--- 07 Apr 2010: setup default use list (all of them) ---*/
shd->nuse = ndset ;
shd->use = (int *)malloc(sizeof(int)*ndset) ;
for( ids=0 ; ids < ndset ; ids++ ) shd->use[ids] = ids ;
shd->dslab = (slabar != NULL) ? slabar->str : NULL ; /* 23 May 2010 */
/*--- now have to map data from disk ---*/
var = mmap( 0 , (size_t)nbytes_needed ,
PROT_WRITE , THD_MMAP_FLAG , fdes , 0 ) ;
close(fdes) ; /* close file descriptor does not unmap data */
if( var == (void *)(-1) ){ /* this is bad */
ERROR_message(
"EIC: file %s: can't mmap() datafile -- memory space exhausted?" , dfname ) ;
free(shd) ; return NULL ;
}
/*-- create array of pointers to each dataset's data array --*/
shd->datum = datum ;
if( datum == 2 ){ /* shorts */
shd->sv = (short **)malloc(sizeof(short *)*ndset) ;
shd->bv = NULL ;
shd->sv[0] = (short *)var ;
for( ids=1 ; ids < ndset ; ids++ )
shd->sv[ids] = shd->sv[ids-1] + nvals[ids-1]*nvec ;
} else { /* sbytes */
shd->sv = NULL ;
shd->bv = (sbyte **)malloc(sizeof(sbyte *)*ndset) ;
shd->bv[0] = (sbyte *)var ;
for( ids=1 ; ids < ndset ; ids++ )
shd->bv[ids] = shd->bv[ids-1] + nvals[ids-1]*nvec ;
}
shd->nbytes = nbytes_needed ;
return shd ;
}
int main(int argc, char *argv[]) {
int i,j,k,m,n,aa,ii,jj,kk,mm,rr;
int iarg;
int nmask1=0;
int nmask2=0;
THD_3dim_dataset *insetFA = NULL, *insetV1 = NULL,
*insetMD = NULL, *insetL1 = NULL;
THD_3dim_dataset *insetEXTRA=NULL;
THD_3dim_dataset *mset2=NULL;
THD_3dim_dataset *mset1=NULL;
THD_3dim_dataset *outsetMAP=NULL, *outsetMASK=NULL;
char *prefix="tracky";
int LOG_TYPE=0;
char in_FA[300];
char in_V1[300];
char in_MD[300];
char in_L1[300];
int EXTRAFILE=0; // switch for whether other file is input as WM map
char OUT_bin[300];
char OUT_tracstat[300];
char prefix_mask[300];
char prefix_map[300];
// FACT algopts
FILE *fout0;
float MinFA=0.2,MaxAngDeg=45,MinL=20.0;
float MaxAng;
int SeedPerV[3]={2,2,2};
int ArrMax=0;
float tempvmagn;
int Nvox=-1; // tot number vox
int Dim[3]={0,0,0}; // dim in each dir
int Nseed=0,M=30,bval=1000;
int DimSeed[3]; // number of seeds there will be
float Ledge[3]; // voxel edge lengths
int *ROI1, *ROI2;
short int *temp_arr;
char *temp_byte;
int **Tforw, **Tback;
int **Ttot;
float **flTforw, **flTback;
float ****coorded;
int ****INDEX;
int len_forw, len_back; // int count of num of squares through
float phys_forw[1], phys_back[1];
int idx;
float ave_tract_len, ave_tract_len_phys;
int inroi1, inroi2, KEEPIT; // switches for detecting
int in[3]; // to pass to trackit
float physin[3]; // also for trackit, physical loc,
int totlen;
float totlen_phys;
int Numtract;
int READS_in;
float READS_fl;
int end[2][3];
int test_ind[2][3];
int roi3_ct=0, id=0;
float roi3_mu_MD = 0.,roi3_mu_RD = 0.,roi3_mu_L1 = 0.,roi3_mu_FA = 0.;
float roi3_sd_MD = 0.,roi3_sd_RD = 0.,roi3_sd_L1 = 0.,roi3_sd_FA = 0.;
float tempMD,tempFA,tempRD,tempL1;
char dset_or[4] = "RAI";
THD_3dim_dataset *dsetn;
int TV_switch[3] = {0,0,0};
TAYLOR_BUNDLE *tb=NULL;
TAYLOR_TRACT *tt=NULL;
char *mode = "NI_fast_binary";
NI_element *nel=NULL;
int dump_opts=0;
tv_io_header header1 = {.id_string = "TRACK\0",
.origin = {0,0,0},
.n_scalars = 3,
.scal_n[0] = "FA",
.scal_n[1] = "MD",
.scal_n[2] = "L1",
.n_properties = 0,
.vox_to_ras = {{0.,0.,0.,0.},{0.,0.,0.,0.},
{0.,0.,0.,0.},{0.,0.,0.,0.}},
// reset this later based on actual data set
.voxel_order = "RAI\0",
.invert_x = 0,
.invert_y = 0,
.invert_z = 0,
.swap_xy = 0,
.swap_yz = 0,
.swap_zx = 0,
.n_count = 0,
.version = 2,
.hdr_size = 1000};
// for testing names...
char *postfix[4]={"+orig.HEAD\0",".nii.gz\0",".nii\0","+tlrc.HEAD\0"};
int FOUND =-1;
int RECORD_ORIG = 0;
float Orig[3] = {0.0,0.0,0.0};
mainENTRY("3dTrackID"); machdep();
// ****************************************************************
// ****************************************************************
// load AFNI stuff
// ****************************************************************
// ****************************************************************
INFO_message("version: MU");
/** scan args **/
if (argc == 1) { usage_TrackID(1); exit(0); }
iarg = 1;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-help") == 0 ||
strcmp(argv[iarg],"-h") == 0 ) {
usage_TrackID(strlen(argv[iarg])>3 ? 2:1);
exit(0);
}
if( strcmp(argv[iarg],"-verb") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need argument after '-verb'") ;
set_tract_verb(atoi(argv[iarg]));
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-write_opts") == 0) {
dump_opts=1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-rec_orig") == 0) {
RECORD_ORIG=1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-tract_out_mode") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need argument after '-tract_out_mode'") ;
if (strcmp(argv[iarg], "NI_fast_binary") &&
strcmp(argv[iarg], "NI_fast_text") &&
strcmp(argv[iarg], "NI_slow_binary") &&
strcmp(argv[iarg], "NI_slow_text") ) {
ERROR_message("Bad value (%s) for -tract_out_mode",argv[iarg]);
exit(1);
}
mode = argv[iarg];
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mask1") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-mask1'") ;
mset1 = THD_open_dataset( argv[iarg] ) ;
if( mset1 == NULL )
ERROR_exit("Can't open mask1 dataset '%s'", argv[iarg]) ;
DSET_load(mset1) ; CHECK_LOAD_ERROR(mset1) ;
nmask1 = DSET_NVOX(mset1) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mask2") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-mask2'") ;
mset2 = THD_open_dataset( argv[iarg] ) ;
if( mset2 == NULL )
ERROR_exit("Can't open mask2 dataset '%s'",
argv[iarg]) ;
DSET_load(mset2) ; CHECK_LOAD_ERROR(mset2) ;
nmask2 = DSET_NVOX(mset2) ;
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],"-input") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-input'");
for( i=0 ; i<4 ; i++) {
sprintf(in_FA,"%s_FA%s", argv[iarg],postfix[i]);
if(THD_is_ondisk(in_FA)) {
FOUND = i;
break;
}
}
insetFA = THD_open_dataset(in_FA) ;
if( (insetFA == NULL ) || (FOUND==-1))
ERROR_exit("Can't open dataset '%s': for FA.",in_FA);
DSET_load(insetFA) ; CHECK_LOAD_ERROR(insetFA) ;
Nvox = DSET_NVOX(insetFA) ;
Dim[0] = DSET_NX(insetFA); Dim[1] = DSET_NY(insetFA);
Dim[2] = DSET_NZ(insetFA);
Ledge[0] = fabs(DSET_DX(insetFA)); Ledge[1] = fabs(DSET_DY(insetFA));
Ledge[2] = fabs(DSET_DZ(insetFA));
Orig[0] = DSET_XORG(insetFA); Orig[1] = DSET_YORG(insetFA);
Orig[2] = DSET_ZORG(insetFA);
// check tot num vox match (as proxy for dims...)
if( (Nvox != nmask1) || (Nvox != nmask2) )
ERROR_exit("Input dataset does not match both mask volumes!");
// this stores the original data file orientation for later use,
// as well since we convert everything to RAI temporarily, as
// described below
header1.voxel_order[0]=ORIENT_typestr[insetFA->daxes->xxorient][0];
header1.voxel_order[1]=ORIENT_typestr[insetFA->daxes->yyorient][0];
header1.voxel_order[2]=ORIENT_typestr[insetFA->daxes->zzorient][0];
for( i=0 ; i<3 ; i++) {
header1.dim[i] = Dim[i];
header1.voxel_size[i] = Ledge[i];
// will want this when outputting file later for TrackVis.
TV_switch[i] = !(dset_or[i]==header1.voxel_order[i]);
}
dset_or[3]='\0';
FOUND = -1;
for( i=0 ; i<4 ; i++) {
sprintf(in_V1,"%s_V1%s", argv[iarg],postfix[i]);
if(THD_is_ondisk(in_V1)) {
FOUND = i;
break;
}
}
insetV1 = THD_open_dataset(in_V1);
if( insetV1 == NULL )
ERROR_exit("Can't open dataset '%s':V1",in_V1);
DSET_load(insetV1) ; CHECK_LOAD_ERROR(insetV1) ;
FOUND = -1;
for( i=0 ; i<4 ; i++) {
sprintf(in_L1,"%s_L1%s", argv[iarg],postfix[i]);
if(THD_is_ondisk(in_L1)) {
FOUND = i;
break;
}
}
insetL1 = THD_open_dataset(in_L1);
if( insetL1 == NULL )
ERROR_exit("Can't open dataset '%s':L1",in_L1);
DSET_load(insetL1) ; CHECK_LOAD_ERROR(insetL1) ;
FOUND = -1;
for( i=0 ; i<4 ; i++) {
sprintf(in_MD,"%s_MD%s", argv[iarg],postfix[i]);
if(THD_is_ondisk(in_MD)) {
FOUND = i;
break;
}
}
insetMD = THD_open_dataset(in_MD);
if( insetMD == NULL )
ERROR_exit("Can't open dataset '%s':MD",in_MD);
DSET_load(insetMD) ; CHECK_LOAD_ERROR(insetMD) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-algopt") == 0 ){
iarg++ ;
if( iarg >= argc )
ERROR_exit("Need argument after '-algopt'");
if (!(nel = ReadTractAlgOpts(argv[iarg]))) {
ERROR_message("Failed to read options in %s\n", argv[iarg]);
exit(19);
}
if (NI_getTractAlgOpts(nel, &MinFA, &MaxAngDeg, &MinL,
SeedPerV, &M, &bval)) {
ERROR_message("Failed to get options");
exit(1);
}
NI_free_element(nel); nel=NULL;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-logic") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-logic'");
INFO_message("ROI logic type is: %s",argv[iarg]);
if( strcmp(argv[iarg],"AND") == 0 )
LOG_TYPE = 1;
else if( strcmp(argv[iarg],"OR") == 0 )
LOG_TYPE = 0;
else if( strcmp(argv[iarg],"ALL") == 0 )
LOG_TYPE = -1;
else
ERROR_exit("Illegal after '-logic': need 'OR' or 'AND'");
iarg++ ; continue ;
}
//@@
if( strcmp(argv[iarg],"-extra_set") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need argument after '-extra_set'");
EXTRAFILE = 1; // switch on
insetEXTRA = THD_open_dataset(argv[iarg]);
if( (insetEXTRA == NULL ) )
ERROR_exit("Can't open dataset '%s': for extra set.",argv[iarg]);
DSET_load(insetEXTRA) ; CHECK_LOAD_ERROR(insetEXTRA) ;
if( !((Dim[0] == DSET_NX(insetEXTRA)) && (Dim[1] == DSET_NY(insetEXTRA)) && (Dim[2] == DSET_NZ(insetEXTRA))))
ERROR_exit("Dimensions of extra set '%s' don't match those of the DTI prop ones ('%s', etc.).",argv[iarg], in_FA);
iarg++ ; continue ;
}
ERROR_message("Bad option '%s'\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
if (iarg < 4) {
ERROR_message("Too few options. Try -help for details.\n");
exit(1);
}
if (dump_opts) {
nel = NI_setTractAlgOpts(NULL, &MinFA, &MaxAngDeg, &MinL,
SeedPerV, &M, &bval);
WriteTractAlgOpts(prefix, nel);
NI_free_element(nel); nel=NULL;
}
// Process the options a little
for( i=0 ; i<3 ; i++)
DimSeed[i] = Dim[i]*SeedPerV[i];
Nseed = Nvox*SeedPerV[0]*SeedPerV[1]*SeedPerV[2];
// convert to cos of rad value for comparisons, instead of using acos()
MaxAng = cos(CONV*MaxAngDeg);
// switch to add header-- option for now, added Sept. 2012
// for use with map_TrackID to map tracks to different space
if(RECORD_ORIG) {
for( i=0 ; i<3 ; i++)
header1.origin[i] = Orig[i];
}
// at some point, we will have to convert indices into
// pseudo-locations; being forced into this choice means that
// different data set orientations would be represented differently
// and incorrectly in some instances... so, for now, we'll resample
// everything to RAI, and then resample back later. guess this will
// just slow things down slightly.
// have all be RAI for processing here
if(TV_switch[0] || TV_switch[1] || TV_switch[2]) {
dsetn = r_new_resam_dset(insetFA, NULL, 0.0, 0.0, 0.0,
dset_or, RESAM_NN_TYPE, NULL, 1, 0);
DSET_delete(insetFA);
insetFA=dsetn;
dsetn=NULL;
dsetn = r_new_resam_dset(insetMD, NULL, 0.0, 0.0, 0.0,
dset_or, RESAM_NN_TYPE, NULL, 1, 0);
DSET_delete(insetMD);
insetMD=dsetn;
dsetn=NULL;
dsetn = r_new_resam_dset(insetV1, NULL, 0.0, 0.0, 0.0,
dset_or, RESAM_NN_TYPE, NULL, 1, 0);
DSET_delete(insetV1);
insetV1=dsetn;
dsetn=NULL;
dsetn = r_new_resam_dset(insetL1, NULL, 0.0, 0.0, 0.0,
dset_or, RESAM_NN_TYPE, NULL, 1, 0);
DSET_delete(insetL1);
insetL1=dsetn;
dsetn=NULL;
dsetn = r_new_resam_dset(mset1, NULL, 0.0, 0.0, 0.0,
dset_or, RESAM_NN_TYPE, NULL, 1, 0);
DSET_delete(mset1);
mset1=dsetn;
dsetn=NULL;
dsetn = r_new_resam_dset(mset2, NULL, 0.0, 0.0, 0.0,
dset_or, RESAM_NN_TYPE, NULL, 1, 0);
DSET_delete(mset2);
mset2=dsetn;
dsetn=NULL;
if(EXTRAFILE) {
dsetn = r_new_resam_dset(insetEXTRA, NULL, 0.0, 0.0, 0.0,
dset_or, RESAM_NN_TYPE, NULL, 1, 0);
DSET_delete(insetEXTRA);
insetEXTRA=dsetn;
dsetn=NULL;
}
}
// ****************************************************************
// ****************************************************************
// make arrays for tracking
// ****************************************************************
// ****************************************************************
// for temp storage array, just a multiple of longest dimension!
if(Dim[0] > Dim[1])
ArrMax = Dim[0] * 4;
else
ArrMax = Dim[1] * 4;
if(4*Dim[2] > ArrMax)
ArrMax = Dim[2] * 4;
ROI1 = (int *)calloc(Nvox, sizeof(int));
ROI2 = (int *)calloc(Nvox, sizeof(int));
temp_arr = (short int *)calloc(Nvox, sizeof(short int));
temp_byte = (char *)calloc(Nvox, sizeof(char));
// temp storage whilst tracking
Tforw = calloc(ArrMax, sizeof(Tforw));
for(i=0 ; i<ArrMax ; i++)
Tforw[i] = calloc(3, sizeof(int));
Ttot = calloc(2*ArrMax , sizeof(Ttot));
for(i=0 ; i<2*ArrMax ; i++)
Ttot[i] = calloc(3, sizeof(int));
Tback = calloc(ArrMax, sizeof(Tback));
for(i=0 ; i<ArrMax ; i++)
Tback[i] = calloc(3, sizeof(int));
// temp storage whilst tracking, physical loc
flTforw = calloc(ArrMax, sizeof(flTforw));
for(i=0 ; i<ArrMax ; i++)
flTforw[i] = calloc(3, sizeof(int));
flTback = calloc(ArrMax,sizeof(flTback));
for(i=0 ; i<ArrMax ; i++)
flTback[i] = calloc(3, sizeof(int));
if( (ROI1 == NULL) || (ROI2 == NULL) || (temp_arr == NULL)
|| (Tforw == NULL) || (Tback == NULL) || (flTforw == NULL)
|| (flTback == NULL) || (Ttot == NULL)) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(12);
}
coorded = (float ****) calloc( Dim[0], sizeof(float ***) );
for ( i = 0 ; i < Dim[0] ; i++ )
coorded[i] = (float ***) calloc( Dim[1], sizeof(float **) );
for ( i = 0 ; i < Dim[0] ; i++ )
for ( j = 0 ; j < Dim[1] ; j++ )
coorded[i][j] = (float **) calloc( Dim[2], sizeof(float *) );
for ( i=0 ; i<Dim[0] ; i++ )
for ( j=0 ; j<Dim[1] ; j++ )
for ( k= 0 ; k<Dim[2] ; k++ ) //3 comp of V1 and FA
coorded[i][j][k] = (float *) calloc( 4, sizeof(float) );
INDEX = (int ****) calloc( Dim[0], sizeof(int ***) );
for ( i = 0 ; i < Dim[0] ; i++ )
INDEX[i] = (int ***) calloc( Dim[1], sizeof(int **) );
for ( i = 0 ; i < Dim[0] ; i++ )
for ( j = 0 ; j < Dim[1] ; j++ )
INDEX[i][j] = (int **) calloc( Dim[2], sizeof(int *) );
for ( i=0 ; i<Dim[0] ; i++ )
for ( j=0 ; j<Dim[1] ; j++ )
for ( k= 0 ; k<Dim[2] ; k++ )
INDEX[i][j][k] = (int *) calloc( 4, sizeof(int) );
// this statement will never be executed if allocation fails above
if( (INDEX == NULL) || (coorded == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(122);
}
for(i=0 ; i<Nvox ; i++) {
if(THD_get_voxel( mset1, i, 0) >0.5){
ROI1[i] = 1;
}
if(THD_get_voxel( mset2, i, 0) >0.5)
ROI2[i] = 1;
}
// set up eigvecs in 3D coord sys,
// mark off where ROIs are and keep index handy
idx=0;
for( k=0 ; k<Dim[2] ; k++ )
for( j=0 ; j<Dim[1] ; j++ )
for( i=0 ; i<Dim[0] ; i++ ) {
for( m=0 ; m<3 ; m++ )
coorded[i][j][k][m] = THD_get_voxel(insetV1, idx, m);
if(EXTRAFILE)
coorded[i][j][k][3] = THD_get_voxel(insetEXTRA, idx, 0);
else
coorded[i][j][k][3] = THD_get_voxel(insetFA, idx, 0);
// make sure that |V1| == 1 for all eigenvects, otherwise it's
/// a problem in the tractography; currently, some from
// 3dDWItoDT do not have this property...
tempvmagn = sqrt(coorded[i][j][k][0]*coorded[i][j][k][0]+
coorded[i][j][k][1]*coorded[i][j][k][1]+
coorded[i][j][k][2]*coorded[i][j][k][2]);
if( tempvmagn<0.99 )
for( m=0 ; m<3 ; m++ )
coorded[i][j][k][m]/= tempvmagn;
INDEX[i][j][k][0] =idx; // first value is the index itself
if( ROI1[idx]==1 )
INDEX[i][j][k][1]=1; // second value identifies ROI1 mask
else
INDEX[i][j][k][1]=0;
if( ROI2[idx]==1 )
INDEX[i][j][k][2]=1; // third value identifies ROI2 mask
else
INDEX[i][j][k][2]=0;
// fourth value will be counter for number of kept tracks
// passing through
INDEX[i][j][k][3] = 0;
idx+= 1;
}
// *************************************************************
// *************************************************************
// Beginning of main loop
// *************************************************************
// *************************************************************
Numtract = 0;
ave_tract_len = 0.;
ave_tract_len_phys = 0.;
sprintf(OUT_bin,"%s.trk",prefix);
if( (fout0 = fopen(OUT_bin, "w")) == NULL) {
fprintf(stderr, "Error opening file %s.",OUT_bin);
exit(16);
}
fwrite(&header1,sizeof(tv_io_header),1,fout0);
if (get_tract_verb()) {
INFO_message("Begin tracking...");
}
tb = AppCreateBundle(NULL, 0, NULL, insetFA); // start bundle
id = 0;
for( k=0 ; k<Dim[2] ; k++ )
for( j=0 ; j<Dim[1] ; j++ )
for( i=0 ; i<Dim[0] ; i++ )
if(coorded[i][j][k][3] >= MinFA) {
for( ii=0 ; ii<SeedPerV[0] ; ii++ )
for( jj=0 ; jj<SeedPerV[1] ; jj++ )
for( kk=0 ; kk<SeedPerV[2] ; kk++ ) {
in[0] = i;
in[1] = j;
in[2] = k;
physin[0] = ((float) in[0] +
(0.5 + (float) ii)/SeedPerV[0])*Ledge[0];
physin[1] = ((float) in[1] +
(0.5 + (float) jj)/SeedPerV[1])*Ledge[1];
physin[2] = ((float) in[2] +
(0.5 + (float) kk)/SeedPerV[2])*Ledge[2];
len_forw = TrackIt(coorded, in, physin, Ledge, Dim,
MinFA, MaxAng, ArrMax, Tforw,
flTforw, 1, phys_forw);
// reset, because it's changed in TrackIt func
in[0] = i;
in[1] = j;
in[2] = k;
physin[0] = ((float) in[0] +
(0.5 + (float) ii)/SeedPerV[0])*Ledge[0];
physin[1] = ((float) in[1] +
(0.5 + (float) jj)/SeedPerV[1])*Ledge[1];
physin[2] = ((float) in[2] +
(0.5 + (float) kk)/SeedPerV[2])*Ledge[2];
len_back = TrackIt(coorded, in, physin, Ledge, Dim,
MinFA, MaxAng, ArrMax, Tback,
flTback, -1, phys_back);
KEEPIT = 0; // a simple switch
totlen = len_forw+len_back-1; // NB: overlap of starts
totlen_phys = phys_forw[0] + phys_back[0];
if( totlen_phys >= MinL ) {
// glue together for simpler notation later
for( n=0 ; n<len_back ; n++) { // all of this
rr = len_back-n-1; // read in backward
for(m=0;m<3;m++)
Ttot[rr][m] = Tback[n][m];
}
for( n=1 ; n<len_forw ; n++){// skip first->overlap
rr = n+len_back-1; // put after
for(m=0;m<3;m++)
Ttot[rr][m] = Tforw[n][m];
}
// <<So close and orthogonal condition>>:
// test projecting ends, to see if they abut ROI.
for(m=0;m<3;m++) {
//actual projected ends
end[1][m] = 2*Ttot[totlen-1][m]-Ttot[totlen-2][m];
end[0][m] = 2*Ttot[0][m]-Ttot[1][m];
// default choice, just retest known ends
// as default
test_ind[1][m] = test_ind[0][m] = Ttot[0][m];
}
tt = Create_Tract(len_back, flTback, len_forw,
flTforw, id, insetFA); ++id;
if (LOG_TYPE == -1) {
KEEPIT = 1;
} else {
inroi1 = 0;
// check forw
for( n=0 ; n<len_forw ; n++) {
if(INDEX[Tforw[n][0]][Tforw[n][1]][Tforw[n][2]][1]==1){
inroi1 = 1;
break;
} else
continue;
}
if( inroi1==0 ){// after 1st half, check 2nd half
for( m=0 ; m<len_back ; m++) {
if(INDEX[Tback[m][0]][Tback[m][1]][Tback[m][2]][1]==1){
inroi1 = 1;
break;
} else
continue;
}
}
// after 1st&2nd halves, check bound/neigh
if( inroi1==0 ) {
if(INDEX[test_ind[1][0]][test_ind[1][1]][test_ind[1][2]][1]==1)
inroi1 = 1;
if(INDEX[test_ind[0][0]][test_ind[0][1]][test_ind[0][2]][1]==1)
inroi1 = 1;
}
if( ((LOG_TYPE ==0) && (inroi1 ==0)) ||
((LOG_TYPE ==1) && (inroi1 ==1))) {
// have to check in ROI2
inroi2 = 0;
// check forw
for( n=0 ; n<len_forw ; n++) {
if(INDEX[Tforw[n][0]][Tforw[n][1]][Tforw[n][2]][2]==1){
inroi2 = 1;
break;
} else
continue;
}
//after 1st half, check 2nd half
if( inroi2==0 ) {
for( m=0 ; m<len_back ; m++) {
if(INDEX[Tback[m][0]][Tback[m][1]][Tback[m][2]][2]==1){
inroi2 = 1;
break;
} else
continue;
}
}
// after 1st&2nd halves, check bound/neigh
if( inroi2==0 ) {
if(INDEX[test_ind[1][0]][test_ind[1][1]][test_ind[1][2]][2]==1)
inroi2 = 1;
if(INDEX[test_ind[0][0]][test_ind[0][1]][test_ind[0][2]][2]==1)
inroi2 = 1;
}
// for both cases, need to see it here to keep
if( inroi2 ==1 )
KEEPIT = 1; // otherwise, it's gone
} else if((LOG_TYPE ==0) && (inroi1 ==1))
KEEPIT = 1;
}
}
// by now, we *know* if we're keeping this or not.
if( KEEPIT == 1 ) {
tb = AppCreateBundle(tb, 1, tt, NULL);
tt = Free_Tracts(tt, 1);
READS_in = totlen;
fwrite(&READS_in,sizeof(READS_in),1,fout0);
for( n=0 ; n<len_back ; n++) {
//put this one in backwords, to make it connect
m = len_back - 1 - n;
for(aa=0 ; aa<3 ; aa++) {
// recenter phys loc for trackvis, if nec...
// just works this way (where they define
// origin)
READS_fl = flTback[m][aa];
if(!TV_switch[aa])
READS_fl = Ledge[aa]*Dim[aa]-READS_fl;
fwrite(&READS_fl,sizeof(READS_fl),1,fout0);
}
mm = INDEX[Tback[m][0]][Tback[m][1]][Tback[m][2]][0];
READS_fl =THD_get_voxel(insetFA, mm, 0); // FA
fwrite(&READS_fl,sizeof(READS_fl),1,fout0);
READS_fl =THD_get_voxel(insetMD, mm, 0); // MD
fwrite(&READS_fl,sizeof(READS_fl),1,fout0);
READS_fl =THD_get_voxel(insetL1, mm, 0); // L1
fwrite(&READS_fl,sizeof(READS_fl),1,fout0);
// count this voxel for having a tract
INDEX[Tback[m][0]][Tback[m][1]][Tback[m][2]][3]+= 1;
}
for( m=1 ; m<len_forw ; m++) {
for(aa=0 ; aa<3 ; aa++) {
// recenter phys loc for trackvis, if nec...
READS_fl = flTforw[m][aa];
if(!TV_switch[aa])
READS_fl = Ledge[aa]*Dim[aa]-READS_fl;
fwrite(&READS_fl,sizeof(READS_fl),1,fout0);
}
mm = INDEX[Tforw[m][0]][Tforw[m][1]][Tforw[m][2]][0];
READS_fl =THD_get_voxel(insetFA, mm, 0); // FA
fwrite(&READS_fl,sizeof(READS_fl),1,fout0);
READS_fl =THD_get_voxel(insetMD, mm, 0); // MD
fwrite(&READS_fl,sizeof(READS_fl),1,fout0);
READS_fl =THD_get_voxel(insetL1, mm, 0); // L1
fwrite(&READS_fl,sizeof(READS_fl),1,fout0);
// count this voxel for having a tract
INDEX[Tforw[m][0]][Tforw[m][1]][Tforw[m][2]][3]+= 1;
}
ave_tract_len+= totlen;
ave_tract_len_phys+= totlen_phys;
Numtract+=1;
}
}
}
fclose(fout0);
if (get_tract_verb()) {
INFO_message("Done tracking, have %d tracks.", tb->N_tracts);
Show_Taylor_Bundle(tb, NULL, 3);
}
if (!Write_Bundle(tb,prefix,mode)) {
ERROR_message("Failed to write the bundle");
}
// **************************************************************
// **************************************************************
// Some simple stats on ROIs and outputs
// **************************************************************
// **************************************************************
for( k=0 ; k<Dim[2] ; k++ )
for( j=0 ; j<Dim[1] ; j++ )
for( i=0 ; i<Dim[0] ; i++ ) {
if( INDEX[i][j][k][3]>=1 ) {
tempMD = THD_get_voxel(insetMD,INDEX[i][j][k][0],0);
tempFA = THD_get_voxel(insetFA,INDEX[i][j][k][0],0);
tempL1 = THD_get_voxel(insetL1,INDEX[i][j][k][0],0);
tempRD = 0.5*(3*tempMD-tempL1);
roi3_mu_MD+= tempMD;
roi3_mu_FA+= tempFA;
roi3_mu_L1+= tempL1;
roi3_mu_RD+= tempRD;
roi3_sd_MD+= tempMD*tempMD;
roi3_sd_FA+= tempFA*tempFA;
roi3_sd_L1+= tempL1*tempL1;
roi3_sd_RD+= tempRD*tempRD;
roi3_ct+= 1;
}
}
if(roi3_ct > 0 ) { // !!!! make into afni file
roi3_mu_MD/= (float) roi3_ct;
roi3_mu_FA/= (float) roi3_ct;
roi3_mu_L1/= (float) roi3_ct;
roi3_mu_RD/= (float) roi3_ct;
roi3_sd_MD-= roi3_ct*roi3_mu_MD*roi3_mu_MD;
roi3_sd_FA-= roi3_ct*roi3_mu_FA*roi3_mu_FA;
roi3_sd_L1-= roi3_ct*roi3_mu_L1*roi3_mu_L1;
roi3_sd_RD-= roi3_ct*roi3_mu_RD*roi3_mu_RD;
roi3_sd_MD/= (float) roi3_ct-1;
roi3_sd_FA/= (float) roi3_ct-1;
roi3_sd_L1/= (float) roi3_ct-1;
roi3_sd_RD/= (float) roi3_ct-1;
roi3_sd_MD = sqrt(roi3_sd_MD);
roi3_sd_FA = sqrt(roi3_sd_FA);
roi3_sd_L1 = sqrt(roi3_sd_L1);
roi3_sd_RD = sqrt(roi3_sd_RD);
sprintf(OUT_tracstat,"%s.stats",prefix);
if( (fout0 = fopen(OUT_tracstat, "w")) == NULL) {
fprintf(stderr, "Error opening file %s.",OUT_tracstat);
exit(19);
}
fprintf(fout0,"%d\t%d\n",Numtract,roi3_ct);
fprintf(fout0,"%.3f\t%.3f\n",ave_tract_len/Numtract,
ave_tract_len_phys/Numtract);
// as usual, these next values would have to be divided by the
// bval to get their actual value in standard phys units
fprintf(fout0,"%.4f\t%.4f\n",roi3_mu_FA,roi3_sd_FA);
fprintf(fout0,"%.4f\t%.4f\n",roi3_mu_MD,roi3_sd_MD);
fprintf(fout0,"%.4f\t%.4f\n",roi3_mu_RD,roi3_sd_RD);
fprintf(fout0,"%.4f\t%.4f\n",roi3_mu_L1,roi3_sd_L1);
fclose(fout0);
sprintf(prefix_map,"%s_MAP",prefix);
sprintf(prefix_mask,"%s_MASK",prefix);
outsetMAP = EDIT_empty_copy( mset1 ) ;
EDIT_dset_items( outsetMAP ,
ADN_datum_all , MRI_short ,
ADN_prefix , prefix_map ,
ADN_none ) ;
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outsetMAP)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outsetMAP));
outsetMASK = EDIT_empty_copy( mset1 ) ;
EDIT_dset_items( outsetMASK ,
ADN_datum_all , MRI_byte ,
ADN_prefix , prefix_mask ,
ADN_none ) ;
if(!THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outsetMASK)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outsetMASK));
m=0;
for( k=0 ; k<Dim[2] ; k++ )
for( j=0 ; j<Dim[1] ; j++ )
for( i=0 ; i<Dim[0] ; i++ ) {
temp_arr[m]=INDEX[i][j][k][3];
if(temp_arr[m]>0.5)
temp_byte[m]=1;
else
temp_byte[m]=0;
m++;
}
// re-orient the data as original inputs
// (this function copies the pointer)
EDIT_substitute_brick(outsetMAP, 0, MRI_short, temp_arr);
temp_arr=NULL;
if(TV_switch[0] || TV_switch[1] || TV_switch[2]) {
dsetn = r_new_resam_dset(outsetMAP, NULL, 0.0, 0.0, 0.0,
header1.voxel_order, RESAM_NN_TYPE,
NULL, 1, 0);
DSET_delete(outsetMAP);
outsetMAP=dsetn;
dsetn=NULL;
}
EDIT_dset_items( outsetMAP ,
ADN_prefix , prefix_map ,
ADN_none ) ;
THD_load_statistics(outsetMAP );
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outsetMAP)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outsetMAP));
tross_Make_History( "3dTrackID" , argc , argv , outsetMAP) ;
THD_write_3dim_dataset(NULL, NULL, outsetMAP, True);
// re-orient the data as original inputs
EDIT_substitute_brick(outsetMASK, 0, MRI_byte, temp_byte);
temp_byte=NULL;
if(TV_switch[0] || TV_switch[1] || TV_switch[2]) {
dsetn = r_new_resam_dset(outsetMASK, NULL, 0.0, 0.0, 0.0,
header1.voxel_order, RESAM_NN_TYPE,
NULL, 1, 0);
DSET_delete(outsetMASK);
outsetMASK=dsetn;
dsetn=NULL;
}
EDIT_dset_items( outsetMASK ,
ADN_prefix , prefix_mask ,
ADN_none ) ;
THD_load_statistics(outsetMASK);
if(!THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(outsetMASK)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(outsetMASK));
tross_Make_History( "3dTrackID" , argc , argv , outsetMASK) ;
THD_write_3dim_dataset(NULL, NULL, outsetMASK, True);
INFO_message("Number of tracts found = %d",Numtract) ;
}
else
INFO_message("\n No Tracts Found!!!\n");
// ************************************************************
// ************************************************************
// Freeing
// ************************************************************
// ************************************************************
// !!! need to free afni-sets?
DSET_delete(insetFA);
DSET_delete(insetMD);
DSET_delete(insetL1);
DSET_delete(insetV1);
DSET_delete(insetEXTRA);
//DSET_delete(outsetMAP);
//DSET_delete(outsetMASK);
DSET_delete(mset2);
DSET_delete(mset1);
free(prefix);
free(insetV1);
free(insetFA);
free(mset1);
free(mset2);
free(insetEXTRA);
free(ROI1);
free(ROI2);
free(temp_byte);
for( i=0 ; i<ArrMax ; i++) {
free(Tforw[i]);
free(Tback[i]);
free(flTforw[i]);
free(flTback[i]);
}
free(Tforw);
free(Tback);
free(flTforw);
free(flTback);
for( i=0 ; i<Dim[0] ; i++)
for( j=0 ; j<Dim[1] ; j++)
for( k=0 ; k<Dim[2] ; k++)
free(coorded[i][j][k]);
for( i=0 ; i<Dim[0] ; i++)
for( j=0 ; j<Dim[1] ; j++)
free(coorded[i][j]);
for( i=0 ; i<Dim[0] ; i++)
free(coorded[i]);
free(coorded);
for( i=0 ; i<Dim[0] ; i++)
for( j=0 ; j<Dim[1] ; j++)
for( k=0 ; k<Dim[2] ; k++)
free(INDEX[i][j][k]);
for( i=0 ; i<Dim[0] ; i++)
for( j=0 ; j<Dim[1] ; j++)
free(INDEX[i][j]);
for( i=0 ; i<Dim[0] ; i++)
free(INDEX[i]);
free(INDEX);
free(temp_arr); // need to free
for( i=0 ; i<2*ArrMax ; i++)
free(Ttot[i]);
free(Ttot);
//free(mode);
return 0;
}
int main(int argc, char *argv[]) {
int i, k, ii;
int iarg;
char *prefix=NULL;
char *maskname=NULL;
char *gradsname=NULL;
char *dtsname=NULL;
THD_3dim_dataset *MASK=NULL;
THD_3dim_dataset *DTS=NULL;
MRI_IMAGE *GRADS=NULL, *GRADS_IN=NULL;
int Ngrads=0, Nfull=0;
int Nvox=-1; // tot number vox
int Dim[3]={0,0,0}; // dim in each dir
float NOISESCALE_DWI = -1.;
float NOISESCALE_B0 = -1;
float S0 = 1000.;
float bval = 1.;
int NOISE_IN_S0 = 0;
byte *mskd2=NULL; // not great, but another format of mask
float **dwi=NULL;
THD_3dim_dataset *DWI_OUT=NULL;
const gsl_rng_type * T;
gsl_rng *r;
long seed;
srand(time(0));
seed = time(NULL) ;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc (T);
gsl_rng_set (r, seed);
// ###################################################################
// ######################### load ##################################
// ###################################################################
mainENTRY("3dDTtoNoisyDWI"); machdep();
if (argc == 1) { usage_DTtoNoisyDWI(1); exit(0); }
iarg = 1;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-help") == 0 ||
strcmp(argv[iarg],"-h") == 0 ) {
usage_DTtoNoisyDWI(strlen(argv[iarg])>3 ? 2:1);
exit(0);
}
if( strcmp(argv[iarg],"-dt_in") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-eig_vecs'");
dtsname = strdup(argv[iarg]) ;
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],"-mask") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-mask'");
maskname = strdup(argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-grads") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-mask'");
gradsname = strdup(argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-noise_DWI") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need numerical argument after '-noise_DWI'");
NOISESCALE_DWI = atof(argv[iarg]);
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-noise_B0") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need numerical argument after '-noise_B0'");
NOISESCALE_B0 = atof(argv[iarg]);
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-S0") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need numerical argument after '-S0'");
S0 = atof(argv[iarg]);
if(S0 <= 0 )
ERROR_exit("The '-S0' value must be >0.");
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-bval") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need numerical argument after '-bval'");
bval = atof(argv[iarg]);
if(bval <= 0 )
ERROR_exit("The '-bval' value must be >0.");
iarg++ ; continue ;
}
ERROR_message("Bad option '%s'\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
// ###################################################################
// #################### some checks ###############################
// ###################################################################
if(!prefix)
ERROR_exit("Need to give a '-prefix'.");
if(!dtsname)
ERROR_exit("Need to input diffusion tensor file after '-dt_in'.");
if(!gradsname)
ERROR_exit("Need to input gradient file after '-grads'.");
if( NOISESCALE_DWI<0 )
ERROR_exit("Fractional noise value after '-snr0' needs to be >0. "
"It sets the noise scale of ref signal S0.");
if(NOISESCALE_DWI > 0)
INFO_message("You have chosen an SNR0 of approximately %.2f for DWIs",
1./NOISESCALE_DWI);
else
INFO_message("You have noiseless (i.e., infinite SNR) set of DWIs");
if( NOISESCALE_B0 < 0 )
NOISESCALE_B0 = NOISESCALE_DWI;
if(NOISESCALE_B0 > 0)
INFO_message("You have chosen an SNR0 of approximately %.2f for the B0",
1./NOISESCALE_B0);
else
INFO_message("You have noiseless (i.e., infinite SNR) reference B0.");
// ###################################################################
if(dtsname) {
DTS = THD_open_dataset(dtsname);
DSET_load(DTS); CHECK_LOAD_ERROR(DTS);
if( 6 != DSET_NVALS(DTS) )
ERROR_exit("DT file '%s' must have 6 bricks-- "
"it has %d bricks!",
dtsname, DSET_NVALS(DTS));
}
Nvox = DSET_NVOX(DTS);
Dim[0] = DSET_NX(DTS);
Dim[1] = DSET_NY(DTS);
Dim[2] = DSET_NZ(DTS);
if(Nvox<0)
ERROR_exit("Error reading Nvox from eigenvalue file.");
mskd2 = (byte *)calloc(Nvox,sizeof(byte));
if( (mskd2 == NULL)) {
fprintf(stderr, "\n\n MemAlloc failure (masks).\n\n");
exit(122);
}
if(maskname) {
MASK = THD_open_dataset(maskname);
DSET_load(MASK); CHECK_LOAD_ERROR(MASK);
if( 1 != DSET_NVALS(MASK) )
ERROR_exit("Mask file '%s' is not scalar-- "
"it has %d bricks!",
maskname, DSET_NVALS(MASK));
for( k=0 ; k<Nvox ; k++ )
if (THD_get_voxel(MASK, k, 0) > 0 )
mskd2[k] = 1;
DSET_delete(MASK);
free(MASK);
free(maskname);
}
else {
for( k=0 ; k<Nvox ; k++ )
if( fabs(THD_get_voxel(DTS,k,0) > EPS_V) )
mskd2[k] = 1;
}
GRADS_IN = mri_read_1D (gradsname);
GRADS = mri_transpose(GRADS_IN); // get rid of autotranspose...
if (GRADS == NULL)
ERROR_exit("Error reading gradient vector file");
mri_free(GRADS_IN);
Ngrads = GRADS->ny;
if(Ngrads < 6)
ERROR_exit("Too few grads (there appear to be only %d).",Ngrads);
if(GRADS->nx !=3 )
ERROR_exit("Wrong number of columns in the grad file: "
" am reading %d instead of 3.",GRADS->nx);
Nfull = Ngrads+1;
INFO_message("Have surmised there are %d total grads; "
"output file will have %d bricks", Ngrads,Nfull);
dwi = calloc(Nfull,sizeof(dwi));
for(i=0 ; i<Nfull ; i++)
dwi[i] = calloc( Nvox,sizeof(float));
INFO_message("Calculating the DWIs.");
i = RicianNoiseDWIs( dwi, Nvox, Ngrads, DTS,
NOISESCALE_DWI, NOISESCALE_B0,
GRADS, mskd2,
S0, bval, r);
INFO_message("Writing the DWIs.");
DWI_OUT = EDIT_empty_copy( DTS );
EDIT_dset_items(DWI_OUT,
ADN_nvals, Nfull,
ADN_datum_all, MRI_float ,
ADN_prefix, prefix,
ADN_none );
for( i=0; i<Nfull ; i++) {
EDIT_substitute_brick(DWI_OUT, i, MRI_float, dwi[i]);
dwi[i]=NULL;
}
THD_load_statistics( DWI_OUT );
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(DWI_OUT)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(DWI_OUT));
tross_Make_History("3dDTtoNoisyDWI", argc, argv, DWI_OUT);
THD_write_3dim_dataset(NULL, NULL, DWI_OUT, True);
DSET_delete(DWI_OUT);
free(DWI_OUT);
// #################################################################
// ########################## free ###############################
// #################################################################
DSET_delete(DTS);
free(DTS);
for( i=0 ; i<Nfull ; i++)
free(dwi[i]);
free(dwi);
free(prefix);
free(gradsname);
free(dtsname);
mri_free(GRADS);
return 0;
}
int main( int argc , char * argv[] )
{
THD_3dim_dataset *mask_dset=NULL, *iset=NULL,
*sset=NULL, *xset=NULL, *vset=NULL;
char *prefix="toy";
int iarg=1 , mcount, udatum = MRI_float;
byte *maskvox=NULL;
mainENTRY("3dToyProg main"); machdep(); AFNI_logger("3dToyProg",argc,argv);
#ifdef USING_MCW_MALLOC
enable_mcw_malloc() ;
#endif
/*-- options --*/
set_obliquity_report(0); /* silence obliquity */
while( iarg < argc && argv[iarg][0] == '-' ){
CHECK_HELP(argv[iarg], help_3dToyProg);
if( strncmp(argv[iarg],"-mask",5) == 0 ){
if (iarg >= argc) ERROR_exit("Need dset after -mask");
mask_dset = THD_open_dataset( argv[++iarg] ) ;
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");
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-input") == 0) {
if (iarg >= argc) ERROR_exit("Need dset after -mask");
if (!(iset = THD_open_dataset( argv[++iarg]))) {
ERROR_exit("Cannot open input dataset %s!\n", argv[iarg]) ;
}
DSET_mallocize(iset); DSET_load(iset); /* load data part of dataset */
iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-prefix",6) == 0) {
if (iarg >= argc) ERROR_exit("Need name after -prefix");
prefix = argv[++iarg];
iarg++ ; continue ;
continue ;
}
if( strcmp(argv[iarg],"-datum") == 0) {
if (iarg >= argc) ERROR_exit("Need datum type after -datum");
++iarg;
if (!strcmp(argv[iarg],"float")) udatum = MRI_float;
else if (!strcmp(argv[iarg],"short")) udatum = MRI_short;
else {
ERROR_exit(
"For the purpose of this demo, only float and short are allowed");
}
iarg++ ; continue ;
continue ;
}
ERROR_message("ILLEGAL option: %s\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
if( argc < 2 ){
help_3dToyProg(TXT, 0);
PRINT_COMPILE_DATE ; exit(0) ;
}
if( !iset )
ERROR_exit("No dataset on command line!?") ;
if (mask_dset) {
if (THD_dataset_mismatch(mask_dset, iset))
ERROR_exit("grid mismatch between input dset and mask dset");
maskvox = THD_makemask( mask_dset , 0 , 1.0, -1.0 ) ;
mcount = THD_countmask( DSET_NVOX(mask_dset) , maskvox ) ;
if( mcount <= 0 ) ERROR_exit("No voxels in the mask!\n") ;
INFO_message("%d voxels in the mask dset %s\n",
mcount, DSET_PREFIX(mask_dset)) ;
DSET_delete(mask_dset) ; mask_dset=NULL; /* Done with the mask dset */
}
/* An illustration of how volume navigation works */
Dataset_Navigation(iset);
/* Let us create a dataset from scratch */
sset = New_Dataset_From_Scratch(prefix);
/* Now for the output, add history, check for overwrite and write away */
tross_Copy_History( iset , sset );/* Copy the old history (not mandatory). */
tross_Make_History("3dToyProg", argc, argv ,sset) ; /* add the new */
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(sset)) ) {
ERROR_message(
"Output %s already exists, use -overwrite to do you know what",
DSET_HEADNAME(sset));
} else DSET_write(sset);
/* Now we'll do some voxelwise computations */
xset = Voxelwise_Operations(sset, maskvox, prefix);
tross_Copy_History( iset , xset ) ; /* Copy the old */
tross_Make_History("3dToyProg", argc, argv ,xset) ; /* add the new */
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(xset)) ) {
ERROR_message(
"Output %s already exists, use -overwrite to do you know what",
DSET_HEADNAME(xset));
} else DSET_write(xset);
/* Or some volumewise operations */
vset = Volumewise_Operations(sset, prefix, udatum);
tross_Copy_History( iset , vset ) ; /* Copy the old */
tross_Make_History("3dToyProg", argc, argv ,vset) ; /* add the new */
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(vset)) ) {
ERROR_message(
"Output %s already exists, use -overwrite to do you know what",
DSET_HEADNAME(vset));
} else DSET_write(vset);
/* cleanup */
DSET_delete(xset); xset = NULL;
DSET_delete(vset); vset = NULL;
DSET_delete(sset); sset = NULL;
exit(0) ;
}
int main(int argc, char *argv[])
{
int CHECK = 0;
int iarg;
char *Fname_input = NULL;
char *Fname_output = NULL;
char *Fname_outputBV = NULL;
char *Fname_bval = NULL;
int opt;
FILE *fin=NULL, *fout=NULL, *finbv=NULL, *foutBV=NULL;
int i,j,k;
int BZER=0,idx=0,idx2=0;
MRI_IMAGE *flim=NULL;
MRI_IMAGE *preREADIN=NULL;
MRI_IMAGE *preREADBVAL=NULL;
float *READIN=NULL;
float *READBVAL=NULL;
float OUT_MATR[MAXGRADS][7]; // b- or g-matrix
float OUT_GRAD[MAXGRADS][4]; // b- or g-matrix
int INV[3] = {1,1,1}; // if needing to switch
int FLAG[MAXGRADS];
float temp;
int YES_B = 0;
int EXTRA_ZEROS=0;
int HAVE_BVAL = 0;
int BVAL_OUT = 0;
int BVAL_OUT_SEP = 0;
float BMAX_REF = 1; // i.e., essentially zero
int IN_FORM = 0; // 0 for row, 1 for col
int OUT_FORM = 1; // 1 for col, 2 for bmatr
int HAVE_BMAX_REF=0 ; // referring to user input value
int count_in=0, count_out=0;
THD_3dim_dataset *dwset=NULL, *dwout=NULL;
int Nbrik = 0;
char *prefix=NULL ;
float **temp_arr=NULL, **temp_grad=NULL;
int Ndwi = 0, dwi=0, Ndwout = 0, Ndwi_final = 0, Ndwout_final = 0;
int Nvox = 0;
int DWI_COMP_FAC = 0;
int ct_dwi = 0;
float MaxDP = 0;
mainENTRY("1dDW_Grad_o_Mat"); machdep();
if (argc == 1) { usage_1dDW_Grad_o_Mat(1); exit(0); }
iarg = 1;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-help") == 0 ||
strcmp(argv[iarg],"-h") == 0 ) {
usage_1dDW_Grad_o_Mat(strlen(argv[iarg])>3 ? 2:1);
exit(0);
}
if( strcmp(argv[iarg],"-flip_x") == 0) {
INV[0] = -1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-flip_y") == 0) {
INV[1] = -1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-flip_z") == 0) {
INV[2] = -1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-keep_b0s") == 0) {
YES_B = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-put_zeros_top") == 0) {
EXTRA_ZEROS = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_grad_rows") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_grad_rows'\n") ;
Fname_input = argv[iarg];
count_in++;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_grad_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_grad_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_gmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matT_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 2;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_gmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matA_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 3;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_bmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matT_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 4;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_bmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matA_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 5;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_grad_rows") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_grad_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 0;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_grad_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_grad_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_gmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_gmatT_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 2;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_gmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_gmatA_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 3;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_bmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_bmatT_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 4;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_bmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_bmatA_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 5;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_bvals") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_bvals'\n") ;
Fname_bval = argv[iarg];
HAVE_BVAL = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-bmax_ref") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-bmax_ref'\n");
BMAX_REF = atof(argv[iarg]);
HAVE_BMAX_REF = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_bval_col") == 0) {
BVAL_OUT = 1;
iarg++ ; continue ;
}
// May,2015
if( strcmp(argv[iarg],"-out_bval_row_sep") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_bval_row_sep'\n") ;
Fname_outputBV = argv[iarg];
BVAL_OUT_SEP = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-proc_dset") == 0 ){ // in DWIs
if( ++iarg >= argc )
ERROR_exit("Need argument after '-proc_dset'") ;
dwset = THD_open_dataset( argv[iarg] ) ;
if( dwset == NULL )
ERROR_exit("Can't open DWI dataset '%s'", argv[iarg]) ;
DSET_load(dwset) ; CHECK_LOAD_ERROR(dwset) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-pref_dset") == 0 ){ // will be output
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-pref_dset'");
prefix = strdup(argv[iarg]) ;
if( !THD_filename_ok(prefix) )
ERROR_exit("Illegal name after '-pref_dset'");
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-dwi_comp_fac") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-dwi_comp_fac'\n");
DWI_COMP_FAC = atoi(argv[iarg]);
if (DWI_COMP_FAC <=1)
ERROR_exit("The compression factor after '-dwi_comp_fac'"
"must be >1!");
iarg++ ; continue ;
}
ERROR_message("Bad option '%s'\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * *
if( (Fname_input == NULL) ) {
fprintf(stderr,
"\n\tBad Command-lining! Option '-in_*' requires argument.\n");
exit(1);
}
if( (Fname_output == NULL) ) {
fprintf(stderr,
"\n\tBad Command-lining! Option '-out_*' requires arg.\n");
exit(2);
}
if( count_in > 1 ) {
fprintf(stderr,
"\n\tBad Command-lining! Can't have >1 vec file input.\n");
exit(3);
}
if( count_out > 1 ) {
fprintf(stderr,
"\n\tBad Command-lining! Can't have >1 output file opt.\n");
exit(4);
}
if(YES_B && dwset) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Can't have '-keep_b0s' and '-proc_dset' together.\n");
exit(5);
}
if( !prefix && dwset) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Need an output '-pref_dset' when using '-proc_dset'.\n");
exit(6);
}
if(YES_B && DWI_COMP_FAC) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Can't have '-keep_b0s' and '-dwi_comp_fac' together.\n");
exit(7);
}
if(!HAVE_BVAL && (BVAL_OUT || BVAL_OUT_SEP)) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Can't have ask for outputting bvals with no '-in_bvals FILE'.\n");
exit(8);
}
// ********************************************************************
// ************************* start reading ****************************
// ********************************************************************
flim = mri_read_1D (Fname_input);
if (flim == NULL) {
ERROR_exit("Error reading gradient vector file");
}
if( IN_FORM )
preREADIN = mri_transpose(flim); // effectively *undoes* autotranspose
else
preREADIN = mri_copy(flim);
mri_free(flim);
idx = preREADIN->ny;
if( HAVE_BVAL ) {
flim = mri_read_1D (Fname_bval);
if (flim == NULL) {
ERROR_exit("Error reading b-value file");
}
if( flim->ny == 1)
preREADBVAL = mri_transpose(flim); // effectively *undoes* autotransp
else
preREADBVAL = mri_copy(flim);
mri_free(flim);
idx2 = preREADBVAL->ny;
}
if(idx>= MAXGRADS ) {
printf("Error, too many input grads.\n");
mri_free (preREADIN);
if( HAVE_BVAL ) mri_free (preREADBVAL);
exit(4);
}
if( ( (preREADIN->nx != 3 ) && (preREADIN->ny != 3 )) &&
(preREADIN->nx != 6 ) )
printf("Probably an error, "
"because there aren't 3 or 6 numbers in columns!\n");
if( HAVE_BVAL && ( idx != idx2 ) ) {
printf("Error, because the number of bvecs (%d)\n"
"and bvals (%d) don't appear to match!\n", idx, idx2);
mri_free (preREADIN);
mri_free (preREADBVAL);
exit(3);
}
if(dwset) {
Nbrik = DSET_NVALS(dwset);
if( idx != Nbrik ) {
fprintf(stderr,
"\n** ERROR: the number of bvecs (%d) does not match the "
"number of briks in '-proc_dset' (%d).\n", idx, Nbrik);
exit(4);
}
}
READIN = MRI_FLOAT_PTR( preREADIN );
if( HAVE_BVAL )
READBVAL = MRI_FLOAT_PTR( preREADBVAL );
// 0 is grad row;
// 1 is grad col;
// 2 is gmatrRow col T;
// 3 is gmatrDiag col A;
// 4 is bmatrRow col T;
// 5 is bmatrDiag col A;
//if( IN_FORM == 0 ) // grad rows, no binfo
// for( i=0; i<idx ; i++ )
// for ( j=0; j<3 ; j++ )
// OUT_GRAD[i][j+1] = *(READIN +j*idx +i) ;
//else
if ( IN_FORM <= 1 ) // grad cols, no binfo
for( i=0; i<idx ; i++ )
for ( j=0; j<3 ; j++ )
OUT_GRAD[i][j+1] = *(READIN + 3*i+j);
// A/row/3dDWItoDT: Bxx, Byy, Bzz, Bxy, Bxz, Byz
// T/diag/TORTOISE: b_xx 2b_xy 2b_xz b_yy 2b_yz b_zz
else if ( (IN_FORM == 3) || (IN_FORM ==5 ) ) { // diag matr
for( i=0; i<idx ; i++ ) {
for( j=0; j<3 ; j++ ) {
OUT_MATR[i][j+1] = *(READIN+6*i+j);
OUT_MATR[i][3+j+1] = *(READIN+6*i+3+j);
}
for( j=0; j<3 ; j++ )
if(OUT_MATR[i][j] < 0 )
CHECK++;
}
if(CHECK > 0)
INFO_message("Warning: you *said* you input a mat'T',"
" but the matr diagonals don't appear to be uniformly"
" positive. If input cols 0, 3 and 5 are positive,"
" then you might have meant mat'A'?");
}
else if ( (IN_FORM ==2 ) || (IN_FORM ==4 ) ) { // row matr
CHECK = 0;
for( i=0; i<idx ; i++ ) {
OUT_MATR[i][1] = *(READIN +6*i);
OUT_MATR[i][2] = *(READIN +6*i+3);
OUT_MATR[i][3] = *(READIN +6*i+5);
OUT_MATR[i][4] = *(READIN +6*i+1)/2.;
OUT_MATR[i][5] = *(READIN +6*i+2)/2.;
OUT_MATR[i][6] = *(READIN +6*i+4)/2.;
}
for( i=0; i<idx ; i++ )
for( j=0; j<3 ; j++ )
if(OUT_MATR[i][j] < 0 )
CHECK++;
if(CHECK > 0)
INFO_message("Warning: you *said* you input a mat'A',"
" but the matr diagonals don't appear to be uniformly"
" positive. If input cols 0, 1 and 2 are positive,"
" then you might have meant mat'T'?");
}
else{
fprintf(stderr, "Coding error with format number (%d), not allowed.\n",
IN_FORM);
exit(2);
}
// get bval info
if( ( (IN_FORM ==4 ) || (IN_FORM ==5 ) ) ) { //bval
for( i=0; i<idx ; i++ ) {
OUT_MATR[i][0] = OUT_GRAD[i][0] =
OUT_MATR[i][1] + OUT_MATR[i][2] + OUT_MATR[i][3];
if( OUT_MATR[i][0] > 0.000001)
for( j=1 ; j<7 ; j++ )
OUT_MATR[i][j]/= OUT_MATR[i][0];
}
}
else if ( HAVE_BVAL )
for( i=0; i<idx ; i++ ) {
OUT_MATR[i][0] = OUT_GRAD[i][0] = *(READBVAL + i);
}
else if ( OUT_FORM > 3 || BVAL_OUT || BVAL_OUT_SEP || HAVE_BMAX_REF ) {
fprintf(stderr, "ERROR: you asked for b-value dependent output, "
"but gave me no bvals to work with.\n");
exit(2);
}
// * * * ** * * * * * * * * ** ** * * ** * * ** * ** * ** * * *
// at this point, all IN_FORM >1 cases which need bval have led to:
// + grad[0] has bval
// + matr[0] has bval
// + matr file normalized and in diagonal form
// * * * ** * * * * * * * * ** ** * * ** * * ** * ** * ** * * *
for( i=0; i<idx ; i++ )
if( IN_FORM > 1)
j = GradConv_Gsign_from_BmatA( OUT_GRAD[i]+1, OUT_MATR[i]+1);
else
j = GradConv_BmatA_from_Gsign( OUT_MATR[i]+1, OUT_GRAD[i]+1);
// flip if necessary
for( i=0 ; i<idx ; i++) {
for( j=0 ; j<3 ; j++)
OUT_GRAD[i][j+1]*= INV[j];
OUT_MATR[i][4]*= INV[0]*INV[1];
OUT_MATR[i][5]*= INV[0]*INV[2];
OUT_MATR[i][6]*= INV[1]*INV[2];
}
BZER=0;
for( i=0 ; i<idx ; i++) {
if( HAVE_BVAL || (IN_FORM ==4) || (IN_FORM ==5) )
if( OUT_GRAD[i][0] >= BMAX_REF )
FLAG[i] = 1;
else{
if( YES_B )
FLAG[i] = 1;
BZER++;
}
else {
temp = 0.;
for( j=1 ; j<4 ; j++)
temp+= pow(OUT_GRAD[i][j],2);
if( temp > 0.1 )
FLAG[i] = 1;
else{
if( YES_B )
FLAG[i] = 1;
BZER++;
}
}
}
if(YES_B) {
printf("\tChose to *keep* %d b0s,\tas well as \t%d grads\n",
BZER,idx-BZER);
BZER=0;
}
else {
printf("\tGetting rid of %d b0s,\tleaving the %d grads\n",
BZER,idx-BZER);
Ndwi = idx-BZER;
}
Ndwi_final = idx-BZER; // default: all DWIs
if( DWI_COMP_FAC ) {
if( Ndwi % DWI_COMP_FAC != 0 ) {
fprintf(stderr, "\n** ERROR can't compress: "
"Ndwi=%d, and %d/%d has a nonzero remainder (=%d).\n",
Ndwi,Ndwi,DWI_COMP_FAC, Ndwi % DWI_COMP_FAC );
exit(1);
}
else {
Ndwi_final = Ndwi/DWI_COMP_FAC;
INFO_message("You have chosen a compression factor of %d, "
"with %d DWIs,\n"
"\tso that afterward there will be %d DWIs.",
DWI_COMP_FAC, Ndwi, Ndwi_final);
}
}
if(BVAL_OUT_SEP)
if( (foutBV = fopen(Fname_outputBV, "w")) == NULL) {
fprintf(stderr, "\n\nError opening file %s.\n",Fname_outputBV);
exit(1);
}
if( (fout = fopen(Fname_output, "w")) == NULL) {
fprintf(stderr, "\n\nError opening file %s.\n",Fname_output);
exit(1);
}
// 0 is grad row;
// 1 is grad col;
// 2 is gmatrRow col T;
// 3 is gmatrDiag col A;
// 4 is bmatrRow col T;
// 5 is bmatrDiag col A;
if( OUT_FORM>0) {
if( EXTRA_ZEROS ) {
if( BVAL_OUT )
fprintf(fout,"%8d ", 0);
if( BVAL_OUT_SEP )
fprintf(foutBV,"%8d ", 0);
if( OUT_FORM == 1 )
for( k=1 ; k<4 ; k++ )
fprintf(fout,"%11.5f ", 0.0);
else if ( OUT_FORM > 1 ) // bit superfluous at this point
for( k=1 ; k<7 ; k++ )
fprintf(fout,"%11.5f ", 0.0);
fprintf(fout,"\n");
}
ct_dwi = 0;
for(i=0 ; i<idx ; i++){
if(FLAG[i]) {
if( BVAL_OUT )
fprintf(fout,"%8d ", (int) OUT_GRAD[i][0]);
if( BVAL_OUT_SEP )
fprintf(foutBV,"%8d ", (int) OUT_GRAD[i][0]);
if( (OUT_FORM == 4) || (OUT_FORM ==5) )
for( k=1 ; k<7 ; k++ )
OUT_MATR[i][k]*= OUT_MATR[i][0];
if( OUT_FORM == 1 ) // grad col
for( k=1 ; k<4 ; k++ )
fprintf(fout,"%11.5f ", OUT_GRAD[i][k]);
else if( (OUT_FORM == 3) || (OUT_FORM == 5) ) { // gmat
for( k=1 ; k<6 ; k++ )
fprintf(fout,"%11.5f ", OUT_MATR[i][k]);
fprintf(fout,"%11.5f", OUT_MATR[i][k]);
}
else if ( (OUT_FORM == 2 ) || (OUT_FORM ==4)) { // bmat
fprintf(fout,"%11.5f ", OUT_MATR[i][1]);
fprintf(fout,"%11.5f ", 2*OUT_MATR[i][4]);
fprintf(fout,"%11.5f ", 2*OUT_MATR[i][5]);
fprintf(fout,"%11.5f ", OUT_MATR[i][2]);
fprintf(fout,"%11.5f ", 2*OUT_MATR[i][6]);
fprintf(fout,"%11.5f", OUT_MATR[i][3]);
}
fprintf(fout,"\n");
ct_dwi++;
}
if( (ct_dwi == Ndwi_final) && DWI_COMP_FAC ) {
INFO_message("Reached compression level: DWI number %d",
Ndwi_final);
break;
}
}
}
else if(OUT_FORM ==0) {
if(BVAL_OUT)
WARNING_message("Ignoring '-out_bval_col' option, since "
" you are outputting in rows.");
for( k=1 ; k<4 ; k++ ) {
if(EXTRA_ZEROS){
fprintf(fout,"% -11.5f ", 0.0);
if( (k==1) && BVAL_OUT_SEP ) // only output 1 zeroin bval file
fprintf(foutBV,"%8d ", 0);
}
ct_dwi = 0;
for(i=0 ; i<idx ; i++) {
if(FLAG[i]) {
fprintf(fout,"% -11.5f ", OUT_GRAD[i][k]);
if( (k==1) && BVAL_OUT_SEP )// only output 1 zeroin bval file
fprintf(foutBV,"%8d ", (int) OUT_GRAD[i][0]);
ct_dwi++;
}
if( (ct_dwi == Ndwi_final) && DWI_COMP_FAC ) {
INFO_message("Reached compression level: DWI number %d",
Ndwi_final);
break;
}
}
fprintf(fout,"\n");
}
}
fclose(fout);
if( BVAL_OUT_SEP ) {
fprintf(foutBV,"\n");
fclose(foutBV);
}
if(dwset) {
INFO_message("Processing the B0+DWI file now.");
if(!BZER) {
fprintf(stderr, "\n** Error in processing data set: "
"no b=0 values from bvecs/bval info!\n");
exit(5);
}
// FLAG marks where DWIs are if not using '-keep_b0s'!
Nvox = DSET_NVOX(dwset);
Ndwout = Ndwi+1;
temp_arr = calloc( Ndwout,sizeof(temp_arr));
for( i=0 ; i<Ndwout ; i++)
temp_arr[i] = calloc( Nvox,sizeof(float));
temp_grad = calloc( Ndwi,sizeof(temp_grad));
for( i=0 ; i<Ndwi ; i++)
temp_grad[i] = calloc( 3,sizeof(float));
if( (temp_arr == NULL) || (temp_grad == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(123);
}
dwi = 0; // keep track of DWI contraction
for( i=0 ; i<Nbrik ; i++)
if( !FLAG[i] ) // b=0
for( j=0 ; j<Nvox ; j++)
temp_arr[0][j]+= THD_get_voxel(dwset,j,i);
else {
for( j=0 ; j<3 ; j++)
temp_grad[dwi][j]= OUT_GRAD[i][j+1];
dwi++;
for( j=0 ; j<Nvox ; j++)
temp_arr[dwi][j]+= THD_get_voxel(dwset,j,i);
}
if( dwi != Ndwi ) {
fprintf(stderr, "\n** Mismatch in internal DWI counting!\n");
exit(6);
}
// average the values
for( j=0 ; j<Nvox ; j++)
temp_arr[0][j]/= BZER; // can't be zero here.
if( DWI_COMP_FAC ) {
INFO_message("Compressing DWI file");
for( k=1 ; k<DWI_COMP_FAC ; k++)
for( i=0 ; i<Ndwi_final ; i++)
for( j=0 ; j<Nvox ; j++)
temp_arr[1+i][j]+= temp_arr[1+k*Ndwi_final+i][j];
for( i=0 ; i<Ndwi_final ; i++)
for( j=0 ; j<Nvox ; j++)
temp_arr[1+i][j]/= DWI_COMP_FAC;
INFO_message("Checking closeness of compressed gradient values");
MaxDP = GradCloseness(temp_grad, Ndwi, DWI_COMP_FAC);
INFO_message("The max angular difference between matched/compressed\n"
"\tgradients is: %f", MaxDP);
if( MaxDP > 2)
WARNING_message("The max angular difference seem kinda big-- you\n"
" sure about the compression factor?");
}
Ndwout_final = Ndwi_final + 1;
INFO_message("Writing the processed data set.");
dwout = EDIT_empty_copy( dwset );
EDIT_dset_items(dwout,
ADN_nvals, Ndwout_final,
ADN_ntt, 0,
ADN_datum_all, MRI_float ,
ADN_prefix, prefix,
ADN_none );
for( i=0; i<Ndwout_final ; i++) {
EDIT_substitute_brick(dwout, i, MRI_float, temp_arr[i]);
temp_arr[i]=NULL;
}
// if necessary
for( i=Ndwout_final ; i<Ndwout ; i++)
temp_arr[i]=NULL;
THD_load_statistics( dwout );
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(dwout)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(dwout));
tross_Make_History("1dDW_Grad_o_Mat", argc, argv, dwout);
THD_write_3dim_dataset(NULL, NULL, dwout, True);
DSET_delete(dwout);
free(dwout);
DSET_delete(dwset);
free(dwset);
for( i=0 ; i<Ndwout_final ; i++)
free(temp_arr[i]);
free(temp_arr);
}
mri_free(preREADIN);
if( HAVE_BVAL )
mri_free(preREADBVAL);
if(prefix)
free(prefix);
printf("\n\tDone. Check output file '%s' for results",Fname_output);
if(dwset) {
printf("\n\t-> as well as the data_set '%s'",DSET_FILECODE(dwout));
}
if(BVAL_OUT_SEP)
printf("\n\t-> and even the b-value rows '%s'",Fname_outputBV);
printf("\n\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;
}
