/*---------------------------------------------------------------------
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);
}
MRI_vectim * THD_dset_list_censored_to_vectim( int nds, THD_3dim_dataset **ds,
byte *mask , int nkeep , int *keep )
{
MRI_vectim *vout , **vim ;
int kk , jj ;
if( nds < 1 || ds == NULL ) return NULL ;
if( nds == 1 ) /* trivial case */
return THD_dset_censored_to_vectim( ds[0],mask,nkeep,keep );
for( kk=0 ; kk < nds ; kk++ ){
if( !ISVALID_DSET(ds[kk]) ) return NULL ;
if( DSET_NVALS(ds[kk]) != DSET_NVALS(ds[0]) ) return NULL ;
}
#pragma omp critical (MALLOC)
vim = (MRI_vectim **)malloc(sizeof(MRI_vectim *)*nds) ;
for( kk=0 ; kk < nds ; kk++ ){
vim[kk] = THD_dset_censored_to_vectim( ds[kk] , mask , nkeep,keep ) ;
/** DSET_unload( ds[kk] ) ; **/
if( vim[kk] == NULL ){
for( jj=0 ; jj < kk ; jj++ ) VECTIM_destroy(vim[jj]) ;
free(vim) ; return NULL ;
}
}
vout = THD_tcat_vectims( nds , vim ) ;
for( jj=0 ; jj < nds ; jj++ ) VECTIM_destroy(vim[jj]) ;
free(vim) ; return vout ;
}
/*
Get copy contents of sub-brick iv into an double array.
if iv == -1, get the entire dset
*/
double *THD_extract_to_double( int iv , THD_3dim_dataset *dset )
{
MRI_IMAGE *im ;
double *var=NULL, *vv=NULL;
register int ii , nvox ;
ENTRY("THD_extract_to_double") ;
if (!dset) RETURN(var);
if (iv >= 0) {
if (!(im = THD_extract_double_brick(iv, dset))) RETURN(var);
var = MRI_DOUBLE_PTR(im);mri_fix_data_pointer(NULL, im);
mri_free(im);im=NULL;
} else if (iv == -1) {
if (!(var = (double *)calloc(DSET_NVOX(dset)*DSET_NVALS(dset),
sizeof(double)))){
ERROR_message("Failed to allocate");
RETURN(NULL);
}
for (ii=0; ii<DSET_NVALS(dset); ++ii) {
if (!(im = THD_extract_double_brick(ii, dset))) {
ERROR_message("Failed toextract sb %d from dset", ii);
if (var) free(var);
RETURN(NULL);
}
vv = MRI_DOUBLE_PTR(im);
memcpy(var+ii*DSET_NVOX(dset),vv, sizeof(double)*DSET_NVOX(dset));
mri_free(im);im=NULL;
}
} else {
ERROR_message("Bad value of %d\n", iv);
}
RETURN(var);
}
/* Calculates the average value for each voxel in dset across all timepoints.
PRE:
dset is a valid 3D+T dataset with at least 1 timepoint;
ignore is the number of timepoints to ignore at the beginning of dset;
0 <= ignore < number of timepoints in dset;
POST:
return value is NULL on error,
else, return value is an array of floats with the same dimensions as the
subbricks of dset, containing the voxel value averages;
Note: The caller is responsible for free()ing the returned block of memory
when done.
Note2: The complex datatype is not supported, and any such bricks will
result in an error (NULL return value).
*/
double * RIC_CalcVoxelMeans(const THD_3dim_dataset * dset, int ignore) {
double * avg; /* The voxel averages to be returned */
float scalefactor; /* Current dset brick scaling factor */
int ival, nvals; /* Current, number of dset timepoints */
int ivox, nvoxs; /* Current, number of dset brick voxels */
/* Quick check of arguments */
if (!ISVALID_3DIM_DATASET(dset) || DSET_NVALS(dset) < 1 ||
ignore < 0 || ignore >= DSET_NVALS(dset)) {
return NULL;
}
/* Initialize */
DSET_load(dset);
nvals = DSET_NVALS(dset);
nvoxs = dset->daxes->nxx * dset->daxes->nyy * dset->daxes->nzz;
avg = malloc(sizeof(double) * nvoxs);
if (avg == NULL) {
return NULL;
}
/* Calculate the voxel averages; treat matrices as 1-D arrays */
/* Zero the voxel sums */
for (ivox = 0; ivox < nvoxs; ivox += 1) {
avg[ivox] = 0.0;
}
/* Sum each voxel across time (and hope there are not too many points) */
for (ival = ignore; ival < nvals; ival += 1) {
scalefactor = DSET_BRICK_FACTOR(dset, ival);
switch (DSET_BRICK_TYPE(dset, ival)) {
case MRI_short:
RIC_CALCVOXELMEANS__DO_VOXSUM(short);
break;
case MRI_byte:
RIC_CALCVOXELMEANS__DO_VOXSUM(byte);
break;
case MRI_float:
RIC_CALCVOXELMEANS__DO_VOXSUM(float);
break;
default: /* Unsupported datatype */
free(avg);
return NULL;
}
}
/* Divide by number of timepoints to get average */
nvals -= ignore; /* We do not average over the ignored timepoints */
for (ivox = 0; ivox < nvoxs; ivox += 1) {
avg[ivox] /= nvals;
}
return avg;
}
int SUMA_ShortizeDset(THD_3dim_dataset **dsetp, float thisfac) {
static char FuncName[]={"SUMA_ShortizeDset"};
char sprefix[THD_MAX_PREFIX+10];
int i, j;
byte *bb=NULL;
short *sb=NULL;
float bbf=0.0;
THD_3dim_dataset *cpset=NULL, *dset=*dsetp;
SUMA_ENTRY;
if (!dset) {
SUMA_S_Err("NULL *dsetp at input!");
SUMA_RETURN(0);
}
sprintf(sprefix, "%s.s", dset->dblk->diskptr->prefix);
NEW_SHORTY(dset, DSET_NVALS(dset), "ss.cp", cpset);
for (i=0; i<DSET_NVALS(dset); ++i) {
if (DSET_BRICK_TYPE(dset,i) == MRI_byte) {
bb = (byte *)DSET_ARRAY(dset,i);
sb = (short *)DSET_ARRAY(cpset,i);
if (thisfac <= 0.0) {
for (j=0; j<DSET_NVOX(dset); ++j) {
sb[j] = (short)bb[j];
}
thisfac = DSET_BRICK_FACTOR(dset,i);
} else {
bbf = DSET_BRICK_FACTOR(dset,i); if (bbf == 0.0f) bbf = 1.0;
bbf = bbf/thisfac;
for (j=0; j<DSET_NVOX(dset); ++j) {
sb[j] = SHORTIZE((((float)bb[j])*bbf));
}
}
EDIT_BRICK_FACTOR( cpset,i,thisfac ) ;
} else {
EDIT_substscale_brick(cpset, i, DSET_BRICK_TYPE(dset,i),
DSET_ARRAY(dset,i), MRI_short, thisfac);
if (DSET_BRICK_TYPE(dset,i) != MRI_short) {
DSET_FREE_ARRAY(dset, i);
} else {
DSET_NULL_ARRAY(dset, i);
}
}
}
/* preserve tables, if any */
THD_copy_labeltable_atr( cpset->dblk, dset->dblk);
DSET_delete(dset); dset = NULL;
*dsetp=cpset;
SUMA_RETURN(1);
}
int main( int argc , char *argv[] )
{
THD_3dim_dataset *dset ; int aa,ll ; char *cpt ; float val ;
if( argc < 2 ){
printf("Usage: 3dSatCheck dataset [...]\n"
"\n"
"Prints the 'raw' initial transient (saturation) check\n"
"value for each dataset on the command line. Round this\n"
"number to the nearest integer to get an estimate of\n"
"how many non-saturated time points start a dataset.\n"
) ;
exit(0) ;
}
for( aa=1 ; aa < argc ; aa++ ){
dset = THD_open_dataset( argv[aa] ) ; if( !ISVALID_DSET(dset) ) continue ;
if( DSET_NVALS(dset) < 9 ) continue ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) continue ;
val = THD_saturation_check( dset , NULL , 0,0 ) ;
ll = strlen(argv[aa]) ;
cpt = (ll <= 50) ? argv[aa] : argv[aa]+(ll-50) ;
INFO_message("%-50.50s = %.3f",cpt,val) ;
DSET_delete(dset) ;
}
exit(0) ;
}
MRI_IMAGE * THD_median_brick( THD_3dim_dataset *dset )
{
int nvox , nvals , ii ;
MRI_IMAGE *tsim , *medim ;
float *medar ;
float *tsar ; /* 05 Nov 2001 */
ENTRY("THD_median_brick") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ;
if( !DSET_LOADED(dset) ) RETURN(NULL) ;
nvals = DSET_NVALS(dset) ;
tsim = DSET_BRICK(dset,0) ;
if( nvals == 1 ){
medim = mri_scale_to_float( DSET_BRICK_FACTOR(dset,0), tsim ) ;
RETURN(medim) ;
}
medim = mri_new_conforming( tsim , MRI_float ) ;
medar = MRI_FLOAT_PTR(medim) ;
nvox = DSET_NVOX(dset) ;
tsar = (float *) calloc( sizeof(float),nvals+1 ) ; /* 05 Nov 2001 */
for( ii=0 ; ii < nvox ; ii++ ){
THD_extract_array( ii , dset , 0 , tsar ) ; /* 05 Nov 2001 */
medar[ii] = qmed_float( nvals , tsar ) ;
}
free(tsar) ; RETURN(medim) ;
}
/*
* for each input dataset name
* open (check dims, etc.)
* dilate (zeropad, make binary, dilate, unpad, apply)
* fill list of bytemask datasets
*
* also, count total volumes
*/
int process_input_dsets(param_t * params)
{
THD_3dim_dataset * dset, * dfirst=NULL;
int iset, nxyz;
ENTRY("process_input_dsets");
if( !params ) ERROR_exit("NULL inputs to PID");
if( params->ndsets <= 0 ) {
ERROR_message("process_input_dsets: no input datasets");
RETURN(1);
}
/* allocate space for dsets array */
params->dsets = (THD_3dim_dataset **)malloc(params->ndsets*
sizeof(THD_3dim_dataset*));
if( !params->dsets ) ERROR_exit("failed to allocate dset pointers");
if( params->verb ) INFO_message("processing %d input datasets...",
params->ndsets);
/* warn user of dilations */
if(params->verb && params->ndsets) {
int pad = needed_padding(¶ms->IND);
INFO_message("padding all datasets by %d (for dilations)", pad);
}
/* process the datasets */
nxyz = 0;
for( iset=0; iset < params->ndsets; iset++ ) {
/* open and verify dataset */
dset = THD_open_dataset(params->inputs[iset]);
if( !dset ) ERROR_exit("failed to open mask dataset '%s'",
params->inputs[iset]);
DSET_load(dset); CHECK_LOAD_ERROR(dset);
if( params->verb>1 ) INFO_message("loaded dset %s, with %d volumes",
DSET_PREFIX(dset), DSET_NVALS(dset));
if( nxyz == 0 ) { /* make an empty copy of the first dataset */
nxyz = DSET_NVOX(dset);
dfirst = EDIT_empty_copy(dset);
}
/* check for consistency in voxels and grid */
if( DSET_NVOX(dset) != nxyz ) ERROR_exit("nvoxel mis-match");
if( ! EQUIV_GRIDS(dset, dfirst) )
WARNING_message("grid from dset %s does not match that of dset %s",
DSET_PREFIX(dset), DSET_PREFIX(dfirst));
/* apply dilations to all volumes, returning bytemask datasets */
params->dsets[iset] = apply_dilations(dset, ¶ms->IND,1,params->verb);
if( ! params->dsets[iset] ) RETURN(1);
}
DSET_delete(dfirst); /* and nuke */
RETURN(0);
}
MRI_IMAGE * THD_rms_brick( THD_3dim_dataset *dset )
{
int nvox , nvals , ii , jj ;
MRI_IMAGE *tsim , *medim ;
float *medar , sum,fac ;
float *tsar ;
ENTRY("THD_rms_brick") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ;
if( !DSET_LOADED(dset) ) RETURN(NULL) ;
nvals = DSET_NVALS(dset) ; fac = 1.0 / nvals ;
tsim = DSET_BRICK(dset,0) ;
if( nvals == 1 ){
medim = mri_scale_to_float( DSET_BRICK_FACTOR(dset,0), tsim ) ;
RETURN(medim) ;
}
medim = mri_new_conforming( tsim , MRI_float ) ;
medar = MRI_FLOAT_PTR(medim) ;
nvox = DSET_NVOX(dset) ;
tsar = (float *) calloc( sizeof(float),nvals+1 ) ;
for( ii=0 ; ii < nvox ; ii++ ){
THD_extract_array( ii , dset , 0 , tsar ) ;
for( sum=0.0,jj=0 ; jj < nvals ; jj++ ) sum += tsar[jj]*tsar[jj] ;
medar[ii] = sqrtf(fac * sum) ;
}
free(tsar) ; RETURN(medim) ;
}
/* just make sure we have sufficient data for computations */
int check_dims(options_t * opts)
{
int nt, nvox, nmask;
ENTRY("check_dims");
nt = DSET_NVALS(opts->inset);
nvox = DSET_NVOX(opts->inset);
if( opts->mask ) nmask = THD_countmask( nvox, opts->mask );
else nmask = nvox;
/* make sure we have something to compute */
if( nvox < 1 ) {
ERROR_message("input dataset must have at least 1 voxel");
RETURN(1);
} else if( nmask < 1 ) {
ERROR_message("input mask must have at least 1 voxel");
RETURN(1);
} else if( nt < 2 ) {
ERROR_message("input dataset must have at least 2 time points");
RETURN(1);
}
RETURN(0);
}
MRI_IMARR * THD_medmad_bricks( THD_3dim_dataset *dset )
{
int nvox , nvals , ii ;
MRI_IMAGE *tsim , *madim, *medim ;
float *madar, *medar ;
MRI_IMARR *imar ;
float *tsar ;
ENTRY("THD_medmad_bricks") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
nvals = DSET_NVALS(dset) ; if( nvals == 1 ) RETURN(NULL) ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
tsim = DSET_BRICK(dset,0) ;
madim = mri_new_conforming( tsim , MRI_float ) ;
madar = MRI_FLOAT_PTR(madim) ;
medim = mri_new_conforming( tsim , MRI_float ) ;
medar = MRI_FLOAT_PTR(medim) ;
nvox = DSET_NVOX(dset) ;
tsar = (float *) calloc( sizeof(float),nvals+1 ) ;
for( ii=0 ; ii < nvox ; ii++ ){
THD_extract_array( ii , dset , 0 , tsar ) ;
qmedmad_float( nvals , tsar , medar+ii , madar+ii ) ;
}
free(tsar) ;
INIT_IMARR(imar) ; ADDTO_IMARR(imar,medim) ; ADDTO_IMARR(imar,madim) ;
RETURN(imar) ;
}
void THD_vectim_indexed_to_dset( MRI_vectim *mrv, int nlist, int *ilist,
THD_3dim_dataset *dset )
{
int nvals , nvec , jj,kk ;
float *tar , *var ;
ENTRY("THD_vectim_indexed_to_dset") ;
if( mrv == NULL || !ISVALID_DSET(dset) ||
nlist <= 0 || ilist == NULL || nlist > DSET_NVALS(dset) ){
ERROR_message("THD_vectim_indexed_to_dset: illegal inputs (nlist=%d)",nlist) ;
EXRETURN ;
}
nvec = mrv->nvec ;
nvals = mrv->nvals ;
for( kk=0 ; kk < nlist ; kk++ ){
if( ilist[kk] < 0 || ilist[kk] >= nvals ){
ERROR_message("THD_vectim_indexed_to_dset: illegal ilist[%d]=%d",kk,ilist[kk]) ;
EXRETURN ;
}
}
tar = (float *)malloc(sizeof(float)*nlist) ;
for( kk=0 ; kk < nvec ; kk++ ){
var = VECTIM_PTR(mrv,kk) ;
for( jj=0 ; jj < nlist ; jj++ ) tar[jj] = var[ilist[jj]] ;
THD_insert_series( mrv->ivec[kk] , dset ,
nlist , MRI_float , tar , 0 ) ;
}
free(tar) ; EXRETURN ;
}
void THD_vectim_to_dset( MRI_vectim *mrv , THD_3dim_dataset *dset )
{
int nvals , nvec , kk , ign ;
ENTRY("THD_vectim_to_dset") ;
if( mrv == NULL || !ISVALID_DSET(dset) ) EXRETURN ;
if( mrv->nvals + mrv->ignore != DSET_NVALS(dset) ) EXRETURN ;
nvec = mrv->nvec ;
nvals = mrv->nvals ;
ign = mrv->ignore ;
if( ign == 0 ){
for( kk=0 ; kk < nvec ; kk++ )
THD_insert_series( mrv->ivec[kk] , dset ,
nvals , MRI_float , VECTIM_PTR(mrv,kk) , 0 ) ;
} else {
float *var ;
#pragma omp critical (MALLOC)
var = (float *)malloc(sizeof(float)*(nvals+ign)) ;
for( kk=0 ; kk < nvec ; kk++ ){
(void)THD_extract_array( mrv->ivec[kk] , dset , 0 , var ) ;
AAmemcpy( var+ign , VECTIM_PTR(mrv,kk) , sizeof(float)*nvals ) ;
THD_insert_series( mrv->ivec[kk] , dset ,
nvals , MRI_float , var , 0 ) ;
}
}
EXRETURN ;
}
void THD_vectim_to_dset_indexed( MRI_vectim *mrv ,
THD_3dim_dataset *dset , int *tlist )
{
int nvals , nvec , jj,kk , tmax=0 ;
float *tar , *var ;
ENTRY("THD_vectim_to_dset_indexed") ;
if( mrv == NULL || !ISVALID_DSET(dset) || tlist == NULL ) EXRETURN ;
nvec = mrv->nvec ;
nvals = mrv->nvals ;
for( kk=0 ; kk < nvals ; kk++ ){
if( tlist[kk] < 0 ) EXRETURN ;
if( tlist[kk] > tmax ) tmax = tlist[kk] ;
}
tmax++ ; if( DSET_NVALS(dset) < tmax ) EXRETURN ;
tar = (float *)malloc(sizeof(float)*tmax) ;
for( kk=0 ; kk < nvec ; kk++ ){
var = VECTIM_PTR(mrv,kk) ;
for( jj=0 ; jj < tmax ; jj++ ) tar[jj] = 0.0f ;
for( jj=0 ; jj < nvals ; jj++ ) tar[tlist[jj]] = var[jj] ;
THD_insert_series( mrv->ivec[kk] , dset ,
tmax , MRI_float , tar , 0 ) ;
}
free(tar) ; EXRETURN ;
}
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);
}
int main( int argc , char * argv[] )
{
THD_3dim_dataset * dset ;
int iarg , all = 0, verbose = 0, cnt = 0;
if( argc < 2 || strncmp(argv[1],"-help",4) == 0 ) Syntax() ;
iarg = 1 ;
cnt = 1;
while (cnt < argc) {
if( strncmp(argv[iarg],"-all",4) == 0 ){ all = 1 ; iarg++ ; }
else if( strncmp(argv[iarg],"-verbose",5) == 0 ){ verbose = 1 ; iarg++ ; }
++cnt;
}
for( ; iarg < argc ; iarg++ ){
dset = THD_open_dataset( argv[iarg] ) ;
if( dset == NULL ){
printf("-1\n") ;
continue ;
}
if (!all) {
if (verbose) {
printf("%s: %d\n",
DSET_HEADNAME(dset),
DSET_NVALS(dset)) ;
} else {
printf("%d\n",DSET_NVALS(dset)) ;
}
} else {
if (verbose) {
printf("%s: %d %d %d %d\n",
DSET_HEADNAME(dset),
DSET_NX(dset), DSET_NY(dset), DSET_NZ(dset),
DSET_NVALS(dset)) ;
} else {
printf("%d %d %d %d\n",
DSET_NX(dset), DSET_NY(dset), DSET_NZ(dset),
DSET_NVALS(dset)) ;
}
}
THD_delete_3dim_dataset( dset , False ) ;
}
exit(0) ;
}
int is_integral_dset ( THD_3dim_dataset *dset, int check_values)
{
int i=0;
if( !ISVALID_DSET(dset) ) return(0);
for (i=0; i<DSET_NVALS(dset); ++i) {
if (!is_integral_sub_brick(dset, i, check_values)) return(0);
}
return(1);
}
// use Ndim to set number of dimensions to check: 3 or 4
int CompareSetDims(THD_3dim_dataset *A, THD_3dim_dataset *B, int Ndim)
{
int DimA[4] = {0,0,0,0}, DimB[4] = {0,0,0,0};
int i;
if ( Ndim > 4)
ERROR_exit("Bad call to CompareSetDims-- overtime!");
DimA[0] = DSET_NX(A); DimA[1] = DSET_NY(A);
DimA[2] = DSET_NZ(A); DimA[3] = DSET_NVALS(A);
DimB[0] = DSET_NX(B); DimB[1] = DSET_NY(B);
DimB[2] = DSET_NZ(B); DimB[3] = DSET_NVALS(B);
for ( i=0 ; i<Ndim ; i++)
if ( DimA[i] != DimA[i] )
ERROR_exit("Bad dimensional matching of inputs: '%s' and '%s'!",
DSET_PREFIXSTR(A), DSET_PREFIXSTR(B));
return 0;
}
THD_3dim_dataset * THD_despike9_dataset( THD_3dim_dataset *inset , byte *mask )
{
THD_3dim_dataset *outset ;
MRI_vectim *mrv ;
int ii ;
ENTRY("THD_despike9_dataset") ;
if( !ISVALID_DSET(inset) || DSET_NVALS(inset) < 9 ) RETURN(NULL) ;
mrv = THD_dset_to_vectim(inset,mask,0) ; DSET_unload(inset) ;
if( mrv == NULL ) RETURN(NULL) ;
(void)THD_vectim_despike9(mrv) ;
outset = EDIT_empty_copy(inset) ;
for( ii=0 ; ii < DSET_NVALS(outset) ; ii++ )
EDIT_substitute_brick(outset,ii,MRI_float,NULL) ;
THD_vectim_to_dset(mrv,outset) ; VECTIM_destroy(mrv) ;
RETURN(outset) ;
}
float THD_get_float_value( int ind , int ival , THD_3dim_dataset *dset )
{
MRI_TYPE typ ; float val=0.0f ;
if( ind < 0 || ival < 0 || !ISVALID_DSET(dset) ||
ival >= DSET_NVALS(dset) || ind >= DSET_NVOX(dset) ) return val ;
typ = DSET_BRICK_TYPE(dset,ival) ; /* raw data type */
switch( typ ){
default: /* don't know what to do --> return nada */
return(-1);
break ;
case MRI_byte:{
byte *bar ;
bar = (byte *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) val = (float)bar[ind] ;
}
break ;
case MRI_short:{
short *bar ;
bar = (short *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) val = (float)bar[ind] ;
}
break ;
case MRI_float:{
float *bar ;
bar = (float *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) val = bar[ind] ;
}
break ;
case MRI_complex:{
complex *bar ;
bar = (complex *) DSET_ARRAY(dset,ival) ;
if( bar != NULL ) val = CABS(bar[ind]) ;
}
break ;
}
if( DSET_BRICK_FACTOR(dset,ival) > 0.0f )
val *= DSET_BRICK_FACTOR(dset,ival) ;
return val ;
}
int THD_voxel_is_constant( int ind , THD_3dim_dataset *dset )
{
float *far ; int ii,nvox,nvals ;
if( !ISVALID_DSET(dset) ) return 1 ;
if( ind < 0 || ind >= DSET_NVOX(dset) ) return 1 ;
nvals = DSET_NVALS(dset) ; if( nvals == 1 ) return 1 ;
far = (float *)malloc(sizeof(float)*nvals) ; NULL_CHECK(far) ;
ii = THD_extract_array( ind , dset , 0 , far ) ;
if( ii < 0 ){ free(far); return 1; }
for( ii=1 ; ii < nvals && far[ii]==far[0]; ii++ ) ; /*nada*/
free(far) ; return (ii==nvals) ;
}
/*
Return the sub-brick indices referenced in str
This is a new version of MCW_get_intlist, which allows
the use of sub-brick labels
See is_in_labels for details.
ZSS Dec 09
*/
int * MCW_get_thd_intlist( THD_3dim_dataset *dset , char *str )
{
/* test for brick_lab is not needed, and breaks sub-brick selection
of NIfTI datasets 6 Jan 2009 [rickr]
return( (dset && dset->dblk && dset->dblk->brick_lab) ?
MCW_get_labels_intlist (dset->dblk->brick_lab,
DSET_NVALS(dset), str) : NULL );
*/
if( !dset || !dset->dblk ) return NULL;
return MCW_get_labels_intlist(dset->dblk->brick_lab, DSET_NVALS(dset), str);
}
THD_3dim_dataset * process_dataset ()
{
THD_3dim_dataset * new_dset = NULL; /* output bucket dataset */
int ibrick, nbricks; /* sub-brick indices */
int statcode; /* type of stat. sub-brick */
ENTRY("process_dataset") ;
/*----- Make full copy of input dataset -----*/
new_dset = EDIT_full_copy(FDR_dset, FDR_output_prefix);
/*----- Record history of dataset -----*/
tross_Copy_History( FDR_dset , new_dset ) ;
if( commandline != NULL )
{
tross_Append_History ( new_dset, commandline);
free(commandline) ;
}
/*----- Deallocate memory for input dataset -----*/
THD_delete_3dim_dataset (FDR_dset , False ); FDR_dset = NULL ;
/*----- Loop over sub-bricks in the dataset -----*/
nbricks = DSET_NVALS(new_dset);
STATUS("start loop over bricks") ;
for (ibrick = 0; ibrick < nbricks; ibrick++)
{
statcode = DSET_BRICK_STATCODE(new_dset, ibrick);
if (FUNC_IS_STAT(statcode) || FDR_force )
{
/*----- Process the statistical sub-bricks -----*/
if (!FDR_quiet)
printf ("ibrick = %3d statcode = %5s \n",
ibrick, FUNC_prefixstr[MAX(statcode,0)]);
process_subbrick (new_dset, ibrick);
}
}
RETURN(new_dset);
}
int64_t THD_vectim_size( THD_3dim_dataset *dset , byte *mask )
{
int nvals , nvox , nmask ;
int64_t sz ;
ENTRY("THD_vectim_size") ;
if( !ISVALID_DSET(dset) ) RETURN(0) ;
nvals = DSET_NVALS(dset) ;
nvox = DSET_NVOX(dset) ;
if( mask != NULL ) nmask = THD_countmask( nvox , mask ) ;
else nmask = DSET_NVOX(dset) ;
sz = ((int64_t)nmask) * ( ((int64_t)nvals) * sizeof(float) + sizeof(int) ) ;
RETURN(sz) ;
}
int is_integral_sub_brick ( THD_3dim_dataset *dset, int isb, int check_values)
{
float mfac = 0.0;
void *vv=NULL;
if( !ISVALID_DSET(dset) ||
isb < 0 ||
isb >= DSET_NVALS(dset) ) {
fprintf(stderr,"** Bad dset or sub-brick index.\n");
return (0) ;
}
if( !DSET_LOADED(dset) ) DSET_load(dset);
switch( DSET_BRICK_TYPE(dset,isb) ){
case MRI_short:
case MRI_byte:
if (check_values) {
mfac = DSET_BRICK_FACTOR(dset,isb) ;
if (mfac != 0.0f && mfac != 1.0f) return(0);
}
break;
case MRI_double:
case MRI_complex:
case MRI_float:
vv = (void *)DSET_ARRAY(dset,isb);
mfac = DSET_BRICK_FACTOR(dset,isb) ;
if (mfac != 0.0f && mfac != 1.0f) return(0);
if (!vv) {
fprintf(stderr,"** NULL array!\n");
return(0);
}
return(is_integral_data(DSET_NVOX(dset),
DSET_BRICK_TYPE(dset,isb),
DSET_ARRAY(dset,isb) ) );
break;
default:
return(0);
}
return(1);
}
MRI_vectim * THD_dset_to_vectim_byslice( THD_3dim_dataset *dset, byte *mask ,
int ignore , int kzbot , int kztop )
{
byte *mmm ;
MRI_vectim *mrv=NULL ;
int kk,iv , nvals , nvox , nmask , nxy , nz ;
ENTRY("THD_dset_to_vectim_byslice") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
nvals = DSET_NVALS(dset) ; if( nvals <= 0 ) RETURN(NULL) ;
nvox = DSET_NVOX(dset) ;
nxy = DSET_NX(dset) * DSET_NY(dset) ; nz = DSET_NZ(dset) ;
if( kzbot < 0 ) kzbot = 0 ;
if( kztop >= nz ) kztop = nz-1 ;
if( kztop < kzbot ) RETURN(NULL) ;
if( kzbot == 0 && kztop == nz-1 ){
mrv = THD_dset_to_vectim( dset , mask, ignore ) ; RETURN(mrv) ;
}
/* make a mask that includes cutting out un-desirable slices */
{ int ibot , itop , ii ;
#pragma omp critical (MALLOC)
mmm = (byte *)malloc(sizeof(byte)*nvox) ;
if( mask == NULL ) AAmemset( mmm , 1 , sizeof(byte)*nvox ) ;
else AAmemcpy( mmm , mask , sizeof(byte)*nvox ) ;
if( kzbot > 0 )
AAmemset( mmm , 0 , sizeof(byte)*kzbot *nxy ) ;
if( kztop < nz-1 )
AAmemset( mmm+(kztop+1)*nxy , 0 , sizeof(byte)*(nz-1-kztop)*nxy ) ;
}
/* and make the vectim using the standard function */
mrv = THD_dset_to_vectim( dset , mmm , ignore ) ;
free(mmm) ;
RETURN(mrv) ;
}
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 ;
}
MRI_IMAGE * THD_dset_to_1Dmri( THD_3dim_dataset *dset )
{
MRI_IMAGE *im ; float *far ;
int nx , ny , ii ;
ENTRY("THD_dset_to_1D") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ;
if( !DSET_LOADED(dset) ) RETURN(NULL) ;
nx = DSET_NVALS(dset) ;
ny = DSET_NVOX(dset) ;
im = mri_new( nx , ny , MRI_float ) ; far = MRI_FLOAT_PTR(im) ;
for( ii=0 ; ii < ny ; ii++ )
THD_extract_array( ii , dset , 0 , far + ii*nx ) ;
RETURN(im) ;
}
void THD_extract_detrended_array( THD_3dim_dataset *dset ,
int nref, float **ref, MRI_IMARR *imar,
int ii, int scl, float *far )
{
int tt , nval , qq ;
float val , **fitar , *var ;
MRI_IMAGE *qim ;
ENTRY("THD_extract_detrended_array") ;
if( !ISVALID_DSET(dset) ||
nref < 1 || ref == NULL ||
imar == NULL || IMARR_COUNT(imar) < nref+1 ||
ii < 0 || ii >= DSET_NVOX(dset) || far == NULL ) EXRETURN ;
qq = THD_extract_array( ii , dset , 0 , far ) ; /* get data */
if( qq < 0 ) EXRETURN ;
nval = DSET_NVALS(dset) ;
fitar = (float **)malloc(sizeof(float *)*nref) ;
for( qq=0 ; qq < nref ; qq++ ){
qim = IMARR_SUBIM(imar,qq) ; fitar[qq] = MRI_FLOAT_PTR(qim) ;
}
qim = IMARR_SUBIM(imar,nref) ; var = MRI_FLOAT_PTR(qim) ;
for( tt=0 ; tt < nval ; tt++ ){ /* get residuals */
val = far[tt] ;
for( qq=0 ; qq < nref ; qq++ ) val -= ref[qq][tt] * fitar[qq][ii] ;
far[tt] = val ;
}
if( scl && var[ii] > 0.0f ){
val = 1.0f / var[ii] ;
for( tt=0 ; tt < nval ; tt++ ) far[tt] *= val ;
}
/* ZSS: Need to free fitar */
free(fitar); fitar=NULL;
EXRETURN ;
}
THD_3dim_dataset * THD_detrend_dataset( THD_3dim_dataset *dset ,
int nref , float **ref ,
int meth , int scl ,
byte *mask , MRI_IMARR **imar )
{
MRI_IMARR *qmar ;
int ii,jj,kk , nvals,nvox , iv ;
float *var ;
THD_3dim_dataset *newset ;
ENTRY("THD_detrend_dataset") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
nvals = DSET_NVALS(dset) ; nvox = DSET_NVOX(dset) ;
qmar = THD_time_fit_dataset( dset , nref,ref , meth , mask ) ;
if( qmar == NULL ) RETURN(NULL) ;
newset = EDIT_empty_copy(dset) ;
for( iv=0 ; iv < nvals ; iv++ ){
EDIT_substitute_brick( newset , iv , MRI_float , NULL ) ;
EDIT_BRICK_FACTOR( newset , iv , 0.0f ) ; /* 04 Jun 2007 */
}
var = (float *)malloc(sizeof(float)*nvals) ;
for( ii=0 ; ii < nvox ; ii++ ){
if( mask == NULL || mask[ii] )
THD_extract_detrended_array( dset , nref,ref , qmar , ii,scl , var ) ;
else
memset(var,0,sizeof(float)*nvals) ;
THD_insert_series( ii , newset , nvals , MRI_float , var , 0 ) ;
}
free(var) ;
if( imar != NULL ) *imar = qmar ;
else DESTROY_IMARR(qmar) ;
RETURN(newset) ;
}
