/*
* for each input dataset name
* open (check dims, etc.)
* dilate (zeropad, make binary, dilate, unpad, apply)
* fill list of bytemask datasets
*
* also, count total volumes
*/
int process_input_dsets(param_t * params)
{
THD_3dim_dataset * dset, * dfirst=NULL;
int iset, nxyz;
ENTRY("process_input_dsets");
if( !params ) ERROR_exit("NULL inputs to PID");
if( params->ndsets <= 0 ) {
ERROR_message("process_input_dsets: no input datasets");
RETURN(1);
}
/* allocate space for dsets array */
params->dsets = (THD_3dim_dataset **)malloc(params->ndsets*
sizeof(THD_3dim_dataset*));
if( !params->dsets ) ERROR_exit("failed to allocate dset pointers");
if( params->verb ) INFO_message("processing %d input datasets...",
params->ndsets);
/* warn user of dilations */
if(params->verb && params->ndsets) {
int pad = needed_padding(¶ms->IND);
INFO_message("padding all datasets by %d (for dilations)", pad);
}
/* process the datasets */
nxyz = 0;
for( iset=0; iset < params->ndsets; iset++ ) {
/* open and verify dataset */
dset = THD_open_dataset(params->inputs[iset]);
if( !dset ) ERROR_exit("failed to open mask dataset '%s'",
params->inputs[iset]);
DSET_load(dset); CHECK_LOAD_ERROR(dset);
if( params->verb>1 ) INFO_message("loaded dset %s, with %d volumes",
DSET_PREFIX(dset), DSET_NVALS(dset));
if( nxyz == 0 ) { /* make an empty copy of the first dataset */
nxyz = DSET_NVOX(dset);
dfirst = EDIT_empty_copy(dset);
}
/* check for consistency in voxels and grid */
if( DSET_NVOX(dset) != nxyz ) ERROR_exit("nvoxel mis-match");
if( ! EQUIV_GRIDS(dset, dfirst) )
WARNING_message("grid from dset %s does not match that of dset %s",
DSET_PREFIX(dset), DSET_PREFIX(dfirst));
/* apply dilations to all volumes, returning bytemask datasets */
params->dsets[iset] = apply_dilations(dset, ¶ms->IND,1,params->verb);
if( ! params->dsets[iset] ) RETURN(1);
}
DSET_delete(dfirst); /* and nuke */
RETURN(0);
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *dset ;
MRI_IMAGE *im ;
int iarg=1 ;
if( strcmp(argv[1],"-nper") == 0 ){
nper = strtol( argv[2] , NULL , 10 ) ;
iarg = 3 ;
}
for( ; iarg < argc ; iarg++ ){
printf("======= dataset %s nper=%d ========\n",argv[iarg],nper) ;
dset = THD_open_dataset(argv[iarg]) ;
if( dset == NULL ) continue ;
DSET_load(dset) ;
im = DSET_BRICK(dset,0) ;
im->dx = DSET_DX(dset) ;
im->dy = DSET_DY(dset) ;
im->dz = DSET_DZ(dset) ;
(void) THD_orient_guess( im ) ;
printf( "Data Axes Orientation:\n"
" first (x) = %s\n"
" second (y) = %s\n"
" third (z) = %s\n" ,
ORIENT_typestr[dset->daxes->xxorient] ,
ORIENT_typestr[dset->daxes->yyorient] ,
ORIENT_typestr[dset->daxes->zzorient] ) ;
DSET_delete(dset) ;
}
exit(0) ;
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *dset ; int aa,ll ; char *cpt ; float val ;
if( argc < 2 ){
printf("Usage: 3dSatCheck dataset [...]\n"
"\n"
"Prints the 'raw' initial transient (saturation) check\n"
"value for each dataset on the command line. Round this\n"
"number to the nearest integer to get an estimate of\n"
"how many non-saturated time points start a dataset.\n"
) ;
exit(0) ;
}
for( aa=1 ; aa < argc ; aa++ ){
dset = THD_open_dataset( argv[aa] ) ; if( !ISVALID_DSET(dset) ) continue ;
if( DSET_NVALS(dset) < 9 ) continue ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) continue ;
val = THD_saturation_check( dset , NULL , 0,0 ) ;
ll = strlen(argv[aa]) ;
cpt = (ll <= 50) ? argv[aa] : argv[aa]+(ll-50) ;
INFO_message("%-50.50s = %.3f",cpt,val) ;
DSET_delete(dset) ;
}
exit(0) ;
}
THD_3dim_dataset *Seg_load_dset_eng( char *set_name, char *view )
{
static char FuncName[]={"Seg_load_dset_eng"};
THD_3dim_dataset *dset=NULL, *sdset=NULL;
int i=0;
byte make_cp=0;
int verb=0;
char sprefix[THD_MAX_PREFIX+10], *stmp=NULL;
SUMA_ENTRY;
dset = THD_open_dataset( set_name );
if( !ISVALID_DSET(dset) ){
fprintf(stderr,"**ERROR: can't open dataset %s\n",set_name) ;
SUMA_RETURN(NULL);
}
DSET_mallocize(dset) ; DSET_load(dset);
for (i=0; i<DSET_NVALS(dset); ++i) {
if (DSET_BRICK_TYPE(dset,i) != MRI_short) {
if (verb) INFO_message("Sub-brick %d in %s not of type short.\n"
"Creating new short copy of dset ",
i, DSET_PREFIX(dset));
make_cp=1; break;
}
}
if (make_cp) {
if (!SUMA_ShortizeDset(&dset, -1.0)) {
SUMA_S_Err("**ERROR: Failed to shortize");
SUMA_RETURN(NULL);
}
}
if (DSET_IS_MASTERED(dset)) {
if (verb) INFO_message("Dset is mastered, making copy...");
stmp = SUMA_ModifyName(set_name, "append", ".cp", NULL);
sdset = dset;
dset = EDIT_full_copy(sdset, stmp);
free(stmp); DSET_delete(sdset); sdset = NULL;
}
if (view) {
if (view) {
if (!strstr(view,"orig"))
EDIT_dset_items(dset,ADN_view_type, VIEW_ORIGINAL_TYPE, ADN_none);
else if (!strstr(view,"acpc"))
EDIT_dset_items(dset,ADN_view_type, VIEW_ACPCALIGNED_TYPE, ADN_none);
else if (!strstr(view,"tlrc"))
EDIT_dset_items(dset ,ADN_view_type, VIEW_TALAIRACH_TYPE, ADN_none);
else SUMA_S_Errv("View of %s is rubbish", view);
}
}
SUMA_RETURN(dset);
}
int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"3dBRAIN_VOYAGERtoAFNI"};
SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_OPEN_DX_STRUCT **dx = NULL;
THD_3dim_dataset *dset=NULL;
char *sto3d = NULL;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
/* Allocate space for DO structure */
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
ps = SUMA_Parse_IO_Args(argc, argv, "");
if (argc < 2) {
usage_3dBRAIN_VOYAGERtoAFNI(ps);
exit (1);
}
Opt = SUMA_3dBRAIN_VOYAGERtoAFNI_ParseInput (argv, argc, ps);
if (Opt->debug > 2) LocalHead = YUP;
dset = EDIT_empty_copy( NULL ) ;
tross_Make_History( "3dBRAIN_VOYAGERtoAFNI" , argc,argv , dset) ;
if (!(sto3d = SUMA_BrainVoyager_Read_vmr(Opt->in_name, dset, 1, Opt->b2, Opt->b1, Opt->Icold, Opt->out_prefix))) {
if (Opt->debug) SUMA_SL_Err("Failed in SUMA_BrainVoyager_Read_vmr");
exit(1);
}
SUMA_LHv("Old command would be %s\n", sto3d);
if (dset) {
SUMA_LH("Writing Dset");
DSET_write(dset) ;
if (LocalHead) {
fprintf(SUMA_STDERR,"%s: Can use the following command to create dset with to3d:\n%s\n", FuncName,sto3d);
}
} else {
/* the olde way */
if (system(sto3d)) {
fprintf(SUMA_STDERR, "Error %s: Failed while executing shell command:\n%s\n"
"Check to3d's error messages, and disk writing permissions.\n", FuncName, sto3d);
}
}
if (sto3d) SUMA_free(sto3d); sto3d = NULL;
if (dset) { DSET_delete(dset); dset = NULL; }
if (Opt) Opt = SUMA_Free_Generic_Prog_Options_Struct(Opt);
if (!SUMA_Free_CommonFields(SUMAg_CF)) SUMA_error_message(FuncName,"SUMAg_CF Cleanup Failed!",1);
exit(0);
}
bytevec * THD_create_mask_from_string( char *str ) /* Jul 2010 */
{
bytevec *bvec=NULL ; int nstr ; char *buf=NULL ;
ENTRY("THD_create_mask") ;
if( str == NULL || *str == '\0' ) RETURN(NULL) ;
nstr = strlen(str) ;
bvec = (bytevec *)malloc(sizeof(bytevec)) ;
/* try to read it as a dataset */
if( nstr < THD_MAX_NAME ){
THD_3dim_dataset *dset = THD_open_one_dataset(str) ;
if( dset != NULL ){
bvec->nar = DSET_NVOX(dset) ;
bvec->ar = THD_makemask( dset , 0 , 1.0f,0.0f ) ;
DSET_delete(dset) ;
if( bvec->ar == NULL ){
ERROR_message("Can't make mask from dataset '%s'",str) ;
free(bvec) ; bvec = NULL ;
}
RETURN(bvec) ;
}
}
/* if str is a filename, read that file;
otherwise, use the string itself to find the mask */
if( THD_is_file(str) ){
buf = AFNI_suck_file(str) ;
if( buf != NULL ) nstr = strlen(buf) ;
} else {
buf = str ;
}
/* try to read buf as a Base64 mask string */
if( strrchr(buf,'=') != NULL ){
int nvox ;
bvec->ar = mask_from_b64string( buf , &nvox ) ;
if( bvec->ar != NULL ){
bvec->nar = nvox ;
} else {
ERROR_message("Can't make mask from string '%.16s' %s",buf,(nstr<=16)?" ":"...") ;
free(bvec) ; bvec = NULL ;
}
} else {
ERROR_message("Don't understand mask string '%.16s'",buf,(nstr<=16)?" ":"...") ;
free(bvec) ; bvec = NULL ;
}
if( buf != str && buf != NULL ) free(buf) ;
RETURN(bvec) ;
}
void THD_load_tcat( THD_datablock *dblk )
{
int ivout , dd , iv ;
THD_3dim_dataset *dset_in , *dset_out ;
NI_str_array *sar ;
ENTRY("THD_load_tcat") ;
if( !ISVALID_DBLK(dblk) ) EXRETURN ;
dset_out = (THD_3dim_dataset *)dblk->parent ;
if( !ISVALID_DSET(dset_out) ) EXRETURN ;
sar = NI_decode_string_list( dset_out->tcat_list , "~" ) ;
if( sar == NULL ) EXRETURN ;
if( sar->num != dset_out->tcat_num ){ NI_delete_str_array(sar); EXRETURN; }
ivout = 0 ;
for( dd=0 ; dd < sar->num ; dd++ ){
dset_in = THD_open_dataset( sar->str[dd] ) ;
if( dset_in == NULL ){
NI_delete_str_array(sar) ; DSET_unload(dset_out) ;
EXRETURN ;
}
DSET_mallocize(dset_in) ; DSET_load(dset_in) ;
if( !DSET_LOADED(dset_in) ){
NI_delete_str_array(sar) ; DSET_unload(dset_out) ; DSET_delete(dset_in) ;
EXRETURN ;
}
for( iv=0 ; iv < DSET_NVALS(dset_in) ; iv++ ){
EDIT_substitute_brick( dset_out , ivout ,
DSET_BRICK_TYPE(dset_in,iv), DSET_ARRAY(dset_in,iv) );
mri_fix_data_pointer( NULL , DSET_BRICK(dset_in,iv) ) ;
EDIT_BRICK_FACTOR( dset_out , ivout , DSET_BRICK_FACTOR(dset_in,iv) ) ;
EDIT_BRICK_LABEL(dset_out, ivout,
DSET_BRICK_LABEL(dset_in, iv)); /* ZSS Aug. 27 2012 */
ivout++ ;
}
DSET_delete(dset_in) ;
}
NI_delete_str_array(sar) ; EXRETURN ;
}
/*--------------- main routine ---------------*/
int main( int argc, char *argv[] )
{
THD_3dim_dataset * countset=NULL;
param_t * params = &g_params;
int rv, limit;
if( argc < 1 ) { show_help(); return 0; }
/* general stuff */
mainENTRY("3dmask_tool"); machdep(); AFNI_logger("3dmask_tool",argc,argv);
enable_mcw_malloc();
/* process options: a negative return is considered an error */
rv = process_opts(params, argc, argv);
if( rv ) RETURN(rv < 0);
/* open, convert to byte, zeropad, dilate, unzeropad */
if( process_input_dsets(params) ) RETURN(1);
/* create mask count dataset and return num volumes (delete old dsets) */
if( count_masks(params->dsets, params->ndsets, params->verb,
&countset, ¶ms->nvols) ) RETURN(1);
/* limit to frac of nvols (if not counting, convert to 0/1 mask) */
limit = ceil((params->frac>1) ? params->frac : params->nvols*params->frac );
if( params->verb )
INFO_message("frac %g over %d volumes gives min count %d\n",
params->frac, params->nvols, limit);
if( limit <= 0 ) limit = 1;
/* if not counting, result is binary 0/1 */
if( limit_to_frac(countset, limit, params->count, params->verb) )
RETURN(1);
/* maybe apply dilations to output */
if( params->RESD.num > 0 ) {
countset = apply_dilations(countset, ¶ms->RESD, 0, params->verb);
if( !countset ) RETURN(1);
}
/* maybe fill any remaining holes */
if( params->fill )
if ( fill_holes(countset, params->verb) ) RETURN(1);
/* create output */
if( write_result(params, countset, argc, argv) ) RETURN(1);
/* clean up a little memory */
DSET_delete(countset);
free(params->dsets);
RETURN(0);
}
int SUMA_ShortizeDset(THD_3dim_dataset **dsetp, float thisfac) {
static char FuncName[]={"SUMA_ShortizeDset"};
char sprefix[THD_MAX_PREFIX+10];
int i, j;
byte *bb=NULL;
short *sb=NULL;
float bbf=0.0;
THD_3dim_dataset *cpset=NULL, *dset=*dsetp;
SUMA_ENTRY;
if (!dset) {
SUMA_S_Err("NULL *dsetp at input!");
SUMA_RETURN(0);
}
sprintf(sprefix, "%s.s", dset->dblk->diskptr->prefix);
NEW_SHORTY(dset, DSET_NVALS(dset), "ss.cp", cpset);
for (i=0; i<DSET_NVALS(dset); ++i) {
if (DSET_BRICK_TYPE(dset,i) == MRI_byte) {
bb = (byte *)DSET_ARRAY(dset,i);
sb = (short *)DSET_ARRAY(cpset,i);
if (thisfac <= 0.0) {
for (j=0; j<DSET_NVOX(dset); ++j) {
sb[j] = (short)bb[j];
}
thisfac = DSET_BRICK_FACTOR(dset,i);
} else {
bbf = DSET_BRICK_FACTOR(dset,i); if (bbf == 0.0f) bbf = 1.0;
bbf = bbf/thisfac;
for (j=0; j<DSET_NVOX(dset); ++j) {
sb[j] = SHORTIZE((((float)bb[j])*bbf));
}
}
EDIT_BRICK_FACTOR( cpset,i,thisfac ) ;
} else {
EDIT_substscale_brick(cpset, i, DSET_BRICK_TYPE(dset,i),
DSET_ARRAY(dset,i), MRI_short, thisfac);
if (DSET_BRICK_TYPE(dset,i) != MRI_short) {
DSET_FREE_ARRAY(dset, i);
} else {
DSET_NULL_ARRAY(dset, i);
}
}
}
/* preserve tables, if any */
THD_copy_labeltable_atr( cpset->dblk, dset->dblk);
DSET_delete(dset); dset = NULL;
*dsetp=cpset;
SUMA_RETURN(1);
}
int fill_mask(options_t * opts)
{
THD_3dim_dataset * mset;
int nvox;
ENTRY("fill_mask");
if( opts->automask ) {
if( opts->verb ) INFO_message("creating automask...");
opts->mask = THD_automask(opts->inset);
if( ! opts->mask ) {
ERROR_message("failed to apply -automask");
RETURN(1);
}
RETURN(0);
}
if( opts->mask_name ) {
if( opts->verb )
INFO_message("reading mask dset from %s...", opts->mask_name);
mset = THD_open_dataset( opts->mask_name );
if( ! mset ) ERROR_exit("cannot open mask dset '%s'", opts->mask_name);
nvox = DSET_NVOX(opts->inset);
if( DSET_NVOX(mset) != nvox ) {
ERROR_message("mask does not have the same voxel count as input");
RETURN(1);
}
/* fill mask array and mask_nxyz, remove mask dset */
DSET_load(mset); CHECK_LOAD_ERROR(mset);
opts->mask = THD_makemask(mset, 0, 1, 0);
DSET_delete(mset);
if( ! opts->mask ) {
ERROR_message("cannot make mask from '%s'", opts->mask_name);
RETURN(1);
}
if( opts->verb > 1 )
INFO_message("have mask with %d voxels", nvox);
}
RETURN(0);
}
/*
* create empty count dataset
* for each input dataset and each sub-volume
* for each voxel, if set: increment
* close datasets as they are processed
*/
int count_masks(THD_3dim_dataset * dsets[], int ndsets, int verb, /* inputs */
THD_3dim_dataset ** cset, int * nvol) /* outputs */
{
THD_3dim_dataset * dset;
short * counts = NULL; /* will become data for returned cset */
byte * bptr; /* always points to mask volumes */
int nxyz, iset, ivol, ixyz;
ENTRY("count_masks");
if( !dsets || !cset || !nvol )
ERROR_exit("NULL inputs to count_masks");
if( ndsets <= 0 ) {
ERROR_message("count_masks: no input datasets");
RETURN(1);
}
*nvol = 0;
nxyz = DSET_NVOX(dsets[0]);
/* allocate memory for the counts */
counts = (short *)calloc(nxyz, sizeof(short));
if( !counts ) ERROR_exit("failed to malloc %d shorts", nxyz);
/* for each volume of each dataset, count set voxels */
for( iset=0; iset < ndsets; iset++ ) {
dset = dsets[iset];
*nvol += DSET_NVALS(dset); /* accumulate num volumes */
/* for each volume in this dataset, count set voxels */
for( ivol=0; ivol < DSET_NVALS(dset); ivol++ ) {
if( DSET_BRICK_TYPE(dset, ivol) != MRI_byte )
ERROR_exit("in count_masks with non-byte data (set %d, vol %d)",
iset, ivol);
bptr = DBLK_ARRAY(dset->dblk, ivol);
for( ixyz = 0; ixyz < nxyz; ixyz++ )
if( bptr[ixyz] ) counts[ixyz]++;
}
if( iset > 0 ) DSET_delete(dset); /* close the first one at end */
} /* dataset */
if( verb > 1 ) {
int maxval;
for( maxval=counts[0], ixyz=1; ixyz < nxyz; ixyz++ )
if( counts[ixyz] > maxval ) maxval = counts[ixyz];
INFO_message("counted %d mask volumes in %d datasets (%d voxels)\n",
*nvol, ndsets, nxyz);
INFO_message(" (maximum overlap = %d)\n", maxval);
}
if( *nvol >= (1<<15) )
WARNING_message("too many volumes to count as shorts: %d", *nvol);
/* create output dataset */
*cset = EDIT_empty_copy(dsets[0]);
EDIT_dset_items(*cset, ADN_nvals, 1, ADN_ntt, 0, ADN_none);
EDIT_substitute_brick(*cset, 0, MRI_short, counts);
DSET_delete(dsets[0]); /* now finished with first dataset */
RETURN(0);
}
/*
* 1. zeropad (if needed for dilations)
* 2. make byte copy of dataset (if not already)
* 3. dilate (using binary mask)
* 4. if not converting, modify original data
* 5. undo any zeropad
* 6. return new dataset (might be same as old)
*
* dilations are passed as a list of +/- integers (- means erode)
*
* convert: flag specifying whether dset should be converted to MRI_byte
*
* note: the dilations list should not be long (does more than 2 even
* make any sense?), but here they will be treated generically
* - foreach dilation: dilate or erode, as specified by sign
*/
THD_3dim_dataset * apply_dilations(THD_3dim_dataset * dset, int_list * D,
int convert, int verb)
{
THD_3dim_dataset * dnew = NULL;
byte * bdata = NULL;
int index, ivol, id, dsize, datum, pad;
int nx, ny, nz, nvox;
ENTRY("apply_dilations");
if( !dset || !D ) ERROR_exit("missing inputs to apply_dilations");
/* note and apply any needed zeropadding */
pad = needed_padding(D);
if(verb > 3 && pad) INFO_message("padding by %d (for dilations)", pad);
if( pad ) dnew = THD_zeropad(dset, pad, pad, pad, pad, pad, pad, "pad", 0);
else dnew = dset;
/* note geometry */
nx = DSET_NX(dnew); ny = DSET_NY(dnew); nz = DSET_NZ(dnew);
nvox = nx*ny*nz;
/* now apply the actual dilations */
if(verb>1) INFO_message("applying dilation list to dataset");
for( ivol=0; ivol < DSET_NVALS(dnew); ivol++ ) {
datum = DSET_BRICK_TYPE(dnew, ivol);
/* if non-byte data (short/float), make byte mask of volume */
if( datum == MRI_byte )
bdata = DBLK_ARRAY(dnew->dblk, ivol);
else if ( datum == MRI_float || datum == MRI_short )
bdata = THD_makemask(dnew, ivol, 1, 0);
else {
ERROR_message("invalid datum for result: %d", datum);
RETURN(NULL);
}
if( !bdata ) {
ERROR_message("failed to make as mask");
RETURN(NULL);
}
for( index=0; index < D->num; index++ ) {
dsize = D->list[index];
if(verb>2) INFO_message("... dilating vol %d by %d\n", ivol, dsize);
if( dsize > 0 ) {
for( id=0; id < dsize; id++ )
THD_mask_dilate(nx, ny, nz, bdata, 1);
} else if( dsize < 0 ) {
for( id=0; id > dsize; id-- )
THD_mask_erode_sym(nx, ny, nz, bdata, 1);
}
}
/* if we are converting, just replace the old data */
if( convert && (datum == MRI_short || datum == MRI_float) ) {
if( verb > 2 ) INFO_message("applying byte result from dilate");
EDIT_substitute_brick(dnew, ivol, MRI_byte, bdata);
/* explicit set needed on an Fedora 8 system? 5 Jun 2012 */
DSET_BRICK_TYPE(dnew, ivol) = MRI_byte;
continue; /* so nothing more to do */
}
/* if short or float data, apply mask changes to data */
if( datum == MRI_short ) {
short * dptr = DBLK_ARRAY(dnew->dblk, ivol);
int nfill=0;
if( verb > 2 ) INFO_message("applying dilate result to short data");
for( index = 0; index < nvox; index++ )
if( ! dptr[index] && bdata[index] ){ dptr[index] = 1; nfill++; }
if( verb > 1 ) INFO_message("AD: filled %d voxels", nfill);
free(bdata);
}
else if( datum == MRI_float ) {
float * dptr = DBLK_ARRAY(dnew->dblk, ivol);
if( verb > 2 ) INFO_message("applying dilate result to float data");
for( index = 0; index < nvox; index++ )
if( ! dptr[index] && bdata[index] ) dptr[index] = 1.0;
free(bdata);
}
}
/* undo any zeropadding (delete original and temporary datasets) */
if( pad ) {
DSET_delete(dset);
dset = THD_zeropad(dnew, -pad, -pad, -pad, -pad, -pad, -pad, "pad", 0);
DSET_delete(dnew);
dnew = dset;
}
RETURN(dnew);
}
int main( int argc , char *argv[] )
{
int iarg , nerr=0 , nvals,nvox , nx,ny,nz , ii,jj,kk ;
char *prefix="LSSout" , *save1D=NULL , nbuf[256] ;
THD_3dim_dataset *inset=NULL , *outset ;
MRI_vectim *inset_mrv=NULL ;
byte *mask=NULL ; int mask_nx=0,mask_ny=0,mask_nz=0, automask=0, nmask=0 ;
NI_element *nelmat=NULL ; char *matname=NULL ;
char *cgl ;
int Ngoodlist,*goodlist=NULL , nfull , ncmat,ntime ;
NI_int_array *giar ; NI_str_array *gsar ; NI_float_array *gfar ;
MRI_IMAGE *imX, *imA, *imC, *imS ; float *Xar, *Sar ; MRI_IMARR *imar ;
int nS ; float *ss , *oo , *fv , sum ; int nvec , iv ;
int nbstim , nst=0 , jst_bot,jst_top ; char *stlab="LSS" ;
int nodata=1 ;
/*--- help me if you can ---*/
if( argc < 2 || strcasecmp(argv[1],"-HELP") == 0 ) LSS_help() ;
/*--- bureaucratic startup ---*/
PRINT_VERSION("3dLSS"); mainENTRY("3dLSS main"); machdep();
AFNI_logger("3dLSS",argc,argv); AUTHOR("RWCox");
(void)COX_clock_time() ;
/**------- scan command line --------**/
iarg = 1 ;
while( iarg < argc ){
if( strcmp(argv[iarg],"-verb") == 0 ){ verb++ ; iarg++ ; continue ; }
if( strcmp(argv[iarg],"-VERB") == 0 ){ verb+=2 ; iarg++ ; continue ; }
/**========== -mask ==========**/
if( strcasecmp(argv[iarg],"-mask") == 0 ){
THD_3dim_dataset *mset ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-mask'") ;
if( mask != NULL || automask ) ERROR_exit("Can't have two mask inputs") ;
mset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(mset,argv[iarg]) ;
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 '%.33s'",argv[iarg]) ;
nmask = THD_countmask( mask_nx*mask_ny*mask_nz , mask ) ;
if( verb || nmask < 1 ) INFO_message("Number of voxels in mask = %d",nmask) ;
if( nmask < 1 ) ERROR_exit("Mask is too small to process") ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-automask") == 0 ){
if( mask != NULL ) ERROR_exit("Can't have -automask and -mask") ;
automask = 1 ; iarg++ ; continue ;
}
/**========== -matrix ==========**/
if( strcasecmp(argv[iarg],"-matrix") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '%s'",argv[iarg-1]) ;
if( nelmat != NULL ) ERROR_exit("More than 1 -matrix option!?");
nelmat = NI_read_element_fromfile( argv[iarg] ) ; /* read NIML file */
matname = argv[iarg];
if( nelmat == NULL || nelmat->type != NI_ELEMENT_TYPE )
ERROR_exit("Can't process -matrix file '%s'!?",matname) ;
iarg++ ; continue ;
}
/**========== -nodata ===========**/
if( strcasecmp(argv[iarg],"-nodata") == 0 ){
nodata = 1 ; iarg++ ; continue ;
}
/**========== -input ==========**/
if( strcasecmp(argv[iarg],"-input") == 0 ){
if( inset != NULL ) ERROR_exit("Can't have two -input options!?") ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '%s'",argv[iarg-1]) ;
inset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
nodata = 0 ; iarg++ ; continue ;
}
/**========== -prefix =========**/
if( strcasecmp(argv[iarg],"-prefix") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '%s'",argv[iarg-1]) ;
prefix = strdup(argv[iarg]) ;
if( !THD_filename_ok(prefix) ) ERROR_exit("Illegal string after %s",argv[iarg-1]) ;
if( verb && strcmp(prefix,"NULL") == 0 )
INFO_message("-prefix NULL ==> no dataset will be written") ;
iarg++ ; continue ;
}
/**========== -save1D =========**/
if( strcasecmp(argv[iarg],"-save1D") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '%s'",argv[iarg-1]) ;
save1D = strdup(argv[iarg]) ;
if( !THD_filename_ok(save1D) ) ERROR_exit("Illegal string after %s",argv[iarg-1]) ;
iarg++ ; continue ;
}
/***** Loser User *****/
ERROR_message("Unknown option: %s",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
} /* end of loop over options */
/*----- check for errors -----*/
if( nelmat == NULL ){ ERROR_message("No -matrix option!?") ; nerr++ ; }
if( nerr > 0 ) ERROR_exit("Can't continue without these inputs!") ;
if( inset != NULL ){
nvals = DSET_NVALS(inset) ; nvox = DSET_NVOX(inset) ;
nx = DSET_NX(inset) ; ny = DSET_NY(inset) ; nz = DSET_NZ(inset) ;
} else {
automask = nvals = 0 ;
nvox = nx = ny = nz = nodata = 1 ; /* nodata */
mask = NULL ;
}
/*----- masque -----*/
if( mask != NULL ){ /* check -mask option for compatibility */
if( mask_nx != nx || mask_ny != ny || mask_nz != nz )
ERROR_exit("-mask dataset grid doesn't match input dataset :-(") ;
} else if( automask ){ /* create a mask from input dataset */
mask = THD_automask( inset ) ;
if( mask == NULL )
ERROR_message("Can't create -automask from input dataset :-(") ;
nmask = THD_countmask( nvox , mask ) ;
if( verb || nmask < 1 )
INFO_message("Number of voxels in automask = %d (out of %d = %.1f%%)",
nmask, nvox, (100.0f*nmask)/nvox ) ;
if( nmask < 1 ) ERROR_exit("Automask is too small to process") ;
} else if( !nodata ) { /* create a 'mask' for all voxels */
if( verb )
INFO_message("No mask ==> computing for all %d voxels",nvox) ;
mask = (byte *)malloc(sizeof(byte)*nvox) ; nmask = nvox ;
memset( mask , 1 , sizeof(byte)*nvox ) ;
}
/*----- get matrix info from the NIML element -----*/
if( verb ) INFO_message("extracting matrix info") ;
ncmat = nelmat->vec_num ; /* number of columns */
ntime = nelmat->vec_len ; /* number of rows */
if( ntime < ncmat+2 )
ERROR_exit("Matrix has too many columns (%d) for number of rows (%d)",ncmat,ntime) ;
/*--- number of rows in the full matrix (without censoring) ---*/
cgl = NI_get_attribute( nelmat , "NRowFull" ) ;
if( cgl == NULL ) ERROR_exit("Matrix is missing 'NRowFull' attribute!") ;
nfull = (int)strtod(cgl,NULL) ;
if( nodata ){
nvals = nfull ;
} else if( nvals != nfull ){
ERROR_exit("-input dataset has %d time points, but matrix indicates %d",
nvals , nfull ) ;
}
/*--- the goodlist = mapping from matrix row index to time index
(which allows for possible time point censoring) ---*/
cgl = NI_get_attribute( nelmat , "GoodList" ) ;
if( cgl == NULL ) ERROR_exit("Matrix is missing 'GoodList' attribute!") ;
giar = NI_decode_int_list( cgl , ";," ) ;
if( giar == NULL || giar->num < ntime )
ERROR_exit("Matrix 'GoodList' badly formatted?!") ;
Ngoodlist = giar->num ; goodlist = giar->ar ;
if( Ngoodlist != ntime )
ERROR_exit("Matrix 'GoodList' incorrect length?!") ;
else if( verb > 1 && Ngoodlist < nfull )
ININFO_message("censoring reduces time series length from %d to %d",nfull,Ngoodlist) ;
/*--- extract the matrix from the NIML element ---*/
imX = mri_new( ntime , ncmat , MRI_float ) ;
Xar = MRI_FLOAT_PTR(imX) ;
if( nelmat->vec_typ[0] == NI_FLOAT ){ /* from 3dDeconvolve_f */
float *cd ;
for( jj=0 ; jj < ncmat ; jj++ ){
cd = (float *)nelmat->vec[jj] ;
for( ii=0 ; ii < ntime ; ii++ ) Xar[ii+jj*ntime] = cd[ii] ;
}
} else if( nelmat->vec_typ[0] == NI_DOUBLE ){ /* from 3dDeconvolve */
double *cd ;
for( jj=0 ; jj < ncmat ; jj++ ){
cd = (double *)nelmat->vec[jj] ;
for( ii=0 ; ii < ntime ; ii++ ) Xar[ii+jj*ntime] = cd[ii] ;
}
} else {
ERROR_exit("Matrix file stored with illegal data type!?") ;
}
/*--- find the stim_times_IM option ---*/
cgl = NI_get_attribute( nelmat , "BasisNstim") ;
if( cgl == NULL ) ERROR_exit("Matrix doesn't have 'BasisNstim' attribute!") ;
nbstim = (int)strtod(cgl,NULL) ;
if( nbstim <= 0 ) ERROR_exit("Matrix 'BasisNstim' attribute is %d",nbstim) ;
for( jj=1 ; jj <= nbstim ; jj++ ){
sprintf(nbuf,"BasisOption_%06d",jj) ;
cgl = NI_get_attribute( nelmat , nbuf ) ;
if( cgl == NULL || strcmp(cgl,"-stim_times_IM") != 0 ) continue ;
if( nst > 0 )
ERROR_exit("More than one -stim_times_IM option was found in the matrix") ;
nst = jj ;
sprintf(nbuf,"BasisColumns_%06d",jj) ;
cgl = NI_get_attribute( nelmat , nbuf ) ;
if( cgl == NULL )
ERROR_exit("Matrix doesn't have %s attribute!",nbuf) ;
jst_bot = jst_top = -1 ;
sscanf(cgl,"%d:%d",&jst_bot,&jst_top) ;
if( jst_bot < 0 || jst_top < 0 )
ERROR_exit("Can't decode matrix attribute %s",nbuf) ;
if( jst_bot == jst_top )
ERROR_exit("Matrix attribute %s shows only 1 column for -stim_time_IM:\n"
" -->> 3dLSS is meant to be used when more than one stimulus\n"
" time was given, and then it computes the response beta\n"
" for each stim time separately. If you have only one\n"
" stim time with -stim_times_IM, you can use the output\n"
" dataset from 3dDeconvolve (or 3dREMLfit) to get that\n"
" single beta directly.\n" , nbuf ) ;
if( jst_bot >= jst_top || jst_top >= ncmat )
ERROR_exit("Matrix attribute %s has illegal value: %d:%d (ncmat=%d)",nbuf,jst_bot,jst_top,ncmat) ;
sprintf(nbuf,"BasisName_%06d",jj) ;
cgl = NI_get_attribute( nelmat , nbuf ) ;
if( cgl != NULL ) stlab = strdup(cgl) ;
if( verb > 1 )
ININFO_message("-stim_times_IM at stim #%d; cols %d..%d",jj,jst_bot,jst_top) ;
}
if( nst == 0 )
ERROR_exit("Matrix doesn't have any -stim_times_IM options inside :-(") ;
/*--- mangle matrix to segregate IM regressors from the rest ---*/
if( verb ) INFO_message("setting up LSS vectors") ;
imar = LSS_mangle_matrix( imX , jst_bot , jst_top ) ;
if( imar == NULL )
ERROR_exit("Can't compute LSS 'mangled' matrix :-(") ;
/*--- setup for LSS computations ---*/
imA = IMARR_SUBIM(imar,0) ;
imC = IMARR_SUBIM(imar,1) ;
imS = LSS_setup( imA , imC ) ; DESTROY_IMARR(imar) ;
if( imS == NULL )
ERROR_exit("Can't complete LSS setup :-((") ;
nS = imS->ny ; Sar = MRI_FLOAT_PTR(imS) ;
if( save1D != NULL ){
mri_write_1D( save1D , imS ) ;
if( verb ) ININFO_message("saved LSS vectors into file %s",save1D) ;
} else if( nodata ){
WARNING_message("-nodata used but -save1D not used ==> you get no output!") ;
}
if( nodata || strcmp(prefix,"NULL") == 0 ){
INFO_message("3dLSS ends since prefix is 'NULL' or -nodata was used") ;
exit(0) ;
}
/*----- create output dataset -----*/
if( verb ) INFO_message("creating output datset in memory") ;
outset = EDIT_empty_copy(inset) ;
EDIT_dset_items( outset ,
ADN_prefix , prefix ,
ADN_datum_all , MRI_float ,
ADN_brick_fac , NULL ,
ADN_nvals , nS ,
ADN_ntt , nS ,
ADN_none ) ;
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dLSS" , argc,argv , outset ) ;
for( kk=0 ; kk < nS ; kk++ ){
EDIT_substitute_brick( outset , kk , MRI_float , NULL ) ;
sprintf(nbuf,"%s#%03d",stlab,kk) ;
EDIT_BRICK_LABEL( outset , kk , nbuf ) ;
}
/*----- convert input dataset to vectim -----*/
if( verb ) INFO_message("loading input dataset into memory") ;
DSET_load(inset) ; CHECK_LOAD_ERROR(inset) ;
inset_mrv = THD_dset_to_vectim( inset , mask , 0 ) ;
DSET_unload(inset) ;
/*----- compute dot products, store results -----*/
if( verb ) INFO_message("computing away, me buckos!") ;
nvec = inset_mrv->nvec ;
for( kk=0 ; kk < nS ; kk++ ){
ss = Sar + kk*ntime ;
oo = DSET_ARRAY(outset,kk) ;
for( iv=0 ; iv < nvec ; iv++ ){
fv = VECTIM_PTR(inset_mrv,iv) ;
for( sum=0.0f,ii=0 ; ii < ntime ; ii++ )
sum += ss[ii] * fv[goodlist[ii]] ;
oo[inset_mrv->ivec[iv]] = sum ;
}
}
DSET_write(outset) ; WROTE_DSET(outset) ;
/*-------- Hasta la vista, baby --------*/
if( verb )
INFO_message("3dLSS finished: total CPU=%.2f Elapsed=%.2f",
COX_cpu_time() , COX_clock_time() ) ;
exit(0) ;
}
THD_3dim_dataset * THD_open_tcat( char *dlist )
{
THD_3dim_dataset *dset_out , **dset_in ;
int ndset_in , dd , nerr , new_nvals, sb=0 ;
NI_str_array *sar ;
double angle=0.0;
char *dp, *dlocal = dlist; /* local dlist, in case it is altered */
ENTRY("THD_open_tcat") ;
if( dlocal == NULL || *dlocal == '\0' ) RETURN(NULL) ;
/* allow file list to be read from a file 23 Jul 2012 [rickr] */
if( ! strncmp(dlocal, "filelist:", 9) ) {
dlocal = AFNI_suck_file(dlocal+9) ;
if ( ! dlocal ) {
ERROR_message("THD_open_tcat: failed to open '%s' as filelist",
dlocal+9);
RETURN(NULL) ;
}
/* make it look more like expected */
for( dd=0, dp=dlocal; dd < strlen(dlocal); dd++, dp++ )
if( *dp == '\n' || *dp == '\r' ) *dp = ' ';
}
if( strchr(dlocal,' ') == NULL ){
dset_out = THD_open_dataset(dlocal) ; RETURN(dset_out) ;
}
sar = NI_decode_string_list( dlocal , "~" ) ;
if( sar == NULL ) RETURN(NULL) ;
ndset_in = sar->num ;
dset_in = (THD_3dim_dataset **)malloc(sizeof(THD_3dim_dataset *)*sar->num) ;
for( nerr=dd=0 ; dd < ndset_in ; dd++ ){
dset_in[dd] = THD_open_dataset( sar->str[dd] ) ;
if( dset_in[dd] == NULL ){
fprintf(stderr,"** THD_open_tcat: can't open dataset %s\n",sar->str[dd]) ;
nerr++ ;
}
}
if( nerr > 0 ){
for( dd=0 ; dd < ndset_in ; dd++ )
if( dset_in[dd] != NULL ) DSET_delete(dset_in[dd]) ;
free((void *)dset_in) ;
NI_delete_str_array(sar) ;
RETURN(NULL) ;
}
if( ndset_in == 1 ){
dset_out = dset_in[0] ;
free((void *)dset_in) ;
NI_delete_str_array(sar) ;
RETURN(dset_out) ;
}
(void)THD_check_for_duplicates( sar->num , sar->str , 1 ) ; /* 31 May 2007 */
for( nerr=0,dd=1 ; dd < ndset_in ; dd++ ){
if( DSET_NX(dset_in[0]) != DSET_NX(dset_in[dd]) ||
DSET_NY(dset_in[0]) != DSET_NY(dset_in[dd]) ||
DSET_NZ(dset_in[0]) != DSET_NZ(dset_in[dd]) ){
ERROR_message(
"THD_open_tcat: %s [%dx%dx%d] doesn't match %s [%dx%dx%d]\n",
sar->str[0] ,DSET_NX(dset_in[0]) ,
DSET_NY(dset_in[0]) ,DSET_NZ(dset_in[0]) ,
sar->str[dd],DSET_NX(dset_in[dd]),
DSET_NY(dset_in[dd]),DSET_NZ(dset_in[dd]) ) ;
nerr++ ;
} else {
if( !EQUIV_DATAXES(dset_in[dd]->daxes,dset_in[0]->daxes) ){
WARNING_message(
"THD_open_tcat: %s grid mismatch with %s\n",
sar->str[0] , sar->str[dd] ) ; /* don't increment nerr! */
}
angle = dset_obliquity_angle_diff(dset_in[dd], dset_in[0], -1.0);
if (angle > 0.0) {
WARNING_message(
"dataset %s has an obliquity difference of %f degress with %s\n",
dset_in[dd] ,
angle, dset_in[0] );
}
}
}
if( nerr > 0 ){
for( dd=0 ; dd < ndset_in ; dd++ )
if( dset_in[dd] != NULL ) DSET_delete(dset_in[dd]) ;
free((void *)dset_in) ;
NI_delete_str_array(sar) ;
RETURN(NULL) ;
}
/*-- Check for type problems ZSS: Aug 27 2012 --*/
for (nerr=0,dd=0; dd < ndset_in ; dd++) {
for (sb=0; sb < DSET_NVALS(dset_in[dd]); ++sb) {
if ( DSET_BRICK_TYPE(dset_in[0],0) !=
DSET_BRICK_TYPE(dset_in[dd],sb) ) {
++nerr;
}
}
}
if (nerr > 0) { /* don't die, just complain */
WARNING_message(
"Command-line catenated dataset has %d sub-bricks that differ \n"
" in data type from the first sub-brick of the first set.\n"
" Mme Irma sees potential for grief if you go down that path. \n"
" Use 3dinfo -datum on each input to understand why this is happening.\n"
" You can use 3dcalc's -datum option to rewrite the dataset with \n"
" all sub-bricks set to the same type then start over.\n\n",
nerr);
nerr=0;
}
/*-- OK, start making new dataset --*/
new_nvals = 0 ;
for( dd=0 ; dd < ndset_in ; dd++ )
new_nvals += DSET_NVALS(dset_in[dd]) ;
for( dd=0 ; dd < ndset_in ; dd++ )
if( DSET_TIMESTEP(dset_in[dd]) > 0.0 ) break ; /* 1st 3D+time */
if( dd == ndset_in ) dd = 0 ;
dset_out = EDIT_empty_copy( dset_in[dd] ) ;
/* since this is basically an input dataset, set the storage_mode
* to match 27 Jul 2010 [rickr] */
if( DSET_ONDISK(dset_out) && IS_VALID_NON_AFNI_DSET(dset_in[dd]) )
THD_set_storage_mode(dset_out, dset_in[dd]->dblk->diskptr->storage_mode);
EDIT_dset_items( dset_out ,
ADN_prefix , "tcat" ,
ADN_func_type , ISANAT(dset_in[dd]) ? ANAT_EPI_TYPE
: FUNC_FIM_TYPE ,
ADN_ntt , new_nvals ,
ADN_nvals , new_nvals ,
ADN_none ) ;
DSET_mallocize( dset_out ) ;
/* check if we have a valid time axis; if not, make one up */
if( DSET_TIMESTEP(dset_out) <= 0.0f ){
float TR=1.0f , torg=0.0f , tdur=0.0f ;
int tunits=UNITS_SEC_TYPE ;
EDIT_dset_items( dset_out ,
ADN_tunits , tunits ,
ADN_ttdel , TR ,
ADN_ttorg , torg ,
ADN_ttdur , tdur ,
ADN_none ) ;
}
dset_out->tcat_list = strdup( dlocal ) ;
dset_out->tcat_num = ndset_in ;
dset_out->tcat_len = (int *)malloc(sizeof(int)*ndset_in) ;
for( dd=0 ; dd < ndset_in ; dd++ ){
dset_out->tcat_len[dd] = DSET_NVALS(dset_in[dd]) ;
DSET_delete(dset_in[dd]) ;
}
free((void *)dset_in) ;
NI_delete_str_array(sar) ;
#if 0
fprintf(stderr,"THD_open_tcat('%s'):",dset_out->tcat_list);
for(dd=0;dd<ndset_in;dd++)fprintf(stderr," %d",dset_out->tcat_len[dd]);
fprintf(stderr,"\n");
#endif
RETURN(dset_out) ;
}
int main( int argc , char *argv[] )
{
MRI_shindss *shd ;
int ids , nopt , kk ;
char *prefix = "EIC" ;
char *fname=NULL , *buf ;
MRI_vectim *mv ; THD_3dim_dataset *dset ;
/*--- official AFNI startup stuff ---*/
mainENTRY("3dExtractGroupInCorr"); machdep();
AFNI_logger("3dExtractGroupInCorr",argc,argv);
PRINT_VERSION("3dExtractGroupInCorr"); AUTHOR("RW Cox");
/*-- process options --*/
nopt = 1 ;
while( nopt < argc && argv[nopt][0] == '-' ){
if( strcasecmp(argv[nopt],"-prefix") == 0 ){
nopt++ ;
if( strcasecmp(argv[nopt],"NULL") == 0 ) prefix = NULL ;
else prefix = strdup(argv[nopt]) ;
nopt++ ; continue ;
}
ERROR_message("Unknown option: '%s'",argv[nopt]) ;
suggest_best_prog_option(argv[0], argv[nopt]);
exit(1);
}
if( argc < 2 ){ usage_3dExtractGroupInCorr(2) ; exit(0) ; }
/* check for errors */
if( nopt >= argc ) ERROR_exit("No input filename on command line?!") ;
/*-- read input file --*/
fname = strdup(argv[nopt]) ;
if( STRING_HAS_SUFFIX(fname,".data") ){
strcpy(fname+strlen(fname)-5,".niml") ;
WARNING_message("EIC: Replaced '.data' with '.niml' in filename") ;
} else if( STRING_HAS_SUFFIX(fname,".grpincorr") ){
fname = (char *)realloc(fname,strlen(fname)+16) ;
strcat(fname,".niml") ;
INFO_message("EIC: Added '.niml' to end of filename") ;
} else if( STRING_HAS_SUFFIX(fname,".grpincorr.") ){
fname = (char *)realloc(fname,strlen(fname)+16) ;
strcat(fname,"niml") ;
INFO_message("EIC: Added 'niml' to end of filename") ;
}
shd = GRINCOR_read_input( fname ) ;
if( shd == NULL ) ERROR_exit("EIC: Cannot continue after input error") ;
INFO_message("EIC: file opened, contains %d datasets, %d time series, %s bytes",
shd->ndset , shd->nvec , commaized_integer_string(shd->nbytes) ) ;
/*-- process input file --*/
fprintf(stderr,"++ %d datasets: ",shd->ndset) ;
for( ids=0 ; ids < shd->ndset ; ids++ ){
fprintf(stderr,"%d",ids+1) ;
dset = GRINCOR_extract_dataset( shd, ids, prefix ) ; fprintf(stderr,".") ;
DSET_write(dset) ;
DSET_delete(dset) ;
}
fprintf(stderr,"\n") ; exit(0) ;
}
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 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 ;
char *prefix="bandpass" ;
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 ;
/*-- help? --*/
AFNI_SETUP_OMP(0) ; /* 24 Jun 2013 */
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"\n"
"** NOTA BENE: For the purpose of preparing resting-state FMRI datasets **\n"
"** for analysis (e.g., with 3dGroupInCorr), this program is now mostly **\n"
"** superseded by the afni_proc.py script. See the 'afni_proc.py -help' **\n"
"** section 'Resting state analysis (modern)' to get our current rs-FMRI **\n"
"** pre-processing recommended sequence of steps. -- RW Cox, et alii. **\n"
"\n"
"Usage: 3dBandpass [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 3dBandpass 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"
"* 3dBandpass 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 3dBandpass will\n"
" depend on the order in which you run these programs. That's why\n"
" 3dBandpass 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):\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"
"\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.\n"
" -quiet = Turn off the fun and informative messages. (Why?)\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-voxel\n"
" correlations via InstaCorr.\n"
" ++ No other tests are made [yet] for non-stationary behavior\n"
" in the time series data.\n"
) ;
PRINT_AFNI_OMP_USAGE(
"3dBandpass" ,
"* At present, the only part of 3dBandpass that is parallelized is the\n"
" '-blur' option, which processes each sub-brick independently.\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
/*-- startup --*/
mainENTRY("3dBandpass"); machdep();
AFNI_logger("3dBandpass",argc,argv);
PRINT_VERSION("3dBandpass"); AUTHOR("RW Cox");
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],"-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 ;
}
}
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 ) 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 */
mrv = THD_dset_to_vectim( inset , mask , 0 ) ;
if( mrv == NULL ) ERROR_exit("Can't load time series data!?") ;
DSET_unload(inset) ;
/* 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 ;
}
}
/* check whether processing leaves any DoF remaining 18 Mar 2015 [rickr] */
{
int nbprem = THD_bandpass_remain_dim(ntime, dt, fbot, ftop, 1);
int bpused, nremain;
int wlimit; /* warning limit */
bpused = ntime - nbprem; /* #dim lost in bandpass step */
nremain = nbprem - nort; /* #dim left in output */
if( nortset == 1 ) nremain--;
nremain -= (qdet+1);
if( verb ) INFO_message("%d dimensional data reduced to %d by:\n"
" %d (bandpass), %d (-ort), %d (-dsort), %d (detrend)",
ntime, nremain, bpused, nort, nortset?1:0, qdet+1);
/* possibly warn (if 95% lost) user or fail */
wlimit = ntime/20;
if( wlimit < 3 ) wlimit = 3;
if( nremain < wlimit && nremain > 0 )
WARNING_message("dimensionality reduced from %d to %d, be careful!",
ntime, nremain);
if( nremain <= 0 ) /* FAILURE */
ERROR_exit("dimensionality reduced from %d to %d, failing!",
ntime, nremain);
}
/* 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") ;
(void)THD_bandpass_vectim( mrv , dt,fbot,ftop , 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 ) ;
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( verb ) INFO_message("Creating output dataset in memory, then writing it") ;
outset = EDIT_empty_copy(inset) ;
/* do not copy scalars 11 Sep 2015 [rickr] */
EDIT_dset_items( outset , ADN_prefix,prefix ,
ADN_brick_fac,NULL ,
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) ;
DSET_write(outset) ; if( verb ) WROTE_DSET(outset) ;
exit(0) ;
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *inset=NULL , *outset=NULL ;
MCW_cluster *nbhd=NULL ;
byte *mask=NULL ; int mask_nx,mask_ny,mask_nz , automask=0 ;
char *prefix="./LocalCormat" ;
int iarg=1 , verb=1 , ntype=0 , kk,nx,ny,nz,nxy,nxyz,nt , xx,yy,zz, vstep ;
float na,nb,nc , dx,dy,dz ;
MRI_IMARR *imar=NULL ; MRI_IMAGE *pim=NULL ;
int mmlag=10 , ii,jj , do_arma=0 , nvout ;
MRI_IMAGE *concim=NULL ; float *concar=NULL ;
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"Usage: 3dLocalCORMAT [options] inputdataset\n"
"\n"
"Compute the correlation matrix (in time) of the input dataset,\n"
"up to lag given by -maxlag. The matrix is averaged over the\n"
"neighborhood specified by the -nbhd option, and then the entries\n"
"are output at each voxel in a new dataset.\n"
"\n"
"Normally, the input to this program would be the -errts output\n"
"from 3dDeconvolve, or the equivalent residuals from some other\n"
"analysis. If you input a non-residual time series file, you at\n"
"least should use an appropriate -polort level for detrending!\n"
"\n"
"Options:\n"
" -input inputdataset\n"
" -prefix ppp\n"
" -mask mset {these 2 options are}\n"
" -automask {mutually exclusive.}\n"
" -nbhd nnn [e.g., 'SPHERE(9)' for 9 mm radius]\n"
" -polort ppp [default = 0, which is reasonable for -errts output]\n"
" -concat ccc [as in 3dDeconvolve]\n"
" -maxlag mmm [default = 10]\n"
" -ARMA [estimate ARMA(1,1) parameters into last 2 sub-bricks]\n"
"\n"
"A quick hack for my own benignant purposes -- RWCox -- June 2008\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
/*---- official startup ---*/
PRINT_VERSION("3dLocalCormat"); mainENTRY("3dLocalCormat main"); machdep();
AFNI_logger("3dLocalCormat",argc,argv); AUTHOR("Zhark the Toeplitzer");
/*---- loop over options ----*/
while( iarg < argc && argv[iarg][0] == '-' ){
#if 0
fprintf(stderr,"argv[%d] = %s\n",iarg,argv[iarg]) ;
#endif
if( strcmp(argv[iarg],"-ARMA") == 0 ){
do_arma = 1 ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-polort") == 0 ){
char *cpt ;
if( ++iarg >= argc )
ERROR_exit("Need argument after option %s",argv[iarg-1]) ;
pport = (int)strtod(argv[iarg],&cpt) ;
if( *cpt != '\0' )
WARNING_message("Illegal non-numeric value after -polort") ;
if( pport > 3 ){
pport = 3 ; WARNING_message("-polort set to 3 == max implemented") ;
} else if( pport < 0 ){
pport = 0 ; WARNING_message("-polort set to 0 == min implemented") ;
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-input") == 0 ){
if( inset != NULL ) ERROR_exit("Can't have two -input options") ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-input'") ;
inset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-prefix") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '-prefix'") ;
prefix = strdup(argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mask") == 0 ){
THD_3dim_dataset *mset ; int mmm ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-mask'") ;
if( mask != NULL || automask ) ERROR_exit("Can't have two mask inputs") ;
mset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(mset,argv[iarg]) ;
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[iarg]) ;
mmm = THD_countmask( mask_nx*mask_ny*mask_nz , mask ) ;
INFO_message("Number of voxels in mask = %d",mmm) ;
if( mmm < 2 ) ERROR_exit("Mask is too small to process") ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-automask") == 0 ){
if( mask != NULL ) ERROR_exit("Can't have -automask and -mask") ;
automask = 1 ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-nbhd") == 0 ){
char *cpt ;
if( ntype > 0 ) ERROR_exit("Can't have 2 '-nbhd' options") ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-nbhd'") ;
cpt = argv[iarg] ;
if( strncasecmp(cpt,"SPHERE",6) == 0 ){
sscanf( cpt+7 , "%f" , &na ) ;
if( na == 0.0f ) ERROR_exit("Can't have a SPHERE of radius 0") ;
ntype = NTYPE_SPHERE ;
} else if( strncasecmp(cpt,"RECT",4) == 0 ){
sscanf( cpt+5 , "%f,%f,%f" , &na,&nb,&nc ) ;
if( na == 0.0f && nb == 0.0f && nc == 0.0f )
ERROR_exit("'RECT(0,0,0)' is not a legal neighborhood") ;
ntype = NTYPE_RECT ;
} else if( strncasecmp(cpt,"RHDD",4) == 0 ){
sscanf( cpt+5 , "%f" , &na ) ;
if( na == 0.0f ) ERROR_exit("Can't have a RHDD of radius 0") ;
ntype = NTYPE_RHDD ;
} else {
ERROR_exit("Unknown -nbhd shape: '%s'",cpt) ;
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-maxlag") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after option %s",argv[iarg-1]) ;
mmlag = (int)strtod(argv[iarg],NULL) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-concat") == 0 ){
if( concim != NULL )
ERROR_exit("Can't have two %s options!",argv[iarg]) ;
if( ++iarg >= argc )
ERROR_exit("Need argument after option %s",argv[iarg-1]) ;
concim = mri_read_1D( argv[iarg] ) ;
if( concim == NULL )
ERROR_exit("Can't read -concat file '%s'",argv[iarg]) ;
if( concim->nx < 2 )
ERROR_exit("-concat file '%s' must have at least 2 entries!",
argv[iarg]) ;
concar = MRI_FLOAT_PTR(concim) ;
for( ii=1 ; ii < concim->nx ; ii++ )
if( (int)concar[ii-1] >= (int)concar[ii] )
ERROR_exit("-concat file '%s' is not ordered increasingly!",
argv[iarg]) ;
iarg++ ; continue ;
}
ERROR_exit("Unknown option '%s'",argv[iarg]) ;
} /*--- end of loop over options ---*/
if( do_arma && mmlag > 0 && mmlag < 5 )
ERROR_exit("Can't do -ARMA with -maxlag %d",mmlag) ;
/*---- deal with input dataset ----*/
if( inset == NULL ){
if( iarg >= argc ) ERROR_exit("No input dataset on command line?") ;
inset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
}
ntime = DSET_NVALS(inset) ;
if( ntime < 9 )
ERROR_exit("Must have at least 9 values per voxel") ;
DSET_load(inset) ; CHECK_LOAD_ERROR(inset) ;
if( mask != NULL ){
if( mask_nx != DSET_NX(inset) ||
mask_ny != DSET_NY(inset) ||
mask_nz != DSET_NZ(inset) )
ERROR_exit("-mask dataset grid doesn't match input dataset") ;
} else if( automask ){
int mmm ;
mask = THD_automask( inset ) ;
if( mask == NULL )
ERROR_message("Can't create -automask from input dataset?") ;
mmm = THD_countmask( DSET_NVOX(inset) , mask ) ;
INFO_message("Number of voxels in automask = %d",mmm) ;
if( mmm < 2 ) ERROR_exit("Automask is too small to process") ;
}
/*-- set up blocks of continuous time data --*/
if( DSET_IS_TCAT(inset) ){
if( concim != NULL ){
WARNING_message("Ignoring -concat, since dataset is auto-catenated") ;
mri_free(concim) ;
}
concim = mri_new(inset->tcat_num,1,MRI_float) ;
concar = MRI_FLOAT_PTR(concim) ;
concar[0] = 0.0 ;
for( ii=0 ; ii < inset->tcat_num-1 ; ii++ )
concar[ii+1] = concar[ii] + inset->tcat_len[ii] ;
} else if( concim == NULL ){
concim = mri_new(1,1,MRI_float) ;
concar = MRI_FLOAT_PTR(concim) ; concar[0] = 0 ;
}
nbk = concim->nx ;
bk = (int *)malloc(sizeof(int)*(nbk+1)) ;
for( ii=0 ; ii < nbk ; ii++ ) bk[ii] = (int)concar[ii] ;
bk[nbk] = ntime ;
mri_free(concim) ;
mlag = DSET_NVALS(inset) ;
for( ii=0 ; ii < nbk ; ii++ ){
jj = bk[ii+1]-bk[ii] ; if( jj < mlag ) mlag = jj ;
if( bk[ii] < 0 || jj < 9 )
ERROR_exit("something is rotten in the dataset run lengths") ;
}
mlag-- ;
if( mmlag > 0 && mlag > mmlag ) mlag = mmlag ;
else INFO_message("Max lag set to %d",mlag) ;
if( do_arma && mlag < 5 )
ERROR_exit("Can't do -ARMA with maxlag=%d",mlag) ;
/*---- create neighborhood (as a cluster) -----*/
if( ntype <= 0 ){ /* default neighborhood */
ntype = NTYPE_SPHERE ; na = -1.01f ;
INFO_message("Using default neighborhood = self + 6 neighbors") ;
}
switch( ntype ){
default:
ERROR_exit("WTF? ntype=%d",ntype) ;
case NTYPE_SPHERE:{
if( na < 0.0f ){ dx = dy = dz = 1.0f ; na = -na ; }
else { dx = fabsf(DSET_DX(inset)) ;
dy = fabsf(DSET_DY(inset)) ;
dz = fabsf(DSET_DZ(inset)) ; }
nbhd = MCW_spheremask( dx,dy,dz , na ) ;
}
break ;
case NTYPE_RECT:{
if( na < 0.0f ){ dx = 1.0f; na = -na; } else dx = fabsf(DSET_DX(inset));
if( nb < 0.0f ){ dy = 1.0f; nb = -nb; } else dy = fabsf(DSET_DY(inset));
if( nc < 0.0f ){ dz = 1.0f; nc = -nc; } else dz = fabsf(DSET_DZ(inset));
nbhd = MCW_rectmask( dx,dy,dz , na,nb,nc ) ;
}
break ;
case NTYPE_RHDD:{
if( na < 0.0f ){ dx = dy = dz = 1.0f ; na = -na ; }
else { dx = fabsf(DSET_DX(inset)) ;
dy = fabsf(DSET_DY(inset)) ;
dz = fabsf(DSET_DZ(inset)) ; }
nbhd = MCW_rhddmask( dx,dy,dz , na ) ;
}
break ;
}
MCW_radsort_cluster( nbhd , dx,dy,dz ) ; /* 26 Feb 2008 */
INFO_message("Neighborhood comprises %d voxels",nbhd->num_pt) ;
/** create output dataset **/
outset = EDIT_empty_copy(inset) ;
nvout = mlag ; if( do_arma ) nvout += 2 ;
EDIT_dset_items( outset,
ADN_prefix , prefix,
ADN_brick_fac, NULL ,
ADN_nvals , nvout ,
ADN_ntt , nvout ,
ADN_none );
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dLocalCormat" , argc,argv , outset ) ;
for( kk=0 ; kk < nvout ; kk++ )
EDIT_substitute_brick( outset , kk , MRI_float , NULL ) ;
nx = DSET_NX(outset) ;
ny = DSET_NY(outset) ; nxy = nx*ny ;
nz = DSET_NZ(outset) ; nxyz = nxy*nz ;
vstep = (verb && nxyz > 999) ? nxyz/50 : 0 ;
if( vstep ) fprintf(stderr,"++ voxel loop: ") ;
/** actually do the long long slog through all voxels **/
for( kk=0 ; kk < nxyz ; kk++ ){
if( vstep && kk%vstep==vstep-1 ) vstep_print() ;
if( !INMASK(kk) ) continue ;
IJK_TO_THREE( kk , xx,yy,zz , nx,nxy ) ;
imar = THD_get_dset_nbhd_array( inset , mask , xx,yy,zz , nbhd ) ;
if( imar == NULL ) continue ;
pim = mri_cormat_vector(imar) ; DESTROY_IMARR(imar) ;
if( pim == NULL ) continue ;
THD_insert_series( kk, outset, pim->nx, MRI_float, MRI_FLOAT_PTR(pim), 0 ) ;
if( do_arma ){ /* estimate ARMA(1,1) params and store those, too */
float_pair ab ;
float *aa=DSET_ARRAY(outset,mlag), *bb=DSET_ARRAY(outset,mlag+1) ;
ab = estimate_arma11( pim->nx , MRI_FLOAT_PTR(pim) ) ;
aa[kk] = ab.a ; bb[kk] = ab.b ;
}
mri_free(pim) ;
}
if( vstep ) fprintf(stderr,"\n") ;
DSET_delete(inset) ;
DSET_write(outset) ;
WROTE_DSET(outset) ;
exit(0) ;
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *xset , *cset, *mset=NULL ;
int nopt=1 , method=PEARSON , do_autoclip=0 ;
int nvox , nvals , ii, jj, kout, kin, polort=1 ;
int ix1,jy1,kz1, ix2, jy2, kz2 ;
char *prefix = "degree_centrality" ;
byte *mask=NULL;
int nmask , abuc=1 ;
int all_source=0; /* output all source voxels 25 Jun 2010 [rickr] */
char str[32] , *cpt ;
int *imap = NULL ; MRI_vectim *xvectim ;
float (*corfun)(int,float *,float*) = NULL ;
/* djc - add 1d file output for similarity matrix */
FILE *fout1D=NULL;
/* CC - we will have two subbricks: binary and weighted centrality */
int nsubbriks = 2;
int subbrik = 0;
float * bodset;
float * wodset;
int nb_ctr = 0;
/* CC - added flags for thresholding correlations */
double thresh = 0.0;
double othresh = 0.0;
int dothresh = 0;
double sparsity = 0.0;
int dosparsity = 0;
/* variables for calculating degree centrality */
long * binaryDC = NULL;
double * weightedDC = NULL;
/* variables for histogram */
hist_node_head* histogram=NULL;
hist_node* hptr=NULL;
hist_node* pptr=NULL;
int bottom_node_idx = 0;
int totNumCor = 0;
long totPosCor = 0;
int ngoal = 0;
int nretain = 0;
float binwidth = 0.0;
int nhistnodes = 50;
/*----*/
AFNI_SETUP_OMP(0) ; /* 24 Jun 2013 */
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"Usage: 3dDegreeCentrality [options] dset\n"
" Computes voxelwise weighted and binary degree centrality and\n"
" stores the result in a new 3D bucket dataset as floats to\n"
" preserve their values. Degree centrality reflects the strength and\n"
" extent of the correlation of a voxel with every other voxel in\n"
" the brain.\n\n"
" Conceptually the process involves: \n"
" 1. Calculating the correlation between voxel time series for\n"
" every pair of voxels in the brain (as determined by masking)\n"
" 2. Applying a threshold to the resulting correlations to exclude\n"
" those that might have arisen by chance, or to sparsify the\n"
" connectivity graph.\n"
" 3. At each voxel, summarizing its correlation with other voxels\n"
" in the brain, by either counting the number of voxels correlated\n"
" with the seed voxel (binary) or by summing the correlation \n"
" coefficients (weighted).\n"
" Practically the algorithm is ordered differently to optimize for\n"
" computational time and memory usage.\n\n"
" The threshold can be supplied as a correlation coefficient, \n"
" or a sparsity threshold. The sparsity threshold reflects the fraction\n"
" of connections that should be retained after the threshold has been\n"
" applied. To minimize resource consumption, using a sparsity threshold\n"
" involves a two-step procedure. In the first step, a correlation\n"
" coefficient threshold is applied to substantially reduce the number\n"
" of correlations. Next, the remaining correlations are sorted and a\n"
" threshold is calculated so that only the specified fraction of \n"
" possible correlations are above threshold. Due to ties between\n"
" correlations, the fraction of correlations that pass the sparsity\n"
" threshold might be slightly more than the number specified.\n\n"
" Regardless of the thresholding procedure employed, negative \n"
" correlations are excluded from the calculations.\n"
"\n"
"Options:\n"
" -pearson = Correlation is the normal Pearson (product moment)\n"
" correlation coefficient [default].\n"
#if 0
" -spearman = Correlation is the Spearman (rank) correlation\n"
" coefficient.\n"
" -quadrant = Correlation is the quadrant correlation coefficient.\n"
#else
" -spearman AND -quadrant are disabled at this time :-(\n"
#endif
"\n"
" -thresh r = exclude correlations <= r from calculations\n"
" -sparsity s = only use top s percent of correlations in calculations\n"
" s should be an integer between 0 and 100. Uses an\n"
" an adaptive thresholding procedure to reduce memory.\n"
" The speed of determining the adaptive threshold can\n"
" be improved by specifying an initial threshold with\n"
" the -thresh flag.\n"
"\n"
" -polort m = Remove polynomical trend of order 'm', for m=-1..3.\n"
" [default is m=1; removal is by least squares].\n"
" Using m=-1 means no detrending; this is only useful\n"
" for data/information that has been pre-processed.\n"
"\n"
" -autoclip = Clip off low-intensity regions in the dataset,\n"
" -automask = so that the correlation is only computed between\n"
" high-intensity (presumably brain) voxels. The\n"
" mask is determined the same way that 3dAutomask works.\n"
"\n"
" -mask mmm = Mask to define 'in-brain' voxels. Reducing the number\n"
" the number of voxels included in the calculation will\n"
" significantly speedup the calculation. Consider using\n"
" a mask to constrain the calculations to the grey matter\n"
" rather than the whole brain. This is also preferrable\n"
" to using -autoclip or -automask.\n"
"\n"
" -prefix p = Save output into dataset with prefix 'p', this file will\n"
" contain bricks for both 'weighted' or 'degree' centrality\n"
" [default prefix is 'deg_centrality'].\n"
"\n"
" -out1D f = Save information about the above threshold correlations to\n"
" 1D file 'f'. Each row of this file will contain:\n"
" Voxel1 Voxel2 i1 j1 k1 i2 j2 k2 Corr\n"
" Where voxel1 and voxel2 are the 1D indices of the pair of\n"
" voxels, i j k correspond to their 3D coordinates, and Corr\n"
" is the value of the correlation between the voxel time courses.\n"
"\n"
"Notes:\n"
" * The output dataset is a bucket type of floats.\n"
" * The program prints out an estimate of its memory used\n"
" when it ends. It also prints out a progress 'meter'\n"
" to keep you pacified.\n"
"\n"
"-- RWCox - 31 Jan 2002 and 16 Jul 2010\n"
"-- Cameron Craddock - 26 Sept 2015 \n"
) ;
PRINT_AFNI_OMP_USAGE("3dDegreeCentrality",NULL) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
mainENTRY("3dDegreeCentrality main"); machdep(); PRINT_VERSION("3dDegreeCentrality");
AFNI_logger("3dDegreeCentrality",argc,argv);
/*-- option processing --*/
while( nopt < argc && argv[nopt][0] == '-' ){
if( strcmp(argv[nopt],"-time") == 0 ){
abuc = 0 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-autoclip") == 0 ||
strcmp(argv[nopt],"-automask") == 0 ){
do_autoclip = 1 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mask") == 0 ){
mset = THD_open_dataset(argv[++nopt]);
CHECK_OPEN_ERROR(mset,argv[nopt]);
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-pearson") == 0 ){
method = PEARSON ; nopt++ ; continue ;
}
#if 0
if( strcmp(argv[nopt],"-spearman") == 0 ){
method = SPEARMAN ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-quadrant") == 0 ){
method = QUADRANT ; nopt++ ; continue ;
}
#endif
if( strcmp(argv[nopt],"-eta2") == 0 ){
method = ETA2 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-prefix") == 0 ){
prefix = strdup(argv[++nopt]) ;
if( !THD_filename_ok(prefix) ){
ERROR_exit("Illegal value after -prefix!") ;
}
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-thresh") == 0 ){
double val = (double)strtod(argv[++nopt],&cpt) ;
if( *cpt != '\0' || val >= 1.0 || val < 0.0 ){
ERROR_exit("Illegal value (%f) after -thresh!", val) ;
}
dothresh = 1;
thresh = val ; othresh = val ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-sparsity") == 0 ){
double val = (double)strtod(argv[++nopt],&cpt) ;
if( *cpt != '\0' || val > 100 || val <= 0 ){
ERROR_exit("Illegal value (%f) after -sparsity!", val) ;
}
if( val > 5.0 )
{
WARNING_message("Sparsity %3.2f%% is large and will require alot of memory and time, consider using a smaller value. ", val);
}
dosparsity = 1 ;
sparsity = val ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-polort") == 0 ){
int val = (int)strtod(argv[++nopt],&cpt) ;
if( *cpt != '\0' || val < -1 || val > 3 ){
ERROR_exit("Illegal value after -polort!") ;
}
polort = val ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mem_stat") == 0 ){
MEM_STAT = 1 ; nopt++ ; continue ;
}
if( strncmp(argv[nopt],"-mem_profile",8) == 0 ){
MEM_PROF = 1 ; nopt++ ; continue ;
}
/* check for 1d argument */
if ( strcmp(argv[nopt],"-out1D") == 0 ){
if (!(fout1D = fopen(argv[++nopt], "w"))) {
ERROR_message("Failed to open %s for writing", argv[nopt]);
exit(1);
}
nopt++ ; continue ;
}
ERROR_exit("Illegal option: %s",argv[nopt]) ;
}
/*-- open dataset, check for legality --*/
if( nopt >= argc ) ERROR_exit("Need a dataset on command line!?") ;
xset = THD_open_dataset(argv[nopt]); CHECK_OPEN_ERROR(xset,argv[nopt]);
if( DSET_NVALS(xset) < 3 )
ERROR_exit("Input dataset %s does not have 3 or more sub-bricks!",argv[nopt]) ;
DSET_load(xset) ; CHECK_LOAD_ERROR(xset) ;
/*-- compute mask array, if desired --*/
nvox = DSET_NVOX(xset) ; nvals = DSET_NVALS(xset) ;
INC_MEM_STATS((nvox * nvals * sizeof(double)), "input dset");
PRINT_MEM_STATS("inset");
/* if a mask was specified make sure it is appropriate */
if( mset ){
if( DSET_NVOX(mset) != nvox )
ERROR_exit("Input and mask dataset differ in number of voxels!") ;
mask = THD_makemask(mset, 0, 1.0, 0.0) ;
/* update running memory statistics to reflect loading the image */
INC_MEM_STATS( mset->dblk->total_bytes, "mask dset" );
PRINT_MEM_STATS( "mset load" );
nmask = THD_countmask( nvox , mask ) ;
INC_MEM_STATS( nmask * sizeof(byte), "mask array" );
PRINT_MEM_STATS( "mask" );
INFO_message("%d voxels in -mask dataset",nmask) ;
if( nmask < 2 ) ERROR_exit("Only %d voxels in -mask, exiting...",nmask);
/* update running memory statistics to reflect loading the image */
DEC_MEM_STATS( mset->dblk->total_bytes, "mask dset" );
DSET_unload(mset) ;
PRINT_MEM_STATS( "mset unload" );
}
/* if automasking is requested, handle that now */
else if( do_autoclip ){
mask = THD_automask( xset ) ;
nmask = THD_countmask( nvox , mask ) ;
INFO_message("%d voxels survive -autoclip",nmask) ;
if( nmask < 2 ) ERROR_exit("Only %d voxels in -automask!",nmask);
}
/* otherwise we use all of the voxels in the image */
else {
nmask = nvox ;
INFO_message("computing for all %d voxels",nmask) ;
}
if( method == ETA2 && polort >= 0 )
WARNING_message("Polort for -eta2 should probably be -1...");
/* djc - 1d file out init */
if (fout1D != NULL) {
/* define affine matrix */
mat44 affine_mat = xset->daxes->ijk_to_dicom;
/* print command line statement */
fprintf(fout1D,"#Similarity matrix from command:\n#");
for(ii=0; ii<argc; ++ii) fprintf(fout1D,"%s ", argv[ii]);
/* Print affine matrix */
fprintf(fout1D,"\n");
fprintf(fout1D,"#[ ");
int mi, mj;
for(mi = 0; mi < 4; mi++) {
for(mj = 0; mj < 4; mj++) {
fprintf(fout1D, "%.6f ", affine_mat.m[mi][mj]);
}
}
fprintf(fout1D, "]\n");
/* Print image extents*/
THD_dataxes *xset_daxes = xset->daxes;
fprintf(fout1D, "#Image dimensions:\n");
fprintf(fout1D, "#[%d, %d, %d]\n",
xset_daxes->nxx, xset_daxes->nyy, xset_daxes->nzz);
/* Similarity matrix headers */
fprintf(fout1D,"#Voxel1 Voxel2 i1 j1 k1 i2 j2 k2 Corr\n");
}
/* CC calculate the total number of possible correlations, will be
usefule down the road */
totPosCor = (.5*((float)nmask))*((float)(nmask-1));
/** For the case of Pearson correlation, we make sure the **/
/** data time series have their mean removed (polort >= 0) **/
/** and are normalized, so that correlation = dot product, **/
/** and we can use function zm_THD_pearson_corr for speed. **/
switch( method ){
default:
case PEARSON: corfun = zm_THD_pearson_corr ; break ;
case ETA2: corfun = my_THD_eta_squared ; break ;
}
/*-- create vectim from input dataset --*/
INFO_message("vectim-izing input dataset") ;
/*-- CC added in mask to reduce the size of xvectim -- */
xvectim = THD_dset_to_vectim( xset , mask , 0 ) ;
if( xvectim == NULL ) ERROR_exit("Can't create vectim?!") ;
/*-- CC update our memory stats to reflect vectim -- */
INC_MEM_STATS((xvectim->nvec*sizeof(int)) +
((xvectim->nvec)*(xvectim->nvals))*sizeof(float) +
sizeof(MRI_vectim), "vectim");
PRINT_MEM_STATS( "vectim" );
/*--- CC the vectim contains a mapping between voxel index and mask index,
tap into that here to avoid duplicating memory usage ---*/
if( mask != NULL )
{
imap = xvectim->ivec;
/* --- CC free the mask */
DEC_MEM_STATS( nmask*sizeof(byte), "mask array" );
free(mask); mask=NULL;
PRINT_MEM_STATS( "mask unload" );
}
/* -- CC unloading the dataset to reduce memory usage ?? -- */
DEC_MEM_STATS((DSET_NVOX(xset) * DSET_NVALS(xset) * sizeof(double)), "input dset");
DSET_unload(xset) ;
PRINT_MEM_STATS("inset unload");
/* -- CC configure detrending --*/
if( polort < 0 && method == PEARSON ){
polort = 0; WARNING_message("Pearson correlation always uses polort >= 0");
}
if( polort >= 0 ){
for( ii=0 ; ii < xvectim->nvec ; ii++ ){ /* remove polynomial trend */
DETREND_polort(polort,nvals,VECTIM_PTR(xvectim,ii)) ;
}
}
/* -- this procedure does not change time series that have zero variance -- */
if( method == PEARSON ) THD_vectim_normalize(xvectim) ; /* L2 norm = 1 */
/* -- CC create arrays to hold degree and weighted centrality while
they are being calculated -- */
if( dosparsity == 0 )
{
if( ( binaryDC = (long*)calloc( nmask, sizeof(long) )) == NULL )
{
ERROR_message( "Could not allocate %d byte array for binary DC calculation\n",
nmask*sizeof(long));
}
/* -- update running memory estimate to reflect memory allocation */
INC_MEM_STATS( nmask*sizeof(long), "binary DC array" );
PRINT_MEM_STATS( "binaryDC" );
if( ( weightedDC = (double*)calloc( nmask, sizeof(double) )) == NULL )
{
if (binaryDC){ free(binaryDC); binaryDC = NULL; }
ERROR_message( "Could not allocate %d byte array for weighted DC calculation\n",
nmask*sizeof(double));
}
/* -- update running memory estimate to reflect memory allocation */
INC_MEM_STATS( nmask*sizeof(double), "weighted DC array" );
PRINT_MEM_STATS( "weightedDC" );
}
/* -- CC if we are using a sparsity threshold, build a histogram to calculate the
threshold */
if (dosparsity == 1)
{
/* make sure that there is a bin for correlation values that == 1.0 */
binwidth = (1.005-thresh)/nhistnodes;
/* calculate the number of correlations we wish to retain */
ngoal = nretain = (int)(((double)totPosCor)*((double)sparsity) / 100.0);
/* allocate memory for the histogram bins */
if(( histogram = (hist_node_head*)malloc(nhistnodes*sizeof(hist_node_head))) == NULL )
{
/* if the allocation fails, free all memory and exit */
if (binaryDC){ free(binaryDC); binaryDC = NULL; }
if (weightedDC){ free(weightedDC); weightedDC = NULL; }
ERROR_message( "Could not allocate %d byte array for histogram\n",
nhistnodes*sizeof(hist_node_head));
}
else {
/* -- update running memory estimate to reflect memory allocation */
INC_MEM_STATS( nhistnodes*sizeof(hist_node_head), "hist bins" );
PRINT_MEM_STATS( "hist1" );
}
/* initialize history bins */
for( kout = 0; kout < nhistnodes; kout++ )
{
histogram[ kout ].bin_low = thresh+kout*binwidth;
histogram[ kout ].bin_high = histogram[ kout ].bin_low+binwidth;
histogram[ kout ].nbin = 0;
histogram[ kout ].nodes = NULL;
/*INFO_message("Hist bin %d [%3.3f, %3.3f) [%d, %p]\n",
kout, histogram[ kout ].bin_low, histogram[ kout ].bin_high,
histogram[ kout ].nbin, histogram[ kout ].nodes );*/
}
}
/*-- tell the user what we are about to do --*/
if (dosparsity == 0 )
{
INFO_message( "Calculating degree centrality with threshold = %f.\n", thresh);
}
else
{
INFO_message( "Calculating degree centrality with threshold = %f and sparsity = %3.2f%% (%d)\n",
thresh, sparsity, nretain);
}
/*---------- loop over mask voxels, correlate ----------*/
AFNI_OMP_START ;
#pragma omp parallel if( nmask > 999 )
{
int lii,ljj,lin,lout,ithr,nthr,vstep,vii ;
float *xsar , *ysar ;
hist_node* new_node = NULL ;
hist_node* tptr = NULL ;
hist_node* rptr = NULL ;
int new_node_idx = 0;
double car = 0.0 ;
/*-- get information about who we are --*/
#ifdef USE_OMP
ithr = omp_get_thread_num() ;
nthr = omp_get_num_threads() ;
if( ithr == 0 ) INFO_message("%d OpenMP threads started",nthr) ;
#else
ithr = 0 ; nthr = 1 ;
#endif
/*-- For the progress tracker, we want to print out 50 numbers,
figure out a number of loop iterations that will make this easy */
vstep = (int)( nmask / (nthr*50.0f) + 0.901f ) ; vii = 0 ;
if((MEM_STAT==0) && (ithr == 0 )) fprintf(stderr,"Looping:") ;
#pragma omp for schedule(static, 1)
for( lout=0 ; lout < xvectim->nvec ; lout++ ){ /*----- outer voxel loop -----*/
if( ithr == 0 && vstep > 2 ) /* allow small dsets 16 Jun 2011 [rickr] */
{ vii++ ; if( vii%vstep == vstep/2 && MEM_STAT == 0 ) vstep_print(); }
/* get ref time series from this voxel */
xsar = VECTIM_PTR(xvectim,lout) ;
/* try to make calculation more efficient by only calculating the unique
correlations */
for( lin=(lout+1) ; lin < xvectim->nvec ; lin++ ){ /*----- inner loop over voxels -----*/
/* extract the voxel time series */
ysar = VECTIM_PTR(xvectim,lin) ;
/* now correlate the time series */
car = (double)(corfun(nvals,xsar,ysar)) ;
if ( car <= thresh )
{
continue ;
}
/* update degree centrality values, hopefully the pragma
will handle mutual exclusion */
#pragma omp critical(dataupdate)
{
/* if the correlation is less than threshold, ignore it */
if ( car > thresh )
{
totNumCor += 1;
if ( dosparsity == 0 )
{
binaryDC[lout] += 1; binaryDC[lin] += 1;
weightedDC[lout] += car; weightedDC[lin] += car;
/* print correlation out to the 1D file */
if ( fout1D != NULL )
{
/* determine the i,j,k coords */
ix1 = DSET_index_to_ix(xset,lii) ;
jy1 = DSET_index_to_jy(xset,lii) ;
kz1 = DSET_index_to_kz(xset,lii) ;
ix2 = DSET_index_to_ix(xset,ljj) ;
jy2 = DSET_index_to_jy(xset,ljj) ;
kz2 = DSET_index_to_kz(xset,ljj) ;
/* add source, dest, correlation to 1D file */
fprintf(fout1D, "%d %d %d %d %d %d %d %d %.6f\n",
lii, ljj, ix1, jy1, kz1, ix2, jy2, kz2, car);
}
}
else
{
/* determine the index in the histogram to add the node */
new_node_idx = (int)floor((double)(car-othresh)/(double)binwidth);
if ((new_node_idx > nhistnodes) || (new_node_idx < bottom_node_idx))
{
/* this error should indicate a programming error and should not happen */
WARNING_message("Node index %d is out of range [%d,%d)!",new_node_idx,
bottom_node_idx, nhistnodes);
}
else
{
/* create a node to add to the histogram */
new_node = (hist_node*)calloc(1,sizeof(hist_node));
if( new_node == NULL )
{
/* allocate memory for this node, rather than fiddling with
error handling here, lets just move on */
WARNING_message("Could not allocate a new node!");
}
else
{
/* populate histogram node */
new_node->i = lout;
new_node->j = lin;
new_node->corr = car;
new_node->next = NULL;
/* -- update running memory estimate to reflect memory allocation */
INC_MEM_STATS( sizeof(hist_node), "hist nodes" );
if ((totNumCor % (1024*1024)) == 0) PRINT_MEM_STATS( "hist nodes" );
/* populate histogram */
new_node->next = histogram[new_node_idx].nodes;
histogram[new_node_idx].nodes = new_node;
histogram[new_node_idx].nbin++;
/* see if there are enough correlations in the histogram
for the sparsity */
if ((totNumCor - histogram[bottom_node_idx].nbin) > nretain)
{
/* delete the list of nodes */
rptr = histogram[bottom_node_idx].nodes;
while(rptr != NULL)
{
tptr = rptr;
rptr = rptr->next;
/* check that the ptr is not null before freeing it*/
if(tptr!= NULL)
{
DEC_MEM_STATS( sizeof(hist_node), "hist nodes" );
free(tptr);
}
}
PRINT_MEM_STATS( "unloaded hist nodes - thresh increase" );
histogram[bottom_node_idx].nodes = NULL;
totNumCor -= histogram[bottom_node_idx].nbin;
histogram[bottom_node_idx].nbin=0;
/* get the new threshold */
thresh = (double)histogram[++bottom_node_idx].bin_low;
if(MEM_STAT == 1) INFO_message("Increasing threshold to %3.2f (%d)\n",
thresh,bottom_node_idx);
}
} /* else, newptr != NULL */
} /* else, new_node_idx in range */
} /* else, do_sparsity == 1 */
} /* car > thresh */
} /* this is the end of the critical section */
} /* end of inner loop over voxels */
} /* end of outer loop over ref voxels */
if( ithr == 0 ) fprintf(stderr,".\n") ;
} /* end OpenMP */
AFNI_OMP_END ;
/* update the user so that they know what we are up to */
INFO_message ("AFNI_OMP finished\n");
INFO_message ("Found %d (%3.2f%%) correlations above threshold (%f)\n",
totNumCor, 100.0*((float)totNumCor)/((float)totPosCor), thresh);
/*---------- Finish up ---------*/
/*if( dosparsity == 1 )
{
for( kout = 0; kout < nhistnodes; kout++ )
{
INFO_message("Hist bin %d [%3.3f, %3.3f) [%d, %p]\n",
kout, histogram[ kout ].bin_low, histogram[ kout ].bin_high,
histogram[ kout ].nbin, histogram[ kout ].nodes );
}
}*/
/*-- create output dataset --*/
cset = EDIT_empty_copy( xset ) ;
/*-- configure the output dataset */
if( abuc ){
EDIT_dset_items( cset ,
ADN_prefix , prefix ,
ADN_nvals , nsubbriks , /* 2 subbricks, degree and weighted centrality */
ADN_ntt , 0 , /* no time axis */
ADN_type , HEAD_ANAT_TYPE ,
ADN_func_type , ANAT_BUCK_TYPE ,
ADN_datum_all , MRI_float ,
ADN_none ) ;
} else {
EDIT_dset_items( cset ,
ADN_prefix , prefix ,
ADN_nvals , nsubbriks , /* 2 subbricks, degree and weighted centrality */
ADN_ntt , nsubbriks , /* num times */
ADN_ttdel , 1.0 , /* fake TR */
ADN_nsl , 0 , /* no slice offsets */
ADN_type , HEAD_ANAT_TYPE ,
ADN_func_type , ANAT_EPI_TYPE ,
ADN_datum_all , MRI_float ,
ADN_none ) ;
}
/* add history information to the hearder */
tross_Make_History( "3dDegreeCentrality" , argc,argv , cset ) ;
ININFO_message("creating output dataset in memory") ;
/* -- Configure the subbriks: Binary Degree Centrality */
subbrik = 0;
EDIT_BRICK_TO_NOSTAT(cset,subbrik) ; /* stat params */
/* CC this sets the subbrik scaling factor, which we will probably want
to do again after we calculate the voxel values */
EDIT_BRICK_FACTOR(cset,subbrik,1.0) ; /* scale factor */
sprintf(str,"Binary Degree Centrality") ;
EDIT_BRICK_LABEL(cset,subbrik,str) ;
EDIT_substitute_brick(cset,subbrik,MRI_float,NULL) ; /* make array */
/* copy measure data into the subbrik */
bodset = DSET_ARRAY(cset,subbrik);
/* -- Configure the subbriks: Weighted Degree Centrality */
subbrik = 1;
EDIT_BRICK_TO_NOSTAT(cset,subbrik) ; /* stat params */
/* CC this sets the subbrik scaling factor, which we will probably want
to do again after we calculate the voxel values */
EDIT_BRICK_FACTOR(cset,subbrik,1.0) ; /* scale factor */
sprintf(str,"Weighted Degree Centrality") ;
EDIT_BRICK_LABEL(cset,subbrik,str) ;
EDIT_substitute_brick(cset,subbrik,MRI_float,NULL) ; /* make array */
/* copy measure data into the subbrik */
wodset = DSET_ARRAY(cset,subbrik);
/* increment memory stats */
INC_MEM_STATS( (DSET_NVOX(cset)*DSET_NVALS(cset)*sizeof(float)), "output dset");
PRINT_MEM_STATS( "outset" );
/* pull the values out of the histogram */
if( dosparsity == 0 )
{
for( kout = 0; kout < nmask; kout++ )
{
if ( imap != NULL )
{
ii = imap[kout] ; /* ii= source voxel (we know that ii is in the mask) */
}
else
{
ii = kout ;
}
if( ii >= DSET_NVOX(cset) )
{
WARNING_message("Avoiding bodset, wodset overflow %d > %d (%s,%d)\n",
ii,DSET_NVOX(cset),__FILE__,__LINE__ );
}
else
{
bodset[ ii ] = (float)(binaryDC[kout]);
wodset[ ii ] = (float)(weightedDC[kout]);
}
}
/* we are done with this memory, and can kill it now*/
if(binaryDC)
{
free(binaryDC);
binaryDC=NULL;
/* -- update running memory estimate to reflect memory allocation */
DEC_MEM_STATS( nmask*sizeof(long), "binary DC array" );
PRINT_MEM_STATS( "binaryDC" );
}
if(weightedDC)
{
free(weightedDC);
weightedDC=NULL;
/* -- update running memory estimate to reflect memory allocation */
DEC_MEM_STATS( nmask*sizeof(double), "weighted DC array" );
PRINT_MEM_STATS( "weightedDC" );
}
}
else
{
/* add in the values from the histogram, this is a two stage procedure:
at first we add in values a whole bin at the time until we get to a point
where we need to add in a partial bin, then we create a new histogram
to sort the values in the bin and then add those bins at a time */
kout = nhistnodes - 1;
while (( histogram[kout].nbin < nretain ) && ( kout >= 0 ))
{
hptr = pptr = histogram[kout].nodes;
while( hptr != NULL )
{
/* determine the indices corresponding to this node */
if ( imap != NULL )
{
ii = imap[hptr->i] ; /* ii= source voxel (we know that ii is in the mask) */
}
else
{
ii = hptr->i ;
}
if ( imap != NULL )
{
jj = imap[hptr->j] ; /* ii= source voxel (we know that ii is in the mask) */
}
else
{
jj = hptr->j ;
}
/* add in the values */
if(( ii >= DSET_NVOX(cset) ) || ( jj >= DSET_NVOX(cset)))
{
if( ii >= DSET_NVOX(cset))
{
WARNING_message("Avoiding bodset, wodset overflow (ii) %d > %d\n (%s,%d)\n",
ii,DSET_NVOX(cset),__FILE__,__LINE__ );
}
if( jj >= DSET_NVOX(cset))
{
WARNING_message("Avoiding bodset, wodset overflow (jj) %d > %d\n (%s,%d)\n",
jj,DSET_NVOX(cset),__FILE__,__LINE__ );
}
}
else
{
bodset[ ii ] += 1.0 ;
wodset[ ii ] += (float)(hptr->corr);
bodset[ jj ] += 1.0 ;
wodset[ jj ] += (float)(hptr->corr);
}
if( fout1D != NULL )
{
/* add source, dest, correlation to 1D file */
ix1 = DSET_index_to_ix(cset,ii) ;
jy1 = DSET_index_to_jy(cset,ii) ;
kz1 = DSET_index_to_kz(cset,ii) ;
ix2 = DSET_index_to_ix(cset,jj) ;
jy2 = DSET_index_to_jy(cset,jj) ;
kz2 = DSET_index_to_kz(cset,jj) ;
fprintf(fout1D, "%d %d %d %d %d %d %d %d %.6f\n",
ii, jj, ix1, jy1, kz1, ix2, jy2, kz2, (float)(hptr->corr));
}
/* increment node pointers */
pptr = hptr;
hptr = hptr->next;
/* delete the node */
if(pptr)
{
/* -- update running memory estimate to reflect memory allocation */
DEC_MEM_STATS(sizeof( hist_node ), "hist nodes" );
/* free the mem */
free(pptr);
pptr=NULL;
}
}
/* decrement the number of correlations we wish to retain */
nretain -= histogram[kout].nbin;
histogram[kout].nodes = NULL;
/* go on to the next bin */
kout--;
}
PRINT_MEM_STATS( "hist1 bins free - inc into output" );
/* if we haven't used all of the correlations that are available, go through and
add a subset of the voxels from the remaining bin */
if(( nretain > 0 ) && (kout >= 0))
{
hist_node_head* histogram2 = NULL;
hist_node_head* histogram2_save = NULL;
int h2nbins = 100;
float h2binwidth = 0.0;
int h2ndx=0;
h2binwidth = (((1.0+binwidth/((float)h2nbins))*histogram[kout].bin_high) - histogram[kout].bin_low) /
((float)h2nbins);
/* allocate the bins */
if(( histogram2 = (hist_node_head*)malloc(h2nbins*sizeof(hist_node_head))) == NULL )
{
if (binaryDC){ free(binaryDC); binaryDC = NULL; }
if (weightedDC){ free(weightedDC); weightedDC = NULL; }
if (histogram){ histogram = free_histogram(histogram, nhistnodes); }
ERROR_message( "Could not allocate %d byte array for histogram2\n",
h2nbins*sizeof(hist_node_head));
}
else {
/* -- update running memory estimate to reflect memory allocation */
histogram2_save = histogram2;
INC_MEM_STATS(( h2nbins*sizeof(hist_node_head )), "hist bins");
PRINT_MEM_STATS( "hist2" );
}
/* initiatize the bins */
for( kin = 0; kin < h2nbins; kin++ )
{
histogram2[ kin ].bin_low = histogram[kout].bin_low + kin*h2binwidth;
histogram2[ kin ].bin_high = histogram2[ kin ].bin_low + h2binwidth;
histogram2[ kin ].nbin = 0;
histogram2[ kin ].nodes = NULL;
/*INFO_message("Hist2 bin %d [%3.3f, %3.3f) [%d, %p]\n",
kin, histogram2[ kin ].bin_low, histogram2[ kin ].bin_high,
histogram2[ kin ].nbin, histogram2[ kin ].nodes );*/
}
/* move correlations from histogram to histgram2 */
INFO_message ("Adding %d nodes from histogram to histogram2",histogram[kout].nbin);
while ( histogram[kout].nodes != NULL )
{
hptr = histogram[kout].nodes;
h2ndx = (int)floor((double)(hptr->corr - histogram[kout].bin_low)/(double)h2binwidth);
if(( h2ndx < h2nbins ) && ( h2ndx >= 0 ))
{
histogram[kout].nodes = hptr->next;
hptr->next = histogram2[h2ndx].nodes;
histogram2[h2ndx].nodes = hptr;
histogram2[h2ndx].nbin++;
histogram[kout].nbin--;
}
else
{
WARNING_message("h2ndx %d is not in range [0,%d) :: %.10f,%.10f\n",h2ndx,h2nbins,hptr->corr, histogram[kout].bin_low);
}
}
/* free the remainder of histogram */
{
int nbins_rem = 0;
for(ii = 0; ii < nhistnodes; ii++) nbins_rem+=histogram[ii].nbin;
histogram = free_histogram(histogram, nhistnodes);
PRINT_MEM_STATS( "free remainder of histogram1" );
}
kin = h2nbins - 1;
while (( nretain > 0 ) && ( kin >= 0 ))
{
hptr = pptr = histogram2[kin].nodes;
while( hptr != NULL )
{
/* determine the indices corresponding to this node */
if ( imap != NULL )
{
ii = imap[hptr->i] ;
}
else
{
ii = hptr->i ;
}
if ( imap != NULL )
{
jj = imap[hptr->j] ;
}
else
{
jj = hptr->j ;
}
/* add in the values */
if(( ii >= DSET_NVOX(cset) ) || ( jj >= DSET_NVOX(cset)))
{
if( ii >= DSET_NVOX(cset))
{
WARNING_message("Avoiding bodset, wodset overflow (ii) %d > %d\n (%s,%d)\n",
ii,DSET_NVOX(cset),__FILE__,__LINE__ );
}
if( jj >= DSET_NVOX(cset))
{
WARNING_message("Avoiding bodset, wodset overflow (jj) %d > %d\n (%s,%d)\n",
jj,DSET_NVOX(cset),__FILE__,__LINE__ );
}
}
else
{
bodset[ ii ] += 1.0 ;
wodset[ ii ] += (float)(hptr->corr);
bodset[ jj ] += 1.0 ;
wodset[ jj ] += (float)(hptr->corr);
}
if( fout1D != NULL )
{
/* add source, dest, correlation to 1D file */
ix1 = DSET_index_to_ix(cset,ii) ;
jy1 = DSET_index_to_jy(cset,ii) ;
kz1 = DSET_index_to_kz(cset,ii) ;
ix2 = DSET_index_to_ix(cset,jj) ;
jy2 = DSET_index_to_jy(cset,jj) ;
kz2 = DSET_index_to_kz(cset,jj) ;
fprintf(fout1D, "%d %d %d %d %d %d %d %d %.6f\n",
ii, jj, ix1, jy1, kz1, ix2, jy2, kz2, (float)(hptr->corr));
}
/* increment node pointers */
pptr = hptr;
hptr = hptr->next;
/* delete the node */
if(pptr)
{
free(pptr);
DEC_MEM_STATS(( sizeof(hist_node) ), "hist nodes");
pptr=NULL;
}
}
/* decrement the number of correlations we wish to retain */
nretain -= histogram2[kin].nbin;
histogram2[kin].nodes = NULL;
/* go on to the next bin */
kin--;
}
PRINT_MEM_STATS("hist2 nodes free - incorporated into output");
/* we are finished with histogram2 */
{
histogram2 = free_histogram(histogram2, h2nbins);
/* -- update running memory estimate to reflect memory allocation */
PRINT_MEM_STATS( "free hist2" );
}
if (nretain < 0 )
{
WARNING_message( "Went over sparsity goal %d by %d, with a resolution of %f",
ngoal, -1*nretain, h2binwidth);
}
}
if (nretain > 0 )
{
WARNING_message( "Was not able to meet goal of %d (%3.2f%%) correlations, %d (%3.2f%%) correlations passed the threshold of %3.2f, maybe you need to change the threshold or the desired sparsity?",
ngoal, 100.0*((float)ngoal)/((float)totPosCor), totNumCor, 100.0*((float)totNumCor)/((float)totPosCor), thresh);
}
}
INFO_message("Done..\n") ;
/* update running memory statistics to reflect freeing the vectim */
DEC_MEM_STATS(((xvectim->nvec*sizeof(int)) +
((xvectim->nvec)*(xvectim->nvals))*sizeof(float) +
sizeof(MRI_vectim)), "vectim");
/* toss some trash */
VECTIM_destroy(xvectim) ;
DSET_delete(xset) ;
if(fout1D!=NULL)fclose(fout1D);
PRINT_MEM_STATS( "vectim unload" );
if (weightedDC) free(weightedDC) ; weightedDC = NULL;
if (binaryDC) free(binaryDC) ; binaryDC = NULL;
/* finito */
INFO_message("Writing output dataset to disk [%s bytes]",
commaized_integer_string(cset->dblk->total_bytes)) ;
/* write the dataset */
DSET_write(cset) ;
WROTE_DSET(cset) ;
/* increment our memory stats, since we are relying on the header for this
information, we update the stats before actually freeing the memory */
DEC_MEM_STATS( (DSET_NVOX(cset)*DSET_NVALS(cset)*sizeof(float)), "output dset");
/* free up the output dataset memory */
DSET_unload(cset) ;
DSET_delete(cset) ;
/* force a print */
MEM_STAT = 1;
PRINT_MEM_STATS( "Fin" );
exit(0) ;
}
int main( int argc , char *argv[] )
{
char *prefix = "Deghost" ;
int iarg ;
int fe=1 , pe=2 , se=3 , nvals ;
THD_3dim_dataset *inset=NULL , *outset , *filset=NULL ;
if( argc < 2 || strcmp(argv[1],"-help") == 0 ) {
printf(
"Usage: 3dDeghost [options] dataset\n"
"\n"
"* This program tries do remove N/2 (AKA Nyquist) ghosts from an EPI\n"
" magnitude time series dataset.\n"
"* If you apply it to some other kind of dataset (e.g., spiral), weird\n"
" things will probably transpire.\n"
"* The input EPI dataset should NOT be filtered, masked, cropped,\n"
" registered, or pre-processed in any way!\n"
"* This program will not work well if the input EPI dataset is heavily\n"
" 'shaded' -- that is, its intensity varies dramatically inside the brain.\n"
"* The output dataset is always stored in float format.\n"
"* Only the Amitabha Buddha knows if this program is actually useful.\n"
"\n"
"========\n"
"OPTIONS:\n"
"========\n"
" -input dataset = Another way to specify the input dataset\n"
" -prefix pp = Use 'pp' for prefix of output dataset\n"
" -FPS abc = Define the Frequency, Phase, and Slice\n"
" directions in the dataset based on the\n"
" axis orientations inside the dataset header\n"
" (e.g., see the output of 3dinfo). The 'abc'\n"
" code is a permutaton of the digits '123'.\n"
" * The first digit 'a' specifies which dataset\n"
" axis/index is the Frequency encoding direction.\n"
" * The second digit 'b' specifies which dataset\n"
" direction is the Phase encoding direction.\n"
" * The third digit 'c' specifies which dataset\n"
" direction is the Slice encoding direction.\n"
" -->>** The default value for 'abc' is '123'; that is,\n"
" the dataset is ordered so that the first index\n"
" (x-axis) is frequency, the second index is phase,\n"
" and the third index is slice. In most cases,\n"
" this is how the reconstruction software will\n"
" store the images. Only in unusual cases should\n"
" you need the '-FPS' option!\n"
" -filt N = Length of time series filter to apply when\n"
" estimating ghosting parameters. Set N to 0 or 1\n"
" to turn this feature off; otherwise, N should be an\n"
" odd positive integer from 3 to 19 [default N=%d].\n"
" * Longer filter lengths ARE allowed, but will be slow\n"
" (cases with N <= 19 are hand coded for speed).\n"
" * Datasets with fewer than 4 time points will not\n"
" be filtered. For longer datasets, if the filter\n"
" length is too big, it will be shortened ruthlessly.\n"
"=======\n"
"METHOD:\n"
"=======\n"
"Would you believe me if I said magic? Would you accept secret algorithms\n"
"known only to the Olmecs? How about something so ad hoc that it cannot\n"
"be described without embarrasment and shame?\n"
"\n"
"-- Feb 2014 - Zhark the Phantasmal\n"
, orfilt_len
) ;
PRINT_COMPILE_DATE ;
exit(0) ;
}
mainENTRY("3dDeghost main");
machdep();
AFNI_logger("3dDeghost",argc,argv);
PRINT_VERSION("3dDeghost") ;
/*-- scan command line --*/
iarg = 1 ;
while( iarg < argc && argv[iarg][0] == '-' ) {
/*---*/
if( strcasecmp(argv[iarg],"-quiet") == 0 ) {
verb = 0 ;
iarg++ ;
continue ;
}
if( strcasecmp(argv[iarg],"-verb") == 0 ) {
verb++ ;
iarg++ ;
continue ;
}
/*---*/
if( strcasecmp(argv[iarg],"-filt") == 0 ) {
if( ++iarg >= argc )
ERROR_exit("Need argument after option '%s'",argv[iarg-1]) ;
orfilt_len = (int)strtod(argv[iarg],NULL) ;
if( orfilt_len > 1 && orfilt_len%2 == 0 ) {
orfilt_len++ ;
INFO_message("-filt %d has been adjusted to %d (must be odd)" ,
orfilt_len-1 , orfilt_len) ;
}
if( orfilt_len > 19 )
WARNING_message("-filt %d is over the recommended limit of 19",orfilt_len) ;
iarg++ ;
continue ;
}
/*---*/
if( strcasecmp(argv[iarg],"-prefix") == 0 ) {
if( ++iarg >= argc )
ERROR_exit("Need argument after option '%s'",argv[iarg-1]) ;
prefix = argv[iarg] ;
if( !THD_filename_ok(prefix) )
ERROR_exit("Illegal value after -prefix!\n");
iarg++ ;
continue ;
}
/*---*/
if( strcasecmp(argv[iarg],"-input") == 0 || strcasecmp(argv[iarg],"-inset") == 0 ) {
if( ++iarg >= argc )
ERROR_exit("Need argument after option '%s'",argv[iarg-1]) ;
if( inset != NULL )
ERROR_exit("You can't give the input dataset twice!") ;
inset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
DSET_load(inset) ;
CHECK_LOAD_ERROR(inset) ;
iarg++ ;
continue ;
}
/*---*/
if( strcasecmp(argv[iarg],"-FPS") == 0 ) { /* stolen from 3dAllineate.c */
char *fps ;
if( ++iarg >= argc )
ERROR_exit("Need argument after option '%s'",argv[iarg-1]) ;
fps = argv[iarg] ;
if( strlen(fps) < 3 ) ERROR_exit("Code '%s' after '%s' is too short",
fps , argv[iarg-1] ) ;
switch( fps[0] ) {
default:
ERROR_exit("Illegal '%s' F code '%c' :-(" , argv[iarg-1],fps[0] );
case 'i':
case 'I':
case 'x':
case 'X':
case '1':
fe = 1;
break;
case 'j':
case 'J':
case 'y':
case 'Y':
case '2':
fe = 2;
break;
case 'k':
case 'K':
case 'z':
case 'Z':
case '3':
fe = 3;
break;
}
switch( fps[1] ) {
default:
ERROR_exit("Illegal '%s' P code '%c' :-(" , argv[iarg-1],fps[1] );
case 'i':
case 'I':
case 'x':
case 'X':
case '1':
pe = 1;
break;
case 'j':
case 'J':
case 'y':
case 'Y':
case '2':
pe = 2;
break;
case 'k':
case 'K':
case 'z':
case 'Z':
case '3':
pe = 3;
break;
}
switch( fps[2] ) {
default:
ERROR_exit("Illegal '%s' S code '%c' :-(" , argv[iarg-1],fps[2] );
case 'i':
case 'I':
case 'x':
case 'X':
case '1':
se = 1;
break;
case 'j':
case 'J':
case 'y':
case 'Y':
case '2':
se = 2;
break;
case 'k':
case 'K':
case 'z':
case 'Z':
case '3':
se = 3;
break;
}
if( fe+pe+se != 6 ) ERROR_exit("Code '%s' after '%s' is nonsensical",
fps , argv[iarg-1] ) ;
iarg++ ;
continue ;
}
/*---*/
ERROR_exit("Unknown option: %s\n",argv[iarg]);
}
if( inset == NULL && iarg >= argc )
ERROR_exit("No dataset name on command line?\n");
/*-- read input if needed --*/
if( inset == NULL ) {
inset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
DSET_load( inset ) ;
CHECK_LOAD_ERROR(inset) ;
}
/*-- filter input? --*/
nvals = DSET_NVALS(inset) ;
if( orfilt_len > nvals/2 ) {
orfilt_len = nvals/2 ;
if( orfilt_len%2 == 0 ) orfilt_len++ ;
}
if( orfilt_len > 1 && nvals > 1 ) {
MRI_vectim *invect ;
int ii ;
if( verb )
INFO_message("Filtering input dataset: filter length=%d",orfilt_len) ;
invect = THD_dset_to_vectim(inset,NULL,0) ;
THD_vectim_applyfunc( invect , orfilt_vector ) ;
filset = EDIT_empty_copy( inset ) ;
for( ii=0 ; ii < nvals ; ii++ )
EDIT_substitute_brick( filset , ii , MRI_float , NULL ) ;
THD_vectim_to_dset( invect , filset ) ;
VECTIM_destroy(invect) ;
} else {
if( verb )
INFO_message("Time series filtering is turned off") ;
}
/***** outsource the work *****/
outset = THD_deghoster( inset , (filset!=NULL)?filset:inset , pe,fe,se ) ;
if( outset == NULL ) ERROR_exit("THD_deghoster fails :-(((") ;
if( filset != NULL ) DSET_delete(filset) ;
EDIT_dset_items( outset , ADN_prefix,prefix , ADN_none ) ;
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dDeghost" , argc,argv , outset ) ;
DSET_write(outset) ;
WROTE_DSET(outset) ;
exit(0) ;
}
int main( int argc , char *argv[] )
{
MRI_IMAGE *xim , *yim ;
float *xar , *yar , *war ;
int iarg , ndset , nvox , ii , jj, xyall , clip=0 ;
THD_3dim_dataset *xset , *yset , * mask_dset=NULL ;
float xbot=1.0f,xtop=0.0f , ybot=1.0f,ytop=0.0f , val ;
float xsum,ysum , xsig,ysig ;
byte *mmm=NULL ;
char *save_hist=NULL, *save_hist_1D=NULL ;
/*-- read command line arguments --*/
if( argc < 3 || strncmp(argv[1],"-help",5) == 0 ){
printf("Usage: 3dAcost [options] xset yset\n"
"Output = 3dAllineate cost functions between 2 dataset bricks\n"
" (for debugging purposes, mostly).\n"
"\n"
"Options:\n"
" -mask mset Means to use the dataset 'mset' as a mask:\n"
" Only voxels with nonzero values in 'mset'\n"
" will be averaged from 'dataset'. Note\n"
" that the mask dataset and the input dataset\n"
" must have the same number of voxels.\n"
" -histpow p Set histogram power to 'p'; number of bins in\n"
" histogram (each axis) = n^p (n=# of points).\n"
" (Default is p=0.33333.)\n"
" -histbin m Set histogram to use 'm' bins (each axis).\n"
" (Max number of bins is 255.)\n"
" -savehist ss Save 2D histogram to image file 'ss'\n"
" (floating point image; read with 'afni -im')\n"
" -savehist_1D dd Save original form of 2D histogram to 1D file 'dd'\n"
" (-savehist produces the rootogram)\n"
" -xrange a b Use only xset values in range a..b.\n"
" -yrange c d Use only yset values in range c..d.\n"
" (Default is to use all values.)\n"
" -clip Use values from min to mri_topclip()\n"
) ;
exit(0) ;
}
iarg = 1 ;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-xrange") == 0 ){
if( ++iarg >= argc-1 ) ERROR_exit("no arguments after '%s'!",argv[iarg-1]) ;
xbot = (float)strtod(argv[iarg++],NULL) ;
xtop = (float)strtod(argv[iarg++],NULL) ;
continue ;
}
if( strcmp(argv[iarg],"-yrange") == 0 ){
if( ++iarg >= argc-1 ) ERROR_exit("no arguments after '%s'!",argv[iarg-1]) ;
ybot = (float)strtod(argv[iarg++],NULL) ;
ytop = (float)strtod(argv[iarg++],NULL) ;
continue ;
}
if( strcmp(argv[iarg],"-clip") == 0 ){
clip = 1 ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-savehist") == 0 ){
if( ++iarg >= argc ) ERROR_exit("no argument after '%s'!",argv[iarg-1]) ;
if( !THD_filename_ok(argv[iarg]) )
ERROR_exit("badly formed filename: '%s' '%s'",argv[iarg-1],argv[iarg]);
save_hist = argv[iarg] ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-savehist_1D") == 0 ){
if( ++iarg >= argc ) ERROR_exit("no argument after '%s'!",argv[iarg-1]) ;
save_hist_1D= argv[iarg] ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-histpow") == 0 ){
double hist_pow ;
if( ++iarg >= argc ) ERROR_exit("no argument after '%s'!",argv[iarg-1]) ;
hist_pow = strtod(argv[iarg],NULL) ;
set_2Dhist_hpower(hist_pow) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-histbin") == 0 ){
int hist_nbin ;
if( ++iarg >= argc ) ERROR_exit("no argument after '%s'!",argv[iarg-1]) ;
hist_nbin = (int)strtod(argv[iarg],NULL) ;
set_2Dhist_hbin(hist_nbin) ;
iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-mask",5) == 0 ){
if( mask_dset != NULL ) ERROR_exit("Can't use -mask twice!") ;
if( iarg+1 >= argc ) ERROR_exit("-mask needs a filename!") ;
mask_dset = THD_open_dataset( argv[++iarg] ) ;
CHECK_OPEN_ERROR(mask_dset,argv[iarg]) ;
iarg++ ; continue ;
}
fprintf(stderr,"*** Unknown option: %s\n",argv[iarg]) ; exit(1) ;
}
/* should have at least 2 more arguments */
ndset = argc - iarg ;
if( ndset <= 1 ){
fprintf(stderr,"*** No input datasets!?\n") ; exit(1) ;
}
xset = THD_open_dataset(argv[iarg++]) ; CHECK_OPEN_ERROR(xset,argv[iarg-1]) ;
yset = THD_open_dataset(argv[iarg++]) ; CHECK_OPEN_ERROR(yset,argv[iarg-1]) ;
DSET_load(xset) ; DSET_load(yset) ;
CHECK_LOAD_ERROR(xset) ; CHECK_LOAD_ERROR(yset) ;
if( DSET_NVALS(xset) > 1 || DSET_NVALS(yset) > 1 )
WARNING_message("Using only sub-brick [0] of input datasets") ;
nvox = DSET_NVOX(xset) ;
if( nvox != DSET_NVOX(yset) )
ERROR_exit("Input datasets dimensions don't match!") ;
xim = mri_scale_to_float( DSET_BRICK_FACTOR(xset,0) , DSET_BRICK(xset,0) );
yim = mri_scale_to_float( DSET_BRICK_FACTOR(yset,0) , DSET_BRICK(yset,0) );
xar = MRI_FLOAT_PTR(xim) ; yar = MRI_FLOAT_PTR(yim) ;
DSET_unload(xset); DSET_unload(yset);
/* make a byte mask from mask dataset */
war = (float *)malloc(sizeof(float)*nvox) ;
if( mask_dset != NULL ){
int mcount ;
if( DSET_NVOX(mask_dset) != nvox )
ERROR_exit("Input and mask datasets are not same dimensions!");
mmm = THD_makemask( mask_dset , 0 , 666.0,-666.0 ) ;
mcount = THD_countmask( nvox , mmm ) ;
if( mcount <= 5 ) ERROR_exit("Mask is too small: %d voxels",mcount) ;
DSET_delete(mask_dset) ;
for( ii=0 ; ii < nvox ; ii++ ) war[ii] = (float)mmm[ii] ;
free((void *)mmm) ;
} else {
for( ii=0 ; ii < nvox ; ii++ ) war[ii] = 1.0f ;
}
if( clip ){
xbot = mri_min(xim) ; xtop = mri_topclip(xim) ;
INFO_message("xbot=%g xclip=%g",xbot,xtop) ;
ybot = mri_min(yim) ; ytop = mri_topclip(yim) ;
INFO_message("ybot=%g yclip=%g",ybot,ytop) ;
}
xyall = 0 ;
if( xbot >= xtop ){
xbot = 1.e+38 ; xtop = -1.e+38 ;
for( ii=0 ; ii < nvox ; ii++ )
if( war[ii] > 0.0f ){
if( xar[ii] < xbot ) xbot = xar[ii] ;
else if( xar[ii] > xtop ) xtop = xar[ii] ;
}
INFO_message("xbot=%g xtop=%g",xbot,xtop) ;
if( xbot >= xtop ) ERROR_exit("no x range?!") ;
xyall++ ;
}
if( ybot >= ytop ){
ybot = 1.e+38 ; ytop = -1.e+38 ;
for( ii=0 ; ii < nvox ; ii++ )
if( war[ii] > 0.0f ){
if( yar[ii] < ybot ) ybot = yar[ii] ;
else if( yar[ii] > ytop ) ytop = yar[ii] ;
}
INFO_message("ybot=%g ytop=%g",ybot,ytop) ;
if( ybot >= ytop ) ERROR_exit("no y range?!") ;
xyall++ ;
}
if( xyall < 2 ){
for( ii=0 ; ii < nvox ; ii++ )
if( xar[ii] < xbot || xar[ii] > xtop ||
yar[ii] < ybot || yar[ii] > ytop ) war[ii] = 0.0f ;
}
xyall = 0 ;
for( ii=0 ; ii < nvox ; ii++ ) xyall += (war[ii] > 0.0f) ;
INFO_message("Processing %d voxels",xyall) ;
if( xyall <= 5 ) ERROR_exit("Too few voxels to continue!") ;
xsum = ysum = 0.0f ;
for( ii=0 ; ii < nvox ; ii++ ){
if( war[ii] > 0.0f ){ xsum += xar[ii]; ysum += yar[ii]; }
}
xsum /= xyall ; ysum /= xyall ;
INFO_message("xmean=%g ymean=%g",xsum,ysum) ;
xsig = ysig = 0.0f ;
for( ii=0 ; ii < nvox ; ii++ ){
if( war[ii] > 0.0f ){
val = (xar[ii]-xsum) ; xsig += val*val ;
val = (yar[ii]-ysum) ; ysig += val*val ;
}
}
xsig = sqrt( xsig/(xyall-1.0) ); ysig = sqrt( ysig/(xyall-1.0) );
INFO_message("xsig =%g ysig =%g",xsig,ysig) ;
val = THD_pearson_corr_wt( nvox , xar , yar , war ) ;
val = 1.0 - fabs(val) ;
printf("1-Correlation = %+.5f\n",val) ;
val = -THD_mutual_info_scl( nvox , xbot,xtop,xar , ybot,ytop,yar , war ) ;
printf("-Mutual Info = %+.5f\n",val ) ;
val = THD_norm_mutinf_scl( nvox , xbot,xtop,xar , ybot,ytop,yar , war ) ;
printf("Norm Mutual Info = %+.5f\n",val ) ;
#if 0
INFO_message("THD_corr_ratio_scl(%d,%g,%g,xar,%g,%g,yar,war)",
nvox , xbot,xtop , ybot,ytop ) ;
#endif
THD_corr_ratio_sym_mul ;
val = THD_corr_ratio_scl( nvox , xbot,xtop,xar , ybot,ytop,yar , war ) ;
val = 1.0 - fabs(val) ;
printf("1-Corr ratio sym* = %+.5f\n",val) ;
THD_corr_ratio_sym_add ;
val = THD_corr_ratio_scl( nvox , xbot,xtop,xar , ybot,ytop,yar , war ) ;
val = 1.0 - fabs(val) ;
printf("1-Corr ratio sym+ = %+.5f\n",val) ;
THD_corr_ratio_sym_not ;
val = THD_corr_ratio_scl( nvox , xbot,xtop,xar , ybot,ytop,yar , war ) ;
val = 1.0 - fabs(val) ;
printf("1-Corr ratio unsym= %+.5f\n",val) ;
val = -THD_hellinger_scl( nvox , xbot,xtop,xar , ybot,ytop,yar , war ) ;
printf("-Hellinger metric = %+.5f\n",val) ;
if( save_hist != NULL ){ /* Save 2D histogram */
int nbin ; float *xyc ;
nbin = retrieve_2Dhist( &xyc ) ;
if( nbin > 0 && xyc != NULL ){
MRI_IMAGE *fim,*qim ; double ftop ;
fim = mri_new(nbin,nbin,MRI_float); mri_fix_data_pointer(xyc,fim);
#if 0
for( ii=0 ; ii < nbin*nbin ; ii++ ) xyc[ii] = sqrtf(xyc[ii]) ;
ftop = mri_max(fim); if( ftop == 0.0 ) ftop = 1.0;
qim = mri_to_byte_scl(255.4/ftop,0.0,fim) ;
mri_clear_data_pointer(fim); mri_free(fim);
fim = mri_flippo(MRI_ROT_180,1,qim); mri_free(qim);
mri_write_pnm(save_hist,fim); mri_free(fim);
#else
qim = mri_flippo(MRI_ROT_180,1,fim);
mri_clear_data_pointer(fim); mri_free(fim);
mri_write(save_hist,qim); mri_free(qim);
#endif
INFO_message("- Saved %dx%d histogram to %s",nbin,nbin,save_hist) ;
}
}
if( save_hist_1D != NULL ){ /* Save 2D raw histogram */
int nbin ; float *xyc ;
nbin = retrieve_2Dhist( &xyc ) ;
if( nbin > 0 && xyc != NULL ){
FILE *fid=fopen(save_hist_1D,"w");
for( ii=0 ; ii < nbin; ii++ ) {
for( jj=0 ; jj < nbin; jj++ ) {
fprintf(fid,"%.4f\t", xyc[ii*nbin+jj]);
}
fprintf(fid,"\n");
}
fclose(fid);
}
INFO_message("- Saved %dx%d 1D histogram to %s",nbin,nbin,save_hist_1D) ;
}
exit(0) ;
}
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) ;
}
int AFNI_prefilter_args( int *argc , char **argv )
{
int narg=*argc , ii,jj , nused , ttt ;
char *used , *eee ;
if( narg <= 1 || argv == NULL ) return(0) ;
used = (char *)calloc((size_t)narg,sizeof(char)) ;
eee = getenv("AFNI_TRACE") ; ttt = YESSISH(eee) ;
if( ttt )
fprintf( stderr,
"++ AFNI_prefilter_args() processing argv[1..%d]\n",narg-1) ;
/*--- scan thru argv[];
see if any should be processed now and marked as 'used up' ---*/
for( ii=1 ; ii < narg ; ii++ ){
/*** empty argument (should never happen in Unix) ***/
if( argv[ii] == NULL ){
if( ttt ) fprintf(stderr,"++ argv[%d] is NULL\n",ii) ;
used[ii] = 1 ; continue ;
}
/*** -Dname=val to set environment variable ***/
if( strncmp(argv[ii],"-D",2) == 0 && strchr(argv[ii],'=') != NULL ){
if( ttt ) fprintf(stderr,"++ argv[%d] does setenv %s\n",ii,argv[ii]) ;
(void)AFNI_setenv(argv[ii]+2) ; used[ii] = 1 ; continue ;
}
/*** -Vname to get environment variable ***/
if( strncmp(argv[ii],"-V",2) == 0 && strchr(argv[ii],'=') != NULL ){
if( ttt ) fprintf(stderr,"++ argv[%d] does getenv %s\n",ii,argv[ii]) ;
fprintf(stdout,"%s\n",
(eee = my_getenv(argv[ii]+2)) ? eee:"") ;
used[ii] = 1 ; exit(0) ;
}
/*** -overwrite to set AFNI_DECONFLICT ***/
if( strcmp(argv[ii],"-overwrite") == 0 ){
if( ttt ) fprintf(stderr,"++ argv[%d] is -overwrite\n",ii) ;
AFNI_setenv("AFNI_DECONFLICT=OVERWRITE") ;
THD_set_quiet_overwrite(1); /* no need to kvetch */
used[ii] = 1 ; continue ;
}
/*** echo command ***/
if( strcmp(argv[ii],"-echo_edu") == 0 ){
if( ttt ) fprintf(stderr,"++ argv[%d] is -echo_edu\n",ii) ;
{
int jjj=0;
fprintf(stdout,"\n+++ Command Echo:\n ");
for (jjj=0; jjj<narg; ++jjj) {
if (jjj != ii) {
fprintf(stdout,"%s ", argv[jjj]);
}
}
fprintf(stdout,"\n\n");
used[ii] = 1 ; continue ;
}
}
if( strcmp(argv[ii],"-all_opts") == 0 ){
if( ttt ) fprintf(stderr,"++ argv[%d] is -all_opts\n",ii) ;
print_prog_options(argv[0]); used[ii] = 1 ;
exit(0);
/* better exit, otherwise output get burried by program's own -help */
}
if( strcmp(argv[ii],"-h_find") == 0 ){
if( ttt ) fprintf(stderr,"++ argv[%d] is -h_find\n",ii) ;
if (ii+1 >= narg) {
fprintf(stderr,"** -h_find needs a string.\n");
exit(1);
}
used[ii] = 1 ; ii++;
suggest_best_prog_option(argv[0], argv[ii]);
used[ii] = 1 ;
exit(0);
/* better exit, otherwise output get burried by program's own -help */
}
if( strcmp(argv[ii],"-h_aspx") == 0 && ii == 1){
char *s=NULL;
if( ttt ) fprintf(stderr,"++ argv[%d] is -h_apsx\n",ii) ;
if (!(s = sphinxize_prog_help(argv[0], 0))) {
fprintf(stderr,"** Failed to get auto-sphinxized string\n");
exit(1);
}
fprintf(stdout,"%s", s); free(s);
used[ii] = 1 ;
exit(0);
}
if( strcmp(argv[ii],"-h_view") == 0 ){
if( ttt ) fprintf(stderr,"++ argv[%d] is -h_view\n",ii) ;
view_prog_help(argv[0]);
used[ii] = 1 ;
exit(0);
/* better exit, otherwise output get burried by program's own -help */
}
if( strcmp(argv[ii],"-h_web") == 0 ){
if( ttt ) fprintf(stderr,"++ argv[%d] is -h_web\n",ii) ;
web_prog_help(argv[0],0);
used[ii] = 1 ;
exit(0);
/* better exit, otherwise output get burried by program's own -help */
}
/*** -ok_1D_text to set AFNI_1D_ZERO_TEXT ZSS Dec 09 ***/
if( strcmp(argv[ii],"-ok_1D_text") == 0 ){
if( ttt ) fprintf(stderr,"++ argv[%d] is -ok_1D_text\n",ii) ;
AFNI_setenv("AFNI_1D_ZERO_TEXT=YES") ; used[ii] = 1 ; continue ;
}
/*** -skip_afnirc to avoid .afnirc file ***/
if( strcmp(argv[ii],"-skip_afnirc") == 0 ){
if( ttt ) fprintf(stderr,"++ argv[%d] is -skip_afnirc\n",ii) ;
AFNI_mark_environ_done() ; used[ii] = 1 ; continue ;
}
/*** -pad_to_node to force sparse data to a particular size ***/
if( strcmp(argv[ii],"-pad_to_node") == 0 ){
if( ttt ) fprintf(stderr,"++ argv[%d] is -pad_to_node\n",ii) ;
if (ii+1 >= narg) {
fprintf(stderr,"** -pad_to_node needs a positive integer,\n"
" or standard mesh description such as ld120\n");
exit(1);
}
used[ii] = 1 ; ii++;
if (!strncasecmp(argv[ii],"ld",2)) {
if (strlen(argv[ii]) < 3) {
fprintf(stderr,"** need a number right after ld (like ld120)\n");
exit(1);
}
MRILIB_DomainMaxNodeIndex = SUMA_IcoNums(atoi(argv[ii]+2), 0, 'n')-1;
if( ttt ) fprintf(stderr, "ld pad_to_node %d\n",
MRILIB_DomainMaxNodeIndex);
} else if (!strncasecmp(argv[ii],"rd",2)) {
if (strlen(argv[ii]) < 3) {
fprintf(stderr,"** need a number right after rd (like rd6)\n");
exit(1);
}
MRILIB_DomainMaxNodeIndex = SUMA_IcoNums(atoi(argv[ii]+2), 1, 'n')-1;
if( ttt ) fprintf(stderr, "rd pad_to_node %d\n",
MRILIB_DomainMaxNodeIndex);
} else if (!strncasecmp(argv[ii],"d:",2)) {
THD_3dim_dataset *dset=NULL;
if (strlen(argv[ii]) < 3) {
fprintf(stderr,
"** need a dataset right after d: (like d:hello.niml.dset)\n");
exit(1);
}
dset = THD_open_dataset(argv[ii]+2);
if (dset) {
DSET_MAX_NODE(dset, MRILIB_DomainMaxNodeIndex);
DSET_delete(dset); dset = NULL;
if( ttt ) fprintf(stderr, "d: pad_to_node %d\n",
MRILIB_DomainMaxNodeIndex);
} else {
fprintf(stderr,"** Could not load dset %s to determine padding\n",
argv[ii]+2);
}
} else {
MRILIB_DomainMaxNodeIndex = atoi(argv[ii]);
if( ttt ) fprintf(stderr, "pad_to_node %d\n",
MRILIB_DomainMaxNodeIndex);
}
if (MRILIB_DomainMaxNodeIndex < 0) {
fprintf(stderr,"** parameter for -pad_to_node (%d) is negative!\n",
MRILIB_DomainMaxNodeIndex);
exit(1);
}else if (MRILIB_DomainMaxNodeIndex > 500000) {
fprintf(stderr,
"** parameter for -pad_to_node (%d) is suspiciously large.\n"
" I hope you know what you're doing.\n",
MRILIB_DomainMaxNodeIndex );
}
used[ii] = 1;
continue ;
}
if( strcmp(argv[ii],"-np") == 0 ||
strcmp(argv[ii],"-npq") == 0 ){ /* ZSS, June 2011 */
if( ttt ) fprintf(stderr,"++ argv[%d] is -np\n",ii) ;
if (ii+1 >= narg) {
fprintf(stderr,
"** -np needs an integer NP such that 1024 <= NP <= 65500\n");
exit(1);
}
used[ii] = 1 ; ii++;
if (set_user_np(atoi(argv[ii]))<1) {
if (strcmp(argv[ii-1],"-npq")) { /* not quiet mode? */
fprintf(stderr,
"** -np is not an integer such that 1024 <= NP <= 65500\n"
" -np was ignored\n");
}
} else {
if (strcmp(argv[ii-1],"-npq"))
fprintf(stderr,"++ -np set to %d\n", get_user_np());
}
used[ii] = 1;
continue ;
}
if( strcmp(argv[ii],"-npb") == 0 ){ /* ZSS, June 2011 */
if( ttt ) fprintf(stderr,"++ argv[%d] is -npb\n",ii) ;
if (ii+1 >= narg) {
fprintf(stderr,
"** -npb needs an integer NPB such that 0 <= NPB <= %d\n",
get_max_port_bloc());
exit(1);
}
used[ii] = 1 ; ii++;
if (set_user_np_bloc(atoi(argv[ii]))<1) {
fprintf(stderr,
"** -npb is not an integer such that 0 <= NPB <= %d\n"
" -npb was ignored\n", get_max_port_bloc());
}
used[ii] = 1;
continue ;
}
if( strcmp(argv[ii],"-pif") == 0 ){ /* ZSS, June 2011 */
if( ttt ) fprintf(stderr,"++ argv[%d] is -pif\n",ii) ;
if (ii+1 >= narg) {
fprintf(stderr,
"** -pif needs a string value\n");
exit(1);
}
used[ii] = 1 ; ii++;
set_user_pif(argv[ii]);
used[ii] = 1;
continue ;
}
/* -max_port_bloc number and quit */
if( strncmp(argv[ii],"-max_port_bloc", 8) == 0) {
int pp = 0;
pp = get_max_port_bloc();
if (strcmp(argv[ii-1], "-max_port_bloc_quiet")) {
fprintf(stdout, "Maximum port bloc number: %d\n",
pp);
} else {
fprintf(stdout, "%d\n", pp);
}
exit(0);
}
/* -num_assigned port number and quit */
if( strncmp(argv[ii],"-num_assigned_ports", 8) == 0) {
int pp = 0;
pp = get_max_port_bloc();
if (strcmp(argv[ii-1], "-num_assigned_ports_quiet")) {
fprintf(stdout, "Number of assigned ports: %d\n",
pp);
} else {
fprintf(stdout, "%d\n", pp);
}
exit(0);
}
/*** if get to here, argv[ii] is nothing special ***/
} /* end of loop over argv[] */
/*--- compress out used up argv[] entries ---*/
for( nused=0,ii=narg-1 ; ii >= 1 ; ii-- ){
if( !used[ii] ) continue ;
for( jj=ii+1 ; jj < narg ; jj++ ) argv[jj-1] = argv[jj] ;
argv[narg-1] = NULL ; narg-- ; nused++ ;
}
if( ttt && nused > 0 )
fprintf(stderr,"++ 'used up' %d argv[] entries, leaving %d\n",nused,narg) ;
free((void *)used) ; *argc = narg ; return(nused);
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *old_dset , *new_dset ; /* input and output datasets */
THD_3dim_dataset *mask_dset=NULL ;
float mask_bot=666.0 , mask_top=-666.0 ;
byte *cmask=NULL ; int ncmask=0 ;
byte *mmm = NULL ;
int mcount=0, verb=0;
int nopt, nbriks, ii ;
int addBriks = 0 ; /* n-1 sub-bricks out */
int fullBriks = 0 ; /* n sub-bricks out */
int tsout = 0 ; /* flag to output a time series (not a stat bucket) */
int numMultBriks,methIndex,brikIndex;
/*----- Help the pitiful user? -----*/
/* bureaucracy */
mainENTRY("3dTstat main"); machdep(); AFNI_logger("3dTstat",argc,argv);
PRINT_VERSION("3dTstat"); AUTHOR("KR Hammett & RW Cox");
/*--- scan command line for options ---*/
if (argc == 1) { usage_3dTstat(1); exit(0); } /* Bob's help shortcut */
nopt = 1 ;
nbriks = 0 ;
nmeths = 0 ;
verb = 0;
while( nopt < argc && argv[nopt][0] == '-' ){
if (strcmp(argv[nopt], "-h") == 0 || strcmp(argv[nopt], "-help") == 0) {
usage_3dTstat(strlen(argv[nopt]) > 3 ? 2:1);
exit(0);
}
if( strcmp(argv[nopt],"-verb") == 0 ){
verb++ ; nopt++ ; continue ;
}
/*-- methods --*/
if( strcasecmp(argv[nopt],"-centromean") == 0 ){ /* 01 Nov 2010 */
meth[nmeths++] = METH_CENTROMEAN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-bmv") == 0 ){
meth[nmeths++] = METH_BMV ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-median") == 0 ){
meth[nmeths++] = METH_MEDIAN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-nzmedian") == 0 ){
meth[nmeths++] = METH_NZMEDIAN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-DW") == 0 ){
meth[nmeths++] = METH_DW ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-zcount") == 0 ){
meth[nmeths++] = METH_ZCOUNT ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-nzcount") == 0 ){
meth[nmeths++] = METH_NZCOUNT ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-MAD") == 0 ){
meth[nmeths++] = METH_MAD ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-mean") == 0 ){
meth[nmeths++] = METH_MEAN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-sum") == 0 ){
meth[nmeths++] = METH_SUM ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-sos") == 0 ){
meth[nmeths++] = METH_SUM_SQUARES ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-abssum") == 0 ){
meth[nmeths++] = METH_ABSSUM ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-slope") == 0 ){
meth[nmeths++] = METH_SLOPE ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-stdev") == 0 ||
strcasecmp(argv[nopt],"-sigma") == 0 ){
meth[nmeths++] = METH_SIGMA ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-cvar") == 0 ){
meth[nmeths++] = METH_CVAR ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-cvarinv") == 0 ){
meth[nmeths++] = METH_CVARINV ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-stdevNOD") == 0 ||
strcasecmp(argv[nopt],"-sigmaNOD") == 0 ){ /* 07 Dec 2001 */
meth[nmeths++] = METH_SIGMA_NOD ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-cvarNOD") == 0 ){ /* 07 Dec 2001 */
meth[nmeths++] = METH_CVAR_NOD ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-cvarinvNOD") == 0 ){
meth[nmeths++] = METH_CVARINVNOD ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-min") == 0 ){
meth[nmeths++] = METH_MIN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-max") == 0 ){
meth[nmeths++] = METH_MAX ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-absmax") == 0 ){
meth[nmeths++] = METH_ABSMAX ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-signed_absmax") == 0 ){
meth[nmeths++] = METH_SIGNED_ABSMAX ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argmin") == 0 ){
meth[nmeths++] = METH_ARGMIN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argmin1") == 0 ){
meth[nmeths++] = METH_ARGMIN1 ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argmax") == 0 ){
meth[nmeths++] = METH_ARGMAX ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argmax1") == 0 ){
meth[nmeths++] = METH_ARGMAX1 ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argabsmax") == 0 ){
meth[nmeths++] = METH_ARGABSMAX ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-argabsmax1") == 0 ){
meth[nmeths++] = METH_ARGABSMAX1;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-duration") == 0 ){
meth[nmeths++] = METH_DURATION ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-onset") == 0 ){
meth[nmeths++] = METH_ONSET ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-offset") == 0 ){
meth[nmeths++] = METH_OFFSET ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-centroid") == 0 ){
meth[nmeths++] = METH_CENTROID ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-centduration") == 0 ){
meth[nmeths++] = METH_CENTDURATION ;
nbriks++ ;
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-nzmean") == 0 ){
meth[nmeths++] = METH_NZMEAN ;
nbriks++ ;
nopt++ ; continue ;
}
if( strncmp(argv[nopt],"-mask",5) == 0 ){
if( mask_dset != NULL )
ERROR_exit("Cannot have two -mask options!\n") ;
if( nopt+1 >= argc )
ERROR_exit("-mask option requires a following argument!\n");
mask_dset = THD_open_dataset( argv[++nopt] ) ;
if( mask_dset == NULL )
ERROR_exit("Cannot open mask dataset!\n") ;
if( DSET_BRICK_TYPE(mask_dset,0) == MRI_complex )
ERROR_exit("Cannot deal with complex-valued mask dataset!\n");
nopt++ ; continue ;
}
if( strncmp(argv[nopt],"-mrange",5) == 0 ){
if( nopt+2 >= argc )
ERROR_exit("-mrange option requires 2 following arguments!\n");
mask_bot = strtod( argv[++nopt] , NULL ) ;
mask_top = strtod( argv[++nopt] , NULL ) ;
if( mask_top < mask_top )
ERROR_exit("-mrange inputs are illegal!\n") ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-cmask") == 0 ){ /* 16 Mar 2000 */
if( nopt+1 >= argc )
ERROR_exit("-cmask option requires a following argument!\n");
cmask = EDT_calcmask( argv[++nopt] , &ncmask, 0 ) ;
if( cmask == NULL ) ERROR_exit("Can't compute -cmask!\n");
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-autocorr") == 0 ){
meth[nmeths++] = METH_AUTOCORR ;
if( ++nopt >= argc ) ERROR_exit("-autocorr needs an argument!\n");
meth[nmeths++] = atoi(argv[nopt++]);
if (meth[nmeths - 1] == 0) {
addBriks++;
} else {
nbriks+=meth[nmeths - 1] ;
}
continue ;
}
if( strcasecmp(argv[nopt],"-autoreg") == 0 ){
meth[nmeths++] = METH_AUTOREGP ;
if( ++nopt >= argc ) ERROR_exit("-autoreg needs an argument!\n");
meth[nmeths++] = atoi(argv[nopt++]);
if (meth[nmeths - 1] == 0) {
addBriks++;
} else {
nbriks+=meth[nmeths - 1] ;
}
continue ;
}
if( strcasecmp(argv[nopt],"-accumulate") == 0 ){ /* 4 Mar 2008 [rickr] */
meth[nmeths++] = METH_ACCUMULATE ;
meth[nmeths++] = -1; /* flag to add N (not N-1) output bricks */
fullBriks++;
tsout = 1; /* flag to output a timeseries */
nopt++ ; continue ;
}
if( strcasecmp(argv[nopt],"-l2norm") == 0 ){ /* 07 Jan 2013 [rickr] */
meth[nmeths++] = METH_L2_NORM ;
nbriks++ ;
nopt++ ; continue ;
}
/*-- prefix --*/
if( strcasecmp(argv[nopt],"-prefix") == 0 ){
if( ++nopt >= argc ) ERROR_exit("-prefix needs an argument!\n");
MCW_strncpy(prefix,argv[nopt],THD_MAX_PREFIX) ;
if( !THD_filename_ok(prefix) )
ERROR_exit("%s is not a valid prefix!\n",prefix);
nopt++ ; continue ;
}
/*-- tdiff --*/
if( strcasecmp(argv[nopt],"-tdiff") == 0 ){ /* 25 May 2011 */
do_tdiff = 1 ; nopt++ ; continue ;
}
/*-- nscale --*/
if( strcasecmp(argv[nopt],"-nscale") == 0 ){ /* 25 May 2011 */
nscale = 1 ; nopt++ ; continue ;
}
/*-- datum --*/
if( strcasecmp(argv[nopt],"-datum") == 0 ){
if( ++nopt >= argc ) ERROR_exit("-datum needs an argument!\n");
if( strcasecmp(argv[nopt],"short") == 0 ){
datum = MRI_short ;
} else if( strcasecmp(argv[nopt],"float") == 0 ){
datum = MRI_float ;
} else if( strcasecmp(argv[nopt],"byte") == 0 ){
datum = MRI_byte ;
} else {
ERROR_exit("-datum of type '%s' is not supported!\n",
argv[nopt] ) ;
}
nopt++ ; continue ;
}
/* base percentage for duration calcs */
if (strcasecmp (argv[nopt], "-basepercent") == 0) {
if( ++nopt >= argc ) ERROR_exit("-basepercent needs an argument!\n");
basepercent = strtod(argv[nopt], NULL);
if(basepercent>1) basepercent /= 100.0; /* assume integer percent if >1*/
nopt++; continue;
}
/*-- Quien sabe'? --*/
ERROR_message("Unknown option: %s\n",argv[nopt]) ;
suggest_best_prog_option(argv[0], argv[nopt]);
exit(1);
}
if (argc < 2) {
ERROR_message("Too few options, use -help for details");
exit(1);
}
/*--- If no options selected, default to single stat MEAN -- KRH ---*/
if (nmeths == 0) nmeths = 1;
if (nbriks == 0 && addBriks == 0 && fullBriks == 0) nbriks = 1;
/*----- read input dataset -----*/
if( nopt >= argc ) ERROR_exit(" No input dataset!?") ;
old_dset = THD_open_dataset( argv[nopt] ) ;
if( !ISVALID_DSET(old_dset) )
ERROR_exit("Can't open dataset %s\n",argv[nopt]);
nopt++ ;
if( nopt < argc )
WARNING_message("Trailing datasets on command line ignored: %s ...",argv[nopt]) ;
if( DSET_NVALS(old_dset) == 1 ){
WARNING_message("Input dataset has 1 sub-brick ==> -tdiff is turned off") ;
do_tdiff = 0 ;
}
/* no input volumes is bad, 1 volume applies to only certain methods */
/* 2 Nov 2010 [rickr] */
if( DSET_NVALS(old_dset) == 0 ) {
ERROR_exit("Time series is of length 0?\n") ;
}
else if( DSET_NVALS(old_dset) == 1 || (do_tdiff && DSET_NVALS(old_dset)==2) ) {
int methOK, OK = 1;
/* see if each method is valid for nvals == 1 */
for( methIndex = 0; methIndex < nmeths; methIndex++ ) {
methOK = 0;
for( ii = 0; ii < NUM_1_INPUT_METHODS; ii++ ) {
if( meth[methIndex] == valid_1_input_methods[ii] ) {
methOK = 1;
break;
}
}
if( ! methOK )
ERROR_exit("Can't use dataset with %d values per voxel!" ,
DSET_NVALS(old_dset) ) ;
}
/* tell the library function that this case is okay */
g_thd_maker_allow_1brick = 1;
}
if( DSET_NUM_TIMES(old_dset) < 2 ){
WARNING_message("Input dataset is not 3D+time; assuming TR=1.0") ;
EDIT_dset_items( old_dset ,
ADN_ntt , DSET_NVALS(old_dset) ,
ADN_ttorg , 0.0 ,
ADN_ttdel , 1.0 ,
ADN_tunits , UNITS_SEC_TYPE ,
NULL ) ;
}
/* If one or more of the -autocorr/-autoreg options was called with */
/* an argument of 0, then I'll now add extra BRIKs for the N-1 data */
/* output points for each. */
nbriks += ((DSET_NVALS(old_dset)-1) * addBriks);
nbriks += ((DSET_NVALS(old_dset) ) * fullBriks);
/* ------------- Mask business -----------------*/
if( mask_dset == NULL ){
mmm = NULL ;
if( verb )
INFO_message("%d voxels in the entire dataset (no mask)\n",
DSET_NVOX(old_dset)) ;
} else {
if( DSET_NVOX(mask_dset) != DSET_NVOX(old_dset) )
ERROR_exit("Input and mask datasets are not same dimensions!\n");
mmm = THD_makemask( mask_dset , 0 , mask_bot, mask_top ) ;
mcount = THD_countmask( DSET_NVOX(old_dset) , mmm ) ;
if( mcount <= 0 ) ERROR_exit("No voxels in the mask!\n") ;
if( verb ) INFO_message("%d voxels in the mask\n",mcount) ;
DSET_delete(mask_dset) ;
}
if( cmask != NULL ){
if( ncmask != DSET_NVOX(old_dset) )
ERROR_exit("Input and cmask datasets are not same dimensions!\n");
if( mmm != NULL ){
for( ii=0 ; ii < DSET_NVOX(old_dset) ; ii++ )
mmm[ii] = (mmm[ii] && cmask[ii]) ;
free(cmask) ;
mcount = THD_countmask( DSET_NVOX(old_dset) , mmm ) ;
if( mcount <= 0 ) ERROR_exit("No voxels in the mask+cmask!\n") ;
if( verb ) INFO_message("%d voxels in the mask+cmask\n",mcount) ;
} else {
mmm = cmask ;
mcount = THD_countmask( DSET_NVOX(old_dset) , mmm ) ;
if( mcount <= 0 ) ERROR_exit("No voxels in the cmask!\n") ;
if( verb ) INFO_message("%d voxels in the cmask\n",mcount) ;
}
}
/*------------- ready to compute new dataset -----------*/
new_dset = MAKER_4D_to_typed_fbuc(
old_dset , /* input dataset */
prefix , /* output prefix */
datum , /* output datum */
0 , /* ignore count */
0 , /* can't detrend in maker function KRH 12/02*/
nbriks , /* number of briks */
STATS_tsfunc , /* timeseries processor */
NULL, /* data for tsfunc */
mmm,
nscale
) ;
if( new_dset != NULL ){
tross_Copy_History( old_dset , new_dset ) ;
tross_Make_History( "3dTstat" , argc,argv , new_dset ) ;
for (methIndex = 0,brikIndex = 0; methIndex < nmeths;
methIndex++, brikIndex++) {
if ((meth[methIndex] == METH_AUTOCORR) ||
(meth[methIndex] == METH_ACCUMULATE) ||
(meth[methIndex] == METH_AUTOREGP)) {
numMultBriks = meth[methIndex+1];
/* note: this looks like it should be NV-1 4 Mar 2008 [rickr] */
if (numMultBriks == 0) numMultBriks = DSET_NVALS(old_dset)-1;
/* new flag for NVALS [rickr] */
if (numMultBriks == -1) numMultBriks = DSET_NVALS(old_dset);
for (ii = 1; ii <= numMultBriks; ii++) {
char tmpstr[25];
if (meth[methIndex] == METH_AUTOREGP) {
sprintf(tmpstr,"%s[%d](%d)",meth_names[meth[methIndex]],
numMultBriks,ii);
} else {
sprintf(tmpstr,"%s(%d)",meth_names[meth[methIndex]],ii);
}
EDIT_BRICK_LABEL(new_dset, (brikIndex + ii - 1), tmpstr) ;
}
methIndex++;
brikIndex += numMultBriks - 1;
} else {
EDIT_BRICK_LABEL(new_dset, brikIndex, meth_names[meth[methIndex]]) ;
}
}
if( tsout ) /* then change output to a time series */
EDIT_dset_items( new_dset ,
ADN_ntt , brikIndex ,
ADN_ttorg , DSET_TIMEORIGIN(old_dset) ,
ADN_ttdel , DSET_TIMESTEP(old_dset) ,
ADN_tunits , DSET_TIMEUNITS(old_dset) ,
NULL ) ;
DSET_write( new_dset ) ;
WROTE_DSET( new_dset ) ;
} else {
ERROR_exit("Unable to compute output dataset!\n") ;
}
exit(0) ;
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *yset=NULL , *aset=NULL , *mset=NULL , *wset=NULL ;
MRI_IMAGE *fim=NULL, *qim,*tim, *pfim=NULL , *vim , *wim=NULL ;
float *flar , *qar,*tar, *par=NULL , *var , *war=NULL ;
MRI_IMARR *fimar=NULL ;
MRI_IMAGE *aim , *yim ; float *aar , *yar ;
int nt=0 , nxyz=0 , nvox=0 , nparam=0 , nqbase , polort=0 , ii,jj,kk,bb ;
byte *mask=NULL ; int nmask=0 , iarg ;
char *fname_out="-" ; /** equiv to stdout **/
float alpha=0.0f ;
int nfir =0 ; float firwt[5]={0.09f,0.25f,0.32f,0.25f,0.09f} ;
int nmed =0 ;
int nwt =0 ;
#define METHOD_C 3
#define METHOD_K 11
int method = METHOD_C ;
/**--- help the pitiful user? ---**/
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"Usage: 3dInvFMRI [options]\n"
"Program to compute stimulus time series, given a 3D+time dataset\n"
"and an activation map (the inverse of the usual FMRI analysis problem).\n"
"-------------------------------------------------------------------\n"
"OPTIONS:\n"
"\n"
" -data yyy =\n"
" *OR* = Defines input 3D+time dataset [a non-optional option].\n"
" -input yyy =\n"
"\n"
" -map aaa = Defines activation map; 'aaa' should be a bucket dataset,\n"
" each sub-brick of which defines the beta weight map for\n"
" an unknown stimulus time series [also non-optional].\n"
"\n"
" -mapwt www = Defines a weighting factor to use for each element of\n"
" the map. The dataset 'www' can have either 1 sub-brick,\n"
" or the same number as in the -map dataset. In the\n"
" first case, in each voxel, each sub-brick of the map\n"
" gets the same weight in the least squares equations.\n"
" [default: all weights are 1]\n"
"\n"
" -mask mmm = Defines a mask dataset, to restrict input voxels from\n"
" -data and -map. [default: all voxels are used]\n"
"\n"
" -base fff = Each column of the 1D file 'fff' defines a baseline time\n"
" series; these columns should be the same length as\n"
" number of time points in 'yyy'. Multiple -base options\n"
" can be given.\n"
" -polort pp = Adds polynomials of order 'pp' to the baseline collection.\n"
" The default baseline model is '-polort 0' (constant).\n"
" To specify no baseline model at all, use '-polort -1'.\n"
"\n"
" -out vvv = Name of 1D output file will be 'vvv'.\n"
" [default = '-', which is stdout; probably not good]\n"
"\n"
" -method M = Determines the method to use. 'M' is a single letter:\n"
" -method C = least squares fit to data matrix Y [default]\n"
" -method K = least squares fit to activation matrix A\n"
"\n"
" -alpha aa = Set the 'alpha' factor to 'aa'; alpha is used to penalize\n"
" large values of the output vectors. Default is 0.\n"
" A large-ish value for alpha would be 0.1.\n"
"\n"
" -fir5 = Smooth the results with a 5 point lowpass FIR filter.\n"
" -median5 = Smooth the results with a 5 point median filter.\n"
" [default: no smoothing; only 1 of these can be used]\n"
"-------------------------------------------------------------------\n"
"METHODS:\n"
" Formulate the problem as\n"
" Y = V A' + F C' + errors\n"
" where Y = data matrix (N x M) [from -data]\n"
" V = stimulus (N x p) [to -out]\n"
" A = map matrix (M x p) [from -map]\n"
" F = baseline matrix (N x q) [from -base and -polort]\n"
" C = baseline weights (M x q) [not computed]\n"
" N = time series length = length of -data file\n"
" M = number of voxels in mask\n"
" p = number of stimulus time series to estimate\n"
" = number of parameters in -map file\n"
" q = number of baseline parameters\n"
" and ' = matrix transpose operator\n"
" Next, define matrix Z (Y detrended relative to columns of F) by\n"
" -1\n"
" Z = [I - F(F'F) F'] Y\n"
"-------------------------------------------------------------------\n"
" The method C solution is given by\n"
" -1\n"
" V0 = Z A [A'A]\n"
"\n"
" This solution minimizes the sum of squares over the N*M elements\n"
" of the matrix Y - V A' + F C' (N.B.: A' means A-transpose).\n"
"-------------------------------------------------------------------\n"
" The method K solution is given by\n"
" -1 -1\n"
" W = [Z Z'] Z A and then V = W [W'W]\n"
"\n"
" This solution minimizes the sum of squares of the difference between\n"
" the A(V) predicted from V and the input A, where A(V) is given by\n"
" -1\n"
" A(V) = Z' V [V'V] = Z'W\n"
"-------------------------------------------------------------------\n"
" Technically, the solution is unidentfiable up to an arbitrary\n"
" multiple of the columns of F (i.e., V = V0 + F G, where G is\n"
" an arbitrary q x p matrix); the solution above is the solution\n"
" that is orthogonal to the columns of F.\n"
"\n"
"-- RWCox - March 2006 - purely for experimental purposes!\n"
) ;
printf("\n"
"===================== EXAMPLE USAGE =====================================\n"
"** Step 1: From a training dataset, generate activation map.\n"
" The input dataset has 4 runs, each 108 time points long. 3dDeconvolve\n"
" is used on the first 3 runs (time points 0..323) to generate the\n"
" activation map. There are two visual stimuli (Complex and Simple).\n"
"\n"
" 3dDeconvolve -x1D xout_short_two.1D -input rall_vr+orig'[0..323]' \\\n"
" -num_stimts 2 \\\n"
" -stim_file 1 hrf_complex.1D -stim_label 1 Complex \\\n"
" -stim_file 2 hrf_simple.1D -stim_label 2 Simple \\\n"
" -concat '1D:0,108,216' \\\n"
" -full_first -fout -tout \\\n"
" -bucket func_ht2_short_two -cbucket cbuc_ht2_short_two\n"
"\n"
" N.B.: You may want to de-spike, smooth, and register the 3D+time\n"
" dataset prior to the analysis (as usual). These steps are not\n"
" shown here -- I'm presuming you know how to use AFNI already.\n"
"\n"
"** Step 2: Create a mask of highly activated voxels.\n"
" The F statistic threshold is set to 30, corresponding to a voxel-wise\n"
" p = 1e-12 = very significant. The mask is also lightly clustered, and\n"
" restricted to brain voxels.\n"
"\n"
" 3dAutomask -prefix Amask rall_vr+orig\n"
" 3dcalc -a 'func_ht2_short+orig[0]' -b Amask+orig -datum byte \\\n"
" -nscale -expr 'step(a-30)*b' -prefix STmask300\n"
" 3dmerge -dxyz=1 -1clust 1.1 5 -prefix STmask300c STmask300+orig\n"
"\n"
"** Step 3: Run 3dInvFMRI to estimate the stimulus functions in run #4.\n"
" Run #4 is time points 324..431 of the 3D+time dataset (the -data\n"
" input below). The -map input is the beta weights extracted from\n"
" the -cbucket output of 3dDeconvolve.\n"
"\n"
" 3dInvFMRI -mask STmask300c+orig \\\n"
" -data rall_vr+orig'[324..431]' \\\n"
" -map cbuc_ht2_short_two+orig'[6..7]' \\\n"
" -polort 1 -alpha 0.01 -median5 -method K \\\n"
" -out ii300K_short_two.1D\n"
"\n"
" 3dInvFMRI -mask STmask300c+orig \\\n"
" -data rall_vr+orig'[324..431]' \\\n"
" -map cbuc_ht2_short_two+orig'[6..7]' \\\n"
" -polort 1 -alpha 0.01 -median5 -method C \\\n"
" -out ii300C_short_two.1D\n"
"\n"
"** Step 4: Plot the results, and get confused.\n"
"\n"
" 1dplot -ynames VV KK CC -xlabel Run#4 -ylabel ComplexStim \\\n"
" hrf_complex.1D'{324..432}' \\\n"
" ii300K_short_two.1D'[0]' \\\n"
" ii300C_short_two.1D'[0]'\n"
"\n"
" 1dplot -ynames VV KK CC -xlabel Run#4 -ylabel SimpleStim \\\n"
" hrf_simple.1D'{324..432}' \\\n"
" ii300K_short_two.1D'[1]' \\\n"
" ii300C_short_two.1D'[1]'\n"
"\n"
" N.B.: I've found that method K works better if MORE voxels are\n"
" included in the mask (lower threshold) and method C if\n"
" FEWER voxels are included. The above threshold gave 945\n"
" voxels being used to determine the 2 output time series.\n"
"=========================================================================\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
/**--- bureaucracy ---**/
mainENTRY("3dInvFMRI main"); machdep();
PRINT_VERSION("3dInvFMRI"); AUTHOR("Zhark");
AFNI_logger("3dInvFMRI",argc,argv) ;
/**--- scan command line ---**/
iarg = 1 ;
while( iarg < argc ){
if( strcmp(argv[iarg],"-method") == 0 ){
switch( argv[++iarg][0] ){
default:
WARNING_message("Ignoring illegal -method '%s'",argv[iarg]) ;
break ;
case 'C': method = METHOD_C ; break ;
case 'K': method = METHOD_K ; break ;
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-fir5") == 0 ){
if( nmed > 0 ) WARNING_message("Ignoring -fir5 in favor of -median5") ;
else nfir = 5 ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-median5") == 0 ){
if( nfir > 0 ) WARNING_message("Ignoring -median5 in favor of -fir5") ;
else nmed = 5 ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-alpha") == 0 ){
alpha = (float)strtod(argv[++iarg],NULL) ;
if( alpha <= 0.0f ){
alpha = 0.0f ; WARNING_message("-alpha '%s' ignored!",argv[iarg]) ;
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-data") == 0 || strcmp(argv[iarg],"-input") == 0 ){
if( yset != NULL ) ERROR_exit("Can't input 2 3D+time datasets") ;
yset = THD_open_dataset(argv[++iarg]) ;
CHECK_OPEN_ERROR(yset,argv[iarg]) ;
nt = DSET_NVALS(yset) ;
if( nt < 2 ) ERROR_exit("Only 1 sub-brick in dataset %s",argv[iarg]) ;
nxyz = DSET_NVOX(yset) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-map") == 0 ){
if( aset != NULL ) ERROR_exit("Can't input 2 -map datasets") ;
aset = THD_open_dataset(argv[++iarg]) ;
CHECK_OPEN_ERROR(aset,argv[iarg]) ;
nparam = DSET_NVALS(aset) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mapwt") == 0 ){
if( wset != NULL ) ERROR_exit("Can't input 2 -mapwt datasets") ;
wset = THD_open_dataset(argv[++iarg]) ;
CHECK_OPEN_ERROR(wset,argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mask") == 0 ){
if( mset != NULL ) ERROR_exit("Can't input 2 -mask datasets") ;
mset = THD_open_dataset(argv[++iarg]) ;
CHECK_OPEN_ERROR(mset,argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-polort") == 0 ){
char *cpt ;
polort = (int)strtod(argv[++iarg],&cpt) ;
if( *cpt != '\0' ) WARNING_message("Illegal non-numeric value after -polort") ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out") == 0 ){
fname_out = strdup(argv[++iarg]) ;
if( !THD_filename_ok(fname_out) )
ERROR_exit("Bad -out filename '%s'",fname_out) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-base") == 0 ){
if( fimar == NULL ) INIT_IMARR(fimar) ;
qim = mri_read_1D( argv[++iarg] ) ;
if( qim == NULL ) ERROR_exit("Can't read 1D file %s",argv[iarg]) ;
ADDTO_IMARR(fimar,qim) ;
iarg++ ; continue ;
}
ERROR_exit("Unrecognized option '%s'",argv[iarg]) ;
}
/**--- finish up processing options ---**/
if( yset == NULL ) ERROR_exit("No input 3D+time dataset?!") ;
if( aset == NULL ) ERROR_exit("No input FMRI -map dataset?!") ;
if( DSET_NVOX(aset) != nxyz )
ERROR_exit("Grid mismatch between -data and -map") ;
INFO_message("Loading dataset for Y") ;
DSET_load(yset); CHECK_LOAD_ERROR(yset) ;
INFO_message("Loading dataset for A") ;
DSET_load(aset); CHECK_LOAD_ERROR(aset) ;
if( wset != NULL ){
if( DSET_NVOX(wset) != nxyz )
ERROR_exit("Grid mismatch between -data and -mapwt") ;
nwt = DSET_NVALS(wset) ;
if( nwt > 1 && nwt != nparam )
ERROR_exit("Wrong number of values=%d in -mapwt; should be 1 or %d",
nwt , nparam ) ;
INFO_message("Loading dataset for mapwt") ;
DSET_load(wset); CHECK_LOAD_ERROR(wset) ;
}
if( mset != NULL ){
if( DSET_NVOX(mset) != nxyz )
ERROR_exit("Grid mismatch between -data and -mask") ;
INFO_message("Loading dataset for mask") ;
DSET_load(mset); CHECK_LOAD_ERROR(mset) ;
mask = THD_makemask( mset , 0 , 1.0f,-1.0f ); DSET_delete(mset);
nmask = THD_countmask( nxyz , mask ) ;
if( nmask < 3 ){
WARNING_message("Mask has %d voxels -- ignoring!",nmask) ;
free(mask) ; mask = NULL ; nmask = 0 ;
}
}
nvox = (nmask > 0) ? nmask : nxyz ;
INFO_message("N = time series length = %d",nt ) ;
INFO_message("M = number of voxels = %d",nvox ) ;
INFO_message("p = number of params = %d",nparam) ;
/**--- set up baseline funcs in one array ---*/
nqbase = (polort >= 0 ) ? polort+1 : 0 ;
if( fimar != NULL ){
for( kk=0 ; kk < IMARR_COUNT(fimar) ; kk++ ){
qim = IMARR_SUBIMAGE(fimar,kk) ;
if( qim != NULL && qim->nx != nt )
WARNING_message("-base #%d length=%d; data length=%d",kk+1,qim->nx,nt) ;
nqbase += qim->ny ;
}
}
INFO_message("q = number of baselines = %d",nqbase) ;
#undef F
#define F(i,j) flar[(i)+(j)*nt] /* nt X nqbase */
if( nqbase > 0 ){
fim = mri_new( nt , nqbase , MRI_float ) ; /* F matrix */
flar = MRI_FLOAT_PTR(fim) ;
bb = 0 ;
if( polort >= 0 ){ /** load polynomial baseline **/
double a = 2.0/(nt-1.0) ;
for( jj=0 ; jj <= polort ; jj++ ){
for( ii=0 ; ii < nt ; ii++ )
F(ii,jj) = (float)Plegendre( a*ii-1.0 , jj ) ;
}
bb = polort+1 ;
}
#undef Q
#define Q(i,j) qar[(i)+(j)*qim->nx] /* qim->nx X qim->ny */
if( fimar != NULL ){ /** load -base baseline columns **/
for( kk=0 ; kk < IMARR_COUNT(fimar) ; kk++ ){
qim = IMARR_SUBIMAGE(fimar,kk) ; qar = MRI_FLOAT_PTR(qim) ;
for( jj=0 ; jj < qim->ny ; jj++ ){
for( ii=0 ; ii < nt ; ii++ )
F(ii,bb+jj) = (ii < qim->nx) ? Q(ii,jj) : 0.0f ;
}
bb += qim->ny ;
}
DESTROY_IMARR(fimar) ; fimar=NULL ;
}
/* remove mean from each column after first? */
if( polort >= 0 && nqbase > 1 ){
float sum ;
for( jj=1 ; jj < nqbase ; jj++ ){
sum = 0.0f ;
for( ii=0 ; ii < nt ; ii++ ) sum += F(ii,jj) ;
sum /= nt ;
for( ii=0 ; ii < nt ; ii++ ) F(ii,jj) -= sum ;
}
}
/* compute pseudo-inverse of baseline matrix,
so we can project it out from the data time series */
/* -1 */
/* (F'F) F' matrix */
INFO_message("Computing pseudo-inverse of baseline matrix F") ;
pfim = mri_matrix_psinv(fim,NULL,0.0f) ; par = MRI_FLOAT_PTR(pfim) ;
#undef P
#define P(i,j) par[(i)+(j)*nqbase] /* nqbase X nt */
#if 0
qim = mri_matrix_transpose(pfim) ; /** save to disk? **/
mri_write_1D( "Fpsinv.1D" , qim ) ;
mri_free(qim) ;
#endif
}
/**--- set up map image into aim/aar = A matrix ---**/
#undef GOOD
#define GOOD(i) (mask==NULL || mask[i])
#undef A
#define A(i,j) aar[(i)+(j)*nvox] /* nvox X nparam */
INFO_message("Loading map matrix A") ;
aim = mri_new( nvox , nparam , MRI_float ); aar = MRI_FLOAT_PTR(aim);
for( jj=0 ; jj < nparam ; jj++ ){
for( ii=kk=0 ; ii < nxyz ; ii++ ){
if( GOOD(ii) ){ A(kk,jj) = THD_get_voxel(aset,ii,jj); kk++; }
}}
DSET_unload(aset) ;
/**--- set up map weight into wim/war ---**/
#undef WT
#define WT(i,j) war[(i)+(j)*nvox] /* nvox X nparam */
if( wset != NULL ){
int numneg=0 , numpos=0 ;
float fac ;
INFO_message("Loading map weight matrix") ;
wim = mri_new( nvox , nwt , MRI_float ) ; war = MRI_FLOAT_PTR(wim) ;
for( jj=0 ; jj < nwt ; jj++ ){
for( ii=kk=0 ; ii < nxyz ; ii++ ){
if( GOOD(ii) ){
WT(kk,jj) = THD_get_voxel(wset,ii,jj);
if( WT(kk,jj) > 0.0f ){ numpos++; WT(kk,jj) = sqrt(WT(kk,jj)); }
else if( WT(kk,jj) < 0.0f ){ numneg++; WT(kk,jj) = 0.0f; }
kk++;
}
}}
DSET_unload(wset) ;
if( numpos <= nparam )
WARNING_message("Only %d positive weights found in -wtmap!",numpos) ;
if( numneg > 0 )
WARNING_message("%d negative weights found in -wtmap!",numneg) ;
for( jj=0 ; jj < nwt ; jj++ ){
fac = 0.0f ;
for( kk=0 ; kk < nvox ; kk++ ) if( WT(kk,jj) > fac ) fac = WT(kk,jj) ;
if( fac > 0.0f ){
fac = 1.0f / fac ;
for( kk=0 ; kk < nvox ; kk++ ) WT(kk,jj) *= fac ;
}
}
}
/**--- set up data image into yim/yar = Y matrix ---**/
#undef Y
#define Y(i,j) yar[(i)+(j)*nt] /* nt X nvox */
INFO_message("Loading data matrix Y") ;
yim = mri_new( nt , nvox , MRI_float ); yar = MRI_FLOAT_PTR(yim);
for( ii=0 ; ii < nt ; ii++ ){
for( jj=kk=0 ; jj < nxyz ; jj++ ){
if( GOOD(jj) ){ Y(ii,kk) = THD_get_voxel(yset,jj,ii); kk++; }
}}
DSET_unload(yset) ;
/**--- project baseline out of data image = Z matrix ---**/
if( pfim != NULL ){
#undef T
#define T(i,j) tar[(i)+(j)*nt] /* nt X nvox */
INFO_message("Projecting baseline out of Y") ;
qim = mri_matrix_mult( pfim , yim ) ; /* nqbase X nvox */
tim = mri_matrix_mult( fim , qim ) ; /* nt X nvox */
tar = MRI_FLOAT_PTR(tim) ; /* Y projected onto baseline */
for( jj=0 ; jj < nvox ; jj++ )
for( ii=0 ; ii < nt ; ii++ ) Y(ii,jj) -= T(ii,jj) ;
mri_free(tim); mri_free(qim); mri_free(pfim); mri_free(fim);
}
/***** At this point:
matrix A is in aim,
matrix Z is in yim.
Solve for V into vim, using the chosen method *****/
switch( method ){
default: ERROR_exit("Illegal method code! WTF?") ; /* Huh? */
/*.....................................................................*/
case METHOD_C:
/**--- compute pseudo-inverse of A map ---**/
INFO_message("Method C: Computing pseudo-inverse of A") ;
if( wim != NULL ) WARNING_message("Ignoring -mapwt dataset") ;
pfim = mri_matrix_psinv(aim,NULL,alpha) ; /* nparam X nvox */
if( pfim == NULL ) ERROR_exit("mri_matrix_psinv() fails") ;
mri_free(aim) ;
/**--- and apply to data to get results ---*/
INFO_message("Computing result V") ;
vim = mri_matrix_multranB( yim , pfim ) ; /* nt x nparam */
mri_free(pfim) ; mri_free(yim) ;
break ;
/*.....................................................................*/
case METHOD_K:
/**--- compute pseudo-inverse of transposed Z ---*/
INFO_message("Method K: Computing pseudo-inverse of Z'") ;
if( nwt > 1 ){
WARNING_message("Ignoring -mapwt dataset: more than 1 sub-brick") ;
nwt = 0 ; mri_free(wim) ; wim = NULL ; war = NULL ;
}
if( nwt == 1 ){
float fac ;
for( kk=0 ; kk < nvox ; kk++ ){
fac = war[kk] ;
for( ii=0 ; ii < nt ; ii++ ) Y(ii,kk) *= fac ;
for( ii=0 ; ii < nparam ; ii++ ) A(kk,ii) *= fac ;
}
}
tim = mri_matrix_transpose(yim) ; mri_free(yim) ;
pfim = mri_matrix_psinv(tim,NULL,alpha) ; mri_free(tim) ;
if( pfim == NULL ) ERROR_exit("mri_matrix_psinv() fails") ;
INFO_message("Computing W") ;
tim = mri_matrix_mult( pfim , aim ) ;
mri_free(aim) ; mri_free(pfim) ;
INFO_message("Computing result V") ;
pfim = mri_matrix_psinv(tim,NULL,0.0f) ; mri_free(tim) ;
vim = mri_matrix_transpose(pfim) ; mri_free(pfim);
break ;
} /* end of switch on method */
if( wim != NULL ) mri_free(wim) ;
/**--- smooth? ---**/
if( nfir > 0 && vim->nx > nfir ){
INFO_message("FIR-5-ing result") ;
var = MRI_FLOAT_PTR(vim) ;
for( jj=0 ; jj < vim->ny ; jj++ )
linear_filter_reflect( nfir,firwt , vim->nx , var + (jj*vim->nx) ) ;
}
if( nmed > 0 && vim->nx > nmed ){
INFO_message("Median-5-ing result") ;
var = MRI_FLOAT_PTR(vim) ;
for( jj=0 ; jj < vim->ny ; jj++ )
median5_filter_reflect( vim->nx , var + (jj*vim->nx) ) ;
}
/**--- write results ---**/
INFO_message("Writing result to '%s'",fname_out) ;
mri_write_1D( fname_out , vim ) ;
exit(0) ;
}
/*!
A less obtuse way to call IsoSurface extraction functions
See SUMA_IsoSurface.c the types of values that should be passed
if v0 == v1 --> isovalue of v0 extraction
if v1 > v0 --> isorange of [v0;v1[ is used
if v1 < v0 --> turn volume to mask (!=0) and set isovalue to 1
*/
SUMA_SurfaceObject *SUMA_THD_IsoSurface(THD_3dim_dataset *in_volu,
float v0, float v1,
int debug)
{
static char FuncName[]={"SUMA_THD_IsoSurface"};
SUMA_SurfaceObject *SO= NULL;
THD_3dim_dataset *in_vol=in_volu;
SUMA_ISO_OPTIONS MaskMode=SUMA_ISO_UNDEFINED;
SUMA_ISO_XFORMS xform=SUMA_ISO_XFORM_MASK;
float *fv=NULL;
int ii=0, n_mask=0;
SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt=NULL;
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
if (v0 == v1) MaskMode = SUMA_ISO_VAL;
else if (v1 > v0) MaskMode = SUMA_ISO_RANGE;
else if (v1 < v0) {/* make a mask*/
MaskMode = SUMA_ISO_VAL;
in_vol = EDIT_full_copy(in_volu,FuncName);
EDIT_floatize_dataset(in_vol);
fv = (float *)DSET_BRICK_ARRAY(in_vol,0);
n_mask=0;
for (ii=0; ii<DSET_NVOX(in_vol); ++ii) {
if (fv[ii]) {
fv[ii] = 1.0f;
++n_mask;
} else {
fv[ii] = 0.0f;
}
}
v0 = 1.0; v1 = 0.0;
} else {
SUMA_S_Err("Could not determine maskmode");
SUMA_RETURN(SO);
}
Opt = (SUMA_GENERIC_PROG_OPTIONS_STRUCT *)
SUMA_calloc(1,sizeof(SUMA_GENERIC_PROG_OPTIONS_STRUCT));
Opt->in_vol = in_vol;
Opt->xform = xform;
Opt->MaskMode = MaskMode;
Opt->debug = debug;
Opt->v0 = v0;
Opt->v1 = v1;
Opt->obj_type = -1;
/* A la SUMA_IsoSurface.c */
if (!SUMA_Get_isosurface_datasets (Opt)) {
SUMA_SL_Err("Failed to get data.");
SUMA_RETURN(SO);
}
/* Now call Marching Cube functions */
if (!(SO = SUMA_MarchingCubesSurface(Opt))) {
SUMA_S_Err("Failed to create surface.\n");
SUMA_RETURN(SO);
}
Opt->in_vol = NULL; /* Not yours to kill */
Opt->cmask = NULL;
Opt = SUMA_Free_Generic_Prog_Options_Struct(Opt);
if (in_vol && in_vol != in_volu) DSET_delete(in_vol);
SUMA_RETURN(SO);
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *inset=NULL ;
byte *mask=NULL ; int mask_nx=0,mask_ny=0,mask_nz=0 , automask=0 , masknum=0 ;
int iarg=1 , verb=1 , ntype=0 , nev,kk,ii,nxyz,nt ;
float na,nb,nc , dx,dy,dz ;
MRI_IMARR *imar=NULL ; int *ivox ; MRI_IMAGE *pim ;
int do_vmean=0 , do_vnorm=0 , sval_itop=0 ;
int polort=-1 ; float *ev ;
MRI_IMARR *ortar ; MRI_IMAGE *ortim ; int nyort=0 ;
float bpass_L=0.0f , bpass_H=0.0f , dtime ; int do_bpass=0 ;
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"Usage: 3dmaskSVD [options] inputdataset\n"
"Author: Zhark the Gloriously Singular\n"
"\n"
"* Computes the principal singular vector of the time series\n"
" vectors extracted from the input dataset over the input mask.\n"
" ++ You can use the '-sval' option to change which singular\n"
" vectors are output.\n"
"* The sign of the output vector is chosen so that the average\n"
" of arctanh(correlation coefficient) over all input data\n"
" vectors (from the mask) is positive.\n"
"* The output vector is normalized: the sum of its components\n"
" squared is 1.\n"
"* You probably want to use 3dDetrend (or something similar) first,\n"
" to get rid of annoying artifacts, such as motion, breathing,\n"
" dark matter interactions with the brain, etc.\n"
" ++ If you are lazy scum like Zhark, you might be able to get\n"
" away with using the '-polort' option.\n"
" ++ In particular, if your data time series has a nonzero mean,\n"
" then you probably want at least '-polort 0' to remove the\n"
" mean, otherwise you'll pretty much just get a constant\n"
" time series as the principal singular vector!\n"
"* An alternative to this program would be 3dmaskdump followed\n"
" by 1dsvd, which could give you all the singular vectors you\n"
" could ever want, and much more -- enough to confuse you for days.\n"
" ++ In particular, although you COULD input a 1D file into\n"
" 3dmaskSVD, the 1dsvd program would make much more sense.\n"
"* This program will be pretty slow if there are over about 2000\n"
" voxels in the mask. It could be made more efficient for\n"
" such cases, but you'll have to give Zhark some 'incentive'.\n"
"* Result vector goes to stdout. Redirect per your pleasures and needs.\n"
"* Also see program 3dLocalSVD if you want to compute the principal\n"
" singular time series vector from a neighborhood of EACH voxel.\n"
" ++ (Which is a pretty slow operation!)\n"
"* http://en.wikipedia.org/wiki/Singular_value_decomposition\n"
"\n"
"-------\n"
"Options:\n"
"-------\n"
" -vnorm = L2 normalize all time series before SVD [recommended!]\n"
" -sval a = output singular vectors 0 .. a [default a=0 = first one only]\n"
" -mask mset = define the mask [default is entire dataset == slow!]\n"
" -automask = you'll have to guess what this option does\n"
" -polort p = if you are lazy and didn't run 3dDetrend (like Zhark)\n"
" -bpass L H = bandpass [mutually exclusive with -polort]\n"
" -ort xx.1D = time series to remove from the data before SVD-ization\n"
" ++ You can give more than 1 '-ort' option\n"
" ++ 'xx.1D' can contain more than 1 column\n"
" -input ddd = alternative way to give the input dataset name\n"
"\n"
"-------\n"
"Example:\n"
"-------\n"
" You have a mask dataset with discrete values 1, 2, ... 77 indicating\n"
" some ROIs; you want to get the SVD from each ROI's time series separately,\n"
" and then put these into 1 big 77 column .1D file. You can do this using\n"
" a csh shell script like the one below:\n"
"\n"
" # Compute the individual SVD vectors\n"
" foreach mm ( `count 1 77` )\n"
" 3dmaskSVD -vnorm -mask mymask+orig\"<${mm}..${mm}>\" epi+orig > qvec${mm}.1D\n"
" end\n"
" # Glue them together into 1 big file, then delete the individual files\n"
" 1dcat qvec*.1D > allvec.1D\n"
" /bin/rm -f qvec*.1D\n"
" # Plot the results to a JPEG file, then compute their correlation matrix\n"
" 1dplot -one -nopush -jpg allvec.jpg allvec.1D\n"
" 1ddot -terse allvec.1D > allvec_COR.1D\n"
"\n"
" [[ If you use the bash shell, you'll have to figure out the syntax ]]\n"
" [[ yourself. Zhark has no sympathy for you bash shell infidels, and ]]\n"
" [[ considers you only slightly better than those lowly Emacs users. ]]\n"
" [[ And do NOT ever even mention 'nedit' in Zhark's august presence! ]]\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
/*---- official startup ---*/
PRINT_VERSION("3dmaskSVD"); mainENTRY("3dmaskSVD main"); machdep();
AFNI_logger("3dmaskSVD",argc,argv); AUTHOR("Zhark the Singular");
/*---- loop over options ----*/
INIT_IMARR(ortar) ;
mpv_sign_meth = AFNI_yesenv("AFNI_3dmaskSVD_meansign") ;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcasecmp(argv[iarg],"-bpass") == 0 ){
if( iarg+2 >= argc ) ERROR_exit("need 2 args after -bpass") ;
bpass_L = (float)strtod(argv[++iarg],NULL) ;
bpass_H = (float)strtod(argv[++iarg],NULL) ;
if( bpass_L < 0.0f || bpass_H <= bpass_L )
ERROR_exit("Illegal values after -bpass: %g %g",bpass_L,bpass_H) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-ort") == 0 ){ /* 01 Oct 2009 */
int nx,ny ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-ort'") ;
ortim = mri_read_1D( argv[iarg] ) ;
if( ortim == NULL ) ERROR_exit("-ort '%s': Can't read 1D file",argv[iarg]) ;
nx = ortim->nx ; ny = ortim->ny ;
if( nx == 1 && ny > 1 ){
MRI_IMAGE *tim=mri_transpose(ortim); mri_free(ortim); ortim = tim; ny = 1;
}
mri_add_name(argv[iarg],ortim) ; ADDTO_IMARR(ortar,ortim) ; nyort += ny ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-polort") == 0 ){
char *qpt ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-polort'") ;
polort = (int)strtod(argv[iarg],&qpt) ;
if( *qpt != '\0' ) WARNING_message("Illegal non-numeric value after -polort") ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-vnorm") == 0 ){
do_vnorm = 1 ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-input") == 0 ){
if( inset != NULL ) ERROR_exit("Can't have two -input options") ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-input'") ;
inset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-sval") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '-sval'") ;
sval_itop = (int)strtod(argv[iarg],NULL) ;
if( sval_itop < 0 ){ sval_itop = 0 ; WARNING_message("'-sval' reset to 0") ; }
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mask") == 0 ){
THD_3dim_dataset *mset ; int mmm ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-mask'") ;
if( mask != NULL || automask ) ERROR_exit("Can't have two mask inputs") ;
mset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(mset,argv[iarg]) ;
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[iarg]) ;
masknum = mmm = THD_countmask( mask_nx*mask_ny*mask_nz , mask ) ;
INFO_message("Number of voxels in mask = %d",mmm) ;
if( mmm < 2 ) ERROR_exit("Mask is too small to process") ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-automask") == 0 ){
if( mask != NULL ) ERROR_exit("Can't have two mask inputs!") ;
automask = 1 ; iarg++ ; continue ;
}
ERROR_exit("Unknown option '%s'",argv[iarg]) ;
} /*--- end of loop over options ---*/
/*---- deal with input dataset ----*/
if( inset == NULL ){
if( iarg >= argc ) ERROR_exit("No input dataset on command line?") ;
inset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
}
nt = DSET_NVALS(inset) ; /* vector lengths */
if( nt < 9 )
ERROR_exit("Must have at least 9 values per voxel") ;
if( polort+1 >= nt )
ERROR_exit("'-polort %d' too big for time series length = %d",polort,nt) ;
DSET_load(inset) ; CHECK_LOAD_ERROR(inset) ;
nxyz = DSET_NVOX(inset) ;
DSET_UNMSEC(inset) ;
dtime = DSET_TR(inset) ;
if( dtime <= 0.0f ) dtime = 1.0f ;
do_bpass = (bpass_L < bpass_H) ;
if( do_bpass ){
kk = THD_bandpass_OK( nt , dtime , bpass_L , bpass_H , 1 ) ;
if( kk <= 0 ) ERROR_exit("Can't continue since -bpass setup is illegal") ;
polort = -1 ;
}
/*--- deal with the masking ---*/
if( mask != NULL ){
if( mask_nx != DSET_NX(inset) ||
mask_ny != DSET_NY(inset) ||
mask_nz != DSET_NZ(inset) )
ERROR_exit("-mask dataset grid doesn't match input dataset") ;
} else if( automask ){
int mmm ;
mask = THD_automask( inset ) ;
if( mask == NULL )
ERROR_message("Can't create -automask from input dataset?") ;
masknum = mmm = THD_countmask( DSET_NVOX(inset) , mask ) ;
INFO_message("Number of voxels in automask = %d",mmm) ;
if( mmm < 9 ) ERROR_exit("Automask is too small to process") ;
} else {
mask = (byte *)malloc(sizeof(byte)*nxyz) ; masknum = nxyz ;
memset( mask , 1 , sizeof(byte)*nxyz ) ;
INFO_message("Using all %d voxels in dataset",nxyz) ;
}
nev = MIN(nt,masknum) ; /* max possible number of eigenvalues */
if( sval_itop >= nev ){
sval_itop = nev-1 ;
WARNING_message("'-sval' reset to '%d'",sval_itop) ;
}
mri_principal_vector_params( 0 , do_vnorm , sval_itop ) ;
mri_principal_setev(nev) ;
/*-- get data vectors --*/
ivox = (int *)malloc(sizeof(int)*masknum) ;
for( kk=ii=0 ; ii < nxyz ; ii++ ) if( mask[ii] ) ivox[kk++] = ii ;
INFO_message("Extracting data vectors") ;
imar = THD_extract_many_series( masknum, ivox, inset ) ; DSET_unload(inset) ;
if( imar == NULL ) ERROR_exit("Can't get data vector?!") ;
/*-- detrending --*/
if( polort >= 0 || nyort > 0 || do_bpass ){
float **polref=NULL ; float *tsar ;
int nort=IMARR_COUNT(ortar) , nref=0 ;
if( polort >= 0 ){ /* polynomials */
nref = polort+1 ; polref = THD_build_polyref(nref,nt) ;
}
if( nort > 0 ){ /* other orts */
float *oar , *par ; int nx,ny , qq,tt ;
for( kk=0 ; kk < nort ; kk++ ){ /* loop over input -ort files */
ortim = IMARR_SUBIM(ortar,kk) ;
nx = ortim->nx ; ny = ortim->ny ;
if( nx < nt )
ERROR_exit("-ort '%s' length %d shorter than dataset length %d" ,
ortim->name , nx , nt ) ;
polref = (float **)realloc(polref,(nref+ny)*sizeof(float *)) ;
oar = MRI_FLOAT_PTR(ortim) ;
for( qq=0 ; qq < ny ; qq++,oar+=nx ){
par = polref[nref+qq] = (float *)malloc(sizeof(float)*nt) ;
for( tt=0 ; tt < nt ; tt++ ) par[tt] = oar[tt] ;
if( polort == 0 ) THD_const_detrend (nt,par,NULL) ;
else if( polort > 0 ) THD_linear_detrend(nt,par,NULL,NULL) ;
}
nref += ny ;
}
DESTROY_IMARR(ortar) ;
}
if( !do_bpass ){ /* old style ort-ification */
MRI_IMAGE *imq , *imp ; float *qar ;
INFO_message("Detrending data vectors") ;
#if 1
imq = mri_new( nt , nref , MRI_float) ; qar = MRI_FLOAT_PTR(imq) ;
for( kk=0 ; kk < nref ; kk++ )
memcpy( qar+kk*nt , polref[kk] , sizeof(float)*nt ) ;
imp = mri_matrix_psinv( imq , NULL , 1.e-8 ) ;
for( kk=0 ; kk < IMARR_COUNT(imar) ; kk++ ){
mri_matrix_detrend( IMARR_SUBIM(imar,kk) , imq , imp ) ;
}
mri_free(imp) ; mri_free(imq) ;
#else
for( kk=0 ; kk < IMARR_COUNT(imar) ; kk++ ){
tsar = MRI_FLOAT_PTR(IMARR_SUBIM(imar,kk)) ;
THD_generic_detrend_LSQ( nt , tsar , -1 , nref , polref , NULL ) ;
}
#endif
} else { /* bandpass plus (maybe) orts */
float **vec = (float **)malloc(sizeof(float *)*IMARR_COUNT(imar)) ;
INFO_message("Bandpassing data vectors") ;
for( kk=0 ; kk < IMARR_COUNT(imar) ; kk++ )
vec[kk] = MRI_FLOAT_PTR(IMARR_SUBIM(imar,kk)) ;
(void)THD_bandpass_vectors( nt , IMARR_COUNT(imar) , vec ,
dtime , bpass_L , bpass_H ,
2 , nref , polref ) ;
free(vec) ;
}
for( kk=0 ; kk < nref; kk++ ) free(polref[kk]) ;
free(polref) ;
} /* end of detrendization */
/*--- the actual work ---*/
INFO_message("Computing SVD") ;
pim = mri_principal_vector( imar ) ; DESTROY_IMARR(imar) ;
if( pim == NULL ) ERROR_exit("SVD failure!?!") ;
ev = mri_principal_getev() ;
switch(sval_itop+1){
case 1:
INFO_message("First singular value: %g",ev[0]) ; break ;
case 2:
INFO_message("First 2 singular values: %g %g",ev[0],ev[1]) ; break ;
case 3:
INFO_message("First 3 singular values: %g %g %g",ev[0],ev[1],ev[2]) ; break ;
case 4:
INFO_message("First 4 singular values: %g %g %g %g",ev[0],ev[1],ev[2],ev[3]) ; break ;
default:
case 5:
INFO_message("First 5 singular values: %g %g %g %g %g",ev[0],ev[1],ev[2],ev[3],ev[4]) ; break ;
}
mri_write_1D(NULL,pim) ;
exit(0) ;
}
int main( int argc , char *argv[] )
{
int iarg=1 , ii , do_iwarp=0 ;
char *prefix = "NwarpCat" ;
mat44 wmat , smat , qmat ;
THD_3dim_dataset *oset=NULL ;
char *cwarp_all=NULL ; int ntot=0 ;
AFNI_SETUP_OMP(0) ; /* 24 Jun 2013 */
if( argc < 2 || strcasecmp(argv[1],"-help") == 0 ) NWC_help() ;
/*-- bureaucracy --*/
mainENTRY("3dNwarpCat"); machdep();
AFNI_logger("3dNwarpCat",argc,argv);
PRINT_VERSION("3dNwarpCat"); AUTHOR("Zhark the Warper");
(void)COX_clock_time() ;
putenv("AFNI_WSINC5_SILENT=YES") ;
/*-- initialization --*/
CW_no_expad = 1 ; /* don't allow automatic padding of input warp */
Hverb = 0 ; /* don't be verbose inside mri_nwarp.c */
for( ii=0 ; ii < NWMAX ; ii++ ) cwarp[ii] = NULL ;
/*-- scan args --*/
while( iarg < argc && argv[iarg][0] == '-' ){
/*---------------*/
if( strcasecmp(argv[iarg],"-iwarp") == 0 ){
do_iwarp = 1 ; iarg++ ; continue ;
}
/*---------------*/
if( strcasecmp(argv[iarg],"-space") == 0 ){
sname = strdup(argv[++iarg]) ; iarg++ ; continue ;
}
/*---------------*/
if( strcasecmp(argv[iarg],"-NN") == 0 || strncasecmp(argv[iarg],"-nearest",6) == 0 ){
WARNING_message("NN interpolation not legal here -- switched to linear") ;
interp_code = MRI_LINEAR ; iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-linear",4)==0 || strncasecmp(argv[iarg],"-trilinear",6)==0 ){
interp_code = MRI_LINEAR ; iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-cubic",4)==0 || strncasecmp(argv[iarg],"-tricubic",6)==0 ){
WARNING_message("cubic interplation not legal here -- switched to quintic") ;
interp_code = MRI_QUINTIC ; iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-quintic",4)==0 || strncasecmp(argv[iarg],"-triquintic",6)==0 ){
interp_code = MRI_QUINTIC ; iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-wsinc",5) == 0 ){
interp_code = MRI_WSINC5 ; iarg++ ; continue ;
}
/*---------------*/
if( strcasecmp(argv[iarg],"-expad") == 0 ){
int expad ;
if( ++iarg >= argc ) ERROR_exit("no argument after '%s' :-(",argv[iarg-1]) ;
expad = (int)strtod(argv[iarg],NULL) ;
if( expad < 0 ){
WARNING_message("-expad %d is illegal and is set to zero",expad) ;
expad = 0 ;
}
CW_extra_pad = expad ; /* this is how we force extra padding */
iarg++ ; continue ;
}
/*---------------*/
if( strncasecmp(argv[iarg],"-interp",5)==0 ){
char *inam ;
if( ++iarg >= argc ) ERROR_exit("no argument after '%s' :-(",argv[iarg-1]) ;
inam = argv[iarg] ; if( *inam == '-' ) inam++ ;
if( strcasecmp(inam,"NN")==0 || strncasecmp(inam,"nearest",5)==0 ){
WARNING_message("NN interpolation not legal here -- changed to linear") ;
interp_code = MRI_LINEAR ;
} else if( strncasecmp(inam,"linear",3)==0 || strncasecmp(inam,"trilinear",5)==0 ){
interp_code = MRI_LINEAR ;
} else if( strncasecmp(inam,"cubic",3)==0 || strncasecmp(inam,"tricubic",5)==0 ){
WARNING_message("cubic interplation not legal here -- changed to quintic") ;
interp_code = MRI_QUINTIC ;
} else if( strncasecmp(inam,"quintic",3)==0 || strncasecmp(inam,"triquintic",5)==0 ){
interp_code = MRI_QUINTIC ;
} else if( strncasecmp(inam,"wsinc",4)==0 ){
interp_code = MRI_WSINC5 ;
} else {
ERROR_exit("Unknown code '%s' after '%s' :-(",argv[iarg],argv[iarg-1]) ;
}
iarg++ ; continue ;
}
/*---------------*/
if( strcasecmp(argv[iarg],"-verb") == 0 ){
verb++ ; NwarpCalcRPN_verb(verb) ; iarg++ ; continue ;
}
/*---------------*/
if( strcasecmp(argv[iarg],"-prefix") == 0 ){
if( ++iarg >= argc ) ERROR_exit("no argument after '%s' :-(",argv[iarg-1]) ;
prefix = argv[iarg] ;
if( !THD_filename_ok(prefix) ) ERROR_exit("Illegal name after '%s'",argv[iarg-1]) ;
iarg++ ; continue ;
}
/*---------------*/
if( strncasecmp(argv[iarg],"-warp",5) == 0 ){
int nn ;
if( iarg >= argc-1 ) ERROR_exit("no argument after '%s' :-(",argv[iarg]) ;
if( !isdigit(argv[iarg][5]) ) ERROR_exit("illegal format for '%s' :-(",argv[iarg]) ;
nn = (int)strtod(argv[iarg]+5,NULL) ;
if( nn <= 0 || nn > NWMAX )
ERROR_exit("illegal warp index in '%s' :-(",argv[iarg]) ;
if( cwarp[nn-1] != NULL )
ERROR_exit("'%s': you can't specify warp #%d more than once :-(",argv[iarg],nn) ;
cwarp[nn-1] = strdup(argv[++iarg]) ;
if( nn > nwtop ) nwtop = nn ;
iarg++ ; continue ;
}
/*---------------*/
ERROR_message("Confusingly Unknown option '%s' :-(",argv[iarg]) ;
suggest_best_prog_option(argv[0],argv[iarg]) ;
exit(1) ;
}
/*-- load any warps left on the command line, after options --*/
for( ; iarg < argc && nwtop < NWMAX-1 ; iarg++ )
cwarp[nwtop++] = strdup(argv[iarg]) ;
/*-- check if all warp strings are affine matrices --*/
#undef AFFINE_WARP_STRING
#define AFFINE_WARP_STRING(ss) \
( strstr((ss)," ") == NULL && \
( strcasestr((ss),".1D") != NULL || strcasestr((ss),".txt") != NULL ) )
for( ntot=ii=0 ; ii < nwtop ; ii++ ){
if( cwarp[ii] == NULL ) continue ;
ntot += strlen(cwarp[ii]) ;
if( ! AFFINE_WARP_STRING(cwarp[ii]) ) break ; /* not affine */
}
if( ntot == 0 ) ERROR_exit("No warps on command line?!") ;
if( ii == nwtop ){ /* all are affine (this is for Ziad) */
char *fname = malloc(sizeof(char)*(strlen(prefix)+16)) ; FILE *fp ;
float a11,a12,a13,a14,a21,a22,a23,a24,a31,a32,a33,a34 ;
LOAD_IDENT_MAT44(wmat) ;
for( ii=0 ; ii < nwtop ; ii++ ){
if( cwarp[ii] == NULL ) continue ;
smat = CW_read_affine_warp_OLD(cwarp[ii]) ;
qmat = MAT44_MUL(smat,wmat) ; wmat = qmat ;
}
if( strcmp(prefix,"-") == 0 || strncmp(prefix,"stdout",6) == 0 ){
fp = stdout ; strcpy(fname,"stdout") ;
} else {
strcpy(fname,prefix) ;
if( strstr(fname,".1D") == NULL ) strcat(fname,".aff12.1D") ;
fp = fopen(fname,"w") ;
if( fp == NULL ) ERROR_exit("Can't open output matrix file %s",fname) ;
}
if( do_iwarp ){
qmat = MAT44_INV(wmat) ; wmat = qmat ;
}
UNLOAD_MAT44(wmat,a11,a12,a13,a14,a21,a22,a23,a24,a31,a32,a33,a34) ;
fprintf(fp,
" %13.6g %13.6g %13.6g %13.6g %13.6g %13.6g %13.6g %13.6g %13.6g %13.6g %13.6g %13.6g\n",
a11,a12,a13,a14,a21,a22,a23,a24,a31,a32,a33,a34 ) ;
if( verb && fp != stdout ) INFO_message("Wrote matrix to %s",fname) ;
if( fp != stdout ) fclose(fp) ;
exit(0) ;
}
/*** at least one nonlinear warp ==> cat all strings, use library function to read ***/
cwarp_all = (char *)calloc(sizeof(char),(ntot+NWMAX)*2) ;
for( ii=0 ; ii < nwtop ; ii++ ){
if( cwarp[ii] != NULL ){ strcat(cwarp_all,cwarp[ii]) ; strcat(cwarp_all," ") ; }
}
oset = IW3D_read_catenated_warp( cwarp_all ) ; /* process all of them at once */
if( do_iwarp ){ /* 18 Jul 2014 */
THD_3dim_dataset *qwarp ;
if( verb ) fprintf(stderr,"Applying -iwarp option") ;
qwarp = THD_nwarp_invert(oset) ;
DSET_delete(oset) ;
oset = qwarp ;
if( verb ) fprintf(stderr,"\n") ;
}
tross_Make_History( "3dNwarpCat" , argc,argv , oset ) ;
if( sname != NULL ) MCW_strncpy( oset->atlas_space , sname , THD_MAX_NAME ) ;
EDIT_dset_items( oset , ADN_prefix,prefix , ADN_none ) ;
DSET_write(oset) ; WROTE_DSET(oset) ;
/*--- run away screaming into the night, never to be seen again ---*/
INFO_message("total CPU time = %.1f sec Elapsed = %.1f\n",
COX_cpu_time() , COX_clock_time() ) ;
exit(0) ;
}
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[] )
{
MRI_IMAGE *imin, *imout , *imout_orig;
THD_3dim_dataset *iset, *oset , *ooset;
char *prefix = "SpatNorm", *bottom_cuts = NULL;
int iarg , verb=0, OrigSpace = 0 , specie = HUMAN;
float SpatNormDxyz= 0.0, iset_scaled=1.0;
THD_ivec3 orixyz , nxyz ;
THD_fvec3 dxyz , orgxyz, originRAIfv, fv2;
mainENTRY("3dSpatNorm main") ; machdep() ;
if (argc == 1) { usage_3dSpatNorm(1); exit(0); }
/*--- options ---*/
iarg = 1 ;
OrigSpace = 0;
while( iarg < argc && argv[iarg][0] == '-' ){
if (strcmp(argv[iarg],"-h") == 0 || strcmp(argv[iarg],"-help") == 0 ) {
usage_3dSpatNorm(strlen(argv[iarg]) > 3 ? 2:1);
exit(0);
}
/* -prefix */
if( strcmp(argv[iarg],"-prefix") == 0 ){
if( ++iarg >= argc ){
fprintf(stderr,"**ERROR: -prefix requires another argument!\n") ;
exit(1) ;
}
prefix = strdup(argv[iarg]) ;
if( !THD_filename_ok(prefix) ){
fprintf(stderr,"**ERROR: -prefix value contains forbidden characters!\n") ;
exit(1) ;
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-dxyz") == 0 ){
if( ++iarg >= argc ){
fprintf(stderr,"**ERROR: -dxyz requires another argument!\n") ;
exit(1) ;
}
SpatNormDxyz = atof(argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-bottom_cuts") == 0 ){
if( ++iarg >= argc ){
fprintf(stderr,"**ERROR: -bottom_cuts requires another argument!\n") ;
exit(1) ;
}
bottom_cuts = argv[iarg] ;
iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-verb",5) == 0 ){
verb++ ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-human",5) == 0 ){
specie = HUMAN ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-monkey",5) == 0 ){
specie = MONKEY ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-marmoset",5) == 0 ){
specie = MARMOSET ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-rat",5) == 0 ){
specie = RAT ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-orig_space",10) == 0 ){
OrigSpace = 1 ; iarg++ ; continue ;
}
fprintf(stderr,"**ERROR: %s is unknown option!\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1) ;
}
if( iarg >= argc ){
fprintf(stderr,"**ERROR: no input dataset name on command line?!\n") ;
exit(1) ;
}
/*--- read dataset ---*/
iset = THD_open_dataset( argv[iarg] ) ;
if( !ISVALID_DSET(iset) ){
fprintf(stderr,"**ERROR: can't open dataset %s\n",argv[iarg]) ;
exit(1) ;
}
/*--- get median brick --*/
if( verb ) fprintf(stderr,"++3dSpatNorm: loading dataset\n") ;
if (specie == MARMOSET) {
iset_scaled = 2.5;
THD_volDXYZscale(iset->daxes, iset_scaled, 0);
specie = MONKEY;
}
imin = THD_median_brick( iset ) ;
if( imin == NULL ){
fprintf(stderr,"**ERROR: can't load dataset %s\n",argv[iarg]) ;
exit(1) ;
}
imin->dx = fabs(iset->daxes->xxdel) ;
imin->dy = fabs(iset->daxes->yydel) ;
imin->dz = fabs(iset->daxes->zzdel) ;
mri_speciebusiness(specie);
mri_brain_normalize_cuts(bottom_cuts);
if (SpatNormDxyz) {
if (verb) fprintf(stderr,"Overriding default resampling\n");
mri_brainormalize_initialize(SpatNormDxyz, SpatNormDxyz, SpatNormDxyz);
} else {
float xxdel, yydel, zzdel, minres;
if (specie == MONKEY) minres = 0.5;
else if (specie == MARMOSET) minres = 0.2;
else if (specie == RAT) minres = 0.1;
else minres = 0.5;
/* don't allow for too low a resolution, please */
if (imin->dx < minres) xxdel = minres;
else xxdel = imin->dx;
if (imin->dy < minres) yydel = minres;
else yydel = imin->dy;
if (imin->dz < minres) zzdel = minres;
else zzdel = imin->dz;
if (verb) {
fprintf(stderr,
"%s:\n"
" Original resolution %f, %f, %f\n"
" SpatNorm resolution %f, %f, %f\n",
"3dSpatnorm", imin->dx, imin->dy, imin->dz,
xxdel, yydel, zzdel);
}
mri_brainormalize_initialize(xxdel, yydel, zzdel);
}
/* To get around the #define for voxel counts and dimensions */
mri_brainormalize_initialize(imin->dz, imin->dy, imin->dz);
/* me needs the origin of this dset in RAI world */
LOAD_FVEC3( originRAIfv ,
iset->daxes->xxorg , iset->daxes->yyorg , iset->daxes->zzorg) ;
originRAIfv = THD_3dmm_to_dicomm( iset , originRAIfv ) ;
LOAD_FVEC3(fv2, iset->daxes->xxorg + (iset->daxes->nxx-1)*iset->daxes->xxdel ,
iset->daxes->yyorg + (iset->daxes->nyy-1)*iset->daxes->yydel ,
iset->daxes->zzorg + (iset->daxes->nzz-1)*iset->daxes->zzdel);
fv2 = THD_3dmm_to_dicomm( iset , fv2 ) ;
if( originRAIfv.xyz[0] > fv2.xyz[0] ) {
float tf; tf = originRAIfv.xyz[0];
originRAIfv.xyz[0] = fv2.xyz[0]; fv2.xyz[0] = tf; }
if( originRAIfv.xyz[1] > fv2.xyz[1] ) {
float tf; tf = originRAIfv.xyz[1];
originRAIfv.xyz[1] = fv2.xyz[1]; fv2.xyz[1] = tf; }
if( originRAIfv.xyz[2] > fv2.xyz[2] ) {
float tf; tf = originRAIfv.xyz[2];
originRAIfv.xyz[2] = fv2.xyz[2]; fv2.xyz[2] = tf; }
if (verb) {
fprintf(stderr,"++3dSpatNorm (ZSS): RAI origin info: %f %f %f\n",
originRAIfv.xyz[0], originRAIfv.xyz[1], originRAIfv.xyz[2]);
}
DSET_unload( iset ) ; /* don't need this data no more */
/*-- convert image to shorts, if appropriate --*/
if( DSET_BRICK_TYPE(iset,0) == MRI_short ||
DSET_BRICK_TYPE(iset,0) == MRI_byte ){
imout = mri_to_short(0.0,imin) ; /* ZSS Oct 2012: Let function set scaling*/
mri_free(imin) ; imin = imout ;
}
/*--- normalize image spatially ---*/
mri_brainormalize_verbose( verb ) ;
if (OrigSpace) {
imout = mri_brainormalize( imin , iset->daxes->xxorient,
iset->daxes->yyorient,
iset->daxes->zzorient , &imout_orig, NULL) ;
} else {
imout = mri_brainormalize( imin , iset->daxes->xxorient,
iset->daxes->yyorient,
iset->daxes->zzorient , NULL, NULL) ;
}
mri_free( imin ) ;
if( imout == NULL ){
fprintf(stderr,"**ERROR: normalization fails!?\n"); exit(1);
}
if (OrigSpace) {
if( verb ) fprintf(stderr,"++3dSpatNorm: Output in Orignal space\n") ;
mri_free( imout ) ;
imout = imout_orig;
imout->xo = originRAIfv.xyz[0];
imout->yo = originRAIfv.xyz[1];
imout->zo = originRAIfv.xyz[2];
imout_orig = NULL;
} else {
if( verb ) fprintf(stderr,"++3dSpatNorm: Output in SpatNorm space\n") ;
}
#if 0
if( AFNI_yesenv("WATERSHED") ){
imin = mri_watershedize( imout , 0.10 ) ;
if( imin != NULL ){ mri_free(imout); imout = imin; }
}
#endif
/*--- create output dataset ---*/
if( verb )
fprintf(stderr,"++3dSpatNorm: Creating output dset\n") ;
oset = EDIT_empty_copy( NULL ) ;
tross_Copy_History( iset , oset ) ;
tross_Make_History( "3dSpatNorm" , argc,argv , oset ) ;
LOAD_IVEC3( nxyz , imout->nx , imout->ny , imout->nz ) ;
LOAD_FVEC3( dxyz , imout->dx , imout->dy , imout->dz ) ;
LOAD_FVEC3( orgxyz , imout->xo , imout->yo , imout->zo ) ;
LOAD_IVEC3( orixyz , ORI_R2L_TYPE , ORI_A2P_TYPE , ORI_I2S_TYPE ) ;
if( verb )
fprintf(stderr,"++3dSpatNorm: EDIT_dset_items\n") ;
EDIT_dset_items( oset ,
ADN_prefix , prefix ,
ADN_datum_all , imout->kind ,
ADN_nxyz , nxyz ,
ADN_xyzdel , dxyz ,
ADN_xyzorg , orgxyz ,
ADN_xyzorient , orixyz ,
ADN_malloc_type , DATABLOCK_MEM_MALLOC ,
ADN_view_type , VIEW_ORIGINAL_TYPE ,
ADN_type , HEAD_ANAT_TYPE ,
ADN_func_type , ANAT_BUCK_TYPE ,
ADN_none ) ;
if( verb )
fprintf(stderr,"++3dSpatNorm: EDIT_substitute_brick\n") ;
EDIT_substitute_brick( oset , 0 , imout->kind , mri_data_pointer(imout) ) ;
if (OrigSpace) {
if( verb )
fprintf(stderr,"++3dSpatNorm: Changing orientation from RAI\n") ;
ooset = r_new_resam_dset ( oset, iset, 0, 0, 0, NULL, MRI_NN, NULL, 1, 0);
if (!ooset) {
fprintf(stderr,"**ERROR: Failed to reslice!?\n"); exit(1);
}
/* put prefix back, r_new_resam_dset puts dummy prefix */
EDIT_dset_items( ooset ,
ADN_prefix , prefix,
ADN_none ) ;
DSET_delete(oset); oset = ooset; ooset = NULL;
}
if (iset_scaled != 1.0f)
THD_volDXYZscale(oset->daxes,
1/iset_scaled, 0);
DSET_write(oset) ;
if( verb )
fprintf(stderr,"++3dSpatNorm: wrote dataset %s\n",DSET_BRIKNAME(oset)) ;
exit(0) ;
}
