/*---------------------------------------------------------------------- ** ** 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 ; }