int Seg_CheckOpts(SEG_OPTS *Opt)
{
static char FuncName[]={"Seg_CheckOpts"};
SUMA_ENTRY;
if( ! THD_is_directory(Opt->proot) ){
if( mkdir( Opt->proot , THD_MKDIR_MODE ) != 0 ){
SUMA_S_Errv("Failed to create %s\n", Opt->proot);
exit(1);
}
}
/* Fix VoxDbg */
if (Opt->VoxDbg >= 0) {
Vox1D2Vox3D(Opt->VoxDbg,
DSET_NX(Opt->aset), DSET_NX(Opt->aset)*DSET_NY(Opt->aset),
Opt->VoxDbg3);
} else if (Opt->VoxDbg3[0]>=0) {
Opt->VoxDbg = Opt->VoxDbg3[0] + Opt->VoxDbg3[1]*DSET_NX(Opt->aset) +
Opt->VoxDbg3[2]*DSET_NX(Opt->aset)*DSET_NY(Opt->aset);
}
SUMA_set_SegFunc_debug( Opt->debug, Opt->VoxDbg, Opt->VoxDbg3,
Opt->VoxDbgOut);
SUMA_RETURN(1);
}
/*
* A hole is defined as a connected set of zero voxels that does
* not reach an edge.
*
* The core functionality was added to libmri.a in THD_mask_fill_holes.
*/
int fill_holes(THD_3dim_dataset * dset, int verb)
{
short * sptr; /* to for filling holes */
byte * bmask; /* computed result */
int nfilled;
int nx, ny, nz, nvox, index, fill=0;
ENTRY("fill_holes");
bmask = THD_makemask(dset, 0, 1, 0); /* copy input as byte mask */
nx = DSET_NX(dset); ny = DSET_NY(dset); nz = DSET_NZ(dset);
nvox = DSET_NVOX(dset);
/* created filled mask */
nfilled = THD_mask_fill_holes(nx,ny,nz, bmask, verb);
if( nfilled < 0 ) { ERROR_message("failed to fill holes"); RETURN(1); }
/* apply to short volume */
sptr = DBLK_ARRAY(dset->dblk, 0);
for( index = 0; index < nvox; index++ )
if( !sptr[index] && bmask[index] ) { fill++; sptr[index] = 1; }
if(verb>2) INFO_message("final check: fill=%d, nfilled=%d", fill, nfilled);
RETURN(0);
}
MRI_IMARR * THD_get_dset_nbhd_array( THD_3dim_dataset *dset, byte *mask,
int xx, int yy, int zz, MCW_cluster *nbhd )
{
MRI_IMARR *imar ;
int nvox, *ivox , nx,ny,nz , nxy,nxyz , npt, aa,bb,cc,kk,ii ;
nx = DSET_NX(dset) ;
ny = DSET_NY(dset) ; nxy = nx*ny ;
nz = DSET_NZ(dset) ; nxyz = nxy*nz ; npt = nbhd->num_pt ;
kk = xx + yy*nx + zz*nxy ;
if( kk < 0 || kk >= nxyz || !INMASK(kk) ) return NULL ;
ivox = (int *)malloc(sizeof(int)*npt) ; nvox = 0 ;
for( ii=0 ; ii < npt ; ii++ ){
aa = xx + nbhd->i[ii] ; if( aa < 0 || aa >= nx ) continue ;
bb = yy + nbhd->j[ii] ; if( bb < 0 || bb >= ny ) continue ;
cc = zz + nbhd->k[ii] ; if( cc < 0 || cc >= nz ) continue ;
kk = aa + bb*nx + cc*nxy ;
if( INMASK(kk) ) ivox[nvox++] = kk ;
}
imar = THD_extract_many_series( nvox, ivox, dset ) ;
free(ivox) ; return imar ;
}
void initialize_program
(
int argc, /* number of input arguments */
char ** argv /* array of input arguments */
)
{
float parameters [DIMENSION]; /* parameters for PDF estimation */
Boolean ok = TRUE; /* flag for successful PDF estimation */
int nx, ny, nz, nxy, nxyz, ixyz; /* voxel counters */
int n; /* histogram bin index */
short * sfim = NULL; /* pointer to anat data */
short * rfim = NULL; /* truncated data */
int icount;
int lower_cutoff = 25;
/*----- Get operator inputs -----*/
get_options (argc, argv);
/*----- Initialize local variables -----*/
if (anat == NULL) estPDF_error ("Unable to read anat dataset");
nx = DSET_NX(anat); ny = DSET_NY(anat); nz = DSET_NZ(anat);
nxy = nx*ny; nxyz = nxy*nz;
sfim = (short *) DSET_BRICK_ARRAY(anat,0) ;
if (sfim == NULL) estPDF_error ("Unable to read anat dataset");
rfim = (short *) malloc (sizeof(short) * nxyz); MTEST (rfim);
/*----- Just use voxels whose intensity is above the lower cutoff -----*/
icount = 0;
for (ixyz = 0; ixyz < nxyz; ixyz++)
if (sfim[ixyz] > lower_cutoff)
{
rfim[icount] = sfim[ixyz];
icount++;
}
printf ("%d voxels above lower cutoff = %d \n", icount, lower_cutoff);
/*----- Get PDF estimate and set voxel intensity limits -----*/
estpdf_short (icount, rfim, parameters);
min_val_float = parameters[4] - 2.0*parameters[5];
max_val_float = parameters[7] + 2.0*parameters[8];
if (! quiet)
{
printf ("\n");
printf ("Control inputs: \n");
printf ("anat filename = %s \n", anat_filename);
printf ("min value = %f \n", min_val_float);
printf ("max value = %f \n", max_val_float);
}
}
int main( int argc , char * argv[] )
{
THD_3dim_dataset * dset ;
int iarg , all = 0, verbose = 0, cnt = 0;
if( argc < 2 || strncmp(argv[1],"-help",4) == 0 ) Syntax() ;
iarg = 1 ;
cnt = 1;
while (cnt < argc) {
if( strncmp(argv[iarg],"-all",4) == 0 ){ all = 1 ; iarg++ ; }
else if( strncmp(argv[iarg],"-verbose",5) == 0 ){ verbose = 1 ; iarg++ ; }
++cnt;
}
for( ; iarg < argc ; iarg++ ){
dset = THD_open_dataset( argv[iarg] ) ;
if( dset == NULL ){
printf("-1\n") ;
continue ;
}
if (!all) {
if (verbose) {
printf("%s: %d\n",
DSET_HEADNAME(dset),
DSET_NVALS(dset)) ;
} else {
printf("%d\n",DSET_NVALS(dset)) ;
}
} else {
if (verbose) {
printf("%s: %d %d %d %d\n",
DSET_HEADNAME(dset),
DSET_NX(dset), DSET_NY(dset), DSET_NZ(dset),
DSET_NVALS(dset)) ;
} else {
printf("%d %d %d %d\n",
DSET_NX(dset), DSET_NY(dset), DSET_NZ(dset),
DSET_NVALS(dset)) ;
}
}
THD_delete_3dim_dataset( dset , False ) ;
}
exit(0) ;
}
// use Ndim to set number of dimensions to check: 3 or 4
int CompareSetDims(THD_3dim_dataset *A, THD_3dim_dataset *B, int Ndim)
{
int DimA[4] = {0,0,0,0}, DimB[4] = {0,0,0,0};
int i;
if ( Ndim > 4)
ERROR_exit("Bad call to CompareSetDims-- overtime!");
DimA[0] = DSET_NX(A); DimA[1] = DSET_NY(A);
DimA[2] = DSET_NZ(A); DimA[3] = DSET_NVALS(A);
DimB[0] = DSET_NX(B); DimB[1] = DSET_NY(B);
DimB[2] = DSET_NZ(B); DimB[3] = DSET_NVALS(B);
for ( i=0 ; i<Ndim ; i++)
if ( DimA[i] != DimA[i] )
ERROR_exit("Bad dimensional matching of inputs: '%s' and '%s'!",
DSET_PREFIXSTR(A), DSET_PREFIXSTR(B));
return 0;
}
MRI_vectim * THD_dset_to_vectim_byslice( THD_3dim_dataset *dset, byte *mask ,
int ignore , int kzbot , int kztop )
{
byte *mmm ;
MRI_vectim *mrv=NULL ;
int kk,iv , nvals , nvox , nmask , nxy , nz ;
ENTRY("THD_dset_to_vectim_byslice") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
nvals = DSET_NVALS(dset) ; if( nvals <= 0 ) RETURN(NULL) ;
nvox = DSET_NVOX(dset) ;
nxy = DSET_NX(dset) * DSET_NY(dset) ; nz = DSET_NZ(dset) ;
if( kzbot < 0 ) kzbot = 0 ;
if( kztop >= nz ) kztop = nz-1 ;
if( kztop < kzbot ) RETURN(NULL) ;
if( kzbot == 0 && kztop == nz-1 ){
mrv = THD_dset_to_vectim( dset , mask, ignore ) ; RETURN(mrv) ;
}
/* make a mask that includes cutting out un-desirable slices */
{ int ibot , itop , ii ;
#pragma omp critical (MALLOC)
mmm = (byte *)malloc(sizeof(byte)*nvox) ;
if( mask == NULL ) AAmemset( mmm , 1 , sizeof(byte)*nvox ) ;
else AAmemcpy( mmm , mask , sizeof(byte)*nvox ) ;
if( kzbot > 0 )
AAmemset( mmm , 0 , sizeof(byte)*kzbot *nxy ) ;
if( kztop < nz-1 )
AAmemset( mmm+(kztop+1)*nxy , 0 , sizeof(byte)*(nz-1-kztop)*nxy ) ;
}
/* and make the vectim using the standard function */
mrv = THD_dset_to_vectim( dset , mmm , ignore ) ;
free(mmm) ;
RETURN(mrv) ;
}
SEXP R_THD_write_dset(SEXP Sfname, SEXP Sdset, SEXP Opts)
{
SEXP Rdset, brik, head, names, opt, node_list;
int i=0, ip=0, sb, cnt=0, scale = 1, overwrite=0, addFDR=0,
kparts=2, *iv=NULL;
char *fname = NULL, *head_str, *stmp=NULL, *hist=NULL;
NI_group *ngr=NULL;
NI_element *nel=NULL;
char *listels[3] = {"head","brk","index_list"}; /* the brk is on purpose
for backward compatibility */
double *dv=NULL;
float *fv=NULL;
THD_3dim_dataset *dset = NULL;
int debug=0;
if (!debug) debug = get_odebug();
/* get the options list, maybe */
PROTECT(Opts = AS_LIST(Opts));
if ((opt = getListElement(Opts,"debug")) != R_NilValue) {
debug = (int)INTEGER_VALUE(opt);
if (debug>2) set_odebug(debug);
if (debug > 1) INFO_message("Debug is %d\n", debug);
}
/* get the filename */
PROTECT(Sfname = AS_CHARACTER(Sfname));
fname = R_alloc(strlen(CHAR(STRING_ELT(Sfname,0)))+1, sizeof(char));
strcpy(fname, CHAR(STRING_ELT(Sfname,0)));
if (debug >1) INFO_message("Output filename %s\n"
, fname);
/* get the dset structure elements */
PROTECT(Rdset = AS_LIST(Sdset));
if ((head = AS_CHARACTER(getListElement(Rdset,"head"))) == R_NilValue) {
ERROR_message("No header found");
UNPROTECT(3);
return(R_NilValue);
}
if (debug > 1) INFO_message("First head element %s\n"
, CHAR(STRING_ELT(head,0)));
if ((brik = AS_NUMERIC(getListElement(Rdset,"brk"))) == R_NilValue) {
ERROR_message("No brick found");
UNPROTECT(3);
return(R_NilValue);
}
dv = NUMERIC_POINTER(brik);
if (debug > 1) INFO_message("First brik value %f\n"
, dv[0]);
ngr = NI_new_group_element();
NI_rename_group(ngr, "AFNI_dataset" );
NI_set_attribute(ngr,"AFNI_prefix", fname);
if ((opt = getListElement(Opts,"idcode")) != R_NilValue) {
opt = AS_CHARACTER(opt);
stmp = (char *)(CHAR(STRING_ELT(opt,0)));
if (stmp && !strcmp(stmp,"SET_AT_WRITE_FILENAME")) {
stmp = UNIQ_hashcode(fname);
NI_set_attribute(ngr, "AFNI_idcode", stmp);
free(stmp);
} else if (stmp && !strcmp(stmp,"SET_AT_WRITE_RANDOM")) {
stmp = UNIQ_idcode() ;
NI_set_attribute(ngr, "AFNI_idcode", stmp);
free(stmp);
} else if (stmp) {
NI_set_attribute(ngr, "AFNI_idcode",
(char *)(CHAR(STRING_ELT(opt,0))));
}
}
if ((opt = getListElement(Opts,"scale")) != R_NilValue) {
scale = (int)INTEGER_VALUE(opt);
if (debug > 1) INFO_message("Scale is %d\n", scale);
}
if ((opt = getListElement(Opts,"overwrite")) != R_NilValue) {
overwrite = (int)INTEGER_VALUE(opt);
if (debug > 1) INFO_message("overwrite is %d\n", overwrite);
THD_force_ok_overwrite(overwrite) ;
if (overwrite) THD_set_quiet_overwrite(1);
}
if ((opt = getListElement(Opts,"addFDR")) != R_NilValue) {
addFDR = (int)INTEGER_VALUE(opt);
if (debug > 1) INFO_message("addFDR is %d\n", addFDR);
}
PROTECT(opt = getListElement(Opts,"hist"));
if ( opt != R_NilValue) {
opt = AS_CHARACTER(opt);
hist = R_alloc(strlen(CHAR(STRING_ELT(opt,0)))+1, sizeof(char));
strcpy(hist, CHAR(STRING_ELT(opt,0)));
if (debug > 1) INFO_message("hist is %s\n", hist);
}
UNPROTECT(1);
for (ip=0,i=0; i<length(head); ++i) {
head_str = (char *)CHAR(STRING_ELT(head,i));
if (debug > 1) {
INFO_message("Adding %s\n", head_str);
}
nel = NI_read_element_fromstring(head_str);
if (!nel->vec) {
ERROR_message("Empty attribute vector for\n%s\n"
"This is not expected.\n",
head_str);
UNPROTECT(3);
return(R_NilValue);
}
NI_add_to_group(ngr,nel);
}
if (debug > 1) INFO_message("Creating dset header\n");
if (!(dset = THD_niml_to_dataset(ngr, 1))) {
ERROR_message("Failed to create header");
UNPROTECT(3);
return(R_NilValue);
}
if (debug > 2) {
INFO_message("Have header of %d, %d, %d, %d, scale=%d\n",
DSET_NX(dset), DSET_NY(dset),
DSET_NZ(dset), DSET_NVALS(dset), scale);
}
for (i=0; i<DSET_NVALS(dset); ++i) {
if (debug > 2) {
INFO_message("Putting values in sub-brick %d, type %d\n",
i, DSET_BRICK_TYPE(dset,i));
}
if ( ( DSET_BRICK_TYPE(dset,i) == MRI_byte ||
DSET_BRICK_TYPE(dset,i) == MRI_short ) ) {
EDIT_substscale_brick(dset, i,
MRI_double, dv+i*DSET_NVOX(dset),
DSET_BRICK_TYPE(dset,i), scale ? -1.0:1.0);
} else if ( DSET_BRICK_TYPE(dset,i) == MRI_double ) {
EDIT_substitute_brick(dset, i,
MRI_double, dv+i*DSET_NVOX(dset));
} else if ( DSET_BRICK_TYPE(dset,i) == MRI_float ) {
float *ff=(float*)calloc(DSET_NVOX(dset), sizeof(float));
double *dvi=dv+i*DSET_NVOX(dset);
for (ip=0; ip<DSET_NVOX(dset); ++ip) {
ff[ip] = dvi[ip];
}
EDIT_substitute_brick(dset, i, MRI_float, ff);
}
}
/* THD_update_statistics( dset ) ; */
if (addFDR) {
DSET_BRICK_FDRCURVE_ALLKILL(dset) ;
DSET_BRICK_MDFCURVE_ALLKILL(dset) ; /* 22 Oct 2008 */
if( addFDR > 0 ){
int nFDRmask=0; /* in the future, perhaps allow for a mask */
byte *FDRmask=NULL; /* to be sent in also, for now, mask is exact */
/* 0 voxels . */
mri_fdr_setmask( (nFDRmask == DSET_NVOX(dset)) ? FDRmask : NULL ) ;
ip = THD_create_all_fdrcurves(dset) ;
if( ip > 0 ){
if (debug)
ININFO_message("created %d FDR curve%s in dataset header",
ip,(ip==1)?"\0":"s") ;
} else {
if (debug)
ININFO_message("failed to create FDR curves in dataset header") ;
}
}
}
/* Do we have an index_list? */
if ((node_list=AS_INTEGER(getListElement(Rdset,"index_list")))!=R_NilValue) {
iv = INTEGER_POINTER(node_list);
if (debug > 1) INFO_message("First node index value %d, total (%d)\n",
iv[0], length(node_list));
dset->dblk->nnodes = length(node_list);
dset->dblk->node_list = (int *)XtMalloc(dset->dblk->nnodes * sizeof(int));
memcpy(dset->dblk->node_list, iv, dset->dblk->nnodes*sizeof(int));
}
if (hist) {
tross_Append_History(dset, hist);
}
DSET_write(dset);
UNPROTECT(3);
return(R_NilValue);
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *dset=NULL;
int iarg , verbose = -1 ;
char *outbuf, *stmp=NULL;
char *labelName = NULL;
char *sbdelim = {"|"};
char *NAflag = {"NA"};
char *atrdelim = {"\t"}, *form=NULL;
INFO_FIELDS sing[512];
int iis=0, N_sing = 0, isb=0, withhead = 0, itmp=0;
int ip=0, needpair = 0, namelen=0, monog_pairs = 0;
THD_3dim_dataset *tttdset=NULL, *dsetp=NULL;
char *tempstr = NULL;
int extinit = 0;
float RL_AP_IS[6];
mainENTRY("3dinfo main") ; machdep() ;
if( argc < 2) { Syntax(TXT,1) ; RETURN(0); }
iarg = 1 ;
while (iarg < argc && argv[iarg][0] == '-') {
CHECK_HELP(argv[iarg],Syntax);
if( strncmp(argv[iarg],"-verb" ,5) == 0 ){
verbose = 0; iarg++; continue; }
else if( strncmp(argv[iarg],"-VERB" ,5) == 0 ){
verbose = 1; iarg++; continue; }
else if( strncmp(argv[iarg],"-short",5) == 0 ){
verbose = -1; iarg++; continue; }
else if( strcasecmp(argv[iarg],"-header_line") == 0 ||
strcasecmp(argv[iarg],"-hdr") == 0 ){
withhead = 1; iarg++; continue; }
else if( strcasecmp(argv[iarg],"-monog_pairs") == 0 ){
monog_pairs = 1; iarg++; continue; }
else if ( strncmp(argv[iarg],"-label2",7) == 0 )
{
iarg++;
if (iarg >= argc)
ERROR_exit( "3dinfo needs an argument after -label2number\n");
labelName = malloc(sizeof(char) * 2048);
strcpy(labelName, argv[iarg]);
iarg++; continue;
}
else if( strcasecmp(argv[iarg],"-sb_delim") == 0) {
iarg++;
if (iarg >= argc)
ERROR_exit( "3dinfo needs a string after -sb_delim\n");
sbdelim = argv[iarg];
iarg++; continue;
}
else if( strcasecmp(argv[iarg],"-NA_flag") == 0) {
iarg++;
if (iarg >= argc)
ERROR_exit( "3dinfo needs a string after -NA_flag\n");
NAflag = argv[iarg];
iarg++; continue;
}
else if( strcasecmp(argv[iarg],"-atr_delim") == 0) {
iarg++;
if (iarg >= argc)
ERROR_exit( "3dinfo needs a string after -atr_delim\n");
atrdelim = argv[iarg];
iarg++; continue;
}
else if( strcasecmp(argv[iarg],"-space") == 0) {
sing[N_sing++] = DSET_SPACE; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-av_space") == 0) {
sing[N_sing++] = AV_DSET_SPACE; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-gen_space") == 0) {
sing[N_sing++] = DSET_GEN_SPACE; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-is_nifti") == 0) {
sing[N_sing++] = IS_NIFTI; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-is_atlas") == 0) {
sing[N_sing++] = IS_ATLAS; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-exists") == 0) {
sing[N_sing++] = DSET_EXISTS; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-is_oblique") == 0) {
sing[N_sing++] = IS_OBLIQUE; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-obliquity") == 0) {
sing[N_sing++] = OBLIQUITY; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-handedness") == 0) {
sing[N_sing++] = HANDEDNESS; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-prefix") == 0) {
sing[N_sing++] = PREFIX; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-prefix_noext") == 0) {
sing[N_sing++] = PREFIX_NOEXT; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-ni") == 0) {
sing[N_sing++] = NI; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-nj") == 0) {
sing[N_sing++] = NJ; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-nk") == 0) {
sing[N_sing++] = NK; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-n4") == 0) {
sing[N_sing++] = NI;
sing[N_sing++] = NJ;
sing[N_sing++] = NK;
sing[N_sing++] = NV; iarg++;
continue;
} else if( strcasecmp(argv[iarg],"-Rextent") == 0) {
sing[N_sing++] = EXTENT_R; iarg++;
continue;
} else if( strcasecmp(argv[iarg],"-Lextent") == 0) {
sing[N_sing++] = EXTENT_L; iarg++;
continue;
} else if( strcasecmp(argv[iarg],"-Aextent") == 0) {
sing[N_sing++] = EXTENT_A; iarg++;
continue;
} else if( strcasecmp(argv[iarg],"-Pextent") == 0) {
sing[N_sing++] = EXTENT_P; iarg++;
continue;
} else if( strcasecmp(argv[iarg],"-Iextent") == 0) {
sing[N_sing++] = EXTENT_I; iarg++;
continue;
} else if( strcasecmp(argv[iarg],"-Sextent") == 0) {
sing[N_sing++] = EXTENT_S; iarg++;
continue;
} else if( strcasecmp(argv[iarg],"-extent") == 0) {
sing[N_sing++] = EXTENT_R;
sing[N_sing++] = EXTENT_L;
sing[N_sing++] = EXTENT_A;
sing[N_sing++] = EXTENT_P;
sing[N_sing++] = EXTENT_I;
sing[N_sing++] = EXTENT_S;
iarg++;
continue;
} else if( strcasecmp(argv[iarg],"-di") == 0) {
sing[N_sing++] = DI; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-dj") == 0) {
sing[N_sing++] = DJ; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-dk") == 0) {
sing[N_sing++] = DK; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-d3") == 0) {
sing[N_sing++] = DI;
sing[N_sing++] = DJ;
sing[N_sing++] = DK; iarg++;
continue;
} else if( strcasecmp(argv[iarg],"-adi") == 0) {
sing[N_sing++] = ADI; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-adj") == 0) {
sing[N_sing++] = ADJ; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-adk") == 0) {
sing[N_sing++] = ADK; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-ad3") == 0) {
sing[N_sing++] = ADI;
sing[N_sing++] = ADJ;
sing[N_sing++] = ADK; iarg++;
continue;
} else if( strcasecmp(argv[iarg],"-voxvol") == 0) {
sing[N_sing++] = VOXVOL; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-iname") == 0) {
sing[N_sing++] = INAME; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-oi") == 0) {
sing[N_sing++] = OI; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-oj") == 0) {
sing[N_sing++] = OJ; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-ok") == 0) {
sing[N_sing++] = OK; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-o3") == 0) {
sing[N_sing++] = OI;
sing[N_sing++] = OJ;
sing[N_sing++] = OK; iarg++;
continue;
}else if( strcasecmp(argv[iarg],"-nt") == 0) {
sing[N_sing++] = NT; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-nti") == 0) {
sing[N_sing++] = NTI; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-nv") == 0) {
sing[N_sing++] = NV; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-nvi") == 0) {
sing[N_sing++] = NVI; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-ntimes") == 0) {
sing[N_sing++] = NTIMES; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-max_node") == 0) {
sing[N_sing++] = MAX_NODE; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-nijk") == 0) {
sing[N_sing++] = NIJK; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-labeltable") == 0) {
sing[N_sing++] = LTABLE; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-labeltable_as_atlas_points") == 0) {
sing[N_sing++] = LTABLE_AS_ATLAS_POINT_LIST; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-atlas_points") == 0) {
sing[N_sing++] = ATLAS_POINTS; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-fac") == 0) {
sing[N_sing++] = FAC; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-datum") == 0) {
sing[N_sing++] = DATUM; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-label") == 0) {
sing[N_sing++] = LABEL; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-min") == 0) {
sing[N_sing++] = MIN; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-max") == 0) {
sing[N_sing++] = MAX; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-minus") == 0) {
sing[N_sing++] = MINUS; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-maxus") == 0) {
sing[N_sing++] = MAXUS; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-dmin") == 0) {
sing[N_sing++] = DMIN; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-dmax") == 0) {
sing[N_sing++] = DMAX; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-dminus") == 0) {
sing[N_sing++] = DMINUS; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-dmaxus") == 0) {
sing[N_sing++] = DMAXUS; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-TR") == 0) {
sing[N_sing++] = TR; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-header_name") == 0) {
sing[N_sing++] = HEADER_NAME; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-brick_name") == 0) {
sing[N_sing++] = BRICK_NAME; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-history") == 0) {
sing[N_sing++] = HISTORY; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-all_names") == 0) {
sing[N_sing++] = ALL_NAMES; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-orient") == 0) {
sing[N_sing++] = ORIENT; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-same_grid") == 0) {
sing[N_sing++] = SAME_GRID; needpair = 1; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-same_dim") == 0) {
sing[N_sing++] = SAME_DIM; needpair = 1; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-same_delta") == 0) {
sing[N_sing++] = SAME_DELTA; needpair = 1; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-same_orient") == 0) {
sing[N_sing++] = SAME_ORIENT; needpair = 1; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-same_center") == 0) {
sing[N_sing++] = SAME_CENTER; needpair = 1; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-same_obl") == 0) {
sing[N_sing++] = SAME_OBL; needpair = 1; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-slice_timing") == 0) {
sing[N_sing++] = SLICE_TIMING; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-sval_diff") == 0) {
sing[N_sing++] = SVAL_DIFF; needpair = 1; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-val_diff") == 0) {
sing[N_sing++] = VAL_DIFF; needpair = 1; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-same_all_grid") == 0) {
sing[N_sing++] = SAME_DIM;
sing[N_sing++] = SAME_DELTA;
sing[N_sing++] = SAME_ORIENT;
sing[N_sing++] = SAME_CENTER;
sing[N_sing++] = SAME_OBL; needpair = 1; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-id") == 0) {
sing[N_sing++] = ID; iarg++; continue;
} else if( strcasecmp(argv[iarg],"-smode") == 0) {
sing[N_sing++] = SMODE; iarg++; continue;
} else {
ERROR_message("Option %s unknown", argv[iarg]);
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
}
if (N_sing == 0) {
sing[N_sing++] = CLASSIC;
}
if (sing[iis] == CLASSIC) PRINT_VERSION("3dinfo") ;
THD_allow_empty_dataset(1) ; /* 21 Mar 2007 */
if (iarg == argc) {
ERROR_message("No dsets on command line? I have nothing to do.\n");
exit(1);
}
if (needpair && monog_pairs) needpair = 2; /* pair each couple separately */
if (needpair==2 && (argc-iarg) % 2) {
ERROR_message("Using options requiring dset pairs but have odd number\n"
"of dsets (%d) on command line.\n", (argc-iarg));
exit (1);
} else if (needpair==1 && (argc-iarg) < 2) {
ERROR_message("Using options requiring dset pairs but have less than\n"
"two dsets (%d) on command line.\n", (argc-iarg));
exit (1);
}
ip = 0;
for( ; iarg < argc ; iarg++ ){
if (ip == 0) {
int kkk, nml; char *etr;
namelen = 0;
for (kkk=iarg; kkk<argc; ++kkk) {
if ((etr = THD_trailname(argv[kkk],0))) {
nml=strlen(etr);
if (nml < 48 && nml > namelen) namelen = nml;
}
}
if (namelen < 6) namelen = 6;
if (withhead) {
int havenew=0;
for (iis = 0; iis < N_sing; ++iis) {
if (sing[iis] != CLASSIC) {
++havenew;
form = PrintForm(sing[iis], namelen, 1);
/*fprintf(stderr,"ZSS: %d %s >%s<\n",
sing[iis], Field_Names[sing[iis]], form);*/
fprintf(stdout, form, Field_Names[sing[iis]]);
}
if (havenew) {
if (N_sing > 1 && iis < N_sing-1)
fprintf(stdout,"%s",atrdelim);
else fprintf(stdout,"\n");
}
}
}
}
if( argv[iarg][0] == '\0' ) continue ; /* bad filename */
set_obliquity_report(0); /* silence obliquity */
if (!needpair) {
if (!(dset = load_3dinfo_dataset(argv[iarg]))) {
/* exit(1); */
}
} else {
if (needpair == 2) { /* Crazy idea of comparing each pair separately */
if (ip % 2 == 0) {
if (!(dset = load_3dinfo_dataset(argv[iarg] ))) {
/* exit(1); */
}
if (iarg+1==argc || argv[iarg+1][0] == '\0') {
ERROR_message("Bad dset pair for %s\n", argv[iarg]);
exit(1);
}
if (!(dsetp = load_3dinfo_dataset(argv[iarg+1] ))) {
/* exit(1); */
}
} else { /* swap the pair - this allows non pair requiring functions
to work as before.*/
tttdset = dsetp;
dsetp = dset;
dset = tttdset; tttdset=NULL;
}
} else { /* always compare to very first dset */
if (ip==0) {
if (!(dset = load_3dinfo_dataset(argv[iarg] ))) {
/*exit(1);*/
}
if (!(dsetp = load_3dinfo_dataset(argv[iarg+1] ))) {
/*exit(1);*/
}
} else if (ip==1) { /* switch order of first two */
tttdset = dsetp;
dsetp = dset; /* now dsetp is the very first dset */
dset = tttdset; tttdset=NULL;
} else { /* pair with very first, which is dsetp */
if (!(dset = load_3dinfo_dataset(argv[iarg] ))) {
/*exit(1);*/
}
}
}
}
++ip;
if (0 && !dset) { /* allow for DSET_EXISTS option */
ERROR_exit("Should not get here");
}
/* we should re-capture this per dataset 5 Feb 2019 [rickr] */
extinit = 0;
for (iis = 0; iis < N_sing; ++iis) {
if (!dset) {
if (sing[iis] == CLASSIC) {
if( dset == NULL ){ /* still not open? */
ERROR_exit("Can't open dataset %s\n", argv[iarg]) ;
}
} else if (sing[iis] != DSET_EXISTS && sing[iis] != INAME) {
fprintf(stdout, "NO-DSET");
SPIT_DELIM(iis, N_sing, atrdelim);
continue;
}
}
switch (sing[iis]) {
case CLASSIC:
if (labelName == NULL ) /*** get and output info ***/
{
outbuf = THD_dataset_info( dset , verbose ) ;
if( outbuf != NULL ){
printf("\n") ;
puts(outbuf) ;
free(outbuf) ; outbuf = NULL ;
} else {
ERROR_exit("Can't get info for dataset %s",argv[iarg]) ;
}
}
else /*** get and output label ***/
{
int nval_per = dset->dblk->nvals;
int foundLabel = 0;
int ival=0;
for (ival=0 ; ival < nval_per && !foundLabel; ival++ )
{
if (strcmp(DSET_BRICK_LAB(dset,ival), labelName) == 0)
{
printf("%d\n", ival); foundLabel = 1;
}
} /* end of for (ival=0 ; ival < nval_per ; ival++ ) */
if (!foundLabel) printf("\n");
}
THD_delete_3dim_dataset( dset , False ) ;
free(labelName);
break;
case DSET_EXISTS:
fprintf(stdout, "%d", dset ? 1:0);
break;
case DSET_SPACE:
tempstr = THD_get_space(dset);
if(tempstr==NULL)
fprintf(stdout, "-----");
else
fprintf(stdout, "%s", tempstr);
break;
case DSET_GEN_SPACE:
tempstr = THD_get_generic_space(dset);
if(tempstr==NULL)
fprintf(stdout, "-----");
else
fprintf(stdout, "%s", tempstr);
break;
case AV_DSET_SPACE:
/* don't allow anything but the three AFNI views */
tempstr = THD_get_view_space(dset);
if(tempstr==NULL)
fprintf(stdout, "+orig");
else if (!strncasecmp(tempstr,"ORIG",4))
fprintf(stdout, "+orig");
else if (!strncasecmp(tempstr,"ACPC",4))
fprintf(stdout, "+acpc");
else if (!strncasecmp(tempstr,"TLRC",4))
fprintf(stdout, "+tlrc");
else /* shouldn't get here */
fprintf(stdout, "+orig");
break;
case IS_NIFTI:
if ( dset->dblk->diskptr &&
dset->dblk->diskptr->storage_mode == STORAGE_BY_NIFTI ) {
fprintf(stdout,"1");
} else {
fprintf(stdout,"0");
}
break;
case IS_ATLAS:
if ( is_Dset_Atlasy(dset, NULL) ) {
fprintf(stdout,"1");
} else {
fprintf(stdout,"0");
}
break;
case IS_OBLIQUE:
if (dset_obliquity(dset,NULL) > 0) {
fprintf(stdout,"1");
} else {
fprintf(stdout,"0");
}
break;
case HANDEDNESS:
if (THD_handedness(dset) > 0) {
fprintf(stdout,"R");
} else {
fprintf(stdout,"L");
}
break;
case OBLIQUITY:
fprintf(stdout,"%.3f",
THD_compute_oblique_angle(dset->daxes->ijk_to_dicom_real, 0));
break;
case PREFIX:
form = PrintForm(sing[iis], namelen, 1);
fprintf(stdout,form, DSET_PREFIX(dset));
break;
case PREFIX_NOEXT:
{
form = PrintForm(sing[iis], namelen, 1);
stmp=DSET_prefix_noext(dset);
fprintf(stdout,form, stmp);
free(stmp); stmp=NULL;
}
break;
case HEADER_NAME:
fprintf(stdout,"%s", dset->dblk->diskptr->header_name);
break;
case BRICK_NAME:
fprintf(stdout,"%s", dset->dblk->diskptr->brick_name);
break;
case ALL_NAMES:
THD_show_dataset_names(dset, "FOR_3DINFO", stdout);
break;
case HISTORY:
stmp = tross_Get_History(dset);
fprintf(stdout,"%s", stmp ? stmp:NAflag);
if (stmp) free(stmp); stmp=NULL;
break;
case NI:
fprintf(stdout,"%d", DSET_NX(dset));
break;
case NJ:
fprintf(stdout,"%d", DSET_NY(dset));
break;
case NK:
fprintf(stdout,"%d", DSET_NZ(dset));
break;
case NIJK:
fprintf(stdout,"%d", DSET_NVOX(dset));
break;
case NTIMES:
fprintf(stdout,"%d", DSET_NUM_TIMES(dset));
break;
case MAX_NODE:
DSET_MAX_NODE(dset,itmp);
fprintf(stdout,"%d", itmp);
break;
case NT:
case NV:
fprintf(stdout,"%d", DSET_NVALS(dset));
break;
case NTI:
case NVI:
fprintf(stdout,"%d", DSET_NVALS(dset)-1);
break;
case DI:
fprintf(stdout,"%f", DSET_DX(dset));
break;
case DJ:
fprintf(stdout,"%f", DSET_DY(dset));
break;
case DK:
fprintf(stdout,"%f", DSET_DZ(dset));
break;
case OI:
fprintf(stdout,"%f", DSET_XORG(dset));
break;
case OJ:
fprintf(stdout,"%f", DSET_YORG(dset));
break;
case OK:
fprintf(stdout,"%f", DSET_ZORG(dset));
break;
case ADI:
fprintf(stdout,"%f", fabs(DSET_DX(dset)));
break;
case EXTENT_R:
case EXTENT_L:
case EXTENT_A:
case EXTENT_P:
case EXTENT_I:
case EXTENT_S:
{
if (!extinit) {
THD_dset_extent(dset, '-', RL_AP_IS);
extinit = 1;
}
fprintf(stdout,"%f", RL_AP_IS[sing[iis]-EXTENT_R]);
}
break;
case ADJ:
fprintf(stdout,"%f", fabs(DSET_DY(dset)));
break;
case ADK:
fprintf(stdout,"%f", fabs(DSET_DZ(dset)));
break;
case VOXVOL:
fprintf(stdout,"%f", fabs(DSET_DX(dset))*
fabs(DSET_DY(dset))*fabs(DSET_DZ(dset)));
break;
case INAME:
fprintf(stdout,"%s", argv[iarg]);
break;
case LTABLE:
{
char *str;
if ((str = Dtable_to_nimlstring(DSET_Label_Dtable(dset), "VALUE_LABEL_DTABLE"))) {
fprintf(stdout,"%s", str);
free(str);
} else {
fprintf(stdout,"NO_LABEL_TABLE");
}
}
break;
case LTABLE_AS_ATLAS_POINT_LIST:
{
ATLAS_POINT_LIST *apl=NULL;
if ((apl =
label_table_to_atlas_point_list(DSET_Label_Dtable(dset)))) {
atlas_list_to_niml(apl,NULL);
free_atlas_point_list(apl);
} else {
fprintf(stdout,"NO_LABEL_TABLE");
}
}
break;
case ATLAS_POINTS:
{
ATR_string *atr =
THD_find_string_atr( dset->dblk, "ATLAS_LABEL_TABLE");
if (atr) {
fprintf(stdout,"%s", atr->ch);
} else {
fprintf(stdout,"NO_APL");
}
}
break;
case FAC:
{
for (isb=0; isb<DSET_NVALS(dset); ++isb) {
fprintf(stdout,"%f%s",
DSET_BRICK_FACTOR(dset,isb),
(isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim);
}
break;
}
case DATUM:
{
for (isb=0; isb<DSET_NVALS(dset); ++isb) {
fprintf(stdout,"%s%s",
MRI_TYPE_name[DSET_BRICK_TYPE(dset,isb)],
(isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim);
}
break;
}
case LABEL:
{
for (isb=0; isb<DSET_NVALS(dset); ++isb) {
fprintf(stdout,"%s%s",
DSET_BRICK_LABEL(dset,isb) ? DSET_BRICK_LABEL(dset,isb):NAflag,
(isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim);
}
break;
}
case MIN:
case MINUS:
case MAX:
case MAXUS:
{
float vv=0.0, min, max;
for (isb=0; isb<DSET_NVALS(dset); ++isb) {
if (!THD_subbrick_minmax(dset, isb,
(sing[iis] == MINUS || sing[iis] == MAXUS) ? 0:1,
&min, &max)) {
fprintf(stdout,"%s%s",
NAflag,
(isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim);
} else {
if (sing[iis] == MINUS)
vv = min;
else if (sing[iis] == MAXUS)
vv = max;
else if (sing[iis] == MIN)
vv = min;
else if (sing[iis] == MAX)
vv = max;
fprintf(stdout,"%g%s",
vv,
(isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim);
}
}
break;
}
case DMIN:
case DMINUS:
case DMAX:
case DMAXUS:
{
float vv=0.0, min, max;
if (!THD_dset_minmax(dset,
(sing[iis] == DMINUS || sing[iis] == DMAXUS) ? 0:1,
&min, &max)) {
fprintf(stdout,"%s%s",
NAflag,
(isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim);
} else {
if (sing[iis] == DMINUS)
vv = min;
else if (sing[iis] == DMAXUS)
vv = max;
else if (sing[iis] == DMIN)
vv = min;
else if (sing[iis] == DMAX)
vv = max;
fprintf(stdout,"%g%s",
vv,
(isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim);
}
break;
}
case TR:
#if 0
fprintf(stdout,"%f", DSET_TR_SEC(dset));
#else
fprintf(stdout,"%f", DSET_TR(dset));
#endif
break;
case ORIENT:
{
/* fprintf(stdout,"%c%c%c",
* ORIENT_typestr[dset->daxes->xxorient][0], ... ); */
char ostr[4]; /* just to show 23 Jan 2013 [rickr] */
THD_fill_orient_str_3(dset->daxes, ostr);
fprintf(stdout,"%3s", ostr);
}
break;
case SAME_GRID:
fprintf(stdout,"%d",
!THD_dataset_mismatch( dset , dsetp ));
break;
case SAME_DIM:
fprintf(stdout,"%d",
!(THD_dataset_mismatch( dset , dsetp ) & MISMATCH_DIMEN));
break;
case SAME_DELTA:
fprintf(stdout,"%d",
!(THD_dataset_mismatch( dset , dsetp ) & MISMATCH_DELTA));
break;
case SAME_ORIENT:
fprintf(stdout,"%d",
!(THD_dataset_mismatch( dset , dsetp ) & MISMATCH_ORIENT));
break;
case SAME_CENTER:
fprintf(stdout,"%d",
!(THD_dataset_mismatch( dset , dsetp ) & MISMATCH_CENTER));
break;
case SAME_OBL:
fprintf(stdout,"%d",
!(THD_dataset_mismatch( dset , dsetp ) & MISMATCH_OBLIQ));
break;
case SLICE_TIMING: /* 6 May 2013 [rickr] */
{
if( DSET_HAS_SLICE_TIMING(dset) ) {
DSET_UNMSEC(dset); /* make sure times are in seconds */
for (isb=0; isb<dset->taxis->nsl; ++isb) {
fprintf(stdout,"%s%f",
(isb > 0) ? sbdelim : "",
dset->taxis->toff_sl[isb]);
}
} else { /* all slices times are at t=0.0 */
for (isb=0; isb<DSET_NZ(dset); ++isb) {
fprintf(stdout,"%s%f", (isb > 0) ? sbdelim : "", 0.0);
}
}
}
break;
case SVAL_DIFF:
fprintf(stdout,"%f",THD_diff_vol_vals(dset, dsetp, 1));
break;
case VAL_DIFF:
fprintf(stdout,"%f",THD_diff_vol_vals(dset, dsetp, 0));
break;
case ID:
fprintf(stdout,"%s", DSET_IDCODE_STR(dset));
break;
case SMODE:
fprintf(stdout,"%s", DSET_STORAGE_MODE_STR(dset));
break;
default:
ERROR_message("Info field not set properly (%d)\n", sing[iis]);
exit(1);
}
if (sing[iis] != CLASSIC) {
SPIT_DELIM(iis, N_sing, atrdelim);
}
}
}
exit(0) ;
}
THD_3dim_dataset * New_Dataset_From_Scratch(char *prefix)
{
THD_3dim_dataset *oset=NULL;
int nvals, ii, jj, kk, nijk, tt;
float *ts=NULL;
char *stmp;
ENTRY("New_Dataset_From_Scratch"); /* The use of ENTRY and RETURN
will allow for the display of
the function call stack on exit */
/*
Create a dataset that has, say, the following properties
Data stored in RAI directions:
1st dimension (i) is from Right To Left
2nd dimension (j) is from Anterior to Posterior
3rd dimension (k, slice) is from Inferior to Superior
Number of voxels along each dimension is:
Ni = 32
Nj = 32
Nk = 10;
Voxel size in mm along each dimension:
Di = 6.0;
Dj = 6.0;
Dk = 5.2;
Voxel origin in mm DICOM RAI
Xorg = -12.7; (Right == -ve X, Left == +ve X)
Yorg = 2.3; (Anterior == -ve Y, Posterior == +ve Y)
Zorg = -4.5; (Inferior == -ve Z, Superior == +ve Z)
We can create this dataset grid with the following command:
EDIT_geometry_constructor("RAI:D:Ni,Xorg,Di,Nj,Yorg,Dj,Nk,Zorg,Dk", PREFIX)
*/
stmp = modify_afni_prefix(prefix,NULL,".scratch");
if (!(oset = EDIT_geometry_constructor(
"RAI:D:32,-12.7,6.0, 32,2.3,6.0, 10,-4.5,5.2",
stmp ))) {
ERROR_message("Failed to create dset %s\n",stmp);
RETURN(oset);
}
/* You can create a dataset with non-cardinal orientation (oblique)
by directly specifying the 3x4 matrix (A) that converts voxel index (i,j,k)
to millimeter RAI coordinates (x,y,z) with:
oset = EDIT_geometry_constructor(
"MATRIX(a11,a12,a13,a14,a21,a22,a23,a24,a31,a32,a33,a34):nx,ny,nz",
"toy_from_grid" );
See Dataset_Navigation() for coordinate manipulation
*/
/* Now let us fill up this dataset with time series, and say we want the
results to be stored in MRI_short.
I use short because in thie example, one is forced to consider what
the scaling factor, if any should be before inserting the time series
into the volume.
Here I know that my values are between -1.0 and 1.0 so a factor of
MRI_TYPE_maxval[MRI_short] is just fine for all nvals sub-bricks
*/
/* Get the dataset ready to receive 100 values per voxel, and say we have
a time axis sampling frequency of 0.5 Hz, TR = 2sec */
nvals = 100;
EDIT_dset_items( oset ,
ADN_datum_all , MRI_short , /* type */
ADN_nvals , nvals , /* Number of values */
ADN_ntt , nvals ,
ADN_ttdel , 2.0 , /* TR */
ADN_tunits , UNITS_SEC_TYPE,
ADN_none ) ; /* Always last param */
/* Allocate space for the storage of each sub-brick and setup
brick factors */
for (tt=0; tt<nvals; ++tt) {
/* By passing NULL below, the function will allocate
space for one sub-brick and return */
EDIT_substitute_brick(oset , tt , MRI_short , NULL ) ;
/* I don't expect much above 10 */
EDIT_BRICK_FACTOR(oset, tt, 10.0/MRI_TYPE_maxval[MRI_short]);
}
/* Now let us put in the time series */
ts = (float *)calloc(nvals, sizeof(float));
nijk=0;
for (kk=0; kk<DSET_NZ(oset); ++ kk) {
for (jj=0; jj<DSET_NY(oset); ++ jj) {
for (ii=0; ii<DSET_NX(oset); ++ ii) {
for (tt=0; tt<nvals; ++tt) {
ts[tt] = (sin(tt*(kk+1.0)/100.0) +
(1+(float)kk/DSET_NZ(oset))*drand48());
}
/* insert the time series */
THD_insert_series(nijk, oset, nvals,
MRI_float, /* indicates the type of ts */
ts, /* The array to be inserted */
0); /* Values in ts should be scaled
before conversion to volume storage
type. This would have been 1 if
oset was a volume of floats. */
++nijk;
} } }
free(ts); ts = NULL;
RETURN(oset);
}
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[] )
{
THD_3dim_dataset *dset_in=NULL , *dset_out ;
int Lxx=-1 , Lyy=-1 , Lzz=-1 , Mode=FFT_ABS , Sign=-1 , do_alt=0 ;
char *prefix = "FFTout" ;
int iarg ;
MRI_IMAGE *inim , *outim ; float fac ; int nx,ny,nz ;
THD_ivec3 iv ;
if( argc < 2 || strcasecmp(argv[1],"-help") == 0 ){
printf(
"Usage: 3dFFT [options] dataset\n"
"\n"
"* Does the FFT of the input dataset in 3 directions (x,y,z) and\n"
" produces the output dataset.\n"
"\n"
"* Why you'd want to do this is an interesting question.\n"
"\n"
"* Program 3dcalc can operate on complex-valued datasets, but\n"
" only on one component at a time (cf. the '-cx2r' option).\n"
"\n"
"* Most other AFNI programs can only operate on real-valued\n"
" datasets.\n"
"\n"
"* You could use 3dcalc (twice) to split a complex-valued dataset\n"
" into two real-valued datasets, do your will on those with other\n"
" AFNI programs, then merge the results back into a complex-valued\n"
" dataset with 3dTwotoComplex.\n"
"\n"
"Options\n"
"=======\n"
" -abs = Outputs the magnitude of the FFT [default]\n"
" -phase = Outputs the phase of the FFT (-PI..PI == no unwrapping!)\n"
" -complex = Outputs the complex-valued FFT\n"
" -inverse = Does the inverse FFT instead of the forward FFT\n"
"\n"
" -Lx xx = Use FFT of length 'xx' in the x-direction\n"
" -Ly yy = Use FFT of length 'yy' in the y-direction\n"
" -Lz zz = Use FFT of length 'zz' in the z-direction\n"
" * Set a length to 0 to skip the FFT in that direction\n"
"\n"
" -altIN = Alternate signs of input data before FFT, to bring\n"
" zero frequency from edge of FFT-space to center of grid\n"
" for cosmetic purposes.\n"
" -altOUT = Alternate signs of output data after FFT. If you\n"
" use '-altI' on the forward transform, then you should\n"
" use '-altO' an the inverse transform, to get the\n"
" signs of the recovered image correct.\n"
" **N.B.: You cannot use '-altIN' and '-altOUT' in the same run!\n"
"\n"
" -input dd = Read the input dataset from 'dd', instead of\n"
" from the last argument on the command line.\n"
"\n"
" -prefix pp = Use 'pp' for the output dataset prefix.\n"
"\n"
"Notes\n"
"=====\n"
" * In the present avatar, only 1 sub-brick will be processed.\n"
"\n"
" * The program can only do FFT lengths that are factorable\n"
" into a product of powers of 2, 3, and 5, and are even.\n"
" + The largest power of 3 that is allowed is 3^3 = 27.\n"
" + The largest power of 5 that is allowed is 5^3 = 125.\n"
" + e.g., FFT of length 3*5*8=120 is possible.\n"
" + e.g., FFT of length 4*31 =124 is not possible.\n"
"\n"
" * The 'x', 'y', and 'z' axes here refer to the order the\n"
" data is stored, not DICOM coordinates; cf. 3dinfo.\n"
"\n"
" * If you force (via '-Lx' etc.) an FFT length that is not\n"
" allowed, the program will stop with an error message.\n"
"\n"
" * If you force an FFT length that is shorter than an dataset\n"
" axis dimension, the program will stop with an error message.\n"
"\n"
" * If you don't force an FFT length along a particular axis,\n"
" the program will pick the smallest legal value that is\n"
" greater than or equal to the corresponding dataset dimension.\n"
" + e.g., 124 would be increased to 128.\n"
"\n"
" * If an FFT length is longer than an axis length, then the\n"
" input data in that direction is zero-padded at the end.\n"
"\n"
" * For -abs and -phase, the output dataset is in float format.\n"
"\n"
" * If you do the forward and inverse FFT, then you should get back\n"
" the original dataset, except for roundoff error and except that\n"
" the new dataset axis dimensions may be longer than the original.\n"
"\n"
" * Forward FFT = sum_{k=0..N-1} [ exp(-2*PI*i*k/N) * data(k) ]\n"
"\n"
" * Inverse FFT = sum_{k=0..N-1} [ exp(+2*PI*i*k/N) * data(k) ] / N\n"
"\n"
" * Started a long time ago, but only finished in Aug 2009 at the\n"
" request of John Butman, because he asked so nicely. (Now pay up!)\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
PRINT_VERSION("3dFFT") ;
mainENTRY("3dFFT main") ; machdep() ; AUTHOR("RW Cox") ;
AFNI_logger("3dFFT",argc,argv) ;
/*--- scan args ---*/
iarg = 1 ;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strncasecmp(argv[iarg],"-altI",5) == 0 ){
do_alt = 1 ; iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-altOUT",5) == 0 ){
do_alt = -1 ; iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-inverse",4) == 0 ){
Sign = +1 ; iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-abs",4) == 0 ){
Mode = FFT_ABS ; iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-phase",4) == 0 ){
Mode = FFT_PHASE ; iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-complex",4) == 0 ){
Mode = FFT_COMPLEX ; iarg++ ; continue ;
}
if( strlen(argv[iarg]) == 3 && strncmp(argv[iarg],"-L",2) == 0 ){
int lll=-1 , mmm ; char *ept ;
iarg++ ;
if( iarg >= argc )
ERROR_exit("need an argument after option %s",argv[iarg-1]) ;
lll = strtol( argv[iarg] , &ept , 10 ) ;
if( *ept != '\0' )
ERROR_exit("bad argument after option %s",argv[iarg-1]) ;
if( lll > 0 && (mmm = csfft_nextup_even(lll)) != lll )
ERROR_exit(
"'%s %d' is not a legal FFT length here: next largest legal value = %d" ,
argv[iarg-1] , lll , mmm ) ;
switch( argv[iarg-1][2] ){
case 'x': case 'X': Lxx = lll ; break ;
case 'y': case 'Y': Lyy = lll ; break ;
case 'z': case 'Z': Lzz = lll ; break ;
default: ERROR_exit("unknown option '%s'",argv[iarg-1]) ;
}
iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-prefix",4) == 0 ){
iarg++ ;
if( iarg >= argc )
ERROR_exit("need an argument after %s\n",argv[iarg-1]) ;
prefix = strdup( argv[iarg] ) ;
if( !THD_filename_ok(prefix) )
ERROR_exit("bad argument after %s\n",argv[iarg-1]) ;
iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-input",4) == 0 ){
iarg++ ;
if( iarg >= argc )
ERROR_exit("need an argument after %s\n",argv[iarg-1]) ;
dset_in = THD_open_dataset(argv[iarg]); CHECK_OPEN_ERROR(dset_in,argv[iarg]);
iarg++ ; continue ;
}
ERROR_exit("unknown option '%s'\n",argv[iarg]) ;
}
/* check for simple errors */
if( Lxx == 0 && Lyy == 0 && Lzz == 0 )
ERROR_exit("-Lx, -Ly, -Lz all given as zero?!") ;
/* open input dataset */
if( dset_in == NULL ){
if( iarg >= argc ) ERROR_exit("no input dataset on command line?!\n") ;
dset_in = THD_open_dataset(argv[iarg]); CHECK_OPEN_ERROR(dset_in,argv[iarg]);
}
nx = DSET_NX(dset_in) ; ny = DSET_NY(dset_in) ; nz = DSET_NZ(dset_in) ;
if( DSET_NVALS(dset_in) > 1 )
WARNING_message("only 3dFFT-ing sub-brick #0 of input dataset") ;
/* establish actual FFT lengths now (0 ==> no FFT) */
if( nx == 1 ) Lxx = 0 ; /* can't FFT if dataset is shrimpy! */
if( ny == 1 ) Lyy = 0 ;
if( nz == 1 ) Lzz = 0 ;
if( Lxx < 0 ) Lxx = csfft_nextup_even(nx) ; /* get FFT length from */
if( Lyy < 0 ) Lyy = csfft_nextup_even(ny) ; /* dataset dimensions */
if( Lzz < 0 ) Lzz = csfft_nextup_even(nz) ;
INFO_message("x-axis length=%d ; FFT length=%d %s",nx,Lxx,(Lxx==0)?"==> none":"\0") ;
INFO_message("y-axis length=%d ; FFT length=%d %s",ny,Lyy,(Lyy==0)?"==> none":"\0") ;
INFO_message("z-axis length=%d ; FFT length=%d %s",nz,Lzz,(Lzz==0)?"==> none":"\0") ;
if( Lxx > 0 && Lxx < nx ) ERROR_exit("x-axis FFT length too short for data!") ;
if( Lyy > 0 && Lyy < ny ) ERROR_exit("y-axis FFT length too short for data!") ;
if( Lzz > 0 && Lzz < nz ) ERROR_exit("z-axis FFT length too short for data!") ;
/* extract sub-brick #0 */
DSET_load(dset_in) ; CHECK_LOAD_ERROR(dset_in) ;
inim = mri_to_complex( DSET_BRICK(dset_in,0) ) ; /* convert input to complex */
fac = DSET_BRICK_FACTOR(dset_in,0) ;
if( fac > 0.0f && fac != 1.0f ){ /* scale it if needed */
int ii , nvox = nx*ny*nz ; complex *car = MRI_COMPLEX_PTR(inim) ;
for( ii=0 ; ii < nvox ; ii++ ){ car[ii].r *= fac ; car[ii].i *= fac ; }
}
DSET_unload(dset_in) ; /* input data is all copied now */
/* FFT to get output image */
csfft_scale_inverse(1) ; /* scale by 1/N for inverse FFTs */
outim = mri_fft_3D( Sign , inim , Lxx,Lyy,Lzz , do_alt ) ;
mri_free(inim) ;
/* post-process output? */
switch( Mode ){
case FFT_ABS:{
MRI_IMAGE *qim = mri_complex_abs(outim) ;
mri_free(outim) ; outim = qim ;
}
break ;
case FFT_PHASE:{
MRI_IMAGE *qim = mri_complex_phase(outim) ;
mri_free(outim) ; outim = qim ;
}
break ;
}
/* create and write output dataset */
dset_out = EDIT_empty_copy( dset_in ) ;
tross_Copy_History( dset_in , dset_out ) ;
tross_Make_History( "3dFFT" , argc,argv , dset_out ) ;
LOAD_IVEC3( iv , outim->nx , outim->ny , outim->nz ) ;
EDIT_dset_items( dset_out ,
ADN_prefix , prefix ,
ADN_nvals , 1 ,
ADN_ntt , 0 ,
ADN_nxyz , iv , /* change dimensions, possibly */
ADN_none ) ;
EDIT_BRICK_FACTOR( dset_out , 0 , 0.0 ) ;
EDIT_substitute_brick( dset_out , 0 , outim->kind , mri_data_pointer(outim) ) ;
DSET_write(dset_out) ; WROTE_DSET(dset_out) ; DSET_unload(dset_out) ;
exit(0) ;
}
/*!
A function version of the program mc by Thomas Lewiner
see main.c in ./MarchingCubes
*/
SUMA_SurfaceObject *SUMA_MarchingCubesSurface(
SUMA_GENERIC_PROG_OPTIONS_STRUCT * Opt)
{
static char FuncName[]={"SUMA_MarchingCubesSurface"};
SUMA_SurfaceObject *SO=NULL;
int nxx, nyy, nzz, cnt, i, j, k, *FaceSetList=NULL;
float *NodeList=NULL;
SUMA_NEW_SO_OPT *nsoopt = NULL;
THD_fvec3 fv, iv;
MCB *mcp ;
SUMA_ENTRY;
if (Opt->obj_type < 0) {
nxx = DSET_NX(Opt->in_vol);
nyy = DSET_NY(Opt->in_vol);
nzz = DSET_NZ(Opt->in_vol);
if (Opt->debug) {
fprintf(SUMA_STDERR,
"%s:\nNxx=%d\tNyy=%d\tNzz=%d\n", FuncName, nxx, nyy, nzz);
}
mcp = MarchingCubes(-1, -1, -1);
set_resolution( mcp, nxx, nyy, nzz ) ;
init_all(mcp) ;
if (Opt->debug) fprintf(SUMA_STDERR,"%s:\nSetting data...\n", FuncName);
cnt = 0;
for( k = 0 ; k < mcp->size_z ; k++ ) {
for( j = 0 ; j < mcp->size_y ; j++ ) {
for( i = 0 ; i < mcp->size_x ; i++ ) {
SUMA_SET_MC_DATA ( mcp, Opt->mcdatav[cnt], i, j, k);
++cnt;
}
}
}
} else {
/* built in */
nxx = nyy = nzz = Opt->obj_type_res;
mcp = MarchingCubes(-1, -1, -1);
set_resolution( mcp, nxx, nyy, nzz) ;
init_all(mcp) ;
compute_data( *mcp , Opt->obj_type) ;
}
if (Opt->debug)
fprintf(SUMA_STDERR,"%s:\nrunning MarchingCubes...\n", FuncName);
run(mcp) ;
clean_temps(mcp) ;
if (Opt->debug > 1) {
fprintf(SUMA_STDERR,"%s:\nwriting out NodeList and FaceSetList...\n",
FuncName);
write1Dmcb(mcp);
}
if (Opt->debug) {
fprintf(SUMA_STDERR,"%s:\nNow creating SO...\n", FuncName);
}
NodeList = (float *)SUMA_malloc(sizeof(float)*3*mcp->nverts);
FaceSetList = (int *)SUMA_malloc(sizeof(int)*3*mcp->ntrigs);
if (!NodeList || !FaceSetList) {
SUMA_SL_Crit("Failed to allocate!");
SUMA_RETURN(SO);
}
nsoopt = SUMA_NewNewSOOpt();
if (Opt->obj_type < 0) {
nsoopt->LargestBoxSize = -1;
if (Opt->debug) {
fprintf(SUMA_STDERR,
"%s:\nCopying vertices, changing to DICOM \n"
"Orig:(%f %f %f) \nD:(%f %f %f)...\n",
FuncName,
DSET_XORG(Opt->in_vol),
DSET_YORG(Opt->in_vol), DSET_ZORG(Opt->in_vol),
DSET_DX(Opt->in_vol),
DSET_DY(Opt->in_vol), DSET_DZ(Opt->in_vol));
}
for ( i = 0; i < mcp->nverts; i++ ) {
j = 3*i; /* change from index coordinates to mm DICOM, next three lines are equivalent of SUMA_THD_3dfind_to_3dmm*/
fv.xyz[0] = DSET_XORG(Opt->in_vol) + mcp->vertices[i].x * DSET_DX(Opt->in_vol);
fv.xyz[1] = DSET_YORG(Opt->in_vol) + mcp->vertices[i].y * DSET_DY(Opt->in_vol);
fv.xyz[2] = DSET_ZORG(Opt->in_vol) + mcp->vertices[i].z * DSET_DZ(Opt->in_vol);
/* change mm to RAI coords */
iv = SUMA_THD_3dmm_to_dicomm( Opt->in_vol->daxes->xxorient, Opt->in_vol->daxes->yyorient, Opt->in_vol->daxes->zzorient, fv );
NodeList[j ] = iv.xyz[0];
NodeList[j+1] = iv.xyz[1];
NodeList[j+2] = iv.xyz[2];
}
for ( i = 0; i < mcp->ntrigs; i++ ) {
j = 3*i;
FaceSetList[j ] = mcp->triangles[i].v3;
FaceSetList[j+1] = mcp->triangles[i].v2;
FaceSetList[j+2] = mcp->triangles[i].v1;
}
} else {
nsoopt->LargestBoxSize = 100;
/* built in */
for ( i = 0; i < mcp->nverts; i++ ) {
j = 3*i;
NodeList[j ] = mcp->vertices[i].x;
NodeList[j+1] = mcp->vertices[i].y;
NodeList[j+2] = mcp->vertices[i].z;
}
for ( i = 0; i < mcp->ntrigs; i++ ) {
j = 3*i;
FaceSetList[j ] = mcp->triangles[i].v3;
FaceSetList[j+1] = mcp->triangles[i].v2;
FaceSetList[j+2] = mcp->triangles[i].v1;
}
}
SO = SUMA_NewSO(&NodeList, mcp->nverts, &FaceSetList, mcp->ntrigs, nsoopt);
if (Opt->obj_type < 0) {
/* not sure if anything needs to be done here ...*/
} else {
if (Opt->obj_type == 0) SO->normdir = 1;
else SO->normdir = -1;
}
if (Opt->debug) {
fprintf(SUMA_STDERR,"%s:\nCleaning mcp...\n", FuncName);
}
clean_all(mcp) ;
free(mcp);
nsoopt=SUMA_FreeNewSOOpt(nsoopt);
SUMA_RETURN(SO);
}
int main(int argc, char *argv[]) {
int i, k, ii;
int iarg;
char *prefix=NULL;
char *maskname=NULL;
char *gradsname=NULL;
char *dtsname=NULL;
THD_3dim_dataset *MASK=NULL;
THD_3dim_dataset *DTS=NULL;
MRI_IMAGE *GRADS=NULL, *GRADS_IN=NULL;
int Ngrads=0, Nfull=0;
int Nvox=-1; // tot number vox
int Dim[3]={0,0,0}; // dim in each dir
float NOISESCALE_DWI = -1.;
float NOISESCALE_B0 = -1;
float S0 = 1000.;
float bval = 1.;
int NOISE_IN_S0 = 0;
byte *mskd2=NULL; // not great, but another format of mask
float **dwi=NULL;
THD_3dim_dataset *DWI_OUT=NULL;
const gsl_rng_type * T;
gsl_rng *r;
long seed;
srand(time(0));
seed = time(NULL) ;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc (T);
gsl_rng_set (r, seed);
// ###################################################################
// ######################### load ##################################
// ###################################################################
mainENTRY("3dDTtoNoisyDWI"); machdep();
if (argc == 1) { usage_DTtoNoisyDWI(1); exit(0); }
iarg = 1;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-help") == 0 ||
strcmp(argv[iarg],"-h") == 0 ) {
usage_DTtoNoisyDWI(strlen(argv[iarg])>3 ? 2:1);
exit(0);
}
if( strcmp(argv[iarg],"-dt_in") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-eig_vecs'");
dtsname = strdup(argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-prefix") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-prefix'");
prefix = strdup(argv[iarg]) ;
if( !THD_filename_ok(prefix) )
ERROR_exit("Illegal name after '-prefix'");
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mask") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-mask'");
maskname = strdup(argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-grads") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-mask'");
gradsname = strdup(argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-noise_DWI") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need numerical argument after '-noise_DWI'");
NOISESCALE_DWI = atof(argv[iarg]);
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-noise_B0") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need numerical argument after '-noise_B0'");
NOISESCALE_B0 = atof(argv[iarg]);
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-S0") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need numerical argument after '-S0'");
S0 = atof(argv[iarg]);
if(S0 <= 0 )
ERROR_exit("The '-S0' value must be >0.");
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-bval") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need numerical argument after '-bval'");
bval = atof(argv[iarg]);
if(bval <= 0 )
ERROR_exit("The '-bval' value must be >0.");
iarg++ ; continue ;
}
ERROR_message("Bad option '%s'\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
// ###################################################################
// #################### some checks ###############################
// ###################################################################
if(!prefix)
ERROR_exit("Need to give a '-prefix'.");
if(!dtsname)
ERROR_exit("Need to input diffusion tensor file after '-dt_in'.");
if(!gradsname)
ERROR_exit("Need to input gradient file after '-grads'.");
if( NOISESCALE_DWI<0 )
ERROR_exit("Fractional noise value after '-snr0' needs to be >0. "
"It sets the noise scale of ref signal S0.");
if(NOISESCALE_DWI > 0)
INFO_message("You have chosen an SNR0 of approximately %.2f for DWIs",
1./NOISESCALE_DWI);
else
INFO_message("You have noiseless (i.e., infinite SNR) set of DWIs");
if( NOISESCALE_B0 < 0 )
NOISESCALE_B0 = NOISESCALE_DWI;
if(NOISESCALE_B0 > 0)
INFO_message("You have chosen an SNR0 of approximately %.2f for the B0",
1./NOISESCALE_B0);
else
INFO_message("You have noiseless (i.e., infinite SNR) reference B0.");
// ###################################################################
if(dtsname) {
DTS = THD_open_dataset(dtsname);
DSET_load(DTS); CHECK_LOAD_ERROR(DTS);
if( 6 != DSET_NVALS(DTS) )
ERROR_exit("DT file '%s' must have 6 bricks-- "
"it has %d bricks!",
dtsname, DSET_NVALS(DTS));
}
Nvox = DSET_NVOX(DTS);
Dim[0] = DSET_NX(DTS);
Dim[1] = DSET_NY(DTS);
Dim[2] = DSET_NZ(DTS);
if(Nvox<0)
ERROR_exit("Error reading Nvox from eigenvalue file.");
mskd2 = (byte *)calloc(Nvox,sizeof(byte));
if( (mskd2 == NULL)) {
fprintf(stderr, "\n\n MemAlloc failure (masks).\n\n");
exit(122);
}
if(maskname) {
MASK = THD_open_dataset(maskname);
DSET_load(MASK); CHECK_LOAD_ERROR(MASK);
if( 1 != DSET_NVALS(MASK) )
ERROR_exit("Mask file '%s' is not scalar-- "
"it has %d bricks!",
maskname, DSET_NVALS(MASK));
for( k=0 ; k<Nvox ; k++ )
if (THD_get_voxel(MASK, k, 0) > 0 )
mskd2[k] = 1;
DSET_delete(MASK);
free(MASK);
free(maskname);
}
else {
for( k=0 ; k<Nvox ; k++ )
if( fabs(THD_get_voxel(DTS,k,0) > EPS_V) )
mskd2[k] = 1;
}
GRADS_IN = mri_read_1D (gradsname);
GRADS = mri_transpose(GRADS_IN); // get rid of autotranspose...
if (GRADS == NULL)
ERROR_exit("Error reading gradient vector file");
mri_free(GRADS_IN);
Ngrads = GRADS->ny;
if(Ngrads < 6)
ERROR_exit("Too few grads (there appear to be only %d).",Ngrads);
if(GRADS->nx !=3 )
ERROR_exit("Wrong number of columns in the grad file: "
" am reading %d instead of 3.",GRADS->nx);
Nfull = Ngrads+1;
INFO_message("Have surmised there are %d total grads; "
"output file will have %d bricks", Ngrads,Nfull);
dwi = calloc(Nfull,sizeof(dwi));
for(i=0 ; i<Nfull ; i++)
dwi[i] = calloc( Nvox,sizeof(float));
INFO_message("Calculating the DWIs.");
i = RicianNoiseDWIs( dwi, Nvox, Ngrads, DTS,
NOISESCALE_DWI, NOISESCALE_B0,
GRADS, mskd2,
S0, bval, r);
INFO_message("Writing the DWIs.");
DWI_OUT = EDIT_empty_copy( DTS );
EDIT_dset_items(DWI_OUT,
ADN_nvals, Nfull,
ADN_datum_all, MRI_float ,
ADN_prefix, prefix,
ADN_none );
for( i=0; i<Nfull ; i++) {
EDIT_substitute_brick(DWI_OUT, i, MRI_float, dwi[i]);
dwi[i]=NULL;
}
THD_load_statistics( DWI_OUT );
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(DWI_OUT)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(DWI_OUT));
tross_Make_History("3dDTtoNoisyDWI", argc, argv, DWI_OUT);
THD_write_3dim_dataset(NULL, NULL, DWI_OUT, True);
DSET_delete(DWI_OUT);
free(DWI_OUT);
// #################################################################
// ########################## free ###############################
// #################################################################
DSET_delete(DTS);
free(DTS);
for( i=0 ; i<Nfull ; i++)
free(dwi[i]);
free(dwi);
free(prefix);
free(gradsname);
free(dtsname);
mri_free(GRADS);
return 0;
}
MRI_vectim * THD_dset_censored_to_vectim( THD_3dim_dataset *dset,
byte *mask , int nkeep , int *keep )
{
byte *mmm=mask ;
MRI_vectim *mrv=NULL ;
int kk,iv,jj , nvals , nvox , nmask ;
ENTRY("THD_dset_censored_to_vectim") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
if( nkeep <= 0 || keep == NULL ){
mrv = THD_dset_to_vectim( dset , mask , 0 ) ;
RETURN(mrv) ;
}
if( ! THD_subset_loaded(dset,nkeep,keep) ){
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
}
nvals = nkeep ;
nvox = DSET_NVOX(dset) ;
if( mmm != NULL ){
nmask = THD_countmask( nvox , mmm ) ; /* number to keep */
if( nmask <= 0 ) RETURN(NULL) ;
} else {
nmask = nvox ; /* keep them all */
#pragma omp critical (MALLOC)
mmm = (byte *)malloc(sizeof(byte)*nmask) ;
if( mmm == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
RETURN(NULL) ;
}
memset( mmm , 1 , sizeof(byte)*nmask ) ;
}
#pragma omp critical (MALLOC)
mrv = (MRI_vectim *)malloc(sizeof(MRI_vectim)) ;
mrv->nvec = nmask ;
mrv->nvals = nvals ;
mrv->ignore = 0 ;
#pragma omp critical (MALLOC)
mrv->ivec = (int *)malloc(sizeof(int)*nmask) ;
if( mrv->ivec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
}
#pragma omp critical (MALLOC)
mrv->fvec = (float *)malloc(sizeof(float)*(size_t)nmask*(size_t)nvals) ;
if( mrv->fvec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
free(mrv->ivec) ; free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
}
/* store desired voxel time series */
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] ) mrv->ivec[kk++] = iv ; /* build index list */
}
#pragma omp critical (MALLOC)
{ float *var = (float *)malloc(sizeof(float)*DSET_NVALS(dset)) ;
float *vpt ;
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] == 0 ) continue ;
vpt = VECTIM_PTR(mrv,kk) ; kk++ ;
if( nkeep > 1 ){
(void)THD_extract_array( iv , dset , 0 , var ) ;
for( jj=0 ; jj < nkeep ; jj++ ) vpt[jj] = var[keep[jj]] ;
} else {
vpt[0] = THD_get_float_value(iv,keep[0],dset) ;
}
}
free(var) ;
}
mrv->nx = DSET_NX(dset) ; mrv->dx = fabs(DSET_DX(dset)) ;
mrv->ny = DSET_NY(dset) ; mrv->dy = fabs(DSET_DY(dset)) ;
mrv->nz = DSET_NZ(dset) ; mrv->dz = fabs(DSET_DZ(dset)) ;
DSET_UNMSEC(dset) ; mrv->dt = DSET_TR(dset) ;
if( mrv->dt <= 0.0f ) mrv->dt = 1.0f ;
if( mmm != mask ) free(mmm) ;
VECTIM_scan(mrv) ; /* 09 Nov 2010 */
RETURN(mrv) ;
}
MRI_shindss * GRINCOR_read_input( char *fname )
{
NI_element *nel=NULL ;
char *dfname=NULL , *atr ;
NI_float_array *facar ; NI_int_array *nvar, *nnode=NULL, *ninmask=NULL;
MRI_shindss *shd ;
long long nbytes_needed , nbytes_dfname=0 ; int fdes ;
void *var ; int ids , nvmax , nvtot ;
int datum , datum_size ;
char *geometry_string=NULL ;
THD_3dim_dataset *tdset=NULL; int nvox;
int no_ivec=0 , *ivec=NULL , *nvals=NULL , nvec,ndset ; float *fac=NULL ;
NI_str_array *slabar=NULL ;
if( fname == NULL || *fname == '\0' ) GQUIT(NULL) ;
/* get data element */
if (!THD_is_ondisk(fname))
GQUIT("not on disk") ;
nelshd = nel = NI_read_element_fromfile(fname) ;
if( nel == NULL || nel->type != NI_ELEMENT_TYPE )
GQUIT("not properly formatted") ;
if( strcmp(nel->name,"3dGroupInCorr") != 0 )
GQUIT("data element name is not '3dGroupInCorr'") ;
/* no data vector ==> using all voxels */
no_ivec = ( nel->vec_num < 1 ||
nel->vec_len < 1 || nel->vec_typ[0] != NI_INT ) ;
/* number of vectors in each dataset */
atr = NI_get_attribute(nel,"nvec");
if( atr == NULL ) GQUIT("nvec attribute missing?") ;
nvec = (int)strtod(atr,NULL) ;
if( nvec < 2 || (!no_ivec && nel->vec_len != nvec) )
GQUIT("nvec attribute has illegal value") ;
/* number of datasets */
atr = NI_get_attribute(nel,"ndset");
if( atr == NULL ) GQUIT("ndset attribute missing") ;
ndset = (int)strtod(atr,NULL) ;
if( ndset < 1 ) GQUIT("ndset attribute has illegal value") ;
/* number of time points in each dataset (varies with dataset) */
atr = NI_get_attribute(nel,"nvals");
if( atr == NULL ) GQUIT("nvals attribute missing") ;
nvar = NI_decode_int_list(atr,",") ;
if( nvar == NULL || nvar->num < ndset )
GQUIT("nvals attribute doesn't match ndset") ;
nvals = nvar->ar ; nvar->ar = NULL ; NI_delete_int_array(nvar) ;
nvmax = nvtot = nvals[0] ;
for( ids=1 ; ids < ndset ; ids++ ){ /* Feb 2011 */
nvtot += nvals[ids] ;
if( nvals[ids] > nvmax ) nvmax = nvals[ids] ;
}
/* dataset labels [23 May 2010] */
atr = NI_get_attribute(nel,"dset_labels") ;
if( atr != NULL ){
slabar = NI_decode_string_list(atr,";,") ;
if( slabar == NULL || slabar->num < ndset )
GQUIT("dset_labels attribute invalid") ;
}
/* datum of datasets */
atr = NI_get_attribute(nel,"datum") ;
if( atr != NULL && strcasecmp(atr,"byte") == 0 ){
datum = 1 ; datum_size = sizeof(sbyte) ;
} else {
datum = 2 ; datum_size = sizeof(short) ;
}
/* number of bytes needed:
sizeof(datum) * number of vectors per dataset
* number of datasets
* sum of per dataset vector lengths */
nbytes_needed = 0 ;
for( ids=0 ; ids < ndset ; ids++ ) nbytes_needed += nvals[ids] ;
nbytes_needed *= ((long long)nvec) * datum_size ;
if( nbytes_needed >= twogig &&
( sizeof(void *) < 8 || sizeof(size_t) < 8 ) ) /* too much for 32-bit */
GQUIT("datafile size exceeds 2 GB -- you need a 64-bit computer!") ;
/* scale factor for each dataset */
atr = NI_get_attribute(nel,"fac") ;
if( atr == NULL ) GQUIT("fac attribute missing") ;
facar = NI_decode_float_list(atr,",") ;
if( facar == NULL || facar->num < ndset )
GQUIT("can't decode fac attribute") ;
fac = facar->ar ; facar->ar = NULL ; NI_delete_float_array(facar) ;
for( ids=0 ; ids < ndset ; ids++ ) if( fac[ids] <= 0.0f ) fac[ids] = 1.0f ;
/* grid definition */
atr = NI_get_attribute(nel,"geometry") ;
if( atr == NULL ) GQUIT("geometry attribute missing") ;
geometry_string = strdup(atr) ;
tdset = EDIT_geometry_constructor( geometry_string , "GrpInCorr" ) ;
if( tdset == NULL ) GQUIT("can't decode geometry attribute") ;
nvox = DSET_NVOX(tdset) ;
if( no_ivec && nvox != nvec )
GQUIT("geometry attribute doesn't match nvec attribute") ;
if( !no_ivec && nvox < nvec )
GQUIT("geometry attribute specifies too few voxels") ;
/* name of data file: check its size against what's needed */
#if 0
atr = NI_get_attribute(nel,"datafile") ;
if( atr != NULL ){
dfname = strdup(atr) ; nbytes_dfname = THD_filesize(dfname) ;
if( nbytes_dfname <= 0 && strstr(dfname,"/") != NULL ){
char *tnam = THD_trailname(atr,0) ;
nbytes_dfname = THD_filesize(tnam) ;
if( nbytes_dfname > 0 ){ free(dfname); dfname = strdup(tnam); }
}
}
#endif
if( nbytes_dfname <= 0 && strstr(fname,".niml") != NULL ){
if( dfname != NULL ) free(dfname) ;
dfname = strdup(fname) ; strcpy(dfname+strlen(dfname)-5,".data") ;
nbytes_dfname = THD_filesize(dfname) ;
}
if( nbytes_dfname <= 0 ){
char mess[THD_MAX_NAME+256] ;
sprintf(mess,"datafile is missing (%s)",dfname) ; GQUIT(mess) ;
} else if( nbytes_dfname < nbytes_needed ){
char mess[THD_MAX_NAME+1024] ;
sprintf(mess,"datafile %s has %s bytes but needs at least %s",
dfname ,
commaized_integer_string(nbytes_dfname) ,
commaized_integer_string(nbytes_needed) ) ;
GQUIT(mess) ;
} else {
INFO_message("EIC: data file %s found with %s bytes of data",
dfname , commaized_integer_string(nbytes_dfname) ) ;
}
fdes = open( dfname , O_RDWR ) ;
if( fdes < 0 ){
char mess[THD_MAX_NAME+256] ;
sprintf(mess,"can't open datafile (%s)",dfname) ; GQUIT(mess) ;
}
NI_set_attribute( nelshd , "datafile" , dfname ) ;
/* ivec[i] is the voxel spatial index of the i-th vector */
if( no_ivec ){
ivec = NULL ; /* means all voxels: ivec[i] == i */
} else {
ivec = (int *)nel->vec[0] ; /* copy pointer */
nel->vec[0] = NULL ; /* NULL out in element so won't be free-ed */
}
/* And stuff for LR surface pairs ZSS Jan 09*/
if ((atr=NI_get_attribute(nel,"LRpair_nnode"))) {
nnode = NI_decode_int_list(atr,",") ;
}
if ((atr=NI_get_attribute(nel,"LRpair_ninmask"))) {
ninmask = NI_decode_int_list(atr,",") ;
}
/* create output struct */
shd = (MRI_shindss *)malloc(sizeof(MRI_shindss)) ;
shd->nvals = nvals ; shd->nvals_max = nvmax ; shd->nvals_tot = nvtot ;
shd->nvec = nvec ;
shd->ndset = ndset ;
shd->geometry_string = geometry_string ;
shd->tdset = tdset ;
shd->dfname = dfname ;
shd->nvox = nvox ;
shd->nx = DSET_NX(tdset); shd->ny = DSET_NY(tdset); shd->nz = DSET_NZ(tdset);
shd->ivec = ivec ;
shd->fac = fac ;
/* and surface fields... ZSS Jan 09 */
if (nnode) {
if (nnode->num != 2) GQUIT("LRpair_nnode must have 2 values");
shd->nnode[0] = nnode->ar[0];
shd->nnode[1] = nnode->ar[1];
NI_delete_int_array(nnode); nnode=NULL;
} else {
shd->nnode[0] = shd->nnode[1] = -1 ;
}
if (ninmask) {
if (ninmask->num != 2) GQUIT("LRpair_ninmask must have 2 values");
shd->ninmask[0] = ninmask->ar[0];
shd->ninmask[1] = ninmask->ar[1];
NI_delete_int_array(ninmask); ninmask=NULL;
} else {
shd->ninmask[0] = shd->ninmask[1] = -1 ;
}
/*--- 07 Apr 2010: setup default use list (all of them) ---*/
shd->nuse = ndset ;
shd->use = (int *)malloc(sizeof(int)*ndset) ;
for( ids=0 ; ids < ndset ; ids++ ) shd->use[ids] = ids ;
shd->dslab = (slabar != NULL) ? slabar->str : NULL ; /* 23 May 2010 */
/*--- now have to map data from disk ---*/
var = mmap( 0 , (size_t)nbytes_needed ,
PROT_WRITE , THD_MMAP_FLAG , fdes , 0 ) ;
close(fdes) ; /* close file descriptor does not unmap data */
if( var == (void *)(-1) ){ /* this is bad */
ERROR_message(
"EIC: file %s: can't mmap() datafile -- memory space exhausted?" , dfname ) ;
free(shd) ; return NULL ;
}
/*-- create array of pointers to each dataset's data array --*/
shd->datum = datum ;
if( datum == 2 ){ /* shorts */
shd->sv = (short **)malloc(sizeof(short *)*ndset) ;
shd->bv = NULL ;
shd->sv[0] = (short *)var ;
for( ids=1 ; ids < ndset ; ids++ )
shd->sv[ids] = shd->sv[ids-1] + nvals[ids-1]*nvec ;
} else { /* sbytes */
shd->sv = NULL ;
shd->bv = (sbyte **)malloc(sizeof(sbyte *)*ndset) ;
shd->bv[0] = (sbyte *)var ;
for( ids=1 ; ids < ndset ; ids++ )
shd->bv[ids] = shd->bv[ids-1] + nvals[ids-1]*nvec ;
}
shd->nbytes = nbytes_needed ;
return shd ;
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *inset=NULL , *outset ;
THD_3dim_dataset **insar=NULL ; int nsar=0 ;
int iarg=1 , ii,kk , ids ;
MCW_cluster *nbhd=NULL ;
char *prefix="./localhistog" ;
int ntype=0 ; float na=0.0f,nb=0.0f,nc=0.0f ;
int verb=1 , do_prob=0 ;
int nx=0,ny=0,nz=0,nvox=0, rbot,rtop ;
char *labfile=NULL ; NI_element *labnel=NULL ;
int nlab=0 , *labval=NULL ; char **lablab=NULL ; char buf[THD_MAX_SBLABEL] ;
UINT32 *ohist , *mhist=NULL ; char *ohist_name=NULL ; int ohzadd=0 ;
int *rlist , numval ; float mincount=0.0f ; int mcc ;
int *exlist=NULL, numex=0 ;
int do_excNONLAB=0 ;
/*---- for the clueless who wish to become clued-in ----*/
if( argc == 1 ){ usage_3dLocalHistog(1); exit(0); } /* Bob's help shortcut */
/*---- official startup ---*/
#if defined(USING_MCW_MALLOC) && !defined(USE_OMP)
enable_mcw_malloc() ;
#endif
PRINT_VERSION("3dLocalHistog"); mainENTRY("3dLocalHistog main"); machdep();
AFNI_logger("3dLocalHistog",argc,argv);
if( getpid()%2 ) AUTHOR("Bilbo Baggins"); else AUTHOR("Thorin Oakenshield");
AFNI_SETUP_OMP(0) ; /* 24 Jun 2013 */
/*---- loop over options ----*/
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-help") == 0 || strcmp(argv[iarg],"-h") == 0){
usage_3dLocalHistog(strlen(argv[iarg])>3 ? 2:1);
exit(0);
}
if( strncmp(argv[iarg],"-qu",3) == 0 ){
verb = 0 ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-verb",5) == 0 ){
verb++ ; iarg++ ; continue ;
}
#ifdef ALLOW_PROB
if( strncmp(argv[iarg],"-prob",5) == 0 ){
do_prob = 1 ; iarg++ ; continue ;
}
#endif
if( strcmp(argv[iarg],"-exclude") == 0 ){
int ebot=-6666666,etop=-6666666 , ee ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-exclude'") ;
sscanf(argv[iarg],"%d..%d",&ebot,&etop) ;
if( ebot >= -TWO15 && ebot <= TWO15 ){
if( etop < -TWO15 || etop > TWO15 || etop < ebot ) etop = ebot ;
exlist = (int *)realloc(exlist,sizeof(int)*(etop-ebot+1+numex+1)) ;
for( ee=ebot ; ee <= etop ; ee++ ){ if( ee != 0 ) exlist[numex++] = ee ; }
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-excNONLAB") == 0 ){
do_excNONLAB = 1 ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-prefix") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '-prefix'") ;
prefix = strdup(argv[iarg]) ;
if( !THD_filename_ok(prefix) ) ERROR_exit("Bad -prefix!") ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-hsave") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '-hsave'") ;
ohist_name = strdup(argv[iarg]) ;
if( !THD_filename_ok(ohist_name) ) ERROR_exit("Bad -hsave!") ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mincount") == 0 ){
char *cpt ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-mincount'") ;
mincount = (float)strtod(argv[iarg],&cpt) ;
#if 0
if( mincount > 0.0f && mincount < 50.0f && *cpt == '%' ) /* percentage */
mincount = -0.01f*mincount ;
#endif
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 ) ;
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 if( strncasecmp(cpt,"TOHD",4) == 0 ){
sscanf( cpt+5 , "%f" , &na ) ;
if( na == 0.0f ) ERROR_exit("Can't have a TOHD of radius 0") ;
ntype = NTYPE_TOHD ;
} else {
ERROR_exit("Unknown -nbhd shape: '%s'",cpt) ;
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-lab_file") == 0 || strcmp(argv[iarg],"-labfile") == 0 ){
char **labnum ; int nbad=0 ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '%s'",argv[iarg-1]) ;
if( labfile != NULL ) ERROR_exit("Can't use '%s' twice!",argv[iarg-1]) ;
labfile = strdup(argv[iarg]) ;
labnel = THD_string_table_read(labfile,0) ;
if( labnel == NULL || labnel->vec_num < 2 )
ERROR_exit("Can't read label file '%s'",labfile) ;
nlab = labnel->vec_len ;
labnum = (char **)labnel->vec[0] ;
lablab = (char **)labnel->vec[1] ;
labval = (int *)calloc(sizeof(int),nlab) ;
for( ii=0 ; ii < nlab ; ii++ ){
if( labnum[ii] != NULL ){
labval[ii] = (int)strtod(labnum[ii],NULL) ;
if( labval[ii] < -TWO15 || labval[ii] > TWO15 ){ labval[ii] = 0; nbad++; }
}
}
if( nbad > 0 )
ERROR_message("%d label values are outside the range %d..%d :-(" ,
nbad , -TWO15 , TWO15 ) ;
iarg++ ; continue ;
}
ERROR_message("** 3dLocalHistog: Illegal option: '%s'",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1) ;
} /*--- end of loop over options ---*/
/*---- check for stupid user inputs ----*/
if( iarg >= argc ) ERROR_exit("No datasets on command line?") ;
if( ohist_name == NULL && strcmp(prefix,"NULL") == 0 )
ERROR_exit("-prefix NULL is only meaningful if you also use -hsave :-(") ;
/*------------ scan input datasets, built overall histogram ------------*/
nsar = argc - iarg ;
insar = (THD_3dim_dataset **)malloc(sizeof(THD_3dim_dataset *)*nsar) ;
if( verb ) fprintf(stderr,"Scanning %d datasets ",nsar) ;
ohist = (UINT32 *)calloc(sizeof(UINT32),TWO16) ;
for( ids=iarg ; ids < argc ; ids++ ){ /* dataset loop */
insar[ids-iarg] = inset = THD_open_dataset(argv[ids]) ;
CHECK_OPEN_ERROR(inset,argv[ids]) ;
if( ids == iarg ){
nx = DSET_NX(inset); ny = DSET_NY(inset); nz = DSET_NZ(inset); nvox = nx*ny*nz;
} else if( nx != DSET_NX(inset) ||
ny != DSET_NY(inset) || nz != DSET_NZ(inset) ){
ERROR_exit("Dataset %s grid doesn't match!",argv[ids]) ;
}
if( !THD_datum_constant(inset->dblk) )
ERROR_exit("Dataset %s doesn't have a fixed data type! :-(",argv[ids]) ;
if( THD_need_brick_factor(inset) )
ERROR_exit("Dataset %s has scale factors! :-(",argv[ids]) ;
if( DSET_BRICK_TYPE(inset,0) != MRI_byte &&
DSET_BRICK_TYPE(inset,0) != MRI_short &&
DSET_BRICK_TYPE(inset,0) != MRI_float )
ERROR_exit("Dataset %s is not byte- or short-valued! :-(",argv[ids]) ;
DSET_load(inset) ; CHECK_LOAD_ERROR(inset) ;
for( ii=0 ; ii < DSET_NVALS(inset) ; ii++ ){ /* add to overall histogram */
if( verb ) fprintf(stderr,".") ;
switch( DSET_BRICK_TYPE(inset,ii) ){
case MRI_short:{
short *sar = (short *)DSET_BRICK_ARRAY(inset,ii) ;
for( kk=0 ; kk < nvox ; kk++ ) ohist[ sar[kk]+TWO15 ]++ ;
}
break ;
case MRI_byte:{
byte *bar = (byte *)DSET_BRICK_ARRAY(inset,ii) ;
for( kk=0 ; kk < nvox ; kk++ ) ohist[ bar[kk]+TWO15 ]++ ;
}
break ;
case MRI_float:{
float *far = (float *)DSET_BRICK_ARRAY(inset,ii) ; short ss ;
for( kk=0 ; kk < nvox ; kk++ ){ ss = SHORTIZE(far[kk]); ohist[ss+TWO15]++; }
}
break ;
}
} /* end of sub-brick loop */
DSET_unload(inset) ; /* will re-load later, as needed */
} /* end of dataset loop */
if( verb ) fprintf(stderr,"\n") ;
/*-------------- process overall histogram for fun and profit -------------*/
/* if we didn't actually find 0, put it in the histogram now */
if( ohist[0+TWO15] == 0 ){ ohist[0+TWO15] = 1 ; ohzadd = 1 ; }
/* excNONLAB? */
if( nlab > 0 && do_excNONLAB ){
byte *klist = (byte *)calloc(sizeof(byte),TWO16) ; int nee ;
for( ii=0 ; ii < nlab ; ii++ ){ if( labval[ii] != 0 ) klist[labval[ii]+TWO15] = 1 ; }
for( nee=ii=0 ; ii < TWO16 ; ii++ ){ if( !klist[ii] ) nee++ ; }
exlist = (int *)realloc(exlist,sizeof(int)*(numex+nee+1)) ;
for( ii=0 ; ii < TWO16 ; ii++ ){ if( ii != TWO15 && !klist[ii] ) exlist[numex++] = ii-TWO15 ; }
free(klist) ;
}
/* make a copy of ohist and edit it for mincount, etc */
mhist = (UINT32 *)malloc(sizeof(UINT32)*TWO16) ;
memcpy(mhist,ohist,sizeof(UINT32)*TWO16) ;
mcc = (mincount < 0.0f) ? (int)(-mincount*nvox) : (int)mincount ;
if( mcc > 1 ){
for( ids=ii=0 ; ii < TWO16 ; ii++ ){
if( ii != TWO15 && mhist[ii] > 0 && mhist[ii] < mcc ){ mhist[ii] = 0; ids++; }
}
if( ids > 0 && verb )
INFO_message("Edited out %d values with overall histogram counts less than %d",ids,mcc) ;
}
if( numex > 0 ){
int ee ;
for( ids=0,ii=0 ; ii < numex ; ii++ ){
ee = exlist[ii] ;
if( mhist[ee+TWO15] > 0 ){ mhist[ee+TWO15] = 0; ids++; }
}
free(exlist) ;
if( ids > 0 && verb )
INFO_message("Edited out %d values from the exclude list",ids) ;
}
/* count number of values with nonzero (edited) counts */
numval = 0 ;
for( ii=0 ; ii < TWO16 ; ii++ ) if( mhist[ii] != 0 ) numval++ ;
if( numval == 0 ) ERROR_exit("Nothing found! WTF?") ; /* should not happen */
/* make list of all values with nonzero (edited) count */
rlist = (int *)malloc(sizeof(int)*numval) ;
if( verb > 1 ) fprintf(stderr,"++ Include list:") ;
for( ii=kk=0 ; ii < TWO16 ; ii++ ){
if( mhist[ii] != 0 ){
rlist[kk++] = ii-TWO15 ;
if( verb > 1 ) fprintf(stderr," %d[%u]",ii-TWO15,mhist[ii]) ;
}
}
if( verb > 1 ) fprintf(stderr,"\n") ;
rbot = rlist[0] ; rtop = rlist[numval-1] ; /* smallest and largest values found */
if( rbot == rtop ) ERROR_exit("Only one value (%d) found in all inputs!",rbot) ;
/* if 0 isn't first in rlist, then
put it in first place and move negative values up by one spot */
if( rbot < 0 ){
for( kk=0 ; kk < numval && rlist[kk] != 0 ; kk++ ) ; /*nada*/
if( kk < numval ){ /* should always be true */
for( ii=kk-1 ; ii >= 0 ; ii-- ) rlist[ii+1] = rlist[ii] ;
rlist[0] = 0 ;
}
}
if( verb )
INFO_message("Value range = %d..%d (%d distinct values)",rbot,rtop,numval );
/* save overall histogram? */
if( ohist_name != NULL ){
FILE *fp = fopen(ohist_name,"w") ; int nl=0 ;
if( fp == NULL ) ERROR_exit("Can't open -hsave '%s' for output!",ohist_name) ;
if( ohzadd ) ohist[0+TWO15] = 0 ;
for( ii=0 ; ii < TWO16 ; ii++ ){
if( ohist[ii] != 0 ){ fprintf(fp,"%6d %u\n",ii-TWO15,ohist[ii]); nl++; }
}
fclose(fp) ;
if( verb ) INFO_message("Wrote %d lines to -hsave file %s",nl,ohist_name) ;
}
free(ohist) ; free(mhist) ; mhist = ohist = NULL ; /* done with this */
if( strcmp(prefix,"NULL") == 0 ) exit(0) ; /* special case */
/*----------- build the neighborhood mask -----------*/
if( ntype <= 0 ){ /* default neighborhood */
ntype = NTYPE_SPHERE ; na = 0.0f ;
if( verb ) INFO_message("Using default neighborhood = self") ;
}
switch( ntype ){
default:
ERROR_exit("WTF? ntype=%d",ntype) ; /* should not happen */
case NTYPE_SPHERE:{
float dx , dy , dz ;
if( na < 0.0f ){ dx = dy = dz = 1.0f ; na = -na ; }
else { dx = fabsf(DSET_DX(insar[0])) ;
dy = fabsf(DSET_DY(insar[0])) ;
dz = fabsf(DSET_DZ(insar[0])) ; }
nbhd = MCW_spheremask( dx,dy,dz , na ) ;
}
break ;
case NTYPE_RECT:{
float dx , dy , dz ;
if( na < 0.0f ){ dx = 1.0f; na = -na; } else dx = fabsf(DSET_DX(insar[0]));
if( nb < 0.0f ){ dy = 1.0f; nb = -nb; } else dy = fabsf(DSET_DY(insar[0]));
if( nc < 0.0f ){ dz = 1.0f; nc = -nc; } else dz = fabsf(DSET_DZ(insar[0]));
nbhd = MCW_rectmask( dx,dy,dz , na,nb,nc ) ;
}
break ;
case NTYPE_RHDD:{
float dx , dy , dz ;
if( na < 0.0f ){ dx = dy = dz = 1.0f ; na = -na ; }
else { dx = fabsf(DSET_DX(insar[0])) ;
dy = fabsf(DSET_DY(insar[0])) ;
dz = fabsf(DSET_DZ(insar[0])) ; }
nbhd = MCW_rhddmask( dx,dy,dz , na ) ;
}
break ;
case NTYPE_TOHD:{
float dx , dy , dz ;
if( na < 0.0f ){ dx = dy = dz = 1.0f ; na = -na ; }
else { dx = fabsf(DSET_DX(insar[0])) ;
dy = fabsf(DSET_DY(insar[0])) ;
dz = fabsf(DSET_DZ(insar[0])) ; }
nbhd = MCW_tohdmask( dx,dy,dz , na ) ;
}
break ;
}
if( verb ) INFO_message("Neighborhood comprises %d voxels",nbhd->num_pt) ;
/*------- actually do some work for a change (is it lunchtime yet?) -------*/
if( verb ) fprintf(stderr,"Voxel-wise histograms ") ;
outset = THD_localhistog( nsar,insar , numval,rlist , nbhd , do_prob,verb ) ;
if( outset == NULL ) ERROR_exit("Function THD_localhistog() fails?!") ;
/*---- save resulting dataset ----*/
EDIT_dset_items( outset , ADN_prefix,prefix , ADN_none ) ;
tross_Copy_History( insar[0] , outset ) ;
tross_Make_History( "3dLocalHistog" , argc,argv , outset ) ;
/* but first attach labels to sub-bricks */
EDIT_BRICK_LABEL(outset,0,"0:Other") ;
for( kk=1 ; kk < numval ; kk++ ){
sprintf(buf,"%d:",rlist[kk]) ;
for( ii=0 ; ii < nlab ; ii++ ){
if( labval[ii] == rlist[kk] && lablab[ii] != NULL ){
ids = strlen(buf) ;
MCW_strncpy(buf+ids,lablab[ii],THD_MAX_SBLABEL-ids) ;
break ;
}
}
EDIT_BRICK_LABEL(outset,kk,buf) ;
}
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) ;
}
MRI_vectim * THD_dset_to_vectim( THD_3dim_dataset *dset, byte *mask , int ignore )
{
byte *mmm=mask ;
MRI_vectim *mrv=NULL ;
int kk,iv , nvals , nvox , nmask ;
size_t ntot ;
ENTRY("THD_dset_to_vectim") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
if( ignore < 0 ) ignore = 0 ;
nvals = DSET_NVALS(dset) - ignore ; if( nvals <= 0 ) RETURN(NULL) ;
nvox = DSET_NVOX(dset) ;
if( mmm != NULL ){
nmask = THD_countmask( nvox , mmm ) ; /* number to keep */
if( nmask <= 0 ) RETURN(NULL) ;
} else {
nmask = nvox ; /* keep them all */
#pragma omp critical (MALLOC)
mmm = (byte *)malloc(sizeof(byte)*nmask) ;
if( mmm == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
RETURN(NULL) ;
}
memset( mmm , 1 , sizeof(byte)*nmask ) ;
}
#pragma omp critical (MALLOC)
mrv = (MRI_vectim *)malloc(sizeof(MRI_vectim)) ;
mrv->nvec = nmask ;
mrv->nvals = nvals ;
mrv->ignore = ignore ;
#pragma omp critical (MALLOC)
mrv->ivec = (int *)malloc(sizeof(int)*nmask) ;
if( mrv->ivec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
}
ntot = sizeof(float)*(size_t)nmask*(size_t)nvals ;
#pragma omp critical (MALLOC)
mrv->fvec = (float *)malloc(ntot) ;
if( mrv->fvec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory -- tried to get %lld bytes",(long long)ntot) ;
free(mrv->ivec) ; free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
} else if( ntot > 1000000000 ){
INFO_message("THD_dset_to_vectim: allocated %lld bytes",(long long)ntot) ;
}
/* store desired voxel time series */
STATUS("create index list") ;
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] ) mrv->ivec[kk++] = iv ; /* build index list */
}
if( ignore > 0 ){ /* extract 1 at a time, save what we want */
#pragma omp critical (MALLOC)
float *var = (float *)malloc(sizeof(float)*(nvals+ignore)) ;
STATUS("ignore > 0 --> extracting one at a time") ;
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] == 0 ) continue ;
(void)THD_extract_array( iv , dset , 0 , var ) ;
AAmemcpy( VECTIM_PTR(mrv,kk) , var+ignore , sizeof(float)*nvals ) ;
kk++ ;
}
free(var) ;
} else { /* do all at once: this way is a lot faster */
STATUS("ignore==0 --> extracting all at once") ;
THD_extract_many_arrays( nmask , mrv->ivec , dset , mrv->fvec ) ;
}
STATUS("setting parameters in vectim header") ;
mrv->nx = DSET_NX(dset) ; mrv->dx = fabs(DSET_DX(dset)) ;
mrv->ny = DSET_NY(dset) ; mrv->dy = fabs(DSET_DY(dset)) ;
mrv->nz = DSET_NZ(dset) ; mrv->dz = fabs(DSET_DZ(dset)) ;
DSET_UNMSEC(dset) ; mrv->dt = DSET_TR(dset) ;
if( mrv->dt <= 0.0f ) mrv->dt = 1.0f ;
if( mmm != mask ){
STATUS("free(mmm)") ;
free(mmm) ;
}
STATUS("VECTIM_scan()") ;
VECTIM_scan(mrv) ; /* 09 Nov 2010 */
RETURN(mrv) ;
}
int main(int argc, char **argv)
{
static char FuncName[]={"3dGenFeatureDist"};
SEG_OPTS *Opt=NULL;
char *atr=NULL, sbuf[512], *methods=NULL;
int cc, /* class counter */
kk, /* key counter */
aa, /* feature counter */
nn, /* sub-brick index */
vv, /* voxel index */
ss, /* subjects counter */
iii, /* dummy counter */
nbins, /* number of bins */
*ifeat=NULL, key,
**N_alloc_FCset=NULL, /* Number of values allocated for each
vector in FCset */
**N_FCset=NULL, /* Number of filled values for each vector in FCset */
N_ffalloc=0, N_ff, isneg=0,
missfeatwarn=-1 /* Missing feature warning for some subject */;
float fsf=0.0, fsb=0.0,
***FCset=NULL, /* Table holding samples for each feature/class combo */
hrange[2]={-3.0, 3.0}, bwidth1=0.05, bwidth=0.0,
*ff=NULL;
short *sf=NULL, *sb=NULL;
byte **masks=NULL;
SUMA_HIST ***hh=NULL, **hf=NULL;
double ff_m, ff_s;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
Opt = GenFeatureDist_Default(argv, argc);
Opt = GenFeatureDist_ParseInput (Opt, argv, argc);
Opt->hist = tross_commandline( FuncName , argc , argv ) ;
if (!GenFeatureDist_CheckOpts(Opt)) {
ERROR_exit("Failed on option check");
}
/* labeltable? */
if (Opt->labeltable_name) {
Dtable *vl_dtable=NULL;
char *labeltable_str=NULL;
/* read the table */
if (!(labeltable_str = AFNI_suck_file( Opt->labeltable_name))) {
ERROR_exit("Failed to read %s", Opt->labeltable_name);
}
if (!(vl_dtable = Dtable_from_nimlstring(labeltable_str))) {
ERROR_exit("Could not parse labeltable");
}
/* make sure all classes are in the labeltable */
for (cc=0; cc<Opt->clss->num; ++cc) {
if ((key = SUMA_KeyofLabel_Dtable(vl_dtable, Opt->clss->str[cc]))<0){
ERROR_exit("Key not found in %s for %s ",
Opt->labeltable_name, Opt->clss->str[cc]);
}
if (Opt->keys) {
if (Opt->keys[cc]!=key) {
ERROR_exit("Key mismatch %d %d", Opt->keys[cc], key);
}
}
}
if (!Opt->keys) { /* get them from table */
Opt->keys = (int *)calloc(Opt->clss->num, sizeof(int));
for (cc=0; cc<Opt->clss->num; ++cc) {
if ((key = SUMA_KeyofLabel_Dtable(vl_dtable, Opt->clss->str[cc]))<0){
ERROR_exit("(should noy happen) Key not found in %s for %s ",
Opt->labeltable_name, Opt->clss->str[cc]);
}
Opt->keys[cc] = key;
}
}
destroy_Dtable(vl_dtable); vl_dtable=NULL;
}
if (!Opt->keys) {
/* add default keys */
SUMA_S_Note("Keys not available, assuming defaults");
Opt->keys = (int *)calloc(Opt->clss->num, sizeof(int));
for (cc=0; cc<Opt->clss->num; ++cc) {
Opt->keys[cc] = cc+1;
}
}
/* Show the match between keys and classes */
SUMA_ShowClssKeys(Opt->clss->str, Opt->clss->num, Opt->keys);
/* For each feature, each class, collect the values */
SUMA_S_Notev("Collecting data from %d subjects\n", Opt->sig_names->num);
missfeatwarn = -1;
for (ss=0; ss<Opt->sig_names->num; ++ss) { /* for each subject */
/* load the input data */
if (!(Opt->sig = Seg_load_dset( Opt->sig_names->str[ss] ))) {
exit(1);
}
if (Opt->debug > 1) {
SUMA_S_Notev("Have %d sub-bricks in signatures of dude %d\n",
DSET_NVALS(Opt->sig), ss);
}
if (ss == 0) { /* some setup based on initial grid */
if (!Opt->feats) { /* create features from signature */
char *allfeats=NULL;
for (nn=0; nn<DSET_NVALS(Opt->sig); ++nn) {
allfeats =
SUMA_append_replace_string(allfeats,
DSET_BRICK_LABEL(Opt->sig,nn),";", 1);
}
Opt->feats = NI_strict_decode_string_list(allfeats,";, ");
SUMA_free(allfeats); allfeats=NULL;
}
SUMA_S_Notev("Have to work with %d classes, %d features\n",
Opt->clss->num, Opt->feats->num);
SUMA_S_Note("Initializing storage");
/* Receptacles for all observations for each feature
and class combination */
FCset = (float ***)SUMA_calloc(Opt->feats->num, sizeof(float **));
N_FCset = (int **)SUMA_calloc(Opt->feats->num, sizeof(int *));
N_alloc_FCset = (int **)SUMA_calloc(Opt->feats->num, sizeof(int *));
ifeat = (int *)SUMA_calloc(Opt->feats->num, sizeof(int));
for (aa=0; aa<Opt->feats->num; ++aa) {
FCset[aa] = (float **)calloc(Opt->clss->num, sizeof(float *));
N_FCset[aa] = (int *)SUMA_calloc(Opt->clss->num, sizeof(int));
N_alloc_FCset[aa] = (int *)SUMA_calloc(Opt->clss->num, sizeof(int));
}
masks = (byte **)SUMA_calloc(Opt->sig_names->num, sizeof (byte *));
/* Fix VoxDbg */
if (Opt->VoxDbg >= 0) {
Vox1D2Vox3D(Opt->VoxDbg,
DSET_NX(Opt->sig), DSET_NX(Opt->sig)*DSET_NY(Opt->sig),
Opt->VoxDbg3);
} else if (Opt->VoxDbg3[0]>=0) {
Opt->VoxDbg = Opt->VoxDbg3[0] +
Opt->VoxDbg3[1]*DSET_NX(Opt->sig) +
Opt->VoxDbg3[2]*DSET_NX(Opt->sig)*DSET_NY(Opt->sig);
}
}
/* allocate for mask which will be non-zero whenever a voxel is in at least 1 mask. It will have the 1st assignment */
masks[ss] = (byte *)SUMA_calloc(DSET_NVOX(Opt->sig), sizeof(byte));
/* create mapping between feature names and sub-briks */
for (aa=0; aa<Opt->feats->num; ++aa) {
ifeat[aa] = 0;
while (ifeat[aa] < DSET_NVALS(Opt->sig) &&
strcmp(DSET_BRICK_LABEL(Opt->sig,ifeat[aa]),
Opt->feats->str[aa])) ++ifeat[aa];
if (ifeat[aa] >= DSET_NVALS(Opt->sig)) ifeat[aa]=-1;
if (Opt->debug > 1) {
SUMA_S_Notev("Have feature %s in sub-brick %d\n",
Opt->feats->str[aa], ifeat[aa]);
}
}
SUMA_S_Notev("Loading sample classes for subject #%d\n", ss);
if (!(Opt->samp = Seg_load_dset( Opt->samp_names->str[ss] ))) {
exit(1);
}
if (THD_dataset_mismatch(Opt->samp, Opt->sig)) {
SUMA_S_Err(
"Grid mismatch between -samp [%dx%dx%d] and \n"
" -sig [%dx%dx%d] volumes for pair #%d\n",
DSET_NX(Opt->samp), DSET_NY(Opt->samp), DSET_NZ(Opt->samp),
DSET_NX(Opt->sig), DSET_NY(Opt->sig), DSET_NZ(Opt->sig), ss);
exit(1);
}
if (Opt->debug > 1) {
SUMA_S_Notev("Have %d sub-bricks in samples of dude %d\n",
DSET_NVALS(Opt->samp), ss);
}
/* Now collect features for each class */
SUMA_S_Note("Collecting features for each class");
for (cc=0; cc<Opt->clss->num; ++cc) {
if (Opt->debug > 1) {
SUMA_S_Notev("Working class %s\n", Opt->clss->str[cc]);
}
key = Opt->keys[cc];
for (nn=0; nn<DSET_NVALS(Opt->samp); ++nn) {
if (Opt->debug > 2) {
SUMA_S_Notev("Looking for key %d for class %s in sb %d\n",
key, Opt->clss->str[cc], nn);
}
sb = (short *)DSET_ARRAY(Opt->samp,nn);
fsb = DSET_BRICK_FACTOR(Opt->samp,nn);
if (fsb == 0.0) fsb = 1.0;
if (fsb != 1.0) {
SUMA_S_Err("Non-integral dset, possibly.");
exit(1);
}
for (vv=0; vv<DSET_NVOX(Opt->samp); ++vv) {
if (sb[vv] == key) {
for (aa=0; aa<Opt->feats->num; ++aa) {
if (ifeat[aa]>-1) {
if (N_alloc_FCset[aa][cc] <= N_FCset[aa][cc]) {
N_alloc_FCset[aa][cc] += 10000;
FCset[aa][cc] =
(float*)SUMA_realloc(FCset[aa][cc],
N_alloc_FCset[aa][cc]*sizeof(float));
}
sf = (short *)DSET_ARRAY(Opt->sig, ifeat[aa]);
fsf = DSET_BRICK_FACTOR(Opt->sig,ifeat[aa]);
if (fsf == 0.0) fsf = 1.0;
FCset[aa][cc][N_FCset[aa][cc]] = sf[vv]*fsf;
++N_FCset[aa][cc];
if (!masks[ss][vv]) {
masks[ss][vv] = (short)key; /* fcfs */
/* in case we exceed short range */
if (masks[ss][vv]) masks[ss][vv] = 1;
}
} else {
if (missfeatwarn != ss) {
SUMA_S_Warnv("Feature %s not found in subject %d\n",
Opt->feats->str[aa], ss);
missfeatwarn = ss;
}
}
}
}
}
}
}
DSET_delete(Opt->sig); Opt->sig=NULL;
DSET_delete(Opt->samp); Opt->samp=NULL;
} /* loop across all subjects */
/* compute histograms of features across all classes and save them */
hf = (SUMA_HIST **)SUMA_calloc(Opt->feats->num, sizeof(SUMA_HIST *));
SUMA_S_Note("Computing histograms of features across all classes");
ff = NULL; N_ffalloc = 0;
for (aa=0; aa<Opt->feats->num; ++aa) {
N_ff=0;
for (cc=0; cc<Opt->clss->num; ++cc) {
N_ff += N_FCset[aa][cc]; /* more than I need because same voxel
can belong to multiple classes, but just
to be safe */
}
if (N_ffalloc < N_ff) {
N_ffalloc = N_ff;
if (ff) SUMA_free(ff); ff=NULL;
if (!(ff = (float*)SUMA_calloc(N_ff, sizeof(float)))) {
SUMA_S_Crit("Failed to allocate");
exit(1);
}
}
N_ff=0; isneg = 0; ff_m=0.0;
for (ss=0; ss<Opt->sig_names->num; ++ss) { /* Once again, unfortunately */
/* load the input data */
if (!(Opt->sig = Seg_load_dset( Opt->sig_names->str[ss] ))) {
exit(1);
}
if (Opt->debug > 1) {
SUMA_S_Notev("Have %d sub-bricks in signatures of dude %d\n",
DSET_NVALS(Opt->sig), ss);
}
if (ifeat[aa]>-1) {
sb = (short *)DSET_ARRAY(Opt->sig,ifeat[aa]);
fsb = DSET_BRICK_FACTOR(Opt->sig,ifeat[aa]);
if (fsb == 0.0) fsb = 1.0;
for (vv=0; vv<DSET_NVOX(Opt->sig); ++vv) {
if (masks[ss][vv]) {
ff[N_ff] = sb[vv]*fsb;
if (ff[N_ff] < 0) ++isneg;
ff_m += ff[N_ff];
++N_ff;
}
}
}
DSET_delete(Opt->sig); Opt->sig=NULL;
}
ff_m /= N_ff; ff_s=0.0;
for (iii=0; iii<N_ff; ++iii) {
ff_s += SUMA_POW2(ff[iii]-ff_m);
}
ff_s = sqrt(ff_s/N_ff);
sprintf(sbuf, "h(%s)",Opt->feats->str[aa]);
/* Check if you have user specified binning specs */
bwidth = -1; nbins = -1;
for (iii=0; iii<Opt->N_hspec; ++iii) {
if (!strcmp(Opt->feats->str[aa], Opt->hspec[iii]->label)) {
hrange[0] = Opt->hspec[iii]->min;
hrange[1] = Opt->hspec[iii]->max;
nbins = Opt->hspec[iii]->K;
bwidth = 0;
methods = "hands off sir";
break;
}
}
if (bwidth < 0) {
int nmatch = -1;
/* Check the wildcard option */
for (iii=0; iii<Opt->N_hspec; ++iii) {
if ((nmatch = SUMA_is_wild_hspec_label(Opt->hspec[iii]->label))>=0) {
if (!nmatch || !strncmp(Opt->feats->str[aa],
Opt->hspec[iii]->label, nmatch)) {
SUMA_S_Note("Feature %s matched with hspec %s\n",
Opt->feats->str[aa], Opt->hspec[iii]->label);
hrange[0] = Opt->hspec[iii]->min;
hrange[1] = Opt->hspec[iii]->max;
nbins = Opt->hspec[iii]->K;
bwidth = 0;
methods = "hands woff sir";
break;
}
}
}
}
if (bwidth < 0) { /* no user specs found */
nbins = 0;
methods = "Range|OsciBinWidth";
if ((float)isneg/(float)N_ff*100.0 > 1.0) {
hrange[0] = ff_m-3*ff_s;
hrange[1] = ff_m+3*ff_s;
bwidth = bwidth1*ff_s;
} else if (ff_m-3*ff_s > 0) {
hrange[0] = ff_m-3*ff_s;
hrange[1] = ff_m+3*ff_s;
bwidth = bwidth1*ff_s;
} else {
hrange[0] = 0;
hrange[1] = 6.0*ff_s/2.0;
bwidth = bwidth1*ff_s/2.0;
}
}
SUMA_S_Notev("Feature %s: mean %f, std %f\n"
"Hist params: [%f %f], binwidth %f\n",
Opt->feats->str[aa], ff_m, ff_s,
hrange[0], hrange[1], bwidth);
if (!(hf[aa] = SUMA_hist_opt(ff, N_ff, nbins, bwidth, hrange, sbuf, 1,
0.1, methods))) {
SUMA_S_Errv("Failed to generate histogram for %s. \n"
"This will cause trouble at classification.\n",
Opt->feats->str[aa]);
} else {
if ((float)hf[aa]->N_ignored/(float)hf[aa]->n > 0.05) {
SUMA_S_Warnv("For histogram %s, %.2f%% of the samples were\n"
"ignored for being outside the range [%f %f]\n",
Opt->feats->str[aa],
100*(float)hf[aa]->N_ignored/(float)hf[aa]->n,
hf[aa]->min, hf[aa]->max);
}
if (Opt->debug > 1) SUMA_Show_hist(hf[aa], 1, NULL);
/* save the histogram */
if (!SUMA_write_hist(hf[aa],
SUMA_hist_fname(Opt->proot,
Opt->feats->str[aa], NULL, 0))) {
SUMA_S_Errv("Failed to write histog to %s\n", sbuf);
}
}
}
if (ff) SUMA_free(ff); ff = NULL;
/* Compute histograms of features per class && save them*/
hh = (SUMA_HIST ***)SUMA_calloc(Opt->feats->num, sizeof(SUMA_HIST **));
for (aa=0; aa<Opt->feats->num; ++aa) {
hh[aa] = (SUMA_HIST **)SUMA_calloc(Opt->clss->num, sizeof(SUMA_HIST *));
}
SUMA_S_Note("Computing histograms of features per class");
for (cc=0; cc<Opt->clss->num; ++cc) {
if (N_FCset[0][cc] < 10) {
SUMA_S_Errv("Requested class %s (%d) has just %d samples.\n"
"Not enough to grease your pan.\n",
Opt->clss->str[cc], Opt->keys[cc], N_FCset[0][cc]);
exit(1);
}
for (aa=0; aa<Opt->feats->num; ++aa) {
sprintf(sbuf, "h(%s|%s)",Opt->feats->str[aa], Opt->clss->str[cc]);
hrange[0] = hf[aa]->min; hrange[1] = hf[aa]->max;
/* Do not optimize hist range and binwidth anymore,
but allow smoothing. This is needed when a particular
class has very few samples */
if (!(hh[aa][cc] = SUMA_hist_opt(FCset[aa][cc], N_FCset[aa][cc],
hf[aa]->K, hf[aa]->W,
hrange, sbuf, 1,
0.1, "OsciSmooth"))) {
SUMA_S_Errv("Failed to generate histogram for %s|%s. \n"
"This will cause trouble at classification.\n",
Opt->feats->str[aa], Opt->clss->str[cc])
} else {
if (Opt->debug > 1) SUMA_Show_hist(hh[aa][cc], 1, NULL);
/* save the histogram */
if (!SUMA_write_hist(hh[aa][cc],
SUMA_hist_fname(Opt->proot,
Opt->feats->str[aa], Opt->clss->str[cc], 0))) {
SUMA_S_Errv("Failed to write histog to %s\n", sbuf);
}
}
}
}
SUMA_S_Note("Computing Correlation matrices");
/* L2 normalize all of FCset */
for (cc=0; cc<Opt->clss->num; ++cc) {
for (aa=0; aa<Opt->feats->num; ++aa) {
THD_normalize(N_FCset[aa][cc], FCset[aa][cc]);
}
}
{
NI_element **CC=NULL;
float *fm=NULL, *fn=NULL;
NI_element *nel = NULL;
int suc;
/* Compute the correlation matrices for each class */
CC = (NI_element **) SUMA_calloc(Opt->clss->num, sizeof(NI_element *));
for(cc=0; cc<Opt->clss->num; ++cc) {
sprintf(sbuf, "CorrMat(%s)", Opt->clss->str[cc]);
CC[cc] = NI_new_data_element(sbuf, Opt->feats->num);
NI_set_attribute(CC[cc],"Measure","correlation");
atr = SUMA_NI_str_ar_2_comp_str(Opt->feats, " ; ");
NI_set_attribute(CC[cc],"ColumnLabels", atr);SUMA_free(atr); atr = NULL;
atr = SUMA_HistString (FuncName, argc, argv, NULL);
NI_set_attribute(CC[cc],"CommandLine", atr);SUMA_free(atr); atr = NULL;
for (aa=0; aa<Opt->feats->num; ++aa) {
NI_add_column_stride ( CC[cc], NI_FLOAT, NULL, 1 );
}
for (aa=0; aa<Opt->feats->num; ++aa) {
fm = (float*)CC[cc]->vec[aa];
for (iii=0; iii<aa; ++iii) fm[iii] = 0.0; /* will fill later */
fm[aa]=1.0;
for (iii=aa+1; iii<Opt->feats->num; ++iii) {
if (N_FCset[aa][cc]!=N_FCset[iii][cc]) {
SUMA_S_Errv("Sanity check failed, %d != %d\n",
N_FCset[aa][cc], N_FCset[iii][cc]);
}
SUMA_DOTP_VEC(FCset[aa][cc], FCset[iii][cc],
fm[iii], N_FCset[aa][cc],
float, float);
}
}
/* Now fill the remainder */
for (aa=0; aa<Opt->feats->num; ++aa) {
fm = (float*)CC[cc]->vec[aa];
for (iii=0; iii<aa; ++iii) {
fn = (float*)CC[cc]->vec[iii];
fm[iii] = fn[aa];
}
}
snprintf(sbuf, 510, "file:%s.niml.cormat",
SUMA_corrmat_fname(Opt->proot, Opt->clss->str[cc], 0));
NEL_WRITE_TXH(CC[cc], sbuf, suc);
}
}
/* free everything */
if (FCset) {
for (aa=0; aa<Opt->feats->num; ++aa) {
for (cc=0; cc<Opt->clss->num; ++cc) {
if (FCset[aa][cc]) SUMA_free(FCset[aa][cc]);
}
SUMA_free(FCset[aa]);
}
SUMA_free(FCset); FCset=NULL;
}
if (N_FCset) {
for (aa=0; aa<Opt->feats->num; ++aa) {
SUMA_free(N_FCset[aa]);
}
SUMA_free(N_FCset); N_FCset=NULL;
}
if (N_alloc_FCset) {
for (aa=0; aa<Opt->feats->num; ++aa) {
SUMA_free(N_alloc_FCset[aa]);
}
SUMA_free(N_alloc_FCset); N_alloc_FCset=NULL;
}
if (ifeat) SUMA_free(ifeat); ifeat=NULL;
if (hh) {
for (aa=0; aa<Opt->feats->num; ++aa) {
for (cc=0; cc<Opt->clss->num; ++cc) {
if (hh[aa][cc]) hh[aa][cc] = SUMA_Free_hist(hh[aa][cc]);
}
SUMA_free(hh[aa]);
}
SUMA_free(hh); hh=NULL;
}
if (hf) {
for (aa=0; aa<Opt->feats->num; ++aa) {
if (hf[aa]) hf[aa] = SUMA_Free_hist(hf[aa]);
}
SUMA_free(hf); hf=NULL;
}
if (masks) {
for (ss=0; ss<Opt->sig_names->num; ++ss) {
if (masks[ss]) SUMA_free(masks[ss]);
}
masks[ss]=NULL;
}
SUMA_S_Notev("\n"
"Consider running this script to examine the distributions:\n"
" @ExamineGenFeatDists -fdir %s -odir %s\n",
Opt->proot, Opt->proot);
/* all done, free */
Opt = free_SegOpts(Opt);
PRINT_COMPILE_DATE ; exit(0);
}
MRI_vectim * THD_2dset_to_vectim( THD_3dim_dataset *dset1, byte *mask1 ,
THD_3dim_dataset *dset2, byte *mask2 ,
int ignore )
{
byte *mmmv[2]={NULL, NULL}, *mmmt=NULL;
THD_3dim_dataset *dsetv[2]={NULL, NULL};
MRI_vectim *mrv=NULL ;
int kk2, kk,iv,id, nvals , nvoxv[2]={0,0} , nmaskv[2]={0,0} ;
int *ivvectmp=NULL;
ENTRY("THD_2dset_to_vectim") ;
mmmv[0] = mask1;
mmmv[1] = mask2;
dsetv[0] = dset1;
dsetv[1] = dset2;
for (id=0; id<2;++id) {
if( !ISVALID_DSET(dsetv[id]) ) RETURN(NULL) ;
DSET_load(dsetv[id]) ; if( !DSET_LOADED(dsetv[id]) ) RETURN(NULL) ;
nvoxv[id] = DSET_NVOX(dsetv[id]) ;
}
if (DSET_NVALS(dsetv[0]) != DSET_NVALS(dsetv[1])) {
RETURN(NULL) ;
}
if( ignore < 0 ) ignore = 0 ;
nvals = DSET_NVALS(dsetv[0]) - ignore ; if( nvals <= 0 ) RETURN(NULL) ;
for (id=0; id<2; ++id) {
if( mmmv[id] != NULL ){
nmaskv[id] = THD_countmask( nvoxv[id] , mmmv[id] ) ;/* number to keep */
if( nmaskv[id] <= 0 ) RETURN(NULL) ;
} else {
nmaskv[id] = nvoxv[id] ; /* keep them all */
#pragma omp critical (MALLOC)
mmmv[id] = (byte *)malloc(sizeof(byte)*nmaskv[id]) ;
if( mmmv[id] == NULL ){
ERROR_message("THD_2dset_to_vectim: out of memory") ;
RETURN(NULL) ;
}
memset( mmmv[id] , 1 , sizeof(byte)*nmaskv[id] ) ;
}
}
#pragma omp critical (MALLOC)
mrv = (MRI_vectim *)malloc(sizeof(MRI_vectim)) ;
mrv->nvec = nmaskv[0]+nmaskv[1] ;
mrv->nvals = nvals ;
mrv->ignore = ignore ;
#pragma omp critical (MALLOC)
mrv->ivec = (int *)malloc(sizeof(int)*(nmaskv[0]+nmaskv[1])) ;
#pragma omp critical (MALLOC)
ivvectmp = (int *)malloc(sizeof(int)*(nmaskv[1])) ;
if( mrv->ivec == NULL || ivvectmp == NULL){
ERROR_message("THD_2dset_to_vectim: out of memory") ;
if (mrv->ivec) free(mrv->ivec) ;
if (ivvectmp) free(ivvectmp) ;
free(mrv) ;
if( mmmv[0] != mask1 ) free(mmmv[0]) ;
if( mmmv[1] != mask2 ) free(mmmv[1]) ;
RETURN(NULL) ;
}
#pragma omp critical (MALLOC)
mrv->fvec = (float *)malloc(sizeof(float)*(nmaskv[0]+nmaskv[1])*(size_t)nvals) ;
if( mrv->fvec == NULL ){
ERROR_message("THD_2dset_to_vectim: out of memory") ;
if (ivvectmp) free(ivvectmp) ;
free(mrv->ivec) ; free(mrv) ;
if( mmmv[0] != mask1 ) free(mmmv[0]) ;
if( mmmv[1] != mask2 ) free(mmmv[1]) ;
RETURN(NULL) ;
}
/* store desired voxel time series */
mmmt = mmmv[0];
for( kk=iv=0 ; iv < nvoxv[0] ; iv++ ){
if( mmmt[iv] ) mrv->ivec[kk++] = iv ; /* build index list to 1st dset */
}
mmmt = mmmv[1]; kk2 = 0;
for( iv=0 ; iv < nvoxv[1] ; iv++ ){
if( mmmt[iv] ) {
mrv->ivec[kk++] = iv + nvoxv[0] ;
/* build index list to 2nd dset*/
ivvectmp[kk2++] = iv;
}
}
if( ignore > 0 ){ /* extract 1 at a time, save what we want */
#pragma omp critical (MALLOC)
float *var = (float *)malloc(sizeof(float)*(nvals+ignore)) ;
mmmt = mmmv[0];
for( kk=iv=0 ; iv < nvoxv[0] ; iv++ ){
if( mmmt[iv] == 0 ) continue ;
(void)THD_extract_array( iv , dsetv[0] , 0 , var ) ;
AAmemcpy( VECTIM_PTR(mrv,kk) , var+ignore , sizeof(float)*nvals ) ;
kk++ ;
}
mmmt = mmmv[1];
for( iv=0 ; iv < nvoxv[1] ; iv++ ){
if( mmmt[iv] == 0 ) continue ;
(void)THD_extract_array( iv , dsetv[1] , 0 , var ) ;
AAmemcpy( VECTIM_PTR(mrv,kk) , var+ignore , sizeof(float)*nvals ) ;
kk++ ;
}
free(var) ;
} else { /* do all at once: this way is a lot faster */
THD_extract_many_arrays( nmaskv[0] , mrv->ivec ,
dsetv[0] , mrv->fvec ) ;
THD_extract_many_arrays( nmaskv[1] , ivvectmp,
dsetv[1] , (mrv->fvec+(size_t)nmaskv[0]*(size_t)mrv->nvals) ) ;
}
mrv->nx = DSET_NX(dsetv[0]) + DSET_NX(dsetv[1]);
mrv->dx = fabs(DSET_DX(dsetv[0])) ;
mrv->ny = DSET_NY(dsetv[0]) ; mrv->dy = fabs(DSET_DY(dsetv[0])) ;
mrv->nz = DSET_NZ(dsetv[0]) ; mrv->dz = fabs(DSET_DZ(dsetv[0])) ;
DSET_UNMSEC(dsetv[0]) ; mrv->dt = DSET_TR(dsetv[0]) ;
if( mrv->dt <= 0.0f ) mrv->dt = 1.0f ;
if( mmmv[0] != mask1 ) free(mmmv[0]) ;
if( mmmv[1] != mask2 ) free(mmmv[1]) ;
if (ivvectmp) free(ivvectmp) ;
if (0) {
int ShowThisTs=38001;
float *fff=NULL;
fprintf(stderr,"++ ZSS mrv->nvec = %d, mrv->nvals = %d\n",
mrv->nvec, mrv->nvals);
for( kk=0 ; kk < mrv->nvals; ++kk) {
fff=mrv->fvec+((size_t)mrv->nvals*(size_t)ShowThisTs);
fprintf(stderr," %f \t", *(fff+kk));
}
}
VECTIM_scan(mrv) ; /* 09 Nov 2010 */
RETURN(mrv) ;
}
MRI_vectim * THD_dset_to_vectim_stend( THD_3dim_dataset *dset, byte *mask , int start, int end )
{
byte *mmm=mask ;
MRI_vectim *mrv=NULL ;
int kk,iv , nvals , nvox , nmask ;
ENTRY("THD_dset_to_vectim_stend") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
if( start < 0 ) start = 0 ;
if( end < start ) end = DSET_NVALS(dset)-1 ;
nvals = end - start + 1 ; if( nvals <= 0 ) RETURN(NULL) ;
nvox = DSET_NVOX(dset) ;
if( mmm != NULL ){
nmask = THD_countmask( nvox , mmm ) ; /* number to keep */
if( nmask <= 0 ) RETURN(NULL) ;
} else {
nmask = nvox ; /* keep them all */
#pragma omp critical (MALLOC)
mmm = (byte *)malloc(sizeof(byte)*nmask) ;
if( mmm == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
RETURN(NULL) ;
}
memset( mmm , 1 , sizeof(byte)*nmask ) ;
}
#pragma omp critical (MALLOC)
mrv = (MRI_vectim *)malloc(sizeof(MRI_vectim)) ;
mrv->nvec = nmask ;
mrv->nvals = nvals ;
mrv->ignore = start ;
#pragma omp critical (MALLOC)
mrv->ivec = (int *)malloc(sizeof(int)*nmask) ;
if( mrv->ivec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
}
#pragma omp critical (MALLOC)
mrv->fvec = (float *)malloc(sizeof(float)*(size_t)nmask*(size_t)nvals) ;
if( mrv->fvec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
free(mrv->ivec) ; free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
}
/* store desired voxel time series */
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] ) mrv->ivec[kk++] = iv ; /* build index list */
}
if( nvals < DSET_NVALS(dset) ){ /* extract 1 at a time, save what we want */
#pragma omp critical (MALLOC)
float *var = (float *)malloc(sizeof(float)*(DSET_NVALS(dset))) ;
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] == 0 ) continue ;
(void)THD_extract_array( iv , dset , 0 , var ) ;
AAmemcpy( VECTIM_PTR(mrv,kk) , var+start , sizeof(float)*nvals ) ;
kk++ ;
}
free(var) ;
} else { /* do all at once: this way is a lot faster */
THD_extract_many_arrays( nmask , mrv->ivec , dset , mrv->fvec ) ;
}
mrv->nx = DSET_NX(dset) ; mrv->dx = fabs(DSET_DX(dset)) ;
mrv->ny = DSET_NY(dset) ; mrv->dy = fabs(DSET_DY(dset)) ;
mrv->nz = DSET_NZ(dset) ; mrv->dz = fabs(DSET_DZ(dset)) ;
DSET_UNMSEC(dset) ; mrv->dt = DSET_TR(dset) ;
if( mrv->dt <= 0.0f ) mrv->dt = 1.0f ;
if( mmm != mask ) free(mmm) ;
VECTIM_scan(mrv) ; /* 09 Nov 2010 */
RETURN(mrv) ;
}
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;
}
void initialize_program (int argc, char * argv[])
{
int iv; /* index number of sub-brick */
void * vfim = NULL; /* sub-brick data pointer */
float * ffim = NULL; /* sub-brick data in floating point format */
int ixyz; /* voxel index */
int nx, ny, nz, nxyz; /* numbers of voxels in input dataset */
int mx=0, my=0, mz=0, mxyz; /* numbers of voxels in mask dataset */
int nthr=0; /* number of voxels above mask threshold */
char message[80]; /* error message */
int ibin; /* p-value bin index */
/*-- 20 Apr 2001: addto the arglist, if user wants to [RWCox] --*/
machdep() ;
{ int new_argc ; char ** new_argv ;
addto_args( argc , argv , &new_argc , &new_argv ) ;
if( new_argv != NULL ){ argc = new_argc ; argv = new_argv ; }
}
/*----- Save command line for history notes -----*/
commandline = tross_commandline( PROGRAM_NAME , argc,argv ) ;
/*----- Does user request help menu? -----*/
if( argc < 2 || strcmp(argv[1],"-help") == 0 ) FDR_Syntax() ;
/*----- Add to program log -----*/
AFNI_logger (PROGRAM_NAME,argc,argv);
/*----- Read input options -----*/
read_options( argc , argv ) ;
/*----- Open the mask dataset -----*/
if (FDR_mask_filename != NULL)
{
if (!FDR_quiet)
printf ("Reading mask dataset: %s \n", FDR_mask_filename);
DOPEN (FDR_dset, FDR_mask_filename);
if (FDR_dset == NULL)
{
sprintf (message, "Cannot open mask dataset %s", FDR_mask_filename);
FDR_error (message);
}
if (DSET_NVALS(FDR_dset) != 1)
WARNING_message("Mask dataset: using sub-brick #0") ;
/*----- Get dimensions of mask dataset -----*/
mx = DSET_NX(FDR_dset);
my = DSET_NY(FDR_dset);
mz = DSET_NZ(FDR_dset);
mxyz = mx*my*mz;
/*----- Allocate memory for float data -----*/
ffim = (float *) malloc (sizeof(float) * mxyz); MTEST (ffim);
/*----- Convert mask dataset sub-brick to floats (in ffim) -----*/
iv = 0 ;
SUB_POINTER (FDR_dset, iv, 0, vfim);
EDIT_coerce_scale_type (mxyz, DSET_BRICK_FACTOR(FDR_dset,iv),
DSET_BRICK_TYPE(FDR_dset,iv), vfim, /* input */
MRI_float , ffim); /* output */
/*----- Allocate memory for mask volume -----*/
FDR_mask = (byte *) malloc (sizeof(byte) * mxyz);
MTEST (FDR_mask);
/*----- Create mask of voxels above mask threshold -----*/
nthr = 0;
for (ixyz = 0; ixyz < mxyz; ixyz++){
if (fabs(ffim[ixyz]) >= FDR_mask_thr){ FDR_mask[ixyz] = 1; nthr++; }
else FDR_mask[ixyz] = 0;
}
if (!FDR_quiet)
printf ("Number of voxels above mask threshold = %d \n", nthr);
if (nthr < 1)
FDR_error ("No voxels above mask threshold. Cannot continue.");
/*----- Delete floating point sub-brick -----*/
if (ffim != NULL) { free (ffim); ffim = NULL; }
/*----- Delete mask dataset -----*/
THD_delete_3dim_dataset (FDR_dset, False); FDR_dset = NULL ;
}
/*----- Get the input data -----*/
if (FDR_input1D_filename != NULL)
{
/*----- Read the input .1D file -----*/
if (!FDR_quiet) printf ("Reading input data: %s \n",
FDR_input1D_filename);
FDR_input1D_data = read_time_series (FDR_input1D_filename, &nxyz);
if (FDR_input1D_data == NULL)
{
sprintf (message, "Unable to read input .1D data file: %s",
FDR_input1D_filename);
FDR_error (message);
}
if (nxyz < 1)
{
sprintf (message, "No p-values in input .1D data file: %s",
FDR_input1D_filename);
FDR_error (message);
}
FDR_nxyz = nxyz;
FDR_nthr = nxyz;
}
else
{
/*----- Open the input 3D dataset -----*/
if (!FDR_quiet) printf ("Reading input dataset: %s \n",
FDR_input_filename);
FDR_dset = THD_open_dataset(FDR_input_filename);
CHECK_OPEN_ERROR(FDR_dset,FDR_input_filename);
/*----- Get dimensions of input dataset -----*/
nx = DSET_NX(FDR_dset);
ny = DSET_NY(FDR_dset);
nz = DSET_NZ(FDR_dset);
nxyz = nx*ny*nz;
/*----- Check for compatible dimensions -----*/
if (FDR_mask != NULL)
{
if ((nx != mx) || (ny != my) || (nz != mz))
FDR_error ("Mask and input dataset have incompatible dimensions");
FDR_nxyz = nxyz;
FDR_nthr = nthr;
}
else
{
FDR_nxyz = nxyz;
FDR_nthr = nxyz;
}
/*----- Check whether output dataset already exists -----*/
if( THD_deathcon() ) check_one_output_file (FDR_dset, FDR_output_prefix);
}
/*----- Initialize constant c(N) -----*/
if (FDR_cn < 0.0)
{
double cn;
cn = 0.0;
for (ixyz = 1; ixyz <= FDR_nthr; ixyz++)
cn += 1.0 / ixyz;
FDR_cn = cn;
if (!FDR_quiet)
printf ("c(N) = %f \n", FDR_cn);
}
/*----- Initialize voxel pointers -----*/
for (ibin = 0; ibin < FDR_MAX_LL; ibin++)
FDR_head_voxel[ibin] = NULL;
return ;
}
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[] )
{
float mrad=0.0f , fwhm=0.0f ;
int nrep=1 ;
char *prefix = "Polyfit" ;
char *resid = NULL ;
char *cfnam = NULL ;
int iarg , verb=0 , do_automask=0 , nord=3 , meth=2 , do_mclip=0 ;
THD_3dim_dataset *inset ;
MRI_IMAGE *imout , *imin ;
byte *mask=NULL ; int nvmask=0 , nmask=0 , do_mone=0 , do_byslice=0 ;
MRI_IMARR *exar=NULL ;
floatvec *fvit=NULL ; /* 26 Feb 2019 */
if( argc < 2 || strcasecmp(argv[1],"-help") == 0 ){
printf("\n"
"Usage: 3dPolyfit [options] dataset ~1~\n"
"\n"
"* Fits a polynomial in space to the input dataset and outputs that fitted dataset.\n"
"\n"
"* You can also add your own basis datasets to the fitting mix, using the\n"
" '-base' option.\n"
"\n"
"* You can get the fit coefficients using the '-1Dcoef' option.\n"
"\n"
"--------\n"
"Options: ~1~\n"
"--------\n"
"\n"
" -nord n = Maximum polynomial order (0..9) [default order=3]\n"
" [n=0 is the constant 1]\n"
" [n=-1 means only use volumes from '-base']\n"
"\n"
" -blur f = Gaussian blur input dataset (inside mask) with FWHM='f' (mm)\n"
"\n"
" -mrad r = Radius (voxels) of preliminary median filter of input\n"
" [default is no blurring of either type; you can]\n"
" [do both types (Gaussian and median), but why??]\n"
" [N.B.: median blur is slower than Gaussian]\n"
"\n"
" -prefix pp = Use 'pp' for prefix of output dataset (the fit).\n"
" [default prefix is 'Polyfit'; use NULL to skip this output]\n"
"\n"
" -resid rr = Use 'rr' for the prefix of the residual dataset.\n"
" [default is not to output residuals]\n"
"\n"
" -1Dcoef cc = Save coefficients of fit into text file cc.1D.\n"
" [default is not to save these coefficients]\n"
"\n"
" -automask = Create a mask (a la 3dAutomask)\n"
" -mask mset = Create a mask from nonzero voxels in 'mset'.\n"
" [default is not to use a mask, which is probably a bad idea]\n"
"\n"
" -mone = Scale the mean value of the fit (inside the mask) to 1.\n"
" [probably this option is not useful for anything]\n"
"\n"
" -mclip = Clip fit values outside the rectilinear box containing the\n"
" mask to the edge of that box, to avoid weird artifacts.\n"
"\n"
" -meth mm = Set 'mm' to 2 for least squares fit;\n"
" set it to 1 for L1 fit [default method=2]\n"
" [Note that L1 fitting is slower than L2 fitting!]\n"
"\n"
" -base bb = In addition to the polynomial fit, also use\n"
" the volumes in dataset 'bb' as extra basis functions.\n"
" [If you use a base dataset, then you can set nord]\n"
" [to -1, to skip using any spatial polynomial fit.]\n"
"\n"
" -verb = Print fun and useful progress reports :-)\n"
"\n"
"------\n"
"Notes: ~1~\n"
"------\n"
"* Output dataset is always stored in float format.\n"
"\n"
"* If the input dataset has more than 1 sub-brick, only sub-brick #0\n"
" is processed. To fit more than one volume, you'll have to use a script\n"
" to loop over the input sub-bricks, and then glue (3dTcat) the results\n"
" together to get a final result. A simple example:\n"
" #!/bin/tcsh\n"
" set base = model.nii\n"
" set dset = errts.nii\n"
" set nval = `3dnvals $dset`\n"
" @ vtop = $nval - 1\n"
" foreach vv ( `count 0 $vtop` )\n"
" 3dPolyfit -base \"$base\" -nord 0 -mask \"$base\" -1Dcoef QQ.$vv -prefix QQ.$vv.nii $dset\"[$vv]\"\n"
" end\n"
" 3dTcat -prefix QQall.nii QQ.0*.nii\n"
" 1dcat QQ.0*.1D > QQall.1D\n"
" \rm QQ.0*\n"
" exit 0\n"
"\n"
"* If the '-base' dataset has multiple sub-bricks, all of them are used.\n"
"\n"
"* You can use the '-base' option more than once, if desired or needed.\n"
"\n"
"* The original motivation for this program was to fit a spatial model\n"
" to a field map MRI, but that didn't turn out to be useful. Nevertheless,\n"
" I make this program available to someone who might find it beguiling.\n"
"\n"
"* If you really want, I could allow you to put sign constraints on the\n"
" fit coefficients (e.g., say that the coefficient for a given base volume\n"
" should be non-negative). But you'll have to beg for this.\n"
"\n"
"-- Emitted by RWCox\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
/*-- startup paperwork --*/
mainENTRY("3dPolyfit main"); machdep(); AFNI_logger("3dPolyfit",argc,argv);
PRINT_VERSION("3dPolyfit") ;
/*-- scan command line --*/
iarg = 1 ;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcasecmp(argv[iarg],"-base") == 0 ){
THD_3dim_dataset *bset ; int kk ; MRI_IMAGE *bim ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-base'") ;
bset = THD_open_dataset(argv[iarg]) ;
CHECK_OPEN_ERROR(bset,argv[iarg]) ;
DSET_load(bset) ; CHECK_LOAD_ERROR(bset) ;
if( exar == NULL ) INIT_IMARR(exar) ;
for( kk=0 ; kk < DSET_NVALS(bset) ; kk++ ){
bim = THD_extract_float_brick(kk,bset) ;
if( bim != NULL ) ADDTO_IMARR(exar,bim) ;
DSET_unload_one(bset,kk) ;
}
DSET_delete(bset) ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-verb") == 0 ){
verb++ ; iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-hermite") == 0 ){ /* 25 Mar 2013 [New Year's Day] */
mri_polyfit_set_basis("hermite") ; /* HIDDEN */
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-byslice") == 0 ){ /* 25 Mar 2013 [New Year's Day] */
do_byslice++ ; iarg++ ; continue ; /* HIDDEN */
}
if( strcasecmp(argv[iarg],"-mask") == 0 ){
THD_3dim_dataset *mset ;
if( ++iarg >= 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[iarg]) ;
CHECK_OPEN_ERROR(mset,argv[iarg]) ;
DSET_load(mset) ; CHECK_LOAD_ERROR(mset) ;
nvmask = DSET_NVOX(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]) ;
nmask = THD_countmask( nvmask , mask ) ;
if( nmask < 99 ) ERROR_exit("Too few voxels in mask (%d)",nmask) ;
if( verb ) INFO_message("Number of voxels in mask = %d",nmask) ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-nord") == 0 ){
nord = (int)strtol( argv[++iarg], NULL , 10 ) ;
if( nord < -1 || nord > 9 )
ERROR_exit("Illegal value after -nord :(") ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-meth") == 0 ){
meth = (int)strtol( argv[++iarg], NULL , 10 ) ;
if( meth < 1 || meth > 2 )
ERROR_exit("Illegal value after -meth :(") ;
iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-automask",5) == 0 ){
if( mask != NULL ) ERROR_exit("Can't use -mask and -automask together!") ;
do_automask++ ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-mclip",5) == 0 ){
do_mclip++ ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-mone",5) == 0 ){
do_mone++ ; iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-mrad") == 0 ){
mrad = strtod( argv[++iarg] , NULL ) ; iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-blur") == 0 ){
fwhm = strtod( argv[++iarg] , NULL ) ; iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-prefix") == 0 ){
prefix = argv[++iarg] ;
if( !THD_filename_ok(prefix) )
ERROR_exit("Illegal value after -prefix :(");
if( strcasecmp(prefix,"NULL") == 0 ) prefix = NULL ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-resid") == 0 ){
resid = argv[++iarg] ;
if( !THD_filename_ok(resid) )
ERROR_exit("Illegal value after -resid :(");
if( strcasecmp(resid,"NULL") == 0 ) resid = NULL ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-1Dcoef") == 0 ){ /* 26 Feb 2019 */
cfnam = argv[++iarg] ;
if( !THD_filename_ok(cfnam) )
ERROR_exit("Illegal value after -1Dcoef :(");
if( strcasecmp(cfnam,"NULL") == 0 ) cfnam = NULL ;
iarg++ ; continue ;
}
ERROR_exit("Unknown option: %s\n",argv[iarg]);
}
/*--- check for blatant errors ---*/
if( iarg >= argc )
ERROR_exit("No input dataset name on command line?");
if( prefix == NULL && resid == NULL && cfnam == NULL )
ERROR_exit("-prefix and -resid and -1Dcoef are all NULL?!") ;
if( do_byslice && cfnam != NULL ){
WARNING_message("-byslice does not work with -1Dcoef option :(") ;
cfnam = NULL ;
}
if( nord < 0 && exar == NULL )
ERROR_exit("no polynomial fit AND no -base option ==> nothing to compute :(") ;
/*-- read input --*/
if( verb ) INFO_message("Load input dataset") ;
inset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
DSET_load(inset) ; CHECK_LOAD_ERROR(inset) ;
if( DSET_NVALS(inset) > 1 )
WARNING_message( "Only processing sub-brick #0 (out of %d)" , DSET_NVALS(inset) );
/* check input mask or create automask */
if( mask != NULL ){
if( nvmask != DSET_NVOX(inset) )
ERROR_exit("-mask and input datasets don't match in voxel counts :-(") ;
} else if( do_automask ){
THD_automask_verbose( (verb > 1) ) ;
THD_automask_extclip( 1 ) ;
mask = THD_automask( inset ) ; nvmask = DSET_NVOX(inset) ;
nmask = THD_countmask( nvmask , mask ) ;
if( nmask < 99 ) ERROR_exit("Too few voxels in automask (%d)",nmask) ;
if( verb ) ININFO_message("Number of voxels in automask = %d",nmask) ;
} else {
WARNING_message("3dPolyfit is running without a mask") ;
}
#undef GOOD
#define GOOD(i) (mask == NULL || mask[i])
/* check -base input datasets */
if( exar != NULL ){
int ii,kk , nvbad=0 , nvox=DSET_NVOX(inset),nm ; float *ex , exb ;
for( kk=0 ; kk < IMARR_COUNT(exar) ; kk++ ){
if( nvox != IMARR_SUBIM(exar,kk)->nvox ){
if( IMARR_SUBIM(exar,kk)->nvox != nvbad ){
ERROR_message("-base volume (%d voxels) doesn't match input dataset grid size (%d voxels)",
IMARR_SUBIM(exar,kk)->nvox , nvox ) ;
nvbad = IMARR_SUBIM(exar,kk)->nvox ;
}
}
}
if( nvbad != 0 ) ERROR_exit("Cannot continue :-(") ;
/* subtract mean from each base input, if is a constant polynomial in the fit */
if( nord >= 0 ){
if( verb ) INFO_message("subtracting spatial mean from '-base'") ;
for( kk=0 ; kk < IMARR_COUNT(exar) ; kk++ ){
exb = 0.0f ; ex = MRI_FLOAT_PTR(IMARR_SUBIM(exar,kk)) ;
for( nm=ii=0 ; ii < nvox ; ii++ ){ if( GOOD(ii) ){ exb += ex[ii]; nm++; } }
exb /= nm ;
for( ii=0 ; ii < nvox ; ii++ ) ex[ii] -= exb ;
}
}
}
/* if blurring, edit mask a little */
if( mask != NULL && (fwhm > 0.0f || mrad > 0.0f) ){
int ii ;
ii = THD_mask_remove_isolas( DSET_NX(inset),DSET_NY(inset),DSET_NZ(inset),mask ) ;
if( ii > 0 ){
nmask = THD_countmask( nvmask , mask ) ;
if( verb )
ININFO_message("Removed %d isola%s from mask, leaving %d voxels" ,
ii,(ii==1)?"\0":"s" , nmask ) ;
if( nmask < 99 )
ERROR_exit("Too few voxels left in mask after isola removal :-(") ;
}
}
/* convert input to float, which is simpler to deal with */
imin = THD_extract_float_brick(0,inset) ;
if( imin == NULL ) ERROR_exit("Can't extract input dataset brick?! :-(") ;
DSET_unload(inset) ;
if( verb ) INFO_message("Start fitting process") ;
/* do the Gaussian blurring */
if( fwhm > 0.0f ){
if( verb ) ININFO_message("Gaussian blur: FWHM=%g mm",fwhm) ;
imin->dx = fabsf(DSET_DX(inset)) ;
imin->dy = fabsf(DSET_DY(inset)) ;
imin->dz = fabsf(DSET_DZ(inset)) ;
mri_blur3D_addfwhm( imin , mask , fwhm ) ;
}
/* do the fitting */
mri_polyfit_verb(verb) ;
if( do_byslice )
imout = mri_polyfit_byslice( imin , nord , exar , mask , mrad , meth ) ;
else
imout = mri_polyfit ( imin , nord , exar , mask , mrad , meth ) ;
/* WTF? */
if( imout == NULL )
ERROR_exit("Can't compute polynomial fit :-( !?") ;
if( resid == NULL ) mri_free(imin) ;
if( ! do_byslice )
fvit = mri_polyfit_get_fitvec() ; /* get coefficients of fit [26 Feb 2019] */
/* scale the fit dataset? */
if( do_mone ){
float sum=0.0f ; int nsum=0 , ii,nvox ; float *par=MRI_FLOAT_PTR(imout) ;
nvox = imout->nvox ;
for( ii=0 ; ii < nvox ; ii++ ){
if( mask != NULL && mask[ii] == 0 ) continue ;
sum += par[ii] ; nsum++ ;
}
if( nsum > 0 && sum != 0.0f ){
sum = nsum / sum ;
if( verb ) ININFO_message("-mone: scaling fit by %g",sum) ;
for( ii=0 ; ii < nvox ; ii++ ) par[ii] *= sum ;
}
}
/* if there's a mask, clip values outside of its box */
#undef PF
#define PF(i,j,k) par[(i)+(j)*nx+(k)*nxy]
if( mask != NULL && do_mclip ){
int xm,xp,ym,yp,zm,zp , ii,jj,kk , nx,ny,nz,nxy ; float *par ;
MRI_IMAGE *bim = mri_empty_conforming( imout , MRI_byte ) ;
mri_fix_data_pointer(mask,bim) ;
if( verb ) ININFO_message("-mclip: polynomial fit to autobox of mask") ;
MRI_autobbox( bim , &xm,&xp , &ym,&yp , &zm,&zp ) ;
mri_clear_data_pointer(bim) ; mri_free(bim) ;
nx = imout->nx ; ny = imout->ny ; nz = imout->nz ; nxy = nx*ny ;
par = MRI_FLOAT_PTR(imout) ;
for( ii=0 ; ii < xm ; ii++ )
for( kk=0 ; kk < nz ; kk++ )
for( jj=0 ; jj < ny ; jj++ ) PF(ii,jj,kk) = PF(xm,jj,kk) ;
for( ii=xp+1 ; ii < nx ; ii++ )
for( kk=0 ; kk < nz ; kk++ )
for( jj=0 ; jj < ny ; jj++ ) PF(ii,jj,kk) = PF(xp,jj,kk) ;
for( jj=0 ; jj < ym ; jj++ )
for( kk=0 ; kk < nz ; kk++ )
for( ii=0 ; ii < nx ; ii++ ) PF(ii,jj,kk) = PF(ii,ym,kk) ;
for( jj=yp+1 ; jj < ny ; jj++ )
for( kk=0 ; kk < nz ; kk++ )
for( ii=0 ; ii < nx ; ii++ ) PF(ii,jj,kk) = PF(ii,yp,kk) ;
for( kk=0 ; kk < zm ; kk++ )
for( jj=0 ; jj < ny ; jj++ )
for( ii=0 ; ii < nx ; ii++ ) PF(ii,jj,kk) = PF(ii,jj,zm) ;
for( kk=zp+1 ; kk < nz ; kk++ )
for( jj=0 ; jj < ny ; jj++ )
for( ii=0 ; ii < nx ; ii++ ) PF(ii,jj,kk) = PF(ii,jj,zp) ;
}
if( mask != NULL ) free(mask) ;
/* write outputs */
if( prefix != NULL ){
THD_3dim_dataset *outset = EDIT_empty_copy( inset ) ;
EDIT_dset_items( outset ,
ADN_prefix , prefix ,
ADN_nvals , 1 ,
ADN_ntt , 0 ,
ADN_none ) ;
EDIT_substitute_brick( outset , 0 , MRI_float , MRI_FLOAT_PTR(imout) ) ;
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dPolyfit" , argc,argv , outset ) ;
DSET_write(outset) ;
WROTE_DSET(outset) ;
}
if( resid != NULL ){
THD_3dim_dataset *outset = EDIT_empty_copy( inset ) ;
float *inar=MRI_FLOAT_PTR(imin) , *outar=MRI_FLOAT_PTR(imout) ;
int nx,ny,nz , nxyz , kk ;
nx = imout->nx ; ny = imout->ny ; nz = imout->nz ; nxyz = nx*ny*nz ;
for( kk=0 ; kk < nxyz ; kk++ ) outar[kk] = inar[kk] - outar[kk] ;
mri_free(imin) ;
EDIT_dset_items( outset ,
ADN_prefix , resid ,
ADN_nvals , 1 ,
ADN_ntt , 0 ,
ADN_none ) ;
EDIT_substitute_brick( outset , 0 , MRI_float , MRI_FLOAT_PTR(imout) ) ;
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dPolyfit" , argc,argv , outset ) ;
DSET_write(outset) ;
WROTE_DSET(outset) ;
}
if( cfnam != NULL && fvit != NULL ){ /* won't work with '-byslice' */
char *qn ;
qn = STRING_HAS_SUFFIX(cfnam,".1D") ? cfnam : modify_afni_prefix(cfnam,NULL,".1D") ;
mri_write_floatvec( qn , fvit ) ;
}
exit(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) ;
}
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 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) ;
}
