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 ; }
int esweep_minPos(const esweep_object *obj, int from, int to, int *pos) { /* UNTESTED */ Wave *wave; Polar *polar; Complex *cplx; Real min, tmp; int i; ESWEEP_OBJ_NOTEMPTY(obj, ERR_EMPTY_OBJECT); ESWEEP_ASSERT(from < obj->size, ERR_BAD_PARAMETER); ESWEEP_ASSERT(to < obj->size, ERR_BAD_PARAMETER); if (from < 0) from=0; if (to < 0) to=obj->size-1; ESWEEP_ASSERT(to > from, ERR_BAD_PARAMETER); switch (obj->type) { case WAVE: wave=(Wave*) obj->data; for (i=from+1, *pos=0, min=wave[from]; i<obj->size; i++) if (wave[i]<min) { min=wave[i]; *pos=i; } break; case COMPLEX: cplx=(Complex*) obj->data; for (i=from+1, *pos=0, min=CABS(cplx[from]); i<obj->size; i++) { tmp=CABS(cplx[i]); if (tmp<min) { min=tmp; *pos=i; } } break; case POLAR: polar=(Polar*) obj->data; for (i=from+1, *pos=0, min=polar[from].abs; i<obj->size; i++) { if (polar[i].abs<min) { min=polar[i].abs; *pos=i; } } break; default: ESWEEP_NOT_THIS_TYPE(obj->type, ERR_NOT_ON_THIS_TYPE); } return ERR_OK; }
void absfft_func( int num , double to,double dt, float *vec ) { static complex *cx=NULL ; static int ncx=0 , numold=0 ; float f0,f1 ; int ii ; if( num < 2 ) return ; if( num != numold ){ numold = num ; ncx = csfft_nextup_even(numold) ; cx = (complex *)realloc(cx,sizeof(complex)*ncx) ; } get_linear_trend( num , vec , &f0,&f1 ) ; /* thd_detrend.c */ for( ii=0 ; ii < num ; ii++ ){ cx[ii].r = vec[ii]-(f0+f1*ii); cx[ii].i = 0.0; } for( ; ii < ncx ; ii++ ){ cx[ii].r = cx[ii].i = 0.0 ; } csfft_cox( -1 , ncx , cx ) ; /* csfft.c */ vec[0] = 0.0 ; for( ii=1 ; ii < num ; ii++ ) vec[ii] = CABS(cx[ii]) ; return ; }
int esweep_min(const esweep_object *obj, int from, int to, Real *min) { /* UNTESTED */ Wave *wave; Polar *polar; Surface *surf; Complex *cplx; Real tmp; int i, size; ESWEEP_OBJ_NOTEMPTY(obj, ERR_EMPTY_OBJECT); ESWEEP_ASSERT(from < obj->size, ERR_BAD_PARAMETER); ESWEEP_ASSERT(to < obj->size, ERR_BAD_PARAMETER); if (from < 0) from=0; if (to < 0) to=obj->size-1; ESWEEP_ASSERT(to > from, ERR_BAD_PARAMETER); switch (obj->type) { case WAVE: wave=(Wave*) obj->data; for (i=from+1, *min=wave[from]; i<= to; i++) if (wave[i]< *min) *min=wave[i]; break; case COMPLEX: cplx=(Complex*) obj->data; for (i=from+1, *min=CABS(cplx[from]); i<= to; i++) { tmp=CABS(cplx[i]); if (tmp<*min) *min=tmp; } break; case POLAR: polar=(Polar*) obj->data; for (i=from+1, *min=polar[from].abs; i<= to; i++) if (polar[i].abs<*min) *min=polar[i].abs; break; case SURFACE: surf=(Surface*) obj->data; for (i=1, *min=surf->z[0], size=surf->xsize*surf->ysize; i<size; i++) if (surf->z[i]<*min) *min=surf->z[i]; break; default: ESWEEP_NOT_THIS_TYPE(obj->type, ERR_NOT_ON_THIS_TYPE); } return ERR_OK; }
FLOAT sample (complex FLOAT *z_ptr, complex FLOAT *c_ptr) { complex FLOAT z = *z_ptr, c = *c_ptr; complex FLOAT oz = 255 + 255 * I; unsigned i, deadline = 1; FLOAT d = (FLOAT)((unsigned long long)-1); for (i = 0; likely(i != (unsigned)-1); i++) { if (unlikely(CABS(z) > ESCAPE)) break; z = z * z + c; if (i > trap.start) { FLOAT n = CABS(z); if (n < d) d = n; } if (unlikely(oz == z)) return d / 2; if (i > deadline) { oz = z; deadline <<= 1; } } return trap.range < d ? -1 : trap.range - d; }
static void toy_tsfunc( double tzero, double tdelta , int npts, float ts[], double ts_mean , double ts_slope , void *ud, int nbriks, float *val ) { static complex *comp_array=NULL; float mag=0, pow=0, pow6=0; int jj; TOY_UD *rpud = (TOY_UD *)ud; if( val == NULL ){ INFO_message("toy_tsfunc: %s notification call, npts=%d\n", npts?"Start":"End", npts); if( npts > 0 ){ /* the "start notification" */ /* This is when you perform any setup you don't want to repeat each time the function is called for a new voxel. Such a setup typically involves allocating for temporary arrays */ /* allocate for fft array */ comp_array = (complex *) calloc( sizeof(complex) , rpud->nfft); } else { /* the "end notification" */ /* Last call, meant for cleanup */ if (comp_array) free(comp_array); comp_array = NULL; } return ; } /* if we get here then we have data to process */ /* Load time series */ for( jj=0 ; jj < npts ; jj++ ) { comp_array[jj].r = ts[jj]; comp_array[jj].i = 0.0f ; } /* zero pad */ for( jj=npts ; jj < rpud->nfft ; jj++ ) comp_array[jj].r = comp_array[jj].i = 0.0f ; csfft_cox( -1 , rpud->nfft, comp_array ) ; /* DFT */ for( jj=0 ; jj < rpud->nfft ; jj++ ) { mag = CABS(comp_array[jj]) ; pow += mag*mag; if (jj<rpud->nfft/6) pow6 += mag*mag ; } val[0] = pow; val[1] = pow6; return ; }
float THD_get_float_value( int ind , int ival , THD_3dim_dataset *dset ) { MRI_TYPE typ ; float val=0.0f ; if( ind < 0 || ival < 0 || !ISVALID_DSET(dset) || ival >= DSET_NVALS(dset) || ind >= DSET_NVOX(dset) ) return val ; typ = DSET_BRICK_TYPE(dset,ival) ; /* raw data type */ switch( typ ){ default: /* don't know what to do --> return nada */ return(-1); break ; case MRI_byte:{ byte *bar ; bar = (byte *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) val = (float)bar[ind] ; } break ; case MRI_short:{ short *bar ; bar = (short *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) val = (float)bar[ind] ; } break ; case MRI_float:{ float *bar ; bar = (float *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) val = bar[ind] ; } break ; case MRI_complex:{ complex *bar ; bar = (complex *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) val = CABS(bar[ind]) ; } break ; } if( DSET_BRICK_FACTOR(dset,ival) > 0.0f ) val *= DSET_BRICK_FACTOR(dset,ival) ; return val ; }
void fft2D_absfunc( int nx , int ny , double dx, double dy, float *ar ) { complex *cxar , *cpt ; int nxup,nyup , ii,jj ; float fi,fj , *fpt ; if( nx < 5 || ny < 5 ) return ; nxup = csfft_nextup_even(nx) ; /* get FFT size */ nyup = csfft_nextup_even(ny) ; cxar = (complex *) malloc(sizeof(complex)*nxup*nyup) ; /* copy input to output, sign-alternating and zero-padding along the way */ cpt = cxar ; fpt = ar ; fj = 1.0 ; for( jj=0 ; jj < ny ; jj++ ){ fi = fj ; fj = -fj ; for(ii=0; ii<nx ; ii++){cpt->r=*fpt*fi; cpt->i=0.0; cpt++;fpt++;fi=-fi;} for( ; ii<nxup; ii++){cpt->r=cpt->i=0.0; cpt++;} } for( ; jj < nyup ; jj++ ){cpt->r=cpt->i=0.0; cpt++;} /* row FFTs */ for( jj=0 ; jj < ny ; jj++ ) csfft_cox( -1 , nxup , cxar+jj*nxup ) ; /* column FFTs */ cpt = (complex *) malloc(sizeof(complex)*nyup) ; for( ii=0 ; ii < nxup ; ii++ ){ for( jj=0 ; jj < nyup ; jj++ ) cpt[jj] = cxar[ii+jj*nxup] ; csfft_cox( -1 , nyup , cpt ) ; for( jj=0 ; jj < nyup ; jj++ ) cxar[ii+jj*nxup] = cpt[jj] ; } /* copy to output */ for( jj=0 ; jj < ny ; jj++ ) for( ii=0 ; ii < nx ; ii++ ) ar[ii+jj*nx] = CABS(cxar[ii+jj*nxup]) ; free(cxar) ; free(cpt) ; return ; }
int esweep_lg(esweep_object *obj) { /* logarithm to base 10 */ Wave *wave; Polar *polar; Surface *surface; Complex *cpx; int i, zsize; Real abs, arg; ESWEEP_OBJ_NOTEMPTY(obj, ERR_EMPTY_OBJECT); switch (obj->type) { case WAVE: wave=(Wave*) obj->data; for (i=0; i<obj->size; i++) { wave[i]=LG(FABS(wave[i])); } break; case POLAR: polar=(Polar*) obj->data; for (i=0; i<obj->size; i++) { polar[i].abs=LG(polar[i].abs); } break; case SURFACE: surface=(Surface*) obj->data; zsize=surface->xsize*(surface->ysize); for (i=0; i<zsize; i++) surface->z[i]=LG(surface->z[i]); break; case COMPLEX: cpx=(Complex*) obj->data; for (i=0; i<obj->size; i++) { abs=CABS(cpx[i]); arg=ATAN2(cpx[i]); cpx[i].real=LG(abs); cpx[i].imag=arg; } break; default: ESWEEP_NOT_THIS_TYPE(obj->type, ERR_NOT_ON_THIS_TYPE); } ESWEEP_ASSERT(correctFpException(obj), ERR_FP); return ERR_OK; }
int esweep_abs(esweep_object *obj) { /* UNTESTED */ Complex *cpx; Polar *polar; Wave *wave; Surface *surf; int i, size; ESWEEP_OBJ_NOTEMPTY(obj, ERR_EMPTY_OBJECT); switch (obj->type) { case WAVE: wave=(Wave*) obj->data; for (i=0; i<obj->size; i++) wave[i]=FABS(wave[i]); break; case COMPLEX: cpx=(Complex*) obj->data; polar=(Polar*) cpx; for (i=0; i<obj->size; i++) { polar[i].abs=CABS(cpx[i]); polar[i].arg=0.0; } break; case POLAR: polar=(Polar*) obj->data; for (i=0; i<obj->size; i++) polar[i].arg=0; break; case SURFACE: surf=(Surface*) obj->data; ESWEEP_OBJ_ISVALID_SURFACE(obj, surf, ERR_NOT_ON_THIS_TYPE, ERR_OBJ_NOT_VALID); for (i=0, size=surf->xsize*surf->ysize; i < size; i++) surf->z[i]=FABS(surf->z[i]); break; default: ESWEEP_NOT_THIS_TYPE(obj->type, ERR_NOT_ON_THIS_TYPE); } ESWEEP_ASSERT(correctFpException(obj), ERR_FP); return ERR_OK; }
static inline Real __esweep_intern__sum(const esweep_object *obj) { Wave *wave; Polar *polar; Complex *cplx; Surface *surf; int i, size; Real sum=0.0; size=obj->size; switch (obj->type) { case WAVE: wave=(Wave*) obj->data; for (i=0; i<size; i++) sum+=wave[i]; break; case POLAR: polar=(Polar*) obj->data; for (i=0; i<size; i++) sum+=polar[i].abs; break; case COMPLEX: cplx=(Complex*) obj->data; for (i=0; i<size; i++) sum+=CABS(cplx[i]); break; case SURFACE: surf=(Surface*) obj->data; for (i=0, size=surf->xsize*surf->ysize; i<size; i++) sum+=surf->z[i]; break; default: return __NAN(""); } return sum; }
double mri_maxabs( MRI_IMAGE * im ) { register int ii , npix ; byte byte_max = 0 ; int int_max = 0 ; double double_max = 0.0 ; ENTRY("mri_maxabs") ; npix = im->nvox ; switch( im->kind ){ case MRI_byte:{ byte *qar = MRI_BYTE_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) byte_max = MAX( byte_max , qar[ii] ) ; RETURN( (double) byte_max ); } case MRI_short:{ short *qar = MRI_SHORT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) int_max = MAX( int_max , abs(qar[ii]) ) ; RETURN( (double) int_max ); } case MRI_int:{ int *qar = MRI_INT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) int_max = MAX( int_max , abs(qar[ii]) ) ; RETURN( (double) int_max ); } case MRI_float:{ float *qar = MRI_FLOAT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) double_max = MAX( double_max , fabs(qar[ii]) ) ; RETURN( double_max ); } case MRI_double:{ double *qar = MRI_DOUBLE_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) double_max = MAX( double_max , fabs(qar[ii]) ) ; RETURN( double_max ); } case MRI_complex:{ complex *qar = MRI_COMPLEX_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) double_max = MAX( double_max , CABS(qar[ii]) ) ; RETURN( double_max ); } case MRI_rgb: RETURN( mri_max( im ) ); default: ERROR_message("mri_max: unknown image kind") ; } RETURN( 0 ); }
intfloat mri_indmin_nz( MRI_IMAGE *im ) { register int ii , npix ; byte byte_min = 255 ; short short_min = 32767 ; /* 23 Oct 1998: changed from 0 */ int int_min = 2147483647 ; /* ditto */ float float_min = 1.e+38 ; /* changed from -9999999.0 */ double double_min = 1.e+38 ; /* ditto */ intfloat result = { -1 , 0.0f } ; int imin=-1 ; ENTRY("mri_indmin_nz") ; npix = im->nvox ; switch( im->kind ){ case MRI_byte:{ byte *qar = MRI_BYTE_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ){ if( qar[ii] == 0 ) continue ; if( qar[ii] < byte_min ){ byte_min = qar[ii]; imin = ii; } } result.i = imin; result.a = (float)byte_min; RETURN(result); } case MRI_short:{ short *qar = MRI_SHORT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ){ if( qar[ii] == 0 ) continue ; if( qar[ii] < short_min ){ short_min = qar[ii]; imin = ii; } } result.i = imin; result.a = (float)short_min; RETURN(result); } case MRI_int:{ int *qar = MRI_INT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ){ if( qar[ii] == 0 ) continue ; if( qar[ii] < int_min ){ int_min = qar[ii]; imin = ii; } } result.i = imin; result.a = (float)int_min; RETURN(result); } case MRI_float:{ float *qar = MRI_FLOAT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ){ if( qar[ii] == 0.0f ) continue ; if( qar[ii] < float_min ){ float_min = qar[ii]; imin = ii; } } result.i = imin; result.a = float_min; RETURN(result); } case MRI_double:{ double *qar = MRI_DOUBLE_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ){ if( qar[ii] == 0.0 ) continue ; if( qar[ii] < double_min ){ double_min = qar[ii]; imin = ii; } } result.i = imin; result.a = (float)double_min; RETURN(result); } case MRI_complex:{ complex *qar = MRI_COMPLEX_PTR(im) ; float aval ; for( ii=0 ; ii < npix ; ii++ ){ aval = CABS(qar[ii]) ; if( aval == 0.0f ) continue ; if( aval < float_min ){ float_min = aval; imin = ii; } } result.i = imin; result.a = float_min; RETURN(result); } case MRI_rgb:{ byte *rgb = MRI_RGB_PTR(im) ; double val , bot=255.0 ; for( ii=0 ; ii < npix ; ii++ ){ /* scale to brightness */ val = 0.299 * rgb[3*ii] /* between 0 and 255 */ + 0.587 * rgb[3*ii+1] + 0.114 * rgb[3*ii+2] ; if( val != 0.0 && val < bot ){ bot = val; imin = ii; } } result.i = imin; result.a = (float)bot; RETURN(result); } } RETURN(result); }
double_pair mri_minmax_nz( MRI_IMAGE *im ) { register int ii , npix ; byte byte_min = 255 ; short short_min = 32767 ; int int_min = 2147483647 ; float float_min = 1.e+38 ; double double_min = 1.e+38 ; byte byte_max = 0 ; short short_max = -32767 ; int int_max = -2147483647 ; float float_max = -1.e+38 ; double double_max = -1.e+38 ; double_pair dp = {0.0,0.0} ; ENTRY("mri_minmax_nz") ; npix = im->nvox ; switch( im->kind ){ case MRI_byte:{ byte *qar = MRI_BYTE_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ){ if( qar[ii] == 0 ) continue ; byte_min = MIN( byte_min , qar[ii] ) ; byte_max = MAX( byte_max , qar[ii] ) ; } if( byte_min <= byte_max ){ dp.a = (double)byte_min ; dp.b = (double)byte_max ; } RETURN(dp) ; } case MRI_short:{ short *qar = MRI_SHORT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ){ if( qar[ii] == 0 ) continue ; short_min = MIN( short_min , qar[ii] ) ; short_max = MAX( short_max , qar[ii] ) ; } if( short_min <= short_max ){ dp.a = (double)short_min ; dp.b = (double)short_max ; } RETURN(dp) ; } case MRI_float:{ float *qar = MRI_FLOAT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ){ if( qar[ii] == 0 ) continue ; float_min = MIN( float_min , qar[ii] ) ; float_max = MAX( float_max , qar[ii] ) ; } if( float_min <= float_max ){ dp.a = (double)float_min ; dp.b = (double)float_max ; } RETURN(dp) ; } case MRI_complex:{ complex *qar = MRI_COMPLEX_PTR(im) ; float aval ; for( ii=0 ; ii < npix ; ii++ ){ aval = CABS(qar[ii]) ; if( aval == 0.0f ) continue ; float_min = MIN( float_min , aval ) ; float_max = MAX( float_max , aval ) ; } if( float_min <= float_max ){ dp.a = (double)float_min ; dp.b = (double)float_max ; } RETURN(dp) ; } case MRI_rgb:{ byte *rgb = MRI_RGB_PTR(im) ; double val ; for( ii=0 ; ii < npix ; ii++ ){ /* scale to brightness */ val = 0.299 * rgb[3*ii] /* between 0 and 255 */ + 0.587 * rgb[3*ii+1] + 0.114 * rgb[3*ii+2] ; if( val == 0.0f ) continue ; float_min = MIN( float_min , val ) ; float_max = MAX( float_max , val ) ; } if( float_min <= float_max ){ dp.a = (double)float_min ; dp.b = (double)float_max ; } RETURN(dp) ; } default: ERROR_message("mri_minmax_nz: unknown image kind") ; } RETURN( dp ); }
double mri_min( MRI_IMAGE *im ) { register int ii , npix ; byte byte_min = 255 ; short short_min = 32767 ; int int_min = 2147483647 ; float float_min = 1.e+38 ; double double_min = 1.e+38 ; ENTRY("mri_min") ; npix = im->nvox ; switch( im->kind ){ case MRI_byte:{ byte *qar = MRI_BYTE_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) byte_min = MIN( byte_min , qar[ii] ) ; RETURN( (double) byte_min ); } case MRI_short:{ short *qar = MRI_SHORT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) short_min = MIN( short_min , qar[ii] ) ; RETURN( (double) short_min ); } case MRI_int:{ int *qar = MRI_INT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) int_min = MIN( int_min , qar[ii] ) ; RETURN( (double) int_min ); } case MRI_float:{ float *qar = MRI_FLOAT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) float_min = MIN( float_min , qar[ii] ) ; RETURN( (double) float_min ); } case MRI_double:{ double *qar = MRI_DOUBLE_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) double_min = MIN( double_min , qar[ii] ) ; RETURN( double_min ); } case MRI_complex:{ complex *qar = MRI_COMPLEX_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) float_min = MIN( float_min , CABS(qar[ii]) ) ; RETURN( float_min ); } case MRI_rgb:{ byte *rgb = MRI_RGB_PTR(im) ; double val , bot=255.9 ; for( ii=0 ; ii < npix ; ii++ ){ /* scale to brightness */ val = 0.299 * rgb[3*ii] /* between 0 and 255 */ + 0.587 * rgb[3*ii+1] + 0.114 * rgb[3*ii+2] ; if( val < bot ) bot = val ; } RETURN( bot ); } default: ERROR_message("mri_min: unknown image kind") ; } RETURN( 0 ); }
double mri_max( MRI_IMAGE *im ) { register int ii , npix ; byte byte_max = 0 ; short short_max = -32767 ; /* 23 Oct 1998: changed from 0 */ int int_max = -2147483647 ; /* ditto */ float float_max = -1.e+38 ; /* changed from -9999999.0 */ double double_max = -1.e+38 ; /* ditto */ ENTRY("mri_max") ; npix = im->nvox ; switch( im->kind ){ case MRI_byte:{ byte *qar = MRI_BYTE_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) byte_max = MAX( byte_max , qar[ii] ) ; RETURN( (double) byte_max ); } case MRI_short:{ short *qar = MRI_SHORT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) short_max = MAX( short_max , qar[ii] ) ; RETURN( (double) short_max ); } case MRI_int:{ int *qar = MRI_INT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) int_max = MAX( int_max , qar[ii] ) ; RETURN( (double) int_max ); } case MRI_float:{ float *qar = MRI_FLOAT_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) float_max = MAX( float_max , qar[ii] ) ; RETURN( (double) float_max ); } case MRI_double:{ double *qar = MRI_DOUBLE_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) double_max = MAX( double_max , qar[ii] ) ; RETURN( double_max ); } case MRI_complex:{ complex *qar = MRI_COMPLEX_PTR(im) ; for( ii=0 ; ii < npix ; ii++ ) float_max = MAX( float_max , CABS(qar[ii]) ) ; RETURN( float_max ); } case MRI_rgb:{ byte *rgb = MRI_RGB_PTR(im) ; double val , top=0.0 ; for( ii=0 ; ii < npix ; ii++ ){ /* scale to brightness */ val = 0.299 * rgb[3*ii] /* between 0 and 255 */ + 0.587 * rgb[3*ii+1] + 0.114 * rgb[3*ii+2] ; if( val > top ) top = val ; } RETURN( top ); } default: ERROR_message("mri_max: unknown image kind") ; } RETURN( 0.0 ); }
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 ); }
int THD_extract_array( int ind, THD_3dim_dataset *dset, int raw, void *uar ) { MRI_TYPE typ ; int nv , ival , nb , nb1 ; char *iar ; /* brick in the input */ float *far=NULL ; /* non-raw output */ void *tar=NULL ; /** ENTRY("THD_extract_array") ; **/ if( ind < 0 || uar == NULL || !ISVALID_DSET(dset) || ind >= DSET_NVOX(dset) ) return(-1) ; nv = dset->dblk->nvals ; iar = DSET_ARRAY(dset,0) ; if( iar == NULL ){ /* load data from disk? */ DSET_load(dset) ; iar = DSET_ARRAY(dset,0); if( iar == NULL ) return(-1) ; } typ = DSET_BRICK_TYPE(dset,0) ; /* raw data type */ /* will extract nb bytes of raw data into array tar */ nb1 = mri_datum_size(typ); nb = nb1 * (nv+1); nb1 = nb1 * nv; tar = (void *)calloc(1,nb) ; NULL_CHECK(tar) ; if( !raw ) far = (float *)uar ; /* non-raw output */ switch( typ ){ default: /* don't know what to do --> return nada */ free(tar); return(-1); break ; case MRI_byte:{ byte *ar = (byte *)tar , *bar ; for( ival=0 ; ival < nv ; ival++ ){ bar = (byte *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) ar[ival] = bar[ind] ; } if( !raw ){ for( ival=0 ; ival < nv ; ival++ ) far[ival] = ar[ival] ; } } break ; case MRI_short:{ short *ar = (short *)tar , *bar ; for( ival=0 ; ival < nv ; ival++ ){ bar = (short *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) ar[ival] = bar[ind] ; } if( !raw ){ for( ival=0 ; ival < nv ; ival++ ) far[ival] = ar[ival] ; } } break ; case MRI_float:{ float *ar = (float *)tar , *bar ; for( ival=0 ; ival < nv ; ival++ ){ bar = (float *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) ar[ival] = bar[ind] ; } if( !raw ){ for( ival=0 ; ival < nv ; ival++ ) far[ival] = ar[ival] ; } } break ; #if 0 case MRI_int:{ int *ar = (int *)tar , *bar ; for( ival=0 ; ival < nv ; ival++ ){ bar = (int *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) ar[ival] = bar[ind] ; } if( !raw ){ for( ival=0 ; ival < nv ; ival++ ) far[ival] = ar[ival] ; } } break ; case MRI_double:{ double *ar = (double *)tar , *bar ; for( ival=0 ; ival < nv ; ival++ ){ bar = (double *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) ar[ival] = bar[ind] ; } if( !raw ){ for( ival=0 ; ival < nv ; ival++ ) far[ival] = ar[ival] ; } } break ; #endif case MRI_complex:{ complex *ar = (complex *)tar , *bar ; for( ival=0 ; ival < nv ; ival++ ){ bar = (complex *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) ar[ival] = bar[ind] ; } if( !raw ){ for( ival=0 ; ival < nv ; ival++ ) far[ival] = CABS(ar[ival]) ; } } break ; } if( raw ){ memcpy(uar,tar,nb1); free(tar); return(0); } if( THD_need_brick_factor(dset) ){ for( ival=0 ; ival < nv ; ival++ ) if( DSET_BRICK_FACTOR(dset,ival) > 0.0 ) far[ival] *= DSET_BRICK_FACTOR(dset,ival) ; } free(tar); return(0); }
int main(int argc, char **argv) { int j, k, t; /**< indices */ int d; /**< number of dimensions */ int N; /**< number of source nodes */ int M; /**< number of target nodes */ int n; /**< expansion degree */ int m; /**< cut-off parameter */ int p; /**< degree of smoothness */ const char *s; /**< name of kernel */ C (*kernel)(R, int, const R *); /**< kernel function */ R c; /**< parameter for kernel */ fastsum_plan my_fastsum_plan; /**< plan for fast summation */ C *direct; /**< array for direct computation */ ticks t0, t1; /**< for time measurement */ R time; /**< for time measurement */ R error = K(0.0); /**< for error computation */ R eps_I; /**< inner boundary */ R eps_B; /**< outer boundary */ FILE *fid1, *fid2; R temp; if (argc != 11) { printf("\nfastsum_test d N M n m p kernel c\n\n"); printf(" d dimension \n"); printf(" N number of source nodes \n"); printf(" M number of target nodes \n"); printf(" n expansion degree \n"); printf(" m cut-off parameter \n"); printf(" p degree of smoothness \n"); printf(" kernel kernel function (e.g., gaussian)\n"); printf(" c kernel parameter \n"); printf(" eps_I inner boundary \n"); printf(" eps_B outer boundary \n\n"); exit(-1); } else { d = atoi(argv[1]); N = atoi(argv[2]); c = K(1.0) / POW((R)(N), K(1.0) / ((R)(d))); M = atoi(argv[3]); n = atoi(argv[4]); m = atoi(argv[5]); p = atoi(argv[6]); s = argv[7]; c = (R)(atof(argv[8])); eps_I = (R)(atof(argv[9])); eps_B = (R)(atof(argv[10])); if (strcmp(s, "gaussian") == 0) kernel = gaussian; else if (strcmp(s, "multiquadric") == 0) kernel = multiquadric; else if (strcmp(s, "inverse_multiquadric") == 0) kernel = inverse_multiquadric; else if (strcmp(s, "logarithm") == 0) kernel = logarithm; else if (strcmp(s, "thinplate_spline") == 0) kernel = thinplate_spline; else if (strcmp(s, "one_over_square") == 0) kernel = one_over_square; else if (strcmp(s, "one_over_modulus") == 0) kernel = one_over_modulus; else if (strcmp(s, "one_over_x") == 0) kernel = one_over_x; else if (strcmp(s, "inverse_multiquadric3") == 0) kernel = inverse_multiquadric3; else if (strcmp(s, "sinc_kernel") == 0) kernel = sinc_kernel; else if (strcmp(s, "cosc") == 0) kernel = cosc; else if (strcmp(s, "cot") == 0) kernel = kcot; else { s = "multiquadric"; kernel = multiquadric; } } printf( "d=%d, N=%d, M=%d, n=%d, m=%d, p=%d, kernel=%s, c=%" __FGS__ ", eps_I=%" __FGS__ ", eps_B=%" __FGS__ " \n", d, N, M, n, m, p, s, c, eps_I, eps_B); /** init two dimensional fastsum plan */ fastsum_init_guru(&my_fastsum_plan, d, N, M, kernel, &c, 0, n, m, p, eps_I, eps_B); /*fastsum_init_guru(&my_fastsum_plan, d, N, M, kernel, &c, EXACT_NEARFIELD, n, m, p);*/ /** load source knots and coefficients */ fid1 = fopen("x.dat", "r"); fid2 = fopen("alpha.dat", "r"); for (k = 0; k < N; k++) { for (t = 0; t < d; t++) { fscanf(fid1, __FR__, &my_fastsum_plan.x[k * d + t]); } fscanf(fid2, __FR__, &temp); my_fastsum_plan.alpha[k] = temp; fscanf(fid2, __FR__, &temp); my_fastsum_plan.alpha[k] += temp * II; } fclose(fid1); fclose(fid2); /** load target knots */ fid1 = fopen("y.dat", "r"); for (j = 0; j < M; j++) { for (t = 0; t < d; t++) { fscanf(fid1, __FR__, &my_fastsum_plan.y[j * d + t]); } } fclose(fid1); /** direct computation */ printf("direct computation: "); fflush(NULL); t0 = getticks(); fastsum_exact(&my_fastsum_plan); t1 = getticks(); time = NFFT(elapsed_seconds)(t1, t0); printf(__FI__ "sec\n", time); /** copy result */ direct = (C *) NFFT(malloc)((size_t)(my_fastsum_plan.M_total) * (sizeof(C))); for (j = 0; j < my_fastsum_plan.M_total; j++) direct[j] = my_fastsum_plan.f[j]; /** precomputation */ printf("pre-computation: "); fflush(NULL); t0 = getticks(); fastsum_precompute(&my_fastsum_plan); t1 = getticks(); time = NFFT(elapsed_seconds)(t1, t0); printf(__FI__ "sec\n", time); /** fast computation */ printf("fast computation: "); fflush(NULL); t0 = getticks(); fastsum_trafo(&my_fastsum_plan); t1 = getticks(); time = NFFT(elapsed_seconds)(t1, t0); printf(__FI__ "sec\n", time); /** compute max error */ error = K(0.0); for (j = 0; j < my_fastsum_plan.M_total; j++) { if (CABS(direct[j] - my_fastsum_plan.f[j]) / CABS(direct[j]) > error) error = CABS(direct[j] - my_fastsum_plan.f[j]) / CABS(direct[j]); } printf("max relative error: " __FE__ "\n", error); /** write result to file */ fid1 = fopen("f.dat", "w+"); fid2 = fopen("f_direct.dat", "w+"); if (fid1 == NULL) { printf("Fehler!\n"); exit(EXIT_FAILURE); } for (j = 0; j < M; j++) { temp = CREAL(my_fastsum_plan.f[j]); fprintf(fid1, " % .16" __FES__ "", temp); temp = CIMAG(my_fastsum_plan.f[j]); fprintf(fid1, " % .16" __FES__ "\n", temp); temp = CREAL(direct[j]); fprintf(fid2, " % .16" __FES__ "", temp); temp = CIMAG(direct[j]); fprintf(fid2, " % .16" __FES__ "\n", temp); } fclose(fid1); fclose(fid2); /** finalise the plan */ fastsum_finalize(&my_fastsum_plan); return EXIT_SUCCESS; }
THD_3dim_dataset * MAKER_4D_to_typed_fim( THD_3dim_dataset * old_dset , char * new_prefix , int new_datum , int ignore , int detrend , generic_func * user_func , void * user_data ) { THD_3dim_dataset * new_dset ; /* output dataset */ byte ** bptr = NULL ; /* one of these will be the array of */ short ** sptr = NULL ; /* pointers to input dataset sub-bricks */ float ** fptr = NULL ; /* (depending on input datum type) */ complex ** cptr = NULL ; float * fxar = NULL ; /* array loaded from input dataset */ float * fac = NULL ; /* array of brick scaling factors */ float * fout = NULL ; /* will be array of output floats */ float * dtr = NULL ; /* will be array of detrending coeff */ float val , d0fac , d1fac , x0,x1; double tzero=0 , tdelta , ts_mean , ts_slope ; int ii , old_datum , nuse , use_fac , iz,izold, nxy,nvox , nbad ; register int kk ; void (*ufunc)(double,double,int,float *,double,double,void *,float *) = (void (*)(double,double,int,float *,double,double,void *,float *)) user_func ; /*----------------------------------------------------------*/ /*----- Check inputs to see if they are reasonable-ish -----*/ if( ! ISVALID_3DIM_DATASET(old_dset) ) return NULL ; if( new_datum >= 0 && new_datum != MRI_byte && new_datum != MRI_short && new_datum != MRI_float ) return NULL ; if( user_func == NULL ) return NULL ; if( ignore < 0 ) ignore = 0 ; /*--------- set up pointers to each sub-brick in the input dataset ---------*/ old_datum = DSET_BRICK_TYPE( old_dset , 0 ) ; /* get old dataset datum */ nuse = DSET_NUM_TIMES(old_dset) - ignore ; /* # of points on time axis */ if( nuse < 2 ) return NULL ; if( new_datum < 0 ) new_datum = old_datum ; /* output datum = input */ if( new_datum == MRI_complex ) return NULL ; /* but complex = bad news */ DSET_load( old_dset ) ; /* must be in memory before we get pointers to it */ kk = THD_count_databricks( old_dset->dblk ) ; /* check if it was */ if( kk < DSET_NVALS(old_dset) ){ /* loaded correctly */ DSET_unload( old_dset ) ; return NULL ; } switch( old_datum ){ /* pointer type depends on input datum type */ default: /** don't know what to do **/ DSET_unload( old_dset ) ; return NULL ; /** create array of pointers into old dataset sub-bricks **/ /*--------- input is bytes ----------*/ /* voxel #i at time #k is bptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_byte: bptr = (byte **) malloc( sizeof(byte *) * nuse ) ; if( bptr == NULL ) return NULL ; for( kk=0 ; kk < nuse ; kk++ ) bptr[kk] = (byte *) DSET_ARRAY(old_dset,kk+ignore) ; break ; /*--------- input is shorts ---------*/ /* voxel #i at time #k is sptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_short: sptr = (short **) malloc( sizeof(short *) * nuse ) ; if( sptr == NULL ) return NULL ; for( kk=0 ; kk < nuse ; kk++ ) sptr[kk] = (short *) DSET_ARRAY(old_dset,kk+ignore) ; break ; /*--------- input is floats ---------*/ /* voxel #i at time #k is fptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_float: fptr = (float **) malloc( sizeof(float *) * nuse ) ; if( fptr == NULL ) return NULL ; for( kk=0 ; kk < nuse ; kk++ ) fptr[kk] = (float *) DSET_ARRAY(old_dset,kk+ignore) ; break ; /*--------- input is complex ---------*/ /* voxel #i at time #k is cptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_complex: cptr = (complex **) malloc( sizeof(complex *) * nuse ) ; if( cptr == NULL ) return NULL ; for( kk=0 ; kk < nuse ; kk++ ) cptr[kk] = (complex *) DSET_ARRAY(old_dset,kk+ignore) ; break ; } /* end of switch on input type */ /*---- allocate space for 1 voxel timeseries ----*/ fxar = (float *) malloc( sizeof(float) * nuse ) ; /* voxel timeseries */ if( fxar == NULL ){ FREE_WORKSPACE ; return NULL ; } /*--- get scaling factors for sub-bricks ---*/ fac = (float *) malloc( sizeof(float) * nuse ) ; /* factors */ if( fac == NULL ){ FREE_WORKSPACE ; return NULL ; } use_fac = 0 ; for( kk=0 ; kk < nuse ; kk++ ){ fac[kk] = DSET_BRICK_FACTOR(old_dset,kk+ignore) ; if( fac[kk] != 0.0 ) use_fac++ ; else fac[kk] = 1.0 ; } if( !use_fac ) FREEUP(fac) ; /*--- setup for detrending ---*/ dtr = (float *) malloc( sizeof(float) * nuse ) ; if( dtr == NULL ){ FREE_WORKSPACE ; return NULL ; } d0fac = 1.0 / nuse ; d1fac = 12.0 / nuse / (nuse*nuse - 1.0) ; for( kk=0 ; kk < nuse ; kk++ ) dtr[kk] = kk - 0.5 * (nuse-1) ; /* linear trend, orthogonal to 1 */ /*---------------------- make a new dataset ----------------------*/ new_dset = EDIT_empty_copy( old_dset ) ; /* start with copy of old one */ /*-- edit some of its internal parameters --*/ ii = EDIT_dset_items( new_dset , ADN_prefix , new_prefix , /* filename prefix */ ADN_malloc_type , DATABLOCK_MEM_MALLOC , /* store in memory */ ADN_datum_all , new_datum , /* atomic datum */ ADN_nvals , 1 , /* # sub-bricks */ ADN_ntt , 0 , /* # time points */ ADN_type , ISHEAD(old_dset) /* dataset type */ ? HEAD_FUNC_TYPE : GEN_FUNC_TYPE , ADN_func_type , FUNC_FIM_TYPE , /* function type */ ADN_none ) ; if( ii != 0 ){ ERROR_message("Error creating dataset '%s'",new_prefix) ; THD_delete_3dim_dataset( new_dset , False ) ; /* some error above */ FREE_WORKSPACE ; return NULL ; } /*------ make floating point output brick (only at the end will scale to byte or shorts) ------*/ nvox = old_dset->daxes->nxx * old_dset->daxes->nyy * old_dset->daxes->nzz ; fout = (float *) malloc( sizeof(float) * nvox ) ; /* ptr to brick */ if( fout == NULL ){ THD_delete_3dim_dataset( new_dset , False ) ; FREE_WORKSPACE ; return NULL ; } /*----- set up to find time at each voxel -----*/ tdelta = old_dset->taxis->ttdel ; if( DSET_TIMEUNITS(old_dset) == UNITS_MSEC_TYPE ) tdelta *= 0.001 ; if( tdelta == 0.0 ) tdelta = 1.0 ; izold = -666 ; nxy = old_dset->daxes->nxx * old_dset->daxes->nyy ; /*----------------------------------------------------*/ /*----- Setup has ended. Now do some real work. -----*/ /* start notification */ #if 0 user_func( 0.0 , 0.0 , nvox , NULL,0.0,0.0 , user_data , NULL ) ; #else ufunc( 0.0 , 0.0 , nvox , NULL,0.0,0.0 , user_data , NULL ) ; #endif /***** loop over voxels *****/ for( ii=0 ; ii < nvox ; ii++ ){ /* 1 time series at a time */ /*** load data from input dataset, depending on type ***/ switch( old_datum ){ /*** input = bytes ***/ case MRI_byte: for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] = bptr[kk][ii] ; break ; /*** input = shorts ***/ case MRI_short: for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] = sptr[kk][ii] ; break ; /*** input = floats ***/ case MRI_float: for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] = fptr[kk][ii] ; break ; /*** input = complex (note we use absolute value) ***/ case MRI_complex: for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] = CABS(cptr[kk][ii]) ; break ; } /* end of switch over input type */ /*** scale? ***/ if( use_fac ) for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] *= fac[kk] ; /** compute mean and slope **/ x0 = x1 = 0.0 ; for( kk=0 ; kk < nuse ; kk++ ){ x0 += fxar[kk] ; x1 += fxar[kk] * dtr[kk] ; } x0 *= d0fac ; x1 *= d1fac ; /* factors to remove mean and trend */ ts_mean = x0 ; ts_slope = x1 / tdelta ; /** detrend? **/ if( detrend ) for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] -= (x0 + x1 * dtr[kk]) ; /** compute start time of this timeseries **/ iz = ii / nxy ; /* which slice am I in? */ if( iz != izold ){ /* in a new slice? */ tzero = THD_timeof( ignore , old_dset->daxes->zzorg + iz*old_dset->daxes->zzdel , old_dset->taxis ) ; izold = iz ; if( DSET_TIMEUNITS(old_dset) == UNITS_MSEC_TYPE ) tzero *= 0.001 ; } /*** compute output ***/ #if 0 user_func( tzero,tdelta , nuse,fxar,ts_mean,ts_slope , user_data , fout+ii ) ; #else ufunc( tzero,tdelta , nuse,fxar,ts_mean,ts_slope , user_data , fout+ii ) ; #endif } /* end of outer loop over 1 voxels at a time */ DSET_unload( old_dset ) ; /* don't need this no more */ /* end notification */ #if 0 user_func( 0.0 , 0.0 , 0 , NULL,0.0,0.0 , user_data , NULL ) ; #else ufunc( 0.0 , 0.0 , 0 , NULL,0.0,0.0 , user_data , NULL ) ; #endif nbad = thd_floatscan( nvox , fout ) ; /* 08 Aug 2000 */ if( nbad > 0 ) fprintf(stderr, "++ Warning: %d bad floats computed in MAKER_4D_to_typed_fim\n\a", nbad ) ; /*------------------------------------------------------------*/ /*------- The output is now in fout[ii], ii=0..nvox-1. We must now put this into the output dataset -------*/ switch( new_datum ){ /*** output is floats is the simplest: we just have to attach the fout brick to the dataset ***/ case MRI_float: EDIT_substitute_brick( new_dset , 0 , MRI_float , fout ) ; fout = NULL ; /* so it won't be freed later */ break ; /*** output is shorts: we have to create a scaled sub-brick from fout ***/ case MRI_short:{ short * bout ; float sfac ; /*-- get output sub-brick --*/ bout = (short *) malloc( sizeof(short) * nvox ) ; if( bout == NULL ){ fprintf(stderr, "\nFinal malloc error in MAKER_4D_to_fim - is memory exhausted?\n\a"); EXIT(1) ; } /*-- find scaling and then scale --*/ sfac = MCW_vol_amax( nvox,1,1 , MRI_float , fout ) ; if( sfac > 0.0 ){ sfac = 32767.0 / sfac ; EDIT_coerce_scale_type( nvox,sfac , MRI_float,fout , MRI_short,bout ) ; sfac = 1.0 / sfac ; } /*-- put output brick into dataset, and store scale factor --*/ EDIT_substitute_brick( new_dset , 0 , MRI_short , bout ) ; EDIT_dset_items( new_dset , ADN_brick_fac , &sfac , ADN_none ) ; } break ; /*** output is bytes (byte = unsigned char) we have to create a scaled sub-brick from fout ***/ case MRI_byte:{ byte * bout ; float sfac ; /*-- get output sub-brick --*/ bout = (byte *) malloc( sizeof(byte) * nvox ) ; if( bout == NULL ){ fprintf(stderr, "\nFinal malloc error in MAKER_4D_to_fim - is memory exhausted?\n\a"); EXIT(1) ; } /*-- find scaling and then scale --*/ sfac = MCW_vol_amax( nvox,1,1 , MRI_float , fout ) ; if( sfac > 0.0 ){ sfac = 255.0 / sfac ; EDIT_coerce_scale_type( nvox,sfac , MRI_float,fout , MRI_byte,bout ) ; sfac = 1.0 / sfac ; } /*-- put output brick into dataset, and store scale factor --*/ EDIT_substitute_brick( new_dset , 0 , MRI_byte , bout ) ; EDIT_dset_items( new_dset , ADN_brick_fac , &sfac , ADN_none ) ; } break ; } /* end of switch on output data type */ /*-------------- Cleanup and go home ----------------*/ FREE_WORKSPACE ; return new_dset ; }
void EDIT_coerce_scale_type( int nxyz , float scl , int itype,void *ivol , int otype,void *ovol ) { register int ii ; register float fac = scl , val ; complex *cin=NULL , *cout ; short *sin=NULL , *sout ; float *fin=NULL , *fout ; byte *bin=NULL , *bout ; double *din=NULL , *dout ; /* 11 Jan 1999 */ ENTRY("EDIT_coerce_scale_type") ; #ifdef AFNI_DEBUG { char str[256] ; sprintf(str,"voxels=%d scale=%g input type=%s output type=%s", nxyz,scl , MRI_TYPE_name[itype],MRI_TYPE_name[otype]) ; STATUS(str) ; } #endif if( nxyz <= 0 || ivol == NULL || ovol == NULL ) EXRETURN ; if( fac == 0.0 || fac == 1.0 ) { EDIT_coerce_type( nxyz , itype,ivol , otype,ovol ) ; EXRETURN ; } switch( itype ) { default: fprintf(stderr,"** Unknown itype=%d in EDIT_coerce_scale_type\n",itype); EXRETURN ; case MRI_complex: cin = (complex *) ivol ; break ; case MRI_short : sin = (short *) ivol ; break ; case MRI_float : fin = (float *) ivol ; break ; case MRI_byte : bin = (byte *) ivol ; break ; case MRI_double : din = (double *) ivol ; break ; } switch( otype ) { default: fprintf(stderr,"** Unknown otype=%d in EDIT_coerce_scale_type\n",otype); EXRETURN ; case MRI_complex: cout = (complex *) ovol ; break ; case MRI_short : sout = (short *) ovol ; break ; case MRI_float : fout = (float *) ovol ; break ; case MRI_byte : bout = (byte *) ovol ; break ; case MRI_double : dout = (double *) ovol ; break ; } switch( otype ) { /*** outputs are shorts ***/ case MRI_short: switch( itype ) { case MRI_short: /* inputs are shorts */ for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fac*sin[ii]) ; EXRETURN ; case MRI_float: /* inputs are floats */ for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fac*fin[ii]) ; EXRETURN ; case MRI_double: /* inputs are double */ for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fac*din[ii]) ; EXRETURN ; case MRI_byte: /* inputs are bytes */ for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fac*bin[ii]) ; EXRETURN ; case MRI_complex: /* inputs are complex */ for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fac*CABS(cin[ii])) ; EXRETURN ; } EXRETURN ; /*** outputs are floats ***/ case MRI_float: switch( itype ) { case MRI_short: /* inputs are shorts */ for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = fac*sin[ii] ; EXRETURN ; case MRI_float: /* inputs are floats */ for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = fac*fin[ii] ; EXRETURN ; case MRI_double: /* inputs are doubles */ for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = fac*din[ii] ; EXRETURN ; case MRI_byte: /* inputs are bytes */ for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = fac*bin[ii] ; EXRETURN ; case MRI_complex: /* inputs are complex */ for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = fac*CABS(cin[ii]) ; EXRETURN ; } EXRETURN ; /*** outputs are doubles ***/ case MRI_double: switch( itype ) { case MRI_short: /* inputs are shorts */ for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fac*sin[ii] ; EXRETURN ; case MRI_float: /* inputs are floats */ for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fac*fin[ii] ; EXRETURN ; case MRI_double: /* inputs are doubles */ for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fac*din[ii] ; EXRETURN ; case MRI_byte: /* inputs are bytes */ for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fac*bin[ii] ; EXRETURN ; case MRI_complex: /* inputs are complex */ for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fac*CABS(cin[ii]) ; EXRETURN ; } EXRETURN ; /*** outputs are bytes ***/ case MRI_byte: switch( itype ) { case MRI_short: /* inputs are shorts */ for( ii=0 ; ii < nxyz ; ii++ ) { val = fac*sin[ii] ; bout[ii] = FLOAT_TO_BYTE(val) ; } EXRETURN ; case MRI_float: /* inputs are floats */ for( ii=0 ; ii < nxyz ; ii++ ) { val = fac*fin[ii] ; bout[ii] = FLOAT_TO_BYTE(val) ; } EXRETURN ; case MRI_double: /* inputs are doubles */ for( ii=0 ; ii < nxyz ; ii++ ) { val = fac*din[ii] ; bout[ii] = FLOAT_TO_BYTE(val) ; } EXRETURN ; case MRI_byte: /* inputs are bytes */ for( ii=0 ; ii < nxyz ; ii++ ) { val = fac*bin[ii] ; bout[ii] = FLOAT_TO_BYTE(val) ; } EXRETURN ; case MRI_complex: { /* inputs are complex */ for( ii=0 ; ii < nxyz ; ii++ ) { val = fac*CABS(cin[ii]) ; bout[ii] = FLOAT_TO_BYTE(val) ; } } EXRETURN ; } EXRETURN ; /*** outputs are complex ***/ case MRI_complex: switch( itype ) { case MRI_short: /* inputs are shorts */ for( ii=0 ; ii < nxyz ; ii++ ) cout[ii].r = fac*sin[ii] , cout[ii].i = 0.0 ; EXRETURN ; case MRI_float: /* inputs are floats */ for( ii=0 ; ii < nxyz ; ii++ ) cout[ii].r = fac*fin[ii] , cout[ii].i = 0.0 ; EXRETURN ; case MRI_double: /* inputs are doubles */ for( ii=0 ; ii < nxyz ; ii++ ) cout[ii].r = fac*din[ii] , cout[ii].i = 0.0 ; EXRETURN ; case MRI_byte: /* inputs are bytes */ for( ii=0 ; ii < nxyz ; ii++ ) cout[ii].r = fac*bin[ii] , cout[ii].i = 0.0 ; EXRETURN ; case MRI_complex: /* inputs are complex */ for( ii=0 ; ii < nxyz ; ii++ ) cout[ii].r = fac*cin[ii].r , cout[ii].i = fac*cin[ii].i ; EXRETURN ; } EXRETURN ; } EXRETURN ; }
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 j, k; /**< indices */ int d; /**< number of dimensions */ int N; /**< number of source nodes */ int M; /**< number of target nodes */ int n; /**< expansion degree */ int m; /**< cut-off parameter */ int p; /**< degree of smoothness */ const char *s; /**< name of kernel */ C (*kernel)(R, int, const R *); /**< kernel function */ R c; /**< parameter for kernel */ fastsum_plan my_fastsum_plan; /**< plan for fast summation */ C *direct; /**< array for direct computation */ ticks t0, t1; /**< for time measurement */ R time; /**< for time measurement */ R error = K(0.0); /**< for error computation */ R eps_I; /**< inner boundary */ R eps_B; /**< outer boundary */ if (argc != 11) { printf("\nfastsum_test d N M n m p kernel c eps_I eps_B\n\n"); printf(" d dimension \n"); printf(" N number of source nodes \n"); printf(" M number of target nodes \n"); printf(" n expansion degree \n"); printf(" m cut-off parameter \n"); printf(" p degree of smoothness \n"); printf(" kernel kernel function (e.g., gaussian)\n"); printf(" c kernel parameter \n"); printf(" eps_I inner boundary \n"); printf(" eps_B outer boundary \n\n"); exit(EXIT_FAILURE); } else { d = atoi(argv[1]); N = atoi(argv[2]); c = K(1.0) / POW((R)(N), K(1.0) / ((R)(d))); M = atoi(argv[3]); n = atoi(argv[4]); m = atoi(argv[5]); p = atoi(argv[6]); s = argv[7]; c = (R)(atof(argv[8])); eps_I = (R)(atof(argv[9])); eps_B = (R)(atof(argv[10])); if (strcmp(s, "gaussian") == 0) kernel = gaussian; else if (strcmp(s, "multiquadric") == 0) kernel = multiquadric; else if (strcmp(s, "inverse_multiquadric") == 0) kernel = inverse_multiquadric; else if (strcmp(s, "logarithm") == 0) kernel = logarithm; else if (strcmp(s, "thinplate_spline") == 0) kernel = thinplate_spline; else if (strcmp(s, "one_over_square") == 0) kernel = one_over_square; else if (strcmp(s, "one_over_modulus") == 0) kernel = one_over_modulus; else if (strcmp(s, "one_over_x") == 0) kernel = one_over_x; else if (strcmp(s, "inverse_multiquadric3") == 0) kernel = inverse_multiquadric3; else if (strcmp(s, "sinc_kernel") == 0) kernel = sinc_kernel; else if (strcmp(s, "cosc") == 0) kernel = cosc; else if (strcmp(s, "cot") == 0) kernel = kcot; else { s = "multiquadric"; kernel = multiquadric; } } printf( "d=%d, N=%d, M=%d, n=%d, m=%d, p=%d, kernel=%s, c=%" __FGS__ ", eps_I=%" __FGS__ ", eps_B=%" __FGS__ " \n", d, N, M, n, m, p, s, c, eps_I, eps_B); #ifdef NF_KUB printf("nearfield correction using piecewise cubic Lagrange interpolation\n"); #elif defined(NF_QUADR) printf("nearfield correction using piecewise quadratic Lagrange interpolation\n"); #elif defined(NF_LIN) printf("nearfield correction using piecewise linear Lagrange interpolation\n"); #endif #ifdef _OPENMP #pragma omp parallel { #pragma omp single { printf("nthreads=%d\n", omp_get_max_threads()); } } FFTW(init_threads)(); #endif /** init d-dimensional fastsum plan */ fastsum_init_guru(&my_fastsum_plan, d, N, M, kernel, &c, 0, n, m, p, eps_I, eps_B); //fastsum_init_guru(&my_fastsum_plan, d, N, M, kernel, &c, NEARFIELD_BOXES, n, m, p, eps_I, eps_B); if (my_fastsum_plan.flags & NEARFIELD_BOXES) printf( "determination of nearfield candidates based on partitioning into boxes\n"); else printf("determination of nearfield candidates based on search tree\n"); /** init source knots in a d-ball with radius 0.25-eps_b/2 */ k = 0; while (k < N) { R r_max = K(0.25) - my_fastsum_plan.eps_B / K(2.0); R r2 = K(0.0); for (j = 0; j < d; j++) my_fastsum_plan.x[k * d + j] = K(2.0) * r_max * NFFT(drand48)() - r_max; for (j = 0; j < d; j++) r2 += my_fastsum_plan.x[k * d + j] * my_fastsum_plan.x[k * d + j]; if (r2 >= r_max * r_max) continue; k++; } for (k = 0; k < N; k++) { /* R r=(0.25-my_fastsum_plan.eps_B/2.0)*pow((R)rand()/(R)RAND_MAX,1.0/d); my_fastsum_plan.x[k*d+0] = r; for (j=1; j<d; j++) { R phi=2.0*KPI*(R)rand()/(R)RAND_MAX; my_fastsum_plan.x[k*d+j] = r; for (t=0; t<j; t++) { my_fastsum_plan.x[k*d+t] *= cos(phi); } my_fastsum_plan.x[k*d+j] *= sin(phi); } */ my_fastsum_plan.alpha[k] = NFFT(drand48)() + II * NFFT(drand48)(); } /** init target knots in a d-ball with radius 0.25-eps_b/2 */ k = 0; while (k < M) { R r_max = K(0.25) - my_fastsum_plan.eps_B / K(2.0); R r2 = K(0.0); for (j = 0; j < d; j++) my_fastsum_plan.y[k * d + j] = K(2.0) * r_max * NFFT(drand48)() - r_max; for (j = 0; j < d; j++) r2 += my_fastsum_plan.y[k * d + j] * my_fastsum_plan.y[k * d + j]; if (r2 >= r_max * r_max) continue; k++; } /* for (k=0; k<M; k++) { R r=(0.25-my_fastsum_plan.eps_B/2.0)*pow((R)rand()/(R)RAND_MAX,1.0/d); my_fastsum_plan.y[k*d+0] = r; for (j=1; j<d; j++) { R phi=2.0*KPI*(R)rand()/(R)RAND_MAX; my_fastsum_plan.y[k*d+j] = r; for (t=0; t<j; t++) { my_fastsum_plan.y[k*d+t] *= cos(phi); } my_fastsum_plan.y[k*d+j] *= sin(phi); } } */ /** direct computation */ printf("direct computation: "); fflush(NULL); t0 = getticks(); fastsum_exact(&my_fastsum_plan); t1 = getticks(); time = NFFT(elapsed_seconds)(t1, t0); printf(__FI__ "sec\n", time); /** copy result */ direct = (C *) NFFT(malloc)((size_t)(my_fastsum_plan.M_total) * (sizeof(C))); for (j = 0; j < my_fastsum_plan.M_total; j++) direct[j] = my_fastsum_plan.f[j]; /** precomputation */ printf("pre-computation: "); fflush(NULL); t0 = getticks(); fastsum_precompute(&my_fastsum_plan); t1 = getticks(); time = NFFT(elapsed_seconds)(t1, t0); printf(__FI__ "sec\n", time); /** fast computation */ printf("fast computation: "); fflush(NULL); t0 = getticks(); fastsum_trafo(&my_fastsum_plan); t1 = getticks(); time = NFFT(elapsed_seconds)(t1, t0); printf(__FI__ "sec\n", time); /** compute max error */ error = K(0.0); for (j = 0; j < my_fastsum_plan.M_total; j++) { if (CABS(direct[j] - my_fastsum_plan.f[j]) / CABS(direct[j]) > error) error = CABS(direct[j] - my_fastsum_plan.f[j]) / CABS(direct[j]); } printf("max relative error: %" __FES__ "\n", error); /** finalise the plan */ fastsum_finalize(&my_fastsum_plan); return EXIT_SUCCESS; }
static int * PLUTO_4D_to_nothing (THD_3dim_dataset * old_dset , int ignore , int detrend , generic_func * user_func, void * user_data ) { byte ** bptr = NULL ; /* one of these will be the array of */ short ** sptr = NULL ; /* pointers to input dataset sub-bricks */ float ** fptr = NULL ; /* (depending on input datum type) */ complex ** cptr = NULL ; float * fxar = NULL ; /* array loaded from input dataset */ float * fac = NULL ; /* array of brick scaling factors */ float * dtr = NULL ; /* will be array of detrending coeff */ float val , d0fac , d1fac , x0,x1; double tzero=0.0 , tdelta , ts_mean , ts_slope ; int ii , old_datum , nuse , use_fac , iz,izold, nxy,nvox ; static int retval; register int kk ; /*----------------------------------------------------------*/ /*----- Check inputs to see if they are reasonable-ish -----*/ if( ! ISVALID_3DIM_DATASET(old_dset) ) return NULL ; if( user_func == NULL ) return NULL ; if( ignore < 0 ) ignore = 0 ; /*--------- set up pointers to each sub-brick in the input dataset ---------*/ old_datum = DSET_BRICK_TYPE( old_dset , 0 ) ; /* get old dataset datum */ nuse = DSET_NUM_TIMES(old_dset) - ignore ; /* # of points on time axis */ if( nuse < 2 ) return NULL ; DSET_load( old_dset ) ; /* must be in memory before we get pointers to it */ kk = THD_count_databricks( old_dset->dblk ) ; /* check if it was */ if( kk < DSET_NVALS(old_dset) ){ /* loaded correctly */ DSET_unload( old_dset ) ; return NULL ; } switch( old_datum ){ /* pointer type depends on input datum type */ default: /** don't know what to do **/ DSET_unload( old_dset ) ; return NULL ; /** create array of pointers into old dataset sub-bricks **/ /*--------- input is bytes ----------*/ /* voxel #i at time #k is bptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_byte: bptr = (byte **) malloc( sizeof(byte *) * nuse ) ; if( bptr == NULL ) return NULL ; for( kk=0 ; kk < nuse ; kk++ ) bptr[kk] = (byte *) DSET_ARRAY(old_dset,kk+ignore) ; break ; /*--------- input is shorts ---------*/ /* voxel #i at time #k is sptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_short: sptr = (short **) malloc( sizeof(short *) * nuse ) ; if( sptr == NULL ) return NULL ; for( kk=0 ; kk < nuse ; kk++ ) sptr[kk] = (short *) DSET_ARRAY(old_dset,kk+ignore) ; break ; /*--------- input is floats ---------*/ /* voxel #i at time #k is fptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_float: fptr = (float **) malloc( sizeof(float *) * nuse ) ; if( fptr == NULL ) return NULL ; for( kk=0 ; kk < nuse ; kk++ ) fptr[kk] = (float *) DSET_ARRAY(old_dset,kk+ignore) ; break ; /*--------- input is complex ---------*/ /* voxel #i at time #k is cptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_complex: cptr = (complex **) malloc( sizeof(complex *) * nuse ) ; if( cptr == NULL ) return NULL ; for( kk=0 ; kk < nuse ; kk++ ) cptr[kk] = (complex *) DSET_ARRAY(old_dset,kk+ignore) ; break ; } /* end of switch on input type */ nvox = old_dset->daxes->nxx * old_dset->daxes->nyy * old_dset->daxes->nzz ; /*---- allocate space for 1 voxel timeseries ----*/ fxar = (float *) malloc( sizeof(float) * nuse ) ; /* voxel timeseries */ if( fxar == NULL ){ ZFREE_WORKSPACE ; return NULL ; } /*--- get scaling factors for sub-bricks ---*/ fac = (float *) malloc( sizeof(float) * nuse ) ; /* factors */ if( fac == NULL ){ ZFREE_WORKSPACE ; return NULL ; } use_fac = 0 ; for( kk=0 ; kk < nuse ; kk++ ){ fac[kk] = DSET_BRICK_FACTOR(old_dset,kk+ignore) ; if( fac[kk] != 0.0 ) use_fac++ ; else fac[kk] = 1.0 ; } if( !use_fac ) ZFREEUP(fac) ; /*--- setup for detrending ---*/ dtr = (float *) malloc( sizeof(float) * nuse ) ; if( dtr == NULL ){ ZFREE_WORKSPACE ; return NULL ; } d0fac = 1.0 / nuse ; d1fac = 12.0 / nuse / (nuse*nuse - 1.0) ; for( kk=0 ; kk < nuse ; kk++ ) dtr[kk] = kk - 0.5 * (nuse-1) ; /* linear trend, orthogonal to 1 */ /*----- set up to find time at each voxel -----*/ tdelta = old_dset->taxis->ttdel ; if( DSET_TIMEUNITS(old_dset) == UNITS_MSEC_TYPE ) tdelta *= 0.001 ; if( tdelta == 0.0 ) tdelta = 1.0 ; izold = -666 ; nxy = old_dset->daxes->nxx * old_dset->daxes->nyy ; /*----------------------------------------------------*/ /*----- Setup has ended. Now do some real work. -----*/ /* start notification */ #if 0 user_func( 0.0 , 0.0 , nvox , NULL,0.0,0.0 , user_data ) ; #else { void (*uf)(double,double,int,float *,double,double,void *) = (void (*)(double,double,int,float *,double,double,void *))(user_func) ; uf( 0.0l,0.0l , nvox , NULL , 0.0l,0.0l , user_data ) ; } #endif /***** loop over voxels *****/ for( ii=0 ; ii < nvox ; ii++ ){ /* 1 time series at a time */ /*** load data from input dataset, depending on type ***/ switch( old_datum ){ /*** input = bytes ***/ case MRI_byte: for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] = bptr[kk][ii] ; break ; /*** input = shorts ***/ case MRI_short: for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] = sptr[kk][ii] ; break ; /*** input = floats ***/ case MRI_float: for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] = fptr[kk][ii] ; break ; /*** input = complex (note we use absolute value) ***/ case MRI_complex: for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] = CABS(cptr[kk][ii]) ; break ; } /* end of switch over input type */ /*** scale? ***/ if( use_fac ) for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] *= fac[kk] ; /** compute mean and slope **/ x0 = x1 = 0.0 ; for( kk=0 ; kk < nuse ; kk++ ){ x0 += fxar[kk] ; x1 += fxar[kk] * dtr[kk] ; } x0 *= d0fac ; x1 *= d1fac ; /* factors to remove mean and trend */ ts_mean = x0 ; ts_slope = x1 / tdelta ; /** detrend? **/ if( detrend ) for( kk=0 ; kk < nuse ; kk++ ) fxar[kk] -= (x0 + x1 * dtr[kk]) ; /** compute start time of this timeseries **/ /* The info computed here is not being used in this version*/ iz = ii / nxy ; /* which slice am I in? */ if( iz != izold ){ /* in a new slice? */ tzero = THD_timeof( ignore , old_dset->daxes->zzorg + iz*old_dset->daxes->zzdel , old_dset->taxis ) ; izold = iz ; if( DSET_TIMEUNITS(old_dset) == UNITS_MSEC_TYPE ) tzero *= 0.001 ; } /*** Send data to user function ***/ #if 0 user_func( tzero,tdelta , nuse,fxar,ts_mean,ts_slope , user_data) ; #else { void (*uf)(double,double,int,float *,double,double,void *) = (void (*)(double,double,int,float *,double,double,void *))(user_func) ; uf( tzero,tdelta , nuse,fxar,ts_mean,ts_slope , user_data) ; } #endif } /* end of outer loop over 1 voxels at a time */ DSET_unload( old_dset ) ; /* end notification */ #if 0 user_func( 0.0 , 0.0 , 0 , NULL,0.0,0.0 , user_data ) ; #else { void (*uf)(double,double,int,float *,double,double,void *) = (void (*)(double,double,int,float *,double,double,void *))(user_func) ; uf( 0.0l,0.0l, 0 , NULL,0.0l,0.0l, user_data ) ; } #endif /*-------------- Cleanup and go home ----------------*/ ZFREE_WORKSPACE ; retval = 0; return &retval; /* this value is not used for now .... */ }
void EDIT_coerce_type( int nxyz , int itype,void *ivol , int otype,void *ovol ) { register int ii ; complex *cin=NULL , *cout ; short *sin=NULL , *sout ; float *fin=NULL , *fout ; byte *bin=NULL , *bout ; double *din=NULL , *dout ; /* 10 Jan 1999 */ ENTRY("EDIT_coerce_type") ; #ifdef AFNI_DEBUG { char str[256] ; sprintf(str,"voxels=%d input type=%s output type=%s", nxyz, MRI_TYPE_name[itype],MRI_TYPE_name[otype]) ; STATUS(str) ; } #endif if( nxyz <= 0 || ivol == NULL || ovol == NULL ) EXRETURN ; switch( itype ) { default: fprintf(stderr,"** Unknown itype=%d in EDIT_coerce_type\n",itype); EXRETURN ; case MRI_complex: cin = (complex *) ivol ; break ; case MRI_short : sin = (short *) ivol ; break ; case MRI_float : fin = (float *) ivol ; break ; case MRI_byte : bin = (byte *) ivol ; break ; case MRI_double : din = (double *) ivol ; break ; } switch( otype ) { default: fprintf(stderr,"** Unknown otype=%d in EDIT_coerce_type\n",otype); EXRETURN ; case MRI_complex: cout = (complex *) ovol ; break ; case MRI_short : sout = (short *) ovol ; break ; case MRI_float : fout = (float *) ovol ; break ; case MRI_byte : bout = (byte *) ovol ; break ; case MRI_double : dout = (double *) ovol ; break ; } switch( otype ) { /*** outputs are shorts ***/ case MRI_short: switch( itype ) { case MRI_short: /* inputs are shorts */ memcpy( sout , sin , sizeof(short)*nxyz ) ; EXRETURN ; case MRI_float: /* inputs are floats */ for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fin[ii]) ; EXRETURN ; case MRI_double: /* inputs are doubles */ for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(din[ii]) ; EXRETURN ; case MRI_byte: /* inputs are bytes */ for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = bin[ii] ; EXRETURN ; case MRI_complex: /* inputs are complex */ for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(CABS(cin[ii])) ; EXRETURN ; } EXRETURN ; /*** outputs are floats ***/ case MRI_float: switch( itype ) { case MRI_short: /* inputs are shorts */ for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = sin[ii] ; EXRETURN ; case MRI_float: /* inputs are floats */ memcpy( fout , fin , sizeof(float)*nxyz ) ; EXRETURN ; case MRI_double: /* inputs are doubles */ for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = din[ii] ; EXRETURN ; case MRI_byte: /* inputs are bytes */ for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = bin[ii] ; EXRETURN ; case MRI_complex: /* inputs are complex */ for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = CABS(cin[ii]) ; EXRETURN ; } EXRETURN ; /*** outputs are doubles ***/ case MRI_double: switch( itype ) { case MRI_short: /* inputs are shorts */ for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = sin[ii] ; EXRETURN ; case MRI_float: /* inputs are floats */ for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fin[ii] ; EXRETURN ; case MRI_double: /* inputs are doubles */ memcpy( dout , din , sizeof(double)*nxyz ) ; EXRETURN ; case MRI_byte: /* inputs are bytes */ for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = bin[ii] ; EXRETURN ; case MRI_complex: /* inputs are complex */ for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = CABS(cin[ii]) ; EXRETURN ; } EXRETURN ; /*** outputs are bytes ***/ case MRI_byte: switch( itype ) { case MRI_short: /* inputs are shorts */ for( ii=0 ; ii < nxyz ; ii++ ) bout[ii] = SHORT_TO_BYTE(sin[ii]) ; EXRETURN ; case MRI_float: /* inputs are floats */ for( ii=0 ; ii < nxyz ; ii++ ) bout[ii] = FLOAT_TO_BYTE(fin[ii]) ; EXRETURN ; case MRI_double: /* inputs are doubles */ for( ii=0 ; ii < nxyz ; ii++ ) bout[ii] = FLOAT_TO_BYTE(din[ii]) ; EXRETURN ; case MRI_byte: /* inputs are bytes */ memcpy( bout , bin , sizeof(byte)*nxyz ) ; EXRETURN ; case MRI_complex: { /* inputs are complex */ float val ; for( ii=0 ; ii < nxyz ; ii++ ) { val = CABS(cin[ii]) ; bout[ii] = FLOAT_TO_BYTE(val) ; } } EXRETURN ; } EXRETURN ; /*** outputs are complex ***/ case MRI_complex: switch( itype ) { case MRI_short: /* inputs are shorts */ for( ii=0 ; ii < nxyz ; ii++ ) cout[ii].r = sin[ii] , cout[ii].i = 0.0 ; EXRETURN ; case MRI_float: /* inputs are floats */ for( ii=0 ; ii < nxyz ; ii++ ) cout[ii].r = fin[ii] , cout[ii].i = 0.0 ; EXRETURN ; case MRI_double: /* inputs are doubles */ for( ii=0 ; ii < nxyz ; ii++ ) cout[ii].r = din[ii] , cout[ii].i = 0.0 ; EXRETURN ; case MRI_byte: /* inputs are bytes */ for( ii=0 ; ii < nxyz ; ii++ ) cout[ii].r = bin[ii] , cout[ii].i = 0.0 ; EXRETURN ; case MRI_complex: /* inputs are complex */ memcpy( cout , cin , sizeof(complex)*nxyz ) ; EXRETURN ; } EXRETURN ; } EXRETURN ; }
static UF_long klu_l_backslash /* return 1 if successful, 0 otherwise */ ( /* --- input ---- */ UF_long n, /* A is n-by-n */ UF_long *Ap, /* size n+1, column pointers */ UF_long *Ai, /* size nz = Ap [n], row indices */ double *Ax, /* size nz, numerical values */ UF_long isreal, /* nonzero if A is real, 0 otherwise */ double *B, /* size n, right-hand-side */ /* --- output ---- */ double *X, /* size n, solution to Ax=b */ double *R, /* size n, residual r = b-A*x */ /* --- scalar output --- */ UF_long *lunz, /* nnz (L+U+F) */ double *rnorm, /* norm (b-A*x,1) / norm (A,1) */ /* --- workspace - */ klu_l_common *Common /* default parameters and statistics */ ) { double anorm = 0, asum ; klu_l_symbolic *Symbolic ; klu_l_numeric *Numeric ; UF_long i, j, p ; if (!Ap || !Ai || !Ax || !B || !X || !B) return (0) ; /* ---------------------------------------------------------------------- */ /* symbolic ordering and analysis */ /* ---------------------------------------------------------------------- */ Symbolic = klu_l_analyze (n, Ap, Ai, Common) ; if (!Symbolic) return (0) ; if (isreal) { /* ------------------------------------------------------------------ */ /* factorization */ /* ------------------------------------------------------------------ */ Numeric = klu_l_factor (Ap, Ai, Ax, Symbolic, Common) ; if (!Numeric) { klu_l_free_symbolic (&Symbolic, Common) ; return (0) ; } /* ------------------------------------------------------------------ */ /* statistics (not required to solve Ax=b) */ /* ------------------------------------------------------------------ */ klu_l_rgrowth (Ap, Ai, Ax, Symbolic, Numeric, Common) ; klu_l_condest (Ap, Ax, Symbolic, Numeric, Common) ; klu_l_rcond (Symbolic, Numeric, Common) ; klu_l_flops (Symbolic, Numeric, Common) ; *lunz = Numeric->lnz + Numeric->unz - n + ((Numeric->Offp) ? (Numeric->Offp [n]) : 0) ; /* ------------------------------------------------------------------ */ /* solve Ax=b */ /* ------------------------------------------------------------------ */ for (i = 0 ; i < n ; i++) { X [i] = B [i] ; } klu_l_solve (Symbolic, Numeric, n, 1, X, Common) ; /* ------------------------------------------------------------------ */ /* compute residual, rnorm = norm(b-Ax,1) / norm(A,1) */ /* ------------------------------------------------------------------ */ for (i = 0 ; i < n ; i++) { R [i] = B [i] ; } for (j = 0 ; j < n ; j++) { asum = 0 ; for (p = Ap [j] ; p < Ap [j+1] ; p++) { /* R (i) -= A (i,j) * X (j) */ R [Ai [p]] -= Ax [p] * X [j] ; asum += fabs (Ax [p]) ; } anorm = MAX (anorm, asum) ; } *rnorm = 0 ; for (i = 0 ; i < n ; i++) { *rnorm = MAX (*rnorm, fabs (R [i])) ; } /* ------------------------------------------------------------------ */ /* free numeric factorization */ /* ------------------------------------------------------------------ */ klu_l_free_numeric (&Numeric, Common) ; } else { /* ------------------------------------------------------------------ */ /* statistics (not required to solve Ax=b) */ /* ------------------------------------------------------------------ */ Numeric = klu_zl_factor (Ap, Ai, Ax, Symbolic, Common) ; if (!Numeric) { klu_l_free_symbolic (&Symbolic, Common) ; return (0) ; } /* ------------------------------------------------------------------ */ /* statistics */ /* ------------------------------------------------------------------ */ klu_zl_rgrowth (Ap, Ai, Ax, Symbolic, Numeric, Common) ; klu_zl_condest (Ap, Ax, Symbolic, Numeric, Common) ; klu_zl_rcond (Symbolic, Numeric, Common) ; klu_zl_flops (Symbolic, Numeric, Common) ; *lunz = Numeric->lnz + Numeric->unz - n + ((Numeric->Offp) ? (Numeric->Offp [n]) : 0) ; /* ------------------------------------------------------------------ */ /* solve Ax=b */ /* ------------------------------------------------------------------ */ for (i = 0 ; i < 2*n ; i++) { X [i] = B [i] ; } klu_zl_solve (Symbolic, Numeric, n, 1, X, Common) ; /* ------------------------------------------------------------------ */ /* compute residual, rnorm = norm(b-Ax,1) / norm(A,1) */ /* ------------------------------------------------------------------ */ for (i = 0 ; i < 2*n ; i++) { R [i] = B [i] ; } for (j = 0 ; j < n ; j++) { asum = 0 ; for (p = Ap [j] ; p < Ap [j+1] ; p++) { /* R (i) -= A (i,j) * X (j) */ i = Ai [p] ; REAL (R,i) -= REAL(Ax,p) * REAL(X,j) - IMAG(Ax,p) * IMAG(X,j) ; IMAG (R,i) -= IMAG(Ax,p) * REAL(X,j) + REAL(Ax,p) * IMAG(X,j) ; asum += CABS (Ax, p) ; } anorm = MAX (anorm, asum) ; } *rnorm = 0 ; for (i = 0 ; i < n ; i++) { *rnorm = MAX (*rnorm, CABS (R, i)) ; } /* ------------------------------------------------------------------ */ /* free numeric factorization */ /* ------------------------------------------------------------------ */ klu_zl_free_numeric (&Numeric, Common) ; } /* ---------------------------------------------------------------------- */ /* free symbolic analysis, and residual */ /* ---------------------------------------------------------------------- */ klu_l_free_symbolic (&Symbolic, Common) ; return (1) ; }
int main( int argc , char * argv[] ) { int iarg , pos = 0 ; float thresh=0.0 ; MRI_IMAGE * maskim=NULL , *imin , *imout ; float * maskar ; int nxim , nyim , ii , npix ; if( argc < 3 || strncmp(argv[1],"-help",4) == 0 ){ printf("Usage: immask [-thresh #] [-mask mask_image] [-pos] input_image output_image\n" "* Masks the input_image and produces the output_image;\n" "* Use of -thresh # means all pixels with absolute value below # in\n" " input_image will be set to zero in the output_image\n" "* Use of -mask mask_image means that only locations that are nonzero\n" " in the mask_image will be nonzero in the output_image\n" "* Use of -pos means only positive pixels from input_image will be used\n" "* At least one of -thresh, -mask, -pos must be used; more than one is OK.\n" ) ; exit(0) ; } machdep() ; iarg = 1 ; while( iarg < argc && argv[iarg][0] == '-' ){ /*** -pos ***/ if( strncmp(argv[iarg],"-pos",4) == 0 ){ pos = 1 ; iarg++ ; continue ; } /*** -thresh # ***/ if( strncmp(argv[iarg],"-thresh",5) == 0 ){ thresh = strtod( argv[++iarg] , NULL ) ; if( iarg >= argc || thresh <= 0.0 ){ fprintf(stderr,"Illegal -thresh!\a\n") ; exit(1) ; } iarg++ ; continue ; } if( strncmp(argv[iarg],"-mask",5) == 0 ){ maskim = mri_read_just_one( argv[++iarg] ) ; if( maskim == NULL || iarg >= argc || ! MRI_IS_2D(maskim) ){ fprintf(stderr,"Illegal -mask!\a\n") ; exit(1) ; } if( maskim->kind != MRI_float ){ imin = mri_to_float( maskim ) ; mri_free( maskim ) ; maskim = imin ; } iarg++ ; continue ; } fprintf(stderr,"** Illegal option: %s\a\n",argv[iarg]) ; exit(1) ; } if( thresh <= 0.0 && maskim == NULL && pos == 0 ){ fprintf(stderr,"No -thresh, -mask, -pos ==> can't go on!\a\n") ; exit(1) ; } if( iarg+1 >= argc ){ fprintf(stderr,"Must have input_image and output_image on command line!\a\n") ; exit(1) ; } imin = mri_read_just_one( argv[iarg++] ) ; if( imin == NULL ) exit(1) ; if( ! MRI_IS_2D(imin) ){ fprintf(stderr,"can only process 2D images!\a\n") ; exit(1) ; } nxim = imin->nx ; nyim = imin->ny ; npix = nxim * nyim ; if( maskim == NULL ){ maskim = mri_new( nxim , nyim , MRI_float ) ; maskar = MRI_FLOAT_PTR(maskim) ; for( ii=0 ; ii < npix ; ii++ ) maskar[ii] = 1.0 ; } else if( maskim->nx != nxim || maskim->ny != nyim ){ fprintf(stderr,"Mask and input image not same size!\a\n") ; exit(1) ; } else { maskar = MRI_FLOAT_PTR(maskim) ; } imout = mri_new( nxim , nyim , imin->kind ) ; switch( imin->kind ){ default: fprintf(stderr,"Unrecognized input image type!\a\n") ; exit(1) ; case MRI_byte:{ byte * arin , * arout , val ; arin = mri_data_pointer(imin) ; arout = mri_data_pointer(imout) ; for( ii=0 ; ii < npix ; ii++ ){ val = arin[ii] ; if( maskar[ii] != 0.0 && ABS(val) >= thresh ) arout[ii] = val ; else arout[ii] = 0 ; } } break ; case MRI_short:{ short * arin , * arout , val ; arin = mri_data_pointer(imin) ; arout = mri_data_pointer(imout) ; for( ii=0 ; ii < npix ; ii++ ){ val = arin[ii] ; if( maskar[ii] != 0.0 && ABS(val) >= thresh ) arout[ii] = val ; else arout[ii] = 0 ; } if( pos ) for( ii=0 ; ii < npix ; ii++ ) if( arout[ii] < 0 ) arout[ii] = 0 ; } break ; case MRI_float:{ float * arin , * arout , val ; arin = mri_data_pointer(imin) ; arout = mri_data_pointer(imout) ; for( ii=0 ; ii < npix ; ii++ ){ val = arin[ii] ; if( maskar[ii] != 0.0 && ABS(val) >= thresh ) arout[ii] = val ; else arout[ii] = 0 ; } if( pos ) for( ii=0 ; ii < npix ; ii++ ) if( arout[ii] < 0 ) arout[ii] = 0 ; } break ; case MRI_int:{ int * arin , * arout , val ; arin = mri_data_pointer(imin) ; arout = mri_data_pointer(imout) ; for( ii=0 ; ii < npix ; ii++ ){ val = arin[ii] ; if( maskar[ii] != 0.0 && ABS(val) >= thresh ) arout[ii] = val ; else arout[ii] = 0 ; } if( pos ) for( ii=0 ; ii < npix ; ii++ ) if( arout[ii] < 0 ) arout[ii] = 0 ; } break ; case MRI_double:{ double * arin , * arout , val ; arin = mri_data_pointer(imin) ; arout = mri_data_pointer(imout) ; for( ii=0 ; ii < npix ; ii++ ){ val = arin[ii] ; if( maskar[ii] != 0.0 && ABS(val) >= thresh ) arout[ii] = val ; else arout[ii] = 0 ; } if( pos ) for( ii=0 ; ii < npix ; ii++ ) if( arout[ii] < 0 ) arout[ii] = 0 ; } break ; case MRI_complex:{ complex * arin , * arout , val ; arin = mri_data_pointer(imin) ; arout = mri_data_pointer(imout) ; for( ii=0 ; ii < npix ; ii++ ){ val = arin[ii] ; if( maskar[ii] != 0.0 && CABS(val) >= thresh ) arout[ii] = val ; else arout[ii] = CMPLX(0,0) ; } } break ; } mri_write( argv[iarg] , imout ) ; exit(0) ; }
int THD_extract_float_array( int ind, THD_3dim_dataset *dset, float *far ) { MRI_TYPE typ ; int nv , ival , nb , nb1 ; char *iar ; /* brick in the input */ if( ind < 0 || far == NULL || !ISVALID_DSET(dset) || ind >= DSET_NVOX(dset) ) return(-1) ; nv = dset->dblk->nvals ; typ = DSET_BRICK_TYPE(dset,0) ; /* raw data type */ switch( typ ){ default: /* don't know what to do --> return nada */ return(-1); break ; case MRI_byte:{ byte *bar ; for( ival=0 ; ival < nv ; ival++ ){ bar = (byte *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) far[ival] = bar[ind] ; } } break ; case MRI_short:{ short *bar ; for( ival=0 ; ival < nv ; ival++ ){ bar = (short *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) far[ival] = bar[ind] ; } } break ; case MRI_float:{ float *bar ; for( ival=0 ; ival < nv ; ival++ ){ bar = (float *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) far[ival] = bar[ind] ; } } break ; case MRI_complex:{ complex *bar ; for( ival=0 ; ival < nv ; ival++ ){ bar = (complex *) DSET_ARRAY(dset,ival) ; if( bar != NULL ) far[ival] = CABS(bar[ind]) ; } } break ; } if( THD_need_brick_factor(dset) ){ for( ival=0 ; ival < nv ; ival++ ) if( DSET_BRICK_FACTOR(dset,ival) > 0.0 ) far[ival] *= DSET_BRICK_FACTOR(dset,ival) ; } return(0); }
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 ); }