void process_subbrick (THD_3dim_dataset * dset, int ibrick)
{
const float EPSILON = 1.0e-10;
float factor; /* factor is new scale factor for this sub-brick */
void * vfim = NULL; /* sub-brick data pointer */
float * ffim = NULL; /* sub-brick data in floating point format */
char brick_label[THD_MAX_NAME]; /* sub-brick label */
ENTRY("process_subbrick") ;
if (!FDR_quiet) printf ("Processing sub-brick #%d \n", ibrick);
/*----- Allocate memory for float data -----*/
ffim = (float *) malloc (sizeof(float) * FDR_nxyz); MTEST (ffim);
/*----- Convert sub-brick to float stats -----*/
SUB_POINTER (dset, ibrick, 0, vfim);
EDIT_coerce_scale_type (FDR_nxyz, DSET_BRICK_FACTOR(dset,ibrick),
DSET_BRICK_TYPE(dset,ibrick), vfim, /* input */
MRI_float , ffim); /* output */
/*----- Calculate FDR z-scores for all voxels within this volume -----*/
process_volume (ffim, DSET_BRICK_STATCODE(dset,ibrick),
DSET_BRICK_STATAUX (dset,ibrick));
/*----- Replace old sub-brick with new z-scores -----*/
if( !FDR_float || DSET_BRICK_TYPE(dset,ibrick)==MRI_float ){
SUB_POINTER (dset, ibrick, 0, vfim);
factor = EDIT_coerce_autoscale_new (FDR_nxyz, MRI_float, ffim,
DSET_BRICK_TYPE(dset,ibrick), vfim);
if (factor < EPSILON) factor = 0.0;
else factor = 1.0 / factor;
if( DSET_BRICK_TYPE(dset,ibrick) == MRI_short )
EDIT_misfit_report( DSET_FILECODE(dset) , ibrick ,
FDR_nxyz , factor , vfim , ffim ) ;
} else { /*** if -float was given ***/
EDIT_substitute_brick( dset , ibrick , MRI_float , ffim ) ;
ffim = NULL ; factor = 0.0f ;
}
/*----- edit the sub-brick -----*/
if( FDR_qval ) strcpy (brick_label, "FDRq:");
else strcpy (brick_label, "FDRz:");
strcat (brick_label, DSET_BRICK_LABEL(dset, ibrick));
EDIT_BRICK_LABEL (dset, ibrick, brick_label);
EDIT_BRICK_FACTOR (dset, ibrick, factor);
if( !FDR_qval ) EDIT_BRICK_TO_FIZT (dset,ibrick);
else EDIT_BRICK_TO_NOSTAT(dset,ibrick);
/*----- Deallocate memory -----*/
if (ffim != NULL) { free (ffim); ffim = NULL; }
EXRETURN ;
}
int SUMA_ShortizeDset(THD_3dim_dataset **dsetp, float thisfac) {
static char FuncName[]={"SUMA_ShortizeDset"};
char sprefix[THD_MAX_PREFIX+10];
int i, j;
byte *bb=NULL;
short *sb=NULL;
float bbf=0.0;
THD_3dim_dataset *cpset=NULL, *dset=*dsetp;
SUMA_ENTRY;
if (!dset) {
SUMA_S_Err("NULL *dsetp at input!");
SUMA_RETURN(0);
}
sprintf(sprefix, "%s.s", dset->dblk->diskptr->prefix);
NEW_SHORTY(dset, DSET_NVALS(dset), "ss.cp", cpset);
for (i=0; i<DSET_NVALS(dset); ++i) {
if (DSET_BRICK_TYPE(dset,i) == MRI_byte) {
bb = (byte *)DSET_ARRAY(dset,i);
sb = (short *)DSET_ARRAY(cpset,i);
if (thisfac <= 0.0) {
for (j=0; j<DSET_NVOX(dset); ++j) {
sb[j] = (short)bb[j];
}
thisfac = DSET_BRICK_FACTOR(dset,i);
} else {
bbf = DSET_BRICK_FACTOR(dset,i); if (bbf == 0.0f) bbf = 1.0;
bbf = bbf/thisfac;
for (j=0; j<DSET_NVOX(dset); ++j) {
sb[j] = SHORTIZE((((float)bb[j])*bbf));
}
}
EDIT_BRICK_FACTOR( cpset,i,thisfac ) ;
} else {
EDIT_substscale_brick(cpset, i, DSET_BRICK_TYPE(dset,i),
DSET_ARRAY(dset,i), MRI_short, thisfac);
if (DSET_BRICK_TYPE(dset,i) != MRI_short) {
DSET_FREE_ARRAY(dset, i);
} else {
DSET_NULL_ARRAY(dset, i);
}
}
}
/* preserve tables, if any */
THD_copy_labeltable_atr( cpset->dblk, dset->dblk);
DSET_delete(dset); dset = NULL;
*dsetp=cpset;
SUMA_RETURN(1);
}
void THD_load_tcat( THD_datablock *dblk )
{
int ivout , dd , iv ;
THD_3dim_dataset *dset_in , *dset_out ;
NI_str_array *sar ;
ENTRY("THD_load_tcat") ;
if( !ISVALID_DBLK(dblk) ) EXRETURN ;
dset_out = (THD_3dim_dataset *)dblk->parent ;
if( !ISVALID_DSET(dset_out) ) EXRETURN ;
sar = NI_decode_string_list( dset_out->tcat_list , "~" ) ;
if( sar == NULL ) EXRETURN ;
if( sar->num != dset_out->tcat_num ){ NI_delete_str_array(sar); EXRETURN; }
ivout = 0 ;
for( dd=0 ; dd < sar->num ; dd++ ){
dset_in = THD_open_dataset( sar->str[dd] ) ;
if( dset_in == NULL ){
NI_delete_str_array(sar) ; DSET_unload(dset_out) ;
EXRETURN ;
}
DSET_mallocize(dset_in) ; DSET_load(dset_in) ;
if( !DSET_LOADED(dset_in) ){
NI_delete_str_array(sar) ; DSET_unload(dset_out) ; DSET_delete(dset_in) ;
EXRETURN ;
}
for( iv=0 ; iv < DSET_NVALS(dset_in) ; iv++ ){
EDIT_substitute_brick( dset_out , ivout ,
DSET_BRICK_TYPE(dset_in,iv), DSET_ARRAY(dset_in,iv) );
mri_fix_data_pointer( NULL , DSET_BRICK(dset_in,iv) ) ;
EDIT_BRICK_FACTOR( dset_out , ivout , DSET_BRICK_FACTOR(dset_in,iv) ) ;
EDIT_BRICK_LABEL(dset_out, ivout,
DSET_BRICK_LABEL(dset_in, iv)); /* ZSS Aug. 27 2012 */
ivout++ ;
}
DSET_delete(dset_in) ;
}
NI_delete_str_array(sar) ; EXRETURN ;
}
THD_3dim_dataset * THD_detrend_dataset( THD_3dim_dataset *dset ,
int nref , float **ref ,
int meth , int scl ,
byte *mask , MRI_IMARR **imar )
{
MRI_IMARR *qmar ;
int ii,jj,kk , nvals,nvox , iv ;
float *var ;
THD_3dim_dataset *newset ;
ENTRY("THD_detrend_dataset") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
nvals = DSET_NVALS(dset) ; nvox = DSET_NVOX(dset) ;
qmar = THD_time_fit_dataset( dset , nref,ref , meth , mask ) ;
if( qmar == NULL ) RETURN(NULL) ;
newset = EDIT_empty_copy(dset) ;
for( iv=0 ; iv < nvals ; iv++ ){
EDIT_substitute_brick( newset , iv , MRI_float , NULL ) ;
EDIT_BRICK_FACTOR( newset , iv , 0.0f ) ; /* 04 Jun 2007 */
}
var = (float *)malloc(sizeof(float)*nvals) ;
for( ii=0 ; ii < nvox ; ii++ ){
if( mask == NULL || mask[ii] )
THD_extract_detrended_array( dset , nref,ref , qmar , ii,scl , var ) ;
else
memset(var,0,sizeof(float)*nvals) ;
THD_insert_series( ii , newset , nvals , MRI_float , var , 0 ) ;
}
free(var) ;
if( imar != NULL ) *imar = qmar ;
else DESTROY_IMARR(qmar) ;
RETURN(newset) ;
}
/*! Replace a voxel's value by the value's rank in the entire set of input datasets */
int main( int argc , char * argv[] )
{
THD_3dim_dataset ** dsets_in = NULL, *dset=NULL; /*input and output datasets*/
int nopt=0, nbriks=0, nsubbriks=0, ib=0, isb=0;
byte *cmask=NULL;
int *all_uniques=NULL, **uniques=NULL, *final_unq=NULL, *N_uniques=NULL;
int N_final_unq=0, iun=0, total_unq=0;
INT_HASH_DATUM *rmap=NULL, *hd=NULL;
int imax=0, iunq=0, ii=0, id = 0;
long int off=0;
char *prefix=NULL;
char stmp[THD_MAX_PREFIX+1]={""};
FILE *fout=NULL;
/*----- Read command line -----*/
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
Rank_help ();
exit(0) ;
}
mainENTRY("3dRank main"); machdep(); AFNI_logger("3dRank",argc,argv);
nopt = 1 ;
while( nopt < argc && argv[nopt][0] == '-' ){
if( strcmp(argv[nopt],"-ver") == 0 ){
PRINT_VERSION("3dRank"); AUTHOR("Ziad Saad");
nopt++; continue;
}
if( strcmp(argv[nopt],"-help") == 0 ){
Rank_help();
exit(0) ;
}
if( strcmp(argv[nopt],"-prefix") == 0 ){
++nopt;
if (nopt>=argc) {
fprintf(stderr,"**ERROR: Need string after -prefix\n");
exit(1);
}
prefix = argv[nopt] ;
++nopt; continue;
}
if( strcmp(argv[nopt],"-input") == 0 ){
dsets_in = (THD_3dim_dataset**)
calloc(argc-nopt+1, sizeof(THD_3dim_dataset*));
++nopt; nbriks=0;
while (nopt < argc ) {
dsets_in[nbriks] = THD_open_dataset( argv[nopt] );
if( !ISVALID_DSET(dsets_in[nbriks]) ){
fprintf(stderr,"**ERROR: can't open dataset %s\n",argv[nopt]) ;
exit(1);
}
++nopt; ++nbriks;
}
continue;
}
ERROR_exit( " Error - unknown option %s", argv[nopt]);
}
if (nopt < argc) {
ERROR_exit( " Error unexplained trailing option: %s\n", argv[nopt]);
}
if (!nbriks) {
ERROR_exit( " Error no volumes entered on command line?");
}
/* some checks and inits*/
nsubbriks = 0;
for (ib = 0; ib<nbriks; ++ib) {
if (!is_integral_dset(dsets_in[ib], 0)) {
ERROR_exit("Dset %s is not of an integral data type.",
DSET_PREFIX(dsets_in[ib]));
}
nsubbriks += DSET_NVALS(dsets_in[ib]);
}
/* Now get unique arrays */
uniques = (int **)calloc(nsubbriks, sizeof(int*));
N_uniques = (int *)calloc(nsubbriks, sizeof(int));
total_unq = 0;
iun = 0;
for (ib = 0; ib<nbriks; ++ib) {
DSET_mallocize(dsets_in[ib]); DSET_load(dsets_in[ib]);
for (isb=0; isb<DSET_NVALS(dsets_in[ib]); ++isb) {
uniques[iun] = THD_unique_vals(dsets_in[ib], isb,
&(N_uniques[iun]), cmask);
total_unq += N_uniques[iun];
++iun;
}
}
/* put all the arrays together and get the unique of the uniques */
all_uniques = (int *)calloc(total_unq, sizeof(int));
off=0;
for (iun=0; iun<nsubbriks; ++iun) {
memcpy(all_uniques+off, uniques[iun], N_uniques[iun]*sizeof(int));
off += N_uniques[iun];
}
/* free intermediate unique arrays */
for (iun=0; iun<nsubbriks; ++iun) {
free(uniques[iun]);
}
free(uniques); uniques=NULL;
free(N_uniques); N_uniques=NULL;
/* get unique of catenated array */
if (!(final_unq = UniqueInt (all_uniques, total_unq, &N_final_unq, 0 ))) {
ERROR_exit( " Failed to get unique list (%d, %d, %d) ",
total_unq, N_final_unq, nsubbriks);
}
free(all_uniques); all_uniques=NULL;
if (prefix) {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"%s.rankmap.1D", prefix);
} else {
if (nbriks == 1) {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"%s.rankmap.1D", DSET_PREFIX(dsets_in[0]));
} else {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"%s+.rankmap.1D", DSET_PREFIX(dsets_in[0]));
}
}
if (stmp[0]) {
if ((fout = fopen(stmp,"w"))) {
fprintf(fout, "#Rank Map (%d unique values)\n", N_final_unq);
fprintf(fout, "#Col. 0: Rank\n");
fprintf(fout, "#Col. 1: Input Dset Value\n");
}
}
/* get the maximum integer in the unique array */
imax = 0;
for (iunq=0; iunq<N_final_unq; ++iunq) {
if (final_unq[iunq] > imax) imax = final_unq[iunq];
if (fout) fprintf(fout, "%d %d\n", iunq, final_unq[iunq]);
hd = (INT_HASH_DATUM*)calloc(1,sizeof(INT_HASH_DATUM));
hd->id = final_unq[iunq];
hd->index = iunq;
HASH_ADD_INT(rmap, id, hd);
}
fclose(fout); fout=NULL;
/* now cycle over all dsets and replace their voxel values with rank */
for (ib = 0; ib<nbriks; ++ib) {
for (isb=0; isb<DSET_NVALS(dsets_in[ib]); ++isb) {
EDIT_BRICK_LABEL( dsets_in[ib],isb, "rank" ) ;
EDIT_BRICK_TO_NOSTAT( dsets_in[ib],isb ) ;
EDIT_BRICK_FACTOR( dsets_in[ib],isb, 0.0);/* no factors for rank*/
switch (DSET_BRICK_TYPE(dsets_in[ib],isb) ){
default:
fprintf(stderr,
"** Bad dset type for unique operation.\n"
"Only Byte, Short, and float dsets are allowed.\n");
break ; /* this should not happen here,
so don't bother returning*/
case MRI_short:{
short *mar = (short *) DSET_ARRAY(dsets_in[ib],isb) ;
if (imax > MRI_TYPE_maxval[MRI_short]) {
WARNING_message("Maximum rank value of %d is\n"
"than maximum value for dset datatype of %d\n",
imax, MRI_TYPE_maxval[MRI_short]);
}
for( ii=0 ; ii < DSET_NVOX(dsets_in[ib]) ; ii++ )
if (!cmask || cmask[ii]) {
id = (int)mar[ii];
HASH_FIND_INT(rmap,&id ,hd);
if (hd) mar[ii] = (short)(hd->index);
else
ERROR_exit("** Failed to find key %d in hash table\n",id);
} else mar[ii] = 0;
}
break ;
case MRI_byte:{
byte *mar ;
if (imax > MRI_TYPE_maxval[MRI_short]) {
WARNING_message("Maximum rank value of %d is\n"
"than maximum value for dset datatype of %d\n",
imax, MRI_TYPE_maxval[MRI_byte]);
}
mar = (byte *) DSET_ARRAY(dsets_in[ib],isb) ;
for( ii=0 ; ii < DSET_NVOX(dsets_in[ib]) ; ii++ )
if (!cmask || cmask[ii]) {
id = (int)mar[ii];
HASH_FIND_INT(rmap,&id ,hd);
if (hd) mar[ii] = (byte)(hd->index);
else
ERROR_exit("** Failed to find key %d in hash table\n",id);
} else mar[ii] = 0;
}
break ;
case MRI_float:{
float *mar = (float *) DSET_ARRAY(dsets_in[ib],isb) ;
for( ii=0 ; ii < DSET_NVOX(dsets_in[ib]) ; ii++ )
if (!cmask || cmask[ii]) {
id = (int)mar[ii]; /* Assuming float is integral valued */
HASH_FIND_INT(rmap,&id ,hd);
if (hd) mar[ii] = (float)(hd->index);
else
ERROR_exit("** Failed to find key %d in hash table\n",id);
} else mar[ii] = 0;
}
break ;
}
}
/* update range, etc. */
THD_load_statistics(dsets_in[ib]);
/* Now write the bricks */
if (prefix) {
if (nbriks == 1) {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"%s", prefix);
} else {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"r%02d.%s", ib, prefix);
}
} else {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"rank.%s", DSET_PREFIX(dsets_in[ib]));
}
EDIT_dset_items( dsets_in[ib] ,
ADN_prefix , stmp ,
ADN_none ) ;
/* change storage mode, this way prefix will determine
format of output dset */
dsets_in[ib]->dblk->diskptr->storage_mode = STORAGE_BY_BRICK;
tross_Make_History( "3dRank" , argc, argv , dsets_in[ib] ) ;
if (DSET_IS_MASTERED(dsets_in[ib])) {
/* THD_write_3dim_dataset won't write a mastered dude */
dset = EDIT_full_copy(dsets_in[ib],stmp);
} else {
dset = dsets_in[ib];
}
/* New ID */
ZERO_IDCODE(dset->idcode);
dset->idcode = MCW_new_idcode() ;
if (!THD_write_3dim_dataset( NULL, stmp, dset,True )) {
ERROR_message("Failed to write %s", stmp);
exit(1);
} else {
WROTE_DSET(dsets_in[ib]);
if (dset != dsets_in[ib]) DSET_deletepp(dset);
DSET_deletepp(dsets_in[ib]);
}
}
/* destroy hash */
while (rmap) {
hd = rmap;
HASH_DEL(rmap,hd);
free(hd);
}
free(final_unq); final_unq=NULL;
exit(0);
}
THD_3dim_dataset * THD_localhistog( int nsar , THD_3dim_dataset **insar ,
int numval , int *rlist , MCW_cluster *nbhd ,
int do_prob , int verb )
{
THD_3dim_dataset *outset=NULL , *inset ;
int nvox=DSET_NVOX(insar[0]) ;
int ids, iv, bb, nnpt=nbhd->num_pt ;
MRI_IMAGE *bbim ; int btyp ;
float **outar , **listar ;
ENTRY("THD_localhistog") ;
/*---- create output dataset ----*/
outset = EDIT_empty_copy(insar[0]) ;
EDIT_dset_items( outset ,
ADN_nvals , numval ,
ADN_datum_all , MRI_float ,
ADN_nsl , 0 ,
ADN_brick_fac , NULL ,
ADN_none ) ;
outar = (float **)malloc(sizeof(float *)*numval) ;
for( bb=0 ; bb < numval ; bb++ ){
EDIT_substitute_brick( outset , bb , MRI_float , NULL ) ;
outar[bb] = DSET_BRICK_ARRAY(outset,bb) ;
}
/*---- make mapping between values and arrays to get those values ----*/
listar = (float **)malloc(sizeof(float *)*TWO16) ;
for( bb=0 ; bb < TWO16 ; bb++ ) listar[bb] = outar[0] ;
for( bb=1 ; bb < numval ; bb++ ){
listar[ rlist[bb] + TWO15 ] = outar[bb] ;
}
/*----------- loop over datasets, add in counts for all voxels -----------*/
for( ids=0 ; ids < nsar ; ids++ ){ /* dataset loop */
inset = insar[ids] ; DSET_load(inset) ;
for( iv=0 ; iv < DSET_NVALS(inset) ; iv++ ){ /* sub-brick loop */
if( verb ) fprintf(stderr,".") ;
bbim = DSET_BRICK(inset,iv) ; btyp = bbim->kind ;
if( nnpt == 1 ){ /* only 1 voxel in nbhd */
int qq,ii,jj,kk,ib,nb ;
switch( bbim->kind ){
case MRI_short:{
short *sar = MRI_SHORT_PTR(bbim) ;
for( qq=0 ; qq < nvox ; qq++ ) listar[sar[qq]+TWO15][qq]++ ;
}
break ;
case MRI_byte:{
byte *bar = MRI_BYTE_PTR(bbim) ;
for( qq=0 ; qq < nvox ; qq++ ) listar[bar[qq]+TWO15][qq]++ ;
}
break ;
case MRI_float:{
float *far = MRI_FLOAT_PTR(bbim) ; short ss ;
for( qq=0 ; qq < nvox ; qq++ ){ ss = SHORTIZE(far[qq]); listar[ss+TWO15][qq]++; }
}
break ;
}
} else { /* multiple voxels in nbhd */
AFNI_OMP_START ;
#pragma omp parallel
{ int qq,ii,jj,kk,ib,nb ; void *nar ; short *sar,ss ; byte *bar ; float *far ;
nar = malloc(sizeof(float)*nnpt) ;
sar = (short *)nar ; bar = (byte *)nar ; far = (float *)nar ;
#pragma omp for
for( qq=0 ; qq < nvox ; qq++ ){ /* qq=voxel index */
ii = DSET_index_to_ix(inset,qq) ;
jj = DSET_index_to_jy(inset,qq) ;
kk = DSET_index_to_kz(inset,qq) ;
nb = mri_get_nbhd_array( bbim , NULL , ii,jj,kk , nbhd , nar ) ;
if( nb == 0 ) continue ;
switch( btyp ){
case MRI_short:
for( ib=0 ; ib < nb ; ib++ ) listar[sar[ib]+TWO15][qq]++ ;
break ;
case MRI_byte:
for( ib=0 ; ib < nb ; ib++ ) listar[bar[ib]+TWO15][qq]++ ;
break ;
case MRI_float:
for( ib=0 ; ib < nb ; ib++ ){ ss = SHORTIZE(far[ib]); listar[ss+TWO15][qq]++; }
break ;
}
} /* end of voxel loop */
free(nar) ;
} /* end of OpenMP */
AFNI_OMP_END ;
}
} /* end of sub-brick loop */
DSET_unload(inset) ;
} /* end of dataset loop */
if( verb ) fprintf(stderr,"\n") ;
free(listar) ;
/*---- post-process output ---*/
if( do_prob ){
byte **bbar ; int pp ;
if( verb ) INFO_message("Conversion to probabilities") ;
AFNI_OMP_START ;
#pragma omp parallel
{ int qq , ib ; float pfac , val ; byte **bbar ;
#pragma omp for
for( qq=0 ; qq < nvox ; qq++ ){
pfac = 0.0001f ;
for( ib=0 ; ib < numval ; ib++ ) pfac += outar[ib][qq] ;
pfac = 250.0f / pfac ;
for( ib=0 ; ib < numval ; ib++ ){
val = outar[ib][qq]*pfac ; outar[ib][qq] = BYTEIZE(val) ;
}
}
} /* end OpenMP */
AFNI_OMP_END ;
bbar = (byte **)malloc(sizeof(byte *)*numval) ;
for( bb=0 ; bb < numval ; bb++ ){
bbar[bb] = (byte *)malloc(sizeof(byte)*nvox) ;
for( pp=0 ; pp < nvox ; pp++ ) bbar[bb][pp] = (byte)outar[bb][pp] ;
EDIT_substitute_brick(outset,bb,MRI_byte,bbar[bb]) ;
EDIT_BRICK_FACTOR(outset,bb,0.004f) ;
}
free(bbar) ;
} /* end of do_prob */
free(outar) ;
RETURN(outset) ;
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *xset , *cset, *mset=NULL ;
int nopt=1 , method=PEARSON , do_autoclip=0 ;
int nvox , nvals , ii, jj, kout, kin, polort=1 ;
int ix1,jy1,kz1, ix2, jy2, kz2 ;
char *prefix = "degree_centrality" ;
byte *mask=NULL;
int nmask , abuc=1 ;
int all_source=0; /* output all source voxels 25 Jun 2010 [rickr] */
char str[32] , *cpt ;
int *imap = NULL ; MRI_vectim *xvectim ;
float (*corfun)(int,float *,float*) = NULL ;
/* djc - add 1d file output for similarity matrix */
FILE *fout1D=NULL;
/* CC - we will have two subbricks: binary and weighted centrality */
int nsubbriks = 2;
int subbrik = 0;
float * bodset;
float * wodset;
int nb_ctr = 0;
/* CC - added flags for thresholding correlations */
double thresh = 0.0;
double othresh = 0.0;
int dothresh = 0;
double sparsity = 0.0;
int dosparsity = 0;
/* variables for calculating degree centrality */
long * binaryDC = NULL;
double * weightedDC = NULL;
/* variables for histogram */
hist_node_head* histogram=NULL;
hist_node* hptr=NULL;
hist_node* pptr=NULL;
int bottom_node_idx = 0;
int totNumCor = 0;
long totPosCor = 0;
int ngoal = 0;
int nretain = 0;
float binwidth = 0.0;
int nhistnodes = 50;
/*----*/
AFNI_SETUP_OMP(0) ; /* 24 Jun 2013 */
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"Usage: 3dDegreeCentrality [options] dset\n"
" Computes voxelwise weighted and binary degree centrality and\n"
" stores the result in a new 3D bucket dataset as floats to\n"
" preserve their values. Degree centrality reflects the strength and\n"
" extent of the correlation of a voxel with every other voxel in\n"
" the brain.\n\n"
" Conceptually the process involves: \n"
" 1. Calculating the correlation between voxel time series for\n"
" every pair of voxels in the brain (as determined by masking)\n"
" 2. Applying a threshold to the resulting correlations to exclude\n"
" those that might have arisen by chance, or to sparsify the\n"
" connectivity graph.\n"
" 3. At each voxel, summarizing its correlation with other voxels\n"
" in the brain, by either counting the number of voxels correlated\n"
" with the seed voxel (binary) or by summing the correlation \n"
" coefficients (weighted).\n"
" Practically the algorithm is ordered differently to optimize for\n"
" computational time and memory usage.\n\n"
" The threshold can be supplied as a correlation coefficient, \n"
" or a sparsity threshold. The sparsity threshold reflects the fraction\n"
" of connections that should be retained after the threshold has been\n"
" applied. To minimize resource consumption, using a sparsity threshold\n"
" involves a two-step procedure. In the first step, a correlation\n"
" coefficient threshold is applied to substantially reduce the number\n"
" of correlations. Next, the remaining correlations are sorted and a\n"
" threshold is calculated so that only the specified fraction of \n"
" possible correlations are above threshold. Due to ties between\n"
" correlations, the fraction of correlations that pass the sparsity\n"
" threshold might be slightly more than the number specified.\n\n"
" Regardless of the thresholding procedure employed, negative \n"
" correlations are excluded from the calculations.\n"
"\n"
"Options:\n"
" -pearson = Correlation is the normal Pearson (product moment)\n"
" correlation coefficient [default].\n"
#if 0
" -spearman = Correlation is the Spearman (rank) correlation\n"
" coefficient.\n"
" -quadrant = Correlation is the quadrant correlation coefficient.\n"
#else
" -spearman AND -quadrant are disabled at this time :-(\n"
#endif
"\n"
" -thresh r = exclude correlations <= r from calculations\n"
" -sparsity s = only use top s percent of correlations in calculations\n"
" s should be an integer between 0 and 100. Uses an\n"
" an adaptive thresholding procedure to reduce memory.\n"
" The speed of determining the adaptive threshold can\n"
" be improved by specifying an initial threshold with\n"
" the -thresh flag.\n"
"\n"
" -polort m = Remove polynomical trend of order 'm', for m=-1..3.\n"
" [default is m=1; removal is by least squares].\n"
" Using m=-1 means no detrending; this is only useful\n"
" for data/information that has been pre-processed.\n"
"\n"
" -autoclip = Clip off low-intensity regions in the dataset,\n"
" -automask = so that the correlation is only computed between\n"
" high-intensity (presumably brain) voxels. The\n"
" mask is determined the same way that 3dAutomask works.\n"
"\n"
" -mask mmm = Mask to define 'in-brain' voxels. Reducing the number\n"
" the number of voxels included in the calculation will\n"
" significantly speedup the calculation. Consider using\n"
" a mask to constrain the calculations to the grey matter\n"
" rather than the whole brain. This is also preferrable\n"
" to using -autoclip or -automask.\n"
"\n"
" -prefix p = Save output into dataset with prefix 'p', this file will\n"
" contain bricks for both 'weighted' or 'degree' centrality\n"
" [default prefix is 'deg_centrality'].\n"
"\n"
" -out1D f = Save information about the above threshold correlations to\n"
" 1D file 'f'. Each row of this file will contain:\n"
" Voxel1 Voxel2 i1 j1 k1 i2 j2 k2 Corr\n"
" Where voxel1 and voxel2 are the 1D indices of the pair of\n"
" voxels, i j k correspond to their 3D coordinates, and Corr\n"
" is the value of the correlation between the voxel time courses.\n"
"\n"
"Notes:\n"
" * The output dataset is a bucket type of floats.\n"
" * The program prints out an estimate of its memory used\n"
" when it ends. It also prints out a progress 'meter'\n"
" to keep you pacified.\n"
"\n"
"-- RWCox - 31 Jan 2002 and 16 Jul 2010\n"
"-- Cameron Craddock - 26 Sept 2015 \n"
) ;
PRINT_AFNI_OMP_USAGE("3dDegreeCentrality",NULL) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
mainENTRY("3dDegreeCentrality main"); machdep(); PRINT_VERSION("3dDegreeCentrality");
AFNI_logger("3dDegreeCentrality",argc,argv);
/*-- option processing --*/
while( nopt < argc && argv[nopt][0] == '-' ){
if( strcmp(argv[nopt],"-time") == 0 ){
abuc = 0 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-autoclip") == 0 ||
strcmp(argv[nopt],"-automask") == 0 ){
do_autoclip = 1 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mask") == 0 ){
mset = THD_open_dataset(argv[++nopt]);
CHECK_OPEN_ERROR(mset,argv[nopt]);
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-pearson") == 0 ){
method = PEARSON ; nopt++ ; continue ;
}
#if 0
if( strcmp(argv[nopt],"-spearman") == 0 ){
method = SPEARMAN ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-quadrant") == 0 ){
method = QUADRANT ; nopt++ ; continue ;
}
#endif
if( strcmp(argv[nopt],"-eta2") == 0 ){
method = ETA2 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-prefix") == 0 ){
prefix = strdup(argv[++nopt]) ;
if( !THD_filename_ok(prefix) ){
ERROR_exit("Illegal value after -prefix!") ;
}
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-thresh") == 0 ){
double val = (double)strtod(argv[++nopt],&cpt) ;
if( *cpt != '\0' || val >= 1.0 || val < 0.0 ){
ERROR_exit("Illegal value (%f) after -thresh!", val) ;
}
dothresh = 1;
thresh = val ; othresh = val ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-sparsity") == 0 ){
double val = (double)strtod(argv[++nopt],&cpt) ;
if( *cpt != '\0' || val > 100 || val <= 0 ){
ERROR_exit("Illegal value (%f) after -sparsity!", val) ;
}
if( val > 5.0 )
{
WARNING_message("Sparsity %3.2f%% is large and will require alot of memory and time, consider using a smaller value. ", val);
}
dosparsity = 1 ;
sparsity = val ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-polort") == 0 ){
int val = (int)strtod(argv[++nopt],&cpt) ;
if( *cpt != '\0' || val < -1 || val > 3 ){
ERROR_exit("Illegal value after -polort!") ;
}
polort = val ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mem_stat") == 0 ){
MEM_STAT = 1 ; nopt++ ; continue ;
}
if( strncmp(argv[nopt],"-mem_profile",8) == 0 ){
MEM_PROF = 1 ; nopt++ ; continue ;
}
/* check for 1d argument */
if ( strcmp(argv[nopt],"-out1D") == 0 ){
if (!(fout1D = fopen(argv[++nopt], "w"))) {
ERROR_message("Failed to open %s for writing", argv[nopt]);
exit(1);
}
nopt++ ; continue ;
}
ERROR_exit("Illegal option: %s",argv[nopt]) ;
}
/*-- open dataset, check for legality --*/
if( nopt >= argc ) ERROR_exit("Need a dataset on command line!?") ;
xset = THD_open_dataset(argv[nopt]); CHECK_OPEN_ERROR(xset,argv[nopt]);
if( DSET_NVALS(xset) < 3 )
ERROR_exit("Input dataset %s does not have 3 or more sub-bricks!",argv[nopt]) ;
DSET_load(xset) ; CHECK_LOAD_ERROR(xset) ;
/*-- compute mask array, if desired --*/
nvox = DSET_NVOX(xset) ; nvals = DSET_NVALS(xset) ;
INC_MEM_STATS((nvox * nvals * sizeof(double)), "input dset");
PRINT_MEM_STATS("inset");
/* if a mask was specified make sure it is appropriate */
if( mset ){
if( DSET_NVOX(mset) != nvox )
ERROR_exit("Input and mask dataset differ in number of voxels!") ;
mask = THD_makemask(mset, 0, 1.0, 0.0) ;
/* update running memory statistics to reflect loading the image */
INC_MEM_STATS( mset->dblk->total_bytes, "mask dset" );
PRINT_MEM_STATS( "mset load" );
nmask = THD_countmask( nvox , mask ) ;
INC_MEM_STATS( nmask * sizeof(byte), "mask array" );
PRINT_MEM_STATS( "mask" );
INFO_message("%d voxels in -mask dataset",nmask) ;
if( nmask < 2 ) ERROR_exit("Only %d voxels in -mask, exiting...",nmask);
/* update running memory statistics to reflect loading the image */
DEC_MEM_STATS( mset->dblk->total_bytes, "mask dset" );
DSET_unload(mset) ;
PRINT_MEM_STATS( "mset unload" );
}
/* if automasking is requested, handle that now */
else if( do_autoclip ){
mask = THD_automask( xset ) ;
nmask = THD_countmask( nvox , mask ) ;
INFO_message("%d voxels survive -autoclip",nmask) ;
if( nmask < 2 ) ERROR_exit("Only %d voxels in -automask!",nmask);
}
/* otherwise we use all of the voxels in the image */
else {
nmask = nvox ;
INFO_message("computing for all %d voxels",nmask) ;
}
if( method == ETA2 && polort >= 0 )
WARNING_message("Polort for -eta2 should probably be -1...");
/* djc - 1d file out init */
if (fout1D != NULL) {
/* define affine matrix */
mat44 affine_mat = xset->daxes->ijk_to_dicom;
/* print command line statement */
fprintf(fout1D,"#Similarity matrix from command:\n#");
for(ii=0; ii<argc; ++ii) fprintf(fout1D,"%s ", argv[ii]);
/* Print affine matrix */
fprintf(fout1D,"\n");
fprintf(fout1D,"#[ ");
int mi, mj;
for(mi = 0; mi < 4; mi++) {
for(mj = 0; mj < 4; mj++) {
fprintf(fout1D, "%.6f ", affine_mat.m[mi][mj]);
}
}
fprintf(fout1D, "]\n");
/* Print image extents*/
THD_dataxes *xset_daxes = xset->daxes;
fprintf(fout1D, "#Image dimensions:\n");
fprintf(fout1D, "#[%d, %d, %d]\n",
xset_daxes->nxx, xset_daxes->nyy, xset_daxes->nzz);
/* Similarity matrix headers */
fprintf(fout1D,"#Voxel1 Voxel2 i1 j1 k1 i2 j2 k2 Corr\n");
}
/* CC calculate the total number of possible correlations, will be
usefule down the road */
totPosCor = (.5*((float)nmask))*((float)(nmask-1));
/** For the case of Pearson correlation, we make sure the **/
/** data time series have their mean removed (polort >= 0) **/
/** and are normalized, so that correlation = dot product, **/
/** and we can use function zm_THD_pearson_corr for speed. **/
switch( method ){
default:
case PEARSON: corfun = zm_THD_pearson_corr ; break ;
case ETA2: corfun = my_THD_eta_squared ; break ;
}
/*-- create vectim from input dataset --*/
INFO_message("vectim-izing input dataset") ;
/*-- CC added in mask to reduce the size of xvectim -- */
xvectim = THD_dset_to_vectim( xset , mask , 0 ) ;
if( xvectim == NULL ) ERROR_exit("Can't create vectim?!") ;
/*-- CC update our memory stats to reflect vectim -- */
INC_MEM_STATS((xvectim->nvec*sizeof(int)) +
((xvectim->nvec)*(xvectim->nvals))*sizeof(float) +
sizeof(MRI_vectim), "vectim");
PRINT_MEM_STATS( "vectim" );
/*--- CC the vectim contains a mapping between voxel index and mask index,
tap into that here to avoid duplicating memory usage ---*/
if( mask != NULL )
{
imap = xvectim->ivec;
/* --- CC free the mask */
DEC_MEM_STATS( nmask*sizeof(byte), "mask array" );
free(mask); mask=NULL;
PRINT_MEM_STATS( "mask unload" );
}
/* -- CC unloading the dataset to reduce memory usage ?? -- */
DEC_MEM_STATS((DSET_NVOX(xset) * DSET_NVALS(xset) * sizeof(double)), "input dset");
DSET_unload(xset) ;
PRINT_MEM_STATS("inset unload");
/* -- CC configure detrending --*/
if( polort < 0 && method == PEARSON ){
polort = 0; WARNING_message("Pearson correlation always uses polort >= 0");
}
if( polort >= 0 ){
for( ii=0 ; ii < xvectim->nvec ; ii++ ){ /* remove polynomial trend */
DETREND_polort(polort,nvals,VECTIM_PTR(xvectim,ii)) ;
}
}
/* -- this procedure does not change time series that have zero variance -- */
if( method == PEARSON ) THD_vectim_normalize(xvectim) ; /* L2 norm = 1 */
/* -- CC create arrays to hold degree and weighted centrality while
they are being calculated -- */
if( dosparsity == 0 )
{
if( ( binaryDC = (long*)calloc( nmask, sizeof(long) )) == NULL )
{
ERROR_message( "Could not allocate %d byte array for binary DC calculation\n",
nmask*sizeof(long));
}
/* -- update running memory estimate to reflect memory allocation */
INC_MEM_STATS( nmask*sizeof(long), "binary DC array" );
PRINT_MEM_STATS( "binaryDC" );
if( ( weightedDC = (double*)calloc( nmask, sizeof(double) )) == NULL )
{
if (binaryDC){ free(binaryDC); binaryDC = NULL; }
ERROR_message( "Could not allocate %d byte array for weighted DC calculation\n",
nmask*sizeof(double));
}
/* -- update running memory estimate to reflect memory allocation */
INC_MEM_STATS( nmask*sizeof(double), "weighted DC array" );
PRINT_MEM_STATS( "weightedDC" );
}
/* -- CC if we are using a sparsity threshold, build a histogram to calculate the
threshold */
if (dosparsity == 1)
{
/* make sure that there is a bin for correlation values that == 1.0 */
binwidth = (1.005-thresh)/nhistnodes;
/* calculate the number of correlations we wish to retain */
ngoal = nretain = (int)(((double)totPosCor)*((double)sparsity) / 100.0);
/* allocate memory for the histogram bins */
if(( histogram = (hist_node_head*)malloc(nhistnodes*sizeof(hist_node_head))) == NULL )
{
/* if the allocation fails, free all memory and exit */
if (binaryDC){ free(binaryDC); binaryDC = NULL; }
if (weightedDC){ free(weightedDC); weightedDC = NULL; }
ERROR_message( "Could not allocate %d byte array for histogram\n",
nhistnodes*sizeof(hist_node_head));
}
else {
/* -- update running memory estimate to reflect memory allocation */
INC_MEM_STATS( nhistnodes*sizeof(hist_node_head), "hist bins" );
PRINT_MEM_STATS( "hist1" );
}
/* initialize history bins */
for( kout = 0; kout < nhistnodes; kout++ )
{
histogram[ kout ].bin_low = thresh+kout*binwidth;
histogram[ kout ].bin_high = histogram[ kout ].bin_low+binwidth;
histogram[ kout ].nbin = 0;
histogram[ kout ].nodes = NULL;
/*INFO_message("Hist bin %d [%3.3f, %3.3f) [%d, %p]\n",
kout, histogram[ kout ].bin_low, histogram[ kout ].bin_high,
histogram[ kout ].nbin, histogram[ kout ].nodes );*/
}
}
/*-- tell the user what we are about to do --*/
if (dosparsity == 0 )
{
INFO_message( "Calculating degree centrality with threshold = %f.\n", thresh);
}
else
{
INFO_message( "Calculating degree centrality with threshold = %f and sparsity = %3.2f%% (%d)\n",
thresh, sparsity, nretain);
}
/*---------- loop over mask voxels, correlate ----------*/
AFNI_OMP_START ;
#pragma omp parallel if( nmask > 999 )
{
int lii,ljj,lin,lout,ithr,nthr,vstep,vii ;
float *xsar , *ysar ;
hist_node* new_node = NULL ;
hist_node* tptr = NULL ;
hist_node* rptr = NULL ;
int new_node_idx = 0;
double car = 0.0 ;
/*-- get information about who we are --*/
#ifdef USE_OMP
ithr = omp_get_thread_num() ;
nthr = omp_get_num_threads() ;
if( ithr == 0 ) INFO_message("%d OpenMP threads started",nthr) ;
#else
ithr = 0 ; nthr = 1 ;
#endif
/*-- For the progress tracker, we want to print out 50 numbers,
figure out a number of loop iterations that will make this easy */
vstep = (int)( nmask / (nthr*50.0f) + 0.901f ) ; vii = 0 ;
if((MEM_STAT==0) && (ithr == 0 )) fprintf(stderr,"Looping:") ;
#pragma omp for schedule(static, 1)
for( lout=0 ; lout < xvectim->nvec ; lout++ ){ /*----- outer voxel loop -----*/
if( ithr == 0 && vstep > 2 ) /* allow small dsets 16 Jun 2011 [rickr] */
{ vii++ ; if( vii%vstep == vstep/2 && MEM_STAT == 0 ) vstep_print(); }
/* get ref time series from this voxel */
xsar = VECTIM_PTR(xvectim,lout) ;
/* try to make calculation more efficient by only calculating the unique
correlations */
for( lin=(lout+1) ; lin < xvectim->nvec ; lin++ ){ /*----- inner loop over voxels -----*/
/* extract the voxel time series */
ysar = VECTIM_PTR(xvectim,lin) ;
/* now correlate the time series */
car = (double)(corfun(nvals,xsar,ysar)) ;
if ( car <= thresh )
{
continue ;
}
/* update degree centrality values, hopefully the pragma
will handle mutual exclusion */
#pragma omp critical(dataupdate)
{
/* if the correlation is less than threshold, ignore it */
if ( car > thresh )
{
totNumCor += 1;
if ( dosparsity == 0 )
{
binaryDC[lout] += 1; binaryDC[lin] += 1;
weightedDC[lout] += car; weightedDC[lin] += car;
/* print correlation out to the 1D file */
if ( fout1D != NULL )
{
/* determine the i,j,k coords */
ix1 = DSET_index_to_ix(xset,lii) ;
jy1 = DSET_index_to_jy(xset,lii) ;
kz1 = DSET_index_to_kz(xset,lii) ;
ix2 = DSET_index_to_ix(xset,ljj) ;
jy2 = DSET_index_to_jy(xset,ljj) ;
kz2 = DSET_index_to_kz(xset,ljj) ;
/* add source, dest, correlation to 1D file */
fprintf(fout1D, "%d %d %d %d %d %d %d %d %.6f\n",
lii, ljj, ix1, jy1, kz1, ix2, jy2, kz2, car);
}
}
else
{
/* determine the index in the histogram to add the node */
new_node_idx = (int)floor((double)(car-othresh)/(double)binwidth);
if ((new_node_idx > nhistnodes) || (new_node_idx < bottom_node_idx))
{
/* this error should indicate a programming error and should not happen */
WARNING_message("Node index %d is out of range [%d,%d)!",new_node_idx,
bottom_node_idx, nhistnodes);
}
else
{
/* create a node to add to the histogram */
new_node = (hist_node*)calloc(1,sizeof(hist_node));
if( new_node == NULL )
{
/* allocate memory for this node, rather than fiddling with
error handling here, lets just move on */
WARNING_message("Could not allocate a new node!");
}
else
{
/* populate histogram node */
new_node->i = lout;
new_node->j = lin;
new_node->corr = car;
new_node->next = NULL;
/* -- update running memory estimate to reflect memory allocation */
INC_MEM_STATS( sizeof(hist_node), "hist nodes" );
if ((totNumCor % (1024*1024)) == 0) PRINT_MEM_STATS( "hist nodes" );
/* populate histogram */
new_node->next = histogram[new_node_idx].nodes;
histogram[new_node_idx].nodes = new_node;
histogram[new_node_idx].nbin++;
/* see if there are enough correlations in the histogram
for the sparsity */
if ((totNumCor - histogram[bottom_node_idx].nbin) > nretain)
{
/* delete the list of nodes */
rptr = histogram[bottom_node_idx].nodes;
while(rptr != NULL)
{
tptr = rptr;
rptr = rptr->next;
/* check that the ptr is not null before freeing it*/
if(tptr!= NULL)
{
DEC_MEM_STATS( sizeof(hist_node), "hist nodes" );
free(tptr);
}
}
PRINT_MEM_STATS( "unloaded hist nodes - thresh increase" );
histogram[bottom_node_idx].nodes = NULL;
totNumCor -= histogram[bottom_node_idx].nbin;
histogram[bottom_node_idx].nbin=0;
/* get the new threshold */
thresh = (double)histogram[++bottom_node_idx].bin_low;
if(MEM_STAT == 1) INFO_message("Increasing threshold to %3.2f (%d)\n",
thresh,bottom_node_idx);
}
} /* else, newptr != NULL */
} /* else, new_node_idx in range */
} /* else, do_sparsity == 1 */
} /* car > thresh */
} /* this is the end of the critical section */
} /* end of inner loop over voxels */
} /* end of outer loop over ref voxels */
if( ithr == 0 ) fprintf(stderr,".\n") ;
} /* end OpenMP */
AFNI_OMP_END ;
/* update the user so that they know what we are up to */
INFO_message ("AFNI_OMP finished\n");
INFO_message ("Found %d (%3.2f%%) correlations above threshold (%f)\n",
totNumCor, 100.0*((float)totNumCor)/((float)totPosCor), thresh);
/*---------- Finish up ---------*/
/*if( dosparsity == 1 )
{
for( kout = 0; kout < nhistnodes; kout++ )
{
INFO_message("Hist bin %d [%3.3f, %3.3f) [%d, %p]\n",
kout, histogram[ kout ].bin_low, histogram[ kout ].bin_high,
histogram[ kout ].nbin, histogram[ kout ].nodes );
}
}*/
/*-- create output dataset --*/
cset = EDIT_empty_copy( xset ) ;
/*-- configure the output dataset */
if( abuc ){
EDIT_dset_items( cset ,
ADN_prefix , prefix ,
ADN_nvals , nsubbriks , /* 2 subbricks, degree and weighted centrality */
ADN_ntt , 0 , /* no time axis */
ADN_type , HEAD_ANAT_TYPE ,
ADN_func_type , ANAT_BUCK_TYPE ,
ADN_datum_all , MRI_float ,
ADN_none ) ;
} else {
EDIT_dset_items( cset ,
ADN_prefix , prefix ,
ADN_nvals , nsubbriks , /* 2 subbricks, degree and weighted centrality */
ADN_ntt , nsubbriks , /* num times */
ADN_ttdel , 1.0 , /* fake TR */
ADN_nsl , 0 , /* no slice offsets */
ADN_type , HEAD_ANAT_TYPE ,
ADN_func_type , ANAT_EPI_TYPE ,
ADN_datum_all , MRI_float ,
ADN_none ) ;
}
/* add history information to the hearder */
tross_Make_History( "3dDegreeCentrality" , argc,argv , cset ) ;
ININFO_message("creating output dataset in memory") ;
/* -- Configure the subbriks: Binary Degree Centrality */
subbrik = 0;
EDIT_BRICK_TO_NOSTAT(cset,subbrik) ; /* stat params */
/* CC this sets the subbrik scaling factor, which we will probably want
to do again after we calculate the voxel values */
EDIT_BRICK_FACTOR(cset,subbrik,1.0) ; /* scale factor */
sprintf(str,"Binary Degree Centrality") ;
EDIT_BRICK_LABEL(cset,subbrik,str) ;
EDIT_substitute_brick(cset,subbrik,MRI_float,NULL) ; /* make array */
/* copy measure data into the subbrik */
bodset = DSET_ARRAY(cset,subbrik);
/* -- Configure the subbriks: Weighted Degree Centrality */
subbrik = 1;
EDIT_BRICK_TO_NOSTAT(cset,subbrik) ; /* stat params */
/* CC this sets the subbrik scaling factor, which we will probably want
to do again after we calculate the voxel values */
EDIT_BRICK_FACTOR(cset,subbrik,1.0) ; /* scale factor */
sprintf(str,"Weighted Degree Centrality") ;
EDIT_BRICK_LABEL(cset,subbrik,str) ;
EDIT_substitute_brick(cset,subbrik,MRI_float,NULL) ; /* make array */
/* copy measure data into the subbrik */
wodset = DSET_ARRAY(cset,subbrik);
/* increment memory stats */
INC_MEM_STATS( (DSET_NVOX(cset)*DSET_NVALS(cset)*sizeof(float)), "output dset");
PRINT_MEM_STATS( "outset" );
/* pull the values out of the histogram */
if( dosparsity == 0 )
{
for( kout = 0; kout < nmask; kout++ )
{
if ( imap != NULL )
{
ii = imap[kout] ; /* ii= source voxel (we know that ii is in the mask) */
}
else
{
ii = kout ;
}
if( ii >= DSET_NVOX(cset) )
{
WARNING_message("Avoiding bodset, wodset overflow %d > %d (%s,%d)\n",
ii,DSET_NVOX(cset),__FILE__,__LINE__ );
}
else
{
bodset[ ii ] = (float)(binaryDC[kout]);
wodset[ ii ] = (float)(weightedDC[kout]);
}
}
/* we are done with this memory, and can kill it now*/
if(binaryDC)
{
free(binaryDC);
binaryDC=NULL;
/* -- update running memory estimate to reflect memory allocation */
DEC_MEM_STATS( nmask*sizeof(long), "binary DC array" );
PRINT_MEM_STATS( "binaryDC" );
}
if(weightedDC)
{
free(weightedDC);
weightedDC=NULL;
/* -- update running memory estimate to reflect memory allocation */
DEC_MEM_STATS( nmask*sizeof(double), "weighted DC array" );
PRINT_MEM_STATS( "weightedDC" );
}
}
else
{
/* add in the values from the histogram, this is a two stage procedure:
at first we add in values a whole bin at the time until we get to a point
where we need to add in a partial bin, then we create a new histogram
to sort the values in the bin and then add those bins at a time */
kout = nhistnodes - 1;
while (( histogram[kout].nbin < nretain ) && ( kout >= 0 ))
{
hptr = pptr = histogram[kout].nodes;
while( hptr != NULL )
{
/* determine the indices corresponding to this node */
if ( imap != NULL )
{
ii = imap[hptr->i] ; /* ii= source voxel (we know that ii is in the mask) */
}
else
{
ii = hptr->i ;
}
if ( imap != NULL )
{
jj = imap[hptr->j] ; /* ii= source voxel (we know that ii is in the mask) */
}
else
{
jj = hptr->j ;
}
/* add in the values */
if(( ii >= DSET_NVOX(cset) ) || ( jj >= DSET_NVOX(cset)))
{
if( ii >= DSET_NVOX(cset))
{
WARNING_message("Avoiding bodset, wodset overflow (ii) %d > %d\n (%s,%d)\n",
ii,DSET_NVOX(cset),__FILE__,__LINE__ );
}
if( jj >= DSET_NVOX(cset))
{
WARNING_message("Avoiding bodset, wodset overflow (jj) %d > %d\n (%s,%d)\n",
jj,DSET_NVOX(cset),__FILE__,__LINE__ );
}
}
else
{
bodset[ ii ] += 1.0 ;
wodset[ ii ] += (float)(hptr->corr);
bodset[ jj ] += 1.0 ;
wodset[ jj ] += (float)(hptr->corr);
}
if( fout1D != NULL )
{
/* add source, dest, correlation to 1D file */
ix1 = DSET_index_to_ix(cset,ii) ;
jy1 = DSET_index_to_jy(cset,ii) ;
kz1 = DSET_index_to_kz(cset,ii) ;
ix2 = DSET_index_to_ix(cset,jj) ;
jy2 = DSET_index_to_jy(cset,jj) ;
kz2 = DSET_index_to_kz(cset,jj) ;
fprintf(fout1D, "%d %d %d %d %d %d %d %d %.6f\n",
ii, jj, ix1, jy1, kz1, ix2, jy2, kz2, (float)(hptr->corr));
}
/* increment node pointers */
pptr = hptr;
hptr = hptr->next;
/* delete the node */
if(pptr)
{
/* -- update running memory estimate to reflect memory allocation */
DEC_MEM_STATS(sizeof( hist_node ), "hist nodes" );
/* free the mem */
free(pptr);
pptr=NULL;
}
}
/* decrement the number of correlations we wish to retain */
nretain -= histogram[kout].nbin;
histogram[kout].nodes = NULL;
/* go on to the next bin */
kout--;
}
PRINT_MEM_STATS( "hist1 bins free - inc into output" );
/* if we haven't used all of the correlations that are available, go through and
add a subset of the voxels from the remaining bin */
if(( nretain > 0 ) && (kout >= 0))
{
hist_node_head* histogram2 = NULL;
hist_node_head* histogram2_save = NULL;
int h2nbins = 100;
float h2binwidth = 0.0;
int h2ndx=0;
h2binwidth = (((1.0+binwidth/((float)h2nbins))*histogram[kout].bin_high) - histogram[kout].bin_low) /
((float)h2nbins);
/* allocate the bins */
if(( histogram2 = (hist_node_head*)malloc(h2nbins*sizeof(hist_node_head))) == NULL )
{
if (binaryDC){ free(binaryDC); binaryDC = NULL; }
if (weightedDC){ free(weightedDC); weightedDC = NULL; }
if (histogram){ histogram = free_histogram(histogram, nhistnodes); }
ERROR_message( "Could not allocate %d byte array for histogram2\n",
h2nbins*sizeof(hist_node_head));
}
else {
/* -- update running memory estimate to reflect memory allocation */
histogram2_save = histogram2;
INC_MEM_STATS(( h2nbins*sizeof(hist_node_head )), "hist bins");
PRINT_MEM_STATS( "hist2" );
}
/* initiatize the bins */
for( kin = 0; kin < h2nbins; kin++ )
{
histogram2[ kin ].bin_low = histogram[kout].bin_low + kin*h2binwidth;
histogram2[ kin ].bin_high = histogram2[ kin ].bin_low + h2binwidth;
histogram2[ kin ].nbin = 0;
histogram2[ kin ].nodes = NULL;
/*INFO_message("Hist2 bin %d [%3.3f, %3.3f) [%d, %p]\n",
kin, histogram2[ kin ].bin_low, histogram2[ kin ].bin_high,
histogram2[ kin ].nbin, histogram2[ kin ].nodes );*/
}
/* move correlations from histogram to histgram2 */
INFO_message ("Adding %d nodes from histogram to histogram2",histogram[kout].nbin);
while ( histogram[kout].nodes != NULL )
{
hptr = histogram[kout].nodes;
h2ndx = (int)floor((double)(hptr->corr - histogram[kout].bin_low)/(double)h2binwidth);
if(( h2ndx < h2nbins ) && ( h2ndx >= 0 ))
{
histogram[kout].nodes = hptr->next;
hptr->next = histogram2[h2ndx].nodes;
histogram2[h2ndx].nodes = hptr;
histogram2[h2ndx].nbin++;
histogram[kout].nbin--;
}
else
{
WARNING_message("h2ndx %d is not in range [0,%d) :: %.10f,%.10f\n",h2ndx,h2nbins,hptr->corr, histogram[kout].bin_low);
}
}
/* free the remainder of histogram */
{
int nbins_rem = 0;
for(ii = 0; ii < nhistnodes; ii++) nbins_rem+=histogram[ii].nbin;
histogram = free_histogram(histogram, nhistnodes);
PRINT_MEM_STATS( "free remainder of histogram1" );
}
kin = h2nbins - 1;
while (( nretain > 0 ) && ( kin >= 0 ))
{
hptr = pptr = histogram2[kin].nodes;
while( hptr != NULL )
{
/* determine the indices corresponding to this node */
if ( imap != NULL )
{
ii = imap[hptr->i] ;
}
else
{
ii = hptr->i ;
}
if ( imap != NULL )
{
jj = imap[hptr->j] ;
}
else
{
jj = hptr->j ;
}
/* add in the values */
if(( ii >= DSET_NVOX(cset) ) || ( jj >= DSET_NVOX(cset)))
{
if( ii >= DSET_NVOX(cset))
{
WARNING_message("Avoiding bodset, wodset overflow (ii) %d > %d\n (%s,%d)\n",
ii,DSET_NVOX(cset),__FILE__,__LINE__ );
}
if( jj >= DSET_NVOX(cset))
{
WARNING_message("Avoiding bodset, wodset overflow (jj) %d > %d\n (%s,%d)\n",
jj,DSET_NVOX(cset),__FILE__,__LINE__ );
}
}
else
{
bodset[ ii ] += 1.0 ;
wodset[ ii ] += (float)(hptr->corr);
bodset[ jj ] += 1.0 ;
wodset[ jj ] += (float)(hptr->corr);
}
if( fout1D != NULL )
{
/* add source, dest, correlation to 1D file */
ix1 = DSET_index_to_ix(cset,ii) ;
jy1 = DSET_index_to_jy(cset,ii) ;
kz1 = DSET_index_to_kz(cset,ii) ;
ix2 = DSET_index_to_ix(cset,jj) ;
jy2 = DSET_index_to_jy(cset,jj) ;
kz2 = DSET_index_to_kz(cset,jj) ;
fprintf(fout1D, "%d %d %d %d %d %d %d %d %.6f\n",
ii, jj, ix1, jy1, kz1, ix2, jy2, kz2, (float)(hptr->corr));
}
/* increment node pointers */
pptr = hptr;
hptr = hptr->next;
/* delete the node */
if(pptr)
{
free(pptr);
DEC_MEM_STATS(( sizeof(hist_node) ), "hist nodes");
pptr=NULL;
}
}
/* decrement the number of correlations we wish to retain */
nretain -= histogram2[kin].nbin;
histogram2[kin].nodes = NULL;
/* go on to the next bin */
kin--;
}
PRINT_MEM_STATS("hist2 nodes free - incorporated into output");
/* we are finished with histogram2 */
{
histogram2 = free_histogram(histogram2, h2nbins);
/* -- update running memory estimate to reflect memory allocation */
PRINT_MEM_STATS( "free hist2" );
}
if (nretain < 0 )
{
WARNING_message( "Went over sparsity goal %d by %d, with a resolution of %f",
ngoal, -1*nretain, h2binwidth);
}
}
if (nretain > 0 )
{
WARNING_message( "Was not able to meet goal of %d (%3.2f%%) correlations, %d (%3.2f%%) correlations passed the threshold of %3.2f, maybe you need to change the threshold or the desired sparsity?",
ngoal, 100.0*((float)ngoal)/((float)totPosCor), totNumCor, 100.0*((float)totNumCor)/((float)totPosCor), thresh);
}
}
INFO_message("Done..\n") ;
/* update running memory statistics to reflect freeing the vectim */
DEC_MEM_STATS(((xvectim->nvec*sizeof(int)) +
((xvectim->nvec)*(xvectim->nvals))*sizeof(float) +
sizeof(MRI_vectim)), "vectim");
/* toss some trash */
VECTIM_destroy(xvectim) ;
DSET_delete(xset) ;
if(fout1D!=NULL)fclose(fout1D);
PRINT_MEM_STATS( "vectim unload" );
if (weightedDC) free(weightedDC) ; weightedDC = NULL;
if (binaryDC) free(binaryDC) ; binaryDC = NULL;
/* finito */
INFO_message("Writing output dataset to disk [%s bytes]",
commaized_integer_string(cset->dblk->total_bytes)) ;
/* write the dataset */
DSET_write(cset) ;
WROTE_DSET(cset) ;
/* increment our memory stats, since we are relying on the header for this
information, we update the stats before actually freeing the memory */
DEC_MEM_STATS( (DSET_NVOX(cset)*DSET_NVALS(cset)*sizeof(float)), "output dset");
/* free up the output dataset memory */
DSET_unload(cset) ;
DSET_delete(cset) ;
/* force a print */
MEM_STAT = 1;
PRINT_MEM_STATS( "Fin" );
exit(0) ;
}
int main( int argc , char *argv[] )
{
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) ;
}
THD_3dim_dataset * THD_deghoster( THD_3dim_dataset *inset ,
THD_3dim_dataset *filset,
int pe , int fe , int se )
{
MRI_IMAGE *medim=NULL , *tim=NULL , *oim=NULL ;
float cval, *mar=NULL , *tar=NULL , *oar=NULL ;
float *xzero_t=NULL , *thet1_t=NULL , *dparr_t=NULL , t1med,t1bmv;
byte *bmask=NULL , *amask=NULL , sm ;
int nvox , nx,ny,nz , dp=0,df=0,ds=0 , np=0,nf=0,ns=0,np2,nf2 ;
int pp,ff,ss,nfp , ii , ppg , nsm,ism , vv,nv , iim , sskip ;
THD_3dim_dataset *outset=NULL ;
float iy,iyn ;
float_pair mp ;
/* create brain mask (bmask) */
medim = THD_median_brick(inset) ;
bmask = DEG_automask_image(medim) ; /* brain mask (we hope) */
nx = medim->nx ;
ny = medim->ny ;
nz = medim->nz ;
nvox = medim->nvox ;
nv = DSET_NVALS(inset) ;
/* estimate noise level from data outside the mask (crudely) */
mar = MRI_FLOAT_PTR(medim) ;
cval = THD_cliplevel(medim,CLFRAC) ;
for( noise_estimate=0.0f,iim=ii=0 ; ii < nvox ; ii++ ) {
if( !bmask[ii] && mar[ii] < cval ) {
noise_estimate += mar[ii] ;
iim++ ;
}
}
if( iim < 9 ) {
FREEUP; /* should not happen */
return NULL;
}
noise_estimate /= iim ; /* initial estimate of noise level */
if( verb > 1 )
INFO_message("Global crude noise_estimate = %g",noise_estimate) ;
/* chop out all sub-threshold voxels (amask) */
amask = (byte *)malloc(sizeof(byte)*nvox) ; /* clipped brain mask */
memcpy(amask,bmask,sizeof(byte)*nvox) ;
for( ii=0 ; ii < nvox ; ii++ )
if( amask[ii] && mar[ii] < cval ) amask[ii] = 0 ;
/* setting up slice coordinates f,p,s */
if( pe == 1 ) {
dp = 1 ;
np = nx ;
}
else if( pe == 2 ) {
dp = nx ;
np = ny ;
}
else if( pe == 3 ) {
dp = nx*ny ;
np = ns ;
}
if( fe == 1 ) {
df = 1 ;
nf = nx ;
}
else if( fe == 2 ) {
df = nx ;
nf = ny ;
}
else if( fe == 3 ) {
df = nx*ny ;
nf = nz ;
}
if( se == 1 ) {
ds = 1 ;
ns = nx ;
}
else if( se == 2 ) {
ds = nx ;
ns = ny ;
}
else if( se == 3 ) {
ds = nx*ny ;
ns = nz ;
}
#undef IJK
#define IJK(f,p,s) ((f)*df+(p)*dp+(s)*ds)
nvim = nfp = nf * np ;
np2 = np / 2 ;
nf2 = nf / 2 ;
smask = (byte * )malloc(sizeof(byte) *nfp) ;
bvec = (float *)malloc(sizeof(float)*nfp) ;
gvec = (float *)malloc(sizeof(float)*nfp) ;
xvec = (float *)malloc(sizeof(float)*nfp) ;
yvec = (float *)malloc(sizeof(float)*nfp) ;
ctvec = (float *)malloc(sizeof(float)*nfp) ;
stvec = (float *)malloc(sizeof(float)*nfp) ;
bvim = (float *)malloc(sizeof(float)*nvim) ;
gvim = (float *)malloc(sizeof(float)*nvim) ;
xvim = (float *)malloc(sizeof(float)*nvim) ;
yvim = (float *)malloc(sizeof(float)*nvim) ;
ctvim = (float *)malloc(sizeof(float)*nvim) ;
stvim = (float *)malloc(sizeof(float)*nvim) ;
xzero_t = (float *)malloc(sizeof(float)*nv) ;
thet1_t = (float *)malloc(sizeof(float)*nv) ;
dparr_t = (float *)malloc(sizeof(float)*nv) ;
/* copy input to output (will be ghost edited later) */
outset = EDIT_empty_copy(inset) ;
for( vv=0 ; vv < nv ; vv++ ) {
oim = THD_extract_float_brick(vv,inset) ;
oar = MRI_FLOAT_PTR(oim) ;
EDIT_BRICK_FACTOR( outset , vv , 0.0f ) ;
EDIT_substitute_brick( outset , vv , MRI_float , oar ) ;
mri_clear_and_free(oim) ;
}
/* loop over slices */
for( ss=0 ; ss < ns ; ss++ ) {
/* make copy of brain mask in this slice,
then edit it down to voxels in the brain
whose N/2 point is outside the brain (smask) */
for( iim=nsm=pp=0 ; pp < np ; pp++ ) {
if( pp >= np2 ) ppg = pp-np2 ;
else ppg = pp+np2 ;
for( ff=0 ; ff < nf ; ff++,iim++ ) {
smask[iim] = sm = amask[IJK(ff,pp,ss)] && !bmask[IJK(ff,ppg,ss)] ;
xvim[iim] = ff-nf2 ;
yvim[iim] = pp-np2 ;
if( sm ) {
xvec[nsm] = xvim[iim];
yvec[nsm] = yvim[iim];
nsm++;
}
}
}
if( nsm < nfp/20 ) { /* skip this slice */
if( verb )
INFO_message("deghost: skipping slice #%d -- too few points in smask",ss) ;
continue ;
}
nvec = nsm ;
if( verb )
INFO_message("deghost: processing slice #%d",ss) ;
/* smask is now the mask of brain voxels whose
Nyquist ghost locations are NOT in the brain mask */
/* loop over time points, estimate the ghost correction parameters */
for( vv=0 ; vv < nv ; vv++ ) {
tim = THD_extract_float_brick(vv,filset) ;
tar = MRI_FLOAT_PTR(tim) ;
/* extract the vector of image values in smask,
and the vector of image values at the ghost locations */
for( iim=ism=pp=0 ; pp < np ; pp++ ) {
if( pp >= np2 ) ppg = pp-np2 ;
else ppg = pp+np2 ;
for( ff=0 ; ff < nf ; ff++,iim++ ) {
bvim[iim] = tar[IJK(ff,pp,ss)] ;
gvim[iim] = tar[IJK(ff,ppg,ss)] ;
if( smask[iim] ) {
bvec[ism] = bvim[iim];
gvec[ism++] = gvim[iim];
}
}
}
/* fit the theta parameters from the smask region and save them */
optimize_theta() ;
xzero_t[vv] = theta_par[0] ;
thet1_t[vv] = theta_par[1] ;
dparr_t[vv] = d_par ;
mri_free(tim) ;
tim = NULL ;
}
/* now check the slice parameters for reasonability */
sskip = 0 ;
if( nv > 4 ) {
orfilt_len = 3 ;
orfilt_vector(nv,xzero_t) ;
orfilt_vector(nv,thet1_t) ;
orfilt_vector(nv,dparr_t) ;
qmedmadbmv_float(nv,thet1_t,&t1med,NULL,&t1bmv) ;
if( verb )
ININFO_message(" slice #%d -- median(theta1)=%g stdev=%g ratio=%g",
ss,t1med,t1bmv,(t1bmv>0.0f)?t1med/t1bmv:0.0f) ;
if( t1med == 0.0f || fabsf(t1med) <= 0.111f*t1bmv ) {
sskip = 1 ;
ININFO_message(" skipping slice #%d -- theta1 too small",ss) ;
}
}
if( sskip ) continue ; /* skip processing this slice */
/* loop over time points, estimate the un-ghosted image */
for( vv=0 ; vv < nv ; vv++ ) {
tim = THD_extract_float_brick(vv,inset) ; /* input data for slice */
tar = MRI_FLOAT_PTR(tim) ;
oar = DSET_ARRAY(outset,vv) ; /* output data for volume */
/* compute theta at each voxel */
if( thet1_t[vv] == 0.0f ) continue ; /* ghost amplitude is 0 ==> skip this time point */
if( verb > 1 )
ININFO_message(" slice=%d index=%d theta = %g %g %g",
ss,vv,xzero_t[vv],thet1_t[vv],dparr_t[vv]) ;
theta_par[0] = xzero_t[vv];
theta_par[1] = thet1_t[vv];
d_par = dparr_t[vv];
compute_thvim() ;
/* compute output values at each voxel:
(a) inside the smask == voxel in brain, N/2 ghost isn't
(b) not in the smask but in the bmask == voxel && N/2 ghost are in brain
(c) otherwise == voxel is unimportant effluvium */
for( iim=pp=0 ; pp < np ; pp++ ) {
if( pp >= np2 ) ppg = pp-np2 ;
else ppg = pp+np2 ;
for( ff=0 ; ff < nf ; ff++,iim++ ) {
iy = tar[IJK(ff,pp,ss)] ;
iyn = tar[IJK(ff,ppg,ss)] ;
if( smask[iim] ) {
oar[IJK(ff,pp,ss)] = find_mhat( iy,iyn , ctvim[iim],stvim[iim] , d_par ) ;
oar[IJK(ff,ppg,ss)] = 0.0f ;
} else if( bmask[IJK(ff,pp,ss)] && bmask[IJK(ff,ppg,ss)] ) {
if( ppg > pp ) {
mp = find_mpair( iy,iyn , ctvim[iim],stvim[iim] , d_par ) ;
oar[IJK(ff,pp,ss)] = mp.a ;
oar[IJK(ff,ppg,ss)] = mp.b ;
}
} else {
/* nada: output is already a copy of input */
}
}
}
}
} /* end of loop over slices */
FREEUP ;
return outset ;
}
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 THD_unique_rank_edit( THD_3dim_dataset *mask_dset ,
int miv,
byte *cmask,
char *mapname, int **unqp, int *N_unq)
{
int *vals=NULL, nvox, mxval, ii;
if (!(vals = THD_unique_rank(mask_dset, miv, cmask, mapname, unqp, N_unq))) {
fprintf(stderr,"** Failed to uniquate\n");
return (0);
}
mxval = -1;
nvox = DSET_NVOX(mask_dset) ;
for( ii=0 ; ii < nvox ; ii++ ) { if (vals[ii] > mxval) mxval = vals[ii]; }
/* fprintf (stderr,"-- Have maxval of %d\n", mxval); */
switch( DSET_BRICK_TYPE(mask_dset,miv) ){
default:
fprintf(stderr,"** Bad dset type for unique operation.\n"
"Should have been stopped a while ago.\n");
if (vals) free(vals); vals = NULL; return (0) ;
case MRI_short:{
short *mar = (short *) DSET_ARRAY(mask_dset,miv) ;
if (mxval > MRI_TYPE_maxval[MRI_short]) {
fprintf(stderr,
"** Have too many unique values (%d) for "
"datatype short (limit %f)!\n",
mxval, MRI_TYPE_maxval[MRI_short]);
if (vals) free(vals); vals = NULL; return (0) ;
}
EDIT_BRICK_FACTOR(mask_dset,miv,0.0);
for( ii=0 ; ii < nvox ; ii++ )
mar[ii] = (short)(vals[ii]);
}
break ;
case MRI_byte:{
byte *mar = (byte *) DSET_ARRAY(mask_dset,miv) ;
if (mxval > MRI_TYPE_maxval[MRI_byte]) {
fprintf(stderr,
"** Have too many unique values (%d) for "
"datatype byte (limit %f)!\n",
mxval, MRI_TYPE_maxval[MRI_byte]);
if (vals) free(vals); vals = NULL; return (0) ;
}
EDIT_BRICK_FACTOR(mask_dset,miv,0.0);
for( ii=0 ; ii < nvox ; ii++ )
mar[ii] = (byte)(vals[ii]);
}
break ;
case MRI_float:{
float *mar = (float *) DSET_ARRAY(mask_dset,miv) ;
EDIT_BRICK_FACTOR(mask_dset,miv,0.0);
for( ii=0 ; ii < nvox ; ii++ )
mar[ii] = (float)(vals[ii]);
}
break ;
}
return (1);
}
int THD_makedsetmask( THD_3dim_dataset *mask_dset ,
int miv , float mask_bot , float mask_top,
byte *cmask )
{
float maxval ; /* for computing limits for an empty mask */
int nvox , ii, nonzero=-1 , empty = 0 ;
if( !ISVALID_DSET(mask_dset) ||
miv < 0 ||
miv >= DSET_NVALS(mask_dset) ) return (-1) ;
nvox = DSET_NVOX(mask_dset) ;
DSET_mallocize(mask_dset); /* do this or else it could be a read only dset! */
DSET_load(mask_dset) ; if( !DSET_LOADED(mask_dset) ) return (-1) ;
nonzero = 0;
switch( DSET_BRICK_TYPE(mask_dset,miv) ){
default:
DSET_unload(mask_dset) ; return (-1) ;
case MRI_short:{
short mbot , mtop ;
short *mar = (short *) DSET_ARRAY(mask_dset,miv) ;
float mfac = DSET_BRICK_FACTOR(mask_dset,miv) ;
if( mfac == 0.0 ) mfac = 1.0 ;
if( mask_bot <= mask_top ){
/* maybe this mask is empty, allow for rounding */
maxval = MRI_TYPE_maxval[MRI_short] + 0.5 ;
if( mask_bot/mfac >= maxval || mask_top/mfac <= -maxval ) empty=1;
mbot = SHORTIZE(mask_bot/mfac) ;
mtop = SHORTIZE(mask_top/mfac) ;
} else {
mbot = (short) -MRI_TYPE_maxval[MRI_short] ;
mtop = (short) MRI_TYPE_maxval[MRI_short] ;
}
if (empty) { /* if empty, clear result 6 Jun 2007 */
for( ii=0 ; ii < nvox ; ii++ ) mar[ii] = 0;
} else if (cmask) {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 && cmask[ii]) { mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
} else {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 ) { mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
}
}
break ;
case MRI_byte:{
byte mbot , mtop ;
byte *mar = (byte *) DSET_ARRAY(mask_dset,miv) ;
float mfac = DSET_BRICK_FACTOR(mask_dset,miv) ;
if( mfac == 0.0 ) mfac = 1.0 ;
if( mask_bot <= mask_top && mask_top > 0.0 ){
/* maybe this mask is empty, allow for rounding */
/* (top <= 0 is flag for full mask) */
maxval = MRI_TYPE_maxval[MRI_byte] + 0.5 ;
if( mask_bot/mfac >= maxval ) empty = 1;
mbot = BYTEIZE(mask_bot/mfac) ;
mtop = BYTEIZE(mask_top/mfac) ;
} else {
mbot = 0 ;
mtop = (byte) MRI_TYPE_maxval[MRI_short] ;
}
if (empty) { /* if empty, clear result 6 Jun 2007 */
for( ii=0 ; ii < nvox ; ii++ ) mar[ii] = 0;
} else if (cmask) {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 && cmask[ii]){ mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
} else {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 ){ mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
}
}
break ;
case MRI_float:{
float mbot , mtop ;
float *mar = (float *) DSET_ARRAY(mask_dset,miv) ;
float mfac = DSET_BRICK_FACTOR(mask_dset,miv) ;
if( mfac == 0.0 ) mfac = 1.0 ;
if( mask_bot <= mask_top ){
mbot = (float) (mask_bot/mfac) ;
mtop = (float) (mask_top/mfac) ;
} else {
mbot = -WAY_BIG ;
mtop = WAY_BIG ;
}
if (cmask) {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 && cmask[ii]) { mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
} else {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 ) { mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
}
}
break ;
}
/* remove any scaling factor ZSS April 24 06*/
EDIT_BRICK_FACTOR(mask_dset,miv , 0.0);
return (nonzero) ;
}
