MRI_IMARR * mri_rgb_to_3byte( MRI_IMAGE *oldim ) /* 15 Apr 1999 */
{
MRI_IMARR *imar ;
MRI_IMAGE *rim , *gim , *bim ;
byte *rr , *gg , *bb , *rgb ;
int ii , npix ;
ENTRY("mri_rgb_to_3byte") ;
if( oldim == NULL || oldim->kind != MRI_rgb ) RETURN( NULL );
rim = mri_new_conforming( oldim , MRI_byte ) ; rr = MRI_BYTE_PTR(rim) ;
gim = mri_new_conforming( oldim , MRI_byte ) ; gg = MRI_BYTE_PTR(gim) ;
bim = mri_new_conforming( oldim , MRI_byte ) ; bb = MRI_BYTE_PTR(bim) ;
rgb= MRI_BYTE_PTR(oldim);
npix = oldim->nvox ;
for( ii=0 ; ii < npix ; ii++ ){
rr[ii] = rgb[3*ii ] ;
gg[ii] = rgb[3*ii+1] ;
bb[ii] = rgb[3*ii+2] ;
}
INIT_IMARR(imar) ;
ADDTO_IMARR(imar,rim) ; ADDTO_IMARR(imar,gim) ; ADDTO_IMARR(imar,bim) ;
RETURN( imar );
}
MRI_IMARR * mri_complex_to_pair( MRI_IMAGE * cim )
{
MRI_IMARR * imarr ;
MRI_IMAGE * rim , * iim ;
register int ii , nvox ;
register float * rar , * iar ;
register complex * car ;
ENTRY("mri_complex_to_pair") ;
if( cim == NULL || cim->kind != MRI_complex ) RETURN( NULL );
rim = mri_new_conforming( cim , MRI_float ) ; rar = MRI_FLOAT_PTR(rim) ;
iim = mri_new_conforming( cim , MRI_float ) ; iar = MRI_FLOAT_PTR(iim) ;
car = MRI_COMPLEX_PTR(cim) ;
nvox = cim->nvox ;
for( ii=0 ; ii < nvox ; ii++ ){ rar[ii] = car[ii].r ; iar[ii] = car[ii].i ; }
INIT_IMARR(imarr) ;
ADDTO_IMARR(imarr,rim) ;
ADDTO_IMARR(imarr,iim) ;
RETURN( imarr );
}
MRI_IMARR * THD_medmad_bricks( THD_3dim_dataset *dset )
{
int nvox , nvals , ii ;
MRI_IMAGE *tsim , *madim, *medim ;
float *madar, *medar ;
MRI_IMARR *imar ;
float *tsar ;
ENTRY("THD_medmad_bricks") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
nvals = DSET_NVALS(dset) ; if( nvals == 1 ) RETURN(NULL) ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
tsim = DSET_BRICK(dset,0) ;
madim = mri_new_conforming( tsim , MRI_float ) ;
madar = MRI_FLOAT_PTR(madim) ;
medim = mri_new_conforming( tsim , MRI_float ) ;
medar = MRI_FLOAT_PTR(medim) ;
nvox = DSET_NVOX(dset) ;
tsar = (float *) calloc( sizeof(float),nvals+1 ) ;
for( ii=0 ; ii < nvox ; ii++ ){
THD_extract_array( ii , dset , 0 , tsar ) ;
qmedmad_float( nvals , tsar , medar+ii , madar+ii ) ;
}
free(tsar) ;
INIT_IMARR(imar) ; ADDTO_IMARR(imar,medim) ; ADDTO_IMARR(imar,madim) ;
RETURN(imar) ;
}
MRI_IMARR * IMARR_medmad_bricks( MRI_IMARR *dmar )
{
int nvox , nvals , ii , kk ;
MRI_IMAGE *tsim , *madim, *medim ;
float *madar, *medar ;
MRI_IMARR *imar ;
float *tsar , **dar ;
ENTRY("IMARR_medmad_bricks") ;
if( dmar == NULL || IMARR_COUNT(dmar) < 2 ) RETURN(NULL) ;
nvals = IMARR_COUNT(dmar) ;
tsim = IMARR_SUBIM(dmar,0) ;
madim = mri_new_conforming( tsim , MRI_float ) ;
madar = MRI_FLOAT_PTR(madim) ;
medim = mri_new_conforming( tsim , MRI_float ) ;
medar = MRI_FLOAT_PTR(medim) ;
nvox = tsim->nvox ;
dar = (float **)malloc(sizeof(float *)*nvals) ;
for( kk=0 ; kk < nvals ; kk++ )
dar[kk] = MRI_FLOAT_PTR( IMARR_SUBIM(dmar,kk) ) ;
tsar = (float *) calloc( sizeof(float),nvals+1 ) ;
for( ii=0 ; ii < nvox ; ii++ ){
for( kk=0 ; kk < nvals ; kk++ ) tsar[kk] = dar[kk][ii] ;
qmedmad_float( nvals , tsar , medar+ii , madar+ii ) ;
}
free(tsar) ; free(dar) ;
INIT_IMARR(imar) ; ADDTO_IMARR(imar,medim) ; ADDTO_IMARR(imar,madim) ;
RETURN(imar) ;
}
MRI_IMAGE * THD_median_brick( THD_3dim_dataset *dset )
{
int nvox , nvals , ii ;
MRI_IMAGE *tsim , *medim ;
float *medar ;
float *tsar ; /* 05 Nov 2001 */
ENTRY("THD_median_brick") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ;
if( !DSET_LOADED(dset) ) RETURN(NULL) ;
nvals = DSET_NVALS(dset) ;
tsim = DSET_BRICK(dset,0) ;
if( nvals == 1 ){
medim = mri_scale_to_float( DSET_BRICK_FACTOR(dset,0), tsim ) ;
RETURN(medim) ;
}
medim = mri_new_conforming( tsim , MRI_float ) ;
medar = MRI_FLOAT_PTR(medim) ;
nvox = DSET_NVOX(dset) ;
tsar = (float *) calloc( sizeof(float),nvals+1 ) ; /* 05 Nov 2001 */
for( ii=0 ; ii < nvox ; ii++ ){
THD_extract_array( ii , dset , 0 , tsar ) ; /* 05 Nov 2001 */
medar[ii] = qmed_float( nvals , tsar ) ;
}
free(tsar) ; RETURN(medim) ;
}
MRI_IMAGE * mri_pair_to_complex( MRI_IMAGE * rim , MRI_IMAGE * iim )
{
MRI_IMAGE * cim , * rfim , * ifim ;
register complex * car ;
register float * rar , * iar ;
register int ii , nvox ;
ENTRY("mri_pair_to_complex") ;
if( rim == NULL || iim == NULL || rim->nvox != iim->nvox ) RETURN( NULL );
cim = mri_new_conforming( rim , MRI_complex ) ;
car = MRI_COMPLEX_PTR(cim) ;
rfim = (rim->kind == MRI_float) ? rim : mri_to_float( rim ) ;
ifim = (iim->kind == MRI_float) ? iim : mri_to_float( iim ) ;
rar = MRI_FLOAT_PTR(rfim) ; iar = MRI_FLOAT_PTR(ifim) ;
nvox = rfim->nvox ;
for( ii=0 ; ii < nvox ; ii++ ){ car[ii].r = rar[ii] ; car[ii].i = iar[ii] ; }
if( rfim != rim ) mri_free( rfim ) ;
if( ifim != iim ) mri_free( ifim ) ;
RETURN( cim );
}
MRI_IMAGE * cx_scramble( MRI_IMAGE * ima , MRI_IMAGE * imb ,
float alpha , float beta )
{
int ii , npix ;
double r1,r2 , t1,t2 , rr,tt ;
complex * ar , * br , * cr ;
double aa,aa1 , bb,bb1 ;
MRI_IMAGE * imc ;
if( ima == NULL || ima->kind != MRI_complex ||
imb == NULL || imb->kind != MRI_complex ||
ima->nx != imb->nx || ima->ny != imb->ny ||
alpha < 0.0 || alpha > 1.0 ||
beta < 0.0 || beta > 1.0 ) return NULL ;
npix = ima->nvox ;
ar = MRI_COMPLEX_PTR(ima) ;
br = MRI_COMPLEX_PTR(imb) ;
imc = mri_new_conforming( ima , MRI_complex ) ;
cr = MRI_COMPLEX_PTR(imc) ;
aa = alpha ; aa1 = 1.0 - aa ;
bb = beta ; bb1 = 1.0 - bb ;
for( ii=0 ; ii < npix ; ii++ ){
r1 = CABS(ar[ii]) ; r2 = CABS(br[ii]) ; rr = pow(r1,aa)*pow(r2,aa1) ;
t1 = CARG(ar[ii]) ; t2 = CARG(br[ii]) ; tt = t1-t2 ;
if( tt < -PI ) t2 -= 2.0*PI ;
else if( tt > PI ) t2 += 2.0*PI ;
tt = bb*t1 + bb1*t2 ;
cr[ii].r = rr * cos(tt) ; cr[ii].i = rr * sin(tt) ;
}
return imc ;
}
MRI_IMAGE * THD_rms_brick( THD_3dim_dataset *dset )
{
int nvox , nvals , ii , jj ;
MRI_IMAGE *tsim , *medim ;
float *medar , sum,fac ;
float *tsar ;
ENTRY("THD_rms_brick") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ;
if( !DSET_LOADED(dset) ) RETURN(NULL) ;
nvals = DSET_NVALS(dset) ; fac = 1.0 / nvals ;
tsim = DSET_BRICK(dset,0) ;
if( nvals == 1 ){
medim = mri_scale_to_float( DSET_BRICK_FACTOR(dset,0), tsim ) ;
RETURN(medim) ;
}
medim = mri_new_conforming( tsim , MRI_float ) ;
medar = MRI_FLOAT_PTR(medim) ;
nvox = DSET_NVOX(dset) ;
tsar = (float *) calloc( sizeof(float),nvals+1 ) ;
for( ii=0 ; ii < nvox ; ii++ ){
THD_extract_array( ii , dset , 0 , tsar ) ;
for( sum=0.0,jj=0 ; jj < nvals ; jj++ ) sum += tsar[jj]*tsar[jj] ;
medar[ii] = sqrtf(fac * sum) ;
}
free(tsar) ; RETURN(medim) ;
}
MRI_IMAGE *mri_to_rgb( MRI_IMAGE *oldim ) /* 11 Feb 1999 */
{
MRI_IMAGE *newim ;
register int ii , npix ;
register byte * rgb ;
ENTRY("mri_to_rgb") ;
if( oldim == NULL ) RETURN( NULL );
newim = mri_new_conforming( oldim , MRI_rgb ) ; rgb = MRI_RGB_PTR(newim) ;
npix = oldim->nvox ;
switch( oldim->kind ){
case MRI_byte:{ byte *qar = MRI_BYTE_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
rgb[3*ii] = rgb[3*ii+1] = rgb[3*ii+2] = qar[ii] ;
} break ;
case MRI_float:{ float *qar = MRI_FLOAT_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
rgb[3*ii] = rgb[3*ii+1] = rgb[3*ii+2] = qar[ii] ;
} break ;
case MRI_short:{ short *qar = MRI_SHORT_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
rgb[3*ii] = rgb[3*ii+1] = rgb[3*ii+2] = qar[ii] ;
} break ;
case MRI_rgb:
memcpy( rgb , MRI_RGB_PTR(oldim) , 3*npix ) ;
break ;
case MRI_rgba:{ rgba *qar = MRI_RGBA_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ){
rgb[3*ii] = qar[ii].r ;
rgb[3*ii+1] = qar[ii].g ;
rgb[3*ii+2] = qar[ii].b ;
}
} break ;
default:
ERROR_message("mri_to_rgb: unrecognized image conversion %d",oldim->kind) ;
mri_free(newim) ; RETURN(NULL);
}
MRI_COPY_AUX(newim,oldim) ;
RETURN( newim );
}
MRI_IMAGE * mri_3to_rgb( MRI_IMAGE *rim , MRI_IMAGE *gim , MRI_IMAGE *bim )
{
MRI_IMAGE *newim ;
register int ii , npix ;
register byte * rgb ;
ENTRY("mri_3to_rgb") ;
if( rim == NULL || bim == NULL || gim == NULL ) RETURN( NULL );
newim = mri_new_conforming( rim , MRI_rgb ) ; rgb = MRI_BYTE_PTR(newim) ;
npix = rim->nvox ;
switch( rim->kind ){
case MRI_byte:{
byte *rr=MRI_BYTE_PTR(rim), *gg=MRI_BYTE_PTR(gim), *bb=MRI_BYTE_PTR(bim) ;
for( ii=0 ; ii < npix ; ii++ ){
rgb[3*ii ] = rr[ii] ;
rgb[3*ii+1] = gg[ii] ;
rgb[3*ii+2] = bb[ii] ;
}
}
break ;
case MRI_float:{
float *rr=MRI_FLOAT_PTR(rim), *gg=MRI_FLOAT_PTR(gim), *bb=MRI_FLOAT_PTR(bim) ;
for( ii=0 ; ii < npix ; ii++ ){
rgb[3*ii ] = rr[ii] ;
rgb[3*ii+1] = gg[ii] ;
rgb[3*ii+2] = bb[ii] ;
}
}
break ;
default:
ERROR_message("mri_3to_rgb: unrecognized image conversion %d",rim->kind) ;
mri_free(newim) ; RETURN(NULL) ;
}
MRI_COPY_AUX(newim,rim) ;
RETURN( newim );
}
MRI_IMAGE * mri_sharpness( MRI_IMAGE *inim )
{
int nx,ny , ii,ip,im , jj,jp,jm ;
float *innar , *outar , avv,qvv ;
MRI_IMAGE *outim , *innim ;
if( inim == NULL ) return NULL ;
innim = mri_to_float(inim) ;
innar = MRI_FLOAT_PTR(innim) ; nx = innim->nx ; ny = innim->ny ;
outim = mri_new_conforming( innim , MRI_float ) ; /* all zero */
outar = MRI_FLOAT_PTR(outim) ;
{ float *qar = (float *)malloc(sizeof(float)*nx*ny) ; int nq=0 ;
for( ii=0 ; ii < nx*ny ; ii++ )
if( innar[ii] != 0.0f ) qar[nq++] = fabsf(innar[ii]) ;
if( nq < 32 ) qvv = 0.0f ;
else qvv = 0.18f * qmed_float(nq,qar) ;
free(qar) ;
}
if( qvv == 0.0f ){ mri_free(innim) ; return outim ; } /* input is all 0! */
for( jj=0 ; jj < ny ; jj++ ){
jm = jj-1 ; if( jm < 0 ) jm++ ;
jp = jj+1 ; if( jp >= ny ) jp-- ;
for( ii=0 ; ii < nx ; ii++ ){
im = ii-1 ; if( im < 0 ) im++ ;
ip = ii+1 ; if( ip >= nx ) ip-- ;
avv = fabsf(IAR(im,jm)) + fabsf(IAR(im,jp)) + fabsf(IAR(ip,jm)) + fabsf(IAR(ip,jp))
+ fabsf(IAR(ii,jm)) + fabsf(IAR(ii,jp)) + fabsf(IAR(im,jj)) + fabsf(IAR(ip,jj))
+ fabsf(IAR(ii,jj)) ;
if( avv < qvv ) avv = qvv ;
OAR(ii,jj) = fabsf( IAR(im,jm) + IAR(im,jp) + IAR(ip,jm) + IAR(ip,jp)
+ 4.0f * ( IAR(ii,jm) + IAR(ii,jp) + IAR(im,jj) + IAR(ip,jj) )
- 20.0f * IAR(ii,jj) ) / avv ;
}
}
innim = mri_median21(outim) ;
mri_free(outim) ; return innim ;
}
MRI_IMAGE * mri_flatten_rgb( MRI_IMAGE *im )
{
MRI_IMAGE *flim , *shim , *newim ;
byte *iar , *nar ;
float *sar , *far ;
int ii , nvox , rr,gg,bb ;
float fac ;
ENTRY("mri_flatten_rgb") ;
if( im == NULL ) RETURN( NULL );
if( im->kind != MRI_rgb ) RETURN( mri_flatten(im) );
flim = mri_to_float( im ) ; /* intensity of input */
shim = mri_flatten( flim ) ; /* flatten intensity */
newim = mri_new_conforming( im , MRI_rgb ) ; /* will be output */
nar = MRI_BYTE_PTR(newim) ; iar = MRI_BYTE_PTR(im) ;
far = MRI_FLOAT_PTR(flim) ; sar = MRI_FLOAT_PTR(shim) ;
nvox = newim->nvox ;
for( ii=0 ; ii < nvox ; ii++ ){
if( far[ii] <= 0.0 || sar[ii] <= 0.0 ){
nar[3*ii] = nar[3*ii+1] = nar[3*ii+2] = 0 ;
} else {
fac = 255.9 * sar[ii] / far[ii] ; /* will be positive */
rr = fac * iar[3*ii] ;
gg = fac * iar[3*ii+1] ;
bb = fac * iar[3*ii+2] ;
nar[3*ii ] = (rr > 255) ? 255 : rr ;
nar[3*ii+1] = (gg > 255) ? 255 : gg ;
nar[3*ii+2] = (bb > 255) ? 255 : bb ;
}
}
mri_free(flim) ; mri_free(shim) ;
MRI_COPY_AUX(newim,im) ;
RETURN( newim );
}
MRI_IMAGE * mri_median21( MRI_IMAGE *innim )
{
float *innar , *outar , qar[21] ;
MRI_IMAGE *outim ;
int ii,ip,iq,im,in , jj,jp,jq,jm,jn , kk , nx,ny ;
if( innim == NULL || innim->kind != MRI_float ) return NULL ;
innar = MRI_FLOAT_PTR(innim) ; nx = innim->nx ; ny = innim->ny ;
outim = mri_new_conforming( innim , MRI_float ) ;
outar = MRI_FLOAT_PTR(outim) ;
for( jj=0 ; jj < ny ; jj++ ){
jm = jj-1 ; if( jm < 0 ) jm++ ;
jn = jm-1 ; if( jn < 0 ) jn++ ;
jp = jj+1 ; if( jp >= ny ) jp-- ;
jq = jp+1 ; if( jq >= ny ) jq-- ;
for( ii=0 ; ii < nx ; ii++ ){
im = ii-1 ; if( im < 0 ) im++ ;
in = im-1 ; if( in < 0 ) in++ ;
ip = ii+1 ; if( ip >= nx ) ip-- ;
iq = ip+1 ; if( iq >= nx ) iq-- ;
kk = 0 ;
qar[kk++] = IAR(im,jn); qar[kk++] = IAR(ii,jn); qar[kk++] = IAR(ip,jn);
qar[kk++] = IAR(in,jm); qar[kk++] = IAR(im,jm); qar[kk++] = IAR(ii,jm); qar[kk++] = IAR(ip,jm); qar[kk++] = IAR(iq,jm);
qar[kk++] = IAR(in,jj); qar[kk++] = IAR(im,jj); qar[kk++] = IAR(ii,jj); qar[kk++] = IAR(ip,jj); qar[kk++] = IAR(iq,jj);
qar[kk++] = IAR(in,jp); qar[kk++] = IAR(im,jp); qar[kk++] = IAR(ii,jp); qar[kk++] = IAR(ip,jp); qar[kk++] = IAR(iq,jp);
qar[kk++] = IAR(im,jq); qar[kk++] = IAR(ii,jq); qar[kk++] = IAR(ip,jq);
OAR(ii,jj) = qmed_float(21,qar) ;
}
}
return outim ;
}
MRI_IMAGE *mri_flatfilter( MRI_IMAGE *imin, float irad, byte *mask, int verb )
{
MRI_IMAGE *imout ;
float *fin=NULL , *fout , *tmp ;
short *sin=NULL ; byte *bin=NULL ; void *vin ;
short *di , *dj , *dk ;
int nd, ii,jj,kk, ip,jp,kp, nx,ny,nz, nxy, ijk, dd,nt=0,pjk, kd=0 ;
MCW_cluster *cl ;
float dz , sum ;
ENTRY("mri_flatfilter") ;
if( imin == NULL || irad <= 0.0f ) RETURN(NULL) ;
/** deal with vector-valued images [15 Dec 2008] -- see mrilib.h **/
#undef CALLME
#define CALLME(inn,out) (out) = mri_flatfilter( (inn), irad,mask,verb )
if( ISVECTIM(imin) ){ VECTORME(imin,imout) ; RETURN(imout) ; }
/** if not a good input data type, floatize and try again **/
if( imin->kind != MRI_float &&
imin->kind != MRI_short &&
imin->kind != MRI_byte ){
MRI_IMAGE *qim ;
qim = mri_to_float( imin ) ;
imout = mri_flatfilter( qim , irad , mask , verb ) ;
mri_free( qim ) ;
RETURN(imout) ;
}
/** build cluster of points for filter-izing **/
if( !use_dxyz ){
if( irad < 1.01f ) irad = 1.01f ;
dz = (imin->nz == 1) ? 6666.0f : 1.0f ;
cl = MCW_build_mask( 1.0f,1.0f,dz , irad ) ;
} else {
float dm ;
dz = (imin->nz == 1) ? 6666.0f : imin->dz ;
dm = MIN(imin->dx,imin->dy) ; dm = MIN(dm,dz) ;
dm *= 1.01f ; if( irad < dm ) irad = dm ;
cl = MCW_build_mask( imin->dx,imin->dy,dz , irad ) ;
}
if( cl == NULL || cl->num_pt < 6 ){ KILL_CLUSTER(cl); RETURN(NULL); }
ADDTO_CLUSTER(cl,0,0,0,0) ; /* add central point to cluster */
di = cl->i ; dj = cl->j ; dk = cl->k ; nd = cl->num_pt ;
nx = imin->nx ; ny = imin->ny ; nz = imin->nz ; nxy = nx*ny ;
if( verb ){
fprintf(stderr,"++ Median mask=%d",nd) ;
if( mask != NULL )
fprintf(stderr," Data mask=%d",THD_countmask(nxy*nz,mask)) ;
}
imout = mri_new_conforming( imin , MRI_float ) ; /* zero filled */
fout = MRI_FLOAT_PTR( imout ) ;
vin = mri_data_pointer( imin ) ;
tmp = (float *) malloc(sizeof(float)*nd) ;
switch( imin->kind ){
default: break ;
case MRI_float: fin = (float *)vin ; break ;
case MRI_short: sin = (short *)vin ; break ;
case MRI_byte : bin = (byte *)vin ; break ;
}
if( verb ){ kd = (int)rint(0.03*nz); if( kd < 1 ) kd = 1; }
for( kk=0 ; kk < nz ; kk++ ){
if( verb && kk%kd == 0 ) fprintf(stderr,".") ;
for( jj=0 ; jj < ny ; jj++ ){
for( ii=0 ; ii < nx ; ii++ ){
ijk = ii + jj*nx + kk*nxy ;
if( SKIPVOX(ijk) ) continue ;
/* extract neighborhood values */
switch( imin->kind ){
default: break ;
case MRI_float:
for( nt=dd=0 ; dd < nd ; dd++ ){
ip = ii+di[dd] ; if( ip < 0 || ip >= nx ) continue ;
jp = jj+dj[dd] ; if( jp < 0 || jp >= ny ) continue ;
kp = kk+dk[dd] ; if( kp < 0 || kp >= nz ) continue ;
pjk = ip+jp*nx+kp*nxy ;
if( SKIPVOX(pjk) ) continue ;
tmp[nt++] = fin[pjk] ;
}
break ;
case MRI_short:
for( nt=dd=0 ; dd < nd ; dd++ ){
ip = ii+di[dd] ; if( ip < 0 || ip >= nx ) continue ;
jp = jj+dj[dd] ; if( jp < 0 || jp >= ny ) continue ;
kp = kk+dk[dd] ; if( kp < 0 || kp >= nz ) continue ;
pjk = ip+jp*nx+kp*nxy ;
if( SKIPVOX(pjk) ) continue ;
tmp[nt++] = sin[pjk] ;
}
break ;
case MRI_byte:
for( nt=dd=0 ; dd < nd ; dd++ ){
ip = ii+di[dd] ; if( ip < 0 || ip >= nx ) continue ;
jp = jj+dj[dd] ; if( jp < 0 || jp >= ny ) continue ;
kp = kk+dk[dd] ; if( kp < 0 || kp >= nz ) continue ;
pjk = ip+jp*nx+kp*nxy ;
if( SKIPVOX(pjk) ) continue ;
tmp[nt++] = bin[pjk] ;
}
break ;
}
sum = 0.0f ;
for( dd=0 ; dd < nt ; dd++ ) sum += tmp[dd] ;
fout[ijk] = sum / nt ; /* the actual filtering */
}}}
if( verb ) fprintf(stderr,"\n") ;
KILL_CLUSTER(cl); free((void *)tmp); /* toss the trash */
RETURN(imout) ;
}
MRI_IMAGE *bim , MRI_IMAGE *fim )
{
int nn=dim->nx , mm=dim->ny , nxy=nn*mm ;
float *dar=MRI_FLOAT_PTR(dim) ;
float *aar=MRI_FLOAT_PTR(aim) , *bar=MRI_FLOAT_PTR(bim) ;
float *ear=MRI_FLOAT_PTR(eim) , *far=MRI_FLOAT_PTR(fim) ;
float xmu=mu , xlam=lam , xac=ac , sum ;
MRI_IMAGE *yaim , *yeim ;
float *yaar , *year ;
register int ii ; register float val ;
/** form [yaim] = [aim] + ac*([aim]-[bim])
[yeim] = [eim] + ac*([eim]-[fim]) **/
yaim = mri_new_conforming(dim,MRI_float) ; yaar = MRI_FLOAT_PTR(yaim) ;
yeim = mri_new_conforming(dim,MRI_float) ; year = MRI_FLOAT_PTR(yeim) ;
if( xac <= 0.0f ){
memcpy( yaar , aar , sizeof(float)*nxy ) ;
memcpy( year , ear , sizeof(float)*nxy ) ;
} else {
register float af , bf ;
af = 1.0f + xac ; bf = xac ;
for( ii=0 ; ii < nxy ; ii++ ){
yaar[ii] = af*aar[ii] - bf*bar[ii] ;
year[ii] = af*ear[ii] - bf*far[ii] ;
}
}
/* copy contents of aim into bim, and eim into fim, */
/* so on output, bim is the old aim, aim is updated, */
MRI_IMAGE *mri_to_complex( MRI_IMAGE *oldim )
{
MRI_IMAGE *newim ;
register int ii , npix ;
register complex *nar ;
ENTRY("mri_to_complex") ;
if( oldim == NULL ) RETURN( NULL ); /* 09 Feb 1999 */
newim = mri_new_conforming( oldim , MRI_complex ) ;
npix = oldim->nvox ;
nar = MRI_COMPLEX_PTR(newim) ;
switch( oldim->kind ){
case MRI_byte:{
byte *qar = MRI_BYTE_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ) nar[ii].r = qar[ii] ;
}
break ;
case MRI_short:{
short *qar = MRI_SHORT_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ) nar[ii].r = qar[ii] ;
}
break ;
case MRI_int:{
int *qar = MRI_INT_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ) nar[ii].r = qar[ii] ;
}
break ;
case MRI_float:{
float *qar = MRI_FLOAT_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ) nar[ii].r = qar[ii] ;
}
break ;
case MRI_double:{
double *qar = MRI_DOUBLE_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ) nar[ii].r = qar[ii] ;
}
break ;
case MRI_complex:{
complex *qar = MRI_COMPLEX_PTR(oldim) ;
(void) memcpy( nar , qar , sizeof(complex)*npix ) ;
}
break ;
case MRI_rgb:{ /* 16 Jun 2000 */
byte *rgb = MRI_RGB_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ){ /* scale to brightness */
nar[ii].r = 0.299 * rgb[3*ii] /* between 0 and 255 */
+ 0.587 * rgb[3*ii+1]
+ 0.114 * rgb[3*ii+2] ;
}
}
break ;
default:
fprintf( stderr , "mri_to_complex: unrecognized image kind\n" ) ;
MRI_FATAL_ERROR ;
}
if( oldim->kind != MRI_complex ){
for( ii=0 ; ii < npix ; ii++ ) nar[ii].i = 0.0 ;
}
MRI_COPY_AUX(newim,oldim) ;
RETURN( newim );
}
MRI_IMARR * THD_time_fit_dataset( THD_3dim_dataset *dset ,
int nref , float **ref , int meth , byte *mask )
{
int ii , nvox,nval , qq,tt ;
float *far , *fit , *var , val ;
MRI_IMARR *imar ; MRI_IMAGE *qim ; float **fitar ;
ENTRY("THD_time_fit_dataset") ;
if( !ISVALID_DSET(dset) ||
nref < 1 || nref >= DSET_NVALS(dset) || ref == NULL ) RETURN(NULL) ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
/* construct output images */
INIT_IMARR(imar) ;
fitar = (float **)malloc(sizeof(float *)*nref) ;
for( qq=0 ; qq < nref ; qq++ ){
qim = mri_new_conforming( DSET_BRICK(dset,0) , MRI_float ) ;
fitar[qq] = MRI_FLOAT_PTR(qim) ;
ADDTO_IMARR(imar,qim) ;
}
qim = mri_new_conforming( DSET_BRICK(dset,0) , MRI_float ) ;
var = MRI_FLOAT_PTR(qim) ; ADDTO_IMARR(imar,qim) ;
nvox = DSET_NVOX(dset) ; nval = DSET_NVALS(dset) ;
far = (float *)malloc(sizeof(float)*nval) ;
fit = (float *)malloc(sizeof(float)*nref) ;
for( ii=0 ; ii < nvox ; ii++ ){
if( !INMASK(ii) ) continue ;
qq = THD_extract_array( ii , dset , 0 , far ) ; /* get data */
if( qq == 0 ){
switch(meth){ /* get fit */
default:
case 2: THD_generic_detrend_LSQ( nval, far, -1, nref,ref, fit ); break;
case 1: THD_generic_detrend_L1 ( nval, far, -1, nref,ref, fit ); break;
}
for( qq=0 ; qq < nref ; qq++ ) fitar[qq][ii] = fit[qq] ; /* save fit */
/* at this point, far[] contains the residuals */
switch(meth){ /* get stdev or MAD */
default:
case 2:{
float mm,vv ;
for( mm=0.0,tt=0 ; tt < nval ; tt++ ) mm += far[tt] ;
mm /= nval ;
for( vv=0.0,tt=0 ; tt < nval ; tt++ ) vv += (far[tt]-mm)*(far[tt]-mm) ;
var[ii] = sqrtf( vv/(nval-1.0) ) ;
}
break ;
case 1:{
for( tt=0 ; tt < nval ; tt++ ) far[tt] = fabsf(far[tt]) ;
var[ii] = qmed_float( nval , far ) ;
}
break ;
}
}
}
free(fit); free(far); free(fitar); RETURN(imar);
}
MRI_IMAGE * mri_local_percentile( MRI_IMAGE *fim , float vrad , float perc )
{
MRI_IMAGE *aim , *bim , *cim , *dim ;
float *aar , *bar , *car , *dar , *nbar ;
byte *ams , *bms ;
MCW_cluster *nbhd ;
int ii,jj,kk , nbar_num , nx,ny,nz,nxy ;
float fq,val ; int qq,qp,qm ;
ENTRY("mri_local_percentile") ;
if( fim == NULL || vrad < 4.0f || perc < 0.0f || perc > 100.0f ) RETURN(NULL) ;
/* compute automask */
aim = mri_to_float(fim) ; aar = MRI_FLOAT_PTR(aim) ;
ams = mri_automask_image(aim) ;
if( ams == NULL ){ mri_free(aim) ; RETURN(NULL) ; }
/* apply automask to image copy */
for( ii=0 ; ii < aim->nvox ; ii++ ) if( ams[ii] == 0 ) aar[ii] = 0.0f ;
free(ams) ;
/* shrink image by 2 for speedup */
bim = mri_double_down(aim) ; bar = MRI_FLOAT_PTR(bim) ; mri_free(aim) ;
bms = (byte *)malloc(sizeof(byte)*bim->nvox) ;
for( ii=0 ; ii < bim->nvox ; ii++ ) bms[ii] = (bar[ii] != 0.0f) ;
/* neighborhood has 1/2 radius in the shrunken volume */
nbhd = MCW_spheremask( 1.0f,1.0f,1.0f , 0.5f*vrad+0.001f ) ;
nbar = (float *)malloc(sizeof(float)*nbhd->num_pt) ;
cim = mri_new_conforming(bim,MRI_float) ; car = MRI_FLOAT_PTR(cim) ;
SetSearchAboutMaskedVoxel(1) ;
nx = bim->nx ; ny = bim->ny ; nz = bim->nz ; nxy = nx*ny ;
/* for each voxel:
extract neighborhood array, sort it, get result */
for( kk=0 ; kk < nz ; kk++ ){
for( jj=0 ; jj < ny ; jj++ ){
for( ii=0 ; ii < nx ; ii++ ){
nbar_num = mri_get_nbhd_array( bim,bms , ii,jj,kk , nbhd,nbar ) ;
if( nbar_num < 1 ){
val = 0.0f ;
} else {
qsort_float(nbar_num,nbar) ;
if( nbar_num == 1 || perc <= 0.000001f ){
val = nbar[0] ;
} else if( perc >= 99.9999f ){
val = nbar[nbar_num-1] ;
} else {
fq = (0.01f*perc)*nbar_num ;
qq = (int)fq ; qp = qq+1 ; if( qp == nbar_num ) qp = qq ;
qm = qq-1 ; if( qm < 0 ) qm = 0 ;
val = 0.3333333f * ( nbar[qm] + nbar[qq] + nbar[qp] ) ;
}
}
FSUB(car,ii,jj,kk,nx,nxy) = val ;
}}}
mri_free(bim) ; free(bms) ; free(nbar) ; KILL_CLUSTER(nbhd) ;
dim = mri_double_up( cim , fim->nx%2 , fim->ny%2 , fim->nz%2 ) ;
mri_free(cim) ;
RETURN(dim) ;
}
MRI_IMAGE *mri_to_short( double scl , MRI_IMAGE *oldim )
{
MRI_IMAGE *newim ;
register int ii , npix ;
register double scale , val ;
register short *sar ;
ENTRY("mri_to_short") ;
if( oldim == NULL ) RETURN( NULL ); /* 09 Feb 1999 */
newim = mri_new_conforming( oldim , MRI_short ) ;
sar = MRI_SHORT_PTR(newim) ;
npix = oldim->nvox ;
if( scl == 0.0 ){
switch( oldim->kind ){
case MRI_int:
case MRI_float:
case MRI_double:
case MRI_complex:
scale = mri_maxabs( oldim ) ;
if( scale != 0.0 ) scale = 10000.0 / scale ;
#ifdef MRI_DEBUG
fprintf( stderr , "mri_to_short: scale factor = %e\n" , scale ) ;
#endif
break ;
default:
scale = 1.0 ;
break ;
}
} else {
scale = scl ;
}
switch( oldim->kind ){
case MRI_rgb:{
byte *rgb = MRI_RGB_PTR(oldim) ;
float rfac=0.299*scale , gfac=0.587*scale , bfac=0.114*scale ;
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = (short)( rfac * rgb[3*ii]
+ gfac * rgb[3*ii+1]
+ bfac * rgb[3*ii+2] ) ;
}
break ;
case MRI_byte:{
byte *qar = MRI_BYTE_PTR(oldim) ;
if( scale != 1.0 )
for( ii=0 ; ii < npix ; ii++ ){
val = scale * qar[ii] ;
sar[ii] = SHORTIZE(val) ;
}
else
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = (short) qar[ii] ;
break ;
}
case MRI_short:{
short *qar = MRI_SHORT_PTR(oldim) ;
if( scale != 1.0 )
for( ii=0 ; ii < npix ; ii++ ){
val = scale * qar[ii] ;
sar[ii] = SHORTIZE(val) ;
}
else
(void) memcpy( sar , qar , sizeof(short)*npix ) ;
break ;
}
case MRI_int:{
int *qar = MRI_INT_PTR(oldim) ;
if( scale != 1.0 )
for( ii=0 ; ii < npix ; ii++ ){
val = scale * qar[ii] ;
sar[ii] = SHORTIZE(val) ;
}
else
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = SHORTIZE(qar[ii]) ;
break ;
}
case MRI_float:{
float *qar = MRI_FLOAT_PTR(oldim) ;
if( scale != 1.0 )
for( ii=0 ; ii < npix ; ii++ ){
val = scale * qar[ii] ;
sar[ii] = SHORTIZE(val) ;
}
else
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = SHORTIZE(qar[ii]) ;
break ;
}
case MRI_double:{
double *qar = MRI_DOUBLE_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = scale * qar[ii] ;
break ;
}
case MRI_complex:{
complex *qar = MRI_COMPLEX_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = scale * CABS(qar[ii]) ;
break ;
}
default:
fprintf( stderr , "mri_to_short: unrecognized image kind\n" ) ;
MRI_FATAL_ERROR ;
}
MRI_COPY_AUX(newim,oldim) ;
RETURN( newim );
}
MRI_IMAGE * THD_extract_double_brick( int iv , THD_3dim_dataset *dset )
{
MRI_IMAGE *im ;
register float fac ;
register double *var;
register int ii , nvox ;
ENTRY("THD_extract_double_brick") ;
if( iv < 0 || !ISVALID_DSET(dset) || iv >= DSET_NVALS(dset) ) RETURN(NULL);
im = mri_new_conforming( DSET_BRICK(dset,iv) , MRI_double ) ;
var = MRI_DOUBLE_PTR(im) ;
nvox = DSET_NVOX(dset) ;
/*-- extract/scale brick into var --*/
switch( DSET_BRICK_TYPE(dset,iv) ){
default:
mri_free(im) ;
ERROR_message("Can't handle sub-bricks of type %s\n",
MRI_TYPE_name[DSET_BRICK_TYPE(dset,iv)] ) ;
RETURN(NULL) ;
case MRI_short:{
register short *dar = DSET_ARRAY(dset,iv) ;
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = dar[ii] ;
}
break ;
case MRI_byte:{
register byte *dar = DSET_ARRAY(dset,iv) ;
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = dar[ii] ;
}
break ;
case MRI_float:{
register float *dar = DSET_ARRAY(dset,iv) ;
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = dar[ii] ;
}
break ;
case MRI_complex:{
register complex *dar = DSET_ARRAY(dset,iv) ;
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = CABS(dar[ii]) ;
}
break ;
#if 0
case MRI_int:{
register int *dar = DSET_ARRAY(dset,iv) ;
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = dar[ii] ;
}
break ;
#endif
case MRI_double:{
register double *dar = DSET_ARRAY(dset,iv) ;
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = dar[ii] ;
}
break ;
case MRI_rgb:{
register byte *dar = DSET_ARRAY(dset,iv) ;
for( ii=0 ; ii < nvox ; ii++ )
var[ii] = 0.299*dar[3*ii] + 0.587*dar[3*ii+1] + 0.114*dar[3*ii+2] ;
}
break;
}
fac = DSET_BRICK_FACTOR(dset,iv) ; if( fac == 0.0f ) fac = 1.0f ;
if( fac != 1.0f ){ for( ii=0 ; ii < nvox ; ii++ ) var[ii] *= fac ; }
RETURN(im) ;
}
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) ;
}
MRI_IMAGE * mri_local_percmean( MRI_IMAGE *fim , float vrad , float p1, float p2 )
{
MRI_IMAGE *aim , *bim , *cim , *dim ;
float *aar , *bar , *car , *dar ;
byte *ams , *bms ;
MCW_cluster *nbhd ;
int ii , nx,ny,nz,nxy,nxyz ;
float vbot=0.0f ;
ENTRY("mri_local_percmean") ;
if( p1 > p2 ){ float val = p1; p1 = p2; p2 = val; }
if( fim == NULL || vrad < 4.0f || p1 < 0.0f || p2 > 100.0f ) RETURN(NULL) ;
/* just one percentile? */
if( p1 == p2 ) RETURN( mri_local_percentile(fim,vrad,p1) ) ;
if( verb ) fprintf(stderr,"A") ;
/* create automask of copy of input image */
aim = mri_to_float(fim) ; aar = MRI_FLOAT_PTR(aim) ;
ams = mri_automask_image(aim) ;
if( ams == NULL ){ mri_free(aim) ; RETURN(NULL) ; }
/* apply automask to copy of input image */
for( ii=0 ; ii < aim->nvox ; ii++ ) if( ams[ii] == 0 ) aar[ii] = 0.0f ;
free(ams) ;
/* shrink image by 2 for speed */
if( verb ) fprintf(stderr,"D") ;
bim = mri_double_down(aim) ; bar = MRI_FLOAT_PTR(bim) ; mri_free(aim) ;
bms = (byte *)malloc(sizeof(byte)*bim->nvox) ;
for( ii=0 ; ii < bim->nvox ; ii++ ) bms[ii] = (bar[ii] != 0.0f) ;
if( !USE_ALL_VALS ){
vbot = 0.00666f * mri_max(bim) ;
}
/* create neighborhood mask (1/2 radius in the shrunken copy) */
nbhd = MCW_spheremask( 1.0f,1.0f,1.0f , 0.5f*vrad+0.001f ) ;
cim = mri_new_conforming(bim,MRI_float) ; car = MRI_FLOAT_PTR(cim) ;
SetSearchAboutMaskedVoxel(1) ;
nx = bim->nx ; ny = bim->ny ; nz = bim->nz ; nxy = nx*ny ; nxyz = nxy*nz ;
/* for each output voxel,
extract neighborhood array, sort it, average desired range.
Since this is the slowest part of the code, it is now OpenMP-ized. */
#ifndef USE_OMP /* old serial code */
{ int vvv,vstep , ii,jj,kk , nbar_num ; float val , *nbar ;
nbar = (float *)malloc(sizeof(float)*nbhd->num_pt) ;
vstep = (verb) ? nxyz/50 : 0 ;
if( vstep ) fprintf(stderr,"\n + Voxel loop: ") ;
for( vvv=kk=0 ; kk < nz ; kk++ ){
for( jj=0 ; jj < ny ; jj++ ){
for( ii=0 ; ii < nx ; ii++,vvv++ ){
if( vstep && vvv%vstep == vstep-1 ) vstep_print() ;
nbar_num = mri_get_nbhd_array( bim,bms , ii,jj,kk , nbhd,nbar ) ;
if( nbar_num < 1 ){ /* no data */
val = 0.0f ;
} else {
qsort_float(nbar_num,nbar) ; /* sort */
if( nbar_num == 1 ){ /* stoopid case */
val = nbar[0] ;
} else { /* average values from p1 to p2 percentiles */
int q1,q2,qq , qb;
if( !USE_ALL_VALS ){ /* Ignore tiny values [17 May 2016] */
for( qb=0 ; qb < nbar_num && nbar[qb] <= vbot ; qb++ ) ; /*nada*/
if( qb == nbar_num ){
val = 0.0f ;
} else if( qb == nbar_num-1 ){
val = nbar[qb] ;
} else {
q1 = (int)( 0.01f*p1*(nbar_num-1-qb)) + qb; if( q1 > nbar_num-1 ) q1 = nbar_num-1;
q2 = (int)( 0.01f*p2*(nbar_num-1-qb)) + qb; if( q2 > nbar_num-1 ) q2 = nbar_num-1;
for( qq=q1,val=0.0f ; qq <= q2 ; qq++ ) val += nbar[qq] ;
val /= (q2-q1+1.0f) ;
}
} else { /* Use all values [the olden way] */
q1 = (int)( 0.01f*p1*(nbar_num-1) ) ; /* p1 location */
q2 = (int)( 0.01f*p2*(nbar_num-1) ) ; /* p2 location */
for( qq=q1,val=0.0f ; qq <= q2 ; qq++ ) val += nbar[qq] ;
val /= (q2-q1+1.0f) ;
}
}
}
FSUB(car,ii,jj,kk,nx,nxy) = val ;
}}}
free(nbar) ;
if( vstep ) fprintf(stderr,"!") ;
}
#else /* new parallel code [06 Mar 2013 = Snowquestration Day!] */
AFNI_OMP_START ;
if( verb ) fprintf(stderr,"V") ;
#pragma omp parallel
{ int vvv , ii,jj,kk,qq , nbar_num ; float val , *nbar ;
nbar = (float *)malloc(sizeof(float)*nbhd->num_pt) ;
#pragma omp for
for( vvv=0 ; vvv < nxyz ; vvv++ ){
ii = vvv % nx ; kk = vvv / nxy ; jj = (vvv-kk*nxy) / nx ;
nbar_num = mri_get_nbhd_array( bim,bms , ii,jj,kk , nbhd,nbar ) ;
if( nbar_num < 1 ){ /* no data */
val = 0.0f ;
} else {
qsort_float(nbar_num,nbar) ; /* sort */
if( nbar_num == 1 ){ /* stoopid case */
val = nbar[0] ;
} else { /* average values from p1 to p2 percentiles */
int q1,q2,qq , qb;
if( !USE_ALL_VALS ){ /* Ignore tiny values [17 May 2016] */
for( qb=0 ; qb < nbar_num && nbar[qb] <= vbot ; qb++ ) ; /*nada*/
if( qb == nbar_num ){
val = 0.0f ;
} else if( qb == nbar_num-1 ){
val = nbar[qb] ;
} else {
q1 = (int)( 0.01f*p1*(nbar_num-1-qb)) + qb; if( q1 > nbar_num-1 ) q1 = nbar_num-1;
q2 = (int)( 0.01f*p2*(nbar_num-1-qb)) + qb; if( q2 > nbar_num-1 ) q2 = nbar_num-1;
for( qq=q1,val=0.0f ; qq <= q2 ; qq++ ) val += nbar[qq] ;
val /= (q2-q1+1.0f) ;
}
} else { /* Use all values [the olden way] */
q1 = (int)( 0.01f*p1*(nbar_num-1) ) ; /* p1 location */
q2 = (int)( 0.01f*p2*(nbar_num-1) ) ; /* p2 location */
for( qq=q1,val=0.0f ; qq <= q2 ; qq++ ) val += nbar[qq] ;
val /= (q2-q1+1.0f) ;
}
if( verb && vvv%66666==0 ) fprintf(stderr,".") ;
}
}
car[vvv] = val ;
}
free(nbar) ;
} /* end parallel code */
AFNI_OMP_END ;
#endif
mri_free(bim) ; free(bms) ; KILL_CLUSTER(nbhd) ;
/* expand output image back to original size */
dim = mri_double_up( cim , fim->nx%2 , fim->ny%2 , fim->nz%2 ) ;
if( verb ) fprintf(stderr,"U") ;
mri_free(cim) ;
RETURN(dim) ;
}
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_to_short_sclip( double scl , double lev ,
int bot , int top , MRI_IMAGE *oldim )
{
MRI_IMAGE *newim ;
register int ii , npix ;
double imin,imax ;
register double dscale , dbbot ;
register float scale , flbot , val ;
register short * ar ;
ENTRY("mri_to_short_sclip") ;
if( oldim == NULL ) RETURN( NULL ); /* 09 Feb 1999 */
newim = mri_new_conforming( oldim , MRI_short ) ;
npix = oldim->nvox ;
if( scl == 0 ){ /* compute scaling to make [min..max] -> [0..lev] */
imin = (oldim->kind==MRI_complex || oldim->kind==MRI_rgb) ? (0) : mri_min(oldim) ;
imax = mri_max( oldim ) ;
imax = (imax <= imin) ? imin+1 : imax ;
scale = dscale = (lev+0.99) / (imax-imin) ;
flbot = dbbot = imin ;
} else { /* user controlled scaling, with lev -> 0 */
scale = dscale = scl ;
flbot = dbbot = lev ;
}
ar = mri_data_pointer( newim ) ; /* fast access to data */
switch( oldim->kind ){
case MRI_rgb:{
register byte * rgb = mri_data_pointer(oldim) ;
float rfac=0.299*scale , gfac=0.587*scale , bfac=0.114*scale ;
for( ii=0 ; ii < npix ; ii++ )
ar[ii] = (short) ( rfac * rgb[3*ii]
+ gfac * rgb[3*ii+1]
+ bfac * rgb[3*ii+2] ) ;
}
break ;
case MRI_byte:{
register byte * oar = mri_data_pointer(oldim) ;
for( ii=0 ; ii < npix ; ii++ ){
val = scale * (oar[ii]-flbot) ;
ar[ii] = BYTEIZE(val) ;
}
break ;
}
case MRI_short:{
register short * oar = mri_data_pointer(oldim) ;
for( ii=0 ; ii < npix ; ii++ ){
val = scale * (oar[ii]-flbot) ;
ar[ii] = SHORTIZE(val) ;
}
break ;
}
case MRI_int:{
register int * oar = mri_data_pointer(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
ar[ii] = scale * (oar[ii]-flbot) ;
break ;
}
case MRI_float:{
register float * oar = mri_data_pointer(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
ar[ii] = scale * (oar[ii]-flbot) ;
break ;
}
case MRI_double:{
register double * oar = mri_data_pointer(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
ar[ii] = dscale * (oar[ii]-dbbot) ;
break ;
}
case MRI_complex:{
register complex * oar = mri_data_pointer(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
ar[ii] = scale * CABS(oar[ii]) ;
break ;
}
default:
fprintf( stderr , "mri_to_short_scl: unrecognized image kind\n" ) ;
MRI_FATAL_ERROR ;
}
/* clip, if desired */
if( bot < top ){
register short bb = bot , tt = top ;
for( ii=0 ; ii < npix ; ii++ ){
if( ar[ii] < bb ) ar[ii] = bb ;
else if( ar[ii] > tt ) ar[ii] = tt ;
}
}
MRI_COPY_AUX(newim,oldim) ;
RETURN( newim );
}
MRI_IMAGE * mri_flatten( MRI_IMAGE * im )
{
MRI_IMAGE * flim , * intim , * outim ;
float * far , * outar ;
int * iar ;
int ii , nvox , ibot,itop , nvox1 ;
float fac , val ;
#ifdef DEBUG
printf("Entry: mri_flatten\n") ;
#endif
if( im == NULL ) return NULL ;
/*** make an image that is just the voxel index in its array ***/
/*** also, make the output image while we are at it ***/
nvox = im->nvox ;
intim = mri_new_conforming( im , MRI_int ) ;
outim = mri_new_conforming( im , MRI_float ) ;
iar = MRI_INT_PTR(intim) ; outar = MRI_FLOAT_PTR(outim) ;
for( ii=0 ; ii < nvox ; ii++ ) iar[ii] = ii ;
/*** copy the input data to a floating point image ***/
flim = mri_to_float( im ) ; far = MRI_FLOAT_PTR(flim) ;
/*** sort this image, with the index array being carried along
so that we know where every pixel came from originally ***/
qsort_pair( nvox , far , iar ) ;
/*** The "far" array is now sorted. Thus, if the pixel that was in
voxel i is now in voxel j, then its place in the histogram is
j/nvox. The only difficulty is that there may be ties. We need
to resolve these ties so that pixels with the same intensity
don't get different output values. We do this by scanning
through far, finding blocks of equal values, and replacing
them by their average position in the histogram.
***/
fac = 1.0 / nvox ; nvox1 = nvox - 1 ;
for( ibot=0 ; ibot < nvox1 ; ){
/** if this value is unique, just set the value and move on **/
val = far[ibot] ; itop = ibot+1 ;
if( val != far[itop] ){
far[ibot] = fac * ibot ;
ibot++ ; continue ;
}
/** scan itop up until value is distinct **/
for( ; itop < nvox1 && val == far[itop] ; itop++ ) ; /* nada */
val = 0.5*fac * (ibot+itop-1) ;
for( ii=ibot ; ii < itop ; ii++ ) far[ii] = val ;
ibot = itop ;
}
far[nvox1] = 1.0 ;
/*** now propagate these values back to the output image ***/
for( ii=0 ; ii < nvox ; ii++ ) outar[iar[ii]] = far[ii] ;
mri_free( flim ) ; mri_free( intim ) ;
MRI_COPY_AUX( outim , im ) ;
return outim ;
}
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) ;
}
