/*----------------------------------------------------------------------
**
** Main routine for this plugin (will be called from AFNI).
**
**----------------------------------------------------------------------
*/
char * HEMISUB_main( PLUGIN_interface * plint )
{
THD_3dim_dataset * dset, * new_dset;
MCW_idcode * idc;
hemi_s hs = { 0 };
char * new_prefix;
char * ret_string = NULL;
char * tag;
if ( plint == NULL )
return "------------------------\n"
"HEMISUB_main: NULL input\n"
"------------------------\n";
PLUTO_next_option( plint );
idc = PLUTO_get_idcode( plint );
dset = PLUTO_find_dset( idc );
if( dset == NULL )
return "-------------------------------\n"
"HEMISUB_main: bad input dataset\n"
"-------------------------------";
DSET_load( dset );
PLUTO_next_option( plint );
new_prefix = PLUTO_get_string( plint );
if ( ! PLUTO_prefix_ok( new_prefix ) )
return "------------------------\n"
"HEMISUB_main: bad prefix\n"
"------------------------\n";
if ( ( new_dset = PLUTO_copy_dset( dset, new_prefix ) ) == NULL )
return "------------------------------------------\n"
"HEMISUB_main: failed to copy input dataset\n"
"------------------------------------------\n";
tag = PLUTO_get_optiontag( plint );
if ( tag && ! strcmp( tag, "Thresh Type" ) )
{
tag = PLUTO_get_string( plint );
if ( tag != NULL )
hs.thresh_type = PLUTO_string_index( tag, NUM_T_OPTS, thresh_opts );
}
if ( ret_string = process_data( new_dset, &hs ) )
return ret_string;
if ( PLUTO_add_dset( plint, new_dset, DSET_ACTION_MAKE_CURRENT ) )
{
THD_delete_3dim_dataset( new_dset, False );
return "---------------------------------------\n"
"HEMISUB_main: failed to add new dataset\n"
"---------------------------------------\n";
}
return NULL;
}
DEFINE_PLUGIN_PROTOTYPE
PLUGIN_interface * PLUGIN_init( int ncall )
{
PLUGIN_interface * plint ; /* will be the output of this routine */
int meth ;
if( ncall > 0 ) return NULL ; /* only one interface */
/*---------------- set titles and call point ----------------*/
plint = PLUTO_new_interface( "Coord Order" ,
"Coordinate Order Display" ,
helpstring ,
PLUGIN_CALL_VIA_MENU , CORD_main ) ;
PLUTO_add_hint( plint , "Coordinate Order Display" ) ;
PLUTO_set_sequence( plint , "A:afnicontrol:display" ) ;
PLUTO_set_runlabels( plint , "Set+Keep" , "Set+Close" ) ; /* 04 Nov 2003 */
/*---------- 2nd line: other inputs ----------*/
PLUTO_add_option( plint ,
"Input" , /* label at left of input line */
"Input" , /* tag to return to plugin */
TRUE /* is this mandatory? */
) ;
meth = PLUTO_string_index( GLOBAL_library.cord.orcode ,
NUM_CORD_STRINGS ,
cord_strings ) ;
if( meth < 0 || meth >= NUM_CORD_STRINGS ) meth = 0 ;
PLUTO_add_string( plint ,
"Order" , /* label next to chooser button */
NUM_CORD_STRINGS , /* number of strings to choose among */
cord_strings , /* list of strings to choose among */
meth /* index of default string */
) ;
/*--------- done with interface setup ---------*/
return plint ;
}
char * STAVG_main( PLUGIN_interface * plint )
{
MCW_idcode * idc ; /* input dataset idcode */
THD_3dim_dataset * old_dset , * new_dset ; /* input and output datasets */
char * new_prefix , * str , * str2; /* strings from user */
int meth; /* chosen computation method */
int new_datum , /* control parameters */
old_datum , ntime ;
int te, ne, tinc, kim, nia;
int numepochs, minlength, maxlength, lastindex, navgpts;
int nvox , perc , new_units, old_units ;
int ii, ibot,itop , kk, jj;
int no1, user_maxlength, delta;
int *pEpochLength, *pTimeIndex;
int nx, ny, nz, npix;
float *pNumAvg;
float old_dtime;
MRI_IMAGE * stimim;
MRI_IMARR *avgimar;
byte ** bptr = NULL ; /* one of these will be the array of */
short ** sptr = NULL ; /* pointers to input dataset sub-bricks */
float ** fptr = NULL ; /* (depending on input datum type) */
float * fxar = NULL ; /* array loaded from input dataset */
float * stimar = NULL ;
float ** fout = NULL ; /* will be array of output floats */
float * tar = NULL ; /* will be array of taper coefficients */
float * nstimar;
/*--------------------------------------------------------------------*/
/*----- 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"
"*************************" ;
ntime = DSET_NUM_TIMES(old_dset) ;
if( ntime < 2 )
return "*****************************\n"
"Dataset has only 1 time point\n"
"*****************************" ;
ii = DSET_NVALS_PER_TIME(old_dset) ;
if( ii > 1 )
return "************************************\n"
"Dataset has > 1 value per time point\n"
"************************************" ;
old_datum = DSET_BRICK_TYPE( old_dset , 0 ) ; /* get old dataset datum type */
new_datum = old_datum;
old_dtime = DSET_TIMESTEP(old_dset);
old_units = DSET_TIMEUNITS(old_dset);
nvox = old_dset->daxes->nxx * old_dset->daxes->nyy * old_dset->daxes->nzz;
npix = old_dset->daxes->nxx * old_dset->daxes->nyy;
nx = old_dset->daxes->nxx;
new_prefix = PLUTO_get_string(plint) ; /* get string item (the output prefix) */
if( ! PLUTO_prefix_ok(new_prefix) ) /* check if it is OK */
return "************************\n"
"Output Prefix is illegal\n"
"************************" ;
/*--------- go to next input line ---------*/
PLUTO_next_option(plint);
stimim = PLUTO_get_timeseries(plint);
if( stimim == NULL ) return "Please specify stimulus timing";
if( stimim->nx < ntime ){
return "**************************************\n"
"Not enough pts in stimulus time-series\n"
"**************************************";
}
stimar = MRI_FLOAT_PTR(stimim);
delta = PLUTO_get_number(plint);
if( abs(delta) > ntime ){
return "************************\n"
"Delta shift is too large\n"
"************************";
}
/*initialize variables if not user specified */
user_maxlength = ntime;
no1 = 0;
/*--------- go to next input line ---------*/
PLUTO_next_option(plint);
str = PLUTO_get_string(plint) ; /* get string item (the method) */
meth = PLUTO_string_index( str , /* find it in list it is from */
_STAVG_NUM_METHODS ,
method_strings ) ;
/*--------- see if the 4th option line is present --------*/
str = PLUTO_get_optiontag( plint ) ;
if( str != NULL ){
user_maxlength = (int) PLUTO_get_number(plint) ;
str2 = PLUTO_get_string(plint) ; /* get string item (the method) */
no1 = PLUTO_string_index( str2 , /* find it in list it is from */
2 ,
yes_no_strings) ;
}
/*------------------------------------------------------*/
/*---------- At this point, the inputs are OK ----------*/
PLUTO_popup_meter( plint ) ; /* popup a progress meter */
/*________________[ Main Code ]_________________________*/
fout = avg_epochs( old_dset, stimar, user_maxlength, 1, meth, plint );
if( fout == NULL ) return " \nError in avg_epochs() function!\n " ;
if( RMB_DEBUG ) fprintf(stderr, "Done with avg_epochs\n");
maxlength = M_maxlength;
/*______________________________________________________*/
new_dset = EDIT_empty_copy( old_dset ) ; /* start with copy of old one */
{ char * his = PLUTO_commandstring(plint) ;
tross_Copy_History( old_dset , new_dset ) ;
tross_Append_History( new_dset , his ) ; free( his ) ;
}
/*-- edit some of its internal parameters --*/
ii = EDIT_dset_items(
new_dset ,
ADN_prefix , new_prefix , /* filename prefix */
ADN_malloc_type , DATABLOCK_MEM_MALLOC , /* store in memory */
ADN_datum_all , new_datum , /* atomic datum */
ADN_nvals , maxlength , /* # sub-bricks */
ADN_ntt , maxlength , /* # time points */
/* ADN_ttorg , old_dtime , */ /* time origin */
/* ADN_ttdel , old_dtime , */ /* time step */
/* ADN_ttdur , old_dtime , */ /* time duration */
/* ADN_nsl , 0 , */ /* z-axis time slicing */
/* ADN_tunits , old_units , */ /* time units */
ADN_none ) ;
if( ii != 0 ){
THD_delete_3dim_dataset( new_dset , False ) ;
FREE_WORKSPACE ;
return "***********************************\n"
"Error while creating output dataset\n"
"***********************************" ;
}
/*------------------------------------------------------------*/
/*------- The output is now in fout[kk][ii],
for kk=0..maxlength-1 , ii=0..nvox-1.
We must now put this into the output dataset -------*/
switch( new_datum ){
/*** output is floats is the simplest:
we just have to attach the fout bricks to the dataset ***/
case MRI_float:
for( kk=0 ; kk < maxlength ; kk++ )
EDIT_substitute_brick( new_dset , kk , MRI_float , fout[kk] ) ;
break ;
/*** output is shorts:
we have to create a scaled sub-brick from fout ***/
case MRI_short:{
short * bout ;
float fac ;
for( kk=0 ; kk < maxlength ; kk++ ){ /* loop over sub-bricks */
/*-- get output sub-brick --*/
bout = (short *) malloc( sizeof(short) * nvox ) ;
if( bout == NULL ){
fprintf(stderr,"\nFinal malloc error in plug_stavg!\n\a") ;
return("Final malloc error in plug_stavg!"); ;
/* exit(1) ;*/
}
/*-- find scaling and then scale --*/
/*fac = MCW_vol_amax( nvox,1,1 , MRI_float , fout[kk] ) ;*/
fac = 1.0;
EDIT_coerce_scale_type( nvox,fac ,
MRI_float,fout[kk] , MRI_short,bout ) ;
free( fout[kk] ) ; /* don't need this anymore */
/*-- put output brick into dataset, and store scale factor --*/
EDIT_substitute_brick( new_dset , kk , MRI_short , bout ) ;
}
}
break ;
/*** output is bytes (byte = unsigned char)
we have to create a scaled sub-brick from fout ***/
case MRI_byte:{
byte * bout ;
float fac ;
for( kk=0 ; kk < maxlength ; kk++ ){ /* loop over sub-bricks */
/*-- get output sub-brick --*/
bout = (byte *) malloc( sizeof(byte) * nvox ) ;
if( bout == NULL ){
fprintf(stderr,"\nFinal malloc error in plug_stavg!\n\a") ;
return("Final malloc error in plug_stavg!"); ;
/* exit(1) ;*/
}
/*-- find scaling and then scale --*/
fac = 1.0;
EDIT_coerce_scale_type( nvox,fac ,
MRI_float,fout[kk] , MRI_byte,bout ) ;
free( fout[kk] ) ; /* don't need this anymore */
/*-- put output brick into dataset, and store scale factor --*/
EDIT_substitute_brick( new_dset , kk , MRI_byte , bout ) ;
}
}
break ;
} /* end of switch on output data type */
/*-------------- Cleanup and go home ----------------*/
PLUTO_set_meter( plint , 100 ) ; /* set progress meter to 100% */
PLUTO_add_dset( plint , new_dset , DSET_ACTION_MAKE_CURRENT ) ;
FREE_WORKSPACE ;
return NULL ; /* null string returned means all was OK */
}
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 * POWER_main( PLUGIN_interface * plint )
{
MCW_idcode * idc ; /* input dataset idcode */
THD_3dim_dataset * old_dset , * new_dsetD3 , * new_dsetA3, * new_dsetavgD3 ; /* input and output datasets */
char * new_prefix , * str , * namestr, * filename; /* strings from user */
int new_datum , ignore , nfft , ninp , /* control parameters */
old_datum , nuse , ntaper , ktbot,
image_type, scale,OutputFlag ,numT,flip;
float avFac;
byte ** bptr = NULL ; /* one of these will be the array of */
short ** sptr = NULL ; /* pointers to input dataset sub-bricks */
float ** fptr = NULL ; /* (depending on input datum type) */
float * this = NULL ; /* array loaded from input dataset */
float ** foutD3 = NULL ; /* will be array of output floats */
float ** foutA3 = NULL ; /* will be array of output floats */
float ** foutavgD3 = NULL ; /* will be array of output floats */
float * tarD3 = NULL ; /* will be array of taper coefficients */
float * tarA3 = NULL ; /* will be array of taper coefficients */
float * taravgD3 = NULL ; /* will be array of taper coefficients */
/*float * flip;*/
float * numAv;
float dfreq , pfact , phi , xr,xi , yr,yi ;
float x0,x1 , y0,y1 , d0fac,d1fac ;
int nfreq , nvox , perc , new_units ;
int istr , ii,iip , ibot,itop , kk , icx ; /* temp variables */
new_prefix = (char *)calloc(100, sizeof(char));
filename = (char *)calloc(100, sizeof(char));
str = (char *)calloc(100, sizeof(char));
namestr = (char *)calloc(100, sizeof(char));
OutputFlag=0;
/*--------------------------------------------------------------------*/
/*----- 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 */
namestr = DSET_PREFIX(old_dset) ;
if( old_dset == NULL )
return "*************************\n"
"Cannot find Input Dataset\n"
"*************************" ;
/*--------- go to second input line ---------*/
PLUTO_next_option(plint) ;
filename = PLUTO_get_string(plint) ; /* get string item (the output prefix) */
sprintf(new_prefix,"%s%s",filename,"_D3");
if (strcmp(new_prefix,"_D3")==0){
OutputFlag=1;
sprintf(new_prefix,"%s%s",namestr,"_D3");
}
if (! PLUTO_prefix_ok(new_prefix) ){
PLUTO_popup_transient(plint,new_prefix);
return "*************************\n"
"Output filename already exists\n"
"*************************" ;
}
PLUTO_popup_transient(plint,"Output file tags set automatically");
str = PLUTO_get_string(plint) ; /* get string item (the datum type) */
istr = PLUTO_string_index( str , /* find it in the list it came from */
NUM_TYPE_STRINGS ,
type_strings ) ;
switch( istr ){
default:
case 0:
new_datum = MRI_float ; break ;
break ;
case 1: new_datum = MRI_byte ; break ; /* assign type of user's choice */
case 2: new_datum = MRI_short ; break ;
case 3: new_datum = DSET_BRICK_TYPE( old_dset , 0 ) ; /* use old dataset type */
}
/*--------- go to next input lines ---------*/
PLUTO_next_option(plint) ; /* skip to next line */
ignore = PLUTO_get_number(plint) ; /* get number item (ignore) */
ninp = DSET_NUM_TIMES(old_dset) ; /* number of values in input */
nuse = ninp; /* number of values to actually use */
nfreq=nuse;
nfft=nuse;
str = PLUTO_get_string(plint) ; /* get string item (the datum type) */
istr = PLUTO_string_index( str , /* find it in the list it came from */
NUM_TYPE_STRINGSX ,
type_stringsx ) ;
switch( istr ){
default:
case 0: image_type = 0; break;
}
PLUTO_next_option(plint) ; /* skip to next line */
scale = PLUTO_get_number(plint) ; /* get number item (scale) */
/*------------------------------------------------------*/
/*---------- At this point, the inputs are OK ----------*/
PLUTO_popup_meter( plint ) ; /* popup a progress meter */
/*--------- set up pointers to each sub-brick in the input dataset ---------*/
DSET_load( old_dset ) ; /* must be in memory before we get pointers to it */
old_datum = DSET_BRICK_TYPE( old_dset , 0 ) ; /* get old dataset datum type */
switch( old_datum ){ /* pointer type depends on input datum type */
default:
return "******************************\n"
"Illegal datum in Input Dataset\n"
"******************************" ;
/** create array of pointers into old dataset sub-bricks **/
/** Note that we skip the first 'ignore' sub-bricks here **/
/*--------- input is bytes ----------*/
/* voxel #i at time #k is bptr[k][i] */
/* for i=0..nvox-1 and k=0..nuse-1. */
case MRI_byte:
bptr = (byte **) malloc( sizeof(byte *) * nuse ) ;
if( bptr == NULL ) return "Malloc\nFailure!\n [bptr]" ;
for( kk=0 ; kk < nuse ; kk++ )
bptr[kk] = (byte *) DSET_ARRAY(old_dset,kk) ;
break ;
/*--------- input is shorts ---------*/
/* voxel #i at time #k is sptr[k][i] */
/* for i=0..nvox-1 and k=0..nuse-1. */
case MRI_short:
sptr = (short **) malloc( sizeof(short *) * nuse ) ;
if( sptr == NULL ) return "Malloc\nFailure!\n [sptr]" ;
for( kk=0 ; kk < nuse ; kk++ )
sptr[kk] = (short *) DSET_ARRAY(old_dset,kk) ;
break ;
/*--------- input is floats ---------*/
/* voxel #i at time #k is fptr[k][i] */
/* for i=0..nvox-1 and k=0..nuse-1. */
case MRI_float:
fptr = (float **) malloc( sizeof(float *) * nuse ) ;
if( fptr == NULL ) return "Malloc\nFailure!\n [fptr]" ;
for( kk=0 ; kk < nuse ; kk++ )
fptr[kk] = (float *) DSET_ARRAY(old_dset,kk) ;
break ;
} /* end of switch on input type */
/*---- allocate space for 2 voxel timeseries and 1 FFT ----*/
this = (float *) malloc( sizeof(float) * nuse ) ; /* input */
tarD3 = (float *) malloc( sizeof(float) * MAX(nuse,nfreq) ) ;
tarA3 = (float *) malloc( sizeof(float) * MAX(nuse,nfreq) ) ;
taravgD3 = (float *) malloc( sizeof(float) * MAX(nuse,nfreq) ) ;
/*flip = (float *)malloc( sizeof(float) * 1);*/
numAv = (float *)malloc( sizeof(float) * 1);
numT=nuse-ignore;
if (OutputFlag==1)
sprintf(new_prefix,"%s%s",namestr,"_D3");
else
sprintf(new_prefix,"%s%s",filename,"_D3");
new_dsetD3 = EDIT_empty_copy( old_dset );
{ char * his = PLUTO_commandstring(plint) ;
tross_Copy_History( old_dset , new_dsetD3 ) ;
tross_Append_History( new_dsetD3 , his ) ; free(his) ;
}
/*-- edit some of its internal parameters --*/
ii = EDIT_dset_items(
new_dsetD3 ,
ADN_prefix , new_prefix , /* filename prefix */
ADN_malloc_type , DATABLOCK_MEM_MALLOC , /* store in memory */
ADN_datum_all , new_datum , /* atomic datum */
ADN_nvals , numT ,
ADN_ntt ,numT,
ADN_none ) ;
if (OutputFlag==1)
sprintf(new_prefix,"%s%s",namestr,"_A3");
else
sprintf(new_prefix,"%s%s",filename,"_A3");
numT=nuse-ignore;
new_dsetA3 = EDIT_empty_copy( old_dset );
{ char * his = PLUTO_commandstring(plint) ;
tross_Copy_History( old_dset , new_dsetA3 ) ;
tross_Append_History( new_dsetA3 , his ) ; free(his) ;
}
/*-- edit some of its internal parameters --*/
ii = EDIT_dset_items(
new_dsetA3 ,
ADN_prefix , new_prefix , /* filename prefix */
ADN_malloc_type , DATABLOCK_MEM_MALLOC , /* store in memory */
ADN_datum_all , new_datum , /* atomic datum */
ADN_nvals , numT,
ADN_ntt ,numT,
ADN_none ) ;
if (OutputFlag==1)
sprintf(new_prefix,"%s%s",namestr,"_avgD3");
else
sprintf(new_prefix,"%s%s",filename,"_avgD3");
new_dsetavgD3 = EDIT_empty_copy( old_dset );
{ char * his = PLUTO_commandstring(plint) ;
tross_Copy_History( old_dset , new_dsetavgD3 ) ;
tross_Append_History( new_dsetavgD3 , his ) ; free(his) ;
}
/*-- edit some of its internal parameters --*/
ii = EDIT_dset_items(
new_dsetavgD3 ,
ADN_prefix , new_prefix , /* filename prefix */
ADN_malloc_type , DATABLOCK_MEM_MALLOC , /* store in memory */
ADN_datum_all , new_datum , /* atomic datum */
ADN_nvals , 1,
ADN_ntt ,1,
ADN_none ) ;
/*---------------------- make a new dataset ----------------------*/
/*-------------------making a new dataset------------------------------------*/
/*------ make floating point output sub-bricks
(only at the end will scale to byte or shorts)
Output #ii at freq #kk will go into fout[kk][ii],
for kk=0..nfreq-1, and for ii=0..nvox-1. ------*/
nvox = old_dset->daxes->nxx * old_dset->daxes->nyy * old_dset->daxes->nzz ;
foutD3 = (float **) malloc( sizeof(float *) * nuse ) ; /* ptrs to sub-bricks */
foutA3 = (float **) malloc( sizeof(float *) * nuse ) ; /* ptrs to sub-bricks */
foutavgD3 = (float **) malloc( sizeof(float *) * 1 ) ; /* ptrs to sub-bricks */
if( foutD3 == NULL | foutA3 == NULL | foutavgD3 == NULL){
THD_delete_3dim_dataset( new_dsetD3 , False ) ;
THD_delete_3dim_dataset( new_dsetA3 , False ) ;
THD_delete_3dim_dataset( new_dsetavgD3 , False ) ;
FREE_WORKSPACE ;
return "Malloc\nFailure!\n [fout]" ;
}
for( kk=0 ; kk < nfreq ; kk++ ){
foutD3[kk] = (float *) malloc( sizeof(float) * nvox ) ; /* sub-brick # kk */
foutA3[kk] = (float *) malloc( sizeof(float) * nvox ) ; /* sub-brick # kk */
foutavgD3[0] = (float *) malloc( sizeof(float) * nvox ) ; /* sub-brick # kk */
if( foutD3[kk] == NULL ) break ;
if( foutA3[kk] == NULL ) break ;
if( foutavgD3[0] == NULL ) break ;
}
if( kk < nfreq ){
for( ; kk >= 0 ; kk-- ){
FREEUP(foutD3[kk]) ;
FREEUP(foutA3[kk]) ;
FREEUP(foutavgD3[0]) ;
}/* free all we did get */
THD_delete_3dim_dataset( new_dsetD3 , False ) ;
THD_delete_3dim_dataset( new_dsetA3 , False ) ;
THD_delete_3dim_dataset( new_dsetavgD3 , False ) ;
FREE_WORKSPACE ;
return "Malloc\nFailure!\n [arrays]" ;
}
{ char buf[128] ;
ii = (nfreq * nvox * sizeof(float)) / (1024*1024) ;
sprintf( buf , " \n"
"*** 3D+time ASL a3/d3:\n"
"*** Using %d MBytes of workspace,\n "
"*** with # time points = %d\n" , ii,numT ) ;
PLUTO_popup_transient( plint , buf ) ;
}
/*----------------------------------------------------*/
/*----- Setup has ended. Now do some real work. -----*/
/***** loop over voxels *****/
/* *(flip)=scale; */
*(numAv)= nuse-ignore;
for( ii=0 ; ii < nvox ; ii ++ ){ /* time series */
switch( old_datum ){
case MRI_byte:
for( kk=0 ; kk < nuse ; kk++ ){
this[kk] = bptr[kk][ii] ;
}
break ;
case MRI_short:
for( kk=0 ; kk < nuse ; kk++ ){
this[kk] = sptr[kk][ii] ;
}
break ;
case MRI_float:
for( kk=0 ; kk < nuse ; kk++ ){
this[kk] = fptr[kk][ii] ;
}
break ;
}
flip=scale*pow(-1,ignore+1);
for( kk=0 ; kk < nuse-ignore ; kk++ ){
if (kk==nuse-1-ignore){
*(*(foutD3+kk)+ii)=
flip*( *(this+kk+ignore-1)-*(this+kk+ignore) );
*(*(foutA3+kk)+ii)=
2*(*(this+kk+ignore-1)+*(this+kk+ignore));
}
else if (kk==0){
/*D3 tag - control*/
*(*(foutD3+kk)+ii)=
flip*( *(this+kk+ignore)-*(this+kk+ignore+1) );
*(*(foutA3+kk)+ii)=
2*(*(this+kk+ignore)+*(this+kk+ignore+1));
}
else{
*(*(foutD3+kk)+ii)=
flip*( 1*(*(this+kk+ignore-1))+-2*(*(this+kk+ignore))+1*(*(this+kk+ignore+1)) );
*(*(foutA3+kk)+ii)=
((*(this+kk+ignore-1))+2*(*(this+kk+ignore))+(*(this+kk+ignore+1)));
flip=-1*flip;
}
}
for( kk=0 ; kk < nuse-ignore ; kk++ )
*(*(foutavgD3)+ii)= *(*(foutavgD3)+ii)+(*(*(foutD3+kk)+ii));
*(*(foutavgD3)+ii)=*(*(foutavgD3)+ii) / (*(numAv));
}
DSET_unload( old_dset ) ; /* don't need this no more */
switch( new_datum ){
/*** output is floats is the simplest:
we just have to attach the fout bricks to the dataset ***/
case MRI_float:
for( kk=0 ; kk < nuse-ignore ; kk++ )
EDIT_substitute_brick( new_dsetD3 , kk , MRI_float , foutD3[kk] ) ;
break ;
/*** output is shorts:
we have to create a scaled sub-brick from fout ***/
case MRI_short:{
short * boutD3 ;
float facD3 ;
for( kk=0 ; kk < nuse-ignore ; kk++ ){ /* loop over sub-bricks */
/*-- get output sub-brick --*/
boutD3 = (short *) malloc( sizeof(short) * nvox ) ;
if( boutD3 == NULL ){
fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ;
EXIT(1) ;
}
/*-- find scaling and then scale --*/
facD3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutD3[kk] ) ;
if( facD3 > 0.0 ){
facD3 = 32767.0 / facD3 ;
EDIT_coerce_scale_type( nvox,facD3 ,
MRI_float,foutD3[kk] , MRI_short,boutD3 ) ;
facD3 = 1.0 / facD3 ;
}
free( foutD3[kk] ) ; /* don't need this anymore */
/*-- put output brick into dataset, and store scale factor --*/
EDIT_substitute_brick( new_dsetD3 , kk , MRI_short , boutD3 ) ;
tarD3 [kk] = facD3 ;
}
/*-- save scale factor array into dataset --*/
EDIT_dset_items( new_dsetD3 , ADN_brick_fac , tarD3 , ADN_none ) ;
}
break ;
/*** output is bytes (byte = unsigned char)
we have to create a scaled sub-brick from fout ***/
case MRI_byte:{
byte * boutD3 ;
float facD3 ;
for( kk=0 ; kk < nuse-ignore ; kk++ ){ /* loop over sub-bricks */
/*-- get output sub-brick --*/
boutD3 = (byte *) malloc( sizeof(byte) * nvox ) ;
if( boutD3 == NULL ){
fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ;
EXIT(1) ;
}
/*-- find scaling and then scale --*/
facD3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutD3[kk] ) ;
if( facD3 > 0.0 ){
facD3 = 255.0 / facD3 ;
EDIT_coerce_scale_type( nvox,facD3 ,
MRI_float,foutD3[kk] , MRI_byte,boutD3 ) ;
facD3 = 1.0 / facD3 ;
}
free( foutD3[kk] ) ; /* don't need this anymore */
/*-- put output brick into dataset, and store scale factor --*/
EDIT_substitute_brick( new_dsetD3 , kk , MRI_byte , boutD3 ) ;
tarD3 [kk] = facD3 ;
}
/*-- save scale factor array into dataset --*/
EDIT_dset_items( new_dsetD3 , ADN_brick_fac , tarD3 , ADN_none ) ;
}
break ;
} /* end of switch on output data type */
switch( new_datum ){
/*** output is floats is the simplest:
we just have to attach the fout bricks to the dataset ***/
case MRI_float:
for( kk=0 ; kk < nuse-ignore ; kk++ )
EDIT_substitute_brick( new_dsetA3 , kk , MRI_float , foutA3[kk] ) ;
break ;
/*** output is shorts:
we have to create a scaled sub-brick from fout ***/
case MRI_short:{
short * boutA3 ;
float facA3 ;
for( kk=0 ; kk < nuse-ignore ; kk++ ){ /* loop over sub-bricks */
/*-- get output sub-brick --*/
boutA3 = (short *) malloc( sizeof(short) * nvox ) ;
if( boutA3 == NULL ){
fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ;
EXIT(1) ;
}
/*-- find scaling and then scale --*/
facA3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutA3[kk] ) ;
if( facA3 > 0.0 ){
facA3 = 32767.0 / facA3 ;
EDIT_coerce_scale_type( nvox,facA3 ,
MRI_float,foutA3[kk] , MRI_short,boutA3 ) ;
facA3 = 1.0 / facA3 ;
}
free( foutA3[kk] ) ; /* don't need this anymore */
/*-- put output brick into dataset, and store scale factor --*/
EDIT_substitute_brick( new_dsetA3 , kk , MRI_short , boutA3 ) ;
tarA3[kk] = facA3 ;
}
/*-- save scale factor array into dataset --*/
EDIT_dset_items( new_dsetA3 , ADN_brick_fac , tarA3 , ADN_none ) ;
}
break ;
/*** output is bytes (byte = unsigned char)
we have to create a scaled sub-brick from fout ***/
case MRI_byte:{
byte * boutA3 ;
float facA3 ;
for( kk=0 ; kk < nuse-ignore ; kk++ ){ /* loop over sub-bricks */
/*-- get output sub-brick --*/
boutA3 = (byte *) malloc( sizeof(byte) * nvox ) ;
if( boutA3 == NULL ){
fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ;
EXIT(1) ;
}
/*-- find scaling and then scale --*/
facA3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutA3[kk] ) ;
if( facA3 > 0.0 ){
facA3 = 255.0 / facA3 ;
EDIT_coerce_scale_type( nvox,facA3 ,
MRI_float,foutA3[kk] , MRI_byte,boutA3 ) ;
facA3 = 1.0 / facA3 ;
}
free( foutA3[kk] ) ; /* don't need this anymore */
/*-- put output brick into dataset, and store scale factor --*/
EDIT_substitute_brick( new_dsetA3 , kk , MRI_byte , boutA3 ) ;
tarA3[kk]= facA3 ;
}
/*-- save scale factor array into dataset --*/
EDIT_dset_items( new_dsetA3 , ADN_brick_fac , tarA3 , ADN_none ) ;
}
break ;
} /* end of switch on output data type */
switch( new_datum ){
case MRI_float:{
EDIT_substitute_brick( new_dsetavgD3 , 0 , MRI_float , foutavgD3[0] ) ;
}
break ;
case MRI_short:{
short * boutavgD3 ;
float facavgD3 ;
boutavgD3 = (short *) malloc( sizeof(short) * nvox ) ;
if( boutavgD3 == NULL ){
fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ;
EXIT(1) ;
}
facavgD3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutavgD3[0] ) ;
if( facavgD3 > 0.0 ){
facavgD3 = 32767.0 / facavgD3 ;
EDIT_coerce_scale_type( nvox,facavgD3 ,
MRI_float,foutavgD3[0] , MRI_short,boutavgD3 ) ;
facavgD3 = 1.0 / facavgD3 ;
}
EDIT_substitute_brick( new_dsetavgD3 , 0 , MRI_short , boutavgD3 ) ;
taravgD3[0] = facavgD3 ;
EDIT_dset_items( new_dsetavgD3 , ADN_brick_fac , taravgD3 , ADN_none ) ;
}
break ;
case MRI_byte:{
byte * boutavgD3 ;
float facavgD3 ;
boutavgD3 = (byte *) malloc( sizeof(byte) * nvox ) ;
if( boutavgD3 == NULL ){
fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ;
EXIT(1) ;
}
facavgD3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutavgD3[0] ) ;
if( facavgD3 > 0.0 ){
facavgD3 = 255.0 / facavgD3 ;
EDIT_coerce_scale_type( nvox,facavgD3 ,
MRI_float,foutavgD3[0] , MRI_byte,boutavgD3 ) ;
facavgD3 = 1.0 / facavgD3 ;
}
EDIT_substitute_brick( new_dsetavgD3 , 0 , MRI_byte , boutavgD3 ) ;
taravgD3[0]= facavgD3 ;
EDIT_dset_items( new_dsetavgD3 , ADN_brick_fac , taravgD3 , ADN_none ) ;
}
break ;
} /* endasda of switch on output data type */
/*-------------- Cleanup and go home ----------------*/
PLUTO_add_dset( plint , new_dsetD3 , DSET_ACTION_NONE ) ;
PLUTO_add_dset( plint , new_dsetA3 , DSET_ACTION_NONE ) ;
PLUTO_add_dset( plint , new_dsetavgD3 , DSET_ACTION_NONE ) ;
FREE_WORKSPACE ;
free(numAv);
return NULL ; /* null string returned means all was OK */
}
char * L1F_main( PLUGIN_interface * plint )
{
char *str ;
int ii ;
float *tsar ;
/*--------- go to first input line ---------*/
PLUTO_next_option(plint) ;
str = PLUTO_get_string(plint) ;
polort = PLUTO_string_index( str , NBASE , baseline_strings ) ;
ignore = PLUTO_get_number(plint) ;
/*------ loop over remaining options, check their tags, process them -----*/
nrsin = nrts = ntsim = 0 ;
do {
str = PLUTO_get_optiontag(plint) ; if( str == NULL ) break ;
if( strcmp(str,"Sinusoid") == 0 ){
sinper[nrsin] = PLUTO_get_number(plint) ;
sinharm[nrsin] = PLUTO_get_number(plint) - 1.0 ;
if( sinper[nrsin] <= 0.0 )
return "************************\n"
"Illegal Sinusoid Period!\n"
"************************" ;
nrsin++ ;
} else if( strcmp(str,"Timeseries") == 0 ){
tsim[ntsim] = PLUTO_get_timeseries(plint) ;
if( tsim[ntsim] == NULL || tsim[ntsim]->nx < 3 || tsim[ntsim]->kind != MRI_float )
return "*************************\n"
"Illegal Timeseries Input!\n"
"*************************" ;
tsar = MRI_FLOAT_PTR(tsim[ntsim]) ;
for( ii=ignore ; ii < tsim[ntsim]->nx && tsar[ii] >= WAY_BIG ; ii++ ) ; /* nada */
ignore = ii ;
nrts += tsim[ntsim]->ny ; ntsim++ ;
} else {
return "************************\n"
"Illegal optiontag found!\n"
"************************" ;
}
} while(1) ;
/*--- nothing left to do until data arrives ---*/
initialize = 1 ; /* force re-initialization */
/*** compute how many ref functions are ordered ***/
{ int nref , ks ;
char str[64] ;
nref = (polort+1) + nrts ;
for( ks=0 ; ks < nrsin ; ks++ ) nref += 2*(sinharm[ks]+1) ;
sprintf(str," \nNumber of fit parameters = %d\n",nref) ;
PLUTO_popup_transient( plint , str ) ;
}
return NULL ;
}
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 ;
}
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 */
}
static char * ENV_main( PLUGIN_interface *plint )
{
char *tag ;
int ii,kk , ndone=0 , skip ;
ENTRY("ENV_main") ;
/*--------- loop over input lines ---------*/
while(1){
tag = PLUTO_get_optiontag(plint) ; skip = 0 ;
if( tag == NULL ) break ;
/* find which variable */
for( ii=0 ; ii < NUM_env_var ; ii++ )
if( strcmp(tag,env_var[ii].vname) == 0 ) break ;
if( ii == NUM_env_var )
RETURN( "** ENV_main: table corruption! **" ); /* should not happen */
switch( env_var[ii].vtype ){ /* set vvalue for each type */
default:
RETURN( "** ENV_main: table corruption! **" ); /* should not happen */
/* write a numeric value into the environment */
case ENV_NUMBER_FIXED:
case ENV_NUMBER_EDITABLE:{
float val = PLUTO_get_number(plint) ;
sprintf(env_var[ii].vvalue,"%s=%s" ,
env_var[ii].vname , AV_uformat_fval(val) ) ;
}
break ;
/* write a string value into the environment */
case ENV_STRING:{
char *str = PLUTO_get_string(plint) ; int jj ;
if( str == NULL || *str == '\0' ){
skip = 1 ;
} else {
if( env_var[ii].vcount > 0 ){
jj = PLUTO_string_index( str , env_var[ii].vcount ,
env_var[ii].vlist ) ;
if( jj >= 0 )
sprintf(env_var[ii].vvalue,"%s=%s" ,
env_var[ii].vname , str ) ;
else
sprintf(env_var[ii].vvalue,"%s=" , env_var[ii].vname ) ;
} else {
sprintf(env_var[ii].vvalue,"%s=%s" ,
env_var[ii].vname , str ) ;
}
}
}
break ;
} /* end of switch over environment variable types */
/* actually set environment variable */
if( !skip ){
putenv(env_var[ii].vvalue) ;
/* call callback, if there is one */
#if 0
if( env_var[ii].vfunc != NULL ) env_var[ii].vfunc( env_var[ii].vname ) ;
#else
if( env_var[ii].vfunc != NULL )
AFNI_CALL_VOID_1ARG( env_var[ii].vfunc , char *, env_var[ii].vname ) ;
#endif
}
/* turn this option off (for the user's convenience) */
for( kk=0 ; kk < plint->option_count ; kk++ ) /* find widget */
if( strcmp(tag,plint->option[kk]->tag) == 0 ) break ;
if( kk < plint->option_count ) /* turn off */
XmToggleButtonSetState( plint->wid->opwid[kk]->toggle, False,True ) ;
ndone++ ; /* count of how many we've done */
} /* end of while(1) loop over option lines */
PLUGIN_interface * ENV_init(void)
{
PLUGIN_interface *plint ; /* will be the output of this routine */
char *helpstring=NULL , *ept , *eval ;
int ii ;
/*------- some environment variables for AFNI ------*/
{ static char buf[VAL_NMAX] = "AFNI_CWD=" ; /* 22 Feb 2001 */
ept = getcwd( buf+9 , VAL_NMAX-9 ) ;
if( ept != NULL ){
putenv(buf) ;
ENV_add_string( "AFNI_CWD" ,
"Current working directory (gets output files)" ,
0,NULL , ENV_cwd ) ;
}
}
ENV_add_string( "AFNI_ENFORCE_ASPECT" ,
"To make AFNI enforce image window aspect ratio?" ,
NUM_yesno_list , yesno_list , NULL ) ;
ENV_add_numeric( "AFNI_FIM_PERCENT_LIMIT" ,
"Upper limit on % Change in FIM" ,
10,1000,0,100 , NULL ) ;
ENV_add_numeric( "AFNI_IMAGE_MINFRAC" ,
"Minimum size of image window" ,
0,10,2,2 , NULL ) ;
ENV_add_string( "AFNI_LEFT_IS_LEFT" ,
"To show subject's left on image left?" ,
NUM_yesno_list , yesno_list , ENV_leftisleft ) ;
ENV_add_string( "AFNI_NO_SIDES_LABELS" ,
"Skip showing image window left-side label?" ,
NUM_yesno_list , yesno_list , NULL ) ;
ENV_add_string( "AFNI_VIEW_ANAT_BRICK" ,
"Show OverLay brick whenever possible" ,
NUM_yesno_list , yesno_list , NULL ) ;
ENV_add_string( "AFNI_VIEW_FUNC_BRICK" ,
"Show UnderLay brick whenever possible" ,
NUM_yesno_list , yesno_list , NULL ) ;
ENV_add_string( "AFNI_ORIENT" ,
"Coordinate display orientation" ,
NUM_cord_strings,cord_strings , ENV_coorder ) ;
ENV_add_string( "AFNI_MARKERS_NOQUAL" ,
"Skip markers quality checking?" ,
NUM_yesno_list , yesno_list , ENV_marksquality ) ;
ENV_add_string( "AFNI_COMPRESSOR" ,
"Output BRIK compression method" ,
NUM_COMPRESS_elist,COMPRESS_elist , ENV_compressor ) ;
ENV_add_string( "AFNI_AUTOGZIP" ,
"Use gzip on output if BRIK seems highly compressible" ,
NUM_yesno_list , yesno_list , NULL ) ;
#if 0
ENV_add_string( "AFNI_BYTEORDER" ,
"Byte ordering for output BRIKs" ,
NUM_byteorder_list , byteorder_list , ENV_byteorder ) ;
#endif
#if 0
ENV_add_string( "AFNI_NOMMAP" ,
"Whether to read BRIKs using mmap()" ,
NUM_yesno_list , yesno_list , NULL ) ;
#endif
ENV_add_string( "AFNI_FLOATSCAN" ,
"Scan floating BRIKs for errors on input?" ,
NUM_yesno_list , yesno_list , NULL ) ;
#ifdef USE_SESSTRAIL
ENV_add_numeric( "AFNI_SESSTRAIL" ,
"# directory levels seen in Switch Session, etc." ,
0,9,0,SESSTRAIL , ENV_sesstrail ) ;
#endif
ENV_add_string( "AFNI_PBAR_IMXY" ,
"Sizes of 'Save to PPM' for color pbars" ,
0,NULL , NULL ) ;
ENV_add_string( "AFNI_PSPRINT" ,
"Command to send stdin to PostScript printer" ,
0,NULL , NULL ) ;
ENV_add_string( "AFNI_TRUSTHOST" ,
"Name of host to trust for plugouts and realtime data" ,
0,NULL , ENV_trusthost ) ;
ENV_add_string( "AFNI_IMAGE_LABEL_COLOR" ,
"Name of color for image overlay labels" , /* 21 Sep 2001 */
0,NULL , NULL ) ;
ENV_add_numeric( "AFNI_IMAGE_LABEL_SETBACK" ,
"Size of setback for image overlay labels" ,
0 , 40 , 3 , 3 , NULL ) ;
if( SUMA_ENABLED ){
ENV_add_string( "AFNI_SUMA_BOXCOLOR" , /* 21 Sep 2001 */
"Color name for surface node overlays [or none]" ,
0,NULL , NULL ) ;
ENV_add_numeric( "AFNI_SUMA_BOXSIZE" , /* 10 Mar 2002 */
"Box size for surface node overlays" ,
1 , 10 , 1 , 2 , NULL ) ;
ENV_add_string( "AFNI_SUMA_LINECOLOR" , /* 10 Mar 2002 */
"Color name for surface line overlays [or none]" ,
0,NULL , NULL ) ;
ENV_add_numeric( "AFNI_SUMA_LINESIZE" , /* 15 Jan 2003 */
"Line thickness for surface intersection overlay" ,
0 , 30 , 3 , 0 , NULL ) ;
}
#ifndef NO_FRIVOLITIES
ENV_add_string( "AFNI_IMAGE_PGMFILE" ,
"Image file for AFNI splash window" ,
0,NULL , NULL ) ;
#endif
/* 08 Aug 2001 */
ENV_add_yesno( "AFNI_DONT_MOVE_MENUS" ,
"Move popup menus to enhance visibility?" ) ;
/* 07 Mar 2002 */
ENV_add_numeric( "AFNI_GRAPH_TEXTLIMIT" ,
"Max rows in Graph Button-3 popup" ,
1 , 99 , 0 , 40 , NULL ) ;
/* 16 Mar 2002 */
ENV_add_string( "AFNI_KEEP_PANNING" ,
"Keep 'pan' turned on in image viewers?" ,
NUM_yesno_list , yesno_list , NULL ) ;
/* 18 Mar 2002 */
ENV_add_string( "AFNI_VALUE_LABEL" ,
"Turn on the Define Overlay dataset value label?" ,
NUM_yesno_list , yesno_list , NULL ) ;
/* 22 Mar 2002 */
ENV_add_string( "AFNI_CROSSHAIR_LINES" ,
"Draw crosshairs with lines, not overlay voxels?" ,
NUM_yesno_list , yesno_list , NULL ) ;
/* 25 Mar 2002 */
ENV_add_string( "AFNI_CROP_ZOOMSAVE" ,
"Crop zoomed images when saving to disk?" ,
NUM_yesno_list , yesno_list , NULL ) ;
/* 23 Aug 2003 */
ENV_add_numeric( "AFNI_MAX_OPTMENU" ,
"Max buttons in an Option Menu" ,
100 , 100000 , 0 , 255 , NULL ) ;
/* 23 Oct 2003 */
ENV_add_numeric( "AFNI_STROKE_THRESHOLD" ,
"Coarseness of grayscale stroking" ,
8 , 99 , 0 , 32 , NULL ) ;
ENV_add_string( "AFNI_STROKE_AUTOPLOT" ,
"To automatically draw grayscale-data value plot?" ,
NUM_yesno_list , yesno_list , NULL ) ;
/* 04 Nov 2003 */
ENV_add_string( "AFNI_IMAGE_MINTOMAX" ,
"Set new image viewers to do min-to-max grayscaling?" ,
NUM_yesno_list , yesno_list , ENV_redisplay ) ;
ENV_add_string( "AFNI_IMAGE_GLOBALRANGE" ,
"Set image viewers to use 3D global data range by slice, volume or dataset min-max?",
NUM_globalrange_strings , globalrange_strings , ENV_globalrange_view ) ;
/* 19 Nov 2003 */
ENV_add_numeric( "AFNI_DRAW_UNDOSIZE" ,
"Megabytes allowed for Drawing Undo" ,
1 , 999 , 0 , 6 , NULL ) ;
#if !defined(NO_FRIVOLITIES) && defined(DARWIN)
ENV_add_yesno( "AFNI_SPEECH" , "Allow speech synthesis?" ) ; /* 03 Dec 2003 */
#endif
ENV_add_numeric( "AFNI_VIDEO_DELAY" , /* 04 Dec 2003 */
"Image redraw interval for 'V' or 'v' (ms)." ,
1,9000,0,1 , NULL ) ;
ENV_add_numeric( "AFNI_IMAGE_ENTROPY" ,
"Entropy threshold: below this, 2%-98% is off." ,
0,10,1,0 , NULL ) ;
ENV_add_string( "AFNI_THRESH_LOCK" , /* 06 Feb 2004 */
"Lock Threshold slider values together?" ,
NUM_threshlock_list , threshlock_list , ENV_thresh_lock ) ;
ENV_add_string( "AFNI_GRAPH_CX2R" , /* 18 Apr 2011 */
"Graph display of complex time series" ,
NUM_cx2r_list , cx2r_list , NULL ) ;
ENV_add_string( "AFNI_GRAPH_BOXLAB" , /* 18 Apr 2011 */
"Box graph display of brick labels" ,
NUM_boxlab_list , boxlab_list , NULL ) ;
ENV_add_yesno( "AFNI_PBAR_LOCK" , "Lock Color Pbars together?" ) ; /* 07 Feb 2004 */
ENV_add_yesno( "AFNI_RANGE_LOCK", "Lock OLay Ranges together?" ) ; /* 23 Feb 2004 */
ENV_add_yesno( "AFNI_DISP_SCROLLBARS" , "Image Disp menu get scrollbars?" ) ;
/* 23 Feb 2004 [rickr] */
ENV_add_yesno( "AFNI_IMAGE_ZOOM_NN" ,
"Use Nearest Neighbor interpolation for image Zoom?" ) ;
/* 22 Mar 2004 [RWCox] */
ENV_add_yesno( "AFNI_SLAVE_FUNCTIME" , "Time Index affects functional overlay?" ) ;
#if 0
ENV_add_yesno( "AFNI_SLAVE_THRTIME" , "Time Index affects threshold overlay?" ) ;
#endif
ENV_add_string( "AFNI_REALTIME_MP_HOST_PORT" , /* 31 Mar 2004 [rickr] */
"Supply host:port string for realtime motion parameters." ,
0,NULL , NULL ) ;
/* 07 Apr 2004 [RWCox] */
ENV_add_yesno( "AFNI_X11_REDECORATE" , "Try to set X11 window 'decorations'?" ) ;
/* 21 Dec 2004 [RWCox] */
ENV_add_string( "AFNI_TITLE_LABEL2" ,
"Use 'label2' field for window titles?" ,
NUM_yesno_list , yesno_list , ENV_redraw_titles ) ;
/* 21 Mar 2005 [RWCox] */
ENV_add_string( "AFNI_EDGIZE_OVERLAY" ,
"Display color overlay as edges?" ,
NUM_yesno_list , yesno_list , ENV_redisplay ) ;
/* 11 Dec 2014 [RWCox] */
ENV_add_string( "AFNI_EDGIZE_COLOR" ,
"Name of color for EDGIZE+Alpha overlays." , /* 21 Sep 2001 */
0,NULL , NULL ) ;
/* 08 Apr 2005 [rickr] */
ENV_add_numeric( "AFNI_NIFTI_DEBUG" ,
"Set nifti_io debug level (should then do Rescan:This)" ,
0,5,0,0 , NULL ) ;
/* 20 Apr 2005 [RWCox] */
ENV_add_string( "AFNI_OVERLAY_ZERO" ,
"Do 0 values get color in an Overlay?" ,
NUM_yesno_list , yesno_list , ENV_redisplay ) ;
/* 20 Oct 2005 [RWCox] */
ENV_add_yesno("AFNI_TTATLAS_CAUTION","Add caution to 'Where Am I' output?");
/* 10 May 2006 [drg] */
ENV_add_numeric( "AFNI_JPEG_COMPRESS" ,
"JPEG compression quality %" ,
1,100,0,95 , ENV_setjpegquality ) ;
/* 21 Feb 2007 [RWCox] */
ENV_add_yesno( "AFNI_DATASET_BROWSE" , "Switch datasets upon selection?" ) ;
/* 05 Mar 2007 [RWCox] */
ENV_add_yesno( "AFNI_THRESH_AUTO" , "Reset threshold on Switch Overlay?" ) ;
/* 18 Sep 2007 [RWCox] */
ENV_add_string( "AFNI_IMAGE_CLIPPED" ,
"Set new image viewers to do clipped grayscaling?" ,
NUM_yesno_list , yesno_list , ENV_redisplay ) ;
ENV_add_numeric( "AFNI_IMAGE_CLIPBOT" ,
"Set clipped grayscale bottom = fraction of top default" ,
0,50,2,25 , ENV_redisplay ) ;
ENV_add_numeric( "AFNI_IMAGE_CLIPTOP" ,
"Set clipped grayscale top = fraction of default" ,
60,190,2,100 , ENV_redisplay ) ;
ENV_add_numeric( "AFNI_1DPLOT_THIK" ,
"Set 1dplot-style line thickness" ,
0,20,3,3 , NULL ) ;
#if 0
/* 20 Dec 2007 [RWCox] */
ENV_add_string( "AFNI_CLUSTER_PREFIX" ,
"Prefix for Clusterize 1D file Saves" , 0 , NULL , NULL ) ;
#endif
/* 10 Jan 2008 [RWCox] */
ENV_add_numeric( "AFNI_CLUSTER_REPMAX" ,
"Max number rows in Clusterize Rpt table" ,
10,99,0,15 , NULL ) ;
/* 04 Aug 2010 [RWCox] */
ENV_add_numeric( "AFNI_CLUSTER_WAMIMAX" ,
"Max clusters sent to 'whereami'" ,
1,99,0,20 , NULL ) ;
/* 28 Feb 2011 [RWCox] */
ENV_add_yesno( "AFNI_CLUSTER_EBAR" ,
"Error bars in Clusterize plots?" ) ;
/* 03 Jun 2008 [RWCox] */
ENV_add_yesno( "AFNI_IMAGE_TICK_DIV_IN_MM" ,
"Image tick divisions count is in mm?" ) ;
/* 09 Feb 2009 [RWCox] */
ENV_add_numeric( "AFNI_ANIM_DUP" ,
"Duplication factor for MPEG save" ,
1,99,0,1 , NULL ) ;
/* 29 Apr 2009 [RWCox] */
{ static char *fsize[3] = { "Normal" , "Big" , "Small" } ;
ENV_add_string( "AFNI_TTATLAS_FONTSIZE" ,
"Size of 'Where am I?' window font" ,
3 , fsize , NULL ) ;
}
/* 11 May 2009 [RWCox] */
ENV_add_yesno( "AFNI_INSTACORR_FDR" ,
"Compute FDR curve for InstaCorr correlations?" ) ;
/* 27 Aug 2009 [RWCox] */
ENV_add_numeric( "AFNI_IMAGE_CROPSTEP" ,
"Cropped image panning step size" ,
-9,9,0,1 , NULL ) ;
/* 06 Oct 2010 [RWCox] */
ENV_add_string( "AFNI_IDEAL_COLORS" ,
"Colors for the FIM Ideal in AFNI Graph viewer" ,
0,NULL , NULL ) ;
ENV_add_string( "AFNI_ORT_COLORS" ,
"Colors for the FIM Ort in AFNI Graph viewer" ,
0,NULL , NULL ) ;
/* 27 Jun 2011 [DRG] */
ENV_add_numeric( "AFNI_WHEREAMI_DEC_PLACES" ,
"Number of decimal places for whereami output" ,
0,4,0,0 , NULL ) ;
ENV_add_numeric( "AFNI_WHEREAMI_MAX_FIND" ,
"Maximum limit for structures from an atlas for whereami output" ,
1,50,0,9 , ENV_wami_maxfind ) ;
ENV_add_string( "AFNI_WHEREAMI_MAX_SEARCH_RAD" ,
"Maximum radius for structures from an atlas for whereami output" ,
0, NULL, ENV_wami_maxrad ) ;
/* 01 Jul 2011 [DRG] */
ENV_add_string( "AFNI_ATLAS_COLORS" ,
"Atlas to use in Atlas colors, Draw Dataset, Go to atlas location" ,
0, NULL, ENV_atlas_reset ) ;
/* 08 Nov 2011 [RWC] */
ENV_add_string( "AFNI_IMAGE_COLORANGLE" ,
"Image view color scale angle" ,
NUM_angle_strings,angle_strings , ENV_angle_string ) ;
/* 23 Dec 2011 [RWC] */
ENV_add_string( "AFNI_IMAGE_LABEL_STRING" ,
"Extra string for image view overlay labels" ,
0,NULL , NULL ) ;
/* 21 Feb 2013 [RWC] */
ENV_add_yesno( "AFNI_HISTOG_CUMULATIVE" ,
"Show cumulative histogram in plugins?" ) ;
/* 25 Jun 2013 [RWC] */
ENV_add_numeric( "AFNI_PBAR_TICK" ,
"Number of tick marks for colorscale" ,
0,63,0,9 , NULL ) ;
/* 23 Jul 2013 [RWC] */
ENV_add_yesno( "AFNI_RECENTER_VIEWING" ,
"Re-center xhairs when switching UnderLay?" ) ;
ENV_add_string( "AFNI_JUMPTO_SPACE" ,
"Space name to use in Jump to (spacename)" ,
0, NULL, ENV_jumpspace_reset ) ;
/*--------- Sort list of variables [21 Feb 2007] -----------*/
if( !AFNI_yesenv("AFNI_DONT_SORT_ENVIRONMENT") )
qsort( env_var , (size_t)NUM_env_var , sizeof(ENV_var) , ENV_compare ) ;
/*---------------- compute helpstring -----------------------*/
helpstring = THD_zzprintf( helpstring , "%s\n" , help_start ) ;
for( ii=0 ; ii < NUM_env_fixed ; ii++ ){
ept = getenv(env_fixed[ii]) ;
if( ept == NULL )
eval = "(Not set)" ;
else if( ept[0] == '\0' )
eval = "(Set to empty string)" ;
else
eval = ept ;
helpstring = THD_zzprintf( helpstring, " %-25.25s= %s\n",
env_fixed[ii],eval ) ;
}
helpstring = THD_zzprintf( helpstring , "%s\n" , help_mid ) ;
for( ii=0 ; ii < NUM_env_var ; ii++ ){
helpstring = THD_zzprintf( helpstring, " %-25.25s: %s\n" ,
env_var[ii].vname , env_var[ii].vhint ) ;
}
helpstring = THD_zzprintf( helpstring , "%s\n" , help_end ) ;
/*---------------- set titles and call point ----------------*/
plint = PLUTO_new_interface( "Environment" ,
"Environment variables control" ,
helpstring ,
PLUGIN_CALL_VIA_MENU , ENV_main ) ;
free(helpstring) ;
PLUTO_add_hint( plint , "Environment variables control" ) ;
PLUTO_set_runlabels( plint , "Set+Keep" , "Set+Close" ) ; /* 04 Nov 2003 */
/*--------- make interface lines: 1 for each variable -----------*/
for( ii=0 ; ii < NUM_env_var ; ii++ ){
PLUTO_add_option( plint ,
"" , /* label at left of input line */
env_var[ii].vname , /* tag to return to plugin */
FALSE /* is this mandatory? */
) ;
ept = getenv( env_var[ii].vname ) ;
switch( env_var[ii].vtype ){
default: break ; /* should never happen */
case ENV_NUMBER_FIXED:
case ENV_NUMBER_EDITABLE:{
double dval=env_var[ii].vdef ; int ival ;
if( ept != NULL ){
dval = strtod(ept,NULL) ;
AV_SHIFT_VAL(-env_var[ii].vdecim,dval) ;
}
ival = rint(dval) ;
if( ival < env_var[ii].vbot ) ival = env_var[ii].vbot ;
else if( ival > env_var[ii].vtop ) ival = env_var[ii].vtop ;
PLUTO_add_number( plint ,
env_var[ii].vname ,
env_var[ii].vbot ,
env_var[ii].vtop ,
env_var[ii].vdecim,
ival,(env_var[ii].vtype==ENV_NUMBER_EDITABLE) ) ;
PLUTO_add_hint( plint , env_var[ii].vhint ) ; /* 8 Apr 2005 rickr */
}
break ;
case ENV_STRING:{
if( env_var[ii].vcount <= 0 ){
PLUTO_add_string( plint ,
env_var[ii].vname ,
0 , &ept , NAME_NMAX ) ;
PLUTO_add_hint( plint , env_var[ii].vhint ) ;
} else {
int dval , jj ;
char ** sval ;
dval = 1 + PLUTO_string_index( ept , env_var[ii].vcount ,
env_var[ii].vlist ) ;
sval = (char **) malloc( sizeof(char *)*(1+env_var[ii].vcount) ) ;
sval[0] = "(Not set)" ;
for( jj=0 ; jj < env_var[ii].vcount ; jj++ )
sval[jj+1] = env_var[ii].vlist[jj] ;
PLUTO_add_string( plint ,
env_var[ii].vname ,
1+env_var[ii].vcount , sval , dval ) ;
PLUTO_add_hint( plint , env_var[ii].vhint ) ;
free(sval) ;
}
}
break ;
} /* end of switch over variable type */
} /* end of loop over variables */
/*--------- done with interface setup ---------*/
return plint ;
}
