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 ;
}
char * TEST_main( PLUGIN_interface * plint )
{
MRI_IMAGE * tsim ;
MCW_idclist * idclist ;
MCW_idcode * idc ;
THD_3dim_dataset * dset ;
char str[256] ;
int id ;
/*--------- go to first input line ---------*/
PLUTO_next_option(plint) ;
idclist = PLUTO_get_idclist(plint) ;
if( PLUTO_idclist_count(idclist) == 0 )
return " \nNo input dataset list!\n " ;
id = 0 ;
do {
idc = PLUTO_idclist_next(idclist) ;
dset = PLUTO_find_dset(idc) ;
if( dset == NULL ) return NULL ;
id++ ;
sprintf(str, " \nDataset %d = %s\n nx = %d\n ny = %d\n nz = %d\n " ,
id , DSET_FILECODE(dset) , dset->daxes->nxx,dset->daxes->nyy,dset->daxes->nzz ) ;
PLUTO_popup_transient( plint , str ) ;
} while(1) ;
return NULL ;
}
static char * EXTRACT_main( PLUGIN_interface * plint )
{
extract_data uda,*ud;
MRI_IMAGE * tsim;
MCW_idcode * idc ; /* input dataset idcode */
THD_3dim_dataset * old_dset , * new_dset ; /* input and output datasets */
char *tmpstr , * str , *nprfxstr;
int ntime, nvec ,nprfx, Err=0 , itmp;
float * vec , fs , T ;
char * tag; /* plugin option tag */
/* Allocate as much character space as Bob specifies in afni.h + a bit more */
tmpstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char));
nprfxstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char));
if (tmpstr == NULL || nprfxstr == NULL)
return "********************\n"
"Could not Allocate\n"
"a teeni weeni bit of\n"
"Memory ! Go complain\n"
"to yer Mamma ! \n"
"********************\n";
ud = &uda; /* ud now points to an allocated space */
ud->errcode = 0; /*reset error flag */
/*--------------------------------------------------------------------*/
/*----- Check inputs from AFNI to see if they are reasonable-ish -----*/
/*--------- go to first input line ---------*/
tag = PLUTO_get_optiontag(plint) ;
if (tag == NULL)
{
return "************************\n"
"Bad 1st line option \n"
"************************" ;
}
idc = PLUTO_get_idcode(plint) ; /* get dataset item */
old_dset = PLUTO_find_dset(idc) ; /* get ptr to dataset */
if( old_dset == NULL )
return "*************************\n"
"Cannot find Input Dataset\n"
"*************************" ;
ud->dsetname = DSET_FILECODE (old_dset);
ud->ignore = PLUTO_get_number(plint) ; /* get number item */
str = PLUTO_get_string(plint) ;
ud->dtrnd = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings );
/*--------- loop over ramining options ---------*/
ud->iloc = -1;
ud->xloc = -1;
ud->yloc = -1;
ud->zloc = -1;
do
{
tag = PLUTO_get_optiontag(plint) ;
if (tag == NULL) break;
if (strcmp (tag, "Mask") == 0)
{
ud->strin = PLUTO_get_string(plint) ;
ud->ncols = PLUTO_get_number(plint) ;
ud->pass = PLUTO_get_number(plint) ;
ud->fail = 0; /* Set voxels that don't make it to 0 */
continue;
}
if (strcmp (tag, "Index") == 0)
{
ud->iloc = PLUTO_get_number(plint) ; /* get number item */
continue;
}
if (strcmp (tag, "XYZ") == 0)
{
ud->xloc = PLUTO_get_number(plint) ; /* get number item */
ud->yloc = PLUTO_get_number(plint) ; /* get number item */
ud->zloc = PLUTO_get_number(plint) ; /* get number item */
continue;
}
if (strcmp (tag, "Output") == 0)
{
ud->new_prefix = PLUTO_get_string(plint) ; /* get string item (the output prefix) */
/* check to see if the field is empty */
if (ud->new_prefix == NULL)
nprfx = 0;
else
nprfx = 1;
/* check if the size is larger than 0. I did not want to check for this unless it's allocated */
if (nprfx == 1 && (int)strlen (ud->new_prefix) == 0)
nprfx = 0;
if (nprfx == 0) /* now create the new name and make new_prefix point to it */
{
sprintf (nprfxstr,"%s.XTRCT",DSET_PREFIX (old_dset));
ud->new_prefix = nprfxstr;
/*printf ("New prefix is set to be : %s\n\a",ud->new_prefix);*/
}
if( ! PLUTO_prefix_ok(ud->new_prefix) ) /* check if it is OK */
return "************************\n"
"Output Prefix is illegal\n"
"************************" ;
ud->strout = PLUTO_get_string(plint) ;
str = PLUTO_get_string(plint) ;
ud->format = (int)PLUTO_string_index( str , NUM_FORMAT_STRINGS , format_strings );
continue;
}
} while (1);
/* ------------------ Check for some errorsor inconsistencies ------------- */
if (ud->iloc == -1 && ud->xloc == -1)
{
return "**************************\n"
"At least iloc or x/y/zloc\n"
"must be specified\n"
"**************************\n"
;
}
if (ud->iloc != -1 && ud->xloc != -1)
{
return "***************************\n"
"iloc AND x/y/zloc can not\n"
"be simultaneously specified\n"
"***************************\n"
;
}
/* ------------------Done with user parameters ---------------------------- */
/* Now loadup that index list or the xyz list */
if (ud->iloc != -1)
{
itmp = 0; /* might want to give option of setting it to number of rows if*/
/* the users know it, otherwise, it is automatically determined*/
ud->indvect = extract_index (ud->strin, ud->iloc, ud->ncols, &itmp, &Err);
}
else /* assuming the only other case is that x y z are specified */
{
itmp = 0;
ud->xyzvect = extract_xyz (ud->strin , ud->xloc , ud->yloc , ud->zloc , ud->ncols, &itmp, &Err);
}
ud->nrows = itmp;
switch (Err)
{
case (0):
break;
case (1):
return "****************************************\n"
"index location should be > 0 and < ncols\n"
"****************************************\n";
case (2):
return "********************************************\n"
"file size and number of columns do not match\n"
"********************************************\n";
case (3):
return "**********************\n"
"Can't find matrix file\n"
"**********************\n";
case (4):
return "*****************\n"
"ncols must be > 0\n"
"*****************\n";
case (5):
return "****************************************\n"
"x/y/z column numbers can NOT be the same\n"
"****************************************\n";
default:
return "****************************************\n"
"Should not have gotten here .....\n"
"****************************************\n";
}
if (strcmp (ud->strout,"") == 0) /* no output file is specified */
{
sprintf ( tmpstr , "%s" , ud->new_prefix);
ud->strout = tmpstr;
}
if (filexists(ud->strout) == 1)
{
return "*******************************\n"
"Outfile exists, won't overwrite\n"
"*******************************\n";
}
ud->outwritets = fopen (ud->strout ,"w");
sprintf ( tmpstr , "%s.log" , ud->strout);
if (filexists(tmpstr) == 1)
{
return "*******************************\n"
"Outfile.log exists, won't overwrite\n"
"*******************************\n";
}
ud->outlogfile = fopen (tmpstr ,"w");
if ((ud->outwritets == NULL) || (ud->outlogfile == NULL) )
{
ud->errcode = ERROR_FILEWRITE;
return "***********************\n"
"Could Not Write Outfile\n"
"***********************\n";
}
ud->nxx = (int)old_dset->daxes->nxx; /* get data set dimensions */
ud->nyy = (int)old_dset->daxes->nyy;
ud->nzz = (int)old_dset->daxes->nzz;
/* ready to dump the log file */
write_ud (ud);
/*------------- ready to compute new dataset -----------*/
new_dset = PLUTO_4D_to_typed_fim( old_dset , /* input dataset */
ud->new_prefix , /* output prefix */
-1, /* negative value indicating data type is like original brick */
ud->ignore , /* ignore count */
ud->dtrnd , /* detrend */
EXTRACT_tsfunc , /* timeseries processor */
(void *)ud /* data for tsfunc */
) ;
PLUTO_add_dset( plint , new_dset , DSET_ACTION_MAKE_CURRENT ) ;
fclose (ud->outlogfile);
fclose (ud->outwritets);
free (tmpstr);
free (nprfxstr);
return NULL ; /* null string returned means all was OK */
}
char * THD_dataset_info( THD_3dim_dataset *dset , int verbose )
{
THD_dataxes *daxes ;
THD_fvec3 fv1 , fv2 , fv3 ;
int ival , ntimes , nval_per , n1,n2,n3 , kv,npar ;
float tf, angle=0.0;
long long tb ;
static char *RR="[R]" , *LL="[L]" ,
*PP="[P]" , *AA="[A]" ,
*SS="[S]" , *II="[I]" , *ZZ=" " ;
char *xlbot , *xltop , *ylbot , *yltop , *zlbot , *zltop , *cpt ;
char str[1024], soblq[1024] ;
int nstr , obliquity;
char *outbuf = NULL ; /* output buffer */
ENTRY("THD_dataset_info") ;
if( ! ISVALID_3DIM_DATASET(dset) ) RETURN(NULL) ;
daxes = dset->daxes ;
if( DSET_IS_BRIK(dset) )
outbuf = THD_zzprintf(outbuf,"Dataset File: %s\n" , DSET_FILECODE(dset) ) ;
else
outbuf = THD_zzprintf(outbuf,"Dataset File: %s\n" , DSET_BRIKNAME(dset) ) ;
outbuf = THD_zzprintf(outbuf,"Identifier Code: %s Creation Date: %s\n" ,
dset->idcode.str , dset->idcode.date ) ;
outbuf = THD_zzprintf(outbuf, "Template Space: %s\n", dset->atlas_space);
if( ISANAT(dset) ){
outbuf = THD_zzprintf(outbuf,"Dataset Type: %s (-%s)\n",
ANAT_typestr[dset->func_type] , ANAT_prefixstr[dset->func_type] ) ;
} else {
outbuf = THD_zzprintf(outbuf,"Dataset Type: %s (-%s)\n",
FUNC_typestr[dset->func_type] , FUNC_prefixstr[dset->func_type] ) ;
}
/* 25 April 1998: do byte order stuff */
switch( DSET_BYTEORDER(dset) ){
case LSB_FIRST:
outbuf = THD_zzprintf(outbuf,"Byte Order: %s" , LSB_FIRST_STRING) ;
break ;
case MSB_FIRST:
outbuf = THD_zzprintf(outbuf,"Byte Order: %s" , MSB_FIRST_STRING) ;
break ;
}
if( THD_find_string_atr(dset->dblk,ATRNAME_BYTEORDER) == NULL ) /* 19 Sep 1999 */
outbuf = THD_zzprintf(outbuf," {assumed}") ;
kv = mri_short_order() ;
switch( kv ){
case LSB_FIRST:
outbuf = THD_zzprintf(outbuf," [this CPU native = %s]\n" , LSB_FIRST_STRING) ;
break ;
case MSB_FIRST:
outbuf = THD_zzprintf(outbuf," [this CPU native = %s]\n" , MSB_FIRST_STRING) ;
break ;
}
/*-- 21 Jun 2002: print storage mode --*/
if( dset->dblk->diskptr != NULL ){
outbuf = THD_zzprintf(outbuf,"Storage Mode: %s\n",
storage_mode_str(dset->dblk->diskptr->storage_mode));
}
tb = dset->dblk->total_bytes ;
if( tb > 0 )
outbuf = THD_zzprintf(outbuf,"Storage Space: %s (%s) bytes\n",
commaized_integer_string(dset->dblk->total_bytes) ,
approximate_number_string(dset->dblk->total_bytes) ) ;
/*-- keywords --*/
if( verbose >= 0 ){
cpt = DSET_KEYWORDS(dset) ;
if( cpt != NULL && cpt[0] != '\0' ){
int j = strlen(cpt) ;
if( j < 99 ){
outbuf = THD_zzprintf(outbuf,"Keywords: %s\n" , cpt ) ;
} else {
int k ;
outbuf = THD_zzprintf(outbuf,"\n----- KEYWORDS -----\n") ;
for( k=0 ; k < j ; k += ZMAX )
outbuf = THD_zzprintf(outbuf,SZMAX,cpt+k) ;
outbuf = THD_zzprintf(outbuf,"\n") ;
}
}
}
/*-- idcodes --*/
if( verbose >= 0 ){
if( ! ISZERO_IDCODE(dset->anat_parent_idcode) )
outbuf = THD_zzprintf(outbuf,"Anatomy Parent: %s [%s]\n" ,
dset->anat_parent_name , dset->anat_parent_idcode.str ) ;
else if( strlen(dset->anat_parent_name) > 0 )
outbuf = THD_zzprintf(outbuf,"Anatomy Parent: %s\n" , dset->anat_parent_name ) ;
if( ! ISZERO_IDCODE(dset->warp_parent_idcode) )
outbuf = THD_zzprintf(outbuf,"Warp Parent: %s [%s]\n" ,
dset->warp_parent_name , dset->warp_parent_idcode.str) ;
else if( strlen(dset->warp_parent_name) > 0 )
outbuf = THD_zzprintf(outbuf,"Warp Parent: %s\n" , dset->warp_parent_name ) ;
}
/*-- tagset --*/
if( verbose > 0 && dset->tagset != NULL && dset->tagset->num > 0 ){
int ii , ns=0 ;
for( ii=0 ; ii < dset->tagset->num ; ii++ )
if( dset->tagset->tag[ii].set ) ns++ ;
outbuf = THD_zzprintf(outbuf,"Tagset: %d set [out of %d total]\n",
ns , dset->tagset->num ) ;
}
/* are we oblique ? */
if((obliquity = dset_obliquity(dset, &angle)) >= 0) {
if(angle>0.0) {
sprintf (soblq,
"Data Axes Tilt: Oblique (%.3f deg. from plumb)\n"
"Data Axes Approximate Orientation:",
angle);
} else {
sprintf (soblq,
"Data Axes Tilt: Plumb\n"
"Data Axes Orientation:");
}
{ char *gstr = EDIT_get_geometry_string(dset) ;
if( gstr != NULL && *gstr != '\0' )
outbuf = THD_zzprintf(outbuf,"Geometry String: \"%s\"\n",gstr) ;
}
} else {
sprintf (soblq,
"Data Axes Tilt: Unspecified, assumed plumb\n"
"Data Axes Orientation:");
}
outbuf = THD_zzprintf(outbuf,
"%s\n"
" first (x) = %s\n"
" second (y) = %s\n"
" third (z) = %s [-orient %c%c%c]\n" ,
soblq,
ORIENT_typestr[daxes->xxorient] ,
ORIENT_typestr[daxes->yyorient] ,
ORIENT_typestr[daxes->zzorient] ,
ORIENT_typestr[daxes->xxorient][0] ,
ORIENT_typestr[daxes->yyorient][0] ,
ORIENT_typestr[daxes->zzorient][0] ) ;
LOAD_FVEC3(fv1 , daxes->xxorg , daxes->yyorg , daxes->zzorg) ;
fv1 = THD_3dmm_to_dicomm( dset , fv1 ) ;
LOAD_FVEC3(fv2 , daxes->xxorg + (daxes->nxx-1)*daxes->xxdel ,
daxes->yyorg + (daxes->nyy-1)*daxes->yydel ,
daxes->zzorg + (daxes->nzz-1)*daxes->zzdel ) ;
fv2 = THD_3dmm_to_dicomm( dset , fv2 ) ;
if( fv1.xyz[0] > fv2.xyz[0] ) FSWAP( fv1.xyz[0] , fv2.xyz[0] ) ;
if( fv1.xyz[1] > fv2.xyz[1] ) FSWAP( fv1.xyz[1] , fv2.xyz[1] ) ;
if( fv1.xyz[2] > fv2.xyz[2] ) FSWAP( fv1.xyz[2] , fv2.xyz[2] ) ;
LOAD_FVEC3(fv3 , daxes->xxdel , daxes->yydel , daxes->zzdel) ;
fv3 = THD_3dmm_to_dicomm( dset , fv3 ) ;
XLAB(xlbot,fv1.xyz[0]) ; YLAB(ylbot,fv1.xyz[1]) ; ZLAB(zlbot,fv1.xyz[2]) ;
XLAB(xltop,fv2.xyz[0]) ; YLAB(yltop,fv2.xyz[1]) ; ZLAB(zltop,fv2.xyz[2]) ;
n1 = DAXES_NUM(daxes,ORI_R2L_TYPE) ;
n2 = DAXES_NUM(daxes,ORI_A2P_TYPE) ;
n3 = DAXES_NUM(daxes,ORI_I2S_TYPE) ;
outbuf = THD_zzprintf(outbuf,
"R-to-L extent: %9.3f %s -to- %9.3f %s -step- %9.3f mm [%3d voxels]\n"
"A-to-P extent: %9.3f %s -to- %9.3f %s -step- %9.3f mm [%3d voxels]\n"
"I-to-S extent: %9.3f %s -to- %9.3f %s -step- %9.3f mm [%3d voxels]\n" ,
fv1.xyz[0],xlbot , fv2.xyz[0],xltop , fabs(fv3.xyz[0]) , n1 ,
fv1.xyz[1],ylbot , fv2.xyz[1],yltop , fabs(fv3.xyz[1]) , n2 ,
fv1.xyz[2],zlbot , fv2.xyz[2],zltop , fabs(fv3.xyz[2]) , n3 ) ;
/*-- 01 Feb 2001: print the center of the dataset as well --*/
if( verbose > 0 ){
fv1.xyz[0] = 0.5*(fv1.xyz[0]+fv2.xyz[0]) ; XLAB(xlbot,fv1.xyz[0]) ;
fv1.xyz[1] = 0.5*(fv1.xyz[1]+fv2.xyz[1]) ; YLAB(ylbot,fv1.xyz[1]) ;
fv1.xyz[2] = 0.5*(fv1.xyz[2]+fv2.xyz[2]) ; ZLAB(zlbot,fv1.xyz[2]) ;
outbuf = THD_zzprintf(outbuf,
"R-to-L center: %9.3f %s\n"
"A-to-P center: %9.3f %s\n"
"I-to-S center: %9.3f %s\n" ,
fv1.xyz[0],xlbot ,
fv1.xyz[1],ylbot ,
fv1.xyz[2],zlbot ) ;
}
ntimes = DSET_NUM_TIMES(dset) ;
nval_per = DSET_NVALS_PER_TIME(dset) ;
if( ntimes > 1 ){
outbuf = THD_zzprintf(outbuf,
"Number of time steps = %d" , ntimes ) ;
STATUS("timestep") ;
outbuf = THD_zzprintf(outbuf, " Time step = %.5f%s Origin = %.5f%s" ,
dset->taxis->ttdel ,
UNITS_TYPE_LABEL(dset->taxis->units_type) ,
dset->taxis->ttorg ,
UNITS_TYPE_LABEL(dset->taxis->units_type) ) ;
if( dset->taxis->nsl > 0 )
outbuf = THD_zzprintf(outbuf," Number time-offset slices = %d Thickness = %.3f",
dset->taxis->nsl , fabs(dset->taxis->dz_sl) ) ;
outbuf = THD_zzprintf(outbuf,"\n") ;
STATUS("nsl done") ;
if( verbose > 0 && dset->taxis->nsl > 0 && dset->taxis->toff_sl != NULL ){
outbuf = THD_zzprintf(outbuf,"Time-offsets per slice:") ;
for( ival=0 ; ival < dset->taxis->nsl ; ival++ )
outbuf = THD_zzprintf(outbuf, " %.3f" , dset->taxis->toff_sl[ival] ) ;
outbuf = THD_zzprintf(outbuf,"\n") ;
}
} else {
outbuf = THD_zzprintf(outbuf,
"Number of values stored at each pixel = %d\n" , nval_per ) ;
}
#if 0
if( verbose > 0 && ntimes > 1 ) nval_per = dset->dblk->nvals ;
else nval_per = 1 ; /* 12 Feb 2002 */
#else
nval_per = dset->dblk->nvals ;
if( verbose < 0 && nval_per > 5 ) nval_per = 3 ;
#endif
/* print out stuff for each sub-brick */
for( ival=0 ; ival < nval_per ; ival++ ){
STATUS("ival a") ;
sprintf( str ,
" -- At sub-brick #%d '%s' datum type is %s" ,
ival , DSET_BRICK_LAB(dset,ival) ,
MRI_TYPE_name[DSET_BRICK_TYPE(dset,ival)] ) ;
nstr = strlen(str) ;
tf = DSET_BRICK_FACTOR(dset,ival) ;
if( ISVALID_STATISTIC(dset->stats) ){
if( tf != 0.0 ){
sprintf( str+nstr ,
":%13.6g to %13.6g [internal]\n"
"%*s[*%13.6g] %13.6g to %13.6g [scaled]\n" ,
dset->stats->bstat[ival].min/tf ,
dset->stats->bstat[ival].max/tf ,
nstr-16," " , tf ,
dset->stats->bstat[ival].min , dset->stats->bstat[ival].max ) ;
} else {
sprintf( str+nstr , ":%13.6g to %13.6g\n" ,
dset->stats->bstat[ival].min , dset->stats->bstat[ival].max ) ;
}
} else if( tf != 0.0 ){
sprintf( str+nstr , " [*%g]\n",tf) ;
} else {
sprintf( str+nstr , "\n") ;
}
STATUS("ival b") ;
outbuf = THD_zzprintf(outbuf,"%s",str) ;
/** 30 Nov 1997: print sub-brick stat params **/
kv = DSET_BRICK_STATCODE(dset,ival) ;
if( FUNC_IS_STAT(kv) ){
STATUS("ival c") ;
outbuf = THD_zzprintf(outbuf," statcode = %s",FUNC_prefixstr[kv] ) ;
npar = FUNC_need_stat_aux[kv] ;
if( npar > 0 ){
outbuf = THD_zzprintf(outbuf,"; statpar =") ;
for( kv=0 ; kv < npar ; kv++ )
outbuf = THD_zzprintf(outbuf," %g",DSET_BRICK_STATPAR(dset,ival,kv)) ;
}
outbuf = THD_zzprintf(outbuf,"\n") ;
STATUS("ival d") ;
}
cpt = DSET_BRICK_KEYWORDS(dset,ival) ;
if( cpt != NULL && cpt[0] != '\0' ){
outbuf = THD_zzprintf(outbuf," keywords = %.66s\n",cpt) ;
}
STATUS("ival z") ;
}
if( verbose < 0 && nval_per < dset->dblk->nvals ) /* 21 Sep 2007 */
outbuf = THD_zzprintf(outbuf,
"** For info on all %d sub-bricks, use '3dinfo -verb' **\n",
dset->dblk->nvals) ;
/** print out dataset global statistical parameters **/
if( ISFUNC(dset) && FUNC_need_stat_aux[dset->func_type] > 0 ){
outbuf = THD_zzprintf(outbuf,"Auxiliary functional statistical parameters:\n %s\n",
FUNC_label_stat_aux[dset->func_type] ) ;
for( ival=0 ; ival < FUNC_need_stat_aux[dset->func_type] ; ival++ )
outbuf = THD_zzprintf(outbuf," %g",dset->stat_aux[ival]) ;
outbuf = THD_zzprintf(outbuf,"\n") ;
}
/** If present, print out History **/
{ char *chn ; int j,k ;
chn = tross_Get_History(dset) ;
if( chn != NULL ){
j = strlen(chn) ;
outbuf = THD_zzprintf(outbuf,"\n----- HISTORY -----\n") ;
for( k=0 ; k < j ; k += ZMAX )
outbuf = THD_zzprintf(outbuf,SZMAX,chn+k) ;
free(chn) ;
outbuf = THD_zzprintf(outbuf,"\n") ;
}
}
/** If present, print out Notes **/
if( verbose >= 0 ){
ATR_int *notecount;
int num_notes, i, j, mmm ;
char *chn , *chd ;
notecount = THD_find_int_atr(dset->dblk, "NOTES_COUNT");
if( notecount != NULL ){
num_notes = notecount->in[0] ;
if( verbose == 0 && num_notes > 5 ) num_notes = 5 ;
mmm = (verbose > 0) ? ZMAX : 1200 ; /* 400 it was!
Come on Bob, have a heart! -ZSS */
for (i=1; i<= num_notes; i++) {
chn = tross_Get_Note( dset , i ) ;
if( chn != NULL ){
j = strlen(chn) ; if( j > mmm ) chn[mmm] = '\0' ;
chd = tross_Get_Notedate(dset,i) ;
if( chd == NULL ){ chd = AFMALL(char,16) ; strcpy(chd,"no date") ; }
outbuf = THD_zzprintf(outbuf,"\n----- NOTE %d [%s] -----\n%s\n",i,chd,chn) ;
free(chn) ; free(chd) ;
}
/*!
Turn float arrays into sub-bricks of a preset type
(based on code in 3dMean)
dset (THD_3dim_dataset *) new dset to which arrays will be added
far (float **) each far[i] is to become one sub-brick in dset
nval (int) the number of arrays in far
otype (int) the sub-brick type. Supported options are:
MRI_float (so far
scaleopt (char) scaling options:
'A' scale if needed
'F' do scale each sub-brick
'G' scale all sub-bricks with the same factor
'N' Do not scale
verb (int) loquaciousness
returns 1 if all is well
0 all hell broke loose
*/
int EDIT_add_bricks_from_far(THD_3dim_dataset *dset,
float **far, int nval,
int otype, char scaleopt,
int verb)
{
int ii=0, kk=0, nxyz;
ENTRY("EDIT_add_bricks_from_far");
if (scaleopt != 'A' && scaleopt != 'F' && scaleopt != 'G' && scaleopt != 'N'){
ERROR_message("Bad scaleopt value of %c", scaleopt);
RETURN(0);
}
if (!dset) {
ERROR_message("NULL input");
RETURN(0);
}
nxyz = DSET_NVOX(dset);
switch( otype ){
default:
ERROR_message("Somehow ended up with otype = %d\n",otype) ;
RETURN(0) ;
case MRI_float:{
for( kk=0 ; kk < nval ; kk++ ){
EDIT_substitute_brick(dset, kk, MRI_float, far[kk]);
DSET_BRICK_FACTOR(dset, kk) = 0.0;
far[kk] = NULL;
}
}
break ;
case MRI_byte:
case MRI_short:{
void ** dfim ;
float gtop=0.0 , fimfac , gtemp ;
if( verb )
fprintf(stderr," ++ Scaling output to type %s brick(s)\n",
MRI_TYPE_name[otype] ) ;
dfim = (void **) malloc(sizeof(void *)*nval) ;
if( scaleopt == 'G' ){ /* allow global scaling */
gtop = 0.0 ;
for( kk=0 ; kk < nval ; kk++ ){
gtemp = MCW_vol_amax( nxyz , 1 , 1 , MRI_float, far[kk] ) ;
gtop = MAX( gtop , gtemp ) ;
if( gtemp == 0.0 )
WARNING_message("output sub-brick %d is all zeros!\n",kk) ;
}
}
for (kk = 0 ; kk < nval ; kk ++ ) {
if( scaleopt != 'G' && scaleopt != 'N'){
/* compute max value in this sub-brick */
gtop = MCW_vol_amax( nxyz , 1 , 1 , MRI_float, far[kk] ) ;
if( gtop == 0.0 )
WARNING_message("output sub-brick %d is all zeros!\n",kk) ;
}
if( scaleopt == 'F' || scaleopt == 'G'){ /* scaling needed */
fimfac = (gtop > 0.0) ? MRI_TYPE_maxval[otype] / gtop : 0.0 ;
} else if( scaleopt == 'A' ){ /* only if needed */
fimfac = ( gtop > MRI_TYPE_maxval[otype] ||
(gtop > 0.0 && gtop < 1.0) )
? MRI_TYPE_maxval[otype]/ gtop : 0.0 ;
if( fimfac == 0.0 && gtop > 0.0 ){ /* 14 May 2010 */
float fv,iv ; /* force scaling if */
for( ii=0 ; ii < nxyz ; ii++ ){ /* non-integers are inside */
fv = far[kk][ii] ; iv = rint(fv) ;
if( fabsf(fv-iv) >= 0.01 ){
fimfac = MRI_TYPE_maxval[otype] / gtop ; break ;
}
}
}
} else if( scaleopt == 'N') { /* no scaling allowed */
fimfac = 0.0 ;
} else {
ERROR_message("Should not see this one");
RETURN(0);
}
if( verb ){
if( fimfac != 0.0 )
INFO_message("Sub-brick %d scale factor = %f\n",kk,fimfac) ;
else
INFO_message("Sub-brick %d: no scale factor\n" ,kk) ;
}
dfim[kk] = (void *) malloc( mri_datum_size(otype) * nxyz ) ;
if( dfim[kk] == NULL ){
ERROR_message("malloc fails at output\n");
exit(1);
}
EDIT_coerce_scale_type( nxyz , fimfac ,
MRI_float, far[kk] , otype,dfim[kk] ) ;
if( otype == MRI_short )
EDIT_misfit_report( DSET_FILECODE(dset) , kk ,
nxyz , (fimfac != 0.0f) ? 1.0f/fimfac : 0.0f ,
dfim[kk] , far[kk] ) ;
free( far[kk] ) ; far[kk] = NULL;
EDIT_substitute_brick(dset, kk, otype, dfim[kk] );
DSET_BRICK_FACTOR(dset,kk) = (fimfac != 0.0) ? 1.0/fimfac : 0.0 ;
dfim[kk]=NULL;
}
free(dfim); dfim = NULL;
}
break ;
}
RETURN(1);
}
char * MASKAVE_main( PLUGIN_interface * plint )
{
MCW_idcode * idc ;
THD_3dim_dataset * input_dset , * mask_dset ;
int iv , mcount , nvox , ii , sigmait , nvals=0 , doall , ivbot,ivtop ;
float mask_bot=666.0 , mask_top=-666.0 ;
double sum=0.0 , sigma=0.0 ;
float * sumar=NULL , * sigmar=NULL ;
char * tag , * str , buf[64] , abuf[32],sbuf[32] ;
byte * mmm ;
char * cname=NULL ; /* 06 Aug 1998 */
int cdisk=0 ; /* 22 Aug 2000 */
int miv=0 ;
/*--------------------------------------------------------------------*/
/*----- Check inputs from AFNI to see if they are reasonable-ish -----*/
if( plint == NULL )
return "*************************\n"
"MASKAVE_main: NULL input\n"
"*************************" ;
/*-- read 1st line --*/
PLUTO_next_option(plint) ;
idc = PLUTO_get_idcode(plint) ;
input_dset = PLUTO_find_dset(idc) ;
if( input_dset == NULL )
return "********************************\n"
"MASKAVE_main: bad input dataset\n"
"********************************" ;
iv = (int) PLUTO_get_number(plint) ;
if( iv >= DSET_NVALS(input_dset) )
return "**********************************\n"
"MASKAVE_main: bad input sub-brick\n"
"**********************************" ;
doall = (iv < 0) ;
if( doall ){
nvals = DSET_NVALS(input_dset) ;
ivbot = 0 ; ivtop = nvals-1 ;
} else {
ivbot = ivtop = iv ;
}
DSET_load(input_dset) ;
if( DSET_ARRAY(input_dset,ivbot) == NULL )
return "*********************************\n"
"MASKAVE_main: can't load dataset\n"
"*********************************" ;
nvox = DSET_NVOX(input_dset) ;
/*-- read 2nd line --*/
PLUTO_next_option(plint) ;
idc = PLUTO_get_idcode(plint) ;
mask_dset = PLUTO_find_dset(idc) ;
if( mask_dset == NULL )
return "*******************************\n"
"MASKAVE_main: bad mask dataset\n"
"*******************************" ;
if( DSET_NVOX(mask_dset) != nvox )
return "*************************************************************\n"
"MASKAVE_main: mask input dataset doesn't match source dataset\n"
"*************************************************************" ;
miv = (int) PLUTO_get_number(plint) ; /* 06 Aug 1998 */
if( miv >= DSET_NVALS(mask_dset) )
return "*****************************************************\n"
"MASKAVE_main: mask dataset sub-brick index is too big\n"
"*****************************************************" ;
DSET_load(mask_dset) ;
if( DSET_ARRAY(mask_dset,0) == NULL )
return "**************************************\n"
"MASKAVE_main: can't load mask dataset\n"
"**************************************" ;
/*-- read optional lines --*/
while( (tag=PLUTO_get_optiontag(plint)) != NULL ){
if( strcmp(tag,"Range") == 0 ){
mask_bot = PLUTO_get_number(plint) ;
mask_top = PLUTO_get_number(plint) ;
continue ;
}
if( strcmp(tag,"1D Save") == 0 ){
char * yn ;
cname = PLUTO_get_string(plint) ;
yn = PLUTO_get_string(plint) ;
cdisk = (strcmp(yn,yesno_list[0]) == 0) ;
continue ;
}
}
/*------------------------------------------------------*/
/*---------- At this point, the inputs are OK ----------*/
/*-- build a byte mask array --*/
mmm = (byte *) malloc( sizeof(byte) * nvox ) ;
if( mmm == NULL )
return "*** Can't malloc workspace! ***" ;
/* separate code for each input data type */
switch( DSET_BRICK_TYPE(mask_dset,miv) ){
default:
free(mmm) ;
return "*** Can't use mask dataset -- illegal data type! ***" ;
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 ){
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] ;
}
for( mcount=0,ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 ){ mmm[ii] = 1 ; mcount++ ; }
else { mmm[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 ){
mbot = BYTEIZE(mask_bot/mfac) ;
mtop = BYTEIZE(mask_top/mfac) ;
if( mtop == 0 ){
free(mmm) ;
return "*** Illegal mask range for mask dataset of bytes. ***" ;
}
} else {
mbot = 0 ;
mtop = (byte) MRI_TYPE_maxval[MRI_short] ;
}
for( mcount=0,ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 ){ mmm[ii] = 1 ; mcount++ ; }
else { mmm[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 ;
}
for( mcount=0,ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 ){ mmm[ii] = 1 ; mcount++ ; }
else { mmm[ii] = 0 ; }
}
break ;
}
if( mcount == 0 ){
free(mmm) ;
return "*** No voxels survive the masking operations! ***" ;
}
sigmait = (mcount > 1) ;
/*-- compute statistics --*/
if( doall ){
sumar = (float *) malloc( sizeof(float) * nvals ) ;
sigmar = (float *) malloc( sizeof(float) * nvals ) ;
}
for( iv=ivbot ; iv <= ivtop ; iv++ ){
sum = sigma = 0.0 ; /* 13 Dec 1999 */
switch( DSET_BRICK_TYPE(input_dset,iv) ){
default:
free(mmm) ; if( doall ){ free(sumar) ; free(sigmar) ; }
return "*** Can't use source dataset -- illegal data type! ***" ;
case MRI_short:{
short * bar = (short *) DSET_ARRAY(input_dset,iv) ;
float mfac = DSET_BRICK_FACTOR(input_dset,iv) ;
if( mfac == 0.0 ) mfac = 1.0 ;
for( ii=0 ; ii < nvox ; ii++ ) if( mmm[ii] ) sum += bar[ii] ;
sum = sum / mcount ;
if( sigmait ){
for( ii=0 ; ii < nvox ; ii++ )
if( mmm[ii] ) sigma += SQR(bar[ii]-sum) ;
sigma = mfac * sqrt( sigma/(mcount-1) ) ;
}
sum = mfac * sum ;
}
break ;
case MRI_byte:{
byte * bar = (byte *) DSET_ARRAY(input_dset,iv) ;
float mfac = DSET_BRICK_FACTOR(input_dset,iv) ;
if( mfac == 0.0 ) mfac = 1.0 ;
for( ii=0 ; ii < nvox ; ii++ ) if( mmm[ii] ) sum += bar[ii] ;
sum = sum / mcount ;
if( sigmait ){
for( ii=0 ; ii < nvox ; ii++ )
if( mmm[ii] ) sigma += SQR(bar[ii]-sum) ;
sigma = mfac * sqrt( sigma/(mcount-1) ) ;
}
sum = mfac * sum ;
}
break ;
case MRI_float:{
float * bar = (float *) DSET_ARRAY(input_dset,iv) ;
float mfac = DSET_BRICK_FACTOR(input_dset,iv) ;
if( mfac == 0.0 ) mfac = 1.0 ;
for( ii=0 ; ii < nvox ; ii++ ) if( mmm[ii] ) sum += bar[ii] ;
sum = sum / mcount ;
if( sigmait ){
for( ii=0 ; ii < nvox ; ii++ )
if( mmm[ii] ) sigma += SQR(bar[ii]-sum) ;
sigma = mfac * sqrt( sigma/(mcount-1) ) ;
}
sum = mfac * sum ;
}
break ;
}
if( doall ){ sumar[iv] = sum ; sigmar[iv] = sigma ; }
}
free(mmm) ;
/*-- send report --*/
if( doall ){
str = (char *) malloc( 1024 + 64*nvals ) ;
sprintf(str," ****** ROI statistics ****** \n"
" Source = %s [all sub-bricks] \n"
" Mask = %s [%s]" ,
DSET_FILECODE(input_dset) ,
DSET_FILECODE(mask_dset) , DSET_BRICK_LABEL(mask_dset,miv) ) ;
if( mask_bot <= mask_top ){
sprintf(buf," [range %g .. %g]" , mask_bot , mask_top ) ;
strcat(str,buf) ;
}
strcat(str," \n") ;
sprintf(buf," Count = %d voxels\n",mcount) ; strcat(str,buf) ;
for( iv=0 ; iv < nvals ; iv++ ){
AV_fval_to_char( sumar[iv] , abuf ) ;
AV_fval_to_char( sigmar[iv] , sbuf ) ;
sprintf(buf," Average = %9.9s Sigma = %9.9s [%s] \n",
abuf,sbuf , DSET_BRICK_LABEL(input_dset,iv) ) ;
strcat(str,buf) ;
}
PLUTO_popup_textwin( plint , str ) ;
/* 06 Aug 1998 */
if( cname != NULL && cname[0] != '\0' ){
MRI_IMAGE * qim = mri_new_vol_empty( nvals,1,1 , MRI_float ) ;
mri_fix_data_pointer( sumar , qim ) ;
PLUTO_register_timeseries( cname , qim ) ;
if( cdisk ){ /* 22 Aug 2000 */
if( PLUTO_prefix_ok(cname) ){
char * cn ;
if( strstr(cname,".1D") == NULL ){
cn = malloc(strlen(cname)+8) ;
strcpy(cn,cname) ; strcat(cn,".1D") ;
} else {
cn = cname ;
}
mri_write_1D( cn , qim ) ;
if( cn != cname ) free(cn) ;
} else {
PLUTO_popup_transient(plint," \n"
"** Illegal filename **\n"
"** in 'To Disk?' !! **\n" ) ;
}
}
mri_fix_data_pointer( NULL , qim ) ; mri_free(qim) ;
}
free(str) ; free(sumar) ; free(sigmar) ;
} else if( mask_bot <= mask_top ){
str = (char *) malloc( 1024 ) ;
sprintf( str , " *** ROI Statistics *** \n"
" Source = %s [%s] \n"
" Mask = %s [%s] [range %g .. %g] \n"
" Count = %d voxels \n"
" Average = %g \n"
" Sigma = %g " ,
DSET_FILECODE(input_dset) , DSET_BRICK_LABEL(input_dset,ivbot) ,
DSET_FILECODE(mask_dset) , DSET_BRICK_LABEL(mask_dset,miv) ,
mask_bot , mask_top , mcount , sum , sigma ) ;
PLUTO_popup_message(plint,str) ;
free(str) ;
} else {
str = (char *) malloc( 1024 ) ;
sprintf( str , " *** ROI Statistics *** \n"
" Source = %s [%s] \n"
" Mask = %s [%s] \n"
" Count = %d voxels \n"
" Average = %g \n"
" Sigma = %g " ,
DSET_FILECODE(input_dset) , DSET_BRICK_LABEL(input_dset,ivbot) ,
DSET_FILECODE(mask_dset) , DSET_BRICK_LABEL(mask_dset,miv) ,
mcount , sum , sigma ) ;
PLUTO_popup_message(plint,str) ;
free(str) ;
}
return NULL ;
}
int main( int argc , char * argv[] )
{
int ninp , ids , nv , iv,jv,kv , ivout , new_nvals , have_fdr = 0, nfdr = 0 ;
THD_3dim_dataset * new_dset=NULL , * dset ;
char buf[256] ;
double angle;
/*----- identify program -----*/
#if 0
printf ("\n\nProgram %s \n", PROGRAM_NAME);
printf ("Last revision: %s \n\n", LAST_MOD_DATE);
#endif
/*** read input options ***/
mainENTRY("3dbucket main"); machdep(); PRINT_VERSION("3dbucket") ;
set_obliquity_report(0); /* silence obliquity */
/*-- 20 Apr 2001: addto the arglist, if user wants to [RWCox] --*/
{ int new_argc ; char ** new_argv ;
addto_args( argc , argv , &new_argc , &new_argv ) ;
if( new_argv != NULL ){ argc = new_argc ; argv = new_argv ; }
}
AFNI_logger("3dbucket",argc,argv) ;
BUCK_read_opts( argc , argv ) ;
/*** create new dataset (empty) ***/
ninp = BUCK_dsar->num ;
if( ninp < 1 ){
fprintf(stderr,"*** No input datasets?\n") ; exit(1) ;
}
new_nvals = 0 ;
for( ids=0 ; ids < ninp ; ids++ ) new_nvals += NSUBV(ids) ;
if( BUCK_verb ) printf("-verb: output will have %d sub-bricks\n",new_nvals) ;
new_dset = EDIT_empty_copy( DSUB(0) ) ;
/* 23 May 2005: check for axis consistency */
/* 06 Feb 2008: and see if there are fdrcurves to perpetuate */
if( DSUB(0)->dblk->brick_fdrcurve ) have_fdr = 1 ;
for( iv=1 ; iv < ninp ; iv++ ){
if( !EQUIV_DATAXES(new_dset->daxes,DSUB(iv)->daxes) )
fprintf(stderr,"++ WARNING: %s grid mismatch with %s\n",
DSET_BRIKNAME(DSUB(0)) , DSET_BRIKNAME(DSUB(iv)) ) ;
if( DSUB(iv)->dblk->brick_fdrcurve ) have_fdr = 1 ;
angle = dset_obliquity_angle_diff(new_dset, DSUB(iv), -1.0);
if (angle > 0.0) {
WARNING_message(
"dataset %s has an obliquity difference of %f degress with %s\n",
new_dset ,
angle, DSUB(iv) );
}
}
/* if( ninp == 1 ) */ tross_Copy_History( DSUB(0) , new_dset ) ;
tross_Make_History( "3dbucket" , argc,argv , new_dset ) ;
EDIT_dset_items( new_dset ,
ADN_prefix , BUCK_output_prefix ,
ADN_directory_name, BUCK_session ,
ADN_type , BUCK_type ,
ADN_func_type , ISANATTYPE(BUCK_type) ? ANAT_BUCK_TYPE
: FUNC_BUCK_TYPE,
ADN_ntt , 0 ,
ADN_nvals , new_nvals ,
ADN_none ) ;
/* can't re-write existing dataset, unless glueing is used */
if (! BUCK_glue){
if( THD_deathcon() && THD_is_file(DSET_HEADNAME(new_dset)) ){
fprintf(stderr,"*** Fatal error: file %s already exists!\n",
DSET_HEADNAME(new_dset) ) ;
exit(1) ;
}
} else { /* if glueing is used, make the 'new'
dataset have the same idcode as the old one */
new_dset->idcode = DSUB(0) -> idcode ; /* copy the struct */
}
THD_force_malloc_type( new_dset->dblk , DATABLOCK_MEM_MALLOC ) ;
/* if there are fdr curves, allocate space 06 Feb 2008 [rickr] */
if( have_fdr ){
new_dset->dblk->brick_fdrcurve = (floatvec **)calloc(sizeof(floatvec *),
new_nvals) ;
if( !new_dset->dblk->brick_fdrcurve ){
fprintf(stderr,"** failed to alloc %d fdrcurves\n",new_nvals);
exit(1);
}
if( BUCK_verb ) printf("-verb: adding fdrcurve list\n");
new_dset->dblk->brick_mdfcurve = (floatvec **)calloc(sizeof(floatvec *),
/* 22 Oct 2008 */ new_nvals) ;
}
/*** loop over input datasets ***/
if( ninp > 1 ) myXtFree( new_dset->keywords ) ;
ivout = 0 ;
for( ids=0 ; ids < ninp ; ids++ ){
dset = DSUB(ids) ;
nv = NSUBV(ids) ;
if( ! BUCK_dry ){
DSET_load(dset) ; CHECK_LOAD_ERROR(dset) ;
}
/** loop over sub-bricks to output **/
for( iv=0 ; iv < nv ; iv++ ){
jv = SUBV(ids,iv) ; /* which sub-brick to use */
if( ! BUCK_dry ){
EDIT_substitute_brick( new_dset , ivout ,
DSET_BRICK_TYPE(dset,jv) , DSET_ARRAY(dset,jv) ) ;
/*----- preserve label when one exists --- Modified March 2010 ZSS*/
if (DSET_HAS_LABEL(dset, jv) )
sprintf (buf, "%s", DSET_BRICK_LABEL(dset,jv));
else
sprintf(buf,"%.12s[%d]",DSET_PREFIX(dset),jv) ;
EDIT_dset_items( new_dset , ADN_brick_label_one+ivout, buf , ADN_none ) ;
#if 0
sprintf(buf,"%s[%d]",DSET_FILECODE(dset),jv) ;
EDIT_dset_items(
new_dset, ADN_brick_keywords_replace_one+ivout, buf, ADN_none ) ;
#endif
EDIT_dset_items(
new_dset ,
ADN_brick_fac_one +ivout, DSET_BRICK_FACTOR(dset,jv),
#if 0
ADN_brick_keywords_append_one+ivout, DSET_BRICK_KEYWORDS(dset,jv) ,
#endif
ADN_none ) ;
/** possibly write statistical parameters for this sub-brick **/
kv = DSET_BRICK_STATCODE(dset,jv) ;
if( FUNC_IS_STAT(kv) ){ /* input sub-brick has stat params */
int npar = FUNC_need_stat_aux[kv] , lv ;
float * par = (float *) malloc( sizeof(float) * (npar+2) ) ;
float * sax = DSET_BRICK_STATAUX(dset,jv) ;
par[0] = kv ;
par[1] = npar ;
for( lv=0 ; lv < npar ; lv++ )
par[lv+2] = (sax != NULL) ? sax[lv] : 0.0 ;
EDIT_dset_items(new_dset ,
ADN_brick_stataux_one+ivout , par ,
ADN_none ) ;
free(par) ;
/* 2: if the input dataset has statistical parameters */
} else if( ISFUNC(dset) && /* dset has stat */
FUNC_IS_STAT(dset->func_type) && /* params */
jv == FUNC_ival_thr[dset->func_type] ){ /* thr sub-brick */
int npar , lv ;
float * par , * sax ;
kv = dset->func_type ;
npar = FUNC_need_stat_aux[kv] ;
par = (float *) malloc( sizeof(float) * (npar+2) ) ;
sax = dset->stat_aux ;
par[0] = kv ;
par[1] = npar ;
for( lv=0 ; lv < npar ; lv++ )
par[lv+2] = (sax != NULL) ? sax[lv] : 0.0 ;
EDIT_dset_items(new_dset ,
ADN_brick_stataux_one+ivout , par ,
ADN_none ) ;
free(par) ;
}
/** append any fdrcurve **/
if( have_fdr ){
/* fixed iv->jv (ick!), noticed by dglen 16 Mar 2010 [rickr] */
if(dset->dblk->brick_fdrcurve && dset->dblk->brick_fdrcurve[jv]){
COPY_floatvec(new_dset->dblk->brick_fdrcurve[ivout],
dset->dblk->brick_fdrcurve[jv]) ;
nfdr++;
}
else new_dset->dblk->brick_fdrcurve[ivout] = NULL ;
if(dset->dblk->brick_mdfcurve && dset->dblk->brick_mdfcurve[jv]){
COPY_floatvec(new_dset->dblk->brick_mdfcurve[ivout],
dset->dblk->brick_mdfcurve[jv]) ;
}
else new_dset->dblk->brick_mdfcurve[ivout] = NULL ;
}
/** print a message? **/
if( BUCK_verb ) printf("-verb: copied %s[%d] into %s[%d]\n" ,
DSET_FILECODE(dset) , jv ,
DSET_FILECODE(new_dset) , ivout ) ;
} else {
printf("-dry: would copy %s[%d] into %s[%d]\n" ,
DSET_FILECODE(dset) , jv ,
DSET_FILECODE(new_dset) , ivout ) ;
}
ivout++ ;
}
/** loop over all bricks in input dataset and
unload them if they aren't going into the output
(not required, but is done to economize on memory) **/
if( ! BUCK_dry && nv < DSET_NVALS(dset) ){
for( kv=0 ; kv < DSET_NVALS(dset) ; kv++ ){ /* all input sub-bricks */
for( iv=0 ; iv < nv ; iv++ ){ /* all output sub-bricks */
jv = SUBV(ids,iv) ;
if( jv == kv ) break ; /* input matches output */
}
if( iv == nv ){
mri_free( DSET_BRICK(dset,kv) ) ;
#if 0
if( BUCK_verb ) printf("-verb: unloaded unused %s[%d]\n" ,
DSET_FILECODE(dset) , kv ) ;
#endif
}
}
}
} /* end of loop over input datasets */
if( ! BUCK_dry ){
if( BUCK_verb ){
if( have_fdr ) fprintf(stderr,"-verb: added %d of %d fdr curves\n",
nfdr, new_nvals);
fprintf(stderr,"-verb: loading statistics\n") ;
}
THD_load_statistics( new_dset ) ;
if( BUCK_glue ) putenv("AFNI_DECONFLICT=OVERWRITE") ;
if( BUCK_glue && BUCK_ccode >= 0 )
THD_set_write_compression(BUCK_ccode) ; /* 16 Mar 2010 */
THD_write_3dim_dataset( NULL,NULL , new_dset , True ) ;
if( BUCK_verb ) fprintf(stderr,"-verb: wrote output: %s\n",DSET_BRIKNAME(new_dset)) ;
}
exit(0) ;
}
static char * BFIT_main( PLUGIN_interface * plint )
{
MCW_idcode * idc ;
THD_3dim_dataset * input_dset , * mask_dset = NULL ;
BFIT_data * bfd ;
BFIT_result * bfr ;
int nvals,ival , nran,nvox , nbin , miv=0 , sqr,sqt ;
float abot,atop,bbot,btop,pcut , eps,eps1 , hlast ;
float *bval , *cval ;
double aa,bb,xc ;
double chq,ccc,cdf ;
int ihqbot,ihqtop ;
int mcount,mgood , ii , jj , ibot,itop ;
float mask_bot=666.0 , mask_top=-666.0 , hbot,htop,dbin ;
char buf[THD_MAX_NAME+128] , tbuf[THD_MAX_NAME+128] , * tag ;
int * hbin , * jbin,*kbin=NULL , *jist[2] ;
MRI_IMAGE * flim ;
double aext=-1.0,bext=-1.0 ;
/*--------------------------------------------------------------------*/
/*----- Check inputs from AFNI to see if they are reasonable-ish -----*/
if( plint == NULL )
return "************************\n"
"BFIT_main: NULL input\n"
"************************" ;
/*-- read 1st line --*/
PLUTO_next_option(plint) ;
idc = PLUTO_get_idcode(plint) ;
input_dset = PLUTO_find_dset(idc) ;
if( input_dset == NULL )
return "****************************\n"
"BFIT_main: bad input dataset\n"
"****************************" ;
nvox = DSET_NVOX(input_dset) ;
nvals = DSET_NVALS(input_dset) ;
ival = (int) PLUTO_get_number(plint) ;
if( ival < 0 || ival >= nvals )
return "**************************\n"
"BFIT_main: bad Brick index\n"
"**************************" ;
DSET_load(input_dset) ;
if( DSET_ARRAY(input_dset,0) == NULL )
return "*****************************\n"
"BFIT_main: can't load dataset\n"
"*****************************" ;
tag = PLUTO_get_string(plint) ;
sqr = PLUTO_string_index(tag,NYESNO,YESNO_strings) ;
/*-- read 2nd line --*/
PLUTO_next_option(plint) ;
abot = PLUTO_get_number(plint) ;
atop = PLUTO_get_number(plint) ;
if( atop <= abot )
return "*** atop <= abot! ***" ;
PLUTO_next_option(plint) ;
bbot = PLUTO_get_number(plint) ;
btop = PLUTO_get_number(plint) ;
if( atop <= abot )
return "*** btop <= bbot! ***" ;
hlast = PLUTO_get_number(plint) ;
PLUTO_next_option(plint) ;
nran = (int) PLUTO_get_number(plint) ;
pcut = PLUTO_get_number(plint) ;
tag = PLUTO_get_string(plint) ;
sqt = PLUTO_string_index(tag,NYESNO,YESNO_strings) ;
/*-- read optional lines --*/
while( (tag=PLUTO_get_optiontag(plint)) != NULL ){
/*-- Mask itself --*/
if( strcmp(tag,"Mask") == 0 ){
idc = PLUTO_get_idcode(plint) ;
mask_dset = PLUTO_find_dset(idc) ;
if( mask_dset == NULL ){
return "******************************\n"
"BFIT_main: bad mask dataset\n"
"******************************" ;
}
if( DSET_NVOX(mask_dset) != nvox ){
return "************************************************************\n"
"BFIT_main: mask input dataset doesn't match source dataset\n"
"************************************************************" ;
}
miv = (int) PLUTO_get_number(plint) ;
if( miv >= DSET_NVALS(mask_dset) || miv < 0 ){
return "****************************************************\n"
"BFIT_main: mask dataset sub-brick index is illegal\n"
"****************************************************" ;
}
DSET_load(mask_dset) ;
if( DSET_ARRAY(mask_dset,miv) == NULL ){
return "*************************************\n"
"BFIT_main: can't load mask dataset\n"
"*************************************" ;
}
continue ;
}
/*-- Mask range of values --*/
if( strcmp(tag,"Range") == 0 ){
if( mask_dset == NULL ){
return "******************************************\n"
"BFIT_main: Can't use Range without Mask\n"
"******************************************" ;
}
mask_bot = PLUTO_get_number(plint) ;
mask_top = PLUTO_get_number(plint) ;
continue ;
}
/*-- Extra plot --*/
if( strcmp(tag,"Extra") == 0 ){
aext = PLUTO_get_number(plint) ;
bext = PLUTO_get_number(plint) ;
continue ;
}
}
/*------------------------------------------------------*/
/*---------- At this point, the inputs are OK ----------*/
bfd = BFIT_prepare_dataset( input_dset , ival , sqr ,
mask_dset , miv , mask_bot , mask_top ) ;
if( bfd == NULL ) return "*** BFIT_prepare_dataset fails ***" ;
bfr = BFIT_compute( bfd ,
pcut , abot,atop , bbot,btop , nran,200 ) ;
if( bfr == NULL ){
BFIT_free_data( bfd ) ;
return "*** BFIT_compute fails! ***" ;
}
itop = bfr->itop ;
mgood = bfr->mgood ;
ibot = bfd->ibot ;
bval = bfd->bval ;
cval = bfd->cval ;
mcount = bfd->mcount ;
xc = bfr->xcut ;
aa = bfr->a ;
bb = bfr->b ;
eps = bfr->eps ;
eps1 = 1.0 - eps ;
if( eps1 > 1.0 ) eps1 = 1.0 ;
eps1 = (mcount-ibot) * eps1 ;
/*-- compute and plot histogram --*/
/* original data was already squared (e.g., R**2 values) */
if( !sqr ){
hbot = 0.0 ; htop = 1.0 ; nbin = 200 ;
if( bval[mcount-1] < 1.0 ) htop = bval[mcount-1] ;
dbin = (htop-hbot)/nbin ;
hbin = (int *) calloc((nbin+1),sizeof(int)) ; /* actual histogram */
jbin = (int *) calloc((nbin+1),sizeof(int)) ; /* theoretical fit */
for( ii=0 ; ii < nbin ; ii++ ){ /* beta fit */
jbin[ii] = (int)( eps1 * ( beta_t2p(hbot+ii*dbin,aa,bb)
-beta_t2p(hbot+ii*dbin+dbin,aa,bb) ) ) ;
}
jist[0] = jbin ;
flim = mri_new_vol_empty( mcount-ibot,1,1 , MRI_float ) ;
mri_fix_data_pointer( bval+ibot , flim ) ;
mri_histogram( flim , hbot,htop , TRUE , nbin,hbin ) ;
/* "extra" histogram (nominal values?) */
if( aext > 0.0 ){
kbin = (int *) calloc((nbin+1),sizeof(int)) ;
jist[1] = kbin ;
for( ii=0 ; ii < nbin ; ii++ ){ /* beta fit */
kbin[ii] = (int)( eps1 * ( beta_t2p(hbot+ii*dbin,aext,bext)
-beta_t2p(hbot+ii*dbin+dbin,aext,bext) ) ) ;
}
}
} else { /* original data was not squared (e.g., correlations) */
double hb,ht ;
htop = 1.0 ; nbin = 200 ;
if( bval[mcount-1] < 1.0 ) htop = sqrt(bval[mcount-1]) ;
hbot = -htop ;
dbin = (htop-hbot)/nbin ;
hbin = (int *) calloc((nbin+1),sizeof(int)) ; /* actual histogram */
jbin = (int *) calloc((nbin+1),sizeof(int)) ; /* theoretical fit */
for( ii=0 ; ii < nbin ; ii++ ){ /* beta fit */
hb = hbot+ii*dbin ; ht = hb+dbin ;
hb = hb*hb ; ht = ht*ht ;
if( hb > ht ){ double qq=hb ; hb=ht ; ht=qq ; }
jbin[ii] = (int)( 0.5*eps1 * ( beta_t2p(hb,aa,bb)
-beta_t2p(ht,aa,bb) ) ) ;
}
jist[0] = jbin ;
flim = mri_new_vol_empty( mcount-ibot,1,1 , MRI_float ) ;
mri_fix_data_pointer( cval+ibot , flim ) ;
mri_histogram( flim , hbot,htop , TRUE , nbin,hbin ) ;
/* nominal fit */
if( aext > 0.0 ){
kbin = (int *) calloc((nbin+1),sizeof(int)) ;
jist[1] = kbin ;
for( ii=0 ; ii < nbin ; ii++ ){ /* beta fit */
hb = hbot+ii*dbin ; ht = hb+dbin ;
hb = hb*hb ; ht = ht*ht ;
if( hb > ht ){ double qq=hb ; hb=ht ; ht=qq ; }
kbin[ii] = (int)( 0.5*eps1 * ( beta_t2p(hb,aext,bext)
-beta_t2p(ht,aext,bext) ) ) ;
}
}
}
sprintf(buf,"%s[%d] a=%.2f b=%.2f \\epsilon=%.2f %%=%.0f",
DSET_FILECODE(input_dset),ival,aa,bb,eps,pcut ) ;
ccc = bfr->q_chisq ;
/* blow up histogram details by sqrt-ing, if ordered */
if( sqt ){
for( ii=0 ; ii < nbin ; ii++ ){
hbin[ii] = (int) sqrt( (double)(100*hbin[ii]+0.5) ) ;
jbin[ii] = (int) sqrt( (double)(100*jbin[ii]+0.5) ) ;
if( kbin!=NULL )
kbin[ii] = (int) sqrt( (double)(100*kbin[ii]+0.5) ) ;
}
}
/* and plot */
sprintf(tbuf,"\\beta fit: cutoff=%.2f nvox=%d q(\\chi^2)=%8.2e",
(sqr)?sqrt(xc):xc , mgood , ccc ) ;
if( sqt ){
ii = strlen(tbuf) ;
sprintf( tbuf+ii , " \\surd ogram" ) ;
}
if( hlast > 0.0 ){
hbin[nbin-1] = jbin[nbin-1] = hlast ;
if( kbin != NULL ) kbin[nbin-1] = hlast ;
}
PLUTO_histoplot( nbin,hbot,htop,hbin ,
tbuf,NULL,buf , (kbin==NULL)?1:2 , jist ) ;
/* cleanup */
mri_clear_data_pointer(flim) ; mri_free(flim) ;
free(hbin) ; free(jbin) ; if( kbin != NULL ) free(kbin);
BFIT_free_data(bfd) ; BFIT_free_result(bfr) ;
return NULL ;
}
int main(int argc, char *argv[])
{
int CHECK = 0;
int iarg;
char *Fname_input = NULL;
char *Fname_output = NULL;
char *Fname_outputBV = NULL;
char *Fname_bval = NULL;
int opt;
FILE *fin=NULL, *fout=NULL, *finbv=NULL, *foutBV=NULL;
int i,j,k;
int BZER=0,idx=0,idx2=0;
MRI_IMAGE *flim=NULL;
MRI_IMAGE *preREADIN=NULL;
MRI_IMAGE *preREADBVAL=NULL;
float *READIN=NULL;
float *READBVAL=NULL;
float OUT_MATR[MAXGRADS][7]; // b- or g-matrix
float OUT_GRAD[MAXGRADS][4]; // b- or g-matrix
int INV[3] = {1,1,1}; // if needing to switch
int FLAG[MAXGRADS];
float temp;
int YES_B = 0;
int EXTRA_ZEROS=0;
int HAVE_BVAL = 0;
int BVAL_OUT = 0;
int BVAL_OUT_SEP = 0;
float BMAX_REF = 1; // i.e., essentially zero
int IN_FORM = 0; // 0 for row, 1 for col
int OUT_FORM = 1; // 1 for col, 2 for bmatr
int HAVE_BMAX_REF=0 ; // referring to user input value
int count_in=0, count_out=0;
THD_3dim_dataset *dwset=NULL, *dwout=NULL;
int Nbrik = 0;
char *prefix=NULL ;
float **temp_arr=NULL, **temp_grad=NULL;
int Ndwi = 0, dwi=0, Ndwout = 0, Ndwi_final = 0, Ndwout_final = 0;
int Nvox = 0;
int DWI_COMP_FAC = 0;
int ct_dwi = 0;
float MaxDP = 0;
mainENTRY("1dDW_Grad_o_Mat"); machdep();
if (argc == 1) { usage_1dDW_Grad_o_Mat(1); exit(0); }
iarg = 1;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-help") == 0 ||
strcmp(argv[iarg],"-h") == 0 ) {
usage_1dDW_Grad_o_Mat(strlen(argv[iarg])>3 ? 2:1);
exit(0);
}
if( strcmp(argv[iarg],"-flip_x") == 0) {
INV[0] = -1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-flip_y") == 0) {
INV[1] = -1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-flip_z") == 0) {
INV[2] = -1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-keep_b0s") == 0) {
YES_B = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-put_zeros_top") == 0) {
EXTRA_ZEROS = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_grad_rows") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_grad_rows'\n") ;
Fname_input = argv[iarg];
count_in++;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_grad_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_grad_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_gmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matT_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 2;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_gmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matA_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 3;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_bmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matT_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 4;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_bmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matA_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 5;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_grad_rows") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_grad_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 0;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_grad_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_grad_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_gmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_gmatT_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 2;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_gmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_gmatA_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 3;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_bmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_bmatT_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 4;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_bmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_bmatA_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 5;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_bvals") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_bvals'\n") ;
Fname_bval = argv[iarg];
HAVE_BVAL = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-bmax_ref") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-bmax_ref'\n");
BMAX_REF = atof(argv[iarg]);
HAVE_BMAX_REF = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_bval_col") == 0) {
BVAL_OUT = 1;
iarg++ ; continue ;
}
// May,2015
if( strcmp(argv[iarg],"-out_bval_row_sep") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_bval_row_sep'\n") ;
Fname_outputBV = argv[iarg];
BVAL_OUT_SEP = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-proc_dset") == 0 ){ // in DWIs
if( ++iarg >= argc )
ERROR_exit("Need argument after '-proc_dset'") ;
dwset = THD_open_dataset( argv[iarg] ) ;
if( dwset == NULL )
ERROR_exit("Can't open DWI dataset '%s'", argv[iarg]) ;
DSET_load(dwset) ; CHECK_LOAD_ERROR(dwset) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-pref_dset") == 0 ){ // will be output
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-pref_dset'");
prefix = strdup(argv[iarg]) ;
if( !THD_filename_ok(prefix) )
ERROR_exit("Illegal name after '-pref_dset'");
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-dwi_comp_fac") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-dwi_comp_fac'\n");
DWI_COMP_FAC = atoi(argv[iarg]);
if (DWI_COMP_FAC <=1)
ERROR_exit("The compression factor after '-dwi_comp_fac'"
"must be >1!");
iarg++ ; continue ;
}
ERROR_message("Bad option '%s'\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * *
if( (Fname_input == NULL) ) {
fprintf(stderr,
"\n\tBad Command-lining! Option '-in_*' requires argument.\n");
exit(1);
}
if( (Fname_output == NULL) ) {
fprintf(stderr,
"\n\tBad Command-lining! Option '-out_*' requires arg.\n");
exit(2);
}
if( count_in > 1 ) {
fprintf(stderr,
"\n\tBad Command-lining! Can't have >1 vec file input.\n");
exit(3);
}
if( count_out > 1 ) {
fprintf(stderr,
"\n\tBad Command-lining! Can't have >1 output file opt.\n");
exit(4);
}
if(YES_B && dwset) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Can't have '-keep_b0s' and '-proc_dset' together.\n");
exit(5);
}
if( !prefix && dwset) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Need an output '-pref_dset' when using '-proc_dset'.\n");
exit(6);
}
if(YES_B && DWI_COMP_FAC) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Can't have '-keep_b0s' and '-dwi_comp_fac' together.\n");
exit(7);
}
if(!HAVE_BVAL && (BVAL_OUT || BVAL_OUT_SEP)) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Can't have ask for outputting bvals with no '-in_bvals FILE'.\n");
exit(8);
}
// ********************************************************************
// ************************* start reading ****************************
// ********************************************************************
flim = mri_read_1D (Fname_input);
if (flim == NULL) {
ERROR_exit("Error reading gradient vector file");
}
if( IN_FORM )
preREADIN = mri_transpose(flim); // effectively *undoes* autotranspose
else
preREADIN = mri_copy(flim);
mri_free(flim);
idx = preREADIN->ny;
if( HAVE_BVAL ) {
flim = mri_read_1D (Fname_bval);
if (flim == NULL) {
ERROR_exit("Error reading b-value file");
}
if( flim->ny == 1)
preREADBVAL = mri_transpose(flim); // effectively *undoes* autotransp
else
preREADBVAL = mri_copy(flim);
mri_free(flim);
idx2 = preREADBVAL->ny;
}
if(idx>= MAXGRADS ) {
printf("Error, too many input grads.\n");
mri_free (preREADIN);
if( HAVE_BVAL ) mri_free (preREADBVAL);
exit(4);
}
if( ( (preREADIN->nx != 3 ) && (preREADIN->ny != 3 )) &&
(preREADIN->nx != 6 ) )
printf("Probably an error, "
"because there aren't 3 or 6 numbers in columns!\n");
if( HAVE_BVAL && ( idx != idx2 ) ) {
printf("Error, because the number of bvecs (%d)\n"
"and bvals (%d) don't appear to match!\n", idx, idx2);
mri_free (preREADIN);
mri_free (preREADBVAL);
exit(3);
}
if(dwset) {
Nbrik = DSET_NVALS(dwset);
if( idx != Nbrik ) {
fprintf(stderr,
"\n** ERROR: the number of bvecs (%d) does not match the "
"number of briks in '-proc_dset' (%d).\n", idx, Nbrik);
exit(4);
}
}
READIN = MRI_FLOAT_PTR( preREADIN );
if( HAVE_BVAL )
READBVAL = MRI_FLOAT_PTR( preREADBVAL );
// 0 is grad row;
// 1 is grad col;
// 2 is gmatrRow col T;
// 3 is gmatrDiag col A;
// 4 is bmatrRow col T;
// 5 is bmatrDiag col A;
//if( IN_FORM == 0 ) // grad rows, no binfo
// for( i=0; i<idx ; i++ )
// for ( j=0; j<3 ; j++ )
// OUT_GRAD[i][j+1] = *(READIN +j*idx +i) ;
//else
if ( IN_FORM <= 1 ) // grad cols, no binfo
for( i=0; i<idx ; i++ )
for ( j=0; j<3 ; j++ )
OUT_GRAD[i][j+1] = *(READIN + 3*i+j);
// A/row/3dDWItoDT: Bxx, Byy, Bzz, Bxy, Bxz, Byz
// T/diag/TORTOISE: b_xx 2b_xy 2b_xz b_yy 2b_yz b_zz
else if ( (IN_FORM == 3) || (IN_FORM ==5 ) ) { // diag matr
for( i=0; i<idx ; i++ ) {
for( j=0; j<3 ; j++ ) {
OUT_MATR[i][j+1] = *(READIN+6*i+j);
OUT_MATR[i][3+j+1] = *(READIN+6*i+3+j);
}
for( j=0; j<3 ; j++ )
if(OUT_MATR[i][j] < 0 )
CHECK++;
}
if(CHECK > 0)
INFO_message("Warning: you *said* you input a mat'T',"
" but the matr diagonals don't appear to be uniformly"
" positive. If input cols 0, 3 and 5 are positive,"
" then you might have meant mat'A'?");
}
else if ( (IN_FORM ==2 ) || (IN_FORM ==4 ) ) { // row matr
CHECK = 0;
for( i=0; i<idx ; i++ ) {
OUT_MATR[i][1] = *(READIN +6*i);
OUT_MATR[i][2] = *(READIN +6*i+3);
OUT_MATR[i][3] = *(READIN +6*i+5);
OUT_MATR[i][4] = *(READIN +6*i+1)/2.;
OUT_MATR[i][5] = *(READIN +6*i+2)/2.;
OUT_MATR[i][6] = *(READIN +6*i+4)/2.;
}
for( i=0; i<idx ; i++ )
for( j=0; j<3 ; j++ )
if(OUT_MATR[i][j] < 0 )
CHECK++;
if(CHECK > 0)
INFO_message("Warning: you *said* you input a mat'A',"
" but the matr diagonals don't appear to be uniformly"
" positive. If input cols 0, 1 and 2 are positive,"
" then you might have meant mat'T'?");
}
else{
fprintf(stderr, "Coding error with format number (%d), not allowed.\n",
IN_FORM);
exit(2);
}
// get bval info
if( ( (IN_FORM ==4 ) || (IN_FORM ==5 ) ) ) { //bval
for( i=0; i<idx ; i++ ) {
OUT_MATR[i][0] = OUT_GRAD[i][0] =
OUT_MATR[i][1] + OUT_MATR[i][2] + OUT_MATR[i][3];
if( OUT_MATR[i][0] > 0.000001)
for( j=1 ; j<7 ; j++ )
OUT_MATR[i][j]/= OUT_MATR[i][0];
}
}
else if ( HAVE_BVAL )
for( i=0; i<idx ; i++ ) {
OUT_MATR[i][0] = OUT_GRAD[i][0] = *(READBVAL + i);
}
else if ( OUT_FORM > 3 || BVAL_OUT || BVAL_OUT_SEP || HAVE_BMAX_REF ) {
fprintf(stderr, "ERROR: you asked for b-value dependent output, "
"but gave me no bvals to work with.\n");
exit(2);
}
// * * * ** * * * * * * * * ** ** * * ** * * ** * ** * ** * * *
// at this point, all IN_FORM >1 cases which need bval have led to:
// + grad[0] has bval
// + matr[0] has bval
// + matr file normalized and in diagonal form
// * * * ** * * * * * * * * ** ** * * ** * * ** * ** * ** * * *
for( i=0; i<idx ; i++ )
if( IN_FORM > 1)
j = GradConv_Gsign_from_BmatA( OUT_GRAD[i]+1, OUT_MATR[i]+1);
else
j = GradConv_BmatA_from_Gsign( OUT_MATR[i]+1, OUT_GRAD[i]+1);
// flip if necessary
for( i=0 ; i<idx ; i++) {
for( j=0 ; j<3 ; j++)
OUT_GRAD[i][j+1]*= INV[j];
OUT_MATR[i][4]*= INV[0]*INV[1];
OUT_MATR[i][5]*= INV[0]*INV[2];
OUT_MATR[i][6]*= INV[1]*INV[2];
}
BZER=0;
for( i=0 ; i<idx ; i++) {
if( HAVE_BVAL || (IN_FORM ==4) || (IN_FORM ==5) )
if( OUT_GRAD[i][0] >= BMAX_REF )
FLAG[i] = 1;
else{
if( YES_B )
FLAG[i] = 1;
BZER++;
}
else {
temp = 0.;
for( j=1 ; j<4 ; j++)
temp+= pow(OUT_GRAD[i][j],2);
if( temp > 0.1 )
FLAG[i] = 1;
else{
if( YES_B )
FLAG[i] = 1;
BZER++;
}
}
}
if(YES_B) {
printf("\tChose to *keep* %d b0s,\tas well as \t%d grads\n",
BZER,idx-BZER);
BZER=0;
}
else {
printf("\tGetting rid of %d b0s,\tleaving the %d grads\n",
BZER,idx-BZER);
Ndwi = idx-BZER;
}
Ndwi_final = idx-BZER; // default: all DWIs
if( DWI_COMP_FAC ) {
if( Ndwi % DWI_COMP_FAC != 0 ) {
fprintf(stderr, "\n** ERROR can't compress: "
"Ndwi=%d, and %d/%d has a nonzero remainder (=%d).\n",
Ndwi,Ndwi,DWI_COMP_FAC, Ndwi % DWI_COMP_FAC );
exit(1);
}
else {
Ndwi_final = Ndwi/DWI_COMP_FAC;
INFO_message("You have chosen a compression factor of %d, "
"with %d DWIs,\n"
"\tso that afterward there will be %d DWIs.",
DWI_COMP_FAC, Ndwi, Ndwi_final);
}
}
if(BVAL_OUT_SEP)
if( (foutBV = fopen(Fname_outputBV, "w")) == NULL) {
fprintf(stderr, "\n\nError opening file %s.\n",Fname_outputBV);
exit(1);
}
if( (fout = fopen(Fname_output, "w")) == NULL) {
fprintf(stderr, "\n\nError opening file %s.\n",Fname_output);
exit(1);
}
// 0 is grad row;
// 1 is grad col;
// 2 is gmatrRow col T;
// 3 is gmatrDiag col A;
// 4 is bmatrRow col T;
// 5 is bmatrDiag col A;
if( OUT_FORM>0) {
if( EXTRA_ZEROS ) {
if( BVAL_OUT )
fprintf(fout,"%8d ", 0);
if( BVAL_OUT_SEP )
fprintf(foutBV,"%8d ", 0);
if( OUT_FORM == 1 )
for( k=1 ; k<4 ; k++ )
fprintf(fout,"%11.5f ", 0.0);
else if ( OUT_FORM > 1 ) // bit superfluous at this point
for( k=1 ; k<7 ; k++ )
fprintf(fout,"%11.5f ", 0.0);
fprintf(fout,"\n");
}
ct_dwi = 0;
for(i=0 ; i<idx ; i++){
if(FLAG[i]) {
if( BVAL_OUT )
fprintf(fout,"%8d ", (int) OUT_GRAD[i][0]);
if( BVAL_OUT_SEP )
fprintf(foutBV,"%8d ", (int) OUT_GRAD[i][0]);
if( (OUT_FORM == 4) || (OUT_FORM ==5) )
for( k=1 ; k<7 ; k++ )
OUT_MATR[i][k]*= OUT_MATR[i][0];
if( OUT_FORM == 1 ) // grad col
for( k=1 ; k<4 ; k++ )
fprintf(fout,"%11.5f ", OUT_GRAD[i][k]);
else if( (OUT_FORM == 3) || (OUT_FORM == 5) ) { // gmat
for( k=1 ; k<6 ; k++ )
fprintf(fout,"%11.5f ", OUT_MATR[i][k]);
fprintf(fout,"%11.5f", OUT_MATR[i][k]);
}
else if ( (OUT_FORM == 2 ) || (OUT_FORM ==4)) { // bmat
fprintf(fout,"%11.5f ", OUT_MATR[i][1]);
fprintf(fout,"%11.5f ", 2*OUT_MATR[i][4]);
fprintf(fout,"%11.5f ", 2*OUT_MATR[i][5]);
fprintf(fout,"%11.5f ", OUT_MATR[i][2]);
fprintf(fout,"%11.5f ", 2*OUT_MATR[i][6]);
fprintf(fout,"%11.5f", OUT_MATR[i][3]);
}
fprintf(fout,"\n");
ct_dwi++;
}
if( (ct_dwi == Ndwi_final) && DWI_COMP_FAC ) {
INFO_message("Reached compression level: DWI number %d",
Ndwi_final);
break;
}
}
}
else if(OUT_FORM ==0) {
if(BVAL_OUT)
WARNING_message("Ignoring '-out_bval_col' option, since "
" you are outputting in rows.");
for( k=1 ; k<4 ; k++ ) {
if(EXTRA_ZEROS){
fprintf(fout,"% -11.5f ", 0.0);
if( (k==1) && BVAL_OUT_SEP ) // only output 1 zeroin bval file
fprintf(foutBV,"%8d ", 0);
}
ct_dwi = 0;
for(i=0 ; i<idx ; i++) {
if(FLAG[i]) {
fprintf(fout,"% -11.5f ", OUT_GRAD[i][k]);
if( (k==1) && BVAL_OUT_SEP )// only output 1 zeroin bval file
fprintf(foutBV,"%8d ", (int) OUT_GRAD[i][0]);
ct_dwi++;
}
if( (ct_dwi == Ndwi_final) && DWI_COMP_FAC ) {
INFO_message("Reached compression level: DWI number %d",
Ndwi_final);
break;
}
}
fprintf(fout,"\n");
}
}
fclose(fout);
if( BVAL_OUT_SEP ) {
fprintf(foutBV,"\n");
fclose(foutBV);
}
if(dwset) {
INFO_message("Processing the B0+DWI file now.");
if(!BZER) {
fprintf(stderr, "\n** Error in processing data set: "
"no b=0 values from bvecs/bval info!\n");
exit(5);
}
// FLAG marks where DWIs are if not using '-keep_b0s'!
Nvox = DSET_NVOX(dwset);
Ndwout = Ndwi+1;
temp_arr = calloc( Ndwout,sizeof(temp_arr));
for( i=0 ; i<Ndwout ; i++)
temp_arr[i] = calloc( Nvox,sizeof(float));
temp_grad = calloc( Ndwi,sizeof(temp_grad));
for( i=0 ; i<Ndwi ; i++)
temp_grad[i] = calloc( 3,sizeof(float));
if( (temp_arr == NULL) || (temp_grad == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(123);
}
dwi = 0; // keep track of DWI contraction
for( i=0 ; i<Nbrik ; i++)
if( !FLAG[i] ) // b=0
for( j=0 ; j<Nvox ; j++)
temp_arr[0][j]+= THD_get_voxel(dwset,j,i);
else {
for( j=0 ; j<3 ; j++)
temp_grad[dwi][j]= OUT_GRAD[i][j+1];
dwi++;
for( j=0 ; j<Nvox ; j++)
temp_arr[dwi][j]+= THD_get_voxel(dwset,j,i);
}
if( dwi != Ndwi ) {
fprintf(stderr, "\n** Mismatch in internal DWI counting!\n");
exit(6);
}
// average the values
for( j=0 ; j<Nvox ; j++)
temp_arr[0][j]/= BZER; // can't be zero here.
if( DWI_COMP_FAC ) {
INFO_message("Compressing DWI file");
for( k=1 ; k<DWI_COMP_FAC ; k++)
for( i=0 ; i<Ndwi_final ; i++)
for( j=0 ; j<Nvox ; j++)
temp_arr[1+i][j]+= temp_arr[1+k*Ndwi_final+i][j];
for( i=0 ; i<Ndwi_final ; i++)
for( j=0 ; j<Nvox ; j++)
temp_arr[1+i][j]/= DWI_COMP_FAC;
INFO_message("Checking closeness of compressed gradient values");
MaxDP = GradCloseness(temp_grad, Ndwi, DWI_COMP_FAC);
INFO_message("The max angular difference between matched/compressed\n"
"\tgradients is: %f", MaxDP);
if( MaxDP > 2)
WARNING_message("The max angular difference seem kinda big-- you\n"
" sure about the compression factor?");
}
Ndwout_final = Ndwi_final + 1;
INFO_message("Writing the processed data set.");
dwout = EDIT_empty_copy( dwset );
EDIT_dset_items(dwout,
ADN_nvals, Ndwout_final,
ADN_ntt, 0,
ADN_datum_all, MRI_float ,
ADN_prefix, prefix,
ADN_none );
for( i=0; i<Ndwout_final ; i++) {
EDIT_substitute_brick(dwout, i, MRI_float, temp_arr[i]);
temp_arr[i]=NULL;
}
// if necessary
for( i=Ndwout_final ; i<Ndwout ; i++)
temp_arr[i]=NULL;
THD_load_statistics( dwout );
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(dwout)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(dwout));
tross_Make_History("1dDW_Grad_o_Mat", argc, argv, dwout);
THD_write_3dim_dataset(NULL, NULL, dwout, True);
DSET_delete(dwout);
free(dwout);
DSET_delete(dwset);
free(dwset);
for( i=0 ; i<Ndwout_final ; i++)
free(temp_arr[i]);
free(temp_arr);
}
mri_free(preREADIN);
if( HAVE_BVAL )
mri_free(preREADBVAL);
if(prefix)
free(prefix);
printf("\n\tDone. Check output file '%s' for results",Fname_output);
if(dwset) {
printf("\n\t-> as well as the data_set '%s'",DSET_FILECODE(dwout));
}
if(BVAL_OUT_SEP)
printf("\n\t-> and even the b-value rows '%s'",Fname_outputBV);
printf("\n\n");
exit(0);
}
static char * DELAY_main( PLUGIN_interface * plint )
{
hilbert_data_V2 uda,*ud;
MRI_IMAGE * tsim;
MCW_idcode * idc ; /* input dataset idcode */
THD_3dim_dataset * old_dset , * new_dset ; /* input and output datasets */
char *tmpstr , * str , *nprfxstr; /* strings from user */
int ntime, nvec ,nprfx, i;
float * vec , fs , T ;
/* Allocate as much character space as Bob specifies in afni.h + a bit more */
tmpstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char));
nprfxstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char));
if (tmpstr == NULL || nprfxstr == NULL)
return "********************\n"
"Could not Allocate\n"
"a teeni weeni bit of\n"
"Memory ! \n"
"********************\n";
ud = &uda; /* ud now points to an allocated space */
ud->errcode = 0; /*reset error flag */
/*--------------------------------------------------------------------*/
/*----- Check inputs from AFNI to see if they are reasonable-ish -----*/
/*--------- go to first input line ---------*/
PLUTO_next_option(plint) ;
idc = PLUTO_get_idcode(plint) ; /* get dataset item */
old_dset = PLUTO_find_dset(idc) ; /* get ptr to dataset */
if( old_dset == NULL )
return "*************************\n"
"Cannot find Input Dataset\n"
"*************************" ;
ud->dsetname = DSET_FILECODE (old_dset);
ud->nsamp = DSET_NUM_TIMES (old_dset);
ud->Navg = 1 ; /* Navg does not play a role for the p value, averaging increases sensitivity */
ud->Nort = PLUTO_get_number(plint) ; /* Should be two by default, for mean and linear trend */
ud->Nfit = 2 ; /* Always 2 for phase and amplitude for this plugin */
/*--------- go to 2nd input line, input time series ---------*/
PLUTO_next_option(plint) ;
tsim = PLUTO_get_timeseries(plint);
if (tsim == NULL) return "No Timeseries Input";
ud->ln = (int)tsim -> nx; /* number of points in each vector */
nvec = tsim -> ny; /* number of vectors */
ud->rvec = (float *) MRI_FLOAT_PTR(tsim); /* vec[i+j*nx] = ith point of jth vector */
/* for i=0 .. ntime-1 and j=0 .. nvec-1 */
if (is_vect_null (ud->rvec,ud->ln) == 1) /* check if ref vect is all zeroes */
{
return "Reference vector is all zeros";
}
ud->refname = tsim->name;
ud->ignore = PLUTO_get_number(plint) ; /* get number item */
str = PLUTO_get_string(plint) ;
ud->Dsamp = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ) ;
/*--------- go to 3rd input line, sampling frequency, and stimulus period ---------*/
PLUTO_next_option(plint) ;
ud->fs = PLUTO_get_number(plint) ; /* get number item */
ud->T = PLUTO_get_number(plint) ; /* get number item */
ud->co = PLUTO_get_number(plint) ; /* get number item */
str = PLUTO_get_string(plint) ;
ud->biasrem = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ) ;
/*--------- go to 4th input line, delay units and wrp option---------*/
PLUTO_next_option(plint) ;
ud->Nseg = (int)PLUTO_get_number(plint) ; /* get number item */
ud->Pover = (int)PLUTO_get_number(plint) ; /* get number item */
str = PLUTO_get_string(plint) ; /* get string item (the method) */
ud->unt = (int)PLUTO_string_index( str , /* find it in list it is from */
NUM_METHOD_STRINGS ,
method_strings ) ;
str = PLUTO_get_string(plint) ;
ud->wrp = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ) ;
/*--------- go to 5th input line Output prefix ---------*/
PLUTO_next_option(plint) ;
ud->new_prefix = PLUTO_get_string(plint) ; /* get string item (the output prefix) */
/* check to see if the field is empty */
if (ud->new_prefix == NULL)
nprfx = 0;
else
nprfx = 1;
/* check if the size is larger than 0. I did not want to check for this unless it's allocated */
if (nprfx == 1 && (int)strlen (ud->new_prefix) == 0)
nprfx = 0;
if (nprfx == 0) /* now create the new name and make new_prefix point to it */
{
sprintf (nprfxstr,"%s.DEL",DSET_PREFIX (old_dset));
ud->new_prefix = nprfxstr;
/*printf ("New prefix is set to be : %s\n\a",ud->new_prefix);*/
}
if( ! PLUTO_prefix_ok(ud->new_prefix) ) /* check if it is OK */
return "************************\n"
"Output Prefix is illegal\n"
"************************" ;
str = PLUTO_get_string(plint) ; /* write delays to file ? */
ud->out = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings );
ud->strout = PLUTO_get_string(plint) ; /* strout is for the outiflename, which will be used after the debugging section */
if (ud->strout == NULL) /* if no output name is given, use the new_prefix */
{ud->strout = ud->new_prefix;}
else
{
if((int)strlen (ud->strout) == 0) ud->strout = ud->new_prefix;
}
str = PLUTO_get_string(plint) ;
ud->outts = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings );
/* ------------------Done with user parameters ---------------------------- */
ud->nxx = (int)old_dset->daxes->nxx; /* get data set dimensions */
ud->nyy = (int)old_dset->daxes->nyy;
ud->nzz = (int)old_dset->daxes->nzz;
/* No need for users to set these options ...*/
ud->dtrnd = 0;
if (ud->ln != (ud->nsamp - ud->ignore))
{
ud->errcode = ERROR_BADLENGTH;
return "***************************\n"
"Bad time series length \n"
"Check reference time series\n"
" or the ignore parameter \n"
"***************************\n";
}
if ((ud->unt < 0) || (ud->unt > 2)) /* unt error Check */
{
ud->errcode = ERROR_WRONGUNIT;
return "***********************\n"
" internal error: (ziad)\n"
"unt values out of bound\n"
"***********************\n"; /*unt must be between 0 and 2 */
}
if ((ud->wrp < 0) || (ud->wrp > 1)) /* wrp error Check */
{
ud->errcode = ERROR_WARPVALUES;
return "***********************\n"
" internal error: (ziad)\n"
"wrp values out of bound\n"
"***********************\n"; /* wrp must be between 0 and 1*/
}
if (ud->fs < 0.0) { /* fs error Check */
ud->errcode = ERROR_FSVALUES;
return "***********************\n"
" internal error: (ziad)\n"
"fs value is negative !\n"
"***********************\n"; /* fs must be >= 0*/
}
if (ud->T < 0.0) { /* T error Check */
ud->errcode = ERROR_TVALUES;
return "***********************\n"
" internal error: (ziad)\n"
"T value is negative !\n"
"***********************\n"; /*T must be >= 0 */
}
if ((ud->T == 0.0) && (ud->unt > 0)) /* unt error Check */
{
ud->errcode = ERROR_TaUNITVALUES;
return "***********************\n"
" internal error: (ziad)\n"
"T and unt val. mismatch\n"
"***********************\n"; /*T must be specified, and > 0 in order to use polar units*/
}
if ((ud->wrp == 1) && (ud->T == 0.0)) /* wrp error Check */
{
ud->errcode = ERROR_TaWRAPVALUES;
return "***********************\n"
" internal error: (ziad)\n"
"wrp and T val. mismatch\n"
"***********************\n"; /*T must be specified, and > 0 in order to use polar warp*/
}
if ((ud->out == NOPE) && (ud->outts == YUP))
{
ud->errcode = ERROR_OUTCONFLICT;
return"***********************\n"
"error: \n"
"Write flag must be on\n"
"to use Write ts\n"
"***********************\n";
}
/* Open the logfile, regardless of the ascii output files */
sprintf ( tmpstr , "%s.log" , ud->strout);
ud->outlogfile = fopen (tmpstr,"w");
if (ud->out == YUP) /* open outfile */
{
ud->outwrite = fopen (ud->strout,"w");
if (ud->outts == YUP)
{
sprintf ( tmpstr , "%s.ts" , ud->strout);
ud->outwritets = fopen (tmpstr,"w");
}
if ((ud->outwrite == NULL) || (ud->outlogfile == NULL) ||\
(ud->outwritets == NULL && ud->outts == YUP) )
{
ud->errcode = ERROR_FILEOPEN;
return "***********************\n"
"Could Not Write Outfile\n"
"***********************\n";
}
}
/* Write out user variables to Logfile */
write_ud (ud); /* writes user data to a file */
/*show_ud (ud,0); */ /* For some debugging */
/*------------- ready to compute new dataset -----------*/
new_dset = MAKER_4D_to_typed_fbuc ( old_dset , /* input dataset */
ud->new_prefix , /* output prefix */
-1, /* negative value indicating data type is like original brick */
ud->ignore , /* ignore count */
1 , /* detrend = ON Let BOB do it*/
NBUCKETS, /*Number of values at each voxel*/
DELAY_tsfuncV2 , /* timeseries processor (bucket version)*/
(void *)ud, /* data for tsfunc */
NULL, 0 ) ;
/* Setup the label, keywords and types of subbricks */
i = 0;
while (i < NBUCKETS)
{
switch (i)
{
case DELINDX: /* delay value in results vector */
EDIT_BRICK_LABEL (new_dset,i,"Delay");
EDIT_BRICK_ADDKEY (new_dset,i,"D");
++i;
break;
case COVINDX: /* covariance value in results vector */
EDIT_BRICK_LABEL (new_dset,i,"Covariance");
EDIT_BRICK_ADDKEY (new_dset,i,"I");
++i;
break;
case COFINDX: /* cross correlation coefficient value in results vector */
EDIT_BRICK_LABEL (new_dset,i,"Corr. Coef.");
EDIT_BRICK_ADDKEY (new_dset,i,"r");
/* Here you must modify either ud->Nfit or ud->Nort or most likely ud->nsamp based on ud->Navg */
EDIT_BRICK_TO_FICO (new_dset,i,ud->nsamp - ud->ignore,ud->Nfit,ud->Nort);
++i;
break;
case VARINDX: /* FMRI time course variance value in results vector */
EDIT_BRICK_LABEL (new_dset,i,"Variance");
EDIT_BRICK_ADDKEY (new_dset,i,"S2");
++i;
break;
default :
return "*********************\n"
"Internal Error (ziad)\n"
" Bad i value \n"
"*********************\n";
break;
}
}
if (!AFNI_noenv("AFNI_AUTOMATIC_FDR")) {
THD_create_all_fdrcurves( new_dset );
}
PLUTO_add_dset( plint , new_dset , DSET_ACTION_MAKE_CURRENT ) ;
if (ud->out == YUP) /* close outfile and outlogfile*/
{
fclose (ud->outlogfile);
fclose (ud->outwrite);
if (ud->outts == YUP) fclose (ud->outwritets);
}
else
{
if (ud->outlogfile != NULL) fclose (ud->outlogfile); /* close outlogfile */
}
free (tmpstr);
free (nprfxstr);
return NULL ; /* null string returned means all was OK */
}
int main( int argc , char * argv[] )
{
int ninp , ids , nv , iv,jv,kv , ivout , new_nvals ;
THD_3dim_dataset * new_dset=NULL , * dset ;
char buf[256] ;
/*----- Identify software -----*/
#if 0
printf ("\n\n");
printf ("Program: %s \n", PROGRAM_NAME);
printf ("Author: %s \n", PROGRAM_AUTHOR);
printf ("Initial Release: %s \n", PROGRAM_INITIAL);
printf ("Latest Revision: %s \n", PROGRAM_LATEST);
printf ("\n");
#endif
/*** read input options ***/
if( argc < 2 || strncmp(argv[1],"-help",4) == 0 ) B2F_Syntax() ;
mainENTRY("3dbuc2fim main"); machdep(); AFNI_logger(PROGRAM_NAME,argc,argv);
PRINT_VERSION("3dbuc2fim") ; AUTHOR(PROGRAM_AUTHOR);
B2F_read_opts( argc , argv ) ;
/*** create new dataset (empty) ***/
ninp = B2F_dsar->num ;
if( ninp < 1 ){
fprintf(stderr,"*** No input datasets?\n") ; exit(1) ;
}
new_nvals = 0 ;
for( ids=0 ; ids < ninp ; ids++ ) new_nvals += NSUBV(ids) ;
/*----- Check for acceptable number of sub-bricks -----*/
if (new_nvals < 1)
{ fprintf(stderr,"*** Less than 1 sub-brick specified\n") ; exit(1) ; }
if (new_nvals > 2)
{ fprintf(stderr,"*** More than 2 sub-bricks specified\n") ; exit(1) ; }
if( B2F_verb ) printf("-verb: output will have %d sub-bricks\n",new_nvals) ;
new_dset = EDIT_empty_copy( DSUB(0) ) ;
if( ninp == 1 ) tross_Copy_History( DSUB(0) , new_dset ) ;
tross_Make_History( "3dbuc2fim" , argc,argv , new_dset ) ;
/*----- Set default value for function type. This will be changed later,
if the second sub-brick has a statistic type. -----*/
if (new_nvals == 1)
B2F_func_type = FUNC_FIM_TYPE;
else
B2F_func_type = FUNC_THR_TYPE;
EDIT_dset_items (new_dset ,
ADN_prefix , B2F_output_prefix ,
ADN_directory_name, B2F_session ,
ADN_type , HEAD_FUNC_TYPE,
ADN_func_type , B2F_func_type,
ADN_ntt , 0 ,
ADN_nvals , new_nvals ,
ADN_none ) ;
if( THD_deathcon() && THD_is_file(DSET_HEADNAME(new_dset)) ){
fprintf(stderr,"*** Fatal error: file %s already exists!\n",
DSET_HEADNAME(new_dset) ) ;
exit(1) ;
}
THD_force_malloc_type( new_dset->dblk , DATABLOCK_MEM_MALLOC ) ;
/*** loop over input datasets ***/
if( ninp > 1 ) myXtFree( new_dset->keywords ) ;
ivout = 0 ;
for( ids=0 ; ids < ninp ; ids++ ){
dset = DSUB(ids) ;
nv = NSUBV(ids) ;
DSET_load(dset) ; CHECK_LOAD_ERROR(dset) ;
/** loop over sub-bricks to output **/
for( iv=0 ; iv < nv ; iv++ ){
jv = SUBV(ids,iv) ; /* which sub-brick to use */
EDIT_substitute_brick( new_dset , ivout ,
DSET_BRICK_TYPE(dset,jv) , DSET_ARRAY(dset,jv) ) ;
/*----- If this sub-brick is from a bucket dataset,
preserve the label for this sub-brick -----*/
if (dset->func_type == FUNC_BUCK_TYPE)
sprintf (buf, "%s", DSET_BRICK_LABEL(dset,jv));
else
sprintf(buf,"%.12s[%d]",DSET_PREFIX(dset),jv) ;
EDIT_dset_items( new_dset , ADN_brick_label_one+ivout, buf , ADN_none ) ;
#if 0
sprintf(buf,"%s[%d]",DSET_FILECODE(dset),jv) ;
EDIT_dset_items(
new_dset, ADN_brick_keywords_replace_one+ivout, buf, ADN_none ) ;
#endif
EDIT_dset_items(
new_dset ,
ADN_brick_fac_one +ivout, DSET_BRICK_FACTOR(dset,jv),
#if 0
ADN_brick_keywords_append_one+ivout, DSET_BRICK_KEYWORDS(dset,jv) ,
#endif
ADN_none ) ;
/** possibly write statistical parameters for this sub-brick **/
kv = DSET_BRICK_STATCODE(dset,jv) ;
if( FUNC_IS_STAT(kv) ){ /* input sub-brick has stat params */
int npar = MAX_STAT_AUX , lv ;
float * par = (float *) malloc( sizeof(float) * (npar) ) ;
float * sax = DSET_BRICK_STATAUX(dset,jv) ;
for( lv=0 ; lv < npar ; lv++ )
par[lv] = (sax != NULL && lv < FUNC_need_stat_aux[kv]) ? sax[lv] : 0.0;
if (ivout == 1)
{
EDIT_dset_items(new_dset ,
ADN_func_type , kv,
ADN_stat_aux, par ,
ADN_none ) ;
}
free(par) ;
/* 2: if the input dataset has statistical parameters */
} else if( ISFUNC(dset) && /* dset has stat */
FUNC_IS_STAT(dset->func_type) && /* params */
jv == FUNC_ival_thr[dset->func_type] ){ /* thr sub-brick */
int npar , lv ;
float * par , * sax ;
kv = dset->func_type ;
npar = MAX_STAT_AUX ;
par = (float *) malloc( sizeof(float) * (npar+2) ) ;
sax = dset->stat_aux ;
for( lv=0 ; lv < npar ; lv++ )
par[lv] = (sax != NULL) ? sax[lv] : 0.0 ;
if (ivout == 1)
{
for( lv=0 ; lv < npar+2 ; lv++ )
printf ("par[%d] = %f \n", lv, par[lv]);
EDIT_dset_items(new_dset ,
ADN_func_type , kv,
ADN_stat_aux, par ,
ADN_none ) ;
}
free(par) ;
}
/** print a message? **/
if( B2F_verb ) printf("-verb: copied %s[%d] into %s[%d]\n" ,
DSET_FILECODE(dset) , jv ,
DSET_FILECODE(new_dset) , ivout ) ;
ivout++ ;
}
/** loop over all bricks in input dataset and
unload them if they aren't going into the output
(not required, but is done to economize on memory) **/
if( nv < DSET_NVALS(dset) ){
for( kv=0 ; kv < DSET_NVALS(dset) ; kv++ ){ /* all input sub-bricks */
for( iv=0 ; iv < nv ; iv++ ){ /* all output sub-bricks */
jv = SUBV(ids,iv) ;
if( jv == kv ) break ; /* input matches output */
}
if( iv == nv ){
mri_free( DSET_BRICK(dset,kv) ) ;
#if 0
if( B2F_verb ) printf("-verb: unloaded unused %s[%d]\n" ,
DSET_FILECODE(dset) , kv ) ;
#endif
}
}
}
} /* end of loop over input datasets */
if( B2F_verb ) fprintf(stderr,"-verb: loading statistics\n") ;
THD_load_statistics( new_dset ) ;
THD_write_3dim_dataset( NULL,NULL , new_dset , True ) ;
if( B2F_verb ) fprintf(stderr,"-verb: wrote output: %s\n",DSET_BRIKNAME(new_dset)) ;
exit(0) ;
}