/*---------------------------------------------------------------------
23 Feb 2012: Return the absolute value of the difference between
two volumes, divided by the number of voxels
and the number of sub-bricks. Voxels that are zero
in both sets are not counted.
Comparisons are done after conversion of data to double
return = -1.0 ERROR
= 0.0 Exactly the same
-----------------------------------------------------------------------*/
double THD_diff_vol_vals(THD_3dim_dataset *d1, THD_3dim_dataset *d2, int scl) {
double dd=0.0, denom=0.0;
int i=0, k=0;
double *a1=NULL, *a2=NULL;
MRI_IMAGE *b1 = NULL , *b2 = NULL;
ENTRY("THD_diff_vol_vals");
if (!d1 && !d2) RETURN(dd);
if (!d1 || !d2) RETURN(-1.0);
if (!EQUIV_GRIDS(d1,d2)) RETURN(-1.0);
if (DSET_NVALS(d1) != DSET_NVALS(d2)) RETURN(-1.0);
DSET_mallocize(d1) ; DSET_load(d1) ;
DSET_mallocize(d2) ; DSET_load(d2) ;
dd = 0.0; denom = 0;
for (i=0; i<DSET_NVALS(d1); ++i) {
b1 = THD_extract_double_brick(i, d1);
b2 = THD_extract_double_brick(i, d2);
a1 = MRI_DOUBLE_PTR(b1);
a2 = MRI_DOUBLE_PTR(b2);
for (k=0; k<DSET_NVOX(d1); ++k) {
dd += ABS(a1[k]-a2[k]);
if (a1[k]!=0.0 || a2[k]!=0.0) ++denom;
}
mri_clear_data_pointer(b1); mri_free(b1) ;
mri_clear_data_pointer(b2); mri_free(b2) ;
}
if (scl && denom>0.0) dd /= denom;
RETURN(dd);
}
THD_3dim_dataset *Seg_load_dset_eng( char *set_name, char *view )
{
static char FuncName[]={"Seg_load_dset_eng"};
THD_3dim_dataset *dset=NULL, *sdset=NULL;
int i=0;
byte make_cp=0;
int verb=0;
char sprefix[THD_MAX_PREFIX+10], *stmp=NULL;
SUMA_ENTRY;
dset = THD_open_dataset( set_name );
if( !ISVALID_DSET(dset) ){
fprintf(stderr,"**ERROR: can't open dataset %s\n",set_name) ;
SUMA_RETURN(NULL);
}
DSET_mallocize(dset) ; DSET_load(dset);
for (i=0; i<DSET_NVALS(dset); ++i) {
if (DSET_BRICK_TYPE(dset,i) != MRI_short) {
if (verb) INFO_message("Sub-brick %d in %s not of type short.\n"
"Creating new short copy of dset ",
i, DSET_PREFIX(dset));
make_cp=1; break;
}
}
if (make_cp) {
if (!SUMA_ShortizeDset(&dset, -1.0)) {
SUMA_S_Err("**ERROR: Failed to shortize");
SUMA_RETURN(NULL);
}
}
if (DSET_IS_MASTERED(dset)) {
if (verb) INFO_message("Dset is mastered, making copy...");
stmp = SUMA_ModifyName(set_name, "append", ".cp", NULL);
sdset = dset;
dset = EDIT_full_copy(sdset, stmp);
free(stmp); DSET_delete(sdset); sdset = NULL;
}
if (view) {
if (view) {
if (!strstr(view,"orig"))
EDIT_dset_items(dset,ADN_view_type, VIEW_ORIGINAL_TYPE, ADN_none);
else if (!strstr(view,"acpc"))
EDIT_dset_items(dset,ADN_view_type, VIEW_ACPCALIGNED_TYPE, ADN_none);
else if (!strstr(view,"tlrc"))
EDIT_dset_items(dset ,ADN_view_type, VIEW_TALAIRACH_TYPE, ADN_none);
else SUMA_S_Errv("View of %s is rubbish", view);
}
}
SUMA_RETURN(dset);
}
void THD_load_tcat( THD_datablock *dblk )
{
int ivout , dd , iv ;
THD_3dim_dataset *dset_in , *dset_out ;
NI_str_array *sar ;
ENTRY("THD_load_tcat") ;
if( !ISVALID_DBLK(dblk) ) EXRETURN ;
dset_out = (THD_3dim_dataset *)dblk->parent ;
if( !ISVALID_DSET(dset_out) ) EXRETURN ;
sar = NI_decode_string_list( dset_out->tcat_list , "~" ) ;
if( sar == NULL ) EXRETURN ;
if( sar->num != dset_out->tcat_num ){ NI_delete_str_array(sar); EXRETURN; }
ivout = 0 ;
for( dd=0 ; dd < sar->num ; dd++ ){
dset_in = THD_open_dataset( sar->str[dd] ) ;
if( dset_in == NULL ){
NI_delete_str_array(sar) ; DSET_unload(dset_out) ;
EXRETURN ;
}
DSET_mallocize(dset_in) ; DSET_load(dset_in) ;
if( !DSET_LOADED(dset_in) ){
NI_delete_str_array(sar) ; DSET_unload(dset_out) ; DSET_delete(dset_in) ;
EXRETURN ;
}
for( iv=0 ; iv < DSET_NVALS(dset_in) ; iv++ ){
EDIT_substitute_brick( dset_out , ivout ,
DSET_BRICK_TYPE(dset_in,iv), DSET_ARRAY(dset_in,iv) );
mri_fix_data_pointer( NULL , DSET_BRICK(dset_in,iv) ) ;
EDIT_BRICK_FACTOR( dset_out , ivout , DSET_BRICK_FACTOR(dset_in,iv) ) ;
EDIT_BRICK_LABEL(dset_out, ivout,
DSET_BRICK_LABEL(dset_in, iv)); /* ZSS Aug. 27 2012 */
ivout++ ;
}
DSET_delete(dset_in) ;
}
NI_delete_str_array(sar) ; EXRETURN ;
}
THD_3dim_dataset * THD_open_tcat( char *dlist )
{
THD_3dim_dataset *dset_out , **dset_in ;
int ndset_in , dd , nerr , new_nvals, sb=0 ;
NI_str_array *sar ;
double angle=0.0;
char *dp, *dlocal = dlist; /* local dlist, in case it is altered */
ENTRY("THD_open_tcat") ;
if( dlocal == NULL || *dlocal == '\0' ) RETURN(NULL) ;
/* allow file list to be read from a file 23 Jul 2012 [rickr] */
if( ! strncmp(dlocal, "filelist:", 9) ) {
dlocal = AFNI_suck_file(dlocal+9) ;
if ( ! dlocal ) {
ERROR_message("THD_open_tcat: failed to open '%s' as filelist",
dlocal+9);
RETURN(NULL) ;
}
/* make it look more like expected */
for( dd=0, dp=dlocal; dd < strlen(dlocal); dd++, dp++ )
if( *dp == '\n' || *dp == '\r' ) *dp = ' ';
}
if( strchr(dlocal,' ') == NULL ){
dset_out = THD_open_dataset(dlocal) ; RETURN(dset_out) ;
}
sar = NI_decode_string_list( dlocal , "~" ) ;
if( sar == NULL ) RETURN(NULL) ;
ndset_in = sar->num ;
dset_in = (THD_3dim_dataset **)malloc(sizeof(THD_3dim_dataset *)*sar->num) ;
for( nerr=dd=0 ; dd < ndset_in ; dd++ ){
dset_in[dd] = THD_open_dataset( sar->str[dd] ) ;
if( dset_in[dd] == NULL ){
fprintf(stderr,"** THD_open_tcat: can't open dataset %s\n",sar->str[dd]) ;
nerr++ ;
}
}
if( nerr > 0 ){
for( dd=0 ; dd < ndset_in ; dd++ )
if( dset_in[dd] != NULL ) DSET_delete(dset_in[dd]) ;
free((void *)dset_in) ;
NI_delete_str_array(sar) ;
RETURN(NULL) ;
}
if( ndset_in == 1 ){
dset_out = dset_in[0] ;
free((void *)dset_in) ;
NI_delete_str_array(sar) ;
RETURN(dset_out) ;
}
(void)THD_check_for_duplicates( sar->num , sar->str , 1 ) ; /* 31 May 2007 */
for( nerr=0,dd=1 ; dd < ndset_in ; dd++ ){
if( DSET_NX(dset_in[0]) != DSET_NX(dset_in[dd]) ||
DSET_NY(dset_in[0]) != DSET_NY(dset_in[dd]) ||
DSET_NZ(dset_in[0]) != DSET_NZ(dset_in[dd]) ){
ERROR_message(
"THD_open_tcat: %s [%dx%dx%d] doesn't match %s [%dx%dx%d]\n",
sar->str[0] ,DSET_NX(dset_in[0]) ,
DSET_NY(dset_in[0]) ,DSET_NZ(dset_in[0]) ,
sar->str[dd],DSET_NX(dset_in[dd]),
DSET_NY(dset_in[dd]),DSET_NZ(dset_in[dd]) ) ;
nerr++ ;
} else {
if( !EQUIV_DATAXES(dset_in[dd]->daxes,dset_in[0]->daxes) ){
WARNING_message(
"THD_open_tcat: %s grid mismatch with %s\n",
sar->str[0] , sar->str[dd] ) ; /* don't increment nerr! */
}
angle = dset_obliquity_angle_diff(dset_in[dd], dset_in[0], -1.0);
if (angle > 0.0) {
WARNING_message(
"dataset %s has an obliquity difference of %f degress with %s\n",
dset_in[dd] ,
angle, dset_in[0] );
}
}
}
if( nerr > 0 ){
for( dd=0 ; dd < ndset_in ; dd++ )
if( dset_in[dd] != NULL ) DSET_delete(dset_in[dd]) ;
free((void *)dset_in) ;
NI_delete_str_array(sar) ;
RETURN(NULL) ;
}
/*-- Check for type problems ZSS: Aug 27 2012 --*/
for (nerr=0,dd=0; dd < ndset_in ; dd++) {
for (sb=0; sb < DSET_NVALS(dset_in[dd]); ++sb) {
if ( DSET_BRICK_TYPE(dset_in[0],0) !=
DSET_BRICK_TYPE(dset_in[dd],sb) ) {
++nerr;
}
}
}
if (nerr > 0) { /* don't die, just complain */
WARNING_message(
"Command-line catenated dataset has %d sub-bricks that differ \n"
" in data type from the first sub-brick of the first set.\n"
" Mme Irma sees potential for grief if you go down that path. \n"
" Use 3dinfo -datum on each input to understand why this is happening.\n"
" You can use 3dcalc's -datum option to rewrite the dataset with \n"
" all sub-bricks set to the same type then start over.\n\n",
nerr);
nerr=0;
}
/*-- OK, start making new dataset --*/
new_nvals = 0 ;
for( dd=0 ; dd < ndset_in ; dd++ )
new_nvals += DSET_NVALS(dset_in[dd]) ;
for( dd=0 ; dd < ndset_in ; dd++ )
if( DSET_TIMESTEP(dset_in[dd]) > 0.0 ) break ; /* 1st 3D+time */
if( dd == ndset_in ) dd = 0 ;
dset_out = EDIT_empty_copy( dset_in[dd] ) ;
/* since this is basically an input dataset, set the storage_mode
* to match 27 Jul 2010 [rickr] */
if( DSET_ONDISK(dset_out) && IS_VALID_NON_AFNI_DSET(dset_in[dd]) )
THD_set_storage_mode(dset_out, dset_in[dd]->dblk->diskptr->storage_mode);
EDIT_dset_items( dset_out ,
ADN_prefix , "tcat" ,
ADN_func_type , ISANAT(dset_in[dd]) ? ANAT_EPI_TYPE
: FUNC_FIM_TYPE ,
ADN_ntt , new_nvals ,
ADN_nvals , new_nvals ,
ADN_none ) ;
DSET_mallocize( dset_out ) ;
/* check if we have a valid time axis; if not, make one up */
if( DSET_TIMESTEP(dset_out) <= 0.0f ){
float TR=1.0f , torg=0.0f , tdur=0.0f ;
int tunits=UNITS_SEC_TYPE ;
EDIT_dset_items( dset_out ,
ADN_tunits , tunits ,
ADN_ttdel , TR ,
ADN_ttorg , torg ,
ADN_ttdur , tdur ,
ADN_none ) ;
}
dset_out->tcat_list = strdup( dlocal ) ;
dset_out->tcat_num = ndset_in ;
dset_out->tcat_len = (int *)malloc(sizeof(int)*ndset_in) ;
for( dd=0 ; dd < ndset_in ; dd++ ){
dset_out->tcat_len[dd] = DSET_NVALS(dset_in[dd]) ;
DSET_delete(dset_in[dd]) ;
}
free((void *)dset_in) ;
NI_delete_str_array(sar) ;
#if 0
fprintf(stderr,"THD_open_tcat('%s'):",dset_out->tcat_list);
for(dd=0;dd<ndset_in;dd++)fprintf(stderr," %d",dset_out->tcat_len[dd]);
fprintf(stderr,"\n");
#endif
RETURN(dset_out) ;
}
/*! Replace a voxel's value by the value's rank in the entire set of input datasets */
int main( int argc , char * argv[] )
{
THD_3dim_dataset ** dsets_in = NULL, *dset=NULL; /*input and output datasets*/
int nopt=0, nbriks=0, nsubbriks=0, ib=0, isb=0;
byte *cmask=NULL;
int *all_uniques=NULL, **uniques=NULL, *final_unq=NULL, *N_uniques=NULL;
int N_final_unq=0, iun=0, total_unq=0;
INT_HASH_DATUM *rmap=NULL, *hd=NULL;
int imax=0, iunq=0, ii=0, id = 0;
long int off=0;
char *prefix=NULL;
char stmp[THD_MAX_PREFIX+1]={""};
FILE *fout=NULL;
/*----- Read command line -----*/
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
Rank_help ();
exit(0) ;
}
mainENTRY("3dRank main"); machdep(); AFNI_logger("3dRank",argc,argv);
nopt = 1 ;
while( nopt < argc && argv[nopt][0] == '-' ){
if( strcmp(argv[nopt],"-ver") == 0 ){
PRINT_VERSION("3dRank"); AUTHOR("Ziad Saad");
nopt++; continue;
}
if( strcmp(argv[nopt],"-help") == 0 ){
Rank_help();
exit(0) ;
}
if( strcmp(argv[nopt],"-prefix") == 0 ){
++nopt;
if (nopt>=argc) {
fprintf(stderr,"**ERROR: Need string after -prefix\n");
exit(1);
}
prefix = argv[nopt] ;
++nopt; continue;
}
if( strcmp(argv[nopt],"-input") == 0 ){
dsets_in = (THD_3dim_dataset**)
calloc(argc-nopt+1, sizeof(THD_3dim_dataset*));
++nopt; nbriks=0;
while (nopt < argc ) {
dsets_in[nbriks] = THD_open_dataset( argv[nopt] );
if( !ISVALID_DSET(dsets_in[nbriks]) ){
fprintf(stderr,"**ERROR: can't open dataset %s\n",argv[nopt]) ;
exit(1);
}
++nopt; ++nbriks;
}
continue;
}
ERROR_exit( " Error - unknown option %s", argv[nopt]);
}
if (nopt < argc) {
ERROR_exit( " Error unexplained trailing option: %s\n", argv[nopt]);
}
if (!nbriks) {
ERROR_exit( " Error no volumes entered on command line?");
}
/* some checks and inits*/
nsubbriks = 0;
for (ib = 0; ib<nbriks; ++ib) {
if (!is_integral_dset(dsets_in[ib], 0)) {
ERROR_exit("Dset %s is not of an integral data type.",
DSET_PREFIX(dsets_in[ib]));
}
nsubbriks += DSET_NVALS(dsets_in[ib]);
}
/* Now get unique arrays */
uniques = (int **)calloc(nsubbriks, sizeof(int*));
N_uniques = (int *)calloc(nsubbriks, sizeof(int));
total_unq = 0;
iun = 0;
for (ib = 0; ib<nbriks; ++ib) {
DSET_mallocize(dsets_in[ib]); DSET_load(dsets_in[ib]);
for (isb=0; isb<DSET_NVALS(dsets_in[ib]); ++isb) {
uniques[iun] = THD_unique_vals(dsets_in[ib], isb,
&(N_uniques[iun]), cmask);
total_unq += N_uniques[iun];
++iun;
}
}
/* put all the arrays together and get the unique of the uniques */
all_uniques = (int *)calloc(total_unq, sizeof(int));
off=0;
for (iun=0; iun<nsubbriks; ++iun) {
memcpy(all_uniques+off, uniques[iun], N_uniques[iun]*sizeof(int));
off += N_uniques[iun];
}
/* free intermediate unique arrays */
for (iun=0; iun<nsubbriks; ++iun) {
free(uniques[iun]);
}
free(uniques); uniques=NULL;
free(N_uniques); N_uniques=NULL;
/* get unique of catenated array */
if (!(final_unq = UniqueInt (all_uniques, total_unq, &N_final_unq, 0 ))) {
ERROR_exit( " Failed to get unique list (%d, %d, %d) ",
total_unq, N_final_unq, nsubbriks);
}
free(all_uniques); all_uniques=NULL;
if (prefix) {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"%s.rankmap.1D", prefix);
} else {
if (nbriks == 1) {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"%s.rankmap.1D", DSET_PREFIX(dsets_in[0]));
} else {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"%s+.rankmap.1D", DSET_PREFIX(dsets_in[0]));
}
}
if (stmp[0]) {
if ((fout = fopen(stmp,"w"))) {
fprintf(fout, "#Rank Map (%d unique values)\n", N_final_unq);
fprintf(fout, "#Col. 0: Rank\n");
fprintf(fout, "#Col. 1: Input Dset Value\n");
}
}
/* get the maximum integer in the unique array */
imax = 0;
for (iunq=0; iunq<N_final_unq; ++iunq) {
if (final_unq[iunq] > imax) imax = final_unq[iunq];
if (fout) fprintf(fout, "%d %d\n", iunq, final_unq[iunq]);
hd = (INT_HASH_DATUM*)calloc(1,sizeof(INT_HASH_DATUM));
hd->id = final_unq[iunq];
hd->index = iunq;
HASH_ADD_INT(rmap, id, hd);
}
fclose(fout); fout=NULL;
/* now cycle over all dsets and replace their voxel values with rank */
for (ib = 0; ib<nbriks; ++ib) {
for (isb=0; isb<DSET_NVALS(dsets_in[ib]); ++isb) {
EDIT_BRICK_LABEL( dsets_in[ib],isb, "rank" ) ;
EDIT_BRICK_TO_NOSTAT( dsets_in[ib],isb ) ;
EDIT_BRICK_FACTOR( dsets_in[ib],isb, 0.0);/* no factors for rank*/
switch (DSET_BRICK_TYPE(dsets_in[ib],isb) ){
default:
fprintf(stderr,
"** Bad dset type for unique operation.\n"
"Only Byte, Short, and float dsets are allowed.\n");
break ; /* this should not happen here,
so don't bother returning*/
case MRI_short:{
short *mar = (short *) DSET_ARRAY(dsets_in[ib],isb) ;
if (imax > MRI_TYPE_maxval[MRI_short]) {
WARNING_message("Maximum rank value of %d is\n"
"than maximum value for dset datatype of %d\n",
imax, MRI_TYPE_maxval[MRI_short]);
}
for( ii=0 ; ii < DSET_NVOX(dsets_in[ib]) ; ii++ )
if (!cmask || cmask[ii]) {
id = (int)mar[ii];
HASH_FIND_INT(rmap,&id ,hd);
if (hd) mar[ii] = (short)(hd->index);
else
ERROR_exit("** Failed to find key %d in hash table\n",id);
} else mar[ii] = 0;
}
break ;
case MRI_byte:{
byte *mar ;
if (imax > MRI_TYPE_maxval[MRI_short]) {
WARNING_message("Maximum rank value of %d is\n"
"than maximum value for dset datatype of %d\n",
imax, MRI_TYPE_maxval[MRI_byte]);
}
mar = (byte *) DSET_ARRAY(dsets_in[ib],isb) ;
for( ii=0 ; ii < DSET_NVOX(dsets_in[ib]) ; ii++ )
if (!cmask || cmask[ii]) {
id = (int)mar[ii];
HASH_FIND_INT(rmap,&id ,hd);
if (hd) mar[ii] = (byte)(hd->index);
else
ERROR_exit("** Failed to find key %d in hash table\n",id);
} else mar[ii] = 0;
}
break ;
case MRI_float:{
float *mar = (float *) DSET_ARRAY(dsets_in[ib],isb) ;
for( ii=0 ; ii < DSET_NVOX(dsets_in[ib]) ; ii++ )
if (!cmask || cmask[ii]) {
id = (int)mar[ii]; /* Assuming float is integral valued */
HASH_FIND_INT(rmap,&id ,hd);
if (hd) mar[ii] = (float)(hd->index);
else
ERROR_exit("** Failed to find key %d in hash table\n",id);
} else mar[ii] = 0;
}
break ;
}
}
/* update range, etc. */
THD_load_statistics(dsets_in[ib]);
/* Now write the bricks */
if (prefix) {
if (nbriks == 1) {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"%s", prefix);
} else {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"r%02d.%s", ib, prefix);
}
} else {
snprintf(stmp, sizeof(char)*THD_MAX_PREFIX,
"rank.%s", DSET_PREFIX(dsets_in[ib]));
}
EDIT_dset_items( dsets_in[ib] ,
ADN_prefix , stmp ,
ADN_none ) ;
/* change storage mode, this way prefix will determine
format of output dset */
dsets_in[ib]->dblk->diskptr->storage_mode = STORAGE_BY_BRICK;
tross_Make_History( "3dRank" , argc, argv , dsets_in[ib] ) ;
if (DSET_IS_MASTERED(dsets_in[ib])) {
/* THD_write_3dim_dataset won't write a mastered dude */
dset = EDIT_full_copy(dsets_in[ib],stmp);
} else {
dset = dsets_in[ib];
}
/* New ID */
ZERO_IDCODE(dset->idcode);
dset->idcode = MCW_new_idcode() ;
if (!THD_write_3dim_dataset( NULL, stmp, dset,True )) {
ERROR_message("Failed to write %s", stmp);
exit(1);
} else {
WROTE_DSET(dsets_in[ib]);
if (dset != dsets_in[ib]) DSET_deletepp(dset);
DSET_deletepp(dsets_in[ib]);
}
}
/* destroy hash */
while (rmap) {
hd = rmap;
HASH_DEL(rmap,hd);
free(hd);
}
free(final_unq); final_unq=NULL;
exit(0);
}
int main( int argc , char * argv[] )
{
THD_3dim_dataset *dset ;
int iarg=1 ;
char *cc1="x",*cc2="y",*cc3="z" ;
float th1=0.0, th2=0.0, th3=0.0 ;
float thx,thy,thz ;
int axx,ayy,azz ;
char *fname="testcox.ppm" , fn[128] ;
void * rhand ;
int bot=1 , ii , nim=0 ;
float omap[128] , bfac ;
MRI_IMAGE * im , * brim ;
int hbr[256] , nperc,ibot,itop,sum ;
byte * bar ;
double ctim ;
int imode=CREN_TWOSTEP ;
int pmode=CREN_SUM_VOX ;
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf("Usage: testcox [-rotate a b c] [-mip|-MIP] [-out f] [-bot b] [-nn|-ts|-li] dset\n") ;
exit(0) ;
}
enable_mcw_malloc() ;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-MIP") == 0 ){
pmode = CREN_MIP_VOX ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mip") == 0 ){
pmode = CREN_MINIP_VOX ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-nn") == 0 ){
imode = CREN_NN ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-ts") == 0 ){
imode = CREN_TWOSTEP ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-li") == 0 ){
imode = CREN_LINEAR ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-bot") == 0 ){
bot = strtod( argv[++iarg] , NULL ) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-rotate") == 0 ){
th1 = (PI/180.0) * strtod( argv[++iarg] , &cc1 ) ;
th2 = (PI/180.0) * strtod( argv[++iarg] , &cc2 ) ;
th3 = (PI/180.0) * strtod( argv[++iarg] , &cc3 ) ;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-out") == 0 ){
fname = argv[++iarg] ;
iarg++ ; continue ;
}
fprintf(stderr,"Illegal option: %s\n",argv[iarg]); exit(1);
}
if( iarg >= argc ){fprintf(stderr,"No dataset?\n"); exit(1); }
dset = THD_open_dataset( argv[iarg] ) ;
if( dset == NULL ){fprintf(stderr,"Can't open dataset!\n");exit(1);}
if( DSET_BRICK_TYPE(dset,0) != MRI_byte ){
fprintf(stderr,"Non-byte dataset input!\n");exit(1);
}
DSET_mallocize(dset) ; DSET_load(dset) ;
if( !DSET_LOADED(dset) ){
fprintf(stderr,"Can't load dataset!\n");exit(1);
}
rhand = new_CREN_renderer() ;
#if 0
THD_rotangle_user_to_dset( dset ,
th1,*cc1 , th2,*cc2 , th3,*cc3 ,
&thx,&axx , &thy,&ayy , &thz,&azz ) ;
CREN_set_viewpoint( rhand , axx,thx,ayy,thy,azz,thz ) ;
#else
CREN_set_angles( rhand , th1,th2,th3 ) ;
#endif
for( ii=0 ; ii < 128 ; ii++ )
omap[ii] = (ii <= bot) ? 0.0
: (ii-bot)/(127.0-bot) ;
CREN_set_opamap( rhand , omap , 1.0 ) ;
brim = DSET_BRICK(dset,0) ; bar = MRI_BYTE_PTR(brim) ;
mri_histobyte( brim , hbr ) ;
nperc = 0.02 * brim->nvox ;
for( sum=0,ibot=0 ; ibot < 128 && sum < nperc ; ibot++ ) sum += hbr[ibot] ;
for( sum=0,itop=255 ; itop > ibot && sum < nperc ; itop-- ) sum += hbr[itop] ;
if( ibot >= itop ){ ibot = 64 ; itop = 192 ; }
bfac = 127.5 / (itop-ibot) ;
for( ii=0 ; ii < brim->nvox ; ii++ )
if( bar[ii] <= ibot ) bar[ii] = 0 ;
else if( bar[ii] >= itop ) bar[ii] = 127 ;
else bar[ii] = bfac * (bar[ii]-ibot) ;
ctim = COX_cpu_time() ;
CREN_set_databytes( rhand , brim->nx,brim->ny,brim->nz , bar ) ;
CREN_dset_axes( rhand , dset ) ;
CREN_set_render_mode( rhand , pmode ) ;
CREN_set_interp( rhand , imode ) ;
for( th3=0 ; th3 < 360.0 ; th3+=5.0 ){
CREN_set_angles( rhand , th1,th2,(PI/180.0)*th3 ) ;
im = CREN_render( rhand, NULL ) ; /* added NULL 2002.08.28 - rickr */
if( im == NULL ){
fprintf(stderr,"renderer fails!\n") ; exit(1) ;
}
sprintf(fn,"tc%03d.jpg",(int)rint(th3)) ;
mri_write_pnm( fn, im ) ;
fprintf(stderr,"+++ Output to file %s\n",fn);
mri_free(im) ; nim++ ;
}
ctim = COX_cpu_time() - ctim ;
fprintf(stderr,"+++ Rendering CPU time = %g s = %g/im\n",ctim,ctim/nim) ;
exit(0) ;
}
int main( int argc , char *argv[] )
{
char *aname ;
THD_3dim_dataset *dset ;
int ii , scl ;
MRI_IMAGE *im , *qim ;
char *fname ;
float fac ;
int do_4D=0 , iarg=1 ; /* 30 Sep 2002 */
FILE *ifp=NULL ;
int xxor=-1,yyor=0,zzor=0 , xdir=0,ydir=0,zdir=0; /* 19 Mar 2003 */
float xdel=0.0 ,ydel=0.0,zdel=0.0;
char orient_code[4] ;
/*-- help me if you can --*/
WARNING_message("This program (3dAFNItoANALYZE) is old, not maintained, and probably useless!") ;
if( argc < 3 || strcmp(argv[1],"-help") == 0 ){
printf("Usage: 3dAFNItoANALYZE [-4D] [-orient code] aname dset\n"
"Writes AFNI dataset 'dset' to 1 or more ANALYZE 7.5 format\n"
".hdr/.img file pairs (one pair for each sub-brick in the\n"
"AFNI dataset). The ANALYZE files will be named\n"
" aname_0000.hdr aname_0000.img for sub-brick #0\n"
" aname_0001.hdr aname_0001.img for sub-brick #1\n"
"and so forth. Each file pair will contain a single 3D array.\n"
"\n"
"* If the AFNI dataset does not include sub-brick scale\n"
" factors, then the ANALYZE files will be written in the\n"
" datum type of the AFNI dataset.\n"
"* If the AFNI dataset does have sub-brick scale factors,\n"
" then each sub-brick will be scaled to floating format\n"
" and the ANALYZE files will be written as floats.\n"
"* The .hdr and .img files are written in the native byte\n"
" order of the computer on which this program is executed.\n"
"\n"
"Options\n"
"-------\n"
"-4D [30 Sep 2002]:\n"
" If you use this option, then all the data will be written to\n"
" one big ANALYZE file pair named aname.hdr/aname.img, rather\n"
" than a series of 3D files. Even if you only have 1 sub-brick,\n"
" you may prefer this option, since the filenames won't have\n"
" the '_0000' appended to 'aname'.\n"
"\n"
"-orient code [19 Mar 2003]:\n"
" This option lets you flip the dataset to a different orientation\n"
" when it is written to the ANALYZE files. The orientation code is\n"
" formed as follows:\n"
" The code must be 3 letters, one each from the\n"
" pairs {R,L} {A,P} {I,S}. The first letter gives\n"
" the orientation of the x-axis, the second the\n"
" orientation of the y-axis, the third the z-axis:\n"
" R = Right-to-Left L = Left-to-Right\n"
" A = Anterior-to-Posterior P = Posterior-to-Anterior\n"
" I = Inferior-to-Superior S = Superior-to-Inferior\n"
" For example, 'LPI' means\n"
" -x = Left +x = Right\n"
" -y = Posterior +y = Anterior\n"
" -z = Inferior +z = Superior\n"
" * For display in SPM, 'LPI' or 'RPI' seem to work OK.\n"
" Be careful with this: you don't want to confuse L and R\n"
" in the SPM display!\n"
" * If you DON'T use this option, the dataset will be written\n"
" out in the orientation in which it is stored in AFNI\n"
" (e.g., the output of '3dinfo dset' will tell you this.)\n"
" * The dataset orientation is NOT stored in the .hdr file.\n"
" * AFNI and ANALYZE data are stored in files with the x-axis\n"
" varying most rapidly and the z-axis most slowly.\n"
" * Note that if you read an ANALYZE dataset into AFNI for\n"
" display, AFNI assumes the LPI orientation, unless you\n"
" set environment variable AFNI_ANALYZE_ORIENT.\n"
) ;
PRINT_COMPILE_DATE; exit(0) ;
}
mainENTRY("3dAFNItoANALYZE main"); machdep(); PRINT_VERSION("3dAFNItoANALYZE");
/*-- read inputs --*/
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-4D") == 0 ){ /* 30 Sep 2002 */
do_4D = 1 ; iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-orient") == 0 ){ /* 19 Mar 2003 */
char acod ;
if( iarg+1 >= argc ){
fprintf(stderr,"** Need something after -orient!\n"); exit(1);
}
MCW_strncpy(orient_code,argv[++iarg],4) ;
if( strlen(orient_code) != 3 ){
fprintf(stderr,"** Illegal code '%s' after -orient!\n",argv[iarg]); exit(1);
}
acod = toupper(orient_code[0]) ; xxor = ORCODE(acod) ;
acod = toupper(orient_code[1]) ; yyor = ORCODE(acod) ;
acod = toupper(orient_code[2]) ; zzor = ORCODE(acod) ;
if( xxor<0 || yyor<0 || zzor<0 || !OR3OK(xxor,yyor,zzor) ){
fprintf(stderr,"** Unusable code after -orient!\n"); exit(1);
}
iarg++ ; continue ;
}
fprintf(stderr,"** Illegal option: %s\n",argv[iarg]); exit(1);
}
if( iarg >= argc-1 ){
fprintf(stderr,"** Not enough arguments on command line!\n"); exit(1);
}
aname = argv[iarg++] ;
if( !THD_filename_ok(aname) ){
fprintf(stderr,"** Illegal aname string %s\n",aname) ;
exit(1) ;
}
fname = malloc( strlen(aname)+16 ) ;
dset = THD_open_dataset( argv[iarg++] ); CHECK_OPEN_ERROR(dset,argv[iarg-1]);
if( xxor >= 0 ){ /* 19 Mar 2003: figure how to flip */
xdir = THD_get_axis_direction( dset->daxes , xxor ) ;
ydir = THD_get_axis_direction( dset->daxes , yyor ) ;
zdir = THD_get_axis_direction( dset->daxes , zzor ) ;
if( ydir == 0 || zdir == 0 ) xdir = 0 ;
if( xdir == 1 && ydir == 2 && zdir == 3 ) xdir = 0 ;
}
if( xdir != 0 ){
float dx=fabs(DSET_DX(dset)) ,
dy=fabs(DSET_DY(dset)) ,
dz=fabs(DSET_DZ(dset)) ;
DSET_mallocize(dset) ;
switch( xdir ){
case 1: case -1: xdel = dx ; break ;
case 2: case -2: xdel = dy ; break ;
case 3: case -3: xdel = dz ; break ;
}
switch( ydir ){
case 1: case -1: ydel = dx ; break ;
case 2: case -2: ydel = dy ; break ;
case 3: case -3: ydel = dz ; break ;
}
switch( zdir ){
case 1: case -1: zdel = dx ; break ;
case 2: case -2: zdel = dy ; break ;
case 3: case -3: zdel = dz ; break ;
}
} else {
xdel = fabs(DSET_DX(dset)) ;
ydel = fabs(DSET_DY(dset)) ;
zdel = fabs(DSET_DZ(dset)) ;
}
DSET_load(dset) ; CHECK_LOAD_ERROR(dset) ;
/* determine if we scale to floats */
scl = THD_need_brick_factor( dset ) ;
/* 30 Sep 2002: if doing a 4D file, write single .hdr now */
if( do_4D ){
im = mri_empty_conforming( DSET_BRICK(dset,0) ,
(scl) ? MRI_float
: DSET_BRICK_TYPE(dset,0) ) ;
if( xdir != 0 ){
qim = mri_flip3D( xdir,ydir,zdir , im ) ;
if( qim == NULL){
fprintf(stderr,"mri_flip3D fails?!\n"); exit(1);
}
mri_free(im); im = qim;
}
im->dx = xdel ; /* load voxel sizes */
im->dy = ydel ;
im->dz = zdel ;
im->dw = 1.0 ;
if( AFNI_yesenv("AFNI_ANALYZE_ORIGINATOR") ){
im->xo = dset->daxes->xxorg ; /* load voxel origin */
im->yo = dset->daxes->yyorg ; /* 03/11/04 KRH added this bit for SPM */
im->zo = dset->daxes->zzorg ;
if( ORIENT_sign[dset->daxes->xxorient] == '-' ){
im->dx = -im->dx ;
/* im->xo = -im->xo ; */
}
if( ORIENT_sign[dset->daxes->yyorient] == '-' ){
im->dy = -im->dy ;
/* im->yo = -im->yo ; */
}
if( ORIENT_sign[dset->daxes->zzorient] == '-' ){
im->dz = -im->dz ;
/* im->zo = -im->zo ; */
}
}
im->nt = DSET_NVALS(dset) ; /* add a time axis */
im->dt = DSET_TR(dset) ;
if( im->dt <= 0.0 ) im->dt = 1.0 ;
if( DSET_TIMEUNITS(dset) == UNITS_MSEC_TYPE ) im->dt *= 0.001 ; /* 05 Jul 2005 */
mri_write_analyze( aname , im ) ; /* output 4D .hdr file */
mri_free(im) ;
sprintf(fname,"%s.img",aname) ; /* open output .img file */
ifp = fopen( fname , "wb" ) ;
if( ifp == NULL ){
fprintf(stderr,"** Can't open file %s for output!\n",fname) ;
exit(1) ;
}
}
/* loop over sub-bricks */
for( ii=0 ; ii < DSET_NVALS(dset) ; ii++ ){
im = DSET_BRICK(dset,ii) ; /* get the sub-brick */
if( scl ){ /* scale it to floats */
fac = DSET_BRICK_FACTOR(dset,ii) ;
if( fac == 0.0 ) fac = 1.0 ;
qim = mri_scale_to_float( fac , im ) ;
} else {
qim = im ;
}
if( xdir != 0 ){ /* 19 Mar 2003: flip it */
MRI_IMAGE *fim ;
fim = mri_flip3D( xdir,ydir,zdir , qim ) ;
if( fim == NULL ){
fprintf(stderr,"mri_flip3D fails at ii=%d ?!\n",ii); exit(1);
}
if( qim != im ) mri_free(qim) ;
qim = fim ;
}
if( do_4D ){ /* 30 Sep 2002: write into 4D .img file */
fwrite( mri_data_pointer(qim) , qim->nvox , qim->pixel_size , ifp ) ;
} else { /* write separate 3D .hdr/.img files */
qim->dx = xdel ; /* load voxel sizes */
qim->dy = ydel ;
qim->dz = zdel ;
qim->dw = 1.0 ;
if( AFNI_yesenv("AFNI_ANALYZE_ORIGINATOR") ){
qim->xo = dset->daxes->xxorg ; /* load voxel origin */
qim->yo = dset->daxes->yyorg ; /* 03/11/04 KRH added this bit for SPM */
qim->zo = dset->daxes->zzorg ;
if( ORIENT_sign[dset->daxes->xxorient] == '-' ){
qim->dx = -qim->dx ;
/* qim->xo = -qim->xo ; */
}
if( ORIENT_sign[dset->daxes->yyorient] == '-' ){
qim->dy = -qim->dy ;
/* qim->yo = -qim->yo ; */
}
if( ORIENT_sign[dset->daxes->zzorient] == '-' ){
qim->dz = -qim->dz ;
/* qim->zo = -qim->zo ; */
}
}
sprintf(fname,"%s_%04d",aname,ii) ; /* make up a filename */
mri_write_analyze( fname , qim ) ; /* do the real work */
}
if( qim != im ) mri_free(qim) ;
DSET_unload_one(dset,ii) ; /* clean up the trash */
}
if( ifp != NULL ) fclose(ifp) ; /* 30 Sep 2002 */
free(fname) ; exit(0) ;
}
/*! compute the overall minimum and maximum voxel values for a dataset */
int main( int argc , char * argv[] )
{
THD_3dim_dataset * old_dset , * new_dset ; /* input and output datasets */
int nopt, nbriks;
int slow_flag, quick_flag, min_flag, max_flag, mean_flag,
automask,count_flag, sum_flag, var_flag, absolute_flag;
int positive_flag, negative_flag, zero_flag, nan_flag, perc_flag, vol_flag;
byte * mmm=NULL ;
int mmvox=0 ;
int nxyz, i;
float *dvec = NULL, mmin=0.0, mmax=0.0;
int N_mp;
double *mpv=NULL, *perc = NULL;
double mp =0.0f, mp0 = 0.0f, mps = 0.0f, mp1 = 0.0f, di =0.0f ;
byte *mmf = NULL;
MRI_IMAGE *anat_im = NULL;
char *mask_dset_name=NULL;
/*----- Read command line -----*/
mainENTRY("3dBrickStat main"); machdep(); AFNI_logger("3dBrickStat",argc,argv);
nopt = 1 ;
min_flag = 0;
max_flag = -1;
mean_flag = 0;
sum_flag = 0;
var_flag = 0;
slow_flag = 0;
quick_flag = -1;
automask = 0;
count_flag = 0;
vol_flag = 0;
positive_flag = -1;
negative_flag = -1;
absolute_flag = 0;
zero_flag = -1;
nan_flag = -1;
perc_flag = 0;
mmin = 1.0;
mmax = -1.0;
mask_dset_name = NULL;
datum = MRI_float;
while( nopt < argc && argv[nopt][0] == '-' ){
if( strcmp(argv[nopt],"-help") == 0 ||
strcmp(argv[nopt],"-h") == 0){
usage_3dBrickStat(strlen(argv[nopt])> 3 ? 2:1);
exit(0);
}
if( strcmp(argv[nopt],"-ver") == 0 ){
PRINT_VERSION("3dBrickStat"); AUTHOR("Daniel Glen");
nopt++; continue;
}
if( strcmp(argv[nopt],"-quick") == 0 ){
quick_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-percentile") == 0 ){
perc_flag = 1;
++nopt;
if (nopt + 2 >= argc) {
ERROR_exit( "** Error: Need 3 parameter after -percentile\n");
}
mp0 = atof(argv[nopt])/100.0f; ++nopt;
mps = atof(argv[nopt])/100.0f; ++nopt;
mp1 = atof(argv[nopt])/100.0f;
if (mps == 0.0f) {
ERROR_exit( "** Error: step cannot be 0" );
}
if (mp0 < 0 || mp0 > 100 || mp1 < 0 || mp1 > 100) {
ERROR_exit( "** Error: p0 and p1 must be >=0 and <= 100" );
}
nopt++; continue;
}
if( strcmp(argv[nopt],"-median") == 0 ){
perc_flag = 1;
mp0 = 0.50f;
mps = 0.01f;
mp1 = 0.50f;
nopt++; continue;
}
if( strcmp(argv[nopt],"-slow") == 0 ){
slow_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-min") == 0 ){
min_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-max") == 0 ){
max_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-sum") == 0 ){
sum_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-mean") == 0 ){
mean_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-var") == 0 ){
if (var_flag) {
ERROR_message("Looks like -stdev is already used.\n"
"-var and -stdev are mutually exclusive");
exit (1);
}
var_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-stdev") == 0 ){
if (var_flag) {
ERROR_message("Looks like -var is already used.\n"
"-var and -stdev are mutually exclusive");
exit (1);
}
var_flag = 2;
nopt++; continue;
}
if( strcmp(argv[nopt],"-count") == 0 ){
count_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-volume") == 0 ){
vol_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-positive") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 1;
negative_flag = 0;
zero_flag = 0;
nopt++; continue;
}
if( strcmp(argv[nopt],"-negative") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 0;
negative_flag = 1;
zero_flag = 0;
nopt++; continue;
}
if( strcmp(argv[nopt],"-zero") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 0;
negative_flag = 0;
zero_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-non-positive") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 0;
negative_flag = 1;
zero_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-non-negative") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 1;
negative_flag = 0;
zero_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-non-zero") == 0 ){
if(positive_flag!=-1) {
ERROR_exit( "Can not use multiple +/-/0 options");
}
positive_flag = 1;
negative_flag = 1;
zero_flag = 0;
nopt++; continue;
}
if( strcmp(argv[nopt],"-absolute") == 0 ){
absolute_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-nan") == 0 ){
if(nan_flag!=-1) {
ERROR_exit( "Can not use both -nan -nonan options");
}
nan_flag = 1;
nopt++; continue;
}
if( strcmp(argv[nopt],"-nonan") == 0 ){
if(nan_flag!=-1) {
ERROR_exit( "Can not use both -nan -nonan options");
}
nan_flag = 0;
nopt++; continue;
}
if( strcmp(argv[nopt],"-autoclip") == 0 ||
strcmp(argv[nopt],"-automask") == 0 ){
if( mmm != NULL ){
ERROR_exit(" ERROR: can't use -autoclip/mask with -mask!");
}
automask = 1 ; nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mrange") == 0 ){
if (nopt+2 >= argc) {
ERROR_exit(" ERROR: Need two values after -mrange");
}
mmin = atof(argv[++nopt]);
mmax = atof(argv[++nopt]);
if (mmax < mmin) {
ERROR_exit(
"1st value in -mrange %s %s should be the smallest one",
argv[nopt-1], argv[nopt]);
}
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mvalue") == 0 ){
if (nopt+1 >= argc) {
ERROR_exit(" ERROR: Need 1 value after -mvalue");
}
mmin = atof(argv[++nopt]);
mmax = mmin ;
nopt++ ; continue ;
}
if( strcmp(argv[nopt],"-mask") == 0 ){
if( mask_dset_name != NULL )
ERROR_exit(" ERROR: can't have 2 -mask options!");
mask_dset_name = argv[++nopt];
nopt++ ; continue ;
}
ERROR_message( " Error - unknown option %s", argv[nopt]);
suggest_best_prog_option(argv[0], argv[nopt]);
exit(1);
}
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
ERROR_message("Too few options");
usage_3dBrickStat(0);
exit(1) ;
}
if (mask_dset_name) {
int ninmask = 0;
THD_3dim_dataset * mask_dset ;
if( automask ){
ERROR_exit(" ERROR: can't use -mask with -automask!");
}
mask_dset = THD_open_dataset(mask_dset_name) ;
CHECK_OPEN_ERROR(mask_dset,mask_dset_name) ;
mmm = THD_makemask( mask_dset , 0 , mmin, mmax ) ;
mmvox = DSET_NVOX( mask_dset ) ;
ninmask = THD_countmask (mmvox, mmm);
if (!ninmask) {
ERROR_exit(" No voxels in mask !");
}
/* text output program, so avoid extras 26 Dec 2013 [rickr] */
/* INFO_message("%d voxels in mask\n", ninmask); */
DSET_delete(mask_dset) ;
}
if(((mmm!=NULL) && (quick_flag))||(automask &&quick_flag)) {
if(quick_flag==1)
WARNING_message( "+++ Warning - can't have quick option with mask");
quick_flag = 0;
slow_flag = 1;
}
/* if max_flag is not set by user, check if other user options set */
if(max_flag==-1) {
if(min_flag || mean_flag || count_flag || vol_flag || sum_flag
|| perc_flag || var_flag)
max_flag = 0;
else
max_flag = 1; /* otherwise check only for max */
}
if((var_flag==1)||(mean_flag==1)||(count_flag==1)||
(vol_flag==1)||(absolute_flag==1) ||
(positive_flag!=-1)||(nan_flag!=-1)||
(sum_flag == 1)||(perc_flag == 1) || (var_flag==2)) {
/* mean flag or count_flag implies slow */
slow_flag = 1;
}
/* check slow and quick options */
if((slow_flag)&&(quick_flag!=1)) /* if user asked for slow give it to him */
quick_flag = 0;
else
quick_flag = 1;
if((max_flag==0)&&(min_flag==0)) /* if the user only asked for mean */
quick_flag = 0; /* no need to do quick way */
if((quick_flag) &&
((absolute_flag==1)||(positive_flag==1)||(negative_flag==1)||(zero_flag==1)))
WARNING_message( " Warning - ignoring +/-/0/abs flags for quick computations");
if(positive_flag==-1) { /* if no +/-/0 options set, allow all voxels */
positive_flag = 1;
negative_flag = 1;
zero_flag = 1;
}
/*----- read input dataset -----*/
if( nopt >= argc ){
ERROR_exit(" No input dataset!?");
}
old_dset = THD_open_dataset( argv[nopt] ) ;
CHECK_OPEN_ERROR(old_dset,argv[nopt]) ;
nxyz = DSET_NVOX(old_dset) ;
if( mmm != NULL && mmvox != nxyz ){
ERROR_exit(" Mask and input datasets not the same size!") ;
}
if(automask && mmm == NULL ){
mmm = THD_automask( old_dset ) ;
for(i=0;i<nxyz;i++) {
if(mmm[i]!=0) ++mmvox;
}
}
if(quick_flag)
Print_Header_MinMax(min_flag, max_flag, old_dset);
if(slow_flag!=1)
exit(0);
/* ZSS do some diddlyiddly sorting - DO not affect Daniel's function later on*/
if (perc_flag == 1) {
DSET_mallocize (old_dset);
DSET_load (old_dset);
if (DSET_NVALS(old_dset) != 1) {
ERROR_exit( "-percentile can only be used on one sub-brick only.\n"
"Use sub-brick selectors '[.]' to specify sub-brick of interest.\n");
}
/* prep for input and output of percentiles */
if (mp0 > mp1) {
N_mp = 1;
} else {
/* allocate one above ceiling to prevent truncation error (and crash),
N_mp is recomputed anyway 16 Mar 2009 [rickr] */
N_mp = (int)((double)(mp1-mp0)/(double)mps) + 2;
}
mpv = (double *)malloc(sizeof(double)*N_mp);
perc = (double *)malloc(sizeof(double)*N_mp);
if (!mpv || !perc) {
ERROR_message("Failed to allocate for mpv or perc");
exit(1);
}
N_mp = 0;
mp = mp0;
do {
mpv[N_mp] = mp; ++N_mp; mp += mps;
} while (mp <= mp1+.00000001);
if (!Percentate (DSET_ARRAY(old_dset, 0), mmm, nxyz,
DSET_BRICK_TYPE(old_dset,0), mpv, N_mp,
0, perc,
zero_flag, positive_flag, negative_flag )) {
ERROR_message("Failed to compute percentiles.");
exit(1);
}
/* take care of brick factor */
if (DSET_BRICK_FACTOR(old_dset,0)) {
for (i=0; i<N_mp; ++i) {
perc[i] = perc[i]*DSET_BRICK_FACTOR(old_dset,0);
}
}
for (i=0; i<N_mp; ++i) {
fprintf(stdout,"%.1f %f ", mpv[i]*100.0f, perc[i]);
}
free(mpv); mpv = NULL;
free(perc); perc = NULL;
}
Max_func(min_flag, max_flag, mean_flag,count_flag,
positive_flag, negative_flag, zero_flag, absolute_flag,
nan_flag, sum_flag, var_flag, vol_flag,old_dset, mmm, mmvox);
if(mmm!=NULL)
free(mmm);
exit(0);
/* unused code time series method for extracting data */
#if 0
EDIT_dset_items( old_dset ,
ADN_ntt , DSET_NVALS(old_dset) ,
ADN_ttorg , 0.0 ,
ADN_ttdel , 1.0 ,
ADN_tunits , UNITS_SEC_TYPE ,
NULL ) ;
nbriks = 1;
/*------------- ready to compute new min, max -----------*/
new_dset = MAKER_4D_to_typed_fbuc(
old_dset , /* input dataset */
"temp" , /* output prefix */
datum , /* output datum */
0 , /* ignore count */
0 , /* can't detrend in maker function KRH 12/02*/
nbriks , /* number of briks */
Max_tsfunc , /* timeseries processor */
NULL, /* data for tsfunc */
NULL, /* mask */
0 /* Allow auto scaling of output */
) ;
if(min_flag)
printf("%-13.6g ", minvalue);
if(max_flag)
printf("%-13.6g", maxvalue);
printf("\n");
exit(0) ;
#endif
}
int main( int argc , char * argv[] )
{
THD_3dim_dataset *mask_dset=NULL, *iset=NULL,
*sset=NULL, *xset=NULL, *vset=NULL;
char *prefix="toy";
int iarg=1 , mcount, udatum = MRI_float;
byte *maskvox=NULL;
mainENTRY("3dToyProg main"); machdep(); AFNI_logger("3dToyProg",argc,argv);
#ifdef USING_MCW_MALLOC
enable_mcw_malloc() ;
#endif
/*-- options --*/
set_obliquity_report(0); /* silence obliquity */
while( iarg < argc && argv[iarg][0] == '-' ){
CHECK_HELP(argv[iarg], help_3dToyProg);
if( strncmp(argv[iarg],"-mask",5) == 0 ){
if (iarg >= argc) ERROR_exit("Need dset after -mask");
mask_dset = THD_open_dataset( argv[++iarg] ) ;
if( mask_dset == NULL )
ERROR_exit("Cannot open mask dataset!\n") ;
if( DSET_BRICK_TYPE(mask_dset,0) == MRI_complex )
ERROR_exit("Cannot deal with complex-valued mask dataset!\n");
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-input") == 0) {
if (iarg >= argc) ERROR_exit("Need dset after -mask");
if (!(iset = THD_open_dataset( argv[++iarg]))) {
ERROR_exit("Cannot open input dataset %s!\n", argv[iarg]) ;
}
DSET_mallocize(iset); DSET_load(iset); /* load data part of dataset */
iarg++ ; continue ;
}
if( strncmp(argv[iarg],"-prefix",6) == 0) {
if (iarg >= argc) ERROR_exit("Need name after -prefix");
prefix = argv[++iarg];
iarg++ ; continue ;
continue ;
}
if( strcmp(argv[iarg],"-datum") == 0) {
if (iarg >= argc) ERROR_exit("Need datum type after -datum");
++iarg;
if (!strcmp(argv[iarg],"float")) udatum = MRI_float;
else if (!strcmp(argv[iarg],"short")) udatum = MRI_short;
else {
ERROR_exit(
"For the purpose of this demo, only float and short are allowed");
}
iarg++ ; continue ;
continue ;
}
ERROR_message("ILLEGAL option: %s\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
if( argc < 2 ){
help_3dToyProg(TXT, 0);
PRINT_COMPILE_DATE ; exit(0) ;
}
if( !iset )
ERROR_exit("No dataset on command line!?") ;
if (mask_dset) {
if (THD_dataset_mismatch(mask_dset, iset))
ERROR_exit("grid mismatch between input dset and mask dset");
maskvox = THD_makemask( mask_dset , 0 , 1.0, -1.0 ) ;
mcount = THD_countmask( DSET_NVOX(mask_dset) , maskvox ) ;
if( mcount <= 0 ) ERROR_exit("No voxels in the mask!\n") ;
INFO_message("%d voxels in the mask dset %s\n",
mcount, DSET_PREFIX(mask_dset)) ;
DSET_delete(mask_dset) ; mask_dset=NULL; /* Done with the mask dset */
}
/* An illustration of how volume navigation works */
Dataset_Navigation(iset);
/* Let us create a dataset from scratch */
sset = New_Dataset_From_Scratch(prefix);
/* Now for the output, add history, check for overwrite and write away */
tross_Copy_History( iset , sset );/* Copy the old history (not mandatory). */
tross_Make_History("3dToyProg", argc, argv ,sset) ; /* add the new */
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(sset)) ) {
ERROR_message(
"Output %s already exists, use -overwrite to do you know what",
DSET_HEADNAME(sset));
} else DSET_write(sset);
/* Now we'll do some voxelwise computations */
xset = Voxelwise_Operations(sset, maskvox, prefix);
tross_Copy_History( iset , xset ) ; /* Copy the old */
tross_Make_History("3dToyProg", argc, argv ,xset) ; /* add the new */
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(xset)) ) {
ERROR_message(
"Output %s already exists, use -overwrite to do you know what",
DSET_HEADNAME(xset));
} else DSET_write(xset);
/* Or some volumewise operations */
vset = Volumewise_Operations(sset, prefix, udatum);
tross_Copy_History( iset , vset ) ; /* Copy the old */
tross_Make_History("3dToyProg", argc, argv ,vset) ; /* add the new */
if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(vset)) ) {
ERROR_message(
"Output %s already exists, use -overwrite to do you know what",
DSET_HEADNAME(vset));
} else DSET_write(vset);
/* cleanup */
DSET_delete(xset); xset = NULL;
DSET_delete(vset); vset = NULL;
DSET_delete(sset); sset = NULL;
exit(0) ;
}
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) ;
}
int
main (int argc, char *argv[])
{
THD_3dim_dataset *old_dset, *new_dset, *I0_dset; /* input and output datasets */
int nopt, nbriks, nvox;
int i;
MRI_IMAGE *grad1Dptr = NULL;
MRI_IMAGE *anat_im = NULL;
MRI_IMAGE *data_im = NULL;
double fac;
short *sar = NULL, *tempsptr = NULL, tempval;
byte *maskptr = NULL, *tempbptr = NULL;
char tempstr[25];
/*----- Read command line -----*/
if (argc < 2 || strcmp (argv[1], "-help") == 0)
{
printf ("Usage: 3dDTtoDWI [options] gradient-file I0-dataset DT-dataset\n"
"Computes multiple gradient images from 6 principle direction tensors and\n"
" corresponding gradient vector coordinates applied to the I0-dataset.\n"
" The program takes three parameters as input : \n"
" a 1D file of the gradient vectors with lines of ASCII floats Gxi,Gyi,Gzi.\n"
" Only the non-zero gradient vectors are included in this file (no G0 line).\n"
" The I0 dataset is a volume without any gradient applied.\n"
" The DT dataset is the 6-sub-brick dataset containing the diffusion tensor data,\n"
" Dxx, Dxy, Dyy, Dxz, Dyz, Dzz (lower triangular row-wise order)\n"
" Options:\n"
" -prefix pname = Use 'pname' for the output dataset prefix name.\n"
" [default='DWI']\n"
" -automask = mask dataset so that the gradient images are computed only for\n"
" high-intensity (presumably brain) voxels. The intensity level is\n"
" determined the same way that 3dClipLevel works.\n\n"
" -datum type = output dataset type [float/short/byte] (default is float).\n"
" -help = show this help screen.\n"
" Example:\n"
" 3dDTtoDWI -prefix DWI -automask tensor25.1D 'DT+orig[26]' DT+orig.\n\n"
" The output is a n sub-brick bucket dataset containing computed DWI images.\n"
" where n is the number of vectors in the gradient file + 1\n"
"\n");
printf ("\n" MASTER_SHORTHELP_STRING);
exit (0);
}
mainENTRY ("3dDTtoDWI main");
machdep ();
AFNI_logger ("3dDTtoDWI", argc, argv);
PRINT_VERSION("3dDTtoDWI") ;
nopt = 1;
datum = MRI_float;
while (nopt < argc && argv[nopt][0] == '-')
{
/*-- prefix --*/
if (strcmp (argv[nopt], "-prefix") == 0)
{
if (++nopt >= argc)
{
fprintf (stderr, "*** Error - prefix needs an argument!\n");
exit (1);
}
MCW_strncpy (prefix, argv[nopt], THD_MAX_PREFIX); /* change name from default prefix */
/* check file name to be sure not to overwrite - mod drg 12/9/2004 */
if (!THD_filename_ok (prefix))
{
fprintf (stderr, "*** Error - %s is not a valid prefix!\n", prefix);
exit (1);
}
nopt++;
continue;
}
/*-- datum --*/
if (strcmp (argv[nopt], "-datum") == 0)
{
if (++nopt >= argc)
{
fprintf (stderr, "*** Error - datum needs an argument!\n");
exit (1);
}
if (strcmp (argv[nopt], "short") == 0)
{
datum = MRI_short;
}
else if (strcmp (argv[nopt], "float") == 0)
{
datum = MRI_float;
}
else if (strcmp (argv[nopt], "byte") == 0)
{
datum = MRI_byte;
}
else
{
fprintf (stderr, "-datum of type '%s' is not supported!\n",
argv[nopt]);
exit (1);
}
nopt++;
continue;
}
if (strcmp (argv[nopt], "-automask") == 0)
{
automask = 1;
nopt++;
continue;
}
fprintf(stderr, "*** Error - unknown option %s\n", argv[nopt]);
exit(1);
}
/*----- read input datasets -----*/
if (nopt >= argc)
{
fprintf (stderr, "*** Error - No input dataset!?\n");
exit (1);
}
/* first input dataset - should be gradient vector file of ascii floats Gx,Gy,Gz */
/* read gradient vector 1D file */
grad1Dptr = mri_read_1D (argv[nopt]);
if (grad1Dptr == NULL)
{
fprintf (stderr, "*** Error reading gradient vector file\n");
exit (1);
}
if (grad1Dptr->ny != 3)
{
fprintf (stderr, "*** Error - Only 3 columns of gradient vectors allowed\n");
fprintf (stderr, "%d columns found\n", grad1Dptr->nx);
mri_free (grad1Dptr);
exit (1);
}
if (grad1Dptr->nx < 6)
{
fprintf (stderr, "*** Error - Must have at least 6 gradient vectors\n");
fprintf (stderr, "%d columns found\n", grad1Dptr->nx);
mri_free (grad1Dptr);
exit (1);
}
nbriks = grad1Dptr->nx + 1; /* number of gradients specified here from file */
nopt++;
/* open I0 dataset - idealized no gradient image */
I0_dset = THD_open_dataset (argv[nopt]);
CHECK_OPEN_ERROR(I0_dset,argv[nopt]) ;
DSET_mallocize (I0_dset);
DSET_load (I0_dset); /* load dataset */
data_im = DSET_BRICK (I0_dset, 0); /* set pointer to the 0th sub-brik of the dataset */
fac = DSET_BRICK_FACTOR(I0_dset, 0); /* get scale factor for each sub-brik*/
if(fac==0.0) fac=1.0;
if((data_im->kind != MRI_float)) {
fprintf (stderr, "*** Error - Can only open float datasets. Use 3dcalc to convert.\n");
mri_free (grad1Dptr);
mri_free (data_im);
exit (1);
}
I0_ptr = mri_data_pointer(data_im) ; /* pointer to I0 data */
nopt++;
/* Now read in all the MRI volumes for each gradient vector */
/* assumes first one is no gradient */
old_dset = THD_open_dataset (argv[nopt]);
CHECK_OPEN_ERROR(old_dset,argv[nopt]) ;
/* expect at least 6 values per voxel - 6 sub-briks as input dataset */
if (DSET_NVALS (old_dset) <6)
{
fprintf (stderr,
"*** Error - Dataset must have at least 6 sub-briks to describe the diffusion tensor\n");
mri_free (grad1Dptr);
mri_free (data_im);
exit (1);
}
InitGlobals (grad1Dptr->nx + 1); /* initialize all the matrices and vectors */
Computebmatrix (grad1Dptr, BMAT_NZ); /* compute bij=GiGj */
INFO_message("The maximum magnitude of the bmatrix appears to be: %.2f", MAX_BVAL);
if (automask)
{
DSET_mallocize (old_dset);
DSET_load (old_dset); /* get B0 (anatomical image) from dataset */
/*anat_im = THD_extract_float_brick( 0, old_dset ); */
anat_im = DSET_BRICK (old_dset, 0); /* set pointer to the 0th sub-brik of the dataset */
maskptr = mri_automask_image (anat_im); /* maskptr is a byte pointer for volume */
/* convert byte mask to same format type as dataset */
nvox = DSET_NVOX (old_dset);
sar = (short *) calloc (nvox, sizeof (short));
/* copy maskptr values to far ptr */
tempsptr = sar;
tempbptr = maskptr;
for (i = 0; i < nvox; i++)
{
*tempsptr++ = (short) *tempbptr++;
tempval = *(tempsptr - 1);
}
free (maskptr);
/*old_dset->dblk->malloc_type = DATABLOCK_MEM_MALLOC; *//* had to set this? */
EDIT_add_brick (old_dset, MRI_short, 0.0, sar); /* add sub-brik to end */
}
/* temporarily set artificial timing to 1 second interval */
EDIT_dset_items (old_dset,
ADN_ntt, DSET_NVALS (old_dset),
ADN_ttorg, 0.0,
ADN_ttdel, 1.0, ADN_tunits, UNITS_SEC_TYPE, NULL);
/*------------- ready to compute new dataset -----------*/
new_dset = MAKER_4D_to_typed_fbuc (old_dset, /* input dataset */
prefix, /* output prefix */
datum, /* output datum */
0, /* ignore count */
0, /* can't detrend in maker function KRH 12/02 */
nbriks, /* number of briks */
DTtoDWI_tsfunc, /* timeseries processor */
NULL, /* data for tsfunc */
NULL, /* mask */
0 /* Allow auto scaling of output */
);
FreeGlobals ();
mri_free (grad1Dptr);
if (automask)
{
mri_free (anat_im);
DSET_unload_one (old_dset, 0);
sar = NULL;
}
if (new_dset != NULL)
{
tross_Copy_History (old_dset, new_dset);
for(i=0;i<nbriks;i++) {
sprintf(tempstr,"grad%3.3d", i);
EDIT_dset_items (new_dset, ADN_brick_label_one + i, tempstr, ADN_none);
}
tross_Make_History ("3dDTtoDWI", argc, argv, new_dset);
DSET_write (new_dset);
fprintf(stderr,"--- Output dataset %s\n", DSET_BRIKNAME(new_dset));
}
else
{
fprintf (stderr, "*** Error - Unable to compute output dataset!\n");
exit (1);
}
exit (0);
}
int main( int argc , char * argv[] )
{
int iv,nvals , nvec , ii,jj,kk , nvox ;
THD_3dim_dataset * new_dset=NULL ;
double * choleski ;
float ** refvec , * fv , * fc , * fit ;
MRI_IMAGE * flim ;
/*** read input options ***/
if( argc < 2 || strncmp(argv[1],"-help",4) == 0 ) DT_Syntax() ;
/*-- 20 Apr 2001: addto the arglist, if user wants to [RWCox] --*/
mainENTRY("3dDetrend main"); machdep() ; PRINT_VERSION("3dDetrend");
AFNI_logger("3dDetrend",argc,argv) ;
{ int new_argc ; char ** new_argv ;
addto_args( argc , argv , &new_argc , &new_argv ) ;
if( new_argv != NULL ){ argc = new_argc ; argv = new_argv ; }
}
DT_read_opts( argc , argv ) ;
/*** create new dataset (empty) ***/
new_dset = EDIT_empty_copy( DT_dset ) ; /* make a copy of its header */
/* modify its header */
tross_Copy_History( DT_dset , new_dset ) ;
tross_Make_History( "3dDetrend" , argc,argv , new_dset ) ;
EDIT_dset_items( new_dset ,
ADN_prefix , DT_output_prefix ,
ADN_directory_name, DT_session ,
ADN_none ) ;
/* can't re-write existing dataset */
if( THD_deathcon() && THD_is_file(DSET_HEADNAME(new_dset)) )
ERROR_exit("File %s already exists!\n",DSET_HEADNAME(new_dset) ) ;
/* read input in, and attach its bricks to the output dataset */
/* (not good in a plugin, but OK in a standalone program!) */
if( DT_verb ) INFO_message("Loading input dataset bricks\n") ;
DSET_mallocize( new_dset ) ;
DSET_mallocize( DT_dset ) ;
DSET_load( DT_dset ) ; CHECK_LOAD_ERROR(DT_dset) ;
nvals = DSET_NVALS(new_dset) ;
for( iv=0 ; iv < nvals ; iv++ )
EDIT_substitute_brick( new_dset , iv ,
DSET_BRICK_TYPE(DT_dset,iv) ,
DSET_ARRAY(DT_dset,iv) ) ;
if( DT_norm && DSET_BRICK_TYPE(new_dset,0) != MRI_float ){
INFO_message("Turning -normalize option off (input not in float format)");
DT_norm = 0 ;
}
/* load reference (detrending) vectors;
setup to do least squares fitting of each voxel */
nvec = 0 ;
for( ii=0 ; ii < IMARR_COUNT(DT_imar) ; ii++ ) /* number of detrending vectors */
nvec += IMARR_SUBIMAGE(DT_imar,ii)->ny ;
refvec = (float **) malloc( sizeof(float *)*nvec ) ;
for( kk=ii=0 ; ii < IMARR_COUNT(DT_imar) ; ii++ ){
fv = MRI_FLOAT_PTR( IMARR_SUBIMAGE(DT_imar,ii) ) ;
for( jj=0 ; jj < IMARR_SUBIMAGE(DT_imar,ii)->ny ; jj++ ) /* compute ptr */
refvec[kk++] = fv + ( jj * IMARR_SUBIMAGE(DT_imar,ii)->nx ) ; /* to vectors */
}
fit = (float *) malloc( sizeof(float) * nvals ) ; /* will get fit to voxel data */
/*--- do the all-voxels-together case ---*/
if( !DT_byslice ){
choleski = startup_lsqfit( nvals , NULL , nvec , refvec ) ;
if( choleski == NULL )
ERROR_exit("Choleski factorization fails: linearly dependent vectors!\n") ;
/* loop over voxels, fitting and detrending (or replacing) */
nvox = DSET_NVOX(new_dset) ;
if( DT_verb ) INFO_message("Computing voxel fits\n") ;
for( kk=0 ; kk < nvox ; kk++ ){
flim = THD_extract_series( kk , new_dset , 0 ) ; /* data */
fv = MRI_FLOAT_PTR(flim) ;
fc = delayed_lsqfit( nvals, fv, nvec, refvec, choleski ) ; /* coef */
for( ii=0 ; ii < nvals ; ii++ ) fit[ii] = 0.0 ;
for( jj=0 ; jj < nvec ; jj++ )
for( ii=0 ; ii < nvals ; ii++ )
fit[ii] += fc[jj] * refvec[jj][ii] ; /* fit */
if( !DT_replace ) /* remove */
for( ii=0 ; ii < nvals ; ii++ ) fit[ii] = fv[ii] - fit[ii] ;
if( DT_norm ) THD_normalize( nvals , fit ) ; /* 23 Nov 1999 */
THD_insert_series( kk, new_dset, nvals, MRI_float, fit, 0 ) ;
free(fc) ; mri_free(flim) ;
}
free(choleski) ;
/*- end of all-voxels-together case -*/
}
#ifdef ALLOW_BYSLICE
else { /*- start of slice case [08 Dec 1999] -*/
int ksl , nslice , tt , nx,ny , nxy , kxy ;
MRI_IMAGE * vim ;
/* make separate space for the slice-wise detrending vectors */
for( kk=ii=0 ; ii < DT_nvector ; ii++ ){
for( jj=0 ; jj < IMARR_SUBIMAGE(DT_imar,ii)->ny ; jj++ ) /* replace ptrs */
refvec[kk++] = (float *) malloc( sizeof(float) * nvals ) ; /* to vectors */
}
nslice = DSET_NZ(new_dset) ;
nxy = DSET_NX(new_dset) * DSET_NY(new_dset) ;
/* loop over slices */
for( ksl=0 ; ksl < nslice ; ksl++ ){
if( DT_verb ) INFO_message("Computing voxel fits for slice %d\n",ksl) ;
/* extract slice vectors from input interlaced vectors */
for( kk=ii=0 ; ii < DT_nvector ; ii++ ){ /* loop over vectors */
vim = IMARR_SUBIMAGE(DT_imar,ii) ; /* ii-th vector image */
nx = vim->nx ; ny = vim->ny ; /* dimensions */
for( jj=0 ; jj < ny ; jj++ ){ /* loop over columns */
fv = MRI_FLOAT_PTR(vim) + (jj*nx) ; /* ptr to column */
for( tt=0 ; tt < nvals ; tt++ ) /* loop over time */
refvec[kk][tt] = fv[ksl+tt*nslice] ; /* data point */
}
}
/* initialize fitting for this slice */
choleski = startup_lsqfit( nvals , NULL , nvec , refvec ) ;
if( choleski == NULL )
ERROR_exit("Choleski fails: linearly dependent vectors at slice %d\n",ksl) ;
/* loop over voxels in this slice */
for( kxy=0 ; kxy < nxy ; kxy++ ){
kk = kxy + ksl*nxy ; /* 3D index */
flim = THD_extract_series( kk , new_dset , 0 ) ; /* data */
fv = MRI_FLOAT_PTR(flim) ;
fc = delayed_lsqfit( nvals, fv, nvec, refvec, choleski ) ; /* coef */
for( ii=0 ; ii < nvals ; ii++ ) fit[ii] = 0.0 ;
for( jj=0 ; jj < nvec ; jj++ )
for( ii=0 ; ii < nvals ; ii++ )
fit[ii] += fc[jj] * refvec[jj][ii] ; /* fit */
if( !DT_replace ) /* remove */
for( ii=0 ; ii < nvals ; ii++ ) fit[ii] = fv[ii] - fit[ii] ;
if( DT_norm ) THD_normalize( nvals , fit ) ; /* 23 Nov 1999 */
THD_insert_series( kk, new_dset, nvals, MRI_float, fit, 0 ) ;
free(fc) ; mri_free(flim) ;
}
free(choleski) ;
} /* end of loop over slices */
} /*- end of -byslice case -*/
#endif
/*-- done done done done --*/
DSET_write(new_dset) ;
if( DT_verb ) WROTE_DSET(new_dset) ;
exit(0) ;
}
/*
Zero out voxels vv in dset where cmask[vv]=0
Returns the number of voxels edited in dset (across all sub-bricks)
-1 if dset was null
*/
int THD_applydsetmask( THD_3dim_dataset *dset , byte *cmask )
{
int ss, ii, jj, kk, vv, nedited = -1 ;
ENTRY("THD_applydsetmask");
if (!dset) RETURN(nedited);
if (!cmask) RETURN(0);
DSET_mallocize(dset); DSET_load(dset);
for (ss=0; ss<DSET_NVALS(dset); ++ss) {
switch (DSET_BRICK_TYPE(dset,ss)) {
case MRI_byte:
{ byte *bv = (byte *)DSET_ARRAY(dset,ss) ;
vv=0;
for (kk=0; kk<DSET_NZ(dset); ++kk) {
for (jj=0; jj<DSET_NY(dset); ++jj) {
for (ii=0; ii<DSET_NX(dset); ++ii) {
if (!cmask[vv]) {
bv[vv] = 0;
++nedited;
}
++vv;
} } }
}
break;
case MRI_short:
{ short *sv = (short *)DSET_ARRAY(dset,ss) ;
vv=0;
for (kk=0; kk<DSET_NZ(dset); ++kk) {
for (jj=0; jj<DSET_NY(dset); ++jj) {
for (ii=0; ii<DSET_NX(dset); ++ii) {
if (!cmask[vv]) {
sv[vv] = 0;
++nedited;
}
++vv;
} } }
}
break;
case MRI_float:
{ float *fv = (float *)DSET_ARRAY(dset,ss) ;
vv=0;
for (kk=0; kk<DSET_NZ(dset); ++kk) {
for (jj=0; jj<DSET_NY(dset); ++jj) {
for (ii=0; ii<DSET_NX(dset); ++ii) {
if (!cmask[vv]) {
fv[vv] = 0;
++nedited;
}
++vv;
} } }
}
break;
case MRI_complex:
{ complex *cv = (complex *)DSET_ARRAY(dset,ss) ;
vv=0;
for (kk=0; kk<DSET_NZ(dset); ++kk) {
for (jj=0; jj<DSET_NY(dset); ++jj) {
for (ii=0; ii<DSET_NX(dset); ++ii) {
if (!cmask[vv]) {
cv[vv].i = cv[vv].r = 0.0;
++nedited;
}
++vv;
} } }
}
break;
default:
ERROR_message(
"THD_applydsetmask: Dset type %d for subbrick %d not supported\n",
DSET_BRICK_TYPE(dset,ss), ss);
break;
}
}
RETURN(nedited);
}
int THD_makedsetmask( THD_3dim_dataset *mask_dset ,
int miv , float mask_bot , float mask_top,
byte *cmask )
{
float maxval ; /* for computing limits for an empty mask */
int nvox , ii, nonzero=-1 , empty = 0 ;
if( !ISVALID_DSET(mask_dset) ||
miv < 0 ||
miv >= DSET_NVALS(mask_dset) ) return (-1) ;
nvox = DSET_NVOX(mask_dset) ;
DSET_mallocize(mask_dset); /* do this or else it could be a read only dset! */
DSET_load(mask_dset) ; if( !DSET_LOADED(mask_dset) ) return (-1) ;
nonzero = 0;
switch( DSET_BRICK_TYPE(mask_dset,miv) ){
default:
DSET_unload(mask_dset) ; return (-1) ;
case MRI_short:{
short mbot , mtop ;
short *mar = (short *) DSET_ARRAY(mask_dset,miv) ;
float mfac = DSET_BRICK_FACTOR(mask_dset,miv) ;
if( mfac == 0.0 ) mfac = 1.0 ;
if( mask_bot <= mask_top ){
/* maybe this mask is empty, allow for rounding */
maxval = MRI_TYPE_maxval[MRI_short] + 0.5 ;
if( mask_bot/mfac >= maxval || mask_top/mfac <= -maxval ) empty=1;
mbot = SHORTIZE(mask_bot/mfac) ;
mtop = SHORTIZE(mask_top/mfac) ;
} else {
mbot = (short) -MRI_TYPE_maxval[MRI_short] ;
mtop = (short) MRI_TYPE_maxval[MRI_short] ;
}
if (empty) { /* if empty, clear result 6 Jun 2007 */
for( ii=0 ; ii < nvox ; ii++ ) mar[ii] = 0;
} else if (cmask) {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 && cmask[ii]) { mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
} else {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 ) { mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
}
}
break ;
case MRI_byte:{
byte mbot , mtop ;
byte *mar = (byte *) DSET_ARRAY(mask_dset,miv) ;
float mfac = DSET_BRICK_FACTOR(mask_dset,miv) ;
if( mfac == 0.0 ) mfac = 1.0 ;
if( mask_bot <= mask_top && mask_top > 0.0 ){
/* maybe this mask is empty, allow for rounding */
/* (top <= 0 is flag for full mask) */
maxval = MRI_TYPE_maxval[MRI_byte] + 0.5 ;
if( mask_bot/mfac >= maxval ) empty = 1;
mbot = BYTEIZE(mask_bot/mfac) ;
mtop = BYTEIZE(mask_top/mfac) ;
} else {
mbot = 0 ;
mtop = (byte) MRI_TYPE_maxval[MRI_short] ;
}
if (empty) { /* if empty, clear result 6 Jun 2007 */
for( ii=0 ; ii < nvox ; ii++ ) mar[ii] = 0;
} else if (cmask) {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 && cmask[ii]){ mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
} else {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 ){ mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
}
}
break ;
case MRI_float:{
float mbot , mtop ;
float *mar = (float *) DSET_ARRAY(mask_dset,miv) ;
float mfac = DSET_BRICK_FACTOR(mask_dset,miv) ;
if( mfac == 0.0 ) mfac = 1.0 ;
if( mask_bot <= mask_top ){
mbot = (float) (mask_bot/mfac) ;
mtop = (float) (mask_top/mfac) ;
} else {
mbot = -WAY_BIG ;
mtop = WAY_BIG ;
}
if (cmask) {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 && cmask[ii]) { mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
} else {
for( ii=0 ; ii < nvox ; ii++ )
if( mar[ii] >= mbot && mar[ii] <= mtop && mar[ii] != 0 ) { mar[ii]=1; ++nonzero; }
else { mar[ii] = 0; }
}
}
break ;
}
/* remove any scaling factor ZSS April 24 06*/
EDIT_BRICK_FACTOR(mask_dset,miv , 0.0);
return (nonzero) ;
}