MRI_IMAGE * FD_brick_to_series( int ixyz , FD_brick *br )
{
MRI_IMAGE *im ; /* output */
int nv , ival ;
char *iar ; /* brick in the input */
MRI_TYPE typ ;
int ix,jy,kz , ind ;
THD_ivec3 ind_fd , ind_ds ;
if( ixyz < 0 || ixyz >= br->n1 * br->n2 * br->n3 ) return NULL ;
/** otherwise, get ready for a real image **/
ix = ixyz % br->n1 ;
jy = ( ixyz % (br->n1 * br->n2) ) / br->n1 ;
kz = ixyz / (br->n1 * br->n2) ;
LOAD_IVEC3( ind_fd , ix,jy,kz ) ; ind_ds = THD_fdind_to_3dind( br , ind_fd ) ;
ix = ind_ds.ijk[0] ;
jy = ind_ds.ijk[1] ;
kz = ind_ds.ijk[2] ;
ind = (kz * br->dset->daxes->nyy + jy) * br->dset->daxes->nxx + ix ;
nv = br->dset->dblk->nvals ;
iar = DSET_ARRAY(br->dset,0) ;
if( iar == NULL ){ /* if data needs to be loaded from disk */
(void) THD_load_datablock( br->dset->dblk ) ;
iar = DSET_ARRAY(br->dset,0) ;
if( iar == NULL ) return NULL ;
}
/* 15 Sep 2004: allow for nonconstant datum */
if( !DSET_datum_constant(br->dset) ){ /* only for stupid users */
float *ar ;
im = mri_new( nv , 1 , MRI_float ) ; ar = MRI_FLOAT_PTR(im) ;
for( ival = 0 ; ival < nv ; ival++ )
ar[ival] = THD_get_voxel( br->dset , ind , ival ) ;
goto image_done ;
}
/* the older (more efficient) way */
typ = DSET_BRICK_TYPE(br->dset,0) ;
im = mri_new( nv , 1 , typ ) ;
#if 0
mri_zero_image(im) ; /* 18 Oct 2001 */
#endif
switch( typ ){
default: /* don't know what to do --> return nada */
mri_free( im ) ;
return NULL ;
case MRI_byte:{
byte *ar = MRI_BYTE_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (byte *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_short:{
short *ar = MRI_SHORT_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (short *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_float:{
float *ar = MRI_FLOAT_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (float *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_int:{
int *ar = MRI_INT_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (int *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_double:{
double *ar = MRI_DOUBLE_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (double *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_complex:{
complex *ar = MRI_COMPLEX_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (complex *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
/* 15 Apr 2002: RGB types */
case MRI_rgb:{
rgbyte *ar = (rgbyte *) MRI_RGB_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (rgbyte *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_rgba:{
rgba *ar = (rgba *) MRI_RGBA_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (rgba *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
}
if( THD_need_brick_factor(br->dset) ){
MRI_IMAGE *qim ;
qim = mri_mult_to_float( br->dset->dblk->brick_fac , im ) ;
mri_free(im) ; im = qim ;
}
/* at this point, the image is ready to ship out;
but first, maybe attach a time origin and spacing */
image_done:
if( br->dset->taxis != NULL ){ /* 21 Oct 1996 */
float zz , tt ;
zz = br->dset->daxes->zzorg + kz * br->dset->daxes->zzdel ;
tt = THD_timeof( 0 , zz , br->dset->taxis ) ;
im->xo = tt ; im->dx = br->dset->taxis->ttdel ; /* origin and delta */
if( br->dset->taxis->units_type == UNITS_MSEC_TYPE ){ /* convert to sec */
im->xo *= 0.001 ; im->dx *= 0.001 ;
}
} else {
im->xo = 0.0 ; im->dx = 1.0 ; /* 08 Nov 1996 */
}
return im ;
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *inset=NULL , *outset ;
THD_3dim_dataset **insar=NULL ; int nsar=0 ;
int iarg=1 , ii,kk , ids ;
MCW_cluster *nbhd=NULL ;
char *prefix="./localhistog" ;
int ntype=0 ; float na=0.0f,nb=0.0f,nc=0.0f ;
int verb=1 , do_prob=0 ;
int nx=0,ny=0,nz=0,nvox=0, rbot,rtop ;
char *labfile=NULL ; NI_element *labnel=NULL ;
int nlab=0 , *labval=NULL ; char **lablab=NULL ; char buf[THD_MAX_SBLABEL] ;
UINT32 *ohist , *mhist=NULL ; char *ohist_name=NULL ; int ohzadd=0 ;
int *rlist , numval ; float mincount=0.0f ; int mcc ;
int *exlist=NULL, numex=0 ;
int do_excNONLAB=0 ;
/*---- for the clueless who wish to become clued-in ----*/
if( argc == 1 ){ usage_3dLocalHistog(1); exit(0); } /* Bob's help shortcut */
/*---- official startup ---*/
#if defined(USING_MCW_MALLOC) && !defined(USE_OMP)
enable_mcw_malloc() ;
#endif
PRINT_VERSION("3dLocalHistog"); mainENTRY("3dLocalHistog main"); machdep();
AFNI_logger("3dLocalHistog",argc,argv);
if( getpid()%2 ) AUTHOR("Bilbo Baggins"); else AUTHOR("Thorin Oakenshield");
AFNI_SETUP_OMP(0) ; /* 24 Jun 2013 */
/*---- loop over options ----*/
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-help") == 0 || strcmp(argv[iarg],"-h") == 0){
usage_3dLocalHistog(strlen(argv[iarg])>3 ? 2:1);
exit(0);
}
if( strncmp(argv[iarg],"-qu",3) == 0 ){
verb = 0 ; iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-verb",5) == 0 ){
verb++ ; iarg++ ; continue ;
}
#ifdef ALLOW_PROB
if( strncmp(argv[iarg],"-prob",5) == 0 ){
do_prob = 1 ; iarg++ ; continue ;
}
#endif
if( strcmp(argv[iarg],"-exclude") == 0 ){
int ebot=-6666666,etop=-6666666 , ee ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-exclude'") ;
sscanf(argv[iarg],"%d..%d",&ebot,&etop) ;
if( ebot >= -TWO15 && ebot <= TWO15 ){
if( etop < -TWO15 || etop > TWO15 || etop < ebot ) etop = ebot ;
exlist = (int *)realloc(exlist,sizeof(int)*(etop-ebot+1+numex+1)) ;
for( ee=ebot ; ee <= etop ; ee++ ){ if( ee != 0 ) exlist[numex++] = ee ; }
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-excNONLAB") == 0 ){
do_excNONLAB = 1 ; 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 -prefix!") ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-hsave") == 0 ){
if( ++iarg >= argc ) ERROR_exit("Need argument after '-hsave'") ;
ohist_name = strdup(argv[iarg]) ;
if( !THD_filename_ok(ohist_name) ) ERROR_exit("Bad -hsave!") ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mincount") == 0 ){
char *cpt ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-mincount'") ;
mincount = (float)strtod(argv[iarg],&cpt) ;
#if 0
if( mincount > 0.0f && mincount < 50.0f && *cpt == '%' ) /* percentage */
mincount = -0.01f*mincount ;
#endif
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-nbhd") == 0 ){
char *cpt ;
if( ntype > 0 ) ERROR_exit("Can't have 2 '-nbhd' options") ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '-nbhd'") ;
cpt = argv[iarg] ;
if( strncasecmp(cpt,"SPHERE",6) == 0 ){
sscanf( cpt+7 , "%f" , &na ) ;
ntype = NTYPE_SPHERE ;
} else if( strncasecmp(cpt,"RECT",4) == 0 ){
sscanf( cpt+5 , "%f,%f,%f" , &na,&nb,&nc ) ;
if( na == 0.0f && nb == 0.0f && nc == 0.0f )
ERROR_exit("'RECT(0,0,0)' is not a legal neighborhood") ;
ntype = NTYPE_RECT ;
} else if( strncasecmp(cpt,"RHDD",4) == 0 ){
sscanf( cpt+5 , "%f" , &na ) ;
if( na == 0.0f ) ERROR_exit("Can't have a RHDD of radius 0") ;
ntype = NTYPE_RHDD ;
} else if( strncasecmp(cpt,"TOHD",4) == 0 ){
sscanf( cpt+5 , "%f" , &na ) ;
if( na == 0.0f ) ERROR_exit("Can't have a TOHD of radius 0") ;
ntype = NTYPE_TOHD ;
} else {
ERROR_exit("Unknown -nbhd shape: '%s'",cpt) ;
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-lab_file") == 0 || strcmp(argv[iarg],"-labfile") == 0 ){
char **labnum ; int nbad=0 ;
if( ++iarg >= argc ) ERROR_exit("Need argument after '%s'",argv[iarg-1]) ;
if( labfile != NULL ) ERROR_exit("Can't use '%s' twice!",argv[iarg-1]) ;
labfile = strdup(argv[iarg]) ;
labnel = THD_string_table_read(labfile,0) ;
if( labnel == NULL || labnel->vec_num < 2 )
ERROR_exit("Can't read label file '%s'",labfile) ;
nlab = labnel->vec_len ;
labnum = (char **)labnel->vec[0] ;
lablab = (char **)labnel->vec[1] ;
labval = (int *)calloc(sizeof(int),nlab) ;
for( ii=0 ; ii < nlab ; ii++ ){
if( labnum[ii] != NULL ){
labval[ii] = (int)strtod(labnum[ii],NULL) ;
if( labval[ii] < -TWO15 || labval[ii] > TWO15 ){ labval[ii] = 0; nbad++; }
}
}
if( nbad > 0 )
ERROR_message("%d label values are outside the range %d..%d :-(" ,
nbad , -TWO15 , TWO15 ) ;
iarg++ ; continue ;
}
ERROR_message("** 3dLocalHistog: Illegal option: '%s'",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1) ;
} /*--- end of loop over options ---*/
/*---- check for stupid user inputs ----*/
if( iarg >= argc ) ERROR_exit("No datasets on command line?") ;
if( ohist_name == NULL && strcmp(prefix,"NULL") == 0 )
ERROR_exit("-prefix NULL is only meaningful if you also use -hsave :-(") ;
/*------------ scan input datasets, built overall histogram ------------*/
nsar = argc - iarg ;
insar = (THD_3dim_dataset **)malloc(sizeof(THD_3dim_dataset *)*nsar) ;
if( verb ) fprintf(stderr,"Scanning %d datasets ",nsar) ;
ohist = (UINT32 *)calloc(sizeof(UINT32),TWO16) ;
for( ids=iarg ; ids < argc ; ids++ ){ /* dataset loop */
insar[ids-iarg] = inset = THD_open_dataset(argv[ids]) ;
CHECK_OPEN_ERROR(inset,argv[ids]) ;
if( ids == iarg ){
nx = DSET_NX(inset); ny = DSET_NY(inset); nz = DSET_NZ(inset); nvox = nx*ny*nz;
} else if( nx != DSET_NX(inset) ||
ny != DSET_NY(inset) || nz != DSET_NZ(inset) ){
ERROR_exit("Dataset %s grid doesn't match!",argv[ids]) ;
}
if( !THD_datum_constant(inset->dblk) )
ERROR_exit("Dataset %s doesn't have a fixed data type! :-(",argv[ids]) ;
if( THD_need_brick_factor(inset) )
ERROR_exit("Dataset %s has scale factors! :-(",argv[ids]) ;
if( DSET_BRICK_TYPE(inset,0) != MRI_byte &&
DSET_BRICK_TYPE(inset,0) != MRI_short &&
DSET_BRICK_TYPE(inset,0) != MRI_float )
ERROR_exit("Dataset %s is not byte- or short-valued! :-(",argv[ids]) ;
DSET_load(inset) ; CHECK_LOAD_ERROR(inset) ;
for( ii=0 ; ii < DSET_NVALS(inset) ; ii++ ){ /* add to overall histogram */
if( verb ) fprintf(stderr,".") ;
switch( DSET_BRICK_TYPE(inset,ii) ){
case MRI_short:{
short *sar = (short *)DSET_BRICK_ARRAY(inset,ii) ;
for( kk=0 ; kk < nvox ; kk++ ) ohist[ sar[kk]+TWO15 ]++ ;
}
break ;
case MRI_byte:{
byte *bar = (byte *)DSET_BRICK_ARRAY(inset,ii) ;
for( kk=0 ; kk < nvox ; kk++ ) ohist[ bar[kk]+TWO15 ]++ ;
}
break ;
case MRI_float:{
float *far = (float *)DSET_BRICK_ARRAY(inset,ii) ; short ss ;
for( kk=0 ; kk < nvox ; kk++ ){ ss = SHORTIZE(far[kk]); ohist[ss+TWO15]++; }
}
break ;
}
} /* end of sub-brick loop */
DSET_unload(inset) ; /* will re-load later, as needed */
} /* end of dataset loop */
if( verb ) fprintf(stderr,"\n") ;
/*-------------- process overall histogram for fun and profit -------------*/
/* if we didn't actually find 0, put it in the histogram now */
if( ohist[0+TWO15] == 0 ){ ohist[0+TWO15] = 1 ; ohzadd = 1 ; }
/* excNONLAB? */
if( nlab > 0 && do_excNONLAB ){
byte *klist = (byte *)calloc(sizeof(byte),TWO16) ; int nee ;
for( ii=0 ; ii < nlab ; ii++ ){ if( labval[ii] != 0 ) klist[labval[ii]+TWO15] = 1 ; }
for( nee=ii=0 ; ii < TWO16 ; ii++ ){ if( !klist[ii] ) nee++ ; }
exlist = (int *)realloc(exlist,sizeof(int)*(numex+nee+1)) ;
for( ii=0 ; ii < TWO16 ; ii++ ){ if( ii != TWO15 && !klist[ii] ) exlist[numex++] = ii-TWO15 ; }
free(klist) ;
}
/* make a copy of ohist and edit it for mincount, etc */
mhist = (UINT32 *)malloc(sizeof(UINT32)*TWO16) ;
memcpy(mhist,ohist,sizeof(UINT32)*TWO16) ;
mcc = (mincount < 0.0f) ? (int)(-mincount*nvox) : (int)mincount ;
if( mcc > 1 ){
for( ids=ii=0 ; ii < TWO16 ; ii++ ){
if( ii != TWO15 && mhist[ii] > 0 && mhist[ii] < mcc ){ mhist[ii] = 0; ids++; }
}
if( ids > 0 && verb )
INFO_message("Edited out %d values with overall histogram counts less than %d",ids,mcc) ;
}
if( numex > 0 ){
int ee ;
for( ids=0,ii=0 ; ii < numex ; ii++ ){
ee = exlist[ii] ;
if( mhist[ee+TWO15] > 0 ){ mhist[ee+TWO15] = 0; ids++; }
}
free(exlist) ;
if( ids > 0 && verb )
INFO_message("Edited out %d values from the exclude list",ids) ;
}
/* count number of values with nonzero (edited) counts */
numval = 0 ;
for( ii=0 ; ii < TWO16 ; ii++ ) if( mhist[ii] != 0 ) numval++ ;
if( numval == 0 ) ERROR_exit("Nothing found! WTF?") ; /* should not happen */
/* make list of all values with nonzero (edited) count */
rlist = (int *)malloc(sizeof(int)*numval) ;
if( verb > 1 ) fprintf(stderr,"++ Include list:") ;
for( ii=kk=0 ; ii < TWO16 ; ii++ ){
if( mhist[ii] != 0 ){
rlist[kk++] = ii-TWO15 ;
if( verb > 1 ) fprintf(stderr," %d[%u]",ii-TWO15,mhist[ii]) ;
}
}
if( verb > 1 ) fprintf(stderr,"\n") ;
rbot = rlist[0] ; rtop = rlist[numval-1] ; /* smallest and largest values found */
if( rbot == rtop ) ERROR_exit("Only one value (%d) found in all inputs!",rbot) ;
/* if 0 isn't first in rlist, then
put it in first place and move negative values up by one spot */
if( rbot < 0 ){
for( kk=0 ; kk < numval && rlist[kk] != 0 ; kk++ ) ; /*nada*/
if( kk < numval ){ /* should always be true */
for( ii=kk-1 ; ii >= 0 ; ii-- ) rlist[ii+1] = rlist[ii] ;
rlist[0] = 0 ;
}
}
if( verb )
INFO_message("Value range = %d..%d (%d distinct values)",rbot,rtop,numval );
/* save overall histogram? */
if( ohist_name != NULL ){
FILE *fp = fopen(ohist_name,"w") ; int nl=0 ;
if( fp == NULL ) ERROR_exit("Can't open -hsave '%s' for output!",ohist_name) ;
if( ohzadd ) ohist[0+TWO15] = 0 ;
for( ii=0 ; ii < TWO16 ; ii++ ){
if( ohist[ii] != 0 ){ fprintf(fp,"%6d %u\n",ii-TWO15,ohist[ii]); nl++; }
}
fclose(fp) ;
if( verb ) INFO_message("Wrote %d lines to -hsave file %s",nl,ohist_name) ;
}
free(ohist) ; free(mhist) ; mhist = ohist = NULL ; /* done with this */
if( strcmp(prefix,"NULL") == 0 ) exit(0) ; /* special case */
/*----------- build the neighborhood mask -----------*/
if( ntype <= 0 ){ /* default neighborhood */
ntype = NTYPE_SPHERE ; na = 0.0f ;
if( verb ) INFO_message("Using default neighborhood = self") ;
}
switch( ntype ){
default:
ERROR_exit("WTF? ntype=%d",ntype) ; /* should not happen */
case NTYPE_SPHERE:{
float dx , dy , dz ;
if( na < 0.0f ){ dx = dy = dz = 1.0f ; na = -na ; }
else { dx = fabsf(DSET_DX(insar[0])) ;
dy = fabsf(DSET_DY(insar[0])) ;
dz = fabsf(DSET_DZ(insar[0])) ; }
nbhd = MCW_spheremask( dx,dy,dz , na ) ;
}
break ;
case NTYPE_RECT:{
float dx , dy , dz ;
if( na < 0.0f ){ dx = 1.0f; na = -na; } else dx = fabsf(DSET_DX(insar[0]));
if( nb < 0.0f ){ dy = 1.0f; nb = -nb; } else dy = fabsf(DSET_DY(insar[0]));
if( nc < 0.0f ){ dz = 1.0f; nc = -nc; } else dz = fabsf(DSET_DZ(insar[0]));
nbhd = MCW_rectmask( dx,dy,dz , na,nb,nc ) ;
}
break ;
case NTYPE_RHDD:{
float dx , dy , dz ;
if( na < 0.0f ){ dx = dy = dz = 1.0f ; na = -na ; }
else { dx = fabsf(DSET_DX(insar[0])) ;
dy = fabsf(DSET_DY(insar[0])) ;
dz = fabsf(DSET_DZ(insar[0])) ; }
nbhd = MCW_rhddmask( dx,dy,dz , na ) ;
}
break ;
case NTYPE_TOHD:{
float dx , dy , dz ;
if( na < 0.0f ){ dx = dy = dz = 1.0f ; na = -na ; }
else { dx = fabsf(DSET_DX(insar[0])) ;
dy = fabsf(DSET_DY(insar[0])) ;
dz = fabsf(DSET_DZ(insar[0])) ; }
nbhd = MCW_tohdmask( dx,dy,dz , na ) ;
}
break ;
}
if( verb ) INFO_message("Neighborhood comprises %d voxels",nbhd->num_pt) ;
/*------- actually do some work for a change (is it lunchtime yet?) -------*/
if( verb ) fprintf(stderr,"Voxel-wise histograms ") ;
outset = THD_localhistog( nsar,insar , numval,rlist , nbhd , do_prob,verb ) ;
if( outset == NULL ) ERROR_exit("Function THD_localhistog() fails?!") ;
/*---- save resulting dataset ----*/
EDIT_dset_items( outset , ADN_prefix,prefix , ADN_none ) ;
tross_Copy_History( insar[0] , outset ) ;
tross_Make_History( "3dLocalHistog" , argc,argv , outset ) ;
/* but first attach labels to sub-bricks */
EDIT_BRICK_LABEL(outset,0,"0:Other") ;
for( kk=1 ; kk < numval ; kk++ ){
sprintf(buf,"%d:",rlist[kk]) ;
for( ii=0 ; ii < nlab ; ii++ ){
if( labval[ii] == rlist[kk] && lablab[ii] != NULL ){
ids = strlen(buf) ;
MCW_strncpy(buf+ids,lablab[ii],THD_MAX_SBLABEL-ids) ;
break ;
}
}
EDIT_BRICK_LABEL(outset,kk,buf) ;
}
DSET_write( outset ) ;
if( verb ) WROTE_DSET( outset ) ;
exit(0) ;
}
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[] )
{
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 THD_extract_array( int ind, THD_3dim_dataset *dset, int raw, void *uar )
{
MRI_TYPE typ ;
int nv , ival , nb , nb1 ;
char *iar ; /* brick in the input */
float *far=NULL ; /* non-raw output */
void *tar=NULL ;
/** ENTRY("THD_extract_array") ; **/
if( ind < 0 || uar == NULL ||
!ISVALID_DSET(dset) || ind >= DSET_NVOX(dset) ) return(-1) ;
nv = dset->dblk->nvals ;
iar = DSET_ARRAY(dset,0) ;
if( iar == NULL ){ /* load data from disk? */
DSET_load(dset) ;
iar = DSET_ARRAY(dset,0); if( iar == NULL ) return(-1) ;
}
typ = DSET_BRICK_TYPE(dset,0) ; /* raw data type */
/* will extract nb bytes of raw data into array tar */
nb1 = mri_datum_size(typ); nb = nb1 * (nv+1); nb1 = nb1 * nv;
tar = (void *)calloc(1,nb) ;
NULL_CHECK(tar) ;
if( !raw ) far = (float *)uar ; /* non-raw output */
switch( typ ){
default: /* don't know what to do --> return nada */
free(tar); return(-1);
break ;
case MRI_byte:{
byte *ar = (byte *)tar , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (byte *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
if( !raw ){
for( ival=0 ; ival < nv ; ival++ ) far[ival] = ar[ival] ;
}
}
break ;
case MRI_short:{
short *ar = (short *)tar , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (short *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
if( !raw ){
for( ival=0 ; ival < nv ; ival++ ) far[ival] = ar[ival] ;
}
}
break ;
case MRI_float:{
float *ar = (float *)tar , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (float *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
if( !raw ){
for( ival=0 ; ival < nv ; ival++ ) far[ival] = ar[ival] ;
}
}
break ;
#if 0
case MRI_int:{
int *ar = (int *)tar , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (int *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
if( !raw ){
for( ival=0 ; ival < nv ; ival++ ) far[ival] = ar[ival] ;
}
}
break ;
case MRI_double:{
double *ar = (double *)tar , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (double *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
if( !raw ){
for( ival=0 ; ival < nv ; ival++ ) far[ival] = ar[ival] ;
}
}
break ;
#endif
case MRI_complex:{
complex *ar = (complex *)tar , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (complex *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
if( !raw ){
for( ival=0 ; ival < nv ; ival++ ) far[ival] = CABS(ar[ival]) ;
}
}
break ;
}
if( raw ){ memcpy(uar,tar,nb1); free(tar); return(0); }
if( THD_need_brick_factor(dset) ){
for( ival=0 ; ival < nv ; ival++ )
if( DSET_BRICK_FACTOR(dset,ival) > 0.0 )
far[ival] *= DSET_BRICK_FACTOR(dset,ival) ;
}
free(tar); return(0);
}
MRI_IMARR * THD_extract_many_series( int ns, int *ind, THD_3dim_dataset *dset )
{
MRI_IMARR *imar ; /* output */
MRI_IMAGE *im ;
int nv , ival , kk ;
char *iar ; /* brick in the input */
float **far ; /* 27 Feb 2003: ptrs to output */
ENTRY("THD_extract_many_series") ;
if( ns <= 0 || ind == NULL | dset == NULL ) RETURN( NULL );
/* try to load dataset */
nv = dset->dblk->nvals ;
iar = DSET_ARRAY(dset,0) ;
if( iar == NULL ){ /* if data needs to be loaded from disk */
(void) THD_load_datablock( dset->dblk ) ;
iar = DSET_ARRAY(dset,0) ;
if( iar == NULL ){
static int nerr=0 ;
if( nerr < 2 ){ ERROR_message("Can't load dataset %s",DSET_HEADNAME(dset)); nerr++; }
RETURN( NULL );
}
}
/* create output */
far = (float **) malloc(sizeof(float *)*ns) ; /* 27 Feb 2003 */
NULL_CHECK(far) ;
INIT_IMARR(imar) ;
for( kk=0 ; kk < ns ; kk++ ){
im = mri_new( nv , 1 , MRI_float ) ; /* N.B.: now does 0 fill */
far[kk] = MRI_FLOAT_PTR(im) ; /* ptr to kk-th output series */
ADDTO_IMARR(imar,im) ;
}
/* fill the output */
switch( DSET_BRICK_TYPE(dset,0) ){
default: /* don't know what to do --> return nada */
DESTROY_IMARR(imar) ; free(far) ;
RETURN( NULL );
case MRI_byte:{
byte * bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (byte *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ){
for( kk=0 ; kk < ns ; kk++ ){
far[kk][ival] = (float)bar[ind[kk]] ;
}
}
}
}
break ;
case MRI_short:{
short * bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (short *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ){
for( kk=0 ; kk < ns ; kk++ ){
far[kk][ival] = (float)bar[ind[kk]] ;
}
}
}
}
break ;
case MRI_float:{
float * bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (float *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ){
for( kk=0 ; kk < ns ; kk++ ){
far[kk][ival] = bar[ind[kk]] ;
}
}
}
}
break ;
#if 0
case MRI_int:{
int * bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (int *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ){
for( kk=0 ; kk < ns ; kk++ ){
far[kk][ival] = bar[ind[kk]] ;
}
}
}
}
break ;
case MRI_double:{
double * bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (double *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ){
for( kk=0 ; kk < ns ; kk++ ){
far[kk][ival] = (float)bar[ind[kk]] ;
}
}
}
}
break ;
#endif
case MRI_complex:{
complex * bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (complex *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ){
for( kk=0 ; kk < ns ; kk++ ){
far[kk][ival] = bar[ind[kk]].r ;
}
}
}
}
break ;
}
/* scale outputs, if needed */
if( THD_need_brick_factor(dset) ){
MRI_IMAGE *qim ;
for( kk=0 ; kk < ns ; kk++ ){
im = IMARR_SUBIMAGE(imar,kk) ;
qim = mri_mult_to_float( dset->dblk->brick_fac , im ) ;
mri_free(im) ;
IMARR_SUBIMAGE(imar,kk) = qim ;
}
}
#if 0 /* 27 Feb 2003 */
/* convert to floats, if needed */
if( IMARR_SUBIMAGE(imar,0)->kind != MRI_float ){
MRI_IMAGE * qim ;
for( kk=0 ; kk < ns ; kk++ ){
im = IMARR_SUBIMAGE(imar,kk) ;
qim = mri_to_float( im ) ;
mri_free(im) ;
IMARR_SUBIMAGE(imar,kk) = qim ;
}
}
#endif
/* add time axis stuff to output images, if present */
if( dset->taxis != NULL ){
float zz , tt ;
int kz ;
for( kk=0 ; kk < ns ; kk++ ){
kz = ind[kk] / ( dset->daxes->nxx * dset->daxes->nyy ) ;
zz = dset->daxes->zzorg + kz * dset->daxes->zzdel ;
tt = THD_timeof( 0 , zz , dset->taxis ) ;
im = IMARR_SUBIMAGE(imar,kk) ;
im->xo = tt ; im->dx = dset->taxis->ttdel ; /* origin and delta */
if( dset->taxis->units_type == UNITS_MSEC_TYPE ){ /* convert to sec */
im->xo *= 0.001 ; im->dx *= 0.001 ;
}
}
} else {
for( kk=0 ; kk < ns ; kk++ ){
im = IMARR_SUBIMAGE(imar,kk) ;
im->xo = 0.0 ; im->dx = 1.0 ;
}
}
free(far) ; RETURN(imar);
}
int THD_extract_float_array( int ind, THD_3dim_dataset *dset, float *far )
{
MRI_TYPE typ ;
int nv , ival , nb , nb1 ;
char *iar ; /* brick in the input */
if( ind < 0 || far == NULL ||
!ISVALID_DSET(dset) || ind >= DSET_NVOX(dset) ) return(-1) ;
nv = dset->dblk->nvals ;
typ = DSET_BRICK_TYPE(dset,0) ; /* raw data type */
switch( typ ){
default: /* don't know what to do --> return nada */
return(-1);
break ;
case MRI_byte:{
byte *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (byte *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) far[ival] = bar[ind] ;
}
}
break ;
case MRI_short:{
short *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (short *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) far[ival] = bar[ind] ;
}
}
break ;
case MRI_float:{
float *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (float *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) far[ival] = bar[ind] ;
}
}
break ;
case MRI_complex:{
complex *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (complex *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) far[ival] = CABS(bar[ind]) ;
}
}
break ;
}
if( THD_need_brick_factor(dset) ){
for( ival=0 ; ival < nv ; ival++ )
if( DSET_BRICK_FACTOR(dset,ival) > 0.0 )
far[ival] *= DSET_BRICK_FACTOR(dset,ival) ;
}
return(0);
}
