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) ;
}
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) ;
}
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) ;
}
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 ;
}
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) ;
}
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 ;
}
MRI_IMAGE * THD_extract_series( int ind , THD_3dim_dataset *dset , int raw )
{
int nv , typ , ii ;
MRI_IMAGE *im ;
void *imar ;
ENTRY("THD_extract_series") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
nv = dset->dblk->nvals ;
if( raw ) typ = DSET_BRICK_TYPE(dset,0) ; /* type of output array */
else typ = MRI_float ;
im = mri_new( nv , 1 , typ ) ; /* output image */
imar = mri_data_pointer(im) ;
ii = THD_extract_array( ind , dset , raw , imar ) ; /* get data */
if( ii != 0 ){ mri_free(im) ; RETURN(NULL) ; } /* bad */
if( dset->taxis != NULL ){ /* 21 Oct 1996 */
float zz , tt ;
int kz = ind / ( dset->daxes->nxx * dset->daxes->nyy ) ;
zz = dset->daxes->zzorg + kz * dset->daxes->zzdel ;
tt = THD_timeof( 0 , zz , dset->taxis ) ;
im->xo = tt ; im->dx = dset->taxis->ttdel ; /* origin and delta */
if( dset->taxis->units_type == UNITS_MSEC_TYPE ){ /* convert to sec */
im->xo *= 0.001 ; im->dx *= 0.001 ;
}
} else {
im->xo = 0.0 ; im->dx = 1.0 ; /* 08 Nov 1996 */
}
RETURN(im) ;
}
int THD_retrend_dataset( THD_3dim_dataset *dset ,
int nref , float **ref ,
int scl , byte *mask , MRI_IMARR *imar )
{
int ii,qq,tt , nvals,nvox ;
MRI_IMAGE *qim ; float **fitar , *far , fac , *var , val ;
ENTRY("THD_retrend_dataset") ;
if( !ISVALID_DSET(dset) ||
nref < 1 || ref == NULL ||
imar == NULL || IMARR_COUNT(imar) <= nref ) RETURN(0) ;
nvals = DSET_NVALS(dset) ; nvox = DSET_NVOX(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) ;
far = (float *)malloc(sizeof(float)*nvals) ;
for( ii=0 ; ii < nvox ; ii++ ){
if( mask != NULL && !mask[ii] ) continue ;
qq = THD_extract_array( ii , dset , 0 , far ) ; /* get data */
if( qq < 0 ) continue ;
fac = (scl) ? var[ii] : 1.0f ;
for( tt=0 ; tt < nvals ; tt++ ){ /* add fit back in */
val = far[tt] * fac ;
for( qq=0 ; qq < nref ; qq++ ) val += ref[qq][tt] * fitar[qq][ii] ;
far[tt] = val ;
}
THD_insert_series( ii , dset , nvals , MRI_float , far , 0 ) ;
}
free(far) ; free(fitar) ; RETURN(1) ;
}
MRI_IMARR * THD_time_fit_dataset( THD_3dim_dataset *dset ,
int nref , float **ref , int meth , byte *mask )
{
int ii , nvox,nval , qq,tt ;
float *far , *fit , *var , val ;
MRI_IMARR *imar ; MRI_IMAGE *qim ; float **fitar ;
ENTRY("THD_time_fit_dataset") ;
if( !ISVALID_DSET(dset) ||
nref < 1 || nref >= DSET_NVALS(dset) || ref == NULL ) RETURN(NULL) ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
/* construct output images */
INIT_IMARR(imar) ;
fitar = (float **)malloc(sizeof(float *)*nref) ;
for( qq=0 ; qq < nref ; qq++ ){
qim = mri_new_conforming( DSET_BRICK(dset,0) , MRI_float ) ;
fitar[qq] = MRI_FLOAT_PTR(qim) ;
ADDTO_IMARR(imar,qim) ;
}
qim = mri_new_conforming( DSET_BRICK(dset,0) , MRI_float ) ;
var = MRI_FLOAT_PTR(qim) ; ADDTO_IMARR(imar,qim) ;
nvox = DSET_NVOX(dset) ; nval = DSET_NVALS(dset) ;
far = (float *)malloc(sizeof(float)*nval) ;
fit = (float *)malloc(sizeof(float)*nref) ;
for( ii=0 ; ii < nvox ; ii++ ){
if( !INMASK(ii) ) continue ;
qq = THD_extract_array( ii , dset , 0 , far ) ; /* get data */
if( qq == 0 ){
switch(meth){ /* get fit */
default:
case 2: THD_generic_detrend_LSQ( nval, far, -1, nref,ref, fit ); break;
case 1: THD_generic_detrend_L1 ( nval, far, -1, nref,ref, fit ); break;
}
for( qq=0 ; qq < nref ; qq++ ) fitar[qq][ii] = fit[qq] ; /* save fit */
/* at this point, far[] contains the residuals */
switch(meth){ /* get stdev or MAD */
default:
case 2:{
float mm,vv ;
for( mm=0.0,tt=0 ; tt < nval ; tt++ ) mm += far[tt] ;
mm /= nval ;
for( vv=0.0,tt=0 ; tt < nval ; tt++ ) vv += (far[tt]-mm)*(far[tt]-mm) ;
var[ii] = sqrtf( vv/(nval-1.0) ) ;
}
break ;
case 1:{
for( tt=0 ; tt < nval ; tt++ ) far[tt] = fabsf(far[tt]) ;
var[ii] = qmed_float( nval , far ) ;
}
break ;
}
}
}
free(fit); free(far); free(fitar); RETURN(imar);
}
/*!
Put some help like for function thd_polyfit
*/
int thd_Acluster ( THD_3dim_dataset *in_set,
byte *mask, int nmask,
THD_3dim_dataset **clust_set,
THD_3dim_dataset **dist_set,
OPT_KMEANS oc )
{
int ii, nl, nc;
double **D=NULL, **distmatrix=NULL; /* this double business is a waste of
memory, at least for D..*/
int ncol = -1;
float *dvec=NULL;
int* clusterid = NULL;
short *sc = NULL;
ENTRY("thd_Acluster");
if (!clust_set || *clust_set) {
fprintf(stderr,
"ERROR: output volume pointer pointers must point to NULL\n");
RETURN(0);
}
if (!mask) nmask = DSET_NVOX(in_set);
ncol = DSET_NVALS(in_set);
if (ncol < DSET_NUM_TIMES(in_set)) ncol = DSET_NUM_TIMES(in_set);
if (oc.verb) {
ININFO_message("Have %d/%d voxels to process "
"with %d dimensions per voxel.\n",
nmask, DSET_NVOX(in_set), ncol);
}
/* Create data matrix */
D = (double **)calloc(sizeof(double*), nmask);
for (ii=0;ii<(nmask);++ii) {
if (!(D[ii] = (double *)calloc(sizeof(double), ncol))) {
fprintf(stderr,"ERROR: Failed while allocating %dx%d double matrix\n",
nmask, ncol);
RETURN(0);
}
}
dvec = (float * )malloc(sizeof(float)*ncol) ; /* array to hold series */
if (oc.verb) {
ININFO_message("Filling D(%dx%d) (mask=%p).\n", nmask, ncol, mask);
}
ii = 0;
for (nl=0; nl<DSET_NVOX(in_set); ++nl) {
if (!mask || mask[nl]) {
THD_extract_array( nl , in_set , 0 , dvec ) ;
for (nc=0; nc<ncol; ++nc) D[ii][nc] = dvec[nc];
++ii;
}
}
/* allocate for answer arrays */
if (!(clusterid = (int *)calloc(sizeof(int), nmask))) {
fprintf(stderr,"ERROR: Failed to allocate for clusterid\n");
RETURN(0);
}
/* now do the clustering
(ANDREJ: I do not know why the counting skipped 1st row and 1st col....) */
if (oc.k > 0) {
if (oc.verb) {
ININFO_message("Going to cluster: k=%d, r=%d\n"
"distmetric %c, jobname %s\n",
oc.k, oc.r, oc.distmetric, oc.jobname);
}
example_kmeans( nmask, ncol, D,
oc.k, oc.r, oc.distmetric,
oc.jobname, clusterid);
} else if (oc.kh > 0) {
if (oc.verb) {
ININFO_message("Going to h cluster: kh=%d\n"
"jobname %s\n",
oc.kh, oc.jobname);
}
if ((distmatrix = example_distance_gene(nmask, ncol, D))) {
example_hierarchical( nmask, ncol, D,
oc.jobname, oc.kh,
distmatrix,
clusterid);
/* YOU SHOULD FREE distmatrix here ...*/
} else {
ERROR_message("Failed to create distmatrix");
RETURN(0);
}
} else {
ERROR_message("Bad option selection");
RETURN(0);
}
/* create output datasets, if required*/
*clust_set = EDIT_empty_copy(in_set) ;
EDIT_dset_items( *clust_set ,
ADN_nvals , 1 ,
ADN_ntt , 1 ,
ADN_datum_all , MRI_short ,
ADN_brick_fac , NULL ,
ADN_prefix , "OML!" ,
ADN_none ) ;
/* MRI_float */
if (oc.verb) {
ININFO_message("loading results into %s\n",
DSET_PREFIX(*clust_set));
}
/* transfer ints in clusterid to shorts array */
sc = (short *)calloc(sizeof(short),DSET_NVOX(in_set));
ii = 0;
for (nl=0; nl<DSET_NVOX(in_set); ++nl) {
if (!mask || mask[nl]) {
sc[nl] = (short)clusterid[ii]+1;
++ii;
}
}
free(clusterid); clusterid = NULL;
EDIT_substitute_brick( *clust_set , 0 , MRI_short , sc ) ;
sc = NULL; /* array now in brick */
if (oc.verb) {
ININFO_message("Freedom");
}
if (dvec) free(dvec); dvec=NULL;
// To free D
for (ii=0;ii<nmask;++ii) {
if (D[ii]) free(D[ii]);
}
free(D); D = NULL;
RETURN(1);
}
/*!
\brief out_set = thd_polyfit( in_set,
mask, polorder,
prefix, verb);
fits a polynomial model of order polorder to
the time series of voxels in in_set
\param in_set (THD_3dim_dataset* ) An AFNI dset pointer to input data
\param mask (byte *) if mask is not NULL then voxel i will be processed
if mask[i] != 0.
if mask is NULL then all voxels are processed.
\param polorder (int) polynomial order
\param prefix (char *) prefix of output dset
\param verb (int) verbosity flag
\return out_set (THD_3dim_dataset* ) Dset containing polynomial fits.
*/
THD_3dim_dataset *thd_polyfit(THD_3dim_dataset *in_set,
byte *mask, int polorder,
char *prefix, int verb)
{
int i=0, j=0, nl=0, k=0,
posi=0, posj=0, posk=0, nrow=0,
ncol = 0;
double xi=0.0, yi=0.0, yy=0.0, ei=0.0, sumsq=0.0, med=0.0;
gsl_matrix *X=NULL, *cov=NULL;
gsl_vector *y=NULL, *w=NULL, *c=NULL;
MRI_IMAGE *im = NULL;
THD_3dim_dataset *out_set=NULL;
double *dar = NULL;
float *cbuf=NULL;
float *dvec = NULL;
gsl_multifit_linear_workspace *work=NULL;
ENTRY("thd_polyfit");
/* prepare output */
out_set = EDIT_empty_copy(in_set) ;
EDIT_dset_items( out_set ,
ADN_nvals , polorder ,
ADN_ntt , polorder ,
ADN_datum_all , MRI_float ,
ADN_brick_fac , NULL ,
ADN_prefix , prefix ? prefix : "OMG!" ,
ADN_none ) ;
for( j=0 ; j < polorder ; j++ ) /* create empty bricks to be filled below */
EDIT_substitute_brick( out_set , j , MRI_float , NULL ) ;
/* do the fitting */
if (verb) fprintf (stderr,"Now fitting...\n");
ncol = DSET_NVALS(in_set);
nrow = DSET_NVOX(in_set);
X = gsl_matrix_alloc (ncol, polorder);
y = gsl_vector_alloc (ncol);
c = gsl_vector_alloc (polorder);
cov = gsl_matrix_alloc (polorder, polorder);
for (i = 0; i < ncol; i++) {
xi = i+1;
gsl_matrix_set (X, i, 0, 1.0);
gsl_matrix_set (X, i, 1, xi);
gsl_matrix_set (X, i, 2, xi*xi);
gsl_matrix_set (X, i, 3, xi*xi*xi);
gsl_matrix_set (X, i, 4, xi*xi*xi*xi);
// printf ("%lg ",xi);
}
/*make header
printf ("matrvola\n");
ZSS: By adding # to the text line,
I made the output file be a .1D format */
if (verb > 1)
fprintf(stdout, "#%s_0\t%s_1\t%s_2\t%s_3\t%s_4\n",
DSET_PREFIX(in_set),DSET_PREFIX(in_set),
DSET_PREFIX(in_set),DSET_PREFIX(in_set),
DSET_PREFIX(in_set));
// go by lines - signatures
/* pre-allocate, I think this should be just fine,
there should be no need to reinitialize work
all the time */
work = gsl_multifit_linear_alloc (ncol, polorder);
dvec = (float * )malloc(sizeof(float)*ncol) ; /* array to hold signature */
cbuf = (float *)malloc(sizeof(float)*polorder) ;
/* array to hold fit */
for (nl=0; nl<nrow; ++nl) {
if (!mask || mask[nl]) {
posi = -1;
posj = -1;
posk = -1;
THD_extract_array( nl , in_set , 0 , dvec ) ;
/*get signature from voxel */
for (k = 0; k < ncol; k++) {
gsl_vector_set (y, k, dvec[k]);
}
gsl_multifit_linear (X, y, c, cov,
&sumsq, work);
/* printf ( "\n # best fit: Y = %g + %g X + %g X^2 +%g X^3 + %g X^4\n",
C(0), C(1), C(2), C(3), C(4));
printf ("# sumsq = %g\n", sumsq); */
for (i=0;i<polorder;++i) cbuf[i] = (float)C(i);
THD_insert_series( nl , out_set , polorder , MRI_float , cbuf , 1 ) ;
/* stick result in output */
if (verb > 1)
fprintf (stdout, "%11g\t%11g\t%11g\t%11g\t%11g\n",
C(0), C(1), C(2), C(3), C(4));
/*
printf ("# covariance matrix:\n");
printf ("[ %+.5e, %+.5e, %+.5e \n",
COV(0,0), COV(0,1), COV(0,2));
printf (" %+.5e, %+.5e, %+.5e \n",
COV(1,0), COV(1,1), COV(1,2));
printf (" %+.5e, %+.5e, %+.5e ]\n",
COV(2,0), COV(2,1), COV(2,2));
printf ("# chisq = %g\n", chisq);
*/
}
}
gsl_multifit_linear_free (work); work = NULL;
free(dvec); dvec = NULL;
free(cbuf); cbuf = NULL;
gsl_vector_free (y);
gsl_vector_free (c);
gsl_matrix_free (cov);
gsl_matrix_free (X);
//gsl_vector_free (w);
free(dvec); dvec = NULL;
RETURN(out_set);
}
MRI_vectim * THD_2dset_to_vectim( THD_3dim_dataset *dset1, byte *mask1 ,
THD_3dim_dataset *dset2, byte *mask2 ,
int ignore )
{
byte *mmmv[2]={NULL, NULL}, *mmmt=NULL;
THD_3dim_dataset *dsetv[2]={NULL, NULL};
MRI_vectim *mrv=NULL ;
int kk2, kk,iv,id, nvals , nvoxv[2]={0,0} , nmaskv[2]={0,0} ;
int *ivvectmp=NULL;
ENTRY("THD_2dset_to_vectim") ;
mmmv[0] = mask1;
mmmv[1] = mask2;
dsetv[0] = dset1;
dsetv[1] = dset2;
for (id=0; id<2;++id) {
if( !ISVALID_DSET(dsetv[id]) ) RETURN(NULL) ;
DSET_load(dsetv[id]) ; if( !DSET_LOADED(dsetv[id]) ) RETURN(NULL) ;
nvoxv[id] = DSET_NVOX(dsetv[id]) ;
}
if (DSET_NVALS(dsetv[0]) != DSET_NVALS(dsetv[1])) {
RETURN(NULL) ;
}
if( ignore < 0 ) ignore = 0 ;
nvals = DSET_NVALS(dsetv[0]) - ignore ; if( nvals <= 0 ) RETURN(NULL) ;
for (id=0; id<2; ++id) {
if( mmmv[id] != NULL ){
nmaskv[id] = THD_countmask( nvoxv[id] , mmmv[id] ) ;/* number to keep */
if( nmaskv[id] <= 0 ) RETURN(NULL) ;
} else {
nmaskv[id] = nvoxv[id] ; /* keep them all */
#pragma omp critical (MALLOC)
mmmv[id] = (byte *)malloc(sizeof(byte)*nmaskv[id]) ;
if( mmmv[id] == NULL ){
ERROR_message("THD_2dset_to_vectim: out of memory") ;
RETURN(NULL) ;
}
memset( mmmv[id] , 1 , sizeof(byte)*nmaskv[id] ) ;
}
}
#pragma omp critical (MALLOC)
mrv = (MRI_vectim *)malloc(sizeof(MRI_vectim)) ;
mrv->nvec = nmaskv[0]+nmaskv[1] ;
mrv->nvals = nvals ;
mrv->ignore = ignore ;
#pragma omp critical (MALLOC)
mrv->ivec = (int *)malloc(sizeof(int)*(nmaskv[0]+nmaskv[1])) ;
#pragma omp critical (MALLOC)
ivvectmp = (int *)malloc(sizeof(int)*(nmaskv[1])) ;
if( mrv->ivec == NULL || ivvectmp == NULL){
ERROR_message("THD_2dset_to_vectim: out of memory") ;
if (mrv->ivec) free(mrv->ivec) ;
if (ivvectmp) free(ivvectmp) ;
free(mrv) ;
if( mmmv[0] != mask1 ) free(mmmv[0]) ;
if( mmmv[1] != mask2 ) free(mmmv[1]) ;
RETURN(NULL) ;
}
#pragma omp critical (MALLOC)
mrv->fvec = (float *)malloc(sizeof(float)*(nmaskv[0]+nmaskv[1])*(size_t)nvals) ;
if( mrv->fvec == NULL ){
ERROR_message("THD_2dset_to_vectim: out of memory") ;
if (ivvectmp) free(ivvectmp) ;
free(mrv->ivec) ; free(mrv) ;
if( mmmv[0] != mask1 ) free(mmmv[0]) ;
if( mmmv[1] != mask2 ) free(mmmv[1]) ;
RETURN(NULL) ;
}
/* store desired voxel time series */
mmmt = mmmv[0];
for( kk=iv=0 ; iv < nvoxv[0] ; iv++ ){
if( mmmt[iv] ) mrv->ivec[kk++] = iv ; /* build index list to 1st dset */
}
mmmt = mmmv[1]; kk2 = 0;
for( iv=0 ; iv < nvoxv[1] ; iv++ ){
if( mmmt[iv] ) {
mrv->ivec[kk++] = iv + nvoxv[0] ;
/* build index list to 2nd dset*/
ivvectmp[kk2++] = iv;
}
}
if( ignore > 0 ){ /* extract 1 at a time, save what we want */
#pragma omp critical (MALLOC)
float *var = (float *)malloc(sizeof(float)*(nvals+ignore)) ;
mmmt = mmmv[0];
for( kk=iv=0 ; iv < nvoxv[0] ; iv++ ){
if( mmmt[iv] == 0 ) continue ;
(void)THD_extract_array( iv , dsetv[0] , 0 , var ) ;
AAmemcpy( VECTIM_PTR(mrv,kk) , var+ignore , sizeof(float)*nvals ) ;
kk++ ;
}
mmmt = mmmv[1];
for( iv=0 ; iv < nvoxv[1] ; iv++ ){
if( mmmt[iv] == 0 ) continue ;
(void)THD_extract_array( iv , dsetv[1] , 0 , var ) ;
AAmemcpy( VECTIM_PTR(mrv,kk) , var+ignore , sizeof(float)*nvals ) ;
kk++ ;
}
free(var) ;
} else { /* do all at once: this way is a lot faster */
THD_extract_many_arrays( nmaskv[0] , mrv->ivec ,
dsetv[0] , mrv->fvec ) ;
THD_extract_many_arrays( nmaskv[1] , ivvectmp,
dsetv[1] , (mrv->fvec+(size_t)nmaskv[0]*(size_t)mrv->nvals) ) ;
}
mrv->nx = DSET_NX(dsetv[0]) + DSET_NX(dsetv[1]);
mrv->dx = fabs(DSET_DX(dsetv[0])) ;
mrv->ny = DSET_NY(dsetv[0]) ; mrv->dy = fabs(DSET_DY(dsetv[0])) ;
mrv->nz = DSET_NZ(dsetv[0]) ; mrv->dz = fabs(DSET_DZ(dsetv[0])) ;
DSET_UNMSEC(dsetv[0]) ; mrv->dt = DSET_TR(dsetv[0]) ;
if( mrv->dt <= 0.0f ) mrv->dt = 1.0f ;
if( mmmv[0] != mask1 ) free(mmmv[0]) ;
if( mmmv[1] != mask2 ) free(mmmv[1]) ;
if (ivvectmp) free(ivvectmp) ;
if (0) {
int ShowThisTs=38001;
float *fff=NULL;
fprintf(stderr,"++ ZSS mrv->nvec = %d, mrv->nvals = %d\n",
mrv->nvec, mrv->nvals);
for( kk=0 ; kk < mrv->nvals; ++kk) {
fff=mrv->fvec+((size_t)mrv->nvals*(size_t)ShowThisTs);
fprintf(stderr," %f \t", *(fff+kk));
}
}
VECTIM_scan(mrv) ; /* 09 Nov 2010 */
RETURN(mrv) ;
}
MRI_vectim * THD_dset_to_vectim_stend( THD_3dim_dataset *dset, byte *mask , int start, int end )
{
byte *mmm=mask ;
MRI_vectim *mrv=NULL ;
int kk,iv , nvals , nvox , nmask ;
ENTRY("THD_dset_to_vectim_stend") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
if( start < 0 ) start = 0 ;
if( end < start ) end = DSET_NVALS(dset)-1 ;
nvals = end - start + 1 ; if( nvals <= 0 ) RETURN(NULL) ;
nvox = DSET_NVOX(dset) ;
if( mmm != NULL ){
nmask = THD_countmask( nvox , mmm ) ; /* number to keep */
if( nmask <= 0 ) RETURN(NULL) ;
} else {
nmask = nvox ; /* keep them all */
#pragma omp critical (MALLOC)
mmm = (byte *)malloc(sizeof(byte)*nmask) ;
if( mmm == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
RETURN(NULL) ;
}
memset( mmm , 1 , sizeof(byte)*nmask ) ;
}
#pragma omp critical (MALLOC)
mrv = (MRI_vectim *)malloc(sizeof(MRI_vectim)) ;
mrv->nvec = nmask ;
mrv->nvals = nvals ;
mrv->ignore = start ;
#pragma omp critical (MALLOC)
mrv->ivec = (int *)malloc(sizeof(int)*nmask) ;
if( mrv->ivec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
}
#pragma omp critical (MALLOC)
mrv->fvec = (float *)malloc(sizeof(float)*(size_t)nmask*(size_t)nvals) ;
if( mrv->fvec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
free(mrv->ivec) ; free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
}
/* store desired voxel time series */
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] ) mrv->ivec[kk++] = iv ; /* build index list */
}
if( nvals < DSET_NVALS(dset) ){ /* extract 1 at a time, save what we want */
#pragma omp critical (MALLOC)
float *var = (float *)malloc(sizeof(float)*(DSET_NVALS(dset))) ;
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] == 0 ) continue ;
(void)THD_extract_array( iv , dset , 0 , var ) ;
AAmemcpy( VECTIM_PTR(mrv,kk) , var+start , sizeof(float)*nvals ) ;
kk++ ;
}
free(var) ;
} else { /* do all at once: this way is a lot faster */
THD_extract_many_arrays( nmask , mrv->ivec , dset , mrv->fvec ) ;
}
mrv->nx = DSET_NX(dset) ; mrv->dx = fabs(DSET_DX(dset)) ;
mrv->ny = DSET_NY(dset) ; mrv->dy = fabs(DSET_DY(dset)) ;
mrv->nz = DSET_NZ(dset) ; mrv->dz = fabs(DSET_DZ(dset)) ;
DSET_UNMSEC(dset) ; mrv->dt = DSET_TR(dset) ;
if( mrv->dt <= 0.0f ) mrv->dt = 1.0f ;
if( mmm != mask ) free(mmm) ;
VECTIM_scan(mrv) ; /* 09 Nov 2010 */
RETURN(mrv) ;
}
MRI_vectim * THD_dset_to_vectim( THD_3dim_dataset *dset, byte *mask , int ignore )
{
byte *mmm=mask ;
MRI_vectim *mrv=NULL ;
int kk,iv , nvals , nvox , nmask ;
size_t ntot ;
ENTRY("THD_dset_to_vectim") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
if( ignore < 0 ) ignore = 0 ;
nvals = DSET_NVALS(dset) - ignore ; if( nvals <= 0 ) RETURN(NULL) ;
nvox = DSET_NVOX(dset) ;
if( mmm != NULL ){
nmask = THD_countmask( nvox , mmm ) ; /* number to keep */
if( nmask <= 0 ) RETURN(NULL) ;
} else {
nmask = nvox ; /* keep them all */
#pragma omp critical (MALLOC)
mmm = (byte *)malloc(sizeof(byte)*nmask) ;
if( mmm == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
RETURN(NULL) ;
}
memset( mmm , 1 , sizeof(byte)*nmask ) ;
}
#pragma omp critical (MALLOC)
mrv = (MRI_vectim *)malloc(sizeof(MRI_vectim)) ;
mrv->nvec = nmask ;
mrv->nvals = nvals ;
mrv->ignore = ignore ;
#pragma omp critical (MALLOC)
mrv->ivec = (int *)malloc(sizeof(int)*nmask) ;
if( mrv->ivec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
}
ntot = sizeof(float)*(size_t)nmask*(size_t)nvals ;
#pragma omp critical (MALLOC)
mrv->fvec = (float *)malloc(ntot) ;
if( mrv->fvec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory -- tried to get %lld bytes",(long long)ntot) ;
free(mrv->ivec) ; free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
} else if( ntot > 1000000000 ){
INFO_message("THD_dset_to_vectim: allocated %lld bytes",(long long)ntot) ;
}
/* store desired voxel time series */
STATUS("create index list") ;
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] ) mrv->ivec[kk++] = iv ; /* build index list */
}
if( ignore > 0 ){ /* extract 1 at a time, save what we want */
#pragma omp critical (MALLOC)
float *var = (float *)malloc(sizeof(float)*(nvals+ignore)) ;
STATUS("ignore > 0 --> extracting one at a time") ;
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] == 0 ) continue ;
(void)THD_extract_array( iv , dset , 0 , var ) ;
AAmemcpy( VECTIM_PTR(mrv,kk) , var+ignore , sizeof(float)*nvals ) ;
kk++ ;
}
free(var) ;
} else { /* do all at once: this way is a lot faster */
STATUS("ignore==0 --> extracting all at once") ;
THD_extract_many_arrays( nmask , mrv->ivec , dset , mrv->fvec ) ;
}
STATUS("setting parameters in vectim header") ;
mrv->nx = DSET_NX(dset) ; mrv->dx = fabs(DSET_DX(dset)) ;
mrv->ny = DSET_NY(dset) ; mrv->dy = fabs(DSET_DY(dset)) ;
mrv->nz = DSET_NZ(dset) ; mrv->dz = fabs(DSET_DZ(dset)) ;
DSET_UNMSEC(dset) ; mrv->dt = DSET_TR(dset) ;
if( mrv->dt <= 0.0f ) mrv->dt = 1.0f ;
if( mmm != mask ){
STATUS("free(mmm)") ;
free(mmm) ;
}
STATUS("VECTIM_scan()") ;
VECTIM_scan(mrv) ; /* 09 Nov 2010 */
RETURN(mrv) ;
}
/* count voxels or mask fraction that hits a global maximum of 4095
*
* method = 4095_count : return masked counts
* 4095_frac : return masked fractions
* 4095_warn : return limit warning
*
* return 1 on error, 0 otherwise
*/
int compute_4095(options_t * opts, int method)
{
double * dwork;
float * fdata, gmax, fval;
byte * mask = opts->mask; /* save 6 characters... */
int nt, nvox, vind, tind, nmask, found, nlocal;
ENTRY("compute_4095");
nt = DSET_NVALS(opts->inset);
nvox = DSET_NVOX(opts->inset);
/* note how many voxels this is over */
if( opts->mask ) nmask = THD_countmask( nvox, opts->mask );
else nmask = nvox;
if( opts->verb )
INFO_message("computing %s, nvox = %d, nmask = %d, nt = %d",
meth_index_to_name(method), nvox, nmask, nt);
/* allocate result early, in case there is nothing to do */
opts->result = calloc(nt, sizeof(float));
if( nmask == 0 ) {
ERROR_message("empty mask");
RETURN(0);
}
/* check_dims() has been called, so we have sufficient data */
fdata = calloc(nt, sizeof(float));
/* do the work */
gmax = 0.0;
found = 0;
for( vind=0; vind < nvox; vind++ ) {
if( opts->mask && ! opts->mask[vind] ) continue;
if( THD_extract_array(vind, opts->inset, 0, fdata) ) {
ERROR_message("failed to exract data at index %d\n", vind);
free(fdata); RETURN(1);
}
/* start counting */
for( tind=0; tind < nt; tind++ ) {
fval = fdata[tind];
/* track global max */
if( fval > gmax ) gmax = fval;
/* if we pass the limit, quit working */
if( gmax > 4095.0 ) break;
/* track hits */
if( fval == 4095.0 ) opts->result[tind]++;
}
}
/* no longer needed */
free(fdata);
/* babble to user */
if( opts->verb )
INFO_message("global max = %f", gmax);
/* if warning, decide and return */
if( method == T21_METH_4095_WARN ) {
if( gmax != 4095 ) {
if( opts->verb ) INFO_message("max of %g is okay", gmax);
else { printf("0\n"); fflush(stdout); }
RETURN(0);
}
if( opts->verb ) WARNING_message("suspicious max of exactly 4095");
else { printf("1\n"); fflush(stdout); }
RETURN(0);
}
/* if frac, scale */
if( method == T21_METH_4095_FRAC ) {
for( tind=0; tind < nt; tind++ ) opts->result[tind] /= nmask;
}
if( opts->verb > 1 ) INFO_message("successfully ran 4095 test");
RETURN(0);
}
/* this is basically enorm, with scaling variants
*
* convert dsum to dmean and then a scalar:
* method = 1 : enorm sqrt(ss)
* 2 : rms sqrt(ss/nvox) = stdev (biased)
* 3 : srms sqrt(ss/nvox) / grand mean
*/
int compute_enorm(options_t * opts, int method)
{
double * dwork, dscale, gmean, mdiff;
float * fdata, fdiff;
byte * mask = opts->mask; /* save 6 characters... */
int nt, nvox, vind, tind, nmask;
ENTRY("compute_enorm");
nt = DSET_NVALS(opts->inset);
nvox = DSET_NVOX(opts->inset);
/* note how many voxels this is over */
if( opts->mask ) nmask = THD_countmask( nvox, opts->mask );
else nmask = nvox;
if( opts->verb )
INFO_message("computing %s, nvox = %d, nmask = %d, nt = %d",
meth_index_to_name(method), nvox, nmask, nt);
/* check_dims() has been called, so we have sufficient data */
dwork = calloc(nt, sizeof(double));
fdata = calloc(nt, sizeof(float));
/* could steal fdata, but that might be unethical (plus, garbage on err) */
opts->result = calloc(nt, sizeof(float));
/* use gmean to get mean across all masked voxels and time */
gmean = 0.0;
mdiff = 0.0;
for( vind=0; vind < nvox; vind++ ) {
if( opts->mask && ! opts->mask[vind] ) continue;
if( THD_extract_array(vind, opts->inset, 0, fdata) ) {
ERROR_message("failed to exract data at index %d\n", vind);
free(dwork); free(fdata); RETURN(1);
}
/* accumuate squared differences; dwork[0] is already 0 */
gmean += fdata[0]; /* and accumlate for mean */
for( tind=1; tind < nt; tind++ ) {
gmean += fdata[tind]; /* accumlate for mean */
fdiff = fdata[tind]-fdata[tind-1];
mdiff += fabs(fdiff); /* accumulate for mean diff */
dwork[tind] += fdiff*fdiff;
}
}
/* convert dsum to dmean and then a scalar:
* method = 1 : enorm sqrt(ss)
* 2 : rms sqrt(ss/nmask) = stdev (biased) of first diffs
* 3 : srms sqrt(ss/nmask) / abs(grand mean)
*/
gmean = fabs(gmean/nmask/nt); /* global masked mean */
mdiff /= nmask*nt; /* global masked mean first diff */
/* set the enorm scalar, based on the method */
if( method == T21_METH_ENORM ) {
if( opts->verb ) INFO_message("writing enorm : uses no scaling");
dscale = 1.0;
} else if ( method == T21_METH_RMS ) {
if( opts->verb ) INFO_message("writing rms = dvars = enorm/sqrt(nvox)");
dscale = sqrt(nmask);
} else if ( method == T21_METH_SRMS || method == T21_METH_S_SRMS ) {
if( opts->verb ) INFO_message("scaled dvars = srms = rms/gmean");
if( gmean == 0.0 ) {
ERROR_message("values have zero mean, failing (use rms, instead)");
free(dwork); free(fdata); RETURN(1);
} else if( gmean < 1.0 ) {
WARNING_message("values might be de-meaned, consider rms");
}
dscale = sqrt(nmask)*gmean;
}
/* babble to user */
if( opts->verb )
INFO_message("global mean = %f, mean diff = %f, mdiff/gmean = %f",
gmean, mdiff, mdiff/gmean);
if( opts->verb > 2 ) INFO_message("scaling enorm down by %f", dscale);
/* scale and store the result */
for( tind=1; tind < nt; tind++ )
opts->result[tind] = sqrt(dwork[tind]) / dscale;
opts->nt = nt;
/* if computing a mean diff, apply the shift */
if( method == T21_METH_S_SRMS ) {
mdiff /= gmean;
if( opts->verb ) INFO_message("shift by scaled mean diff %f", mdiff);
for( tind=1; tind < nt; tind++ )
opts->result[tind] -= mdiff;
}
free(dwork);
free(fdata);
if( opts->verb > 1 ) INFO_message("successfully computed enorm");
RETURN(0);
}
int main( int argc , char *argv[] )
{
int vstep=0 , ii,nvox , ntin , ntout , do_one=0 , nup=-1 ;
THD_3dim_dataset *inset=NULL , *outset ;
char *prefix="Upsam", *dsetname=NULL ;
int verb=0 , iarg=1, datum = MRI_float;
float *ivec , *ovec , trin , trout, *fac=NULL, *ofac=NULL,
top=0.0, maxtop=0.0;
/*------- help the pitifully ignorant user? -------*/
if( argc < 2 || strcmp(argv[1],"-help") == 0 ){
printf(
"Usage: 3dUpsample [options] n dataset\n"
"\n"
"* Upsamples a 3D+time dataset, in the time direction,\n"
" by a factor of 'n'.\n"
"* The value of 'n' must be between 2 and 320 (inclusive).\n"
"* The output dataset is in float format by default.\n"
"\n"
"Options:\n"
"--------\n"
" -1 or -one = Use linear interpolation. Otherwise,\n"
" or -linear 7th order polynomial interpolation is used.\n"
"\n"
" -prefix pp = Define the prefix name of the output dataset.\n"
" [default prefix is 'Upsam']\n"
"\n"
" -verb = Be eloquently and mellifluosly verbose.\n"
"\n"
" -n n = An alternate way to specify n\n"
" -input dataset = An alternate way to specify dataset\n"
"\n"
" -datum ddd = Use datatype ddd at output. Choose from\n"
" float (default), short, byte.\n"
"Example:\n"
"--------\n"
" 3dUpsample -prefix LongFred 5 Fred+orig\n"
"\n"
"Nota Bene:\n"
"----------\n"
"* You should not use this for files that were 3dTcat-ed across\n"
" imaging run boundaries, since that will result in interpolating\n"
" between non-contiguous time samples!\n"
"* If the input has M time points, the output will have n*M time\n"
" points. The last n-1 of them will be past the end of the original\n"
" time series.\n"
"* This program gobbles up memory and diskspace as a function of n.\n"
" You can reduce output file size with -datum option.\n"
"\n"
"--- RW Cox - April 2008\n"
) ;
PRINT_COMPILE_DATE ; exit(0) ;
}
mainENTRY("3dUpsample"); machdep();
PRINT_VERSION("3dUpsample"); AUTHOR("RWCox") ;
AFNI_logger("3dUpsample",argc,argv);
/*------- read command line args -------*/
datum = MRI_float;
iarg = 1 ;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strncasecmp(argv[iarg],"-prefix",5) == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '%s'",argv[iarg-1]);
prefix = argv[iarg] ;
if( !THD_filename_ok(prefix) )
ERROR_exit("Illegal string after -prefix: '%s'",prefix) ;
iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-one",4) == 0 ||
strcmp (argv[iarg],"-1" ) == 0 ||
strncasecmp(argv[iarg],"-lin",4) == 0 ){
do_one = 1 ; iarg++ ; continue ;
}
if( strncasecmp(argv[iarg],"-verb",3) == 0 ){
verb = 1 ; iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-n") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '%s'",argv[iarg-1]);
nup = (int)strtod(argv[iarg],NULL) ;
if( nup < 2 || nup > 320 )
ERROR_exit("3dUpsample rate '%d' is outside range 2..320",nup) ;
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-input") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '%s'",argv[iarg-1]);
dsetname = argv[iarg];
iarg++ ; continue ;
}
if( strcasecmp(argv[iarg],"-datum") == 0 ){
if( ++iarg >= argc )
ERROR_exit("Need argument after '%s'",argv[iarg-1]);
if( strcmp(argv[iarg],"short") == 0 ){
datum = MRI_short ;
} else if( strcmp(argv[iarg],"float") == 0 ){
datum = MRI_float ;
} else if( strcmp(argv[iarg],"byte") == 0 ){
datum = MRI_byte ;
} else {
ERROR_message("-datum of type '%s' not supported in 3dUpsample!\n",
argv[iarg] ) ;
exit(1) ;
}
iarg++ ; continue ;
}
ERROR_message("Unknown argument on command line: '%s'",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit (1);
}
/*------- check options for completeness and consistency -----*/
if (nup == -1) {
if( iarg+1 >= argc )
ERROR_exit("need 'n' and 'dataset' on command line!") ;
nup = (int)strtod(argv[iarg++],NULL) ;
if( nup < 2 || nup > 320 )
ERROR_exit("3dUpsample rate '%d' is outside range 2..320",nup) ;
}
if (!dsetname) {
if( iarg >= argc )
ERROR_exit("need 'dataset' on command line!") ;
dsetname = argv[iarg];
}
inset = THD_open_dataset(dsetname) ;
if( !ISVALID_DSET(inset) )
ERROR_exit("3dUpsample can't open dataset '%s'", dsetname) ;
ntin = DSET_NVALS(inset) ; trin = DSET_TR(inset) ;
if( ntin < 2 )
ERROR_exit("dataset '%s' has only 1 value per voxel?!",dsetname) ;
nvox = DSET_NVOX(inset) ;
if( verb ) INFO_message("loading input dataset into memory") ;
DSET_load(inset) ; CHECK_LOAD_ERROR(inset) ;
/*------ create output dataset ------*/
ntout = ntin * nup ; trout = trin / nup ;
/* scaling factor for output */
fac = NULL; maxtop = 0.0;
if (MRI_IS_INT_TYPE(datum)) {
fac = (float *)calloc(DSET_NVALS(inset), sizeof(float));
ofac = (float *)calloc(ntout, sizeof(float));
for (ii=0; ii<DSET_NVALS(inset); ++ii) {
top = MCW_vol_amax( DSET_NVOX(inset),1,1 ,
DSET_BRICK_TYPE(inset,ii),
DSET_BRICK_ARRAY(inset,ii) ) ;
if (DSET_BRICK_FACTOR(inset, ii))
top = top * DSET_BRICK_FACTOR(inset,ii);
fac[ii] = (top > MRI_TYPE_maxval[datum]) ?
top/MRI_TYPE_maxval[datum] : 0.0 ;
if (top > maxtop) maxtop = top;
}
if (storage_mode_from_filename(prefix) != STORAGE_BY_BRICK) {
fac[0] = (maxtop > MRI_TYPE_maxval[datum]) ?
maxtop/MRI_TYPE_maxval[datum] : 0.0 ;
for (ii=0; ii<ntout; ++ii)
ofac[ii] = fac[0];
if (verb) INFO_message("Forcing global scaling, Max = %f, fac = %f\n",
maxtop, fac[0]);
} else {
if (verb) INFO_message("Reusing scaling factors of input dset\n");
upsample_1( nup, DSET_NVALS(inset), fac, ofac);
}
}
free(fac); fac = NULL;
outset = EDIT_empty_copy(inset) ;
EDIT_dset_items( outset ,
ADN_nvals , ntout ,
ADN_ntt , DSET_NUM_TIMES(inset) > 1 ? ntout : 0 ,
ADN_datum_all , datum ,
ADN_brick_fac , ofac ,
ADN_prefix , prefix ,
ADN_none ) ;
tross_Copy_History( inset , outset ) ;
tross_Make_History( "3dUpsample" , argc,argv , outset ) ;
free(ofac); ofac = NULL;
if( outset->taxis != NULL ){
outset->taxis->ttdel /= nup ;
outset->taxis->ttdur /= nup ;
if( outset->taxis->toff_sl != NULL ){
for( ii=0 ; ii < outset->taxis->nsl ; ii++ )
outset->taxis->toff_sl[ii] /= nup ;
}
}
for( ii=0 ; ii < ntout ; ii++ ){ /* create empty bricks to be filled below */
EDIT_substitute_brick( outset , ii , datum , NULL ) ;
}
/*------- loop over voxels and process them one at a time ---------*/
if( verb )
INFO_message("Upsampling time series from %d to %d: %s interpolation",
ntin , ntout , (do_one) ? "linear" : "heptic" ) ;
if( verb && nvox > 499 ) vstep = nvox / 50 ;
if( vstep > 0 ) fprintf(stderr,"++ voxel loop: ") ;
ivec = (float *)malloc(sizeof(float)*ntin) ;
ovec = (float *)malloc(sizeof(float)*ntout) ;
for( ii=0 ; ii < nvox ; ii++ ){
if( vstep > 0 && ii%vstep==vstep-1 ) vstep_print() ;
THD_extract_array( ii , inset , 0 , ivec ) ;
if( do_one ) upsample_1( nup , ntin , ivec , ovec ) ;
else upsample_7( nup , ntin , ivec , ovec ) ;
THD_insert_series( ii , outset , ntout , MRI_float , ovec ,
datum==MRI_float ? 1:0 ) ;
} /* end of loop over voxels */
if( vstep > 0 ) fprintf(stderr," Done!\n") ;
/*----- clean up and go away -----*/
DSET_write(outset) ;
if( verb ) WROTE_DSET(outset) ;
if( verb ) INFO_message("Total CPU time = %.1f s",COX_cpu_time()) ;
exit(0);
}
MRI_vectim * THD_dset_censored_to_vectim( THD_3dim_dataset *dset,
byte *mask , int nkeep , int *keep )
{
byte *mmm=mask ;
MRI_vectim *mrv=NULL ;
int kk,iv,jj , nvals , nvox , nmask ;
ENTRY("THD_dset_censored_to_vectim") ;
if( !ISVALID_DSET(dset) ) RETURN(NULL) ;
if( nkeep <= 0 || keep == NULL ){
mrv = THD_dset_to_vectim( dset , mask , 0 ) ;
RETURN(mrv) ;
}
if( ! THD_subset_loaded(dset,nkeep,keep) ){
DSET_load(dset) ; if( !DSET_LOADED(dset) ) RETURN(NULL) ;
}
nvals = nkeep ;
nvox = DSET_NVOX(dset) ;
if( mmm != NULL ){
nmask = THD_countmask( nvox , mmm ) ; /* number to keep */
if( nmask <= 0 ) RETURN(NULL) ;
} else {
nmask = nvox ; /* keep them all */
#pragma omp critical (MALLOC)
mmm = (byte *)malloc(sizeof(byte)*nmask) ;
if( mmm == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
RETURN(NULL) ;
}
memset( mmm , 1 , sizeof(byte)*nmask ) ;
}
#pragma omp critical (MALLOC)
mrv = (MRI_vectim *)malloc(sizeof(MRI_vectim)) ;
mrv->nvec = nmask ;
mrv->nvals = nvals ;
mrv->ignore = 0 ;
#pragma omp critical (MALLOC)
mrv->ivec = (int *)malloc(sizeof(int)*nmask) ;
if( mrv->ivec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
}
#pragma omp critical (MALLOC)
mrv->fvec = (float *)malloc(sizeof(float)*(size_t)nmask*(size_t)nvals) ;
if( mrv->fvec == NULL ){
ERROR_message("THD_dset_to_vectim: out of memory") ;
free(mrv->ivec) ; free(mrv) ; if( mmm != mask ) free(mmm) ;
RETURN(NULL) ;
}
/* store desired voxel time series */
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] ) mrv->ivec[kk++] = iv ; /* build index list */
}
#pragma omp critical (MALLOC)
{ float *var = (float *)malloc(sizeof(float)*DSET_NVALS(dset)) ;
float *vpt ;
for( kk=iv=0 ; iv < nvox ; iv++ ){
if( mmm[iv] == 0 ) continue ;
vpt = VECTIM_PTR(mrv,kk) ; kk++ ;
if( nkeep > 1 ){
(void)THD_extract_array( iv , dset , 0 , var ) ;
for( jj=0 ; jj < nkeep ; jj++ ) vpt[jj] = var[keep[jj]] ;
} else {
vpt[0] = THD_get_float_value(iv,keep[0],dset) ;
}
}
free(var) ;
}
mrv->nx = DSET_NX(dset) ; mrv->dx = fabs(DSET_DX(dset)) ;
mrv->ny = DSET_NY(dset) ; mrv->dy = fabs(DSET_DY(dset)) ;
mrv->nz = DSET_NZ(dset) ; mrv->dz = fabs(DSET_DZ(dset)) ;
DSET_UNMSEC(dset) ; mrv->dt = DSET_TR(dset) ;
if( mrv->dt <= 0.0f ) mrv->dt = 1.0f ;
if( mmm != mask ) free(mmm) ;
VECTIM_scan(mrv) ; /* 09 Nov 2010 */
RETURN(mrv) ;
}
