/*
Get copy contents of sub-brick iv into an integer array.
if iv == -1, get the entire dset
NO ROUNDING is done. Only type casting.
*/
int *THD_extract_to_int( int iv , THD_3dim_dataset *dset )
{
MRI_IMAGE *im ;
int *var=NULL, *vv=NULL;
register int ii , nvox ;
ENTRY("THD_extract_to_int") ;
if (!dset) RETURN(var);
if (iv >= 0) {
if (!(im = THD_extract_int_brick(iv, dset))) RETURN(var);
var = MRI_INT_PTR(im);mri_fix_data_pointer(NULL, im);
mri_free(im);im=NULL;
} else if (iv == -1) {
if (!(var = (int *)calloc(DSET_NVOX(dset)*DSET_NVALS(dset),sizeof(int)))){
ERROR_message("Failed to allocate");
RETURN(NULL);
}
for (ii=0; ii<DSET_NVALS(dset); ++ii) {
if (!(im = THD_extract_int_brick(ii, dset))) {
ERROR_message("Failed toextract sb %d from dset", ii);
if (var) free(var);
RETURN(NULL);
}
vv = MRI_INT_PTR(im);
memcpy(var+ii*DSET_NVOX(dset),vv, sizeof(int)*DSET_NVOX(dset));
mri_free(im);im=NULL;
}
} else {
ERROR_message("Bad value of %d\n", iv);
}
RETURN(var);
}
MRI_IMAGE * mri_transpose_int( MRI_IMAGE * im )
{
MRI_IMAGE * om ;
int * iar , * oar ;
int ii,jj,nx,ny ;
ENTRY("mri_transpose_int") ;
if( im == NULL || im->kind != MRI_int ) RETURN(NULL) ;
nx = im->nx ; ny = im->ny ;
om = mri_new( ny , nx , MRI_int ) ;
iar = MRI_INT_PTR(im) ;
oar = MRI_INT_PTR(om) ;
for( jj=0 ; jj < ny ; jj++ )
for( ii=0 ; ii < nx ; ii++ )
oar[jj+ii*ny] = iar[ii+jj*nx] ;
MRI_COPY_AUX(om,im) ;
RETURN(om) ;
}
int mri_write_ascii( char *fname, MRI_IMAGE *im )
{
int ii , jj , nx , ny ;
FILE *imfile ;
ENTRY("mri_write_ascii") ;
if( im == NULL || im->nz > 1 ) RETURN( 0 ) ; /* stoopid user */
if( fname == NULL || *fname == '\0' ) fname = "-" ; /* to stdout */
imfile = fopen_maybe(fname) ;
if( imfile == NULL ) RETURN(0) ;
ii = mri_floatscan( im ) ; /* 05 Apr 2010 */
if( ii > 0 )
WARNING_message("Zeroed %d float error%s while writing 1D file %s",
ii , (ii > 1) ? "s" : "\0" , fname ) ;
nx = im->nx ; ny = im->ny ;
for( jj=0 ; jj < ny ; jj++ ){
switch( im->kind ){
default: break ;
case MRI_float:{
float *iar = MRI_FLOAT_PTR(im) + (jj*nx) ;
for( ii=0 ; ii < nx ; ii++ )
fprintf(imfile," %14g",iar[ii]) ;
}
break ;
case MRI_short:{
short *iar = MRI_SHORT_PTR(im) + (jj*nx) ;
for( ii=0 ; ii < nx ; ii++ )
fprintf(imfile," %6d",iar[ii]) ;
}
break ;
case MRI_byte:{
byte *iar = MRI_BYTE_PTR(im) + (jj*nx) ;
for( ii=0 ; ii < nx ; ii++ )
fprintf(imfile," %3d",iar[ii]) ;
}
break ;
case MRI_int:{
int *iar = MRI_INT_PTR(im) + (jj*nx) ;
for( ii=0 ; ii < nx ; ii++ )
fprintf(imfile," %6d",iar[ii]) ;
}
break ;
case MRI_double:{
double *iar = MRI_DOUBLE_PTR(im) + (jj*nx) ;
for( ii=0 ; ii < nx ; ii++ )
fprintf(imfile," %16g",iar[ii]) ;
}
break ;
case MRI_complex:{
complex *iar = MRI_COMPLEX_PTR(im) + (jj*nx) ;
for( ii=0 ; ii < nx ; ii++ )
fprintf(imfile," %-1.7g;%-1.7g",iar[ii].r,iar[ii].i) ;
}
break ;
case MRI_rgb:{
byte *iar = MRI_RGB_PTR(im) + (3*jj*nx) ;
for( ii=0 ; ii < nx ; ii++ )
fprintf(imfile," %3d %3d %3d",iar[3*ii],iar[3*ii+1],iar[3*ii+2]) ;
}
break ;
}
fprintf(imfile,"\n") ;
}
fclose_maybe(imfile) ;
RETURN( 1 );
}
int main( int argc , char * argv[] )
{
/* --- variable declarations --- */
THD_3dim_dataset * dset ;
THD_diskptr * dskptr;
int nx, ny, nz, nv, itim;
Boolean verbose, nsize;
int ok;
MRI_IMAGE * im, * im2d, * tim2d;
MRI_TYPE kind;
int ibr, iz, count, izz,izsub ;
int zfirst, zlast, tfirst, tlast;
char input_filename[THD_MAX_NAME],
prefix_filename[THD_MAX_NAME],
output_filename[THD_MAX_NAME],
str[THD_MAX_NAME];
/* --- get user command line inputs --- */
F3D_initialize_user_data (argc, argv,
&verbose, &nsize,
&zfirst, &zlast, &tfirst, &tlast,
input_filename, prefix_filename );
/* --- open 3d data set --- */
dset = THD_open_one_dataset( input_filename ) ;
if( dset == NULL ) FatalError ("Unable to open input file") ;
if ( verbose ) printf("EPsim: 3d Dataset File = %s\n" , input_filename ) ;
/* --- load data block --- */
ok = THD_load_datablock( dset->dblk );
if ( !ok ) FatalError ("Unable to load data block") ;
/* --- get data dimensions --- */
dskptr = dset->dblk->diskptr;
nx = dskptr->dimsizes[0];
ny = dskptr->dimsizes[1];
nz = dskptr->dimsizes[2];
nv = dskptr->nvals;
if ( verbose )
printf ("EPsim: nx=%d ny=%d nz=%d nv=%d\n", nx, ny, nz, nv);
/* --- check for valid user inputs --- */
if (zfirst < 1) zfirst = 1;
if (zlast > nz) zlast = nz;
if (tfirst < 1) tfirst = 1;
if (tlast > nv) tlast = nv;
if (zfirst > nz) FatalError ("No data selected -- zfirst too large.");
if (zlast < 1) FatalError ("No data selected -- zlast too small.");
if (tfirst > nv) FatalError ("No data selected -- tfirst too large.");
if (tlast < 1) FatalError ("No data selected -- tlast too small.");
/* --- get data type --- */
kind = IMAGE_IN_IMARR ( dset->dblk->brick, 0 ) -> kind;
if ( verbose ) printf ("EPsim: datum = %s \n", MRI_TYPE_name[kind]);
/* --- create 2d data pointer --- */
im2d = mri_new_vol_empty ( nx, ny, 1, kind );
/*** open channel to AFNI ***/
sprintf( buf , "tcp:%s:%d" , host , get_port_named("CONTROL_PORT") ) ;
ioc = iochan_init( buf , "create" ) ;
if( ioc == NULL ) FatalError("Cannot open control channel to AFNI") ;
if( verbose ) printf("EPsim: waiting for AFNI") ; fflush(stdout) ;
while(1){
iz = iochan_goodcheck( ioc , 1000 ) ;
if( iz < 0 ) FatalError("control channel failed") ;
if( iz > 0 ) break ;
if( verbose ){ printf(".") ; fflush(stdout) ; }
}
if( verbose ){ printf("!\n") ; fflush(stdout) ; }
if( use_shm ) strcpy( buf , SHM_NAME ) ;
else sprintf(buf , "tcp:%s:%d" ,
host , get_port_named("AFNI_PLUGOUT_TCP_BASE") ) ;
if( use_child ){
jj = strlen(buf) ;
sprintf(buf+jj,"\ncat epsim.out") ;
} else if( use_3T ){
jj = strlen(buf) ;
sprintf(buf+jj,"\n3T_toafni -dummy < %s" , fname_3T ) ;
}
if( verbose ) printf("sending control data: %s\n",buf) ;
jj = iochan_sendall( ioc , buf , strlen(buf)+1 ) ;
if( jj < 0 ) FatalError("send control data failed") ;
iochan_sleep(LONG_DELAY) ; /* wait a bit */
while( ! iochan_clearcheck(ioc,LONG_DELAY) ) /* loop until cleared */
iochan_sleep(LONG_DELAY) ;
if( verbose ) printf("EPsim: closing control channel\n") ;
IOCHAN_CLOSE(ioc) ;
/*** now open data channel ***/
ioc = iochan_init( buf , "create" ) ;
if( ioc == NULL ) FatalError("Cannot open data channel to AFNI") ;
if( verbose ) printf("EPsim: waiting for AFNI") ; fflush(stdout) ;
while(1){
iz = iochan_goodcheck( ioc , 1000 ) ;
if( iz < 0 ) FatalError("data channel failed") ;
if( iz > 0 ) break ;
if( verbose ){ printf(".") ; fflush(stdout) ; }
}
if( verbose ){ printf("!\n") ; fflush(stdout) ; }
if( use_child ){
FILE * fp = fopen( "epsim.out" , "w" ) ;
if( fp == NULL ){fprintf(stderr,"Can't open epsim.out!\n");IOCHAN_CLOSE(ioc);exit(1);}
fprintf( fp , "ZNUM %d\n"
"ZDELTA %g\n"
"XYFOV %g %g\n"
"ZFIRST %g%c\n"
"ZORDER seq\n"
"XYZAXES %s %s %s\n"
"ACQUISITION_TYPE %s\n"
,
nz ,
fabs(dset->daxes->zzdel) ,
fabs(dset->daxes->xxdel)*nx , fabs(dset->daxes->yydel)*ny ,
fabs(dset->daxes->zzorg) , ORIENT_first[dset->daxes->zzorient] ,
ORIENT_shortstr[dset->daxes->xxorient] ,
ORIENT_shortstr[dset->daxes->yyorient] ,
ORIENT_shortstr[dset->daxes->zzorient] ,
( ((zlast-zfirst)>0) ? "2D+zt" : "2D+z" )
) ;
fclose(fp) ;
if( verbose ) printf("EPsim: wrote epsim.out file\n") ;
sprintf( buf , "XYMATRIX %d %d\n"
"DATUM %s\n"
,
nx , ny ,
MRI_TYPE_name[kind]
) ;
} else if( use_3T ){
sprintf( buf , "XYMATRIX %d %d\n"
"DATUM %s\n"
,
nx , ny ,
MRI_TYPE_name[kind]
) ;
} else {
sprintf( buf , "ZNUM %d\n"
"ZDELTA %g\n"
"XYFOV %g %g\n"
"ZFIRST %g%c\n"
"ZORDER seq\n"
"XYZAXES %s %s %s\n"
"ACQUISITION_TYPE %s\n"
"XYMATRIX %d %d\n"
"DATUM %s\n"
,
nz ,
fabs(dset->daxes->zzdel) ,
fabs(dset->daxes->xxdel)*nx , fabs(dset->daxes->yydel)*ny ,
fabs(dset->daxes->zzorg) , ORIENT_first[dset->daxes->zzorient] ,
ORIENT_shortstr[dset->daxes->xxorient] ,
ORIENT_shortstr[dset->daxes->yyorient] ,
ORIENT_shortstr[dset->daxes->zzorient] ,
( ((zlast-zfirst)>0) ? "2D+zt" : "2D+z" ) ,
nx , ny ,
MRI_TYPE_name[kind]
) ;
}
nbytes = im2d->nvox * im2d->pixel_size ;
for( itim=0 ; itim < ntimes ; itim++ ){
count = 0;
if( use_3T ) izsub = (nz%2 == 0) ? (nz-1) : (nz) ;
for ( ibr = tfirst-1 ; ibr < tlast ; ibr++ )
{
for ( iz = zfirst-1 ; iz < zlast ; iz++ )
{
/* --- set 2d data pointer into 3d data set --- */
im = IMAGE_IN_IMARR ( dset->dblk->brick, ibr );
if( use_3T ){
izz = 2*iz ; if( izz >= nz ) izz -= izsub ; /* alt ordering */
} else {
izz = iz ; /* seq ordering */
}
switch ( kind )
{
case MRI_byte :
mri_set_data_pointer(im2d, MRI_BYTE_PTR(im) + iz*nx*ny) ;
break;
case MRI_short :
mri_set_data_pointer(im2d, MRI_SHORT_PTR(im) + iz*nx*ny) ;
break;
case MRI_int :
mri_set_data_pointer(im2d, MRI_INT_PTR(im) + iz*nx*ny) ;
break;
case MRI_float :
mri_set_data_pointer(im2d, MRI_FLOAT_PTR(im) + iz*nx*ny) ;
break;
case MRI_double :
mri_set_data_pointer(im2d, MRI_DOUBLE_PTR(im) + iz*nx*ny) ;
break;
case MRI_complex :
mri_set_data_pointer(im2d, MRI_COMPLEX_PTR(im) + iz*nx*ny) ;
break;
case MRI_rgb :
mri_set_data_pointer(im2d, MRI_RGB_PTR(im) + 3*iz*nx*ny) ;
break;
default :
FatalError ("Illegal data type encountered.");
}
#if 0
/* --- create 2d data file name --- */
strcpy ( output_filename, prefix_filename );
if ( nv > 1 )
sprintf ( str, "%02d.%04d", izz+1, ibr+1 );
else
if ( nz > 999 )
sprintf ( str, ".%04d", izz+1 );
else
sprintf ( str, ".%03d", izz+1 );
strcat ( output_filename, str );
#endif
if( first ){
if( verbose )
printf("EPsim: sending this data as header info in image channel:\n%s\n",buf) ;
jj = iochan_sendall( ioc , buf , strlen(buf)+1 ) ;
if( jj < 0 ) FatalError("send header info failed") ;
first = 0 ;
}
if ( verbose )
printf ( "EPsim: sending 2D image izz=%d ibr=%d\n", izz,ibr );
jj = iochan_sendall( ioc , mri_data_pointer(im2d) , nbytes ) ;
if( jj < 0 ) FatalError("send image failed") ;
iochan_sleep( delay ) ;
#if 0
if ( !nsize )
ok = mri_write ( output_filename, im2d );
else
{
tim2d = mri_nsize (im2d);
ok = mri_write ( output_filename, tim2d);
mri_free (tim2d);
}
#endif
count ++ ;
} /* --- iz --- */
} /* --- ibr --- */
sleep(20) ;
} /* -- itim --*/
if ( verbose ) printf ("Sent %d 2D images. \n", count);
if( verbose ){ printf("Waiting for AFNI") ; fflush(stdout) ; }
while(1){
jj = iochan_clearcheck(ioc,1000) ;
if( jj ) break ;
if( verbose ){ printf(".") ; fflush(stdout) ; }
}
if( verbose ) printf("!\n") ;
iochan_sleep(100) ; IOCHAN_CLOSE(ioc) ;
exit(0) ;
}
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 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 );
}
MRI_IMAGE * THD_extract_int_brick( int iv , THD_3dim_dataset *dset )
{
MRI_IMAGE *im ;
register float fac ;
register int *var;
register int ii , nvox ;
ENTRY("THD_extract_int_brick") ;
if( iv < 0 || !ISVALID_DSET(dset) || iv >= DSET_NVALS(dset) ) RETURN(NULL);
im = mri_new_conforming( DSET_BRICK(dset,iv) , MRI_int ) ;
var = MRI_INT_PTR(im) ;
nvox = DSET_NVOX(dset) ;
/*-- extract/scale brick into var --*/
fac = DSET_BRICK_FACTOR(dset,iv) ; if( fac == 0.0f ) fac = 1.0f ;
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) ;
if (fac == 1.0f) {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)dar[ii] ;
} else {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)(fac*dar[ii]) ;
}
}
break ;
case MRI_byte:{
register byte *dar = DSET_ARRAY(dset,iv) ;
if (fac == 1.0f) {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)dar[ii] ;
} else {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)(fac*dar[ii]) ;
}
}
break ;
case MRI_float:{
register float *dar = DSET_ARRAY(dset,iv) ;
if (fac == 1.0f) {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)dar[ii] ;
} else {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)(fac*dar[ii]) ;
}
}
break ;
case MRI_complex:{
register complex *dar = DSET_ARRAY(dset,iv) ;
if (fac == 1.0f) {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)CABS(dar[ii]) ;
} else {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)(fac*CABS(dar[ii])) ;
}
}
break ;
#if 0
case MRI_int:{
register int *dar = DSET_ARRAY(dset,iv) ;
if (fac == 1.0f) {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)dar[ii] ;
} else {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)(fac*dar[ii]) ;
}
}
break ;
#endif
case MRI_double:{
register double *dar = DSET_ARRAY(dset,iv) ;
if (fac == 1.0f) {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)dar[ii] ;
} else {
for( ii=0 ; ii < nvox ; ii++ ) var[ii] = (int)(fac*dar[ii]) ;
}
}
break ;
case MRI_rgb:{
register byte *dar = DSET_ARRAY(dset,iv) ;
if (fac == 1.0f) {
for( ii=0 ; ii < nvox ; ii++ )
var[ii] = (int)(0.299*dar[3*ii] +
0.587*dar[3*ii+1] + 0.114*dar[3*ii+2] );
} else { /* this should not happen... */
for( ii=0 ; ii < nvox ; ii++ )
var[ii] = (int)((0.299*dar[3*ii] +
0.587*dar[3*ii+1] + 0.114*dar[3*ii+2] )*fac); }
}
break ;
}
RETURN(im) ;
}
MRI_IMAGE * mri_warp3D_align_one( MRI_warp3D_align_basis *bas, MRI_IMAGE *im )
{
float *fit , *dfit , *qfit , *tol ;
int iter , good,ngood , ii, pp , skip_first ;
MRI_IMAGE *tim , *fim ;
float *pmat=MRI_FLOAT_PTR(bas->imps) , /* pseudo inverse: n X m matrix */
*tar , tv , sfit ;
int n=bas->imps->nx , /* = nfree+1 */
m=bas->imps->ny , /* = imap->nx = length of ima */
npar=bas->nparam , /* = number of warp parameters */
nfree=bas->nfree , /* = number of free warp parameters */
*ima=MRI_INT_PTR(bas->imap) , /* = indexes in fim of voxels to use */
*pma ; /* = map of free to total params */
int ctstart ;
int do_twopass=(bas->imps_blur != NULL && bas->twoblur > 0.0f) , passnum=1 ;
int blur_pass ;
char *save_prefix ;
static int save_index=0 ;
#define AITMAX 3.33
#define NMEM 5
float *fitmem[NMEM] ;
int mm , last_aitken , num_aitken=0 ;
float sdif , fitdif[NMEM] ; /* 28 Sep 2005 */
int num_bad_diff ;
float best_dif , best_par[999] ; /* 09 Jan 2006 */
int best_ite=0 ;
ENTRY("mri_warp3D_align_one") ;
ctstart = NI_clock_time() ;
save_prefix = getenv("AFNI_WARPDRIVE_SAVER") ;
/** pma[k] = external parameter index for the k-th free parameter **/
pma = (int *)malloc(sizeof(int) * nfree) ;
for( pp=ii=0 ; ii < npar ; ii++ )
if( !bas->param[ii].fixed ) pma[pp++] = ii ;
#if 0
fprintf(stderr,"pma=") ;
for(pp=0;pp<nfree;pp++)fprintf(stderr," %d",pma[pp]);
fprintf(stderr,"\n") ;
#endif
fit = (float *)malloc(sizeof(float) * npar ) ;
dfit = (float *)malloc(sizeof(float) * npar ) ;
qfit = (float *)malloc(sizeof(float) * nfree) ;
tol = (float *)malloc(sizeof(float) * npar ) ;
for( mm=0 ; mm < NMEM ; mm++ ) fitmem[mm] = NULL ;
for( mm=0 ; mm < NMEM ; mm++ ) fitdif[mm] = 3.e+33 ;
/*--- loop back point for two pass alignment ---*/
bas->num_iter = 0 ;
mri_warp3D_set_womask( bas->imsk ) ;
ReStart:
best_dif = -666.0f ; /* 09 Jan 2006 */
blur_pass = (do_twopass && passnum==1) ;
mri_warp3D_method( blur_pass ? MRI_LINEAR : bas->regmode ) ;
/* load initial fit parameters;
if they are all the identity transform value,
then skip the first transformation of the fim volume */
if( passnum == 1 ){
skip_first = 1 ;
for( pp=0 ; pp < npar ; pp++ ){
if( bas->param[pp].fixed ){
fit[pp] = bas->param[pp].val_fixed ;
} else {
fit[pp] = bas->param[pp].val_init ;
}
skip_first = skip_first && (fit[pp] == bas->param[pp].ident) ;
}
} else {
skip_first = 0 ; /* and fit[] is unchanged */
}
fitmem[0] = (float *)malloc(sizeof(float)*npar) ;
memcpy( fitmem[0] , fit , sizeof(float)*npar ) ;
for( pp=0 ; pp < npar ; pp++ ) tol[pp] = bas->param[pp].toler ;
if( blur_pass ){
float fac = (1.0f+bas->twoblur) ;
if( fac < 3.0f ) fac = 3.0f ;
for( pp=0 ; pp < npar ; pp++ ) tol[pp] *= fac ;
}
if( bas->verb )
fprintf(stderr,"++ mri_warp3D_align_one: START PASS #%d\n",passnum) ;
/* setup base image for registration into fim,
and pseudo-inverse of base+derivative images into pmat */
if( blur_pass ){ /* first pass ==> registering blurred images */
float *far , blur=bas->twoblur ;
int nx=im->nx , ny=im->ny , nz=im->nz ;
fim = mri_to_float( im ) ; far = MRI_FLOAT_PTR(fim) ;
EDIT_blur_volume_3d( nx,ny,nz , 1.0f,1.0f,1.0f ,
MRI_float , far, blur,blur,blur ) ;
pmat = MRI_FLOAT_PTR(bas->imps_blur) ;
} else { /* registering original image */
if( im->kind == MRI_float ) fim = im ;
else fim = mri_to_float( im ) ;
pmat = MRI_FLOAT_PTR(bas->imps) ;
}
/******** iterate fit ********/
iter = 0 ; good = 1 ; last_aitken = 3 ; num_bad_diff = 0 ;
while( good ){
if( skip_first ){
tim = fim ; skip_first = 0 ;
} else {
bas->vwset( npar , fit ) ; /**************************/
tim = mri_warp3D( fim , 0,0,0 , bas->vwfor ) ; /* warp on current params */
} /**************************/
tar = MRI_FLOAT_PTR(tim) ;
sdif = mri_scaled_diff( bas->imbase , tim , bas->imsk ) ;
if( bas->verb )
fprintf(stderr,"++++++++++ Start iter=%d RMS_diff=%g\n",iter+1,sdif) ;
if( best_dif < 0.0f || sdif < best_dif ){ /* 09 Jan 2006 */
best_dif = sdif ; best_ite = iter ;
memcpy( best_par , fit , sizeof(float)*npar ) ;
}
/* find least squares fit of base + derivatives to warped image */
sfit = 0.0f ;
for( pp=0 ; pp < npar ; pp++ ) dfit[pp] = 0.0f ;
for( pp=0 ; pp < nfree ; pp++ ) qfit[pp] = 0.0f ;
for( ii=0 ; ii < m ; ii++ ){
tv = tar[ima[ii]] ; sfit += P(nfree,ii) * tv ;
for( pp=0 ; pp < nfree ; pp++ ) qfit[pp] += P(pp,ii) * tv ;
}
if( tim != fim ) mri_free( tim ) ;
#if 0
fprintf(stderr,"qfit=");
for(pp=0;pp<nfree;pp++)fprintf(stderr," %g",qfit[pp]);
fprintf(stderr,"\n") ;
#endif
for( pp=0 ; pp < nfree ; pp++ ) dfit[pma[pp]] = qfit[pp] ;
for( pp=0 ; pp < npar ; pp++ ){
fit[pp] += dfit[pp] ;
if( fit[pp] > bas->param[pp].max ) fit[pp] = bas->param[pp].max ;
else if( fit[pp] < bas->param[pp].min ) fit[pp] = bas->param[pp].min ;
}
if( bas->verb ){
fprintf(stderr,"+ Delta:") ;
for( pp=0 ; pp < npar ; pp++ ) fprintf(stderr," %13.6g",dfit[pp]) ;
fprintf(stderr,"\n") ;
fprintf(stderr,"+ Total: scale factor=%g\n"
"+ #%5d:",sfit,iter+1) ;
for( pp=0 ; pp < npar ; pp++ ) fprintf(stderr," %13.6g", fit[pp]) ;
fprintf(stderr,"\n") ;
}
/* save fit results for a while into the past, and then maybe do Aitken */
if( fitmem[NMEM-1] != NULL ) free((void *)fitmem[NMEM-1]) ;
for( mm=NMEM-1 ; mm > 0 ; mm-- ) fitmem[mm] = fitmem[mm-1] ;
fitmem[0] = (float *)malloc(sizeof(float)*npar) ;
memcpy( fitmem[0] , fit , sizeof(float)*npar ) ;
/* 28 Sep 2005: if RMS went up, back off the changes! */
for( mm=NMEM-1 ; mm > 0 ; mm-- ) fitdif[mm] = fitdif[mm-1] ;
fitdif[0] = sdif ;
if( iter > 1 && num_bad_diff < 2 &&
fitmem[1] != NULL && fitdif[0] > 1.0666f * fitdif[1] ){
for( pp=0 ; pp < npar ; pp++ )
fit[pp] = 0.5 * ( fitmem[0][pp] + fitmem[1][pp] ) ;
memcpy( fitmem[0] , fit , sizeof(float)*npar ) ;
last_aitken = iter+1 ; num_bad_diff++ ;
if( bas->verb )
fprintf(stderr,"+++ RMS_diff changes too much! Shrinking!\n") ;
} else {
num_bad_diff = 0 ;
}
iter++ ;
if( iter > last_aitken+NMEM && !AFNI_noenv("AFNI_WARPDRIVE_AITKEN") ){
double s0,s1,s2 , dd , de,df ;
num_aitken = 0 ;
for( pp=0 ; pp < npar ; pp++ ){
dd = fabs(fitmem[1][pp]-fit[pp]) ;
if( dd <= tol[pp] ) continue ; /* done here */
de = dd ;
for( mm=2 ; mm < NMEM ; mm++ ){
df = fabs(fitmem[mm][pp]-fitmem[mm-1][pp]) ;
if( df <= de ) break ;
de = df ;
}
if( mm == NMEM ){ /* do Aitken */
s2 = fit[pp] ; s1 = fitmem[1][pp] ; s0 = fitmem[2][pp] ;
de = ( (s2-s1) - (s1-s0) ) ;
if( de != 0.0 ){
de = -(s2-s1)*(s2-s1) / de ; dd *= AITMAX ;
if( fabs(de) > dd ){ de = (de > 0.0) ? dd : -dd ; }
fit[pp] += de ;
if( fit[pp] > bas->param[pp].max ) fit[pp] = bas->param[pp].max ;
else if( fit[pp] < bas->param[pp].min ) fit[pp] = bas->param[pp].min ;
num_aitken++ ;
}
}
}
if( num_aitken > 0 ) last_aitken = iter ;
if( bas->verb && num_aitken > 0 ){
fprintf(stderr,"+ Aitken on %d params:\n"
"+________:",num_aitken) ;
for( pp=0 ; pp < npar ; pp++ ){
if( fit[pp] != fitmem[0][pp] ){
fprintf(stderr," %13.6g", fit[pp]) ; fitmem[0][pp] = fit[pp] ;
} else {
fprintf(stderr," _____________") ;
}
}
fprintf(stderr,"\n") ;
}
}
/* save intermediate image? */
if( save_prefix != NULL ){
char sname[THD_MAX_NAME] ; FILE *fp ;
mri_warp3D_set_womask( NULL ) ; /* must warp the whole thing */
bas->vwset( npar , fit ) ;
tim = mri_warp3D( fim , 0,0,0 , bas->vwfor ) ;
tar = MRI_FLOAT_PTR(tim) ;
mri_warp3D_set_womask( bas->imsk ) ;
sprintf(sname,"%s_%04d.mmm",save_prefix,save_index++) ;
fprintf(stderr,"+ Saving intermediate image to binary file %s\n",sname) ;
fp = fopen( sname , "w" ) ;
if( fp != NULL ){
fwrite( tar, tim->pixel_size, tim->nvox, fp ) ; fclose(fp) ;
}
if( bas->vwdet != NULL ){
int i,j,k , nx=tim->nx,ny=tim->ny,nz=tim->nz ;
for( k=0 ; k < nz ; k++ ){
for( j=0 ; j < ny ; j++ ){
for( i=0 ; i < nx ; i++ ){
tar[i+(j+k*ny)*nx] = bas->vwdet( (float)i,(float)j,(float)k ) ;
}}}
sprintf(sname,"%s_%04d.ddd",save_prefix,save_index-1) ;
fprintf(stderr,"+ Saving determinant image to binary file %s\n",sname) ;
fp = fopen( sname , "w" ) ;
if( fp != NULL ){
fwrite( tar, tim->pixel_size, tim->nvox, fp ) ; fclose(fp) ;
}
}
mri_free( tim ) ;
}
/* loop back for more iterations? */
if( last_aitken == iter ) continue ; /* don't test, just loop */
if( fitmem[2] == NULL ) continue ;
ngood = 0 ;
for( pp=0 ; pp < npar ; pp++ )
if( !bas->param[pp].fixed )
ngood += ( ( fabs(fitmem[1][pp]-fitmem[0][pp]) <= tol[pp] ) &&
( fabs(fitmem[2][pp]-fitmem[1][pp]) <= tol[pp] ) ) ;
good = (ngood < nfree) && (iter < bas->max_iter) ;
} /******** end while loop for iteration of fitting procedure ********/
for( mm=0 ; mm < NMEM ; mm++ )
if( fitmem[mm] != NULL ){ free((void *)fitmem[mm]); fitmem[mm] = NULL; }
/*--- 09 Jan 2006: if prior best fit was better than current, replace ---*/
if( best_dif > 0.0f && 1.0666f*best_dif < sdif ){
memcpy( fit , best_par , sizeof(float)*npar ) ;
if( bas->verb )
fprintf(stderr,"+++++ Replacing final fit with iter #%d's fit +++++\n",
best_ite+1) ;
}
/*--- do the second pass? ---*/
if( blur_pass ){
if( bas->verb )
fprintf(stderr,"+++++++++++++ Loop back for next pass +++++++++++++\n");
mri_free(fim) ; fim = NULL ; passnum++ ; goto ReStart ;
} else {
if( bas->verb )
fprintf(stderr,"+++++++++++++ Convergence test passed +++++++++++++\n");
}
/*--- done! ---*/
bas->num_iter = iter ;
for( pp=0 ; pp < npar ; pp++ ) bas->param[pp].val_out = fit[pp] ;
/*-- do the actual realignment to get the output image --*/
if( bas->regfinal > 0 ) mri_warp3D_method( bas->regfinal ) ;
mri_warp3D_set_womask( NULL ) ;
bas->vwset( npar , fit ) ;
tim = mri_warp3D( fim , 0,0,0 , bas->vwfor ) ;
if( fim != im ) mri_free(fim) ; /* if it was a copy, junk it */
free((void *)dfit) ; free((void *)fit) ;
free((void *)qfit) ; free((void *)pma) ; free((void *)tol) ;
if( bas->verb ){
double st = (NI_clock_time()-ctstart) * 0.001 ;
fprintf(stderr,"++ mri_warp3D_align_one EXIT: %.2f seconds elapsed\n",st) ;
}
RETURN( tim ) ;
}
MRI_IMAGE *mri_to_complex( MRI_IMAGE *oldim )
{
MRI_IMAGE *newim ;
register int ii , npix ;
register complex *nar ;
ENTRY("mri_to_complex") ;
if( oldim == NULL ) RETURN( NULL ); /* 09 Feb 1999 */
newim = mri_new_conforming( oldim , MRI_complex ) ;
npix = oldim->nvox ;
nar = MRI_COMPLEX_PTR(newim) ;
switch( oldim->kind ){
case MRI_byte:{
byte *qar = MRI_BYTE_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ) nar[ii].r = qar[ii] ;
}
break ;
case MRI_short:{
short *qar = MRI_SHORT_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ) nar[ii].r = qar[ii] ;
}
break ;
case MRI_int:{
int *qar = MRI_INT_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ) nar[ii].r = qar[ii] ;
}
break ;
case MRI_float:{
float *qar = MRI_FLOAT_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ) nar[ii].r = qar[ii] ;
}
break ;
case MRI_double:{
double *qar = MRI_DOUBLE_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ) nar[ii].r = qar[ii] ;
}
break ;
case MRI_complex:{
complex *qar = MRI_COMPLEX_PTR(oldim) ;
(void) memcpy( nar , qar , sizeof(complex)*npix ) ;
}
break ;
case MRI_rgb:{ /* 16 Jun 2000 */
byte *rgb = MRI_RGB_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ ){ /* scale to brightness */
nar[ii].r = 0.299 * rgb[3*ii] /* between 0 and 255 */
+ 0.587 * rgb[3*ii+1]
+ 0.114 * rgb[3*ii+2] ;
}
}
break ;
default:
fprintf( stderr , "mri_to_complex: unrecognized image kind\n" ) ;
MRI_FATAL_ERROR ;
}
if( oldim->kind != MRI_complex ){
for( ii=0 ; ii < npix ; ii++ ) nar[ii].i = 0.0 ;
}
MRI_COPY_AUX(newim,oldim) ;
RETURN( newim );
}
MRI_IMAGE * FD_brick_to_mri( int kslice , int ival , FD_brick * br )
{
MRI_IMAGE * im ; /* output */
register int ii,di,ei , jj,dj,ej , base , pp ;
char * iar ; /* brick in the input */
MRI_TYPE typ ;
/** desire a fake image **/
if( ival < 0 ){
im = mri_new( br->n1 , br->n2 , MRI_short ) ;
im->dx = br->del1 ;
im->dy = br->del2 ;
im->dz = br->del3 ;
return im ;
}
/** otherwise, get ready for a real image **/
if( ival >= br->dset->dblk->nvals ) return NULL ;
iar = DSET_ARRAY(br->dset,ival) ;
if( iar == NULL ){ /* if data needs to be loaded from disk */
(void) THD_load_datablock( br->dset->dblk ) ;
iar = DSET_ARRAY(br->dset,ival) ;
if( iar == NULL ) return NULL ;
}
typ = DSET_BRICK_TYPE(br->dset,ival) ;
im = mri_new( br->n1 , br->n2 , typ ) ;
im->dx = br->del1 ;
im->dy = br->del2 ;
im->dz = br->del3 ;
switch( typ ){
default: /* don't know what to do --> return nada */
mri_free( im ) ;
return NULL ;
case MRI_byte:{
register byte * ar = MRI_BYTE_PTR(im) ;
register byte * bar = (byte *) iar ;
di = br->d1 ; dj = br->d2 ; /* strides */
ei = br->e1 ; ej = br->e2 ; /* final indices */
base = br->start + kslice * br->d3 ;
pp = 0 ;
for( jj=0 ; jj != ej ; jj += dj )
for( ii=0 ; ii != ei ; ii += di ) ar[pp++] = bar[ii+(jj+base)] ;
}
break ;
case MRI_short:{
register short * ar = MRI_SHORT_PTR(im) ;
register short * bar = (short *) iar ;
di = br->d1 ; dj = br->d2 ; /* strides */
ei = br->e1 ; ej = br->e2 ; /* final indices */
base = br->start + kslice * br->d3 ;
pp = 0 ;
for( jj=0 ; jj != ej ; jj += dj )
for( ii=0 ; ii != ei ; ii += di ) ar[pp++] = bar[ii+(jj+base)] ;
}
break ;
case MRI_float:{
register float * ar = MRI_FLOAT_PTR(im) ;
register float * bar = (float *) iar ;
di = br->d1 ; dj = br->d2 ; /* strides */
ei = br->e1 ; ej = br->e2 ; /* final indices */
base = br->start + kslice * br->d3 ;
pp = 0 ;
for( jj=0 ; jj != ej ; jj += dj )
for( ii=0 ; ii != ei ; ii += di ) ar[pp++] = bar[ii+(jj+base)] ;
}
break ;
case MRI_int:{
register int * ar = MRI_INT_PTR(im) ;
register int * bar = (int *) iar ;
di = br->d1 ; dj = br->d2 ; /* strides */
ei = br->e1 ; ej = br->e2 ; /* final indices */
base = br->start + kslice * br->d3 ;
pp = 0 ;
for( jj=0 ; jj != ej ; jj += dj )
for( ii=0 ; ii != ei ; ii += di ) ar[pp++] = bar[ii+(jj+base)] ;
}
break ;
case MRI_double:{
register double * ar = MRI_DOUBLE_PTR(im) ;
register double * bar = (double *) iar ;
di = br->d1 ; dj = br->d2 ; /* strides */
ei = br->e1 ; ej = br->e2 ; /* final indices */
base = br->start + kslice * br->d3 ;
pp = 0 ;
for( jj=0 ; jj != ej ; jj += dj )
for( ii=0 ; ii != ei ; ii += di ) ar[pp++] = bar[ii+(jj+base)] ;
}
break ;
case MRI_complex:{
register complex * ar = MRI_COMPLEX_PTR(im) ;
register complex * bar = (complex *) iar ;
di = br->d1 ; dj = br->d2 ; /* strides */
ei = br->e1 ; ej = br->e2 ; /* final indices */
base = br->start + kslice * br->d3 ;
pp = 0 ;
for( jj=0 ; jj != ej ; jj += dj )
for( ii=0 ; ii != ei ; ii += di ) ar[pp++] = bar[ii+(jj+base)] ;
}
break ;
case MRI_rgb:{ /* 15 Apr 2002 */
register rgbyte * ar = (rgbyte *) MRI_RGB_PTR(im) ;
register rgbyte * bar = (rgbyte *) iar ;
di = br->d1 ; dj = br->d2 ; /* strides */
ei = br->e1 ; ej = br->e2 ; /* final indices */
base = br->start + kslice * br->d3 ;
pp = 0 ;
for( jj=0 ; jj != ej ; jj += dj )
for( ii=0 ; ii != ei ; ii += di ) ar[pp++] = bar[ii+(jj+base)] ;
}
break ;
}
if( DSET_BRICK_FACTOR(br->dset,ival) != 0.0 ){
MRI_IMAGE * qim ;
STATUS(" scaling to float");
qim = mri_scale_to_float( DSET_BRICK_FACTOR(br->dset,ival) , im ) ;
mri_free(im) ; im = qim ;
}
return im ;
}
MRI_IMAGE * FD_brick_to_series( int ixyz , FD_brick *br )
{
MRI_IMAGE *im ; /* output */
int nv , ival ;
char *iar ; /* brick in the input */
MRI_TYPE typ ;
int ix,jy,kz , ind ;
THD_ivec3 ind_fd , ind_ds ;
if( ixyz < 0 || ixyz >= br->n1 * br->n2 * br->n3 ) return NULL ;
/** otherwise, get ready for a real image **/
ix = ixyz % br->n1 ;
jy = ( ixyz % (br->n1 * br->n2) ) / br->n1 ;
kz = ixyz / (br->n1 * br->n2) ;
LOAD_IVEC3( ind_fd , ix,jy,kz ) ; ind_ds = THD_fdind_to_3dind( br , ind_fd ) ;
ix = ind_ds.ijk[0] ;
jy = ind_ds.ijk[1] ;
kz = ind_ds.ijk[2] ;
ind = (kz * br->dset->daxes->nyy + jy) * br->dset->daxes->nxx + ix ;
nv = br->dset->dblk->nvals ;
iar = DSET_ARRAY(br->dset,0) ;
if( iar == NULL ){ /* if data needs to be loaded from disk */
(void) THD_load_datablock( br->dset->dblk ) ;
iar = DSET_ARRAY(br->dset,0) ;
if( iar == NULL ) return NULL ;
}
/* 15 Sep 2004: allow for nonconstant datum */
if( !DSET_datum_constant(br->dset) ){ /* only for stupid users */
float *ar ;
im = mri_new( nv , 1 , MRI_float ) ; ar = MRI_FLOAT_PTR(im) ;
for( ival = 0 ; ival < nv ; ival++ )
ar[ival] = THD_get_voxel( br->dset , ind , ival ) ;
goto image_done ;
}
/* the older (more efficient) way */
typ = DSET_BRICK_TYPE(br->dset,0) ;
im = mri_new( nv , 1 , typ ) ;
#if 0
mri_zero_image(im) ; /* 18 Oct 2001 */
#endif
switch( typ ){
default: /* don't know what to do --> return nada */
mri_free( im ) ;
return NULL ;
case MRI_byte:{
byte *ar = MRI_BYTE_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (byte *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_short:{
short *ar = MRI_SHORT_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (short *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_float:{
float *ar = MRI_FLOAT_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (float *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_int:{
int *ar = MRI_INT_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (int *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_double:{
double *ar = MRI_DOUBLE_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (double *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_complex:{
complex *ar = MRI_COMPLEX_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (complex *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
/* 15 Apr 2002: RGB types */
case MRI_rgb:{
rgbyte *ar = (rgbyte *) MRI_RGB_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (rgbyte *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
case MRI_rgba:{
rgba *ar = (rgba *) MRI_RGBA_PTR(im) , *bar ;
for( ival=0 ; ival < nv ; ival++ ){
bar = (rgba *) DSET_ARRAY(br->dset,ival) ;
if( bar != NULL ) ar[ival] = bar[ind] ;
}
}
break ;
}
if( THD_need_brick_factor(br->dset) ){
MRI_IMAGE *qim ;
qim = mri_mult_to_float( br->dset->dblk->brick_fac , im ) ;
mri_free(im) ; im = qim ;
}
/* at this point, the image is ready to ship out;
but first, maybe attach a time origin and spacing */
image_done:
if( br->dset->taxis != NULL ){ /* 21 Oct 1996 */
float zz , tt ;
zz = br->dset->daxes->zzorg + kz * br->dset->daxes->zzdel ;
tt = THD_timeof( 0 , zz , br->dset->taxis ) ;
im->xo = tt ; im->dx = br->dset->taxis->ttdel ; /* origin and delta */
if( br->dset->taxis->units_type == UNITS_MSEC_TYPE ){ /* convert to sec */
im->xo *= 0.001 ; im->dx *= 0.001 ;
}
} else {
im->xo = 0.0 ; im->dx = 1.0 ; /* 08 Nov 1996 */
}
return im ;
}
MRI_IMAGE *mri_to_short( double scl , MRI_IMAGE *oldim )
{
MRI_IMAGE *newim ;
register int ii , npix ;
register double scale , val ;
register short *sar ;
ENTRY("mri_to_short") ;
if( oldim == NULL ) RETURN( NULL ); /* 09 Feb 1999 */
newim = mri_new_conforming( oldim , MRI_short ) ;
sar = MRI_SHORT_PTR(newim) ;
npix = oldim->nvox ;
if( scl == 0.0 ){
switch( oldim->kind ){
case MRI_int:
case MRI_float:
case MRI_double:
case MRI_complex:
scale = mri_maxabs( oldim ) ;
if( scale != 0.0 ) scale = 10000.0 / scale ;
#ifdef MRI_DEBUG
fprintf( stderr , "mri_to_short: scale factor = %e\n" , scale ) ;
#endif
break ;
default:
scale = 1.0 ;
break ;
}
} else {
scale = scl ;
}
switch( oldim->kind ){
case MRI_rgb:{
byte *rgb = MRI_RGB_PTR(oldim) ;
float rfac=0.299*scale , gfac=0.587*scale , bfac=0.114*scale ;
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = (short)( rfac * rgb[3*ii]
+ gfac * rgb[3*ii+1]
+ bfac * rgb[3*ii+2] ) ;
}
break ;
case MRI_byte:{
byte *qar = MRI_BYTE_PTR(oldim) ;
if( scale != 1.0 )
for( ii=0 ; ii < npix ; ii++ ){
val = scale * qar[ii] ;
sar[ii] = SHORTIZE(val) ;
}
else
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = (short) qar[ii] ;
break ;
}
case MRI_short:{
short *qar = MRI_SHORT_PTR(oldim) ;
if( scale != 1.0 )
for( ii=0 ; ii < npix ; ii++ ){
val = scale * qar[ii] ;
sar[ii] = SHORTIZE(val) ;
}
else
(void) memcpy( sar , qar , sizeof(short)*npix ) ;
break ;
}
case MRI_int:{
int *qar = MRI_INT_PTR(oldim) ;
if( scale != 1.0 )
for( ii=0 ; ii < npix ; ii++ ){
val = scale * qar[ii] ;
sar[ii] = SHORTIZE(val) ;
}
else
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = SHORTIZE(qar[ii]) ;
break ;
}
case MRI_float:{
float *qar = MRI_FLOAT_PTR(oldim) ;
if( scale != 1.0 )
for( ii=0 ; ii < npix ; ii++ ){
val = scale * qar[ii] ;
sar[ii] = SHORTIZE(val) ;
}
else
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = SHORTIZE(qar[ii]) ;
break ;
}
case MRI_double:{
double *qar = MRI_DOUBLE_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = scale * qar[ii] ;
break ;
}
case MRI_complex:{
complex *qar = MRI_COMPLEX_PTR(oldim) ;
for( ii=0 ; ii < npix ; ii++ )
sar[ii] = scale * CABS(qar[ii]) ;
break ;
}
default:
fprintf( stderr , "mri_to_short: unrecognized image kind\n" ) ;
MRI_FATAL_ERROR ;
}
MRI_COPY_AUX(newim,oldim) ;
RETURN( newim );
}
MRI_IMAGE * mri_cat2D( int mx , int my , int gap ,
void *gapval , MRI_IMARR *imar )
{
int nx , ny , ii , jj , kind , ij , nxout , nyout , ijoff , jout,iout ;
MRI_IMAGE *imout , *imin=NULL ;
void *vout ;
ENTRY("mri_cat2D") ;
/*--- sanity checks ---*/
if( mx < 1 || my < 1 || imar == NULL ||
(!OK_wrap && imar->num < mx*my) )
RETURN( NULL );
if( gap < 0 || (gap > 0 && gapval == NULL) ) RETURN( NULL );
for( ij=0 ; ij < mx*my ; ij++ ){ /* find first non-empty image */
imin = IMARR_SUBIMAGE(imar,ij%imar->num) ;
if( imin != NULL ) break ;
}
if( ij == mx*my ) RETURN( NULL ); /* all are empty! */
kind = imin->kind ;
nx = imin->nx ;
ny = imin->ny ;
if( mx==1 && my==1 ){ /* 1x1 case (shouldn't happen) */
imout = mri_to_mri( kind , imin ) ; /* Just copy input to output */
RETURN( imout );
}
for( ij=0 ; ij < mx*my ; ij++ ){ /* check for consistency */
imin = IMARR_SUBIMAGE(imar,ij%imar->num) ;
if( imin != NULL &&
(imin->kind != kind || imin->nx != nx || imin->ny != ny) )
RETURN( NULL );
}
nxout = mx * nx + (mx-1) * gap ;
nyout = my * ny + (my-1) * gap ;
imout = mri_new( nxout , nyout , kind ) ;
vout = mri_data_pointer( imout ) ;
ij = 0 ;
for( jj=0 ; jj < my ; jj++ ){ /* loop over rows */
for( ii=0 ; ii < mx ; ii++ , ij++ ){ /* loop over columns */
if (WrapZero && ij >= imar->num) imin = NULL;
else imin = IMARR_SUBIMAGE(imar,ij%imar->num) ;
ijoff = ii * (nx+gap) + jj * (ny+gap) * nxout ;
/*--- NULL image ==> fill this spot with zeroes ---*/
if( imin == NULL || mri_data_pointer(imin) == NULL ){
switch( kind ){
case MRI_byte:{
byte *pout = ((byte *) vout);
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
(void) memset( pout+ijoff , 0 , sizeof(byte)*nx ) ;
} break ;
case MRI_rgb:{ /* 11 Feb 1999 */
byte *pout = ((byte *) vout);
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
(void) memset( pout+(3*ijoff) , 0 , sizeof(byte)*(3*nx) ) ;
} break ;
case MRI_short:{
short *pout = ((short *) vout);
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
(void) memset( pout+ijoff , 0 , sizeof(short)*nx ) ;
} break ;
case MRI_int:{
int *pout = ((int *) vout);
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
(void) memset( pout+ijoff , 0 , sizeof(int)*nx ) ;
} break ;
case MRI_float:{
float *pout = ((float *) vout);
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
for( iout=0 ; iout < nx ; iout++ )
pout[iout+ijoff] = 0 ;
} break ;
case MRI_double:{
double *pout = ((double *) vout);
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
for( iout=0 ; iout < nx ; iout++ )
pout[iout+ijoff] = 0 ;
} break ;
case MRI_complex:{
complex *pout = ((complex *) vout);
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
for( iout=0 ; iout < nx ; iout++ )
pout[iout+ijoff].r = pout[iout+ijoff].i = 0 ;
} break ;
}
/*--- Copy input image data into place ---*/
} else {
switch( kind ){
case MRI_byte:{
byte *pout = ((byte *) vout) ,
*pin = (byte *) MRI_BYTE_PTR(imin) ;
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
memcpy( pout+ijoff , pin , sizeof(byte)*nx ) , pin += nx ;
} break ;
case MRI_rgb:{ /* 11 Feb 1999 */
byte *pout = ((byte *) vout) ,
*pin = (byte *) MRI_RGB_PTR(imin) ;
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
memcpy( pout+(3*ijoff) , pin , sizeof(byte)*(3*nx) ) , pin += 3*nx ;
} break ;
case MRI_short:{
short *pout = ((short *) vout) ,
*pin = (short *) MRI_SHORT_PTR(imin) ;
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
memcpy( pout+ijoff , pin , sizeof(short)*nx ) , pin += nx ;
} break ;
case MRI_int:{
int *pout = ((int *) vout) ,
*pin = (int *) MRI_INT_PTR(imin) ;
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
memcpy( pout+ijoff , pin , sizeof(int)*nx ) , pin += nx ;
} break ;
case MRI_float:{
float *pout = ((float *) vout) ,
*pin = (float *) MRI_FLOAT_PTR(imin) ;
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
memcpy( pout+ijoff , pin , sizeof(float)*nx ) , pin += nx ;
} break ;
case MRI_double:{
double *pout = ((double *) vout) ,
*pin = (double *) MRI_DOUBLE_PTR(imin) ;
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
memcpy( pout+ijoff , pin , sizeof(double)*nx ) , pin += nx ;
} break ;
case MRI_complex:{
complex *pout = ((complex *) vout) ,
*pin = (complex *) MRI_COMPLEX_PTR(imin) ;
for( jout=0 ; jout < ny ; jout++ , ijoff+=nxout )
memcpy( pout+ijoff , pin , sizeof(complex)*nx ) , pin += nx ;
} break ;
}
}
}
}
/******************* Deal with the gaps *******************/
if( gap > 0 ){
/**** put value into gap after each row ****/
ii = nxout * gap ;
for( jj=0 ; jj < my-1 ; jj++ ){
ijoff = (ny + jj * (ny+gap)) * nxout ;
switch( kind ){
case MRI_byte:{
byte gval = *((byte *)gapval) , *pout = ((byte *) vout) ;
for( ij=0 ; ij < ii ; ij++ ) pout[ij+ijoff] = gval ;
} break ;
case MRI_rgb:{ /* 11 Feb 1999 */
byte rval = *(((byte *)gapval) ) ,
gval = *(((byte *)gapval)+1) ,
bval = *(((byte *)gapval)+2) , *pout = ((byte *) vout) ;
for( ij=0 ; ij < ii ; ij++ ){
pout[3*(ij+ijoff) ] = rval ;
pout[3*(ij+ijoff)+1] = gval ;
pout[3*(ij+ijoff)+2] = bval ;
}
} break ;
case MRI_short:{
short gval = *((short *)gapval) , *pout = ((short *) vout) ;
for( ij=0 ; ij < ii ; ij++ ) pout[ij+ijoff] = gval ;
} break ;
case MRI_float:{
float gval = *((float *)gapval) , *pout = ((float *) vout) ;
for( ij=0 ; ij < ii ; ij++ ) pout[ij+ijoff] = gval ;
} break ;
case MRI_int:{
int gval = *((int *)gapval) , *pout = ((int *) vout) ;
for( ij=0 ; ij < ii ; ij++ ) pout[ij+ijoff] = gval ;
} break ;
case MRI_double:{
double gval = *((double *)gapval) , *pout = ((double *) vout) ;
for( ij=0 ; ij < ii ; ij++ ) pout[ij+ijoff] = gval ;
} break ;
case MRI_complex:{
complex gval = *((complex *)gapval) , *pout = ((complex *) vout) ;
for( ij=0 ; ij < ii ; ij++ ) pout[ij+ijoff] = gval ;
} break ;
}
}
/**** put value into gap after each column ****/
for( ii=0 ; ii < mx-1 ; ii++ ){
ijoff = nx + ii*(nx+gap) ;
switch( kind ){
case MRI_byte:{
byte gval = *((byte *)gapval) , *pout = ((byte *) vout) ;
for( ij=0 ; ij < gap ; ij++ , ijoff++ )
for( jj=0 ; jj < nyout ; jj++ ) pout[jj*nxout+ijoff] = gval ;
} break ;
case MRI_rgb:{ /* 11 Feb 1999 */
byte rval = *(((byte *)gapval) ) ,
gval = *(((byte *)gapval)+1) ,
bval = *(((byte *)gapval)+2) , *pout = ((byte *) vout) ;
for( ij=0 ; ij < gap ; ij++ , ijoff++ )
for( jj=0 ; jj < nyout ; jj++ ){
pout[3*(jj*nxout+ijoff) ] = rval ;
pout[3*(jj*nxout+ijoff)+1] = gval ;
pout[3*(jj*nxout+ijoff)+2] = bval ;
}
} break ;
case MRI_short:{
short gval = *((short *)gapval) , *pout = ((short *) vout) ;
for( ij=0 ; ij < gap ; ij++ , ijoff++ )
for( jj=0 ; jj < nyout ; jj++ ) pout[jj*nxout+ijoff] = gval ;
} break ;
case MRI_float:{
float gval = *((float *)gapval) , *pout = ((float *) vout) ;
for( ij=0 ; ij < gap ; ij++ , ijoff++ )
for( jj=0 ; jj < nyout ; jj++ ) pout[jj*nxout+ijoff] = gval ;
} break ;
case MRI_int:{
int gval = *((int *)gapval) , *pout = ((int *) vout) ;
for( ij=0 ; ij < gap ; ij++ , ijoff++ )
for( jj=0 ; jj < nyout ; jj++ ) pout[jj*nxout+ijoff] = gval ;
} break ;
case MRI_double:{
double gval = *((double *)gapval) , *pout = ((double *) vout) ;
for( ij=0 ; ij < gap ; ij++ , ijoff++ )
for( jj=0 ; jj < nyout ; jj++ ) pout[jj*nxout+ijoff] = gval ;
} break ;
case MRI_complex:{
complex gval = *((complex *)gapval) , *pout = ((complex *) vout) ;
for( ij=0 ; ij < gap ; ij++ , ijoff++ )
for( jj=0 ; jj < nyout ; jj++ ) pout[jj*nxout+ijoff] = gval ;
} break ;
}
}
}
RETURN( imout );
}
static MRI_IMAGE * mri_warp3D_align_fitim( MRI_warp3D_align_basis *bas ,
MRI_IMAGE *cim ,
int warp_mode , float delfac )
{
MRI_IMAGE *fitim , *pim , *mim ;
float *fitar , *car=MRI_FLOAT_PTR(cim) ;
int nfree=bas->nfree , *ima=MRI_INT_PTR(bas->imap) , nmap=bas->imap->nx ;
int npar =bas->nparam ;
float *pvec , *par , *mar ;
int ii , pp , cc ;
float dpar , delta ;
/*-- create image containing basis columns --*/
fitim = mri_new( nmap , nfree+1 , MRI_float ) ;
fitar = MRI_FLOAT_PTR(fitim) ;
pvec = (float *)malloc(sizeof(float) * npar) ;
#undef FMAT
#define FMAT(i,j) fitar[(i)+(j)*nmap] /* col dim=nmap, row dim=nfree+1 */
/* column #nfree = base image itself */
for( ii=0 ; ii < nmap ; ii++ ) FMAT(ii,nfree) = car[ima[ii]] ;
pvec = (float *)malloc(sizeof(float) * npar) ;
/* for each free parameter:
apply inverse transform to base image with param value up and down
compute central difference to approximate derivative of base
image wrt parameter
store as a column in the fitim matrix */
mri_warp3D_method( warp_mode ) ; /* set interpolation mode */
mri_warp3D_set_womask( bas->imsk ) ;
for( pp=0,cc=0 ; pp < npar ; pp++ ){
if( bas->param[pp].fixed ) continue ; /* don't do this one! */
/* init all params to their identity transform value */
for( ii=0 ; ii < npar ; ii++ )
pvec[ii] = (bas->param[ii].fixed) ? bas->param[ii].val_fixed
: bas->param[ii].ident ;
/* change in the pp-th parameter to use for derivative */
dpar = delfac * bas->param[pp].delta ;
if( bas->verb )
fprintf(stderr,"+ difference base by %f in param#%d [%s]\n",
dpar , pp+1 , bas->param[pp].name ) ;
pvec[pp] = bas->param[pp].ident + dpar ; /* set positive change */
bas->vwset( npar , pvec ) ; /* put into transform */
pim = mri_warp3D( cim , 0,0,0 , bas->vwinv ) ; /* warp image */
pvec[pp] = bas->param[pp].ident - dpar ; /* set negative change */
bas->vwset( npar , pvec ) ;
mim = mri_warp3D( cim , 0,0,0 , bas->vwinv ) ;
/* compute derivative */
delta = bas->scale_init / ( 2.0f * dpar ) ;
par = MRI_FLOAT_PTR(pim) ; mar = MRI_FLOAT_PTR(mim) ;
for( ii=0 ; ii < nmap ; ii++ )
FMAT(ii,cc) = delta * ( par[ima[ii]] - mar[ima[ii]] ) ;
#if 0
{ float psum=0.0f,msum=0.0f,dsum=0.0f;
for( ii=0 ; ii < nmap ; ii++ ){
psum += fabsf(par[ima[ii]]) ;
msum += fabsf(mar[ima[ii]]) ;
dsum += fabsf(FMAT(ii,cc)) ;
}
fprintf(stderr," pp=%d psum=%g msum=%g dsum=%g\n",pp,psum,msum,dsum) ;
}
#endif
mri_free(pim) ; mri_free(mim) ; /* no longer needed */
cc++ ; /* oopsie */
}
mri_warp3D_set_womask( NULL ) ;
free((void *)pvec) ;
#if 0
{ int zz , jj ;
for( jj=0 ; jj <= nfree ; jj++ ){
zz = 0 ;
for( ii=0 ; ii < nmap ; ii++ ) if( FMAT(ii,jj) == 0.0 ) zz++ ;
fprintf(stderr," fitim: col#%d has %d zeros out of %d\n",jj,zz,nmap) ;
}
}
#endif
return(fitim) ;
}
MRI_IMAGE *mri_to_complex_ext( MRI_IMAGE *oldim, int xnew, int ynew, int altern )
{
MRI_IMAGE *newim ; complex *nar ;
int oldx,oldy , itop,jtop , ii,jj , jbold,jbnew ;
ENTRY("mri_to_complex_ext") ;
if( oldim == NULL ) RETURN( NULL ); /* 09 Feb 1999 */
if( ! MRI_IS_2D(oldim) ){
fprintf(stderr,"\n*** mri_to_complex_ext only works on 2D images\n") ;
RETURN( NULL );
}
oldx = oldim->nx ;
oldy = oldim->ny ;
itop = (xnew<oldx) ? xnew : oldx ; /* smallest x dimension */
jtop = (ynew<oldy) ? ynew : oldy ; /* smallest y dimension */
newim = mri_new( xnew , ynew , MRI_complex ) ;
nar = MRI_COMPLEX_PTR(newim) ;
/*** copy 0..itop by 0..jtop from old into new ***/
for( jj=0 ; jj < jtop ; jj++ ){
jbold = oldx * jj ;
jbnew = xnew * jj ;
for( ii=0 ; ii < itop ; ii++ ){
nar[ii+jbnew].i = 0.0 ;
switch( oldim->kind ){
default: break ;
case MRI_byte:{ byte *qar = MRI_BYTE_PTR(oldim) ;
nar[ii+jbnew].r = qar[ii+jbold] ;
} break ;
case MRI_short:{ short *qar = MRI_SHORT_PTR(oldim) ;
nar[ii+jbnew].r = qar[ii+jbold] ;
} break ;
case MRI_int:{ int *qar = MRI_INT_PTR(oldim) ;
nar[ii+jbnew].r = qar[ii+jbold] ;
} break ;
case MRI_float:{ float *qar = MRI_FLOAT_PTR(oldim) ;
nar[ii+jbnew].r = qar[ii+jbold] ;
} break ;
case MRI_double:{ double *qar = MRI_DOUBLE_PTR(oldim) ;
nar[ii+jbnew].r = qar[ii+jbold] ;
} break ;
case MRI_complex:{ complex *qar = MRI_COMPLEX_PTR(oldim) ;
nar[ii+jbnew] = qar[ii+jbold] ;
} break ;
}
}
}
/*** if old image is smaller in x, extend all x rows with zeros ***/
if( oldx < xnew ){
for( jj=0 ; jj < jtop ; jj++ ){
jbnew = jj * xnew ;
for( ii=oldx ; ii < xnew ; ii++ ){
nar[ii+jbnew].r = 0.0 ; nar[ii+jbnew].i = 0.0 ;
}
}
}
/*** if old image is smaller in y, fill out last rows with zeros ***/
for( jj=oldy ; jj < ynew ; jj++ ){
jbnew = jj * xnew ;
for( ii=0 ; ii < xnew ; ii++ ){
nar[ii+jbnew].r = 0.0 ; nar[ii+jbnew].i = 0.0 ;
}
}
if( altern ){
for( jj=0 ; jj < ynew ; jj++ ){
jbnew = jj * xnew ;
for( ii=0 ; ii < xnew ; ii++ ){
if( (ii+jj)%2 ){
nar[ii+jbnew].r = - nar[ii+jbnew].r ;
nar[ii+jbnew].i = - nar[ii+jbnew].i ;
}
}
}
}
MRI_COPY_AUX(newim,oldim) ;
RETURN( newim );
}
int mri_warp3D_align_setup( MRI_warp3D_align_basis *bas )
{
MRI_IMAGE *cim , *fitim ;
int nx, ny, nz, nxy, nxyz , ii,jj,kk , nmap, *im ;
float *wf , *wtar , clip , clip2 ;
int *ima , pp , wtproc , npar , nfree ;
byte *msk ;
int ctstart ;
ENTRY("mri_warp3D_align_setup") ;
ctstart = NI_clock_time() ;
/*- check for good inputs -*/
if( bas == NULL || bas->imbase == NULL ) RETURN(1) ;
if( bas->nparam < 1 || bas->param == NULL ) RETURN(1) ;
if( bas->vwfor == NULL ||
bas->vwinv == NULL || bas->vwset == NULL ) RETURN(1) ;
/*- set defaults in bas, if values weren't set by user -*/
if( bas->scale_init <= 0.0f ) bas->scale_init = 1.0f ;
if( bas->delfac <= 0.0f ) bas->delfac = 1.0f ;
if( bas->regmode <= 0 ) bas->regmode = MRI_LINEAR ;
if( bas->max_iter <= 0 ) bas->max_iter = 9 ;
/* process the weight image? */
wtproc = (bas->imwt == NULL) ? 1 : bas->wtproc ;
npar = bas->nparam ;
nfree = npar ;
for( pp=0 ; pp < npar ; pp++ )
if( bas->param[pp].fixed ) nfree-- ;
if( nfree <= 0 ) RETURN(1) ;
bas->nfree = nfree ;
/*- clean out anything from last call -*/
mri_warp3D_align_cleanup( bas ) ;
/*-- need local copy of input base image --*/
cim = mri_to_float( bas->imbase ) ;
nx=cim->nx ; ny=cim->ny ; nz=cim->nz ; nxy = nx*ny ; nxyz=nxy*nz ;
/*-- make weight image up from the base image if it isn't supplied --*/
if( bas->verb ) fprintf(stderr,"++ mri_warp3D_align_setup ENTRY\n") ;
if( bas->imwt == NULL ||
bas->imwt->nx != nx ||
bas->imwt->ny != ny ||
bas->imwt->nz != nz ) bas->imww = mri_copy( cim ) ;
else bas->imww = mri_to_float( bas->imwt ) ;
if( bas->twoblur > 0.0f ){
float bmax = cbrt((double)nxyz) * 0.03 ;
if( bmax < bas->twoblur ){
if( bas->verb )
fprintf(stderr,"+ shrink bas->twoblur from %.3f to %.3f\n",
bas->twoblur , bmax ) ;
bas->twoblur = bmax ;
}
}
if( bas->verb ) fprintf(stderr,"+ processing weight:") ;
/* make sure weight is non-negative */
wf = MRI_FLOAT_PTR(bas->imww) ;
for( ii=0 ; ii < nxyz ; ii++ ) wf[ii] = fabs(wf[ii]) ;
/* trim off edges of weight */
if( wtproc ){
int ff ;
int xfade=bas->xedge , yfade=bas->yedge , zfade=bas->zedge ;
if( xfade < 0 || yfade < 0 || zfade < 0 )
mri_warp3D_align_edging_default(nx,ny,nz,&xfade,&yfade,&zfade) ;
if( bas->twoblur > 0.0f ){
xfade += (int)rint(1.5*bas->twoblur) ;
yfade += (int)rint(1.5*bas->twoblur) ;
zfade += (int)rint(1.5*bas->twoblur) ;
}
if( 3*zfade >= nz ) zfade = (nz-1)/3 ;
if( 3*xfade >= nx ) xfade = (nx-1)/3 ;
if( 3*yfade >= ny ) yfade = (ny-1)/3 ;
if( bas->verb ) fprintf(stderr," [edge(%d,%d,%d)]",xfade,yfade,zfade) ;
for( jj=0 ; jj < ny ; jj++ )
for( ii=0 ; ii < nx ; ii++ )
for( ff=0 ; ff < zfade ; ff++ )
WW(ii,jj,ff) = WW(ii,jj,nz-1-ff) = 0.0f ;
for( kk=0 ; kk < nz ; kk++ )
for( jj=0 ; jj < ny ; jj++ )
for( ff=0 ; ff < xfade ; ff++ )
WW(ff,jj,kk) = WW(nx-1-ff,jj,kk) = 0.0f ;
for( kk=0 ; kk < nz ; kk++ )
for( ii=0 ; ii < nx ; ii++ )
for( ff=0 ; ff < yfade ; ff++ )
WW(ii,ff,kk) = WW(ii,ny-1-ff,kk) = 0.0f ;
}
/* spatially blur weight a little */
if( wtproc ){
float blur ;
blur = 1.0f + MAX(1.5f,bas->twoblur) ;
if( bas->verb ) fprintf(stderr," [blur(%.1f)]",blur) ;
EDIT_blur_volume_3d( nx,ny,nz , 1.0f,1.0f,1.0f ,
MRI_float , wf , blur,blur,blur ) ;
}
/* get rid of low-weight voxels */
clip = 0.035 * mri_max(bas->imww) ;
clip2 = 0.5*THD_cliplevel(bas->imww,0.4) ;
if( clip2 > clip ) clip = clip2 ;
if( bas->verb ) fprintf(stderr," [clip(%.1f)]",clip) ;
for( ii=0 ; ii < nxyz ; ii++ ) if( wf[ii] < clip ) wf[ii] = 0.0f ;
/* keep only the largest cluster of nonzero voxels */
{ byte *mmm = (byte *)malloc( sizeof(byte)*nxyz ) ;
for( ii=0 ; ii < nxyz ; ii++ ) mmm[ii] = (wf[ii] > 0.0f) ;
THD_mask_clust( nx,ny,nz, mmm ) ;
THD_mask_erode( nx,ny,nz, mmm, 1 ) ; /* cf. thd_automask.c */
THD_mask_clust( nx,ny,nz, mmm ) ;
for( ii=0 ; ii < nxyz ; ii++ ) if( !mmm[ii] ) wf[ii] = 0.0f ;
free((void *)mmm) ;
}
if( bas->verb ) fprintf(stderr,"\n") ;
/*-- make integer index map of weight > 0 voxels --*/
nmap = 0 ;
for( ii=0 ; ii < nxyz ; ii++ ) if( wf[ii] > 0.0f ) nmap++ ;
if( bas->verb )
fprintf(stderr,"+ using %d [%.3f%%] voxels\n",nmap,(100.0*nmap)/nxyz);
if( nmap < 7*nfree+13 ){
fprintf(stderr,"** mri_warp3D_align error: weight image too zero-ish!\n") ;
mri_warp3D_align_cleanup( bas ) ; mri_free(cim) ;
RETURN(1) ;
}
bas->imap = mri_new( nmap , 1 , MRI_int ) ;
ima = MRI_INT_PTR(bas->imap) ;
bas->imsk = mri_new_conforming( bas->imww , MRI_byte ) ;
msk = MRI_BYTE_PTR(bas->imsk) ;
for( ii=jj=0 ; ii < nxyz ; ii++ ){
if( wf[ii] > 0.0f ){ ima[jj++] = ii; msk[ii] = 1; }
}
/* make copy of sqrt(weight), but only at mapped indexes */
wtar = (float *)malloc(sizeof(float)*nmap) ;
for( ii=0 ; ii < nmap ; ii++ ) wtar[ii] = sqrt(wf[ima[ii]]) ;
/*-- for parameters that don't come with a step size, find one --*/
clip = bas->tolfac ; if( clip <= 0.0f ) clip = 0.03f ;
for( ii=0 ; ii < npar ; ii++ ){
if( bas->param[ii].fixed ) continue ; /* don't need this */
if( bas->param[ii].delta <= 0.0f )
mri_warp3D_get_delta( bas , ii ) ; /* find step size */
if( bas->param[ii].toler <= 0.0f ){ /* and set default tolerance */
bas->param[ii].toler = clip * bas->param[ii].delta ;
if( bas->verb )
fprintf(stderr,"+ set toler param#%d [%s] = %f\n",
ii+1,bas->param[ii].name,bas->param[ii].toler) ;
}
}
/* don't need the computed weight image anymore */
mri_free(bas->imww) ; bas->imww = NULL ; wf = NULL ;
/*-- create image containing basis columns, then pseudo-invert it --*/
if( bas->verb ) fprintf(stderr,"+ Compute Derivatives of Base\n") ;
fitim = mri_warp3D_align_fitim( bas , cim , bas->regmode , bas->delfac ) ;
if( bas->verb ) fprintf(stderr,"+ calculate pseudo-inverse\n") ;
bas->imps = mri_psinv( fitim , wtar ) ;
mri_free(fitim) ;
if( bas->imps == NULL ){ /* bad bad bad */
fprintf(stderr,"** mri_warp3D_align error: can't invert Base matrix!\n") ;
free((void *)wtar) ; mri_warp3D_align_cleanup( bas ) ; mri_free(cim) ;
RETURN(1) ;
}
/*--- twoblur? ---*/
if( bas->twoblur > 0.0f ){
float *car=MRI_FLOAT_PTR(cim) ;
float blur = bas->twoblur ;
float bfac = blur ;
if( bfac < 1.1234f ) bfac = 1.1234f ;
else if( bfac > 1.3456f ) bfac = 1.3456f ;
if( bas->verb ) fprintf(stderr,"+ Compute Derivatives of Blurred Base\n") ;
EDIT_blur_volume_3d( nx,ny,nz , 1.0f,1.0f,1.0f ,
MRI_float , car, blur,blur,blur ) ;
fitim = mri_warp3D_align_fitim( bas , cim , MRI_LINEAR , bfac*bas->delfac ) ;
if( bas->verb ) fprintf(stderr,"+ calculate pseudo-inverse\n") ;
bas->imps_blur = mri_psinv( fitim , wtar ) ;
mri_free(fitim) ;
if( bas->imps_blur == NULL ){ /* bad */
fprintf(stderr,"** mri_warp3D_align error: can't invert Blur matrix!\n") ;
}
}
/*--- done ---*/
mri_free(cim) ; free((void *)wtar) ;
if( bas->verb ){
double st = (NI_clock_time()-ctstart) * 0.001 ;
fprintf(stderr,"++ mri_warp3D_align_setup EXIT: %.2f seconds elapsed\n",st);
}
RETURN(0);
}
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_flatten( MRI_IMAGE * im )
{
MRI_IMAGE * flim , * intim , * outim ;
float * far , * outar ;
int * iar ;
int ii , nvox , ibot,itop , nvox1 ;
float fac , val ;
#ifdef DEBUG
printf("Entry: mri_flatten\n") ;
#endif
if( im == NULL ) return NULL ;
/*** make an image that is just the voxel index in its array ***/
/*** also, make the output image while we are at it ***/
nvox = im->nvox ;
intim = mri_new_conforming( im , MRI_int ) ;
outim = mri_new_conforming( im , MRI_float ) ;
iar = MRI_INT_PTR(intim) ; outar = MRI_FLOAT_PTR(outim) ;
for( ii=0 ; ii < nvox ; ii++ ) iar[ii] = ii ;
/*** copy the input data to a floating point image ***/
flim = mri_to_float( im ) ; far = MRI_FLOAT_PTR(flim) ;
/*** sort this image, with the index array being carried along
so that we know where every pixel came from originally ***/
qsort_pair( nvox , far , iar ) ;
/*** The "far" array is now sorted. Thus, if the pixel that was in
voxel i is now in voxel j, then its place in the histogram is
j/nvox. The only difficulty is that there may be ties. We need
to resolve these ties so that pixels with the same intensity
don't get different output values. We do this by scanning
through far, finding blocks of equal values, and replacing
them by their average position in the histogram.
***/
fac = 1.0 / nvox ; nvox1 = nvox - 1 ;
for( ibot=0 ; ibot < nvox1 ; ){
/** if this value is unique, just set the value and move on **/
val = far[ibot] ; itop = ibot+1 ;
if( val != far[itop] ){
far[ibot] = fac * ibot ;
ibot++ ; continue ;
}
/** scan itop up until value is distinct **/
for( ; itop < nvox1 && val == far[itop] ; itop++ ) ; /* nada */
val = 0.5*fac * (ibot+itop-1) ;
for( ii=ibot ; ii < itop ; ii++ ) far[ii] = val ;
ibot = itop ;
}
far[nvox1] = 1.0 ;
/*** now propagate these values back to the output image ***/
for( ii=0 ; ii < nvox ; ii++ ) outar[iar[ii]] = far[ii] ;
mri_free( flim ) ; mri_free( intim ) ;
MRI_COPY_AUX( outim , im ) ;
return outim ;
}
MRI_IMAGE * mri_valpad_2D( int nxbot , int nxtop ,
int nybot , int nytop , MRI_IMAGE *fim,
byte val)
{
int nxold,nyold , nxnew,nynew , nx,ny ;
int ii,jj , iibot,iitop , jjbot,jjtop ;
MRI_IMAGE *vim ;
ENTRY("mri_valpad_2D") ;
/*- check for user stupidity -*/
if( fim == NULL ) RETURN(NULL) ;
nx = fim->nx ; ny = fim->ny ;
/*- special case: just copy input -*/
if( nxbot == 0 && nybot == 0 &&
nxtop == 0 && nytop == 0 ){
vim = mri_copy( fim ) ;
RETURN(vim) ;
}
nxold = nx ; nxnew = nxold + nxbot + nxtop ; /* dimensions */
nyold = ny ; nynew = nyold + nybot + nytop ;
iibot = MAX(0,-nxbot) ; iitop = MIN(nxold,nxold+nxtop) ; /* range of data */
jjbot = MAX(0,-nybot) ; jjtop = MIN(nyold,nyold+nytop) ; /* in old dataset */
if( nxnew < 1 || iibot >= iitop || /* check for reasonable sizes */
nynew < 1 || jjbot >= jjtop ){ /* and ranges of dataset */
fprintf(stderr,"*** mri_zeropad: can't cut image down to nothing!\n") ;
RETURN(NULL) ;
}
vim = mri_new( nxnew , nynew , fim->kind ) ;
MRI_COPY_AUX(vim,fim) ;
memset( mri_data_pointer(vim) , val ,
nxnew*nynew*mri_datum_size(vim->kind) ) ;
/* macros for computing 1D subscripts from 2D indices */
#undef SNEW /* in case was defined in some stupid .h file */
#undef SOLD
#define SNEW(i,j) ((i+nxbot)+(j+nybot)*nxnew)
#define SOLD(i,j) (i+j*nxold)
switch( fim->kind ){ /* copy rows of old into new */
default:
fprintf(stderr,"*** mri_zeropad: unknown input datum=%d\n",fim->kind) ;
mri_free(vim) ;
RETURN(NULL) ;
case MRI_byte:{
byte *bnew = MRI_BYTE_PTR(vim), *bold = MRI_BYTE_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
case MRI_rgb:{
byte *bnew = MRI_RGB_PTR(vim), *bold = MRI_RGB_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ ){
bnew[3*SNEW(ii,jj) ] = bold[3*SOLD(ii,jj) ] ;
bnew[3*SNEW(ii,jj)+1] = bold[3*SOLD(ii,jj)+1] ;
bnew[3*SNEW(ii,jj)+2] = bold[3*SOLD(ii,jj)+2] ;
}
}
break ;
case MRI_short:{
short *bnew = MRI_SHORT_PTR(vim), *bold = MRI_SHORT_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
case MRI_int:{
int *bnew = MRI_INT_PTR(vim), *bold = MRI_INT_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
case MRI_float:{
float *bnew = MRI_FLOAT_PTR(vim), *bold = MRI_FLOAT_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
case MRI_double:{
double *bnew = MRI_DOUBLE_PTR(vim), *bold = MRI_DOUBLE_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
case MRI_complex:{
complex *bnew = MRI_COMPLEX_PTR(vim), *bold = MRI_COMPLEX_PTR(fim) ;
for( jj=jjbot ; jj < jjtop ; jj++ )
for( ii=iibot ; ii < iitop ; ii++ )
bnew[SNEW(ii,jj)] = bold[SOLD(ii,jj)] ;
}
break ;
} /* end of switch on datum type */
RETURN(vim) ;
}
