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 );
}
