void UC_read_opts( int argc , char * argv[] )
{
int nopt = 1 ;
float val ;
int kk, nxyz, mm,nn ;
float * vv , * bb ;
while( nopt < argc && argv[nopt][0] == '-' ){
/**** -verbose ****/
if( strncmp(argv[nopt],"-verbose",5) == 0 ){
UC_be_quiet = 0 ;
nopt++ ; continue ;
}
/**** -ref file.1D ****/
if( strncmp(argv[nopt],"-ref",4) == 0 ){
MRI_IMAGE * im ;
nopt++ ;
if( nopt >= argc ) UC_syntax("-ref needs an argument!") ;
im = mri_read( argv[nopt] ) ;
if( im == NULL ) UC_syntax("Can't read -ref file!") ;
if( im->kind == MRI_float ){
UC_ref = im ;
} else {
UC_ref = mri_to_float(im) ; mri_free(im) ;
}
im = mri_transpose(UC_ref) ; mri_free(UC_ref) ; UC_ref = im ;
nopt++ ; continue ;
}
/**** -prefix prefix ****/
if( strncmp(argv[nopt],"-prefix",6) == 0 ){
nopt++ ;
if( nopt >= argc ) UC_syntax("-prefix needs an argument!") ;
MCW_strncpy( UC_prefix , argv[nopt++] , THD_MAX_PREFIX ) ;
continue ;
}
/**** -mask mset ****/
if( strncmp(argv[nopt],"-mask",5) == 0 ){
THD_3dim_dataset * mset ; int ii ;
nopt++ ;
if( nopt >= argc ) UC_syntax("need arguments after -mask!") ;
mset = THD_open_dataset( argv[nopt] ) ;
if( mset == NULL ) UC_syntax("can't open -mask dataset!") ;
UC_mask = THD_makemask( mset , 0 , 1.0,0.0 ) ;
UC_mask_nvox = DSET_NVOX(mset) ;
DSET_delete(mset) ;
if( UC_mask == NULL ) UC_syntax("can't use -mask dataset!") ;
UC_mask_hits = THD_countmask( UC_mask_nvox , UC_mask ) ;
if( UC_mask_hits == 0 ) UC_syntax("mask is all zeros!") ;
if( !UC_be_quiet ) printf("--- %d voxels in mask\n",UC_mask_hits) ;
nopt++ ; continue ;
}
/**** unknown switch ****/
fprintf(stderr,"\n*** unrecognized option %s\n",argv[nopt]) ;
exit(1) ;
} /* end of loop over options */
/*--- a simple consistency check ---*/
/*--- last input is dataset name ---*/
if( nopt >= argc ) UC_syntax("no input dataset name?") ;
UC_dset = THD_open_dataset( argv[nopt] ) ;
if( !ISVALID_3DIM_DATASET(UC_dset) ){
fprintf(stderr,"\n*** can't open dataset file %s\n",argv[nopt]) ;
exit(1) ;
}
nxyz = DSET_NVOX(UC_dset) ;
if( UC_mask != NULL && nxyz != UC_mask_nvox )
UC_syntax("mask and input dataset size mismatch!") ;
/*--- load vectors ---*/
UC_nvec = (UC_mask_hits > 0) ? UC_mask_hits : nxyz ;
UC_vdim = DSET_NVALS(UC_dset) ;
if( UC_vdim < 4 )
UC_syntax("input dataset needs at least 4 sub-bricks!") ;
if( UC_ref == NULL || UC_ref->nx < UC_vdim )
UC_syntax("input ref not long enough for input dataset!") ;
vv = (float *) malloc( sizeof(float) * UC_nvec * UC_vdim ) ;
UC_vec = (float **) malloc( sizeof(float *) * UC_nvec ) ;
for( kk=0 ; kk < UC_nvec ; kk++ ) UC_vec[kk] = vv + (kk*UC_vdim) ;
if( !UC_be_quiet ) printf("--- reading dataset\n") ;
DSET_load(UC_dset) ; CHECK_LOAD_ERROR(UC_dset) ;
/* copy brick data into float storage */
if( !UC_be_quiet ) printf("--- loading vectors\n") ;
bb = (float *) malloc( sizeof(float) * nxyz ) ;
for( mm=0 ; mm < UC_vdim ; mm++ ){
EDIT_coerce_type( nxyz , DSET_BRICK_TYPE(UC_dset,mm) ,
DSET_ARRAY(UC_dset,mm) ,
MRI_float , bb ) ;
DSET_unload_one( UC_dset , mm ) ;
if( UC_mask == NULL ){
for( kk=0 ; kk < nxyz ; kk++ ) UC_vec[kk][mm] = bb[kk] ;
} else {
for( nn=kk=0 ; kk < nxyz ; kk++ )
if( UC_mask[kk] ) UC_vec[nn++][mm] = bb[kk] ;
}
}
free(bb) ; DSET_unload( UC_dset ) ;
/* detrend and normalize vectors */
if( !UC_be_quiet ) printf("--- normalizing vectors\n") ;
for( kk=0 ; kk < UC_nvec ; kk++ )
normalize( UC_vdim , UC_vec[kk] ) ;
for( kk=0 ; kk < UC_ref->ny ; kk++ )
normalize( UC_vdim , MRI_FLOAT_PTR(UC_ref) + kk*UC_ref->nx ) ;
return ;
}
int main( int argc , char * argv[] )
{
THD_dfvec3 *xx , *yy , dv ;
int nvec=0 , ii,jj, iarg ;
THD_dvecmat rt , rtinv ;
THD_dmat33 pp,ppt , rr ;
THD_dfvec3 tt ;
THD_3dim_dataset *mset=NULL , *dset=NULL ;
double *ww=NULL ;
int nww=0 ;
int keeptags=1 , wtval=0 , verb=0 , dummy=0 ;
char * prefix = "tagalign" , *mfile=NULL ;
float *fvol , cbot,ctop , dsum ;
int nval , nvox , clipit , ival, RMETH=MRI_CUBIC;
float matar[12] ;
int use_3dWarp=1 , matrix_type=ROTATION ;
mainENTRY("3dTagalign main");
/*--- help? ---*/
/*- scan args -*/
iarg = 1 ; RMETH=MRI_CUBIC;
while( iarg < argc && argv[iarg][0] == '-' ){
/*-----*/
if( strcmp(argv[iarg],"-h") == 0 ||
strcmp(argv[iarg],"-help") == 0){ /* 22 Apr 2003 */
usage_3dTagalign(strlen(argv[iarg]) > 3 ? 2:1);
exit(0);
}
/*-----*/
if( strcmp(argv[iarg],"-NN") == 0 ){
RMETH = MRI_NN ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-linear") == 0 ){
RMETH = MRI_LINEAR ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-cubic") == 0 ){
RMETH = MRI_CUBIC ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-quintic") == 0 ){
RMETH = MRI_QUINTIC ; iarg++ ; continue ;
}
/*-----*/
if( strcmp(argv[iarg],"-rotate") == 0 ){ /* 22 Apr 2003 */
matrix_type = ROTATION ; use_3dWarp = 1 ;
iarg++ ; continue ;
}
/*-----*/
if( strcmp(argv[iarg],"-affine") == 0 ){ /* 21 Apr 2003 */
matrix_type = AFFINE ; use_3dWarp = 1 ;
iarg++ ; continue ;
}
/*-----*/
if( strcmp(argv[iarg],"-rotscl") == 0 ){ /* 22 Apr 2003 */
matrix_type = ROTSCL ; use_3dWarp = 1 ;
iarg++ ; continue ;
}
#if 0
/*-----*/
if( strcmp(argv[iarg],"-3dWarp") == 0 ){ /* 21 Apr 2003 */
use_3dWarp = 1 ;
iarg++ ; continue ;
}
#endif
/*-----*/
if( strcmp(argv[iarg],"-master") == 0 ){
if( mset != NULL ) ERREX("Can only have one -master option") ;
if( ++iarg >= argc ) ERREX("Need an argument after -master") ;
mset = THD_open_dataset( argv[iarg] ) ;
if( mset == NULL ) ERREX("Can't open -master dataset") ;
if( mset->tagset == NULL ) ERREX("No tags in -master dataset") ;
if( TAGLIST_COUNT(mset->tagset) < 3 ) ERREX("Not enough tags in -master dataset") ;
for( nvec=ii=0 ; ii < TAGLIST_COUNT(mset->tagset) ; ii++ )
if( TAG_SET(TAGLIST_SUBTAG(mset->tagset,ii)) ) nvec++ ;
if( nvec < 3 ) ERREX("Not enough tags set in -master dataset") ;
if( nvec < TAGLIST_COUNT(mset->tagset) )
fprintf(stderr,"++ WARNING: not all tags are set in -master dataset\n") ;
if( verb ) fprintf(stderr,"++ Found %d tags in -master dataset\n",nvec) ;
iarg++ ; continue ;
}
#if 0
/*-----*/
if( strcmp(argv[iarg],"-wtval") == 0 ){
if( ww != NULL ) ERREX("Can't have -wtval after -wt1D") ;
wtval++ ;
iarg++ ; continue ;
}
/*-----*/
if( strcmp(argv[iarg],"-wt1D") == 0 ){
MRI_IMAGE * wtim ; float * wtar ;
if( wtval ) ERREX("Can't have -wt1D after -wtval") ;
if( ww != NULL ) ERREX("Can't have two -wt1D options!") ;
if( ++iarg >= argc ) ERREX("Need an argument after -wt1D") ;
wtim = mri_read_1D( argv[iarg] ) ;
if( wtim == NULL ) ERREX("Can't read -wtim file") ;
if( wtim->ny > 1 ) ERREX("-wtim file has more than one columm") ;
wtar = MRI_FLOAT_PTR(wtim) ;
ww = (double *) malloc(sizeof(double)*wtim->nx) ; nww = wtim->nx ;
for( ii=0 ; ii < nww ; ii++ ){
ww[ii] = (double) wtar[ii] ;
if( ww[ii] < 0.0 ) ERREX("Negative value found in -wt1D file") ;
}
mri_free(wtim) ;
iarg++ ; continue ;
}
#endif
/*-----*/
if( strcmp(argv[iarg],"-nokeeptags") == 0 ){
keeptags = 0 ;
iarg++ ; continue ;
}
/*-----*/
if( strncmp(argv[iarg],"-verb",5) == 0 ){
verb++ ;
iarg++ ; continue ;
}
/*-----*/
if( strcmp(argv[iarg],"-dummy") == 0 ){
dummy++ ;
iarg++ ; continue ;
}
/*-----*/
if( strcmp(argv[iarg],"-prefix") == 0 ){
if( ++iarg >= argc ) ERREX("Need an argument after -prefix") ;
prefix = argv[iarg] ;
if( !THD_filename_ok(prefix) ) ERREX("-prefix string is illegal") ;
iarg++ ; continue ;
}
/*-----*/
if( strcmp(argv[iarg],"-matvec") == 0 ){
if( ++iarg >= argc ) ERREX("Need an argument after -matvec") ;
mfile = argv[iarg] ;
if( !THD_filename_ok(mfile) ) ERREX("-matvec string is illegal") ;
iarg++ ; continue ;
}
/*-----*/
fprintf(stderr,"** Unknown option: %s\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1) ;
} /* end of scanning command line for options */
if( argc < 2 ){
ERROR_message("Too few options");
usage_3dTagalign(0);
exit(1) ;
}
if( mset == NULL ) ERREX("No -master option found on command line") ;
#if 0
if( ww != NULL && nww < nvec ) ERREX("Not enough weights found in -wt1D file") ;
/*-- if -wtval, setup weights from master tag values --*/
if( wtval ){
ww = (double *) malloc(sizeof(double)*nvec) ; nww = nvec ;
for( ii=jj=0 ; ii < TAGLIST_COUNT(mset->tagset) ; ii++ ){
if( TAG_SET(TAGLIST_SUBTAG(mset->tagset,ii)) ){
ww[jj] = (double) TAG_VAL(TAGLIST_SUBTAG(mset->tagset,ii)) ;
if( ww[jj] < 0.0 ) ERREX("Negative value found in -master tag values") ;
jj++ ;
}
}
}
#endif
/*-- read input dataset (to match to master dataset) --*/
if( iarg >= argc ) ERREX("No input dataset?") ;
dset = THD_open_dataset( argv[iarg] ) ;
if( dset == NULL ) ERREX("Can't open input dataset") ;
if( dset->tagset == NULL ) ERREX("No tags in input dataset") ;
if( TAGLIST_COUNT(dset->tagset) !=
TAGLIST_COUNT(mset->tagset) ) ERREX("Tag counts don't match in -master and input") ;
/* check if set tags match exactly */
for( ii=0 ; ii < TAGLIST_COUNT(mset->tagset) ; ii++ ){
if( TAG_SET(TAGLIST_SUBTAG(mset->tagset,ii)) !=
TAG_SET(TAGLIST_SUBTAG(dset->tagset,ii)) )
ERREX("Set tags don't match in -master and input") ;
}
/*-- load vector lists: xx=master, yy=input --*/
xx = (THD_dfvec3 *) malloc( sizeof(THD_dfvec3) * nvec ) ;
yy = (THD_dfvec3 *) malloc( sizeof(THD_dfvec3) * nvec ) ;
dsum = 0.0 ;
for( ii=jj=0 ; ii < nvec ; ii++ ){
if( TAG_SET(TAGLIST_SUBTAG(mset->tagset,ii)) ){
LOAD_DFVEC3( xx[jj] , /* N.B.: */
TAG_X( TAGLIST_SUBTAG(mset->tagset,ii) ) , /* these are */
TAG_Y( TAGLIST_SUBTAG(mset->tagset,ii) ) , /* in Dicom */
TAG_Z( TAGLIST_SUBTAG(mset->tagset,ii) ) ) ; /* order now */
LOAD_DFVEC3( yy[jj] ,
TAG_X( TAGLIST_SUBTAG(dset->tagset,ii) ) ,
TAG_Y( TAGLIST_SUBTAG(dset->tagset,ii) ) ,
TAG_Z( TAGLIST_SUBTAG(dset->tagset,ii) ) ) ;
dv = SUB_DFVEC3( xx[jj] , yy[jj] ) ;
dsum += dv.xyz[0]*dv.xyz[0] + dv.xyz[1]*dv.xyz[1] + dv.xyz[2]*dv.xyz[2] ;
jj++ ;
}
}
dsum = sqrt(dsum/nvec) ;
fprintf(stderr,"++ RMS distance between tags before = %.2f mm\n" , dsum ) ;
/*-- compute best transformation from mset to dset coords --*/
switch( matrix_type ){
default:
case ROTATION:
rt = DLSQ_rot_trans( nvec , yy , xx , ww ) ; /* in thd_rot3d.c */
break ;
case AFFINE:
rt = DLSQ_affine ( nvec , yy , xx ) ; /* 21 Apr 2003 */
break ;
case ROTSCL:
rt = DLSQ_rotscl ( nvec , yy , xx , (DSET_NZ(dset)==1) ? 2 : 3 ) ;
break ;
}
rtinv = INV_DVECMAT(rt) ;
/*-- check for floating point legality --*/
nval = 0 ;
for( ii=0 ; ii < 3 ; ii++ ){
dsum = rt.vv.xyz[ii] ; nval += thd_floatscan(1,&dsum) ;
for( jj=0 ; jj < 3 ; jj++ ){
dsum = rt.mm.mat[ii][jj] ; nval += thd_floatscan(1,&dsum) ;
}
}
if( nval > 0 ){
fprintf(stderr,"** Floating point errors during calculation\n"
"** of transform matrix and translation vector\n" ) ;
exit(1) ;
}
/*-- check for rotation matrix legality --*/
dsum = DMAT_DET(rt.mm) ;
if( dsum == 0.0 || (matrix_type == ROTATION && fabs(dsum-1.0) > 0.01) ){
fprintf(stderr,"** Invalid transform matrix computed: tags dependent?\n"
"** computed [matrix] and [vector] follow:\n" ) ;
for( ii=0 ; ii < 3 ; ii++ )
fprintf(stderr," [ %10.5f %10.5f %10.5f ] [ %10.5f ] \n",
rt.mm.mat[ii][0],rt.mm.mat[ii][1],rt.mm.mat[ii][2],rt.vv.xyz[ii] );
exit(1) ;
}
/*-- print summary --*/
if( verb ){
fprintf(stderr,"++ Matrix & Vector [Dicom: x=R-L; y=A-P; z=I-S]\n") ;
for( ii=0 ; ii < 3 ; ii++ )
fprintf(stderr," %10.5f %10.5f %10.5f %10.5f\n",
rt.mm.mat[ii][0],rt.mm.mat[ii][1],rt.mm.mat[ii][2],rt.vv.xyz[ii] );
}
if( matrix_type == ROTATION || matrix_type == ROTSCL ){
double theta, costheta , dist , fac=1.0 ;
if( matrix_type == ROTSCL ){
fac = DMAT_DET(rt.mm); fac = fabs(fac);
if( DSET_NZ(dset) == 1 ) fac = sqrt(fac) ;
else fac = cbrt(fac) ;
}
costheta = 0.5 * sqrt(1.0 + DMAT_TRACE(rt.mm)/fac ) ;
theta = 2.0 * acos(costheta) * 180/3.14159265 ;
dist = SIZE_DFVEC3(rt.vv) ;
fprintf(stderr,"++ Total rotation=%.2f degrees; translation=%.2f mm; scaling=%.2f\n",
theta,dist,fac) ;
}
if( mfile ){
FILE * mp ;
if( THD_is_file(mfile) )
fprintf(stderr,"++ Warning: -matvec will overwrite file %s\n",mfile) ;
mp = fopen(mfile,"w") ;
if( mp == NULL ){
fprintf(stderr,"** Can't write to -matvec %s\n",mfile) ;
} else {
for( ii=0 ; ii < 3 ; ii++ )
fprintf(mp," %10.5f %10.5f %10.5f %10.5f\n",
rt.mm.mat[ii][0],rt.mm.mat[ii][1],rt.mm.mat[ii][2],rt.vv.xyz[ii] );
fclose(mp) ;
if( verb ) fprintf(stderr,"++ Wrote matrix+vector to %s\n",mfile) ;
}
}
if( dummy ){
fprintf(stderr,"++ This was a -dummy run: no output dataset\n") ; exit(0) ;
}
/*-- 21 Apr 2003: transformation can be done the old way (a la 3drotate),
or the new way (a la 3dWarp). --*/
#if 0
if( !use_3dWarp ){ /**** the old way ****/
/*-- now must scramble the rotation matrix and translation
vector from Dicom coordinate order to dataset brick order --*/
pp = DBLE_mat_to_dicomm( dset ) ;
ppt = TRANSPOSE_DMAT(pp) ;
rr = DMAT_MUL(ppt,rt.mm) ; rr = DMAT_MUL(rr,pp) ; tt = DMATVEC(ppt,rt.vv) ;
/*-- now create the output dataset by screwing with the input dataset
(this code is adapted from 3drotate.c) --*/
DSET_mallocize(dset) ;
DSET_load( dset ) ; CHECK_LOAD_ERROR(dset) ;
dset->idcode = MCW_new_idcode() ;
dset->dblk->diskptr->storage_mode = STORAGE_BY_BRICK ; /* 14 Jan 2004 */
EDIT_dset_items( dset ,
ADN_prefix , prefix ,
ADN_label1 , prefix ,
ADN_none ) ;
if( !THD_ok_overwrite() &&
(THD_deathcon() && THD_is_file(dset->dblk->diskptr->header_name) )){
fprintf(stderr,
"** Output file %s already exists -- cannot continue!\n",
dset->dblk->diskptr->header_name ) ;
exit(1) ;
}
tross_Make_History( "3dTagalign" , argc,argv , dset ) ;
/*-- if desired, keep old tagset --*/
if( keeptags ){
THD_dfvec3 rv ;
dsum = 0.0 ;
for( jj=ii=0 ; ii < TAGLIST_COUNT(dset->tagset) ; ii++ ){
if( TAG_SET(TAGLIST_SUBTAG(dset->tagset,ii)) ){
rv = DMATVEC( rt.mm , yy[jj] ) ; /* operating on */
rv = ADD_DFVEC3( rt.vv , rv ) ; /* Dicom order */
dv = SUB_DFVEC3( xx[jj] , rv ) ;
dsum += dv.xyz[0]*dv.xyz[0] + dv.xyz[1]*dv.xyz[1]
+ dv.xyz[2]*dv.xyz[2] ;
UNLOAD_DFVEC3( rv , TAG_X( TAGLIST_SUBTAG(dset->tagset,ii) ) ,
TAG_Y( TAGLIST_SUBTAG(dset->tagset,ii) ) ,
TAG_Z( TAGLIST_SUBTAG(dset->tagset,ii) ) ) ;
jj++ ;
}
}
dsum = sqrt(dsum/nvec) ;
fprintf(stderr,"++ RMS distance between tags after = %.2f mm\n" , dsum ) ;
} else {
myXtFree(dset->tagset) ; /* send it to the dustbin */
}
/*-- rotate sub-bricks --*/
if( verb ) fprintf(stderr,"++ computing output BRIK") ;
nvox = DSET_NVOX(dset) ;
nval = DSET_NVALS(dset) ;
fvol = (float *) malloc( sizeof(float) * nvox ) ;
THD_rota_method( MRI_HEPTIC ) ;
clipit = 1 ;
for( ival=0 ; ival < nval ; ival++ ){
/*- get sub-brick out of dataset -*/
EDIT_coerce_type( nvox ,
DSET_BRICK_TYPE(dset,ival),DSET_ARRAY(dset,ival) ,
MRI_float,fvol ) ;
if( clipit ){
register int ii ; register float bb,tt ;
bb = tt = fvol[0] ;
for( ii=1 ; ii < nvox ; ii++ ){
if( fvol[ii] < bb ) bb = fvol[ii] ;
else if( fvol[ii] > tt ) tt = fvol[ii] ;
}
cbot = bb ; ctop = tt ;
}
if( verb && nval < 5 ) fprintf(stderr,".") ;
/*- rotate it -*/
THD_rota_vol_matvec( DSET_NX(dset) , DSET_NY(dset) , DSET_NZ(dset) ,
fabs(DSET_DX(dset)) , fabs(DSET_DY(dset)) ,
fabs(DSET_DZ(dset)) ,
fvol , rr , tt ) ;
if( verb ) fprintf(stderr,".") ;
if( clipit ){
register int ii ; register float bb,tt ;
bb = cbot ; tt = ctop ;
for( ii=0 ; ii < nvox ; ii++ ){
if( fvol[ii] < bb ) fvol[ii] = bb ;
else if( fvol[ii] > tt ) fvol[ii] = tt ;
}
}
if( verb && nval < 5 ) fprintf(stderr,".") ;
/*- put it back into dataset -*/
EDIT_coerce_type( nvox, MRI_float,fvol ,
DSET_BRICK_TYPE(dset,ival),DSET_ARRAY(dset,ival) );
} /* end of loop over sub-brick index */
if( verb ) fprintf(stderr,":") ;
/* save matrix+vector into dataset, too */
UNLOAD_DMAT(rt.mm,matar[0],matar[1],matar[2],
matar[4],matar[5],matar[6],
matar[8],matar[9],matar[10] ) ;
UNLOAD_DFVEC3(rt.vv,matar[3],matar[7],matar[11]) ;
THD_set_atr( dset->dblk, "TAGALIGN_MATVEC", ATR_FLOAT_TYPE, 12, matar ) ;
/* write dataset to disk */
dset->dblk->master_nvals = 0 ; /* in case this was a mastered dataset */
DSET_write(dset) ;
if( verb ) fprintf(stderr,"\n") ;
} else
#endif
{ /**** the new way: use 3dWarp type transformation ****/
THD_3dim_dataset *oset ;
THD_vecmat tran ;
#if 0
DFVEC3_TO_FVEC3( rt.vv , tran.vv ) ;
DMAT_TO_MAT ( rt.mm , tran.mm ) ;
#else
DFVEC3_TO_FVEC3( rtinv.vv , tran.vv ) ;
DMAT_TO_MAT ( rtinv.mm , tran.mm ) ;
#endif
mri_warp3D_method( RMETH ) ;
oset = THD_warp3D_affine( dset, tran, mset, prefix, 0, WARP3D_NEWDSET ) ;
if( oset == NULL ){
fprintf(stderr,"** ERROR: THD_warp3D() fails!\n"); exit(1);
}
tross_Copy_History( dset , oset ) ;
tross_Make_History( "3dTagalign" , argc,argv , oset ) ;
UNLOAD_DMAT(rt.mm,matar[0],matar[1],matar[2],
matar[4],matar[5],matar[6],
matar[8],matar[9],matar[10] ) ;
UNLOAD_DFVEC3(rt.vv,matar[3],matar[7],matar[11]) ;
THD_set_atr( oset->dblk, "TAGALIGN_MATVEC", ATR_FLOAT_TYPE, 12, matar ) ;
/*-- if desired, keep old tagset --*/
if( keeptags ){
THD_dfvec3 rv ;
oset->tagset = myXtNew(THD_usertaglist) ;
*(oset->tagset) = *(dset->tagset) ;
dsum = 0.0 ;
for( jj=ii=0 ; ii < TAGLIST_COUNT(oset->tagset) ; ii++ ){
if( TAG_SET(TAGLIST_SUBTAG(oset->tagset,ii)) ){
rv = DMATVEC( rt.mm , yy[jj] ) ;
rv = ADD_DFVEC3( rt.vv , rv ) ;
dv = SUB_DFVEC3( xx[jj] , rv ) ;
dsum += dv.xyz[0]*dv.xyz[0] + dv.xyz[1]*dv.xyz[1]
+ dv.xyz[2]*dv.xyz[2] ;
UNLOAD_DFVEC3( rv , TAG_X( TAGLIST_SUBTAG(oset->tagset,ii) ) ,
TAG_Y( TAGLIST_SUBTAG(oset->tagset,ii) ) ,
TAG_Z( TAGLIST_SUBTAG(oset->tagset,ii) ) ) ;
jj++ ;
}
}
dsum = sqrt(dsum/nvec) ;
fprintf(stderr,"++ RMS distance between tags after = %.2f mm\n" , dsum ) ;
}
DSET_write(oset) ;
} /* end of 3dWarp-like work */
exit(0) ;
}
THD_3dim_dataset * MAKER_4D_to_typed_fbuc( THD_3dim_dataset * old_dset ,
char * new_prefix , int new_datum ,
int ignore , int detrend ,
int nbrik , generic_func * user_func ,
void * user_data , byte *mmm,
int nscale)
{
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 input brick scaling factors */
float ** fout = NULL ; /* will be arrays of output floats */
float * dtr = NULL ; /* will be array of detrending coeff */
float * val = NULL ; /* will be array of output values */
float d0fac , d1fac , x0,x1;
double tzero=0 , tdelta , ts_mean , ts_slope ;
int ii , old_datum , nuse , use_fac , iz,izold, nxy,nvox , iv ;
register int kk ;
int nbad=0 ; /* 08 Aug 2000 */
void (*ufunc)(double,double,int,float *,double,double,void *,int,float *)
= (void (*)(double,double,int,float *,double,double,void *,int,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( nbrik <= 0 ) 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 */
/* maybe allow nuse == 1 2 Nov 2010 [rickr] */
if( nuse < 1 ) return NULL ;
if( nuse == 1 && ! g_thd_maker_allow_1brick ) return NULL ;
g_thd_maker_allow_1brick = 0; /* and beware repeat calls from plugins */
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 input 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 , nbrik , /* # sub-bricks */
ADN_ntt , 0 , /* # time points */
ADN_type , ISHEAD(old_dset) /* dataset type */
? HEAD_FUNC_TYPE
: GEN_FUNC_TYPE ,
ADN_func_type , FUNC_BUCK_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 ;
}
THD_init_datablock_labels( new_dset->dblk ) ;
THD_init_datablock_keywords( new_dset->dblk ) ;
THD_init_datablock_stataux( new_dset->dblk ) ;
/*------ make floating point output bricks
(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 *) * nbrik ) ;
if( fout == NULL ){
THD_delete_3dim_dataset( new_dset , False ) ;
FREE_WORKSPACE ; return NULL ;
}
for( iv=0 ; iv < nbrik ; iv++ ) fout[iv] = NULL ;
for( iv=0 ; iv < nbrik ; iv++ ){
fout[iv] = (float *) malloc( sizeof(float) * nvox ) ;
if( fout[iv] == NULL ){
THD_delete_3dim_dataset( new_dset , False ) ;
FREE_WORKSPACE ; return NULL ;
}
}
/*-- floating point storage for output from 1 voxel --*/
val = (float *) malloc( sizeof(float) * nbrik ) ;
if( val == 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 , nbrik , NULL ) ;
#else
ufunc( 0.0 , 0.0 , nvox , NULL,0.0,0.0 , user_data , nbrik , 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 ***/
for( iv=0 ; iv < nbrik ; iv++ ) val[iv] = 0.0 ;
if (!mmm || mmm[ii]) { /* not the most efficient place to
mask, but it is the least obtrusive */
#if 0
user_func( tzero,tdelta, nuse,fxar,ts_mean,ts_slope, user_data, nbrik,val );
#else
ufunc( tzero,tdelta, nuse,fxar,ts_mean,ts_slope, user_data, nbrik,val );
#endif
}
for( iv=0 ; iv < nbrik ; iv++ ) fout[iv][ii] = val[iv] ;
} /* 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 , nbrik , NULL ) ;
#else
ufunc( 0.0 , 0.0 , 0 , NULL,0.0,0.0 , user_data , nbrik , NULL ) ;
#endif
/*---- Count and correct float errors ----*/
for( iv=0 ; iv < nbrik ; iv++ )
nbad += thd_floatscan( nvox, fout[iv] ) ;
if( nbad > 0 )
fprintf(stderr,
"++ Warning: %d bad floats computed in MAKER_4D_to_typed_fbuc\n\a",
nbad ) ;
/*------------------------------------------------------------------------*/
/*------- The output is now in fout[iv][ii], iv=0..nbrik-1, 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:
for( iv=0 ; iv < nbrik ; iv++ ){
EDIT_substitute_brick( new_dset , iv , MRI_float , fout[iv] ) ;
fout[iv] = NULL ; /* so it won't be freed later */
}
break ;
/*** output is shorts:
we have to create scaled sub-bricks from fout ***/
case MRI_short:{
short * bout ;
float sfac ;
for( iv=0 ; iv < nbrik ; iv++ ){
bout = (short *) malloc( sizeof(short) * nvox ) ;
if( bout == NULL ){
fprintf(stderr,
"\nFinal malloc error in MAKER_4D_to_fbuc - is memory exhausted?\n\a");
EXIT(1) ;
}
if (nscale) {
sfac = 0.0;
EDIT_coerce_type( nvox, MRI_float, fout[iv] ,
MRI_short, bout ) ;
} else {
sfac = MCW_vol_amax( nvox,1,1 , MRI_float , fout[iv] ) ;
if( sfac > 0.0 ){
sfac = 32767.0 / sfac ;
EDIT_coerce_scale_type( nvox,sfac ,
MRI_float,fout[iv] , MRI_short,bout ) ;
sfac = 1.0 / sfac ;
}
}
val[iv] = sfac ;
EDIT_substitute_brick( new_dset , iv , MRI_short , bout ) ;
}
EDIT_dset_items( new_dset , ADN_brick_fac , val , 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 ;
for( iv=0 ; iv < nbrik ; iv++ ){
bout = (byte *) malloc( sizeof(byte) * nvox ) ;
if( bout == NULL ){
fprintf(stderr,
"\nFinal malloc error in MAKER_4D_to_fbuc - is memory exhausted?\n\a");
EXIT(1) ;
}
if (nscale) {
sfac = 0.0;
EDIT_coerce_type( nvox, MRI_float, fout[iv] ,
MRI_byte, bout ) ;
} else {
sfac = MCW_vol_amax( nvox,1,1 , MRI_float , fout[iv] ) ;
if( sfac > 0.0 ){
sfac = 255.0 / sfac ;
EDIT_coerce_scale_type( nvox,sfac ,
MRI_float,fout[iv] , MRI_byte,bout ) ;
sfac = 1.0 / sfac ;
}
}
val[iv] = sfac ;
EDIT_substitute_brick( new_dset , iv , MRI_byte , bout ) ;
}
EDIT_dset_items( new_dset , ADN_brick_fac , val , 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 ;
}
