int main( int argc , char *argv[] )
{
char *aname ;
THD_3dim_dataset *dset ;
int ii , scl ;
MRI_IMAGE *im , *qim ;
char *fname ;
float fac ;
int do_4D=0 , iarg=1 ; /* 30 Sep 2002 */
FILE *ifp=NULL ;
int xxor=-1,yyor=0,zzor=0 , xdir=0,ydir=0,zdir=0; /* 19 Mar 2003 */
float xdel=0.0 ,ydel=0.0,zdel=0.0;
char orient_code[4] ;
/*-- help me if you can --*/
WARNING_message("This program (3dAFNItoANALYZE) is old, not maintained, and probably useless!") ;
if( argc < 3 || strcmp(argv[1],"-help") == 0 ){
printf("Usage: 3dAFNItoANALYZE [-4D] [-orient code] aname dset\n"
"Writes AFNI dataset 'dset' to 1 or more ANALYZE 7.5 format\n"
".hdr/.img file pairs (one pair for each sub-brick in the\n"
"AFNI dataset). The ANALYZE files will be named\n"
" aname_0000.hdr aname_0000.img for sub-brick #0\n"
" aname_0001.hdr aname_0001.img for sub-brick #1\n"
"and so forth. Each file pair will contain a single 3D array.\n"
"\n"
"* If the AFNI dataset does not include sub-brick scale\n"
" factors, then the ANALYZE files will be written in the\n"
" datum type of the AFNI dataset.\n"
"* If the AFNI dataset does have sub-brick scale factors,\n"
" then each sub-brick will be scaled to floating format\n"
" and the ANALYZE files will be written as floats.\n"
"* The .hdr and .img files are written in the native byte\n"
" order of the computer on which this program is executed.\n"
"\n"
"Options\n"
"-------\n"
"-4D [30 Sep 2002]:\n"
" If you use this option, then all the data will be written to\n"
" one big ANALYZE file pair named aname.hdr/aname.img, rather\n"
" than a series of 3D files. Even if you only have 1 sub-brick,\n"
" you may prefer this option, since the filenames won't have\n"
" the '_0000' appended to 'aname'.\n"
"\n"
"-orient code [19 Mar 2003]:\n"
" This option lets you flip the dataset to a different orientation\n"
" when it is written to the ANALYZE files. The orientation code is\n"
" formed as follows:\n"
" The code must be 3 letters, one each from the\n"
" pairs {R,L} {A,P} {I,S}. The first letter gives\n"
" the orientation of the x-axis, the second the\n"
" orientation of the y-axis, the third the z-axis:\n"
" R = Right-to-Left L = Left-to-Right\n"
" A = Anterior-to-Posterior P = Posterior-to-Anterior\n"
" I = Inferior-to-Superior S = Superior-to-Inferior\n"
" For example, 'LPI' means\n"
" -x = Left +x = Right\n"
" -y = Posterior +y = Anterior\n"
" -z = Inferior +z = Superior\n"
" * For display in SPM, 'LPI' or 'RPI' seem to work OK.\n"
" Be careful with this: you don't want to confuse L and R\n"
" in the SPM display!\n"
" * If you DON'T use this option, the dataset will be written\n"
" out in the orientation in which it is stored in AFNI\n"
" (e.g., the output of '3dinfo dset' will tell you this.)\n"
" * The dataset orientation is NOT stored in the .hdr file.\n"
" * AFNI and ANALYZE data are stored in files with the x-axis\n"
" varying most rapidly and the z-axis most slowly.\n"
" * Note that if you read an ANALYZE dataset into AFNI for\n"
" display, AFNI assumes the LPI orientation, unless you\n"
" set environment variable AFNI_ANALYZE_ORIENT.\n"
) ;
PRINT_COMPILE_DATE; exit(0) ;
}
mainENTRY("3dAFNItoANALYZE main"); machdep(); PRINT_VERSION("3dAFNItoANALYZE");
/*-- read inputs --*/
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-4D") == 0 ){ /* 30 Sep 2002 */
do_4D = 1 ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-orient") == 0 ){ /* 19 Mar 2003 */
char acod ;
if( iarg+1 >= argc ){
fprintf(stderr,"** Need something after -orient!\n"); exit(1);
}
MCW_strncpy(orient_code,argv[++iarg],4) ;
if( strlen(orient_code) != 3 ){
fprintf(stderr,"** Illegal code '%s' after -orient!\n",argv[iarg]); exit(1);
}
acod = toupper(orient_code[0]) ; xxor = ORCODE(acod) ;
acod = toupper(orient_code[1]) ; yyor = ORCODE(acod) ;
acod = toupper(orient_code[2]) ; zzor = ORCODE(acod) ;
if( xxor<0 || yyor<0 || zzor<0 || !OR3OK(xxor,yyor,zzor) ){
fprintf(stderr,"** Unusable code after -orient!\n"); exit(1);
}
iarg++ ; continue ;
}
fprintf(stderr,"** Illegal option: %s\n",argv[iarg]); exit(1);
}
if( iarg >= argc-1 ){
fprintf(stderr,"** Not enough arguments on command line!\n"); exit(1);
}
aname = argv[iarg++] ;
if( !THD_filename_ok(aname) ){
fprintf(stderr,"** Illegal aname string %s\n",aname) ;
exit(1) ;
}
fname = malloc( strlen(aname)+16 ) ;
dset = THD_open_dataset( argv[iarg++] ); CHECK_OPEN_ERROR(dset,argv[iarg-1]);
if( xxor >= 0 ){ /* 19 Mar 2003: figure how to flip */
xdir = THD_get_axis_direction( dset->daxes , xxor ) ;
ydir = THD_get_axis_direction( dset->daxes , yyor ) ;
zdir = THD_get_axis_direction( dset->daxes , zzor ) ;
if( ydir == 0 || zdir == 0 ) xdir = 0 ;
if( xdir == 1 && ydir == 2 && zdir == 3 ) xdir = 0 ;
}
if( xdir != 0 ){
float dx=fabs(DSET_DX(dset)) ,
dy=fabs(DSET_DY(dset)) ,
dz=fabs(DSET_DZ(dset)) ;
DSET_mallocize(dset) ;
switch( xdir ){
case 1: case -1: xdel = dx ; break ;
case 2: case -2: xdel = dy ; break ;
case 3: case -3: xdel = dz ; break ;
}
switch( ydir ){
case 1: case -1: ydel = dx ; break ;
case 2: case -2: ydel = dy ; break ;
case 3: case -3: ydel = dz ; break ;
}
switch( zdir ){
case 1: case -1: zdel = dx ; break ;
case 2: case -2: zdel = dy ; break ;
case 3: case -3: zdel = dz ; break ;
}
} else {
xdel = fabs(DSET_DX(dset)) ;
ydel = fabs(DSET_DY(dset)) ;
zdel = fabs(DSET_DZ(dset)) ;
}
DSET_load(dset) ; CHECK_LOAD_ERROR(dset) ;
/* determine if we scale to floats */
scl = THD_need_brick_factor( dset ) ;
/* 30 Sep 2002: if doing a 4D file, write single .hdr now */
if( do_4D ){
im = mri_empty_conforming( DSET_BRICK(dset,0) ,
(scl) ? MRI_float
: DSET_BRICK_TYPE(dset,0) ) ;
if( xdir != 0 ){
qim = mri_flip3D( xdir,ydir,zdir , im ) ;
if( qim == NULL){
fprintf(stderr,"mri_flip3D fails?!\n"); exit(1);
}
mri_free(im); im = qim;
}
im->dx = xdel ; /* load voxel sizes */
im->dy = ydel ;
im->dz = zdel ;
im->dw = 1.0 ;
if( AFNI_yesenv("AFNI_ANALYZE_ORIGINATOR") ){
im->xo = dset->daxes->xxorg ; /* load voxel origin */
im->yo = dset->daxes->yyorg ; /* 03/11/04 KRH added this bit for SPM */
im->zo = dset->daxes->zzorg ;
if( ORIENT_sign[dset->daxes->xxorient] == '-' ){
im->dx = -im->dx ;
/* im->xo = -im->xo ; */
}
if( ORIENT_sign[dset->daxes->yyorient] == '-' ){
im->dy = -im->dy ;
/* im->yo = -im->yo ; */
}
if( ORIENT_sign[dset->daxes->zzorient] == '-' ){
im->dz = -im->dz ;
/* im->zo = -im->zo ; */
}
}
im->nt = DSET_NVALS(dset) ; /* add a time axis */
im->dt = DSET_TR(dset) ;
if( im->dt <= 0.0 ) im->dt = 1.0 ;
if( DSET_TIMEUNITS(dset) == UNITS_MSEC_TYPE ) im->dt *= 0.001 ; /* 05 Jul 2005 */
mri_write_analyze( aname , im ) ; /* output 4D .hdr file */
mri_free(im) ;
sprintf(fname,"%s.img",aname) ; /* open output .img file */
ifp = fopen( fname , "wb" ) ;
if( ifp == NULL ){
fprintf(stderr,"** Can't open file %s for output!\n",fname) ;
exit(1) ;
}
}
/* loop over sub-bricks */
for( ii=0 ; ii < DSET_NVALS(dset) ; ii++ ){
im = DSET_BRICK(dset,ii) ; /* get the sub-brick */
if( scl ){ /* scale it to floats */
fac = DSET_BRICK_FACTOR(dset,ii) ;
if( fac == 0.0 ) fac = 1.0 ;
qim = mri_scale_to_float( fac , im ) ;
} else {
qim = im ;
}
if( xdir != 0 ){ /* 19 Mar 2003: flip it */
MRI_IMAGE *fim ;
fim = mri_flip3D( xdir,ydir,zdir , qim ) ;
if( fim == NULL ){
fprintf(stderr,"mri_flip3D fails at ii=%d ?!\n",ii); exit(1);
}
if( qim != im ) mri_free(qim) ;
qim = fim ;
}
if( do_4D ){ /* 30 Sep 2002: write into 4D .img file */
fwrite( mri_data_pointer(qim) , qim->nvox , qim->pixel_size , ifp ) ;
} else { /* write separate 3D .hdr/.img files */
qim->dx = xdel ; /* load voxel sizes */
qim->dy = ydel ;
qim->dz = zdel ;
qim->dw = 1.0 ;
if( AFNI_yesenv("AFNI_ANALYZE_ORIGINATOR") ){
qim->xo = dset->daxes->xxorg ; /* load voxel origin */
qim->yo = dset->daxes->yyorg ; /* 03/11/04 KRH added this bit for SPM */
qim->zo = dset->daxes->zzorg ;
if( ORIENT_sign[dset->daxes->xxorient] == '-' ){
qim->dx = -qim->dx ;
/* qim->xo = -qim->xo ; */
}
if( ORIENT_sign[dset->daxes->yyorient] == '-' ){
qim->dy = -qim->dy ;
/* qim->yo = -qim->yo ; */
}
if( ORIENT_sign[dset->daxes->zzorient] == '-' ){
qim->dz = -qim->dz ;
/* qim->zo = -qim->zo ; */
}
}
sprintf(fname,"%s_%04d",aname,ii) ; /* make up a filename */
mri_write_analyze( fname , qim ) ; /* do the real work */
}
if( qim != im ) mri_free(qim) ;
DSET_unload_one(dset,ii) ; /* clean up the trash */
}
if( ifp != NULL ) fclose(ifp) ; /* 30 Sep 2002 */
free(fname) ; exit(0) ;
}
int main( int argc , char * argv[] )
{
float mrad=0.0f , fwhm=0.0f ;
int nrep=1 ;
char *prefix = "Polyfit" ;
char *resid = NULL ;
char *cfnam = NULL ;
int iarg , verb=0 , do_automask=0 , nord=3 , meth=2 , do_mclip=0 ;
THD_3dim_dataset *inset ;
MRI_IMAGE *imout , *imin ;
byte *mask=NULL ; int nvmask=0 , nmask=0 , do_mone=0 , do_byslice=0 ;
MRI_IMARR *exar=NULL ;
floatvec *fvit=NULL ; /* 26 Feb 2019 */
if( argc < 2 || strcasecmp(argv[1],"-help") == 0 ){
printf("\n"
"Usage: 3dPolyfit [options] dataset ~1~\n"
"\n"
"* Fits a polynomial in space to the input dataset and outputs that fitted dataset.\n"
"\n"
"* You can also add your own basis datasets to the fitting mix, using the\n"
" '-base' option.\n"
"\n"
"* You can get the fit coefficients using the '-1Dcoef' option.\n"
"\n"
"--------\n"
"Options: ~1~\n"
"--------\n"
"\n"
" -nord n = Maximum polynomial order (0..9) [default order=3]\n"
" [n=0 is the constant 1]\n"
" [n=-1 means only use volumes from '-base']\n"
"\n"
" -blur f = Gaussian blur input dataset (inside mask) with FWHM='f' (mm)\n"
"\n"
" -mrad r = Radius (voxels) of preliminary median filter of input\n"
" [default is no blurring of either type; you can]\n"
" [do both types (Gaussian and median), but why??]\n"
" [N.B.: median blur is slower than Gaussian]\n"
"\n"
" -prefix pp = Use 'pp' for prefix of output dataset (the fit).\n"
" [default prefix is 'Polyfit'; use NULL to skip this output]\n"
"\n"
" -resid rr = Use 'rr' for the prefix of the residual dataset.\n"
" [default is not to output residuals]\n"
"\n"
" -1Dcoef cc = Save coefficients of fit into text file cc.1D.\n"
" [default is not to save these coefficients]\n"
"\n"
" -automask = Create a mask (a la 3dAutomask)\n"
" -mask mset = Create a mask from nonzero voxels in 'mset'.\n"
" [default is not to use a mask, which is probably a bad idea]\n"
"\n"
" -mone = Scale the mean value of the fit (inside the mask) to 1.\n"
" [probably this option is not useful for anything]\n"
"\n"
" -mclip = Clip fit values outside the rectilinear box containing the\n"
" mask to the edge of that box, to avoid weird artifacts.\n"
"\n"
" -meth mm = Set 'mm' to 2 for least squares fit;\n"
" set it to 1 for L1 fit [default method=2]\n"
" [Note that L1 fitting is slower than L2 fitting!]\n"
"\n"
" -base bb = In addition to the polynomial fit, also use\n"
" the volumes in dataset 'bb' as extra basis functions.\n"
" [If you use a base dataset, then you can set nord]\n"
" [to -1, to skip using any spatial polynomial fit.]\n"
"\n"
" -verb = Print fun and useful progress reports :-)\n"
"\n"
"------\n"
"Notes: ~1~\n"
"------\n"
"* Output dataset is always stored in float format.\n"
"\n"
"* If the input dataset has more than 1 sub-brick, only sub-brick #0\n"
" is processed. To fit more than one volume, you'll have to use a script\n"
" to loop over the input sub-bricks, and then glue (3dTcat) the results\n"
" together to get a final result. A simple example:\n"
" #!/bin/tcsh\n"
" set base = model.nii\n"
" set dset = errts.nii\n"
" set nval = `3dnvals $dset`\n"
" @ vtop = $nval - 1\n"
" foreach vv ( `count 0 $vtop` )\n"
" 3dPolyfit -base \"$base\" -nord 0 -mask \"$base\" -1Dcoef QQ.$vv -prefix QQ.$vv.nii $dset\"[$vv]\"\n"
" end\n"
" 3dTcat -prefix QQall.nii QQ.0*.nii\n"
" 1dcat QQ.0*.1D > QQall.1D\n"
" \rm QQ.0*\n"
" exit 0\n"
"\n"
"* If the '-base' dataset has multiple sub-bricks, all of them are used.\n"
"\n"
"* You can use the '-base' option more than once, if desired or needed.\n"
"\n"
"* The original motivation for this program was to fit a spatial model\n"
" to a field map MRI, but that didn't turn out to be useful. Nevertheless,\n"
" I make this program available to someone who might find it beguiling.\n"
"\n"
"* If you really want, I could allow you to put sign constraints on the\n"
" fit coefficients (e.g., say that the coefficient for a given base volume\n"
" should be non-negative). But you'll have to beg for this.\n"
"\n"
"-- Emitted by RWCox\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
/*-- startup paperwork --*/
mainENTRY("3dPolyfit main"); machdep(); AFNI_logger("3dPolyfit",argc,argv);
PRINT_VERSION("3dPolyfit") ;
/*-- scan command line --*/
iarg = 1 ;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcasecmp(argv[iarg],"-base") == 0 ){
THD_3dim_dataset *bset ; int kk ; MRI_IMAGE *bim ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-base'") ;
bset = THD_open_dataset(argv[iarg]) ;
CHECK_OPEN_ERROR(bset,argv[iarg]) ;
DSET_load(bset) ; CHECK_LOAD_ERROR(bset) ;
if( exar == NULL ) INIT_IMARR(exar) ;
for( kk=0 ; kk < DSET_NVALS(bset) ; kk++ ){
bim = THD_extract_float_brick(kk,bset) ;
if( bim != NULL ) ADDTO_IMARR(exar,bim) ;
DSET_unload_one(bset,kk) ;
}
DSET_delete(bset) ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-verb") == 0 ){
verb++ ; iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-hermite") == 0 ){ /* 25 Mar 2013 [New Year's Day] */
mri_polyfit_set_basis("hermite") ; /* HIDDEN */
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-byslice") == 0 ){ /* 25 Mar 2013 [New Year's Day] */
do_byslice++ ; iarg++ ; continue ; /* HIDDEN */
}
if( strcasecmp(argv[iarg],"-mask") == 0 ){
THD_3dim_dataset *mset ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-mask'") ;
if( mask != NULL || do_automask ) ERROR_exit("Can't have two mask inputs") ;
mset = THD_open_dataset(argv[iarg]) ;
CHECK_OPEN_ERROR(mset,argv[iarg]) ;
DSET_load(mset) ; CHECK_LOAD_ERROR(mset) ;
nvmask = DSET_NVOX(mset) ;
mask = THD_makemask( mset , 0 , 0.5f, 0.0f ) ; DSET_delete(mset) ;
if( mask == NULL ) ERROR_exit("Can't make mask from dataset '%s'",argv[iarg]) ;
nmask = THD_countmask( nvmask , mask ) ;
if( nmask < 99 ) ERROR_exit("Too few voxels in mask (%d)",nmask) ;
if( verb ) INFO_message("Number of voxels in mask = %d",nmask) ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-nord") == 0 ){
nord = (int)strtol( argv[++iarg], NULL , 10 ) ;
if( nord < -1 || nord > 9 )
ERROR_exit("Illegal value after -nord :(") ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-meth") == 0 ){
meth = (int)strtol( argv[++iarg], NULL , 10 ) ;
if( meth < 1 || meth > 2 )
ERROR_exit("Illegal value after -meth :(") ;
iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-automask",5) == 0 ){
if( mask != NULL ) ERROR_exit("Can't use -mask and -automask together!") ;
do_automask++ ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-mclip",5) == 0 ){
do_mclip++ ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-mone",5) == 0 ){
do_mone++ ; iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-mrad") == 0 ){
mrad = strtod( argv[++iarg] , NULL ) ; iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-blur") == 0 ){
fwhm = strtod( argv[++iarg] , NULL ) ; iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-prefix") == 0 ){
prefix = argv[++iarg] ;
if( !THD_filename_ok(prefix) )
ERROR_exit("Illegal value after -prefix :(");
if( strcasecmp(prefix,"NULL") == 0 ) prefix = NULL ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-resid") == 0 ){
resid = argv[++iarg] ;
if( !THD_filename_ok(resid) )
ERROR_exit("Illegal value after -resid :(");
if( strcasecmp(resid,"NULL") == 0 ) resid = NULL ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-1Dcoef") == 0 ){ /* 26 Feb 2019 */
cfnam = argv[++iarg] ;
if( !THD_filename_ok(cfnam) )
ERROR_exit("Illegal value after -1Dcoef :(");
if( strcasecmp(cfnam,"NULL") == 0 ) cfnam = NULL ;
iarg++ ; continue ;
}
ERROR_exit("Unknown option: %s\n",argv[iarg]);
}
/*--- check for blatant errors ---*/
if( iarg >= argc )
ERROR_exit("No input dataset name on command line?");
if( prefix == NULL && resid == NULL && cfnam == NULL )
ERROR_exit("-prefix and -resid and -1Dcoef are all NULL?!") ;
if( do_byslice && cfnam != NULL ){
WARNING_message("-byslice does not work with -1Dcoef option :(") ;
cfnam = NULL ;
}
if( nord < 0 && exar == NULL )
ERROR_exit("no polynomial fit AND no -base option ==> nothing to compute :(") ;
/*-- read input --*/
if( verb ) INFO_message("Load input dataset") ;
inset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
DSET_load(inset) ; CHECK_LOAD_ERROR(inset) ;
if( DSET_NVALS(inset) > 1 )
WARNING_message( "Only processing sub-brick #0 (out of %d)" , DSET_NVALS(inset) );
/* check input mask or create automask */
if( mask != NULL ){
if( nvmask != DSET_NVOX(inset) )
ERROR_exit("-mask and input datasets don't match in voxel counts :-(") ;
} else if( do_automask ){
THD_automask_verbose( (verb > 1) ) ;
THD_automask_extclip( 1 ) ;
mask = THD_automask( inset ) ; nvmask = DSET_NVOX(inset) ;
nmask = THD_countmask( nvmask , mask ) ;
if( nmask < 99 ) ERROR_exit("Too few voxels in automask (%d)",nmask) ;
if( verb ) ININFO_message("Number of voxels in automask = %d",nmask) ;
} else {
WARNING_message("3dPolyfit is running without a mask") ;
}
#undef GOOD
#define GOOD(i) (mask == NULL || mask[i])
/* check -base input datasets */
if( exar != NULL ){
int ii,kk , nvbad=0 , nvox=DSET_NVOX(inset),nm ; float *ex , exb ;
for( kk=0 ; kk < IMARR_COUNT(exar) ; kk++ ){
if( nvox != IMARR_SUBIM(exar,kk)->nvox ){
if( IMARR_SUBIM(exar,kk)->nvox != nvbad ){
ERROR_message("-base volume (%d voxels) doesn't match input dataset grid size (%d voxels)",
IMARR_SUBIM(exar,kk)->nvox , nvox ) ;
nvbad = IMARR_SUBIM(exar,kk)->nvox ;
}
}
}
if( nvbad != 0 ) ERROR_exit("Cannot continue :-(") ;
/* subtract mean from each base input, if is a constant polynomial in the fit */
if( nord >= 0 ){
if( verb ) INFO_message("subtracting spatial mean from '-base'") ;
for( kk=0 ; kk < IMARR_COUNT(exar) ; kk++ ){
exb = 0.0f ; ex = MRI_FLOAT_PTR(IMARR_SUBIM(exar,kk)) ;
for( nm=ii=0 ; ii < nvox ; ii++ ){ if( GOOD(ii) ){ exb += ex[ii]; nm++; } }
exb /= nm ;
for( ii=0 ; ii < nvox ; ii++ ) ex[ii] -= exb ;
}
}
}
/* if blurring, edit mask a little */
if( mask != NULL && (fwhm > 0.0f || mrad > 0.0f) ){
int ii ;
ii = THD_mask_remove_isolas( DSET_NX(inset),DSET_NY(inset),DSET_NZ(inset),mask ) ;
if( ii > 0 ){
nmask = THD_countmask( nvmask , mask ) ;
if( verb )
ININFO_message("Removed %d isola%s from mask, leaving %d voxels" ,
ii,(ii==1)?"\0":"s" , nmask ) ;
if( nmask < 99 )
ERROR_exit("Too few voxels left in mask after isola removal :-(") ;
}
}
/* convert input to float, which is simpler to deal with */
imin = THD_extract_float_brick(0,inset) ;
if( imin == NULL ) ERROR_exit("Can't extract input dataset brick?! :-(") ;
DSET_unload(inset) ;
if( verb ) INFO_message("Start fitting process") ;
/* do the Gaussian blurring */
if( fwhm > 0.0f ){
if( verb ) ININFO_message("Gaussian blur: FWHM=%g mm",fwhm) ;
imin->dx = fabsf(DSET_DX(inset)) ;
imin->dy = fabsf(DSET_DY(inset)) ;
imin->dz = fabsf(DSET_DZ(inset)) ;
mri_blur3D_addfwhm( imin , mask , fwhm ) ;
}
/* do the fitting */
mri_polyfit_verb(verb) ;
if( do_byslice )
imout = mri_polyfit_byslice( imin , nord , exar , mask , mrad , meth ) ;
else
imout = mri_polyfit ( imin , nord , exar , mask , mrad , meth ) ;
/* WTF? */
if( imout == NULL )
ERROR_exit("Can't compute polynomial fit :-( !?") ;
if( resid == NULL ) mri_free(imin) ;
if( ! do_byslice )
fvit = mri_polyfit_get_fitvec() ; /* get coefficients of fit [26 Feb 2019] */
/* scale the fit dataset? */
if( do_mone ){
float sum=0.0f ; int nsum=0 , ii,nvox ; float *par=MRI_FLOAT_PTR(imout) ;
nvox = imout->nvox ;
for( ii=0 ; ii < nvox ; ii++ ){
if( mask != NULL && mask[ii] == 0 ) continue ;
sum += par[ii] ; nsum++ ;
}
if( nsum > 0 && sum != 0.0f ){
sum = nsum / sum ;
if( verb ) ININFO_message("-mone: scaling fit by %g",sum) ;
for( ii=0 ; ii < nvox ; ii++ ) par[ii] *= sum ;
}
}
/* if there's a mask, clip values outside of its box */
#undef PF
#define PF(i,j,k) par[(i)+(j)*nx+(k)*nxy]
if( mask != NULL && do_mclip ){
int xm,xp,ym,yp,zm,zp , ii,jj,kk , nx,ny,nz,nxy ; float *par ;
MRI_IMAGE *bim = mri_empty_conforming( imout , MRI_byte ) ;
mri_fix_data_pointer(mask,bim) ;
if( verb ) ININFO_message("-mclip: polynomial fit to autobox of mask") ;
MRI_autobbox( bim , &xm,&xp , &ym,&yp , &zm,&zp ) ;
mri_clear_data_pointer(bim) ; mri_free(bim) ;
nx = imout->nx ; ny = imout->ny ; nz = imout->nz ; nxy = nx*ny ;
par = MRI_FLOAT_PTR(imout) ;
for( ii=0 ; ii < xm ; ii++ )
for( kk=0 ; kk < nz ; kk++ )
for( jj=0 ; jj < ny ; jj++ ) PF(ii,jj,kk) = PF(xm,jj,kk) ;
for( ii=xp+1 ; ii < nx ; ii++ )
for( kk=0 ; kk < nz ; kk++ )
for( jj=0 ; jj < ny ; jj++ ) PF(ii,jj,kk) = PF(xp,jj,kk) ;
for( jj=0 ; jj < ym ; jj++ )
for( kk=0 ; kk < nz ; kk++ )
for( ii=0 ; ii < nx ; ii++ ) PF(ii,jj,kk) = PF(ii,ym,kk) ;
for( jj=yp+1 ; jj < ny ; jj++ )
for( kk=0 ; kk < nz ; kk++ )
for( ii=0 ; ii < nx ; ii++ ) PF(ii,jj,kk) = PF(ii,yp,kk) ;
for( kk=0 ; kk < zm ; kk++ )
for( jj=0 ; jj < ny ; jj++ )
for( ii=0 ; ii < nx ; ii++ ) PF(ii,jj,kk) = PF(ii,jj,zm) ;
for( kk=zp+1 ; kk < nz ; kk++ )
for( jj=0 ; jj < ny ; jj++ )
for( ii=0 ; ii < nx ; ii++ ) PF(ii,jj,kk) = PF(ii,jj,zp) ;
}
if( mask != NULL ) free(mask) ;
/* write outputs */
if( prefix != NULL ){
THD_3dim_dataset *outset = EDIT_empty_copy( inset ) ;
EDIT_dset_items( outset ,
ADN_prefix , prefix ,
ADN_nvals , 1 ,
ADN_ntt , 0 ,
ADN_none ) ;
EDIT_substitute_brick( outset , 0 , MRI_float , MRI_FLOAT_PTR(imout) ) ;
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dPolyfit" , argc,argv , outset ) ;
DSET_write(outset) ;
WROTE_DSET(outset) ;
}
if( resid != NULL ){
THD_3dim_dataset *outset = EDIT_empty_copy( inset ) ;
float *inar=MRI_FLOAT_PTR(imin) , *outar=MRI_FLOAT_PTR(imout) ;
int nx,ny,nz , nxyz , kk ;
nx = imout->nx ; ny = imout->ny ; nz = imout->nz ; nxyz = nx*ny*nz ;
for( kk=0 ; kk < nxyz ; kk++ ) outar[kk] = inar[kk] - outar[kk] ;
mri_free(imin) ;
EDIT_dset_items( outset ,
ADN_prefix , resid ,
ADN_nvals , 1 ,
ADN_ntt , 0 ,
ADN_none ) ;
EDIT_substitute_brick( outset , 0 , MRI_float , MRI_FLOAT_PTR(imout) ) ;
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dPolyfit" , argc,argv , outset ) ;
DSET_write(outset) ;
WROTE_DSET(outset) ;
}
if( cfnam != NULL && fvit != NULL ){ /* won't work with '-byslice' */
char *qn ;
qn = STRING_HAS_SUFFIX(cfnam,".1D") ? cfnam : modify_afni_prefix(cfnam,NULL,".1D") ;
mri_write_floatvec( qn , fvit ) ;
}
exit(0) ;
}
void UC_read_opts( int argc , char * argv[] )
{
int nopt = 1 ;
float val ;
int kk, nxyz, mm,nn ;
float * vv , * bb ;
while( nopt < argc && argv[nopt][0] == '-' ){
/**** -verbose ****/
if( strncmp(argv[nopt],"-verbose",5) == 0 ){
UC_be_quiet = 0 ;
nopt++ ; continue ;
}
/**** -ref file.1D ****/
if( strncmp(argv[nopt],"-ref",4) == 0 ){
MRI_IMAGE * im ;
nopt++ ;
if( nopt >= argc ) UC_syntax("-ref needs an argument!") ;
im = mri_read( argv[nopt] ) ;
if( im == NULL ) UC_syntax("Can't read -ref file!") ;
if( im->kind == MRI_float ){
UC_ref = im ;
} else {
UC_ref = mri_to_float(im) ; mri_free(im) ;
}
im = mri_transpose(UC_ref) ; mri_free(UC_ref) ; UC_ref = im ;
nopt++ ; continue ;
}
/**** -prefix prefix ****/
if( strncmp(argv[nopt],"-prefix",6) == 0 ){
nopt++ ;
if( nopt >= argc ) UC_syntax("-prefix needs an argument!") ;
MCW_strncpy( UC_prefix , argv[nopt++] , THD_MAX_PREFIX ) ;
continue ;
}
/**** -mask mset ****/
if( strncmp(argv[nopt],"-mask",5) == 0 ){
THD_3dim_dataset * mset ; int ii ;
nopt++ ;
if( nopt >= argc ) UC_syntax("need arguments after -mask!") ;
mset = THD_open_dataset( argv[nopt] ) ;
if( mset == NULL ) UC_syntax("can't open -mask dataset!") ;
UC_mask = THD_makemask( mset , 0 , 1.0,0.0 ) ;
UC_mask_nvox = DSET_NVOX(mset) ;
DSET_delete(mset) ;
if( UC_mask == NULL ) UC_syntax("can't use -mask dataset!") ;
UC_mask_hits = THD_countmask( UC_mask_nvox , UC_mask ) ;
if( UC_mask_hits == 0 ) UC_syntax("mask is all zeros!") ;
if( !UC_be_quiet ) printf("--- %d voxels in mask\n",UC_mask_hits) ;
nopt++ ; continue ;
}
/**** unknown switch ****/
fprintf(stderr,"\n*** unrecognized option %s\n",argv[nopt]) ;
exit(1) ;
} /* end of loop over options */
/*--- a simple consistency check ---*/
/*--- last input is dataset name ---*/
if( nopt >= argc ) UC_syntax("no input dataset name?") ;
UC_dset = THD_open_dataset( argv[nopt] ) ;
if( !ISVALID_3DIM_DATASET(UC_dset) ){
fprintf(stderr,"\n*** can't open dataset file %s\n",argv[nopt]) ;
exit(1) ;
}
nxyz = DSET_NVOX(UC_dset) ;
if( UC_mask != NULL && nxyz != UC_mask_nvox )
UC_syntax("mask and input dataset size mismatch!") ;
/*--- load vectors ---*/
UC_nvec = (UC_mask_hits > 0) ? UC_mask_hits : nxyz ;
UC_vdim = DSET_NVALS(UC_dset) ;
if( UC_vdim < 4 )
UC_syntax("input dataset needs at least 4 sub-bricks!") ;
if( UC_ref == NULL || UC_ref->nx < UC_vdim )
UC_syntax("input ref not long enough for input dataset!") ;
vv = (float *) malloc( sizeof(float) * UC_nvec * UC_vdim ) ;
UC_vec = (float **) malloc( sizeof(float *) * UC_nvec ) ;
for( kk=0 ; kk < UC_nvec ; kk++ ) UC_vec[kk] = vv + (kk*UC_vdim) ;
if( !UC_be_quiet ) printf("--- reading dataset\n") ;
DSET_load(UC_dset) ; CHECK_LOAD_ERROR(UC_dset) ;
/* copy brick data into float storage */
if( !UC_be_quiet ) printf("--- loading vectors\n") ;
bb = (float *) malloc( sizeof(float) * nxyz ) ;
for( mm=0 ; mm < UC_vdim ; mm++ ){
EDIT_coerce_type( nxyz , DSET_BRICK_TYPE(UC_dset,mm) ,
DSET_ARRAY(UC_dset,mm) ,
MRI_float , bb ) ;
DSET_unload_one( UC_dset , mm ) ;
if( UC_mask == NULL ){
for( kk=0 ; kk < nxyz ; kk++ ) UC_vec[kk][mm] = bb[kk] ;
} else {
for( nn=kk=0 ; kk < nxyz ; kk++ )
if( UC_mask[kk] ) UC_vec[nn++][mm] = bb[kk] ;
}
}
free(bb) ; DSET_unload( UC_dset ) ;
/* detrend and normalize vectors */
if( !UC_be_quiet ) printf("--- normalizing vectors\n") ;
for( kk=0 ; kk < UC_nvec ; kk++ )
normalize( UC_vdim , UC_vec[kk] ) ;
for( kk=0 ; kk < UC_ref->ny ; kk++ )
normalize( UC_vdim , MRI_FLOAT_PTR(UC_ref) + kk*UC_ref->nx ) ;
return ;
}
int main( int argc , char *argv[] )
{
int iarg=1 , ii,nvox , nvals ;
THD_3dim_dataset *inset=NULL, *outset=NULL , *mset=NULL ;
char *prefix="./blurinmask" ;
float fwhm_goal=0.0f ; int fwhm_2D=0 ;
byte *mask=NULL ; int mask_nx=0,mask_ny=0,mask_nz=0 , automask=0 , nmask=0 ;
float dx,dy,dz=0.0f , *bar , val ;
int floatize=0 ; /* 18 May 2009 */
MRI_IMAGE *immask=NULL ; /* 07 Oct 2009 */
short *mmask=NULL ;
short *unval_mmask=NULL ; int nuniq_mmask=0 ;
int do_preserve=0 , use_qsar ; /* 19 Oct 2009 */
THD_3dim_dataset *fwhmset=NULL ;
MRI_IMAGE *fxim=NULL, *fyim=NULL, *fzim=NULL ; /* 13 Jun 2016 */
int niter_fxyz=0 ; float dmax=0.0f , dmin=0.0f ;
/*------- help the pitifully ignorant luser? -------*/
AFNI_SETUP_OMP(0) ; /* 24 Jun 2013 */
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"Usage: ~1~\n"
"3dBlurInMask [options]\n"
"Blurs a dataset spatially inside a mask. That's all. Experimental.\n"
"\n"
"OPTIONS ~1~\n"
"-------\n"
" -input ddd = This required 'option' specifies the dataset\n"
" that will be smoothed and output.\n"
" -FWHM f = Add 'f' amount of smoothness to the dataset (in mm).\n"
" **N.B.: This is also a required 'option'.\n"
" -FWHMdset d = Read in dataset 'd' and add the amount of smoothness\n"
" given at each voxel -- spatially variable blurring.\n"
" ** EXPERIMENTAL EXPERIMENTAL EXPERIMENTAL **\n"
" -mask mmm = Mask dataset, if desired. Blurring will\n"
" occur only within the mask. Voxels NOT in\n"
" the mask will be set to zero in the output.\n"
" -Mmask mmm = Multi-mask dataset -- each distinct nonzero\n"
" value in dataset 'mmm' will be treated as\n"
" a separate mask for blurring purposes.\n"
" **N.B.: 'mmm' must be byte- or short-valued!\n"
" -automask = Create an automask from the input dataset.\n"
" **N.B.: only 1 masking option can be used!\n"
" -preserve = Normally, voxels not in the mask will be\n"
" set to zero in the output. If you want the\n"
" original values in the dataset to be preserved\n"
" in the output, use this option.\n"
" -prefix ppp = Prefix for output dataset will be 'ppp'.\n"
" **N.B.: Output dataset is always in float format.\n"
" -quiet = Don't be verbose with the progress reports.\n"
" -float = Save dataset as floats, no matter what the\n"
" input data type is.\n"
" **N.B.: If the input dataset is unscaled shorts, then\n"
" the default is to save the output in short\n"
" format as well. In EVERY other case, the\n"
" program saves the output as floats. Thus,\n"
" the ONLY purpose of the '-float' option is to\n"
" force an all-shorts input dataset to be saved\n"
" as all-floats after blurring.\n"
"\n"
"NOTES ~1~\n"
"-----\n"
" * If you don't provide a mask, then all voxels will be included\n"
" in the blurring. (But then why are you using this program?)\n"
" * Note that voxels inside the mask that are not contiguous with\n"
" any other voxels inside the mask will not be modified at all!\n"
" * Works iteratively, similarly to 3dBlurToFWHM, but without\n"
" the extensive overhead of monitoring the smoothness.\n"
" * But this program will be faster than 3dBlurToFWHM, and probably\n"
" slower than 3dmerge.\n"
" * Since the blurring is done iteratively, rather than all-at-once as\n"
" in 3dmerge, the results will be slightly different than 3dmerge's,\n"
" even if no mask is used here (3dmerge, of course, doesn't take a mask).\n"
" * If the original FWHM of the dataset was 'S' and you input a value\n"
" 'F' with the '-FWHM' option, then the output dataset's smoothness\n"
" will be about sqrt(S*S+F*F). The number of iterations will be\n"
" about (F*F/d*d) where d=grid spacing; this means that a large value\n"
" of F might take a lot of CPU time!\n"
" * The spatial smoothness of a 3D+time dataset can be estimated with a\n"
" command similar to the following:\n"
" 3dFWHMx -detrend -mask mmm+orig -input ddd+orig\n"
) ;
printf(
" * The minimum number of voxels in the mask is %d\n",MASK_MIN) ;
printf(
" * Isolated voxels will be removed from the mask!\n") ;
PRINT_AFNI_OMP_USAGE("3dBlurInMask",NULL) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
/*---- official startup ---*/
PRINT_VERSION("3dBlurInMask"); mainENTRY("3dBlurInMask main"); machdep();
AFNI_logger("3dBlurInMask",argc,argv); AUTHOR("RW Cox") ;
/*---- loop over options ----*/
while( iarg < argc && argv[iarg][0] == '-' ){
if( strncmp(argv[iarg],"-preserve",5) == 0 ){ /* 19 Oct 2009 */
do_preserve = 1 ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-qui",4) == 0 ){
verb = 0 ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-ver",4) == 0 ){
verb++ ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-input") == 0 || strcmp(argv[iarg],"-dset") == 0 ){
if( inset != NULL ) ERROR_exit("Can't have two -input options") ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-input'") ;
inset = THD_open_dataset( argv[iarg] );
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-prefix") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '-prefix'") ;
prefix = strdup(argv[iarg]) ;
if( !THD_filename_ok(prefix) ) ERROR_exit("Bad name after '-prefix'") ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-Mmask") == 0 ){ /* 07 Oct 2009 */
if( ++iarg >= argc ) ERROR_exit("Need argument after '-Mmask'") ;
if( mmask != NULL || mask != NULL || automask ) ERROR_exit("Can't have two mask inputs") ;
mset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(mset,argv[iarg]) ;
DSET_load(mset) ; CHECK_LOAD_ERROR(mset) ;
mask_nx = DSET_NX(mset); mask_ny = DSET_NY(mset); mask_nz = DSET_NZ(mset);
#if 0
if( !MRI_IS_INT_TYPE(DSET_BRICK_TYPE(mset,0)) )
ERROR_exit("-Mmask dataset is not integer type!") ;
#endif
immask = mri_to_short( 1.0 , DSET_BRICK(mset,0) ) ;
mmask = MRI_SHORT_PTR(immask) ;
unval_mmask = UniqueShort( mmask, mask_nx*mask_ny*mask_nz, &nuniq_mmask, 0 ) ;
if( unval_mmask == NULL || nuniq_mmask == 0 )
ERROR_exit("-Mmask dataset cannot be processed!?") ;
if( nuniq_mmask == 1 && unval_mmask[0] == 0 )
ERROR_exit("-Mmask dataset is all zeros!?") ;
if( verb ){
int qq , ww ;
for( ii=qq=0 ; ii < nuniq_mmask ; ii++ ) if( unval_mmask[ii] != 0 ) qq++ ;
for( ii=ww=0 ; ii < immask->nvox ; ii++ ) if( mmask[ii] != 0 ) ww++ ;
INFO_message("%d unique nonzero values in -Mmask; %d nonzero voxels",qq,ww) ;
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mask") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '-mask'") ;
if( mmask != NULL || mask != NULL || automask ) ERROR_exit("Can't have two mask inputs") ;
mset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(mset,argv[iarg]) ;
DSET_load(mset) ; CHECK_LOAD_ERROR(mset) ;
mask_nx = DSET_NX(mset); mask_ny = DSET_NY(mset); mask_nz = DSET_NZ(mset);
mask = THD_makemask( mset , 0 , 0.5f, 0.0f ) ; DSET_unload(mset) ;
if( mask == NULL ) ERROR_exit("Can't make mask from dataset '%s'",argv[iarg]) ;
ii = THD_mask_remove_isolas( mask_nx,mask_ny,mask_nz , mask ) ;
if( verb && ii > 0 ) INFO_message("Removed %d isola%s from mask dataset",ii,(ii==1)?"\0":"s") ;
nmask = THD_countmask( mask_nx*mask_ny*mask_nz , mask ) ;
if( verb ) INFO_message("Number of voxels in mask = %d",nmask) ;
if( nmask < MASK_MIN ) ERROR_exit("Mask is too small to process") ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-automask") == 0 ){
if( mmask != NULL || mask != NULL ) ERROR_exit("Can't have 2 mask inputs") ;
automask = 1 ; iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-FWHM") == 0 || strcasecmp(argv[iarg],"-FHWM") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '%s'",argv[iarg-1]);
val = (float)strtod(argv[iarg],NULL) ;
if( val <= 0.0f ) ERROR_exit("Illegal value after '%s': '%s'",
argv[iarg-1],argv[iarg]) ;
fwhm_goal = val ; fwhm_2D = 0 ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-FWHMdset") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '%s'",argv[iarg-1]);
if( fwhmset != NULL ) ERROR_exit("You can't use option '-FWHMdset' twice :(") ;
fwhmset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(fwhmset,argv[iarg]) ;
do_preserve = 1 ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-float",6) == 0 ){ /* 18 May 2009 */
floatize = 1 ; iarg++ ; continue ;
}
#if 0
if( strcmp(argv[iarg],"-FWHMxy") == 0 || strcmp(argv[iarg],"-FHWMxy") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '%s'",argv[iarg-1]);
val = (float)strtod(argv[iarg],NULL) ;
if( val <= 0.0f ) ERROR_exit("Illegal value after '%s': '%s'",
argv[iarg-1],argv[iarg]) ;
fwhm_goal = val ; fwhm_2D = 1 ;
iarg++ ; continue ;
}
#endif
ERROR_exit("Uknown option '%s'",argv[iarg]) ;
} /*--- end of loop over options ---*/
/*----- check for stupid inputs, load datasets, et cetera -----*/
if( fwhmset == NULL && fwhm_goal == 0.0f )
ERROR_exit("No -FWHM option given! What do you want?") ;
if( fwhmset != NULL && fwhm_goal > 0.0f ){
WARNING_message("-FWHMdset option replaces -FWHM value") ;
fwhm_goal = 0.0f ;
}
if( fwhmset != NULL && mmask != NULL )
ERROR_exit("Sorry: -FWHMdset and -Mmask don't work together (yet)") ;
if( inset == NULL ){
if( iarg >= argc ) ERROR_exit("No input dataset on command line?") ;
inset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(inset,argv[iarg]) ;
}
nvox = DSET_NVOX(inset) ;
dx = fabs(DSET_DX(inset)) ; if( dx == 0.0f ) dx = 1.0f ;
dy = fabs(DSET_DY(inset)) ; if( dy == 0.0f ) dy = 1.0f ;
dz = fabs(DSET_DZ(inset)) ; if( dz == 0.0f ) dz = 1.0f ;
dmax = MAX(dx,dy) ; if( dmax < dz ) dmax = dz ; /* 13 Jun 2016 */
dmin = MIN(dx,dy) ; if( dmin > dz ) dmin = dz ;
if( !floatize ){ /* 18 May 2009 */
if( !THD_datum_constant(inset->dblk) ||
THD_need_brick_factor(inset) ||
DSET_BRICK_TYPE(inset,0) != MRI_short ){
if( verb ) INFO_message("forcing output to be stored in float format") ;
floatize = 1 ;
} else {
if( verb ) INFO_message("output dataset will be stored as shorts") ;
}
} else {
if( verb ) INFO_message("output dataset will be stored as floats") ;
}
#if 0
if( DSET_NZ(inset) == 1 && !fwhm_2D ){
WARNING_message("Dataset is 2D ==> switching from -FWHM to -FWHMxy") ;
fwhm_2D = 1 ;
}
#endif
/*--- deal with mask or automask ---*/
if( mask != NULL ){
if( mask_nx != DSET_NX(inset) ||
mask_ny != DSET_NY(inset) ||
mask_nz != DSET_NZ(inset) )
ERROR_exit("-mask dataset grid doesn't match input dataset") ;
} else if( automask ){
mask = THD_automask( inset ) ;
if( mask == NULL )
ERROR_message("Can't create -automask from input dataset?") ;
nmask = THD_countmask( DSET_NVOX(inset) , mask ) ;
if( verb ) INFO_message("Number of voxels in automask = %d",nmask);
if( nmask < MASK_MIN ) ERROR_exit("Automask is too small to process") ;
} else if( mmask != NULL ){
if( mask_nx != DSET_NX(inset) ||
mask_ny != DSET_NY(inset) ||
mask_nz != DSET_NZ(inset) )
ERROR_exit("-Mmask dataset grid doesn't match input dataset") ;
} else {
mask = (byte *)malloc(sizeof(byte)*nvox) ; nmask = nvox ;
memset(mask,1,sizeof(byte)*nvox) ;
if( verb ) INFO_message("No mask ==> processing all %d voxels",nvox);
}
/*--- process FWHMdset [13 Jun 2016] ---*/
if( fwhmset != NULL ){
float *fxar,*fyar,*fzar , *fwar ; MRI_IMAGE *fwim ;
float fwmax=0.0f , fsx,fsy,fsz ; int ii, nfpos=0 ;
if( DSET_NX(inset) != DSET_NX(fwhmset) ||
DSET_NY(inset) != DSET_NY(fwhmset) ||
DSET_NZ(inset) != DSET_NZ(fwhmset) )
ERROR_exit("grid dimensions for FWHMdset and input dataset do not match :(") ;
STATUS("get fwim") ;
DSET_load(fwhmset) ;
fwim = mri_scale_to_float(DSET_BRICK_FACTOR(fwhmset,0),DSET_BRICK(fwhmset,0));
fwar = MRI_FLOAT_PTR(fwim);
DSET_unload(fwhmset) ;
STATUS("process fwar") ;
for( ii=0 ; ii < nvox ; ii++ ){
if( mask[ii] && fwar[ii] > 0.0f ){
nfpos++ ;
if( fwar[ii] > fwmax ) fwmax = fwar[ii] ;
} else {
fwar[ii] = 0.0f ; mask[ii] = 0 ;
}
}
if( nfpos < 100 )
ERROR_exit("Cannot proceed: too few (%d) voxels are positive in -FWHMdset!",nfpos) ;
niter_fxyz = (int)rintf(2.0f*fwmax*fwmax*FFAC/(0.05f*dmin*dmin)) + 1 ;
if( verb ) INFO_message("-FWHMdset: niter=%d npos=%d",niter_fxyz,nfpos) ;
STATUS("create fxim etc.") ;
fxim = mri_new_conforming(fwim,MRI_float); fxar = MRI_FLOAT_PTR(fxim);
fyim = mri_new_conforming(fwim,MRI_float); fyar = MRI_FLOAT_PTR(fyim);
fzim = mri_new_conforming(fwim,MRI_float); fzar = MRI_FLOAT_PTR(fzim);
fsx = FFAC/(dx*dx*niter_fxyz) ;
fsy = FFAC/(dy*dy*niter_fxyz) ;
fsz = FFAC/(dz*dz*niter_fxyz) ;
/** INFO_message("fsx=%g fsy=%g fsz=%g",fsx,fsy,fsz) ; **/
for( ii=0 ; ii < nvox ; ii++ ){
if( fwar[ii] > 0.0f ){
fxar[ii] = fwar[ii]*fwar[ii] * fsx ;
fyar[ii] = fwar[ii]*fwar[ii] * fsy ;
fzar[ii] = fwar[ii]*fwar[ii] * fsz ;
} else {
fxar[ii] = fyar[ii] = fzar[ii] = 0.0f ;
}
}
STATUS("free(fwim)") ;
mri_free(fwim) ;
}
/*--- process input dataset ---*/
STATUS("load input") ;
DSET_load(inset) ; CHECK_LOAD_ERROR(inset) ;
outset = EDIT_empty_copy( inset ) ; /* moved here 04 Jun 2007 */
EDIT_dset_items( outset , ADN_prefix , prefix , ADN_none ) ;
EDIT_dset_items( outset , ADN_brick_fac , NULL , ADN_none ) ; /* 11 Sep 2007 */
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dBlurInMask" , argc,argv , outset ) ;
nvals = DSET_NVALS(inset) ;
use_qsar = (do_preserve || mmask != NULL) ; /* 19 Oct 20090 */
AFNI_OMP_START ;
#pragma omp parallel if( nvals > 1 )
{
MRI_IMAGE *dsim ; int ids,qit ; byte *qmask=NULL ; register int vv ;
MRI_IMAGE *qim=NULL, *qsim=NULL; float *qar=NULL, *dsar, *qsar=NULL;
#pragma omp critical (MALLOC)
{ if( use_qsar ){
qsim = mri_new_conforming(DSET_BRICK(inset,0),MRI_float); qsar = MRI_FLOAT_PTR(qsim);
}
if( mmask != NULL ){
qmask = (byte *)malloc(sizeof(byte)*nvox) ;
qim = mri_new_conforming(immask,MRI_float); qar = MRI_FLOAT_PTR(qim);
qim->dx = dx ; qim->dy = dy ; qim->dz = dz ;
}
}
#pragma omp for
for( ids=0 ; ids < nvals ; ids++ ){
#pragma omp critical (MALLOC)
{ dsim = mri_scale_to_float(DSET_BRICK_FACTOR(inset,ids),DSET_BRICK(inset,ids));
DSET_unload_one(inset,ids) ;
}
dsim->dx = dx ; dsim->dy = dy ; dsim->dz = dz ; dsar = MRI_FLOAT_PTR(dsim) ;
/* if needed, initialize qsar with data to be preserved in output */
if( do_preserve ){
for( vv=0 ; vv < nvox ; vv++ ) qsar[vv] = dsar[vv] ;
} else if( mmask != NULL ){
for( vv=0 ; vv < nvox ; vv++ ) qsar[vv] = 0.0f ;
}
if( fwhmset != NULL ){ /* 13 Jun 2016: spatially variable blurring */
for( qit=0 ; qit < niter_fxyz ; qit++ ){
mri_blur3D_variable( dsim , mask , fxim,fyim,fzim ) ;
}
if( do_preserve ){
for( vv=0 ; vv < nvox ; vv++ ) if( mask[vv] ) qsar[vv] = dsar[vv] ;
}
} else if( mmask != NULL ){ /* 07 Oct 2009: multiple masks */
int qq ; register short uval ;
for( qq=0 ; qq < nuniq_mmask ; qq++ ){
uval = unval_mmask[qq] ; if( uval == 0 ) continue ;
for( vv=0 ; vv < nvox ; vv++ ) qmask[vv] = (mmask[vv]==uval) ; /* make mask */
(void)THD_mask_remove_isolas( mask_nx,mask_ny,mask_nz , qmask ) ;
nmask = THD_countmask( nvox , qmask ) ;
if( verb && ids==0 ) ININFO_message("voxels in Mmask[%d] = %d",uval,nmask) ;
if( nmask >= MASK_MIN ){
/* copy data from dataset to qar */
for( vv=0 ; vv < nvox ; vv++ ) if( qmask[vv] ) qar[vv] = dsar[vv] ;
/* blur qar (output will be zero where qmask==0) */
mri_blur3D_addfwhm( qim , qmask , fwhm_goal ) ; /** the real work **/
/* copy results back to qsar */
for( vv=0 ; vv < nvox ; vv++ ) if( qmask[vv] ) qsar[vv] = qar[vv] ;
}
}
} else { /* the olden way: 1 mask */
mri_blur3D_addfwhm( dsim , mask , fwhm_goal ) ; /** all the work **/
/* dsim will be zero where mask==0;
if we want to preserve the input values, copy dsar into qsar now
at all mask!=0 voxels, since qsar contains the original data values */
if( do_preserve ){
for( vv=0 ; vv < nvox ; vv++ ) if( mask[vv] ) qsar[vv] = dsar[vv] ;
}
}
/* if necessary, copy combined results in qsar to dsar for output */
if( use_qsar ){
for( vv=0 ; vv < nvox ; vv++ ) dsar[vv] = qsar[vv] ;
}
if( floatize ){
EDIT_substitute_brick( outset , ids , MRI_float , dsar ) ;
} else {
#pragma omp critical (MALLOC)
{ EDIT_substscale_brick( outset , ids , MRI_float , dsar ,
MRI_short , 1.0f ) ;
mri_free(dsim) ;
}
}
} /* end of loop over sub-bricks */
#pragma omp critical (MALLOC)
{ if( qsim != NULL ) mri_free(qsim);
if( immask != NULL ){ free(qmask); mri_free(qim); }
}
} /* end OpenMP */
AFNI_OMP_END ;
if( mask != NULL ) free( mask) ;
if( immask != NULL ) mri_free(immask) ;
DSET_unload(inset) ;
DSET_write(outset) ;
WROTE_DSET(outset) ;
exit(0) ;
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *dset , *oset=NULL , *tset=NULL ;
int nvals , iv , nxyz , ii,jj,kk , iarg , kz,kzold ;
float cut1=2.5,cut2=4.0 , sq2p,sfac , fq ;
MRI_IMAGE *flim ;
char *prefix="despike" , *tprefix=NULL ;
int corder=-1 , nref , ignore=0 , polort=2 , nuse , nomask=0 ;
int nspike, nbig, nproc ;
float **ref ;
float c21,ic21 , pspike,pbig ;
short *sar , *qar ;
byte *tar , *mask=NULL ;
float *zar , *yar ;
int datum ;
int localedit=0 ; /* 04 Apr 2007 */
int verb=1 ;
int do_NEW = 0 ; /* 29 Nov 2013 */
MRI_IMAGE *NEW_psinv=NULL ;
int dilate = 4 ; /* 04 Dec 2013 */
int ctim = 0 ;
/*----- Read command line -----*/
AFNI_SETUP_OMP(0) ; /* 24 Jun 2013 */
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf("Usage: 3dDespike [options] dataset\n"
"Removes 'spikes' from the 3D+time input dataset and writes\n"
"a new dataset with the spike values replaced by something\n"
"more pleasing to the eye.\n"
"\n"
"Method:\n"
" * L1 fit a smooth-ish curve to each voxel time series\n"
" [see -corder option for description of the curve]\n"
" [see -NEW option for a different & faster fitting method]\n"
" * Compute the MAD of the difference between the curve and\n"
" the data time series (the residuals).\n"
" * Estimate the standard deviation 'sigma' of the residuals\n"
" as sqrt(PI/2)*MAD.\n"
" * For each voxel value, define s = (value-curve)/sigma.\n"
" * Values with s > c1 are replaced with a value that yields\n"
" a modified s' = c1+(c2-c1)*tanh((s-c1)/(c2-c1)).\n"
" * c1 is the threshold value of s for a 'spike' [default c1=2.5].\n"
" * c2 is the upper range of the allowed deviation from the curve:\n"
" s=[c1..infinity) is mapped to s'=[c1..c2) [default c2=4].\n"
"\n"
"Options:\n"
" -ignore I = Ignore the first I points in the time series:\n"
" these values will just be copied to the\n"
" output dataset [default I=0].\n"
" -corder L = Set the curve fit order to L:\n"
" the curve that is fit to voxel data v(t) is\n"
"\n"
" k=L [ (2*PI*k*t) (2*PI*k*t) ]\n"
" f(t) = a+b*t+c*t*t + SUM [ d * sin(--------) + e * cos(--------) ]\n"
" k=1 [ k ( T ) k ( T ) ]\n"
"\n"
" where T = duration of time series;\n"
" the a,b,c,d,e parameters are chosen to minimize\n"
" the sum over t of |v(t)-f(t)| (L1 regression);\n"
" this type of fitting is is insensitive to large\n"
" spikes in the data. The default value of L is\n"
" NT/30, where NT = number of time points.\n"
"\n"
" -cut c1 c2 = Alter default values for the spike cut values\n"
" [default c1=2.5, c2=4.0].\n"
" -prefix pp = Save de-spiked dataset with prefix 'pp'\n"
" [default pp='despike']\n"
" -ssave ttt = Save 'spikiness' measure s for each voxel into a\n"
" 3D+time dataset with prefix 'ttt' [default=no save]\n"
" -nomask = Process all voxels\n"
" [default=use a mask of high-intensity voxels, ]\n"
" [as created via '3dAutomask -dilate 4 dataset'].\n"
" -dilate nd = Dilate 'nd' times (as in 3dAutomask). The default\n"
" value of 'nd' is 4.\n"
" -q[uiet] = Don't print '++' informational messages.\n"
"\n"
" -localedit = Change the editing process to the following:\n"
" If a voxel |s| value is >= c2, then replace\n"
" the voxel value with the average of the two\n"
" nearest non-spike (|s| < c2) values; the first\n"
" one previous and the first one after.\n"
" Note that the c1 cut value is not used here.\n"
"\n"
" -NEW = Use the 'new' method for computing the fit, which\n"
" should be faster than the L1 method for long time\n"
" series (200+ time points); however, the results\n"
" are similar but NOT identical. [29 Nov 2013]\n"
" * You can also make the program use the 'new'\n"
" method by setting the environment variable\n"
" AFNI_3dDespike_NEW\n"
" to the value YES; as in\n"
" setenv AFNI_3dDespike_NEW YES (csh)\n"
" export AFNI_3dDespike_NEW=YES (bash)\n"
" * If this variable is set to YES, you can turn off\n"
" the '-NEW' processing by using the '-OLD' option.\n"
" -->>* For time series more than 500 points long, the\n"
" '-OLD' algorithm is tremendously slow. You should\n"
" use the '-NEW' algorith in such cases.\n"
" ** At some indeterminate point in the future, the '-NEW'\n"
" method will become the default!\n"
" -->>* As of 29 Sep 2016, '-NEW' is the default if there\n"
" is more than 500 points in the time series dataset.\n"
"\n"
" -NEW25 = A slightly more aggressive despiking approach than\n"
" the '-NEW' method.\n"
"\n"
"Caveats:\n"
"* Despiking may interfere with image registration, since head\n"
" movement may produce 'spikes' at the edge of the brain, and\n"
" this information would be used in the registration process.\n"
" This possibility has not been explored or calibrated.\n"
"* [LATER] Actually, it seems like the registration problem\n"
" does NOT happen, and in fact, despiking seems to help!\n"
"* Check your data visually before and after despiking and\n"
" registration!\n"
" [Hint: open 2 AFNI controllers, and turn Time Lock on.]\n"
) ;
PRINT_AFNI_OMP_USAGE("3dDespike",NULL) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
/** AFNI package setup and logging **/
mainENTRY("3dDespike main"); machdep(); AFNI_logger("3dDespike",argc,argv);
PRINT_VERSION("3dDespike") ; AUTHOR("RW Cox") ;
/** parse options **/
if( AFNI_yesenv("AFNI_3dDespike_NEW") ) do_NEW = 1 ; /* 29 Nov 2013 */
iarg = 1 ;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strncmp(argv[iarg],"-q",2) == 0 ){ /* 04 Apr 2007 */
verb = 0 ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-v",2) == 0 ){
verb++ ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-NEW") == 0 ){ /* 29 Nov 2013 */
do_NEW = 1 ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-NEW25") == 0 ){ /* 29 Sep 2016 */
do_NEW = 1 ; use_des25 = 1 ; cut1 = 2.5f ; cut2 = 3.2f ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-OLD") == 0 ){
do_NEW = 0 ; iarg++ ; continue ;
}
/** -localedit **/
if( strcmp(argv[iarg],"-localedit") == 0 ){ /* 04 Apr 2007 */
localedit = 1 ; iarg++ ; continue ;
}
/** don't use masking **/
if( strcmp(argv[iarg],"-nomask") == 0 ){
nomask = 1 ; iarg++ ; continue ;
}
/** dilation count [04 Dec 2013] **/
if( strcmp(argv[iarg],"-dilate") == 0 ){
dilate = (int)strtod(argv[++iarg],NULL) ;
if( dilate <= 0 ) dilate = 1 ;
else if( dilate > 99 ) dilate = 99 ;
iarg++ ; continue ;
}
/** output dataset prefix **/
if( strcmp(argv[iarg],"-prefix") == 0 ){
prefix = argv[++iarg] ;
if( !THD_filename_ok(prefix) ) ERROR_exit("-prefix is not good");
iarg++ ; continue ;
}
/** ratio dataset prefix **/
if( strcmp(argv[iarg],"-ssave") == 0 ){
tprefix = argv[++iarg] ;
if( !THD_filename_ok(tprefix) ) ERROR_exit("-ssave prefix is not good");
iarg++ ; continue ;
}
/** trigonometric polynomial order **/
if( strcmp(argv[iarg],"-corder") == 0 ){
corder = strtol( argv[++iarg] , NULL , 10 ) ;
if( corder < 0 ) ERROR_exit("Illegal value of -corder");
iarg++ ; continue ;
}
/** how much to ignore at start **/
if( strcmp(argv[iarg],"-ignore") == 0 ){
ignore = strtol( argv[++iarg] , NULL , 10 ) ;
if( ignore < 0 ) ERROR_exit("Illegal value of -ignore");
iarg++ ; continue ;
}
/** thresholds for s ratio **/
if( strcmp(argv[iarg],"-cut") == 0 ){
cut1 = strtod( argv[++iarg] , NULL ) ;
cut2 = strtod( argv[++iarg] , NULL ) ;
if( cut1 < 1.0 || cut2 < cut1+0.5 )
ERROR_exit("Illegal values after -cut");
iarg++ ; continue ;
}
ERROR_exit("Unknown option: %s",argv[iarg]) ;
}
c21 = cut2-cut1 ; ic21 = 1.0/c21 ;
/*----- read input dataset -----*/
if( iarg >= argc ) ERROR_exit("No input dataset!!??");
dset = THD_open_dataset( argv[iarg] ) ;
CHECK_OPEN_ERROR(dset,argv[iarg]) ;
datum = DSET_BRICK_TYPE(dset,0) ;
if( (datum != MRI_short && datum != MRI_float) || !DSET_datum_constant(dset) )
ERROR_exit("Can't process non-short, non-float dataset!") ;
if( verb ) INFO_message("Input data type = %s\n",MRI_TYPE_name[datum]) ;
nvals = DSET_NUM_TIMES(dset) ; nuse = nvals - ignore ;
if( nuse < 15 )
ERROR_exit("Can't use dataset with < 15 time points per voxel!") ;
if( nuse > 500 && !do_NEW ){
INFO_message("Switching to '-NEW' method since number of time points = %d > 500",nuse) ;
do_NEW = 1 ;
}
if( use_des25 && nuse < 99 ) use_des25 = 0 ;
if( verb ) INFO_message("ignoring first %d time points, using last %d",ignore,nuse);
if( corder > 0 && 4*corder+2 > nuse ){
ERROR_exit("-corder %d is too big for NT=%d",corder,nvals) ;
} else if( corder < 0 ){
corder = rint(nuse/30.0) ; if( corder > 50 && !do_NEW ) corder = 50 ;
if( verb ) INFO_message("using %d time points => -corder %d",nuse,corder) ;
} else {
if( verb ) INFO_message("-corder %d set from command line",corder) ;
}
nxyz = DSET_NVOX(dset) ;
if( verb ) INFO_message("Loading dataset %s",argv[iarg]) ;
DSET_load(dset) ; CHECK_LOAD_ERROR(dset) ;
/*-- create automask --*/
if( !nomask ){
mask = THD_automask( dset ) ;
if( verb ){
ii = THD_countmask( DSET_NVOX(dset) , mask ) ;
INFO_message("%d voxels in the automask [out of %d in dataset]",ii,DSET_NVOX(dset)) ;
}
for( ii=0 ; ii < dilate ; ii++ )
THD_mask_dilate( DSET_NX(dset), DSET_NY(dset), DSET_NZ(dset), mask, 3 ) ;
if( verb ){
ii = THD_countmask( DSET_NVOX(dset) , mask ) ;
INFO_message("%d voxels in the dilated automask [out of %d in dataset]",ii,DSET_NVOX(dset)) ;
}
} else {
if( verb ) INFO_message("processing all %d voxels in dataset",DSET_NVOX(dset)) ;
}
/*-- create empty despiked dataset --*/
oset = EDIT_empty_copy( dset ) ;
EDIT_dset_items( oset ,
ADN_prefix , prefix ,
ADN_brick_fac , NULL ,
ADN_datum_all , datum ,
ADN_none ) ;
if( THD_deathcon() && THD_is_file(DSET_HEADNAME(oset)) )
ERROR_exit("output dataset already exists: %s",DSET_HEADNAME(oset));
tross_Copy_History( oset , dset ) ;
tross_Make_History( "3dDespike" , argc , argv , oset ) ;
/* create bricks (will be filled with zeros) */
for( iv=0 ; iv < nvals ; iv++ )
EDIT_substitute_brick( oset , iv , datum , NULL ) ;
/* copy the ignored bricks */
switch( datum ){
case MRI_short:
for( iv=0 ; iv < ignore ; iv++ ){
sar = DSET_ARRAY(oset,iv) ;
qar = DSET_ARRAY(dset,iv) ;
memcpy( sar , qar , DSET_BRICK_BYTES(dset,iv) ) ;
DSET_unload_one(dset,iv) ;
}
break ;
case MRI_float:
for( iv=0 ; iv < ignore ; iv++ ){
zar = DSET_ARRAY(oset,iv) ;
yar = DSET_ARRAY(dset,iv) ;
memcpy( zar , yar , DSET_BRICK_BYTES(dset,iv) ) ;
DSET_unload_one(dset,iv) ;
}
break ;
}
/*-- setup to save a threshold statistic dataset, if desired --*/
if( tprefix != NULL ){
float *fac ;
tset = EDIT_empty_copy( dset ) ;
fac = (float *) malloc( sizeof(float) * nvals ) ;
for( ii=0 ; ii < nvals ; ii++ ) fac[ii] = TFAC ;
EDIT_dset_items( tset ,
ADN_prefix , tprefix ,
ADN_brick_fac , fac ,
ADN_datum_all , MRI_byte ,
ADN_func_type , FUNC_FIM_TYPE ,
ADN_none ) ;
free(fac) ;
tross_Copy_History( tset , dset ) ;
tross_Make_History( "3dDespike" , argc , argv , tset ) ;
#if 0
if( THD_is_file(DSET_HEADNAME(tset)) )
ERROR_exit("-ssave dataset already exists");
#endif
tross_Copy_History( tset , dset ) ;
tross_Make_History( "3dDespike" , argc , argv , tset ) ;
for( iv=0 ; iv < nvals ; iv++ )
EDIT_substitute_brick( tset , iv , MRI_byte , NULL ) ;
}
/*-- setup to find spikes --*/
sq2p = sqrt(0.5*PI) ;
sfac = sq2p / 1.4826f ;
/* make ref functions */
nref = 2*corder+3 ;
ref = (float **) malloc( sizeof(float *) * nref ) ;
for( jj=0 ; jj < nref ; jj++ )
ref[jj] = (float *) malloc( sizeof(float) * nuse ) ;
/* r(t) = 1 */
for( iv=0 ; iv < nuse ; iv++ ) ref[0][iv] = 1.0 ;
jj = 1 ;
/* r(t) = t - tmid */
{ float tm = 0.5 * (nuse-1.0) ; float fac = 2.0 / nuse ;
for( iv=0 ; iv < nuse ; iv++ ) ref[1][iv] = (iv-tm)*fac ;
jj = 2 ;
/* r(t) = (t-tmid)**jj */
for( ; jj <= polort ; jj++ )
for( iv=0 ; iv < nuse ; iv++ )
ref[jj][iv] = pow( (iv-tm)*fac , (double)jj ) ;
}
for( kk=1 ; kk <= corder ; kk++ ){
fq = (2.0*PI*kk)/nuse ;
/* r(t) = sin(2*PI*k*t/N) */
for( iv=0 ; iv < nuse ; iv++ )
ref[jj][iv] = sin(fq*iv) ;
jj++ ;
/* r(t) = cos(2*PI*k*t/N) */
for( iv=0 ; iv < nuse ; iv++ )
ref[jj][iv] = cos(fq*iv) ;
jj++ ;
}
/****** setup for the NEW solution method [29 Nov 2013] ******/
if( do_NEW ){
NEW_psinv = DES_get_psinv(nuse,nref,ref) ;
INFO_message("Procesing time series with NEW model fit algorithm") ;
} else {
INFO_message("Procesing time series with OLD model fit algorithm") ;
}
/*--- loop over voxels and do work ---*/
#define Laplace_t2p(val) ( 1.0 - nifti_stat2cdf( (val), 15, 0.0, 1.4427 , 0.0 ) )
if( verb ){
if( !localedit ){
INFO_message("smash edit thresholds: %.1f .. %.1f MADs",cut1*sq2p,cut2*sq2p) ;
ININFO_message(" [ %.3f%% .. %.3f%% of normal distribution]",
200.0*qg(cut1*sfac) , 200.0*qg(cut2*sfac) ) ;
ININFO_message(" [ %.3f%% .. %.3f%% of Laplace distribution]" ,
100.0*Laplace_t2p(cut1) , 100.0*Laplace_t2p(cut2) ) ;
} else {
INFO_message("local edit threshold: %.1f MADS",cut2*sq2p) ;
ININFO_message(" [ %.3f%% of normal distribution]",
200.0*qg(cut2*sfac) ) ;
ININFO_message(" [ %.3f%% of Laplace distribution]",
100.0*Laplace_t2p(cut1) ) ;
}
INFO_message("%d slices to process",DSET_NZ(dset)) ;
}
kzold = -1 ;
nspike = 0 ; nbig = 0 ; nproc = 0 ; ctim = NI_clock_time() ;
AFNI_OMP_START ;
#pragma omp parallel if( nxyz > 6666 )
{ int ii , iv , iu , id , jj ;
float *far , *dar , *var , *fitar , *ssp , *fit , *zar ;
short *sar , *qar ; byte *tar ;
float fsig , fq , cls , snew , val ;
float *NEW_wks=NULL ;
#pragma omp critical (DESPIKE_malloc)
{ far = (float *) malloc( sizeof(float) * nvals ) ;
dar = (float *) malloc( sizeof(float) * nvals ) ;
var = (float *) malloc( sizeof(float) * nvals ) ;
fitar = (float *) malloc( sizeof(float) * nvals ) ;
ssp = (float *) malloc( sizeof(float) * nvals ) ;
fit = (float *) malloc( sizeof(float) * nref ) ;
if( do_NEW ) NEW_wks = (float *)malloc(sizeof(float)*DES_workspace_size(nuse,nref)) ;
}
#ifdef USE_OMP
INFO_message("start OpenMP thread #%d",omp_get_thread_num()) ;
#endif
#pragma omp for
for( ii=0 ; ii < nxyz ; ii++ ){ /* ii = voxel index */
if( mask != NULL && mask[ii] == 0 ) continue ; /* skip this voxel */
#ifndef USE_OMP
kz = DSET_index_to_kz(dset,ii) ; /* starting a new slice */
if( kz != kzold ){
if( verb ){
fprintf(stderr, "++ start slice %2d",kz ) ;
if( nproc > 0 ){
pspike = (100.0*nspike)/nproc ;
pbig = (100.0*nbig )/nproc ;
fprintf(stderr,
"; so far %d data points, %d edits [%.3f%%], %d big edits [%.3f%%]",
nproc,nspike,pspike,nbig,pbig ) ;
}
fprintf(stderr,"\n") ;
}
kzold = kz ;
}
#else
if( verb && ii % 2345 == 1234 ) fprintf(stderr,".") ;
#endif
/*** extract ii-th time series into far[] ***/
switch( datum ){
case MRI_short:
for( iv=0 ; iv < nuse ; iv++ ){
qar = DSET_ARRAY(dset,iv+ignore) ; /* skip ignored data */
far[iv] = (float)qar[ii] ;
}
break ;
case MRI_float:
for( iv=0 ; iv < nuse ; iv++ ){
zar = DSET_ARRAY(dset,iv+ignore) ;
far[iv] = zar[ii] ;
}
break ;
}
AAmemcpy(dar,far,sizeof(float)*nuse) ; /* copy time series into dar[] */
/*** solve for L1 fit ***/
if( do_NEW )
cls = DES_solve( NEW_psinv , far , fit , NEW_wks ) ; /* 29 Nov 2013 */
else
cls = cl1_solve( nuse , nref , far , ref , fit,0 ) ; /* the slow part */
if( cls < 0.0f ){ /* fit failed! */
#if 0
fprintf(stderr,"curve fit fails at voxel %d %d %d\n",
DSET_index_to_ix(dset,ii) ,
DSET_index_to_jy(dset,ii) ,
DSET_index_to_kz(dset,ii) ) ;
#endif
continue ; /* skip this voxel */
}
for( iv=0 ; iv < nuse ; iv++ ){ /* detrend */
val = fit[0]
+ fit[1]*ref[1][iv] /* quadratic part of curve fit */
+ fit[2]*ref[2][iv] ;
for( jj=3 ; jj < nref ; jj++ ) /* rest of curve fit */
val += fit[jj] * ref[jj][iv] ;
fitar[iv] = val ; /* save curve fit value */
var[iv] = dar[iv]-val ; /* remove fitted value = resid */
far[iv] = fabsf(var[iv]) ; /* abs value of resid */
}
/*** compute estimate standard deviation of detrended data ***/
fsig = sq2p * qmed_float(nuse,far) ; /* also mangles far array */
/*** process time series for spikes, editing data in dar[] ***/
if( fsig > 0.0f ){ /* data wasn't fit perfectly */
/* find spikiness for each point in time */
fq = 1.0f / fsig ;
for( iv=0 ; iv < nuse ; iv++ ){
ssp[iv] = fq * var[iv] ; /* spikiness s = how many sigma out */
}
/* save spikiness in -ssave datset */
if( tset != NULL ){
for( iv=0 ; iv < nuse ; iv++ ){
tar = DSET_ARRAY(tset,iv+ignore) ;
snew = ITFAC*fabsf(ssp[iv]) ; /* scale for byte storage */
tar[ii] = BYTEIZE(snew) ; /* cf. mrilib.h */
}
}
/* process values of |s| > cut1, editing dar[] */
for( iv=0 ; iv < nuse ; iv++ ){ /* loop over time points */
if( !localedit ){ /** classic 'smash' edit **/
if( ssp[iv] > cut1 ){
snew = cut1 + c21*mytanh((ssp[iv]-cut1)*ic21) ; /* edit s down */
dar[iv] = fitar[iv] + snew*fsig ;
#pragma omp critical (DESPIKE_counter)
{ nspike++ ; if( ssp[iv] > cut2 ) nbig++ ; }
} else if( ssp[iv] < -cut1 ){
snew = -cut1 + c21*mytanh((ssp[iv]+cut1)*ic21) ; /* edit s up */
dar[iv] = fitar[iv] + snew*fsig ;
#pragma omp critical (DESPIKE_counter)
{ nspike++ ; if( ssp[iv] < -cut2 ) nbig++ ; }
}
} else { /** local edit: 04 Apr 2007 **/
if( ssp[iv] >= cut2 || ssp[iv] <= -cut2 ){
for( iu=iv+1 ; iu < nuse ; iu++ ) /* find non-spike above */
if( ssp[iu] < cut2 && ssp[iu] > -cut2 ) break ;
for( id=iv-1 ; id >= 0 ; id-- ) /* find non-spike below */
if( ssp[id] < cut2 && ssp[id] > -cut2 ) break ;
switch( (id>=0) + 2*(iu<nuse) ){ /* compute replacement val */
case 3: val = 0.5*(dar[iu]+dar[id]); break; /* iu and id OK */
case 2: val = dar[iu] ; break; /* only iu OK */
case 1: val = dar[id] ; break; /* only id OK */
default: val = fitar[iv] ; break; /* shouldn't be */
}
dar[iv] = val ;
#pragma omp critical (DESPIKE_counter)
{ nspike++ ; nbig++ ; }
}
}
} /* end of loop over time points */
#pragma omp atomic
nproc += nuse ; /* number data points processed */
} /* end of processing time series when fsig is positive */
/* put dar[] time series (possibly edited above) into output bricks */
switch( datum ){
case MRI_short:
for( iv=0 ; iv < nuse ; iv++ ){
sar = DSET_ARRAY(oset,iv+ignore) ; /* output brick */
sar[ii] = (short)dar[iv] ; /* original or mutated data */
}
break ;
case MRI_float:
for( iv=0 ; iv < nuse ; iv++ ){
zar = DSET_ARRAY(oset,iv+ignore) ; /* output brick */
zar[ii] = dar[iv] ; /* original or mutated data */
}
break ;
}
} /* end of loop over voxels #ii */
#pragma omp critical (DESPIKE_malloc)
{ free(fit); free(ssp); free(fitar); free(var); free(dar); free(far);
if( do_NEW ) free(NEW_wks) ; }
} /* end OpenMP */
AFNI_OMP_END ;
#ifdef USE_OMP
if( verb ) fprintf(stderr,"\n") ;
#endif
ctim = NI_clock_time() - ctim ;
INFO_message( "Elapsed despike time = %s" , nice_time_string(ctim) ) ;
if( ctim > 345678 && !do_NEW )
ININFO_message("That was SLOW -- try the '-NEW' option for a speedup") ;
#ifdef USE_OMP
if( verb ) fprintf(stderr,"\n") ;
#endif
/*--- finish up ---*/
if( do_NEW ) mri_free(NEW_psinv) ;
DSET_delete(dset) ; /* delete input dataset */
if( verb ){
if( nproc > 0 ){
pspike = (100.0*nspike)/nproc ;
pbig = (100.0*nbig )/nproc ;
INFO_message("FINAL: %d data points, %d edits [%.3f%%], %d big edits [%.3f%%]",
nproc,nspike,pspike,nbig,pbig ) ;
} else {
INFO_message("FINAL: no good voxels found to process!!??") ;
}
}
/* write results */
DSET_write(oset) ;
if( verb ) WROTE_DSET(oset) ;
DSET_delete(oset) ;
if( tset != NULL ){
DSET_write(tset) ;
if( verb ) WROTE_DSET(tset) ;
DSET_delete(tset) ;
}
exit( THD_get_write_error_count() ) ;
}
int
main (int argc, char *argv[])
{
THD_3dim_dataset *old_dset, *new_dset, *I0_dset; /* input and output datasets */
int nopt, nbriks, nvox;
int i;
MRI_IMAGE *grad1Dptr = NULL;
MRI_IMAGE *anat_im = NULL;
MRI_IMAGE *data_im = NULL;
double fac;
short *sar = NULL, *tempsptr = NULL, tempval;
byte *maskptr = NULL, *tempbptr = NULL;
char tempstr[25];
/*----- Read command line -----*/
if (argc < 2 || strcmp (argv[1], "-help") == 0)
{
printf ("Usage: 3dDTtoDWI [options] gradient-file I0-dataset DT-dataset\n"
"Computes multiple gradient images from 6 principle direction tensors and\n"
" corresponding gradient vector coordinates applied to the I0-dataset.\n"
" The program takes three parameters as input : \n"
" a 1D file of the gradient vectors with lines of ASCII floats Gxi,Gyi,Gzi.\n"
" Only the non-zero gradient vectors are included in this file (no G0 line).\n"
" The I0 dataset is a volume without any gradient applied.\n"
" The DT dataset is the 6-sub-brick dataset containing the diffusion tensor data,\n"
" Dxx, Dxy, Dyy, Dxz, Dyz, Dzz (lower triangular row-wise order)\n"
" Options:\n"
" -prefix pname = Use 'pname' for the output dataset prefix name.\n"
" [default='DWI']\n"
" -automask = mask dataset so that the gradient images are computed only for\n"
" high-intensity (presumably brain) voxels. The intensity level is\n"
" determined the same way that 3dClipLevel works.\n\n"
" -datum type = output dataset type [float/short/byte] (default is float).\n"
" -help = show this help screen.\n"
" Example:\n"
" 3dDTtoDWI -prefix DWI -automask tensor25.1D 'DT+orig[26]' DT+orig.\n\n"
" The output is a n sub-brick bucket dataset containing computed DWI images.\n"
" where n is the number of vectors in the gradient file + 1\n"
"\n");
printf ("\n" MASTER_SHORTHELP_STRING);
exit (0);
}
mainENTRY ("3dDTtoDWI main");
machdep ();
AFNI_logger ("3dDTtoDWI", argc, argv);
PRINT_VERSION("3dDTtoDWI") ;
nopt = 1;
datum = MRI_float;
while (nopt < argc && argv[nopt][0] == '-')
{
/*-- prefix --*/
if (strcmp (argv[nopt], "-prefix") == 0)
{
if (++nopt >= argc)
{
fprintf (stderr, "*** Error - prefix needs an argument!\n");
exit (1);
}
MCW_strncpy (prefix, argv[nopt], THD_MAX_PREFIX); /* change name from default prefix */
/* check file name to be sure not to overwrite - mod drg 12/9/2004 */
if (!THD_filename_ok (prefix))
{
fprintf (stderr, "*** Error - %s is not a valid prefix!\n", prefix);
exit (1);
}
nopt++;
continue;
}
/*-- datum --*/
if (strcmp (argv[nopt], "-datum") == 0)
{
if (++nopt >= argc)
{
fprintf (stderr, "*** Error - datum needs an argument!\n");
exit (1);
}
if (strcmp (argv[nopt], "short") == 0)
{
datum = MRI_short;
}
else if (strcmp (argv[nopt], "float") == 0)
{
datum = MRI_float;
}
else if (strcmp (argv[nopt], "byte") == 0)
{
datum = MRI_byte;
}
else
{
fprintf (stderr, "-datum of type '%s' is not supported!\n",
argv[nopt]);
exit (1);
}
nopt++;
continue;
}
if (strcmp (argv[nopt], "-automask") == 0)
{
automask = 1;
nopt++;
continue;
}
fprintf(stderr, "*** Error - unknown option %s\n", argv[nopt]);
exit(1);
}
/*----- read input datasets -----*/
if (nopt >= argc)
{
fprintf (stderr, "*** Error - No input dataset!?\n");
exit (1);
}
/* first input dataset - should be gradient vector file of ascii floats Gx,Gy,Gz */
/* read gradient vector 1D file */
grad1Dptr = mri_read_1D (argv[nopt]);
if (grad1Dptr == NULL)
{
fprintf (stderr, "*** Error reading gradient vector file\n");
exit (1);
}
if (grad1Dptr->ny != 3)
{
fprintf (stderr, "*** Error - Only 3 columns of gradient vectors allowed\n");
fprintf (stderr, "%d columns found\n", grad1Dptr->nx);
mri_free (grad1Dptr);
exit (1);
}
if (grad1Dptr->nx < 6)
{
fprintf (stderr, "*** Error - Must have at least 6 gradient vectors\n");
fprintf (stderr, "%d columns found\n", grad1Dptr->nx);
mri_free (grad1Dptr);
exit (1);
}
nbriks = grad1Dptr->nx + 1; /* number of gradients specified here from file */
nopt++;
/* open I0 dataset - idealized no gradient image */
I0_dset = THD_open_dataset (argv[nopt]);
CHECK_OPEN_ERROR(I0_dset,argv[nopt]) ;
DSET_mallocize (I0_dset);
DSET_load (I0_dset); /* load dataset */
data_im = DSET_BRICK (I0_dset, 0); /* set pointer to the 0th sub-brik of the dataset */
fac = DSET_BRICK_FACTOR(I0_dset, 0); /* get scale factor for each sub-brik*/
if(fac==0.0) fac=1.0;
if((data_im->kind != MRI_float)) {
fprintf (stderr, "*** Error - Can only open float datasets. Use 3dcalc to convert.\n");
mri_free (grad1Dptr);
mri_free (data_im);
exit (1);
}
I0_ptr = mri_data_pointer(data_im) ; /* pointer to I0 data */
nopt++;
/* Now read in all the MRI volumes for each gradient vector */
/* assumes first one is no gradient */
old_dset = THD_open_dataset (argv[nopt]);
CHECK_OPEN_ERROR(old_dset,argv[nopt]) ;
/* expect at least 6 values per voxel - 6 sub-briks as input dataset */
if (DSET_NVALS (old_dset) <6)
{
fprintf (stderr,
"*** Error - Dataset must have at least 6 sub-briks to describe the diffusion tensor\n");
mri_free (grad1Dptr);
mri_free (data_im);
exit (1);
}
InitGlobals (grad1Dptr->nx + 1); /* initialize all the matrices and vectors */
Computebmatrix (grad1Dptr, BMAT_NZ); /* compute bij=GiGj */
INFO_message("The maximum magnitude of the bmatrix appears to be: %.2f", MAX_BVAL);
if (automask)
{
DSET_mallocize (old_dset);
DSET_load (old_dset); /* get B0 (anatomical image) from dataset */
/*anat_im = THD_extract_float_brick( 0, old_dset ); */
anat_im = DSET_BRICK (old_dset, 0); /* set pointer to the 0th sub-brik of the dataset */
maskptr = mri_automask_image (anat_im); /* maskptr is a byte pointer for volume */
/* convert byte mask to same format type as dataset */
nvox = DSET_NVOX (old_dset);
sar = (short *) calloc (nvox, sizeof (short));
/* copy maskptr values to far ptr */
tempsptr = sar;
tempbptr = maskptr;
for (i = 0; i < nvox; i++)
{
*tempsptr++ = (short) *tempbptr++;
tempval = *(tempsptr - 1);
}
free (maskptr);
/*old_dset->dblk->malloc_type = DATABLOCK_MEM_MALLOC; *//* had to set this? */
EDIT_add_brick (old_dset, MRI_short, 0.0, sar); /* add sub-brik to end */
}
/* temporarily set artificial timing to 1 second interval */
EDIT_dset_items (old_dset,
ADN_ntt, DSET_NVALS (old_dset),
ADN_ttorg, 0.0,
ADN_ttdel, 1.0, ADN_tunits, UNITS_SEC_TYPE, NULL);
/*------------- ready to compute new dataset -----------*/
new_dset = MAKER_4D_to_typed_fbuc (old_dset, /* input dataset */
prefix, /* output prefix */
datum, /* output datum */
0, /* ignore count */
0, /* can't detrend in maker function KRH 12/02 */
nbriks, /* number of briks */
DTtoDWI_tsfunc, /* timeseries processor */
NULL, /* data for tsfunc */
NULL, /* mask */
0 /* Allow auto scaling of output */
);
FreeGlobals ();
mri_free (grad1Dptr);
if (automask)
{
mri_free (anat_im);
DSET_unload_one (old_dset, 0);
sar = NULL;
}
if (new_dset != NULL)
{
tross_Copy_History (old_dset, new_dset);
for(i=0;i<nbriks;i++) {
sprintf(tempstr,"grad%3.3d", i);
EDIT_dset_items (new_dset, ADN_brick_label_one + i, tempstr, ADN_none);
}
tross_Make_History ("3dDTtoDWI", argc, argv, new_dset);
DSET_write (new_dset);
fprintf(stderr,"--- Output dataset %s\n", DSET_BRIKNAME(new_dset));
}
else
{
fprintf (stderr, "*** Error - Unable to compute output dataset!\n");
exit (1);
}
exit (0);
}
int main( int argc , char *argv[] )
{
char *drive_afni[128] ;
int ndrive=0 , iarg=1 ;
char host[1024]="localhost", nsname[2048], *geomstr, *cpt, temp[32] ;
int dt=1000 , ctold,ctnew , ctzero ;
int verbose=0 , kk,nn , nvox,nval , do_accum=0 ;
THD_3dim_dataset *dset ;
NI_element *nel ;
MRI_IMAGE *fim ; float *far ;
char *targname="niml_feedme" ;
/*-- help the ignorant user --*/
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"Usage: niml_feedme [options] dataset\n"
"\n"
"* Sends volumes from the dataset to AFNI via the NIML socket interface.\n"
"* You must run AFNI with the command 'afni -niml' so that the program\n"
" will be listening for the socket connection.\n"
"* Inside AFNI, the transmitted dataset will be named 'niml_feedme'.\n"
"* For another way to send image data to AFNI, see progam rtfeedme.\n"
"* At present, there is no way to attach statistical parameters to\n"
" a transmitted volume.\n"
"* This program sends all volumes in float format, simply because\n"
" that's easy for me. But you can also send byte, short, and\n"
" complex valued volumes.\n"
"* This program is really just a demo; it has little practical use.\n"
"\n"
"OPTIONS:\n"
" -host sname = Send data, via TCP/IP, to AFNI running on the\n"
" computer system 'sname'. By default, uses the\n"
" current system (localhost), if you don't use this\n"
" option.\n"
"\n"
" -dt ms = Tries to maintain an inter-transmit interval of 'ms'\n"
" milliseconds. The default is 1000 msec per volume.\n"
"\n"
" -verb = Be (very) talkative about actions.\n"
"\n"
" -accum = Send sub-bricks so that they accumulate in AFNI.\n"
" The default is to create only a 1 volume dataset\n"
" inside AFNI, and each sub-brick just replaces\n"
" that one volume when it is received.\n"
"\n"
" -target nam = Change the dataset name transmitted to AFNI from\n"
" 'niml_feedme' to 'nam'.\n"
"\n"
" -drive cmd = Send 'cmd' as a DRIVE_AFNI command.\n"
" * If cmd contains blanks, it must be in 'quotes'.\n"
" * Multiple -drive options may be used.\n"
" * These commands will be sent to AFNI just after\n"
" the first volume is transmitted.\n"
" * See file README.driver for a list of commands.\n"
"\n"
"EXAMPLE: Send volumes from a 3D+time dataset to AFNI:\n"
"\n"
" niml_feedme -dt 1000 -verb -accum -target Elvis \\\n"
" -drive 'OPEN_WINDOW axialimage' \\\n"
" -drive 'OPEN_WINDOW axialgraph' \\\n"
" -drive 'SWITCH_UNDERLAY Elvis' \\\n"
" timeseries+orig\n"
"\n"
"Author: RW Cox -- July 2009\n"
) ;
PRINT_COMPILE_DATE ;
exit(0) ;
}
mainENTRY("niml_feedme") ;
/*-- scan arguments --*/
while( iarg < argc && argv[iarg][0] == '-' ){
if( strncmp(argv[iarg],"-target",5) == 0 ){
targname = strdup(argv[++iarg]) ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-drive") == 0 ){
drive_afni[ndrive++] = argv[++iarg] ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-host") == 0 ){
strcpy( host , argv[++iarg] ) ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-dt") == 0 ){
dt = (int)strtod(argv[++iarg],NULL) ; if( dt < 9 ) dt = 9 ;
iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-verbose",4) == 0 ){
verbose = 1 ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-accum",4) == 0 ){
do_accum = 1 ; iarg++ ; continue ;
}
ERROR_exit("Unrecognized option: %s",argv[iarg]) ;
}
if( iarg >= argc ) ERROR_exit("No dataset on command line?!") ;
/*-- read in the dataset --*/
dset = THD_open_dataset( argv[iarg] ) ;
if( dset == NULL ) ERROR_exit("Can't open dataset '%s'",argv[iarg]) ;
DSET_load(dset) ;
if( !DSET_LOADED(dset) ) ERROR_exit("Can't load dataset '%s'",argv[iarg]) ;
cpt = EDIT_get_geometry_string(dset) ;
geomstr = strdup(cpt) ; /* describes geometry of dataset grid */
if( verbose ) INFO_message("geometry string = '%s'",geomstr) ;
nvox = DSET_NVOX(dset); /* number of voxels in dataset */
nval = DSET_NVALS(dset); /* number of sub-bricks in dataset */
/*-- this stuff is one-time-only setup of the I/O to AFNI --*/
atexit(NF_exit) ; /* call this when program ends */
signal(SIGINT ,NF_sigfunc) ; /* setup signal handler */
signal(SIGBUS ,NF_sigfunc) ; /* for fatal errors */
signal(SIGSEGV,NF_sigfunc) ;
signal(SIGTERM,NF_sigfunc) ;
/* name of NIML stream (socket) to open */
sprintf( nsname , "tcp:%s:%d" , host , get_port_named("AFNI_DEFAULT_LISTEN_NIML"));
/* open the socket (i.e., dial the telephone call) */
fprintf(stderr,"opening NIML stream '%s' ",nsname) ;
NF_stream = NI_stream_open( nsname , "w" ) ;
/* loop until AFNI connects (answers the call),
printing a '.' every 1/2 second to keep the user happy */
while(1){
kk = NI_stream_writecheck( NF_stream , 500 ) ;
if( kk == 1 ){ fprintf(stderr," connected!\n") ; break ; }
if( kk < 0 ){ fprintf(stderr," ** connection fails **\n") ; exit(1) ; }
fprintf(stderr,".") ;
}
/*-- Create VOLUME_DATA NIML element to hold the brick data --*/
nel = NI_new_data_element( "VOLUME_DATA" , nvox ) ;
/* add attributes to the element to help AFNI construct the dataset */
/* define the grid of the dataset */
NI_set_attribute( nel , "geometry_string" , geomstr ) ;
/* define the name of the dataset */
NI_set_attribute( nel , "target_name" , targname ) ;
/* all sub-bricks in the input dataset will be sent to be
sub-brick #0 in the dataset inside AFNI
-- if you don't want this behavior, and want the dataset
inside AFNI to keep growing, then don't set this attribute! */
if( !do_accum ) NI_set_attribute( nel , "index" , "0" ) ;
/* +tlrc view? [default in AFNI is +orig view] */
if( dset->view_type == VIEW_TALAIRACH_TYPE )
NI_set_attribute( nel , "view" , "tlrc" ) ;
/**-- loop over sub-bricks and send them to AFNI --*/
ctzero = NI_clock_time() ; /* for later reference */
if( verbose ) INFO_message("Starting sub-brick loop") ;
for( kk=0 ; kk < nval ; kk++ ){
ctold = NI_clock_time() ; /* clock time at start of work (ms) */
/* get a float copy of the kk-th sub-brick */
fim = THD_extract_float_brick( kk , dset ) ;
DSET_unload_one(dset,kk) ; /* unload this sub-brick now */
if( fim == NULL ){ /* should never happen */
ERROR_message("Can't get sub-brick #%d?? -- skipping",kk) ;
NI_sleep(dt) ; continue ;
}
/* copy the float data into the NIML element for transmission */
far = MRI_FLOAT_PTR(fim) ;
if( kk == 0 ) /* first time: create data column in element */
NI_add_column( nel , NI_FLOAT , far ) ;
else /* later times: overwrite nel data column */
memcpy( nel->vec[0] , far , sizeof(float)*nvox ) ;
mri_free(fim) ; /* done with this now [data all copied to nel] */
/* set sub-brick index in AFNI if doing accumulation */
if( do_accum ){
sprintf(temp,"%d",kk) ; NI_set_attribute( nel , "index" , temp ) ;
}
/*** send the data element to AFNI ***/
nn = NI_write_element( NF_stream , nel , NI_BINARY_MODE ) ;
/* if something bad happened in the transmission, report it */
if( nn <= 0 ){
ERROR_message("Can't write sub-brick #%d to AFNI!",kk) ; break ;
}
/*** first time through ==>
do the '-drive' commands now by sending processing instructions ***/
if( kk == 0 && ndrive > 0 ){
int ii ; NI_procins *npi ;
if( verbose )
ININFO_message("Sending %d 'drive_afni' elements now",ndrive) ;
npi = NI_new_processing_instruction( "DRIVE_AFNI" ) ;
NI_sleep(1) ; /* give AFNI a msec to digest the data */
for( ii=0 ; ii < ndrive ; ii++ ){
NI_set_attribute( npi , "cmd" , drive_afni[ii] ) ;
(void)NI_write_element( NF_stream , npi , NI_TEXT_MODE ) ;
}
NI_free_element(npi) ; /* delete this struct from the world! */
}
ctnew = NI_clock_time() ; /* clock time now */
if( verbose ) ININFO_message("Sent %d bytes for sub-brick #%d in %d ms",
nn , kk , ctnew-ctold ) ;
NI_sleep( dt - (ctnew-ctold) ) ; /* sleep so that time delay is right */
} /* end of loop over sub-bricks */
/** summarize, do some cleanup, and exit stage left **/
if( verbose && kk > 0 ){
float dtav = (NI_clock_time()-ctzero) / (float)kk ;
INFO_message("Transmission finished: %.1f ms = average time per volume",dtav) ;
}
NI_free_element(nel) ; /* destroy the data element */
DSET_delete(dset) ; /* destroy the dataset */
exit(0) ;
}