/* Interleave the columns of data, given nfirst groups of nint columns
* (nfirst*nint = ny). Return a new MRI_IMAGE (so we don't have to do
* this in place.
*
* for ifirst = 0..nfirst
* for iint = 0..nint
* col[iint + ifirst*nint] <- col[ifirst + iint*nfirst]
*
* Each of the ny columns will keep the same nx values, except that
* they will be moved to a different column. 27 Jul 2009 [rickr]
*/
MRI_IMAGE * mri_interleave_columns( MRI_IMAGE * oldim, int nint )
{
MRI_IMAGE *newim=NULL;
char *dold, *dnew;
int ifirst, iint, nfirst, colsize;
ENTRY("mri_interleave_columns") ;
/* check that the inputs seem good */
if( !oldim ) RETURN(NULL);
if( nint <= 0 || nint > oldim->ny ) {
fprintf(stderr,"** interleave_cols: invalid nint=%d (ny=%d)\n",
nint, oldim->ny);
RETURN(NULL);
}
if( oldim->pixel_size <= 0 || oldim->pixel_size > 8 ) {
fprintf(stderr,"** interleave_cols: invalid pixel_size %d\n",
oldim->pixel_size);
RETURN(NULL);
}
nfirst = oldim->ny / nint;
if( nint * nfirst != oldim->ny ) {
fprintf(stderr,"** interleave_cols: nint * nfirst != ny (%d,%d,%d)\n",
nint, nfirst, oldim->ny);
RETURN(NULL);
}
if( oldim->nx * oldim->ny != oldim->nvox ) {
fprintf(stderr,"** interleave_cols: nx*ny != nvox (%d,%d,%lld)\n",
oldim->nx, oldim->ny, oldim->nvox);
RETURN(NULL);
}
/* all seems well, make a copy image and shuffle the data */
newim = mri_copy(oldim) ;
if( !newim ){
fprintf(stderr,"** mri_interleave_columns: failed to copy old image\n");
RETURN(NULL);
}
/* permute data, ignoring data type (except for pixel_size) */
dold = (char *)oldim->im;
dnew = (char *)newim->im;
colsize = oldim->nx * oldim->pixel_size;
for( ifirst=0; ifirst < nfirst; ifirst++ )
for( iint=0; iint < nint; iint++ ) {
memcpy(dnew + (iint + ifirst * nint )*colsize,
dold + (ifirst + iint * nfirst)*colsize,
colsize);
}
#ifdef USE_MRI_LABELS
fprintf(stderr,"** mri_interleave_columns: need to process labels\n");
#endif
RETURN(newim);
}
int main( int argc , char * argv[] )
{
int iarg=1 , dcode=0 , maxgap=2 , nftot=0 ;
char * prefix="zfillin" , * dstr=NULL;
THD_3dim_dataset * inset , * outset ;
MRI_IMAGE * brim ;
int verb=0 ;
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf("Usage: 3dZFillin [options] dataset\n"
"Extracts 1D rows in the given direction from a 3D dataset,\n"
"searches for zeros that are 'close' to nonzero values in the row,\n"
"and replaces the zeros with the closest nonzero neighbor.\n"
"\n"
"OPTIONS:\n"
" -maxstep N = set the maximum distance to a neighbor\n"
" [default=2].\n"
" -dir D = set the direction of fill to 'D', which can\n"
" be one of the following:\n"
" A-P, P-A, I-S, S-I, L-R, R-L, x, y, z\n"
" The first 6 are anatomical directions;\n"
" the last 3 are reference to the dataset\n"
" internal axes [no default value].\n"
" -prefix P = set the prefix to 'P' for the output dataset.\n"
"\n"
"N.B.: * If the input dataset has more than one sub-brick,\n"
" only the first one will be processed.\n"
" * At this time, 3dZFillin only works on byte-valued datasets\n"
"\n"
"This program's only purpose is to fill up the Talairach Daemon\n"
"bricks obtained from the UT San Antonio database.\n"
"\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
mainENTRY("3dZFillin main") ; machdep() ; AFNI_logger("3dZfillin",argc,argv) ;
PRINT_VERSION(3dZFillin") ;
/*-- scan args --*/
while( iarg < argc && argv[iarg][0] == '-' ){
if( strncmp(argv[iarg],"-verb",5) == 0 ){
verb++ ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-prefix") == 0 ){
prefix = argv[++iarg] ;
if( !THD_filename_ok(prefix) ){
fprintf(stderr,"*** Illegal string after -prefix!\n"); exit(1) ;
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-maxstep") == 0 ){
maxgap = strtol( argv[++iarg] , NULL , 10 ) ;
if( maxgap < 1 ){
fprintf(stderr,"*** Illegal value after -maxgap!\n"); exit(1);
}
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-dir") == 0 ){
dstr = argv[++iarg] ;
iarg++ ; continue ;
}
fprintf(stderr,"*** Illegal option: %s\n",argv[iarg]) ; exit(1) ;
}
if( dstr == NULL ){
fprintf(stderr,"*** No -dir option on command line!\n"); exit(1);
}
if( iarg >= argc ){
fprintf(stderr,"*** No input dataset on command line!\n"); exit(1);
}
inset = THD_open_dataset( argv[iarg] ) ;
if( inset == NULL ){
fprintf(stderr,"*** Can't open dataset %s\n",argv[iarg]); exit(1);
}
outset = EDIT_empty_copy( inset ) ;
EDIT_dset_items( outset , ADN_prefix , prefix , ADN_none ) ;
if( THD_deathcon() && THD_is_file( DSET_HEADNAME(outset) ) ){
fprintf(stderr,"** Output file %s exists -- cannot overwrite!\n",
DSET_HEADNAME(outset) ) ;
exit(1) ;
}
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dZFillin" , argc,argv , outset ) ;
if( DSET_NVALS(inset) > 1 ){
fprintf(stderr,"++ WARNING: input dataset has more than one sub-brick!\n");
EDIT_dset_items( outset ,
ADN_ntt , 0 ,
ADN_nvals , 1 ,
ADN_none ) ;
}
if( DSET_BRICK_TYPE(outset,0) != MRI_byte ){
fprintf(stderr,"*** This program only works on byte datasets!\n");
exit(1) ;
}
switch( *dstr ){
case 'x': dcode = 1 ; break ;
case 'y': dcode = 2 ; break ;
case 'z': dcode = 3 ; break ;
default:
if( *dstr == ORIENT_tinystr[outset->daxes->xxorient][0] ||
*dstr == ORIENT_tinystr[outset->daxes->xxorient][1] ) dcode = 1 ;
if( *dstr == ORIENT_tinystr[outset->daxes->yyorient][0] ||
*dstr == ORIENT_tinystr[outset->daxes->yyorient][1] ) dcode = 2 ;
if( *dstr == ORIENT_tinystr[outset->daxes->zzorient][0] ||
*dstr == ORIENT_tinystr[outset->daxes->zzorient][1] ) dcode = 3 ;
break ;
}
if( dcode == 0 ){
fprintf(stderr,"*** Illegal -dir direction!\n") ; exit(1) ;
}
if( verb )
fprintf(stderr,"++ Direction = axis %d in dataset\n",dcode) ;
DSET_load(inset) ; CHECK_LOAD_ERROR(inset) ;
brim = mri_copy( DSET_BRICK(inset,0) ) ;
DSET_unload(inset) ;
EDIT_substitute_brick( outset , 0 , brim->kind , mri_data_pointer(brim) ) ;
nftot = THD_dataset_zfillin( outset , 0 , dcode , maxgap ) ;
fprintf(stderr,"++ Number of voxels filled = %d\n",nftot) ;
if (DSET_write(outset) != False) {
fprintf(stderr,"++ output dataset: %s\n",DSET_BRIKNAME(outset)) ;
exit(0) ;
} else {
fprintf(stderr,
"** 3dZFillin: Failed to write output!\n" ) ;
exit(1) ;
}
}
int mri_warp3D_align_setup( MRI_warp3D_align_basis *bas )
{
MRI_IMAGE *cim , *fitim ;
int nx, ny, nz, nxy, nxyz , ii,jj,kk , nmap, *im ;
float *wf , *wtar , clip , clip2 ;
int *ima , pp , wtproc , npar , nfree ;
byte *msk ;
int ctstart ;
ENTRY("mri_warp3D_align_setup") ;
ctstart = NI_clock_time() ;
/*- check for good inputs -*/
if( bas == NULL || bas->imbase == NULL ) RETURN(1) ;
if( bas->nparam < 1 || bas->param == NULL ) RETURN(1) ;
if( bas->vwfor == NULL ||
bas->vwinv == NULL || bas->vwset == NULL ) RETURN(1) ;
/*- set defaults in bas, if values weren't set by user -*/
if( bas->scale_init <= 0.0f ) bas->scale_init = 1.0f ;
if( bas->delfac <= 0.0f ) bas->delfac = 1.0f ;
if( bas->regmode <= 0 ) bas->regmode = MRI_LINEAR ;
if( bas->max_iter <= 0 ) bas->max_iter = 9 ;
/* process the weight image? */
wtproc = (bas->imwt == NULL) ? 1 : bas->wtproc ;
npar = bas->nparam ;
nfree = npar ;
for( pp=0 ; pp < npar ; pp++ )
if( bas->param[pp].fixed ) nfree-- ;
if( nfree <= 0 ) RETURN(1) ;
bas->nfree = nfree ;
/*- clean out anything from last call -*/
mri_warp3D_align_cleanup( bas ) ;
/*-- need local copy of input base image --*/
cim = mri_to_float( bas->imbase ) ;
nx=cim->nx ; ny=cim->ny ; nz=cim->nz ; nxy = nx*ny ; nxyz=nxy*nz ;
/*-- make weight image up from the base image if it isn't supplied --*/
if( bas->verb ) fprintf(stderr,"++ mri_warp3D_align_setup ENTRY\n") ;
if( bas->imwt == NULL ||
bas->imwt->nx != nx ||
bas->imwt->ny != ny ||
bas->imwt->nz != nz ) bas->imww = mri_copy( cim ) ;
else bas->imww = mri_to_float( bas->imwt ) ;
if( bas->twoblur > 0.0f ){
float bmax = cbrt((double)nxyz) * 0.03 ;
if( bmax < bas->twoblur ){
if( bas->verb )
fprintf(stderr,"+ shrink bas->twoblur from %.3f to %.3f\n",
bas->twoblur , bmax ) ;
bas->twoblur = bmax ;
}
}
if( bas->verb ) fprintf(stderr,"+ processing weight:") ;
/* make sure weight is non-negative */
wf = MRI_FLOAT_PTR(bas->imww) ;
for( ii=0 ; ii < nxyz ; ii++ ) wf[ii] = fabs(wf[ii]) ;
/* trim off edges of weight */
if( wtproc ){
int ff ;
int xfade=bas->xedge , yfade=bas->yedge , zfade=bas->zedge ;
if( xfade < 0 || yfade < 0 || zfade < 0 )
mri_warp3D_align_edging_default(nx,ny,nz,&xfade,&yfade,&zfade) ;
if( bas->twoblur > 0.0f ){
xfade += (int)rint(1.5*bas->twoblur) ;
yfade += (int)rint(1.5*bas->twoblur) ;
zfade += (int)rint(1.5*bas->twoblur) ;
}
if( 3*zfade >= nz ) zfade = (nz-1)/3 ;
if( 3*xfade >= nx ) xfade = (nx-1)/3 ;
if( 3*yfade >= ny ) yfade = (ny-1)/3 ;
if( bas->verb ) fprintf(stderr," [edge(%d,%d,%d)]",xfade,yfade,zfade) ;
for( jj=0 ; jj < ny ; jj++ )
for( ii=0 ; ii < nx ; ii++ )
for( ff=0 ; ff < zfade ; ff++ )
WW(ii,jj,ff) = WW(ii,jj,nz-1-ff) = 0.0f ;
for( kk=0 ; kk < nz ; kk++ )
for( jj=0 ; jj < ny ; jj++ )
for( ff=0 ; ff < xfade ; ff++ )
WW(ff,jj,kk) = WW(nx-1-ff,jj,kk) = 0.0f ;
for( kk=0 ; kk < nz ; kk++ )
for( ii=0 ; ii < nx ; ii++ )
for( ff=0 ; ff < yfade ; ff++ )
WW(ii,ff,kk) = WW(ii,ny-1-ff,kk) = 0.0f ;
}
/* spatially blur weight a little */
if( wtproc ){
float blur ;
blur = 1.0f + MAX(1.5f,bas->twoblur) ;
if( bas->verb ) fprintf(stderr," [blur(%.1f)]",blur) ;
EDIT_blur_volume_3d( nx,ny,nz , 1.0f,1.0f,1.0f ,
MRI_float , wf , blur,blur,blur ) ;
}
/* get rid of low-weight voxels */
clip = 0.035 * mri_max(bas->imww) ;
clip2 = 0.5*THD_cliplevel(bas->imww,0.4) ;
if( clip2 > clip ) clip = clip2 ;
if( bas->verb ) fprintf(stderr," [clip(%.1f)]",clip) ;
for( ii=0 ; ii < nxyz ; ii++ ) if( wf[ii] < clip ) wf[ii] = 0.0f ;
/* keep only the largest cluster of nonzero voxels */
{ byte *mmm = (byte *)malloc( sizeof(byte)*nxyz ) ;
for( ii=0 ; ii < nxyz ; ii++ ) mmm[ii] = (wf[ii] > 0.0f) ;
THD_mask_clust( nx,ny,nz, mmm ) ;
THD_mask_erode( nx,ny,nz, mmm, 1 ) ; /* cf. thd_automask.c */
THD_mask_clust( nx,ny,nz, mmm ) ;
for( ii=0 ; ii < nxyz ; ii++ ) if( !mmm[ii] ) wf[ii] = 0.0f ;
free((void *)mmm) ;
}
if( bas->verb ) fprintf(stderr,"\n") ;
/*-- make integer index map of weight > 0 voxels --*/
nmap = 0 ;
for( ii=0 ; ii < nxyz ; ii++ ) if( wf[ii] > 0.0f ) nmap++ ;
if( bas->verb )
fprintf(stderr,"+ using %d [%.3f%%] voxels\n",nmap,(100.0*nmap)/nxyz);
if( nmap < 7*nfree+13 ){
fprintf(stderr,"** mri_warp3D_align error: weight image too zero-ish!\n") ;
mri_warp3D_align_cleanup( bas ) ; mri_free(cim) ;
RETURN(1) ;
}
bas->imap = mri_new( nmap , 1 , MRI_int ) ;
ima = MRI_INT_PTR(bas->imap) ;
bas->imsk = mri_new_conforming( bas->imww , MRI_byte ) ;
msk = MRI_BYTE_PTR(bas->imsk) ;
for( ii=jj=0 ; ii < nxyz ; ii++ ){
if( wf[ii] > 0.0f ){ ima[jj++] = ii; msk[ii] = 1; }
}
/* make copy of sqrt(weight), but only at mapped indexes */
wtar = (float *)malloc(sizeof(float)*nmap) ;
for( ii=0 ; ii < nmap ; ii++ ) wtar[ii] = sqrt(wf[ima[ii]]) ;
/*-- for parameters that don't come with a step size, find one --*/
clip = bas->tolfac ; if( clip <= 0.0f ) clip = 0.03f ;
for( ii=0 ; ii < npar ; ii++ ){
if( bas->param[ii].fixed ) continue ; /* don't need this */
if( bas->param[ii].delta <= 0.0f )
mri_warp3D_get_delta( bas , ii ) ; /* find step size */
if( bas->param[ii].toler <= 0.0f ){ /* and set default tolerance */
bas->param[ii].toler = clip * bas->param[ii].delta ;
if( bas->verb )
fprintf(stderr,"+ set toler param#%d [%s] = %f\n",
ii+1,bas->param[ii].name,bas->param[ii].toler) ;
}
}
/* don't need the computed weight image anymore */
mri_free(bas->imww) ; bas->imww = NULL ; wf = NULL ;
/*-- create image containing basis columns, then pseudo-invert it --*/
if( bas->verb ) fprintf(stderr,"+ Compute Derivatives of Base\n") ;
fitim = mri_warp3D_align_fitim( bas , cim , bas->regmode , bas->delfac ) ;
if( bas->verb ) fprintf(stderr,"+ calculate pseudo-inverse\n") ;
bas->imps = mri_psinv( fitim , wtar ) ;
mri_free(fitim) ;
if( bas->imps == NULL ){ /* bad bad bad */
fprintf(stderr,"** mri_warp3D_align error: can't invert Base matrix!\n") ;
free((void *)wtar) ; mri_warp3D_align_cleanup( bas ) ; mri_free(cim) ;
RETURN(1) ;
}
/*--- twoblur? ---*/
if( bas->twoblur > 0.0f ){
float *car=MRI_FLOAT_PTR(cim) ;
float blur = bas->twoblur ;
float bfac = blur ;
if( bfac < 1.1234f ) bfac = 1.1234f ;
else if( bfac > 1.3456f ) bfac = 1.3456f ;
if( bas->verb ) fprintf(stderr,"+ Compute Derivatives of Blurred Base\n") ;
EDIT_blur_volume_3d( nx,ny,nz , 1.0f,1.0f,1.0f ,
MRI_float , car, blur,blur,blur ) ;
fitim = mri_warp3D_align_fitim( bas , cim , MRI_LINEAR , bfac*bas->delfac ) ;
if( bas->verb ) fprintf(stderr,"+ calculate pseudo-inverse\n") ;
bas->imps_blur = mri_psinv( fitim , wtar ) ;
mri_free(fitim) ;
if( bas->imps_blur == NULL ){ /* bad */
fprintf(stderr,"** mri_warp3D_align error: can't invert Blur matrix!\n") ;
}
}
/*--- done ---*/
mri_free(cim) ; free((void *)wtar) ;
if( bas->verb ){
double st = (NI_clock_time()-ctstart) * 0.001 ;
fprintf(stderr,"++ mri_warp3D_align_setup EXIT: %.2f seconds elapsed\n",st);
}
RETURN(0);
}
MRI_IMAGE * mri_flip3D( int outx, int outy, int outz, MRI_IMAGE *inim )
{
MRI_IMAGE *outim ;
int ii,jj,kk , dsiz , nxin,nyin,nzin , nxout,nyout,nzout ;
int nxyin , nxyout , ijk_out , ijk_in ;
int ax,bx,cx,dx , ay,by,cy,dy , az,bz,cz,dz , aa,bb,cc,dd ;
char *inar , *outar ;
float delx,dely,delz ;
ENTRY("mri_flip3D") ;
/* check inputs for correctness */
if( inim == NULL || outx == 0 || outy == 0 || outz == 0 ) RETURN( NULL );
ii = abs(outx) ; jj = abs(outy) ; kk = abs(outz) ;
if( ii > 3 || jj > 3 || kk > 3 ) RETURN( NULL );
if( ii == jj || ii == kk || jj == kk ) RETURN( NULL );
if( ii+jj+kk != 6 ) RETURN( NULL );
if( outx==1 && outy==2 && outz==3 ) RETURN( mri_copy(inim) ); /* easy case */
nxin = inim->nx ;
nyin = inim->ny ; nxyin = nxin*nyin ;
nzin = inim->nz ;
/* setup so that i_out = ax + bx*i_in + cx*j_in + dx*k_in,
for i_in=0..nxin-1, j_in=0..nyin-1, k_in=0..nzin-1,
and then similarly for y and z axes */
switch( outx ){
case 1: ax=0 ; bx= 1; cx= 0; dx= 0; nxout=nxin; delx=inim->dx; break;
case -1: ax=nxin-1; bx=-1; cx= 0; dx= 0; nxout=nxin; delx=inim->dx; break;
case 2: ax=0 ; bx= 0; cx= 1; dx= 0; nxout=nyin; delx=inim->dy; break;
case -2: ax=nyin-1; bx= 0; cx=-1; dx= 0; nxout=nyin; delx=inim->dy; break;
case 3: ax=0 ; bx= 0; cx= 0; dx= 1; nxout=nzin; delx=inim->dz; break;
case -3: ax=nzin-1; bx= 0; cx= 0; dx=-1; nxout=nzin; delx=inim->dz; break;
default: RETURN( NULL );
}
switch( outy ){
case 1: ay=0 ; by= 1; cy= 0; dy= 0; nyout=nxin; dely=inim->dx; break;
case -1: ay=nxin-1; by=-1; cy= 0; dy= 0; nyout=nxin; dely=inim->dx; break;
case 2: ay=0 ; by= 0; cy= 1; dy= 0; nyout=nyin; dely=inim->dy; break;
case -2: ay=nyin-1; by= 0; cy=-1; dy= 0; nyout=nyin; dely=inim->dy; break;
case 3: ay=0 ; by= 0; cy= 0; dy= 1; nyout=nzin; dely=inim->dz; break;
case -3: ay=nzin-1; by= 0; cy= 0; dy=-1; nyout=nzin; dely=inim->dz; break;
default: RETURN( NULL );
}
switch( outz ){
case 1: az=0 ; bz= 1; cz= 0; dz= 0; nzout=nxin; delz=inim->dx; break;
case -1: az=nxin-1; bz=-1; cz= 0; dz= 0; nzout=nxin; delz=inim->dx; break;
case 2: az=0 ; bz= 0; cz= 1; dz= 0; nzout=nyin; delz=inim->dy; break;
case -2: az=nyin-1; bz= 0; cz=-1; dz= 0; nzout=nyin; delz=inim->dy; break;
case 3: az=0 ; bz= 0; cz= 0; dz= 1; nzout=nzin; delz=inim->dz; break;
case -3: az=nzin-1; bz= 0; cz= 0; dz=-1; nzout=nzin; delz=inim->dz; break;
default: RETURN( NULL );
}
nxyout = nxout*nyout ;
/* 3D index ijk_out = i_out + nxout*j_out + nxyout*k_out
= (ax + bx*i_in + cx*j_in + dx*k_in)
+(ay + by*i_in + cy*j_in + dy*k_in)*nxout
+(az + bz*i_in + cz*j_in + dz*k_in)*nxyout
= (ax+ay*nxout+az*nxyout)
+(bx+by*nxout+bz*nxyout)*i_in
+(cx+cy*nxout+cz*nxyout)*j_in
+(dx+dy*nxout+dz*nxyout)*k_in
= aa + bb*i_in + cc*j_in + dd*k_in */
inar = mri_data_pointer( inim ) ;
outim = mri_new_vol( nxout,nyout,nzout , inim->kind ) ;
outim->dx = delx ; outim->dy = dely ; outim->dz = delz ;
outar = mri_data_pointer( outim ) ;
if( inar == NULL ){ /* empty input ==> empty output */
free(outar) ; mri_fix_data_pointer(NULL,outim ); RETURN(outim);
}
dsiz = outim->pixel_size ; /* size of each voxel in bytes */
aa = (ax+ay*nxout+az*nxyout)*dsiz ; /* same as aa, etc. in above */
bb = (bx+by*nxout+bz*nxyout)*dsiz ; /* comment, but scaled to be */
cc = (cx+cy*nxout+cz*nxyout)*dsiz ; /* address offset in bytes */
dd = (dx+dy*nxout+dz*nxyout)*dsiz ;
for( ijk_in=kk=0 ; kk < nzin ; kk++ ){
for( jj=0 ; jj < nyin ; jj++ ){
for( ii=0 ; ii < nxin ; ii++,ijk_in+=dsiz ){
ijk_out = aa + bb*ii + cc*jj + dd*kk ;
memcpy( outar+ijk_out , inar+ijk_in , dsiz ) ;
}
}
}
RETURN(outim) ;
}
MRI_IMAGE * mri_clusterize( float rmm , float vmul , MRI_IMAGE *bim ,
float thb , float tht , MRI_IMAGE *tim ,
int posonly , byte *mask )
{
float dx,dy,dz , dbot , vmin ;
int nx,ny,nz , ptmin,iclu , nkeep,nkill,ncgood , nbot,ntop , ii ;
MRI_IMAGE *cim ; void *car ;
MCW_cluster *cl , *dl ; MCW_cluster_array *clar ;
int nnlev = 0 ;
static char *cclev[3] = { "[faces touch]" ,
"[edges touch]" , "[corners touch]" } ;
ENTRY("mri_clusterize") ;
if( report != NULL ){ free((void *)report); report = NULL; }
if( clarout != NULL ){ DESTROY_CLARR(clarout); }
if( bim == NULL || mri_data_pointer(bim) == NULL ) RETURN(NULL) ;
nx = bim->nx; ny = bim->ny; nz = bim->nz;
dx = bim->dx; dy = bim->dy; dz = bim->dz;
if( dx <= 0.0f ) dx = 1.0f ;
if( dy <= 0.0f ) dy = 1.0f ;
if( dz <= 0.0f ) dz = 1.0f ;
dbot = MIN(dx,dy) ; dbot = MIN(dbot,dz) ;
if( rmm < dbot ){
int irr = (int)rintf(rmm) ;
dx = dy = dz = 1.0f;
switch( irr ){
default: rmm = 1.01f ; nnlev = 1 ;break ; /* NN1 */
case -2: rmm = 1.44f ; nnlev = 2 ;break ; /* NN2 */
case -3: rmm = 1.75f ; nnlev = 3 ;break ; /* NN3 */
}
}
vmin = 2.0f*dx*dy*dz ; if( vmul < vmin ) vmul = vmin ;
/* create copy of input image (this will be edited below) */
cim = mri_copy(bim) ; car = mri_data_pointer(cim) ;
if( car == NULL ){ mri_free(cim) ; RETURN(NULL) ; }
/* threshold it, if so ordered (note that tim==bim is legal) */
if( tht > thb && tim != NULL )
mri_threshold( thb , tht , tim , cim ) ;
if( posonly )
mri_threshold( -1.e9 , 0.0 , cim , cim ) ;
mri_maskify( cim , mask ) ; /* Jul 2010: mask it? */
/* smallest cluster to keep */
ptmin = (int)( vmul/(dx*dy*dz) + 0.99f ) ;
/* find all clusters */
clar = MCW_find_clusters( nx,ny,nz , dx,dy,dz , cim->kind,car , rmm ) ;
/* put all big clusters back into the image */
if( clar != NULL ){
ncgood = nkeep = nkill = 0 ; nbot = 999999 ; ntop = 0 ;
for( iclu=0 ; iclu < clar->num_clu ; iclu++ ){
cl = clar->clar[iclu] ;
if( cl->num_pt >= ptmin ){ /* put back into array, get some stats */
MCW_cluster_to_vol( nx,ny,nz , cim->kind,car , cl ) ;
nkeep += cl->num_pt ; ncgood++ ;
nbot = MIN(nbot,cl->num_pt); ntop = MAX(ntop,cl->num_pt);
if( clarout == NULL ) INIT_CLARR(clarout) ;
COPY_CLUSTER(dl,cl) ; ADDTO_CLARR(clarout,dl) ;
} else {
nkill += cl->num_pt ;
}
}
DESTROY_CLARR(clar) ;
report = THD_zzprintf( report ,
" Voxels survived clustering =%6d\n"
" Voxels edited out =%6d\n" ,
nkeep , nkill ) ;
#if 0
if( ntop >= nbot )
report = THD_zzprintf( report ,
" Min cluster size (voxels) =%6d\n"
" Max cluster size =%6d\n"
" Number of clusters kept =%6d\n" ,
nbot , ntop , ncgood ) ;
#endif
if( nnlev > 0 )
report = THD_zzprintf( report ,
" NN clustering level =%6d %s\n" ,
nnlev , cclev[nnlev-1] ) ;
}
RETURN(cim) ;
}
MRI_IMAGE * mri_bi_clusterize( float rmm , float vmul , MRI_IMAGE *bim ,
float thb , float tht , MRI_IMAGE *tim ,
byte *mask )
{
float dx,dy,dz , dbot , vmin ;
int nx,ny,nz , ptmin,iclu , nkeep=0,nkill=0,ncgood=0 ;
int nbot=9999999,ntop=0 , ii , pclust=0,nclust=0 ;
MRI_IMAGE *cim , *dim ; void *car , *dar ;
MCW_cluster *cl , *dl ; MCW_cluster_array *clar ;
int nnlev = 0 ;
static char *cclev[3] = { "[faces touch]" ,
"[edges touch]" , "[corners touch]" } ;
ENTRY("mri_bi_clusterize") ;
if( report != NULL ){ free((void *)report); report = NULL; }
if( clarout != NULL ){ DESTROY_CLARR(clarout); }
if( bim == NULL || mri_data_pointer(bim) == NULL ) RETURN(NULL) ;
if( thb > 0.0f || tht < 0.0f || tim == NULL ) RETURN(NULL) ;
nx = bim->nx; ny = bim->ny; nz = bim->nz;
dx = bim->dx; dy = bim->dy; dz = bim->dz;
if( dx <= 0.0f ) dx = 1.0f ;
if( dy <= 0.0f ) dy = 1.0f ;
if( dz <= 0.0f ) dz = 1.0f ;
dbot = MIN(dx,dy) ; dbot = MIN(dbot,dz) ;
if( rmm < dbot ){
int irr = (int)rintf(rmm) ;
dx = dy = dz = 1.0f;
switch( irr ){
default: rmm = 1.01f ; nnlev = 1 ;break ; /* NN1 */
case -2: rmm = 1.44f ; nnlev = 2 ;break ; /* NN2 */
case -3: rmm = 1.75f ; nnlev = 3 ;break ; /* NN3 */
}
}
vmin = 2.0f*dx*dy*dz ; if( vmul < vmin ) vmul = vmin ;
ptmin = (int)( vmul/(dx*dy*dz) + 0.99f ) ; /* smallest cluster to keep */
/* 0-filled copy of input == will be output image */
dim = mri_new_conforming(bim,bim->kind) ; dar = mri_data_pointer(dim) ;
/* create copy of input image to be edited below */
cim = mri_copy(bim) ; car = mri_data_pointer(cim) ;
mri_maskify( cim , mask ) ; /* mask it? */
/* threshold it on the positive side */
mri_threshold( -1.e22 , tht , tim , cim ) ;
/* find all positive clusters */
clar = MCW_find_clusters( nx,ny,nz , dx,dy,dz , cim->kind,car , rmm ) ;
mri_free(cim) ;
/* put all big clusters into the output image */
if( clar != NULL ){
for( iclu=0 ; iclu < clar->num_clu ; iclu++ ){
cl = clar->clar[iclu] ;
if( cl->num_pt >= ptmin ){ /* put back into array, get some stats */
MCW_cluster_to_vol( nx,ny,nz , dim->kind,dar , cl ) ;
nkeep += cl->num_pt ; ncgood++ ; pclust++ ;
nbot = MIN(nbot,cl->num_pt); ntop = MAX(ntop,cl->num_pt);
if( clarout == NULL ) INIT_CLARR(clarout) ;
COPY_CLUSTER(dl,cl) ; ADDTO_CLARR(clarout,dl) ;
} else {
nkill += cl->num_pt ;
}
}
DESTROY_CLARR(clar) ;
}
/* repeat for negative clusters */
cim = mri_copy(bim) ; car = mri_data_pointer(cim) ;
mri_maskify( cim , mask ) ;
mri_threshold( thb , 1.e+22 , tim , cim ) ;
clar = MCW_find_clusters( nx,ny,nz , dx,dy,dz , cim->kind,car , rmm ) ;
mri_free(cim) ;
if( clar != NULL ){
for( iclu=0 ; iclu < clar->num_clu ; iclu++ ){
cl = clar->clar[iclu] ;
if( cl->num_pt >= ptmin ){ /* put back into array, get some stats */
MCW_cluster_to_vol( nx,ny,nz , dim->kind,dar , cl ) ;
nkeep += cl->num_pt ; ncgood++ ; nclust++ ;
nbot = MIN(nbot,cl->num_pt); ntop = MAX(ntop,cl->num_pt);
if( clarout == NULL ) INIT_CLARR(clarout) ;
COPY_CLUSTER(dl,cl) ; ADDTO_CLARR(clarout,dl) ;
} else {
nkill += cl->num_pt ;
}
}
DESTROY_CLARR(clar) ;
}
if( nkeep > 0 ){
report = THD_zzprintf( report ,
" Voxels survived clustering =%6d\n"
" Voxels edited out =%6d\n"
" # Positive clusters =%6d\n"
" # Negative clusters =%6d\n" ,
nkeep , nkill , pclust,nclust ) ;
if( nnlev > 0 )
report = THD_zzprintf( report ,
" NN clustering level =%6d %s\n" ,
nnlev , cclev[nnlev-1] ) ;
}
RETURN(dim) ;
}
int main(int argc, char *argv[])
{
int CHECK = 0;
int iarg;
char *Fname_input = NULL;
char *Fname_output = NULL;
char *Fname_outputBV = NULL;
char *Fname_bval = NULL;
int opt;
FILE *fin=NULL, *fout=NULL, *finbv=NULL, *foutBV=NULL;
int i,j,k;
int BZER=0,idx=0,idx2=0;
MRI_IMAGE *flim=NULL;
MRI_IMAGE *preREADIN=NULL;
MRI_IMAGE *preREADBVAL=NULL;
float *READIN=NULL;
float *READBVAL=NULL;
float OUT_MATR[MAXGRADS][7]; // b- or g-matrix
float OUT_GRAD[MAXGRADS][4]; // b- or g-matrix
int INV[3] = {1,1,1}; // if needing to switch
int FLAG[MAXGRADS];
float temp;
int YES_B = 0;
int EXTRA_ZEROS=0;
int HAVE_BVAL = 0;
int BVAL_OUT = 0;
int BVAL_OUT_SEP = 0;
float BMAX_REF = 1; // i.e., essentially zero
int IN_FORM = 0; // 0 for row, 1 for col
int OUT_FORM = 1; // 1 for col, 2 for bmatr
int HAVE_BMAX_REF=0 ; // referring to user input value
int count_in=0, count_out=0;
THD_3dim_dataset *dwset=NULL, *dwout=NULL;
int Nbrik = 0;
char *prefix=NULL ;
float **temp_arr=NULL, **temp_grad=NULL;
int Ndwi = 0, dwi=0, Ndwout = 0, Ndwi_final = 0, Ndwout_final = 0;
int Nvox = 0;
int DWI_COMP_FAC = 0;
int ct_dwi = 0;
float MaxDP = 0;
mainENTRY("1dDW_Grad_o_Mat"); machdep();
if (argc == 1) { usage_1dDW_Grad_o_Mat(1); exit(0); }
iarg = 1;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-help") == 0 ||
strcmp(argv[iarg],"-h") == 0 ) {
usage_1dDW_Grad_o_Mat(strlen(argv[iarg])>3 ? 2:1);
exit(0);
}
if( strcmp(argv[iarg],"-flip_x") == 0) {
INV[0] = -1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-flip_y") == 0) {
INV[1] = -1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-flip_z") == 0) {
INV[2] = -1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-keep_b0s") == 0) {
YES_B = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-put_zeros_top") == 0) {
EXTRA_ZEROS = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_grad_rows") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_grad_rows'\n") ;
Fname_input = argv[iarg];
count_in++;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_grad_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_grad_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_gmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matT_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 2;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_gmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matA_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 3;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_bmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matT_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 4;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_bmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_matA_cols'\n") ;
Fname_input = argv[iarg];
count_in++;
IN_FORM = 5;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_grad_rows") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_grad_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 0;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_grad_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_grad_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_gmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_gmatT_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 2;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_gmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_gmatA_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 3;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_bmatT_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_bmatT_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 4;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_bmatA_cols") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_bmatA_cols'\n") ;
Fname_output = argv[iarg];
count_out++;
OUT_FORM = 5;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_bvals") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '-in_bvals'\n") ;
Fname_bval = argv[iarg];
HAVE_BVAL = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-bmax_ref") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-bmax_ref'\n");
BMAX_REF = atof(argv[iarg]);
HAVE_BMAX_REF = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out_bval_col") == 0) {
BVAL_OUT = 1;
iarg++ ; continue ;
}
// May,2015
if( strcmp(argv[iarg],"-out_bval_row_sep") == 0) {
if( ++iarg >= argc )
ERROR_exit("Need argument after '-out_bval_row_sep'\n") ;
Fname_outputBV = argv[iarg];
BVAL_OUT_SEP = 1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-proc_dset") == 0 ){ // in DWIs
if( ++iarg >= argc )
ERROR_exit("Need argument after '-proc_dset'") ;
dwset = THD_open_dataset( argv[iarg] ) ;
if( dwset == NULL )
ERROR_exit("Can't open DWI dataset '%s'", argv[iarg]) ;
DSET_load(dwset) ; CHECK_LOAD_ERROR(dwset) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-pref_dset") == 0 ){ // will be output
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-pref_dset'");
prefix = strdup(argv[iarg]) ;
if( !THD_filename_ok(prefix) )
ERROR_exit("Illegal name after '-pref_dset'");
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-dwi_comp_fac") == 0) {
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-dwi_comp_fac'\n");
DWI_COMP_FAC = atoi(argv[iarg]);
if (DWI_COMP_FAC <=1)
ERROR_exit("The compression factor after '-dwi_comp_fac'"
"must be >1!");
iarg++ ; continue ;
}
ERROR_message("Bad option '%s'\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * *
if( (Fname_input == NULL) ) {
fprintf(stderr,
"\n\tBad Command-lining! Option '-in_*' requires argument.\n");
exit(1);
}
if( (Fname_output == NULL) ) {
fprintf(stderr,
"\n\tBad Command-lining! Option '-out_*' requires arg.\n");
exit(2);
}
if( count_in > 1 ) {
fprintf(stderr,
"\n\tBad Command-lining! Can't have >1 vec file input.\n");
exit(3);
}
if( count_out > 1 ) {
fprintf(stderr,
"\n\tBad Command-lining! Can't have >1 output file opt.\n");
exit(4);
}
if(YES_B && dwset) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Can't have '-keep_b0s' and '-proc_dset' together.\n");
exit(5);
}
if( !prefix && dwset) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Need an output '-pref_dset' when using '-proc_dset'.\n");
exit(6);
}
if(YES_B && DWI_COMP_FAC) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Can't have '-keep_b0s' and '-dwi_comp_fac' together.\n");
exit(7);
}
if(!HAVE_BVAL && (BVAL_OUT || BVAL_OUT_SEP)) {
fprintf(stderr,
"\n** Bad Command-lining! "
"Can't have ask for outputting bvals with no '-in_bvals FILE'.\n");
exit(8);
}
// ********************************************************************
// ************************* start reading ****************************
// ********************************************************************
flim = mri_read_1D (Fname_input);
if (flim == NULL) {
ERROR_exit("Error reading gradient vector file");
}
if( IN_FORM )
preREADIN = mri_transpose(flim); // effectively *undoes* autotranspose
else
preREADIN = mri_copy(flim);
mri_free(flim);
idx = preREADIN->ny;
if( HAVE_BVAL ) {
flim = mri_read_1D (Fname_bval);
if (flim == NULL) {
ERROR_exit("Error reading b-value file");
}
if( flim->ny == 1)
preREADBVAL = mri_transpose(flim); // effectively *undoes* autotransp
else
preREADBVAL = mri_copy(flim);
mri_free(flim);
idx2 = preREADBVAL->ny;
}
if(idx>= MAXGRADS ) {
printf("Error, too many input grads.\n");
mri_free (preREADIN);
if( HAVE_BVAL ) mri_free (preREADBVAL);
exit(4);
}
if( ( (preREADIN->nx != 3 ) && (preREADIN->ny != 3 )) &&
(preREADIN->nx != 6 ) )
printf("Probably an error, "
"because there aren't 3 or 6 numbers in columns!\n");
if( HAVE_BVAL && ( idx != idx2 ) ) {
printf("Error, because the number of bvecs (%d)\n"
"and bvals (%d) don't appear to match!\n", idx, idx2);
mri_free (preREADIN);
mri_free (preREADBVAL);
exit(3);
}
if(dwset) {
Nbrik = DSET_NVALS(dwset);
if( idx != Nbrik ) {
fprintf(stderr,
"\n** ERROR: the number of bvecs (%d) does not match the "
"number of briks in '-proc_dset' (%d).\n", idx, Nbrik);
exit(4);
}
}
READIN = MRI_FLOAT_PTR( preREADIN );
if( HAVE_BVAL )
READBVAL = MRI_FLOAT_PTR( preREADBVAL );
// 0 is grad row;
// 1 is grad col;
// 2 is gmatrRow col T;
// 3 is gmatrDiag col A;
// 4 is bmatrRow col T;
// 5 is bmatrDiag col A;
//if( IN_FORM == 0 ) // grad rows, no binfo
// for( i=0; i<idx ; i++ )
// for ( j=0; j<3 ; j++ )
// OUT_GRAD[i][j+1] = *(READIN +j*idx +i) ;
//else
if ( IN_FORM <= 1 ) // grad cols, no binfo
for( i=0; i<idx ; i++ )
for ( j=0; j<3 ; j++ )
OUT_GRAD[i][j+1] = *(READIN + 3*i+j);
// A/row/3dDWItoDT: Bxx, Byy, Bzz, Bxy, Bxz, Byz
// T/diag/TORTOISE: b_xx 2b_xy 2b_xz b_yy 2b_yz b_zz
else if ( (IN_FORM == 3) || (IN_FORM ==5 ) ) { // diag matr
for( i=0; i<idx ; i++ ) {
for( j=0; j<3 ; j++ ) {
OUT_MATR[i][j+1] = *(READIN+6*i+j);
OUT_MATR[i][3+j+1] = *(READIN+6*i+3+j);
}
for( j=0; j<3 ; j++ )
if(OUT_MATR[i][j] < 0 )
CHECK++;
}
if(CHECK > 0)
INFO_message("Warning: you *said* you input a mat'T',"
" but the matr diagonals don't appear to be uniformly"
" positive. If input cols 0, 3 and 5 are positive,"
" then you might have meant mat'A'?");
}
else if ( (IN_FORM ==2 ) || (IN_FORM ==4 ) ) { // row matr
CHECK = 0;
for( i=0; i<idx ; i++ ) {
OUT_MATR[i][1] = *(READIN +6*i);
OUT_MATR[i][2] = *(READIN +6*i+3);
OUT_MATR[i][3] = *(READIN +6*i+5);
OUT_MATR[i][4] = *(READIN +6*i+1)/2.;
OUT_MATR[i][5] = *(READIN +6*i+2)/2.;
OUT_MATR[i][6] = *(READIN +6*i+4)/2.;
}
for( i=0; i<idx ; i++ )
for( j=0; j<3 ; j++ )
if(OUT_MATR[i][j] < 0 )
CHECK++;
if(CHECK > 0)
INFO_message("Warning: you *said* you input a mat'A',"
" but the matr diagonals don't appear to be uniformly"
" positive. If input cols 0, 1 and 2 are positive,"
" then you might have meant mat'T'?");
}
else{
fprintf(stderr, "Coding error with format number (%d), not allowed.\n",
IN_FORM);
exit(2);
}
// get bval info
if( ( (IN_FORM ==4 ) || (IN_FORM ==5 ) ) ) { //bval
for( i=0; i<idx ; i++ ) {
OUT_MATR[i][0] = OUT_GRAD[i][0] =
OUT_MATR[i][1] + OUT_MATR[i][2] + OUT_MATR[i][3];
if( OUT_MATR[i][0] > 0.000001)
for( j=1 ; j<7 ; j++ )
OUT_MATR[i][j]/= OUT_MATR[i][0];
}
}
else if ( HAVE_BVAL )
for( i=0; i<idx ; i++ ) {
OUT_MATR[i][0] = OUT_GRAD[i][0] = *(READBVAL + i);
}
else if ( OUT_FORM > 3 || BVAL_OUT || BVAL_OUT_SEP || HAVE_BMAX_REF ) {
fprintf(stderr, "ERROR: you asked for b-value dependent output, "
"but gave me no bvals to work with.\n");
exit(2);
}
// * * * ** * * * * * * * * ** ** * * ** * * ** * ** * ** * * *
// at this point, all IN_FORM >1 cases which need bval have led to:
// + grad[0] has bval
// + matr[0] has bval
// + matr file normalized and in diagonal form
// * * * ** * * * * * * * * ** ** * * ** * * ** * ** * ** * * *
for( i=0; i<idx ; i++ )
if( IN_FORM > 1)
j = GradConv_Gsign_from_BmatA( OUT_GRAD[i]+1, OUT_MATR[i]+1);
else
j = GradConv_BmatA_from_Gsign( OUT_MATR[i]+1, OUT_GRAD[i]+1);
// flip if necessary
for( i=0 ; i<idx ; i++) {
for( j=0 ; j<3 ; j++)
OUT_GRAD[i][j+1]*= INV[j];
OUT_MATR[i][4]*= INV[0]*INV[1];
OUT_MATR[i][5]*= INV[0]*INV[2];
OUT_MATR[i][6]*= INV[1]*INV[2];
}
BZER=0;
for( i=0 ; i<idx ; i++) {
if( HAVE_BVAL || (IN_FORM ==4) || (IN_FORM ==5) )
if( OUT_GRAD[i][0] >= BMAX_REF )
FLAG[i] = 1;
else{
if( YES_B )
FLAG[i] = 1;
BZER++;
}
else {
temp = 0.;
for( j=1 ; j<4 ; j++)
temp+= pow(OUT_GRAD[i][j],2);
if( temp > 0.1 )
FLAG[i] = 1;
else{
if( YES_B )
FLAG[i] = 1;
BZER++;
}
}
}
if(YES_B) {
printf("\tChose to *keep* %d b0s,\tas well as \t%d grads\n",
BZER,idx-BZER);
BZER=0;
}
else {
printf("\tGetting rid of %d b0s,\tleaving the %d grads\n",
BZER,idx-BZER);
Ndwi = idx-BZER;
}
Ndwi_final = idx-BZER; // default: all DWIs
if( DWI_COMP_FAC ) {
if( Ndwi % DWI_COMP_FAC != 0 ) {
fprintf(stderr, "\n** ERROR can't compress: "
"Ndwi=%d, and %d/%d has a nonzero remainder (=%d).\n",
Ndwi,Ndwi,DWI_COMP_FAC, Ndwi % DWI_COMP_FAC );
exit(1);
}
else {
Ndwi_final = Ndwi/DWI_COMP_FAC;
INFO_message("You have chosen a compression factor of %d, "
"with %d DWIs,\n"
"\tso that afterward there will be %d DWIs.",
DWI_COMP_FAC, Ndwi, Ndwi_final);
}
}
if(BVAL_OUT_SEP)
if( (foutBV = fopen(Fname_outputBV, "w")) == NULL) {
fprintf(stderr, "\n\nError opening file %s.\n",Fname_outputBV);
exit(1);
}
if( (fout = fopen(Fname_output, "w")) == NULL) {
fprintf(stderr, "\n\nError opening file %s.\n",Fname_output);
exit(1);
}
// 0 is grad row;
// 1 is grad col;
// 2 is gmatrRow col T;
// 3 is gmatrDiag col A;
// 4 is bmatrRow col T;
// 5 is bmatrDiag col A;
if( OUT_FORM>0) {
if( EXTRA_ZEROS ) {
if( BVAL_OUT )
fprintf(fout,"%8d ", 0);
if( BVAL_OUT_SEP )
fprintf(foutBV,"%8d ", 0);
if( OUT_FORM == 1 )
for( k=1 ; k<4 ; k++ )
fprintf(fout,"%11.5f ", 0.0);
else if ( OUT_FORM > 1 ) // bit superfluous at this point
for( k=1 ; k<7 ; k++ )
fprintf(fout,"%11.5f ", 0.0);
fprintf(fout,"\n");
}
ct_dwi = 0;
for(i=0 ; i<idx ; i++){
if(FLAG[i]) {
if( BVAL_OUT )
fprintf(fout,"%8d ", (int) OUT_GRAD[i][0]);
if( BVAL_OUT_SEP )
fprintf(foutBV,"%8d ", (int) OUT_GRAD[i][0]);
if( (OUT_FORM == 4) || (OUT_FORM ==5) )
for( k=1 ; k<7 ; k++ )
OUT_MATR[i][k]*= OUT_MATR[i][0];
if( OUT_FORM == 1 ) // grad col
for( k=1 ; k<4 ; k++ )
fprintf(fout,"%11.5f ", OUT_GRAD[i][k]);
else if( (OUT_FORM == 3) || (OUT_FORM == 5) ) { // gmat
for( k=1 ; k<6 ; k++ )
fprintf(fout,"%11.5f ", OUT_MATR[i][k]);
fprintf(fout,"%11.5f", OUT_MATR[i][k]);
}
else if ( (OUT_FORM == 2 ) || (OUT_FORM ==4)) { // bmat
fprintf(fout,"%11.5f ", OUT_MATR[i][1]);
fprintf(fout,"%11.5f ", 2*OUT_MATR[i][4]);
fprintf(fout,"%11.5f ", 2*OUT_MATR[i][5]);
fprintf(fout,"%11.5f ", OUT_MATR[i][2]);
fprintf(fout,"%11.5f ", 2*OUT_MATR[i][6]);
fprintf(fout,"%11.5f", OUT_MATR[i][3]);
}
fprintf(fout,"\n");
ct_dwi++;
}
if( (ct_dwi == Ndwi_final) && DWI_COMP_FAC ) {
INFO_message("Reached compression level: DWI number %d",
Ndwi_final);
break;
}
}
}
else if(OUT_FORM ==0) {
if(BVAL_OUT)
WARNING_message("Ignoring '-out_bval_col' option, since "
" you are outputting in rows.");
for( k=1 ; k<4 ; k++ ) {
if(EXTRA_ZEROS){
fprintf(fout,"% -11.5f ", 0.0);
if( (k==1) && BVAL_OUT_SEP ) // only output 1 zeroin bval file
fprintf(foutBV,"%8d ", 0);
}
ct_dwi = 0;
for(i=0 ; i<idx ; i++) {
if(FLAG[i]) {
fprintf(fout,"% -11.5f ", OUT_GRAD[i][k]);
if( (k==1) && BVAL_OUT_SEP )// only output 1 zeroin bval file
fprintf(foutBV,"%8d ", (int) OUT_GRAD[i][0]);
ct_dwi++;
}
if( (ct_dwi == Ndwi_final) && DWI_COMP_FAC ) {
INFO_message("Reached compression level: DWI number %d",
Ndwi_final);
break;
}
}
fprintf(fout,"\n");
}
}
fclose(fout);
if( BVAL_OUT_SEP ) {
fprintf(foutBV,"\n");
fclose(foutBV);
}
if(dwset) {
INFO_message("Processing the B0+DWI file now.");
if(!BZER) {
fprintf(stderr, "\n** Error in processing data set: "
"no b=0 values from bvecs/bval info!\n");
exit(5);
}
// FLAG marks where DWIs are if not using '-keep_b0s'!
Nvox = DSET_NVOX(dwset);
Ndwout = Ndwi+1;
temp_arr = calloc( Ndwout,sizeof(temp_arr));
for( i=0 ; i<Ndwout ; i++)
temp_arr[i] = calloc( Nvox,sizeof(float));
temp_grad = calloc( Ndwi,sizeof(temp_grad));
for( i=0 ; i<Ndwi ; i++)
temp_grad[i] = calloc( 3,sizeof(float));
if( (temp_arr == NULL) || (temp_grad == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(123);
}
dwi = 0; // keep track of DWI contraction
for( i=0 ; i<Nbrik ; i++)
if( !FLAG[i] ) // b=0
for( j=0 ; j<Nvox ; j++)
temp_arr[0][j]+= THD_get_voxel(dwset,j,i);
else {
for( j=0 ; j<3 ; j++)
temp_grad[dwi][j]= OUT_GRAD[i][j+1];
dwi++;
for( j=0 ; j<Nvox ; j++)
temp_arr[dwi][j]+= THD_get_voxel(dwset,j,i);
}
if( dwi != Ndwi ) {
fprintf(stderr, "\n** Mismatch in internal DWI counting!\n");
exit(6);
}
// average the values
for( j=0 ; j<Nvox ; j++)
temp_arr[0][j]/= BZER; // can't be zero here.
if( DWI_COMP_FAC ) {
INFO_message("Compressing DWI file");
for( k=1 ; k<DWI_COMP_FAC ; k++)
for( i=0 ; i<Ndwi_final ; i++)
for( j=0 ; j<Nvox ; j++)
temp_arr[1+i][j]+= temp_arr[1+k*Ndwi_final+i][j];
for( i=0 ; i<Ndwi_final ; i++)
for( j=0 ; j<Nvox ; j++)
temp_arr[1+i][j]/= DWI_COMP_FAC;
INFO_message("Checking closeness of compressed gradient values");
MaxDP = GradCloseness(temp_grad, Ndwi, DWI_COMP_FAC);
INFO_message("The max angular difference between matched/compressed\n"
"\tgradients is: %f", MaxDP);
if( MaxDP > 2)
WARNING_message("The max angular difference seem kinda big-- you\n"
" sure about the compression factor?");
}
Ndwout_final = Ndwi_final + 1;
INFO_message("Writing the processed data set.");
dwout = EDIT_empty_copy( dwset );
EDIT_dset_items(dwout,
ADN_nvals, Ndwout_final,
ADN_ntt, 0,
ADN_datum_all, MRI_float ,
ADN_prefix, prefix,
ADN_none );
for( i=0; i<Ndwout_final ; i++) {
EDIT_substitute_brick(dwout, i, MRI_float, temp_arr[i]);
temp_arr[i]=NULL;
}
// if necessary
for( i=Ndwout_final ; i<Ndwout ; i++)
temp_arr[i]=NULL;
THD_load_statistics( dwout );
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(dwout)) )
ERROR_exit("Can't overwrite existing dataset '%s'",
DSET_HEADNAME(dwout));
tross_Make_History("1dDW_Grad_o_Mat", argc, argv, dwout);
THD_write_3dim_dataset(NULL, NULL, dwout, True);
DSET_delete(dwout);
free(dwout);
DSET_delete(dwset);
free(dwset);
for( i=0 ; i<Ndwout_final ; i++)
free(temp_arr[i]);
free(temp_arr);
}
mri_free(preREADIN);
if( HAVE_BVAL )
mri_free(preREADBVAL);
if(prefix)
free(prefix);
printf("\n\tDone. Check output file '%s' for results",Fname_output);
if(dwset) {
printf("\n\t-> as well as the data_set '%s'",DSET_FILECODE(dwout));
}
if(BVAL_OUT_SEP)
printf("\n\t-> and even the b-value rows '%s'",Fname_outputBV);
printf("\n\n");
exit(0);
}
MRI_IMAGE * mri_valpad_2D( int nxbot , int nxtop ,
int nybot , int nytop , MRI_IMAGE *fim,
byte val)
{
int nxold,nyold , nxnew,nynew , nx,ny ;
int ii,jj , iibot,iitop , jjbot,jjtop ;
MRI_IMAGE *vim ;
ENTRY("mri_valpad_2D") ;
/*- check for user stupidity -*/
if( fim == NULL ) RETURN(NULL) ;
nx = fim->nx ; ny = fim->ny ;
/*- special case: just copy input -*/
if( nxbot == 0 && nybot == 0 &&
nxtop == 0 && nytop == 0 ){
vim = mri_copy( fim ) ;
RETURN(vim) ;
}
nxold = nx ; nxnew = nxold + nxbot + nxtop ; /* dimensions */
nyold = ny ; nynew = nyold + nybot + nytop ;
iibot = MAX(0,-nxbot) ; iitop = MIN(nxold,nxold+nxtop) ; /* range of data */
jjbot = MAX(0,-nybot) ; jjtop = MIN(nyold,nyold+nytop) ; /* in old dataset */
if( nxnew < 1 || iibot >= iitop || /* check for reasonable sizes */
nynew < 1 || jjbot >= jjtop ){ /* and ranges of dataset */
fprintf(stderr,"*** mri_zeropad: can't cut image down to nothing!\n") ;
RETURN(NULL) ;
}
vim = mri_new( nxnew , nynew , fim->kind ) ;
MRI_COPY_AUX(vim,fim) ;
memset( mri_data_pointer(vim) , val ,
nxnew*nynew*mri_datum_size(vim->kind) ) ;
/* macros for computing 1D subscripts from 2D indices */
#undef SNEW /* in case was defined in some stupid .h file */
#undef SOLD
#define SNEW(i,j) ((i+nxbot)+(j+nybot)*nxnew)
#define SOLD(i,j) (i+j*nxold)
switch( fim->kind ){ /* copy rows of old into new */
default:
fprintf(stderr,"*** mri_zeropad: unknown input datum=%d\n",fim->kind) ;
mri_free(vim) ;
RETURN(NULL) ;
case MRI_byte:{
byte *bnew = MRI_BYTE_PTR(vim), *bold = MRI_BYTE_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
case MRI_rgb:{
byte *bnew = MRI_RGB_PTR(vim), *bold = MRI_RGB_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ ){
bnew[3*SNEW(ii,jj) ] = bold[3*SOLD(ii,jj) ] ;
bnew[3*SNEW(ii,jj)+1] = bold[3*SOLD(ii,jj)+1] ;
bnew[3*SNEW(ii,jj)+2] = bold[3*SOLD(ii,jj)+2] ;
}
}
break ;
case MRI_short:{
short *bnew = MRI_SHORT_PTR(vim), *bold = MRI_SHORT_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
case MRI_int:{
int *bnew = MRI_INT_PTR(vim), *bold = MRI_INT_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
case MRI_float:{
float *bnew = MRI_FLOAT_PTR(vim), *bold = MRI_FLOAT_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
case MRI_double:{
double *bnew = MRI_DOUBLE_PTR(vim), *bold = MRI_DOUBLE_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
case MRI_complex:{
complex *bnew = MRI_COMPLEX_PTR(vim), *bold = MRI_COMPLEX_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
} /* end of switch on datum type */
RETURN(vim) ;
}
