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_shindss * GRINCOR_read_input( char *fname ) { NI_element *nel=NULL ; char *dfname=NULL , *atr ; NI_float_array *facar ; NI_int_array *nvar, *nnode=NULL, *ninmask=NULL; MRI_shindss *shd ; long long nbytes_needed , nbytes_dfname=0 ; int fdes ; void *var ; int ids , nvmax , nvtot ; int datum , datum_size ; char *geometry_string=NULL ; THD_3dim_dataset *tdset=NULL; int nvox; int no_ivec=0 , *ivec=NULL , *nvals=NULL , nvec,ndset ; float *fac=NULL ; NI_str_array *slabar=NULL ; if( fname == NULL || *fname == '\0' ) GQUIT(NULL) ; /* get data element */ if (!THD_is_ondisk(fname)) GQUIT("not on disk") ; nelshd = nel = NI_read_element_fromfile(fname) ; if( nel == NULL || nel->type != NI_ELEMENT_TYPE ) GQUIT("not properly formatted") ; if( strcmp(nel->name,"3dGroupInCorr") != 0 ) GQUIT("data element name is not '3dGroupInCorr'") ; /* no data vector ==> using all voxels */ no_ivec = ( nel->vec_num < 1 || nel->vec_len < 1 || nel->vec_typ[0] != NI_INT ) ; /* number of vectors in each dataset */ atr = NI_get_attribute(nel,"nvec"); if( atr == NULL ) GQUIT("nvec attribute missing?") ; nvec = (int)strtod(atr,NULL) ; if( nvec < 2 || (!no_ivec && nel->vec_len != nvec) ) GQUIT("nvec attribute has illegal value") ; /* number of datasets */ atr = NI_get_attribute(nel,"ndset"); if( atr == NULL ) GQUIT("ndset attribute missing") ; ndset = (int)strtod(atr,NULL) ; if( ndset < 1 ) GQUIT("ndset attribute has illegal value") ; /* number of time points in each dataset (varies with dataset) */ atr = NI_get_attribute(nel,"nvals"); if( atr == NULL ) GQUIT("nvals attribute missing") ; nvar = NI_decode_int_list(atr,",") ; if( nvar == NULL || nvar->num < ndset ) GQUIT("nvals attribute doesn't match ndset") ; nvals = nvar->ar ; nvar->ar = NULL ; NI_delete_int_array(nvar) ; nvmax = nvtot = nvals[0] ; for( ids=1 ; ids < ndset ; ids++ ){ /* Feb 2011 */ nvtot += nvals[ids] ; if( nvals[ids] > nvmax ) nvmax = nvals[ids] ; } /* dataset labels [23 May 2010] */ atr = NI_get_attribute(nel,"dset_labels") ; if( atr != NULL ){ slabar = NI_decode_string_list(atr,";,") ; if( slabar == NULL || slabar->num < ndset ) GQUIT("dset_labels attribute invalid") ; } /* datum of datasets */ atr = NI_get_attribute(nel,"datum") ; if( atr != NULL && strcasecmp(atr,"byte") == 0 ){ datum = 1 ; datum_size = sizeof(sbyte) ; } else { datum = 2 ; datum_size = sizeof(short) ; } /* number of bytes needed: sizeof(datum) * number of vectors per dataset * number of datasets * sum of per dataset vector lengths */ nbytes_needed = 0 ; for( ids=0 ; ids < ndset ; ids++ ) nbytes_needed += nvals[ids] ; nbytes_needed *= ((long long)nvec) * datum_size ; if( nbytes_needed >= twogig && ( sizeof(void *) < 8 || sizeof(size_t) < 8 ) ) /* too much for 32-bit */ GQUIT("datafile size exceeds 2 GB -- you need a 64-bit computer!") ; /* scale factor for each dataset */ atr = NI_get_attribute(nel,"fac") ; if( atr == NULL ) GQUIT("fac attribute missing") ; facar = NI_decode_float_list(atr,",") ; if( facar == NULL || facar->num < ndset ) GQUIT("can't decode fac attribute") ; fac = facar->ar ; facar->ar = NULL ; NI_delete_float_array(facar) ; for( ids=0 ; ids < ndset ; ids++ ) if( fac[ids] <= 0.0f ) fac[ids] = 1.0f ; /* grid definition */ atr = NI_get_attribute(nel,"geometry") ; if( atr == NULL ) GQUIT("geometry attribute missing") ; geometry_string = strdup(atr) ; tdset = EDIT_geometry_constructor( geometry_string , "GrpInCorr" ) ; if( tdset == NULL ) GQUIT("can't decode geometry attribute") ; nvox = DSET_NVOX(tdset) ; if( no_ivec && nvox != nvec ) GQUIT("geometry attribute doesn't match nvec attribute") ; if( !no_ivec && nvox < nvec ) GQUIT("geometry attribute specifies too few voxels") ; /* name of data file: check its size against what's needed */ #if 0 atr = NI_get_attribute(nel,"datafile") ; if( atr != NULL ){ dfname = strdup(atr) ; nbytes_dfname = THD_filesize(dfname) ; if( nbytes_dfname <= 0 && strstr(dfname,"/") != NULL ){ char *tnam = THD_trailname(atr,0) ; nbytes_dfname = THD_filesize(tnam) ; if( nbytes_dfname > 0 ){ free(dfname); dfname = strdup(tnam); } } } #endif if( nbytes_dfname <= 0 && strstr(fname,".niml") != NULL ){ if( dfname != NULL ) free(dfname) ; dfname = strdup(fname) ; strcpy(dfname+strlen(dfname)-5,".data") ; nbytes_dfname = THD_filesize(dfname) ; } if( nbytes_dfname <= 0 ){ char mess[THD_MAX_NAME+256] ; sprintf(mess,"datafile is missing (%s)",dfname) ; GQUIT(mess) ; } else if( nbytes_dfname < nbytes_needed ){ char mess[THD_MAX_NAME+1024] ; sprintf(mess,"datafile %s has %s bytes but needs at least %s", dfname , commaized_integer_string(nbytes_dfname) , commaized_integer_string(nbytes_needed) ) ; GQUIT(mess) ; } else { INFO_message("EIC: data file %s found with %s bytes of data", dfname , commaized_integer_string(nbytes_dfname) ) ; } fdes = open( dfname , O_RDWR ) ; if( fdes < 0 ){ char mess[THD_MAX_NAME+256] ; sprintf(mess,"can't open datafile (%s)",dfname) ; GQUIT(mess) ; } NI_set_attribute( nelshd , "datafile" , dfname ) ; /* ivec[i] is the voxel spatial index of the i-th vector */ if( no_ivec ){ ivec = NULL ; /* means all voxels: ivec[i] == i */ } else { ivec = (int *)nel->vec[0] ; /* copy pointer */ nel->vec[0] = NULL ; /* NULL out in element so won't be free-ed */ } /* And stuff for LR surface pairs ZSS Jan 09*/ if ((atr=NI_get_attribute(nel,"LRpair_nnode"))) { nnode = NI_decode_int_list(atr,",") ; } if ((atr=NI_get_attribute(nel,"LRpair_ninmask"))) { ninmask = NI_decode_int_list(atr,",") ; } /* create output struct */ shd = (MRI_shindss *)malloc(sizeof(MRI_shindss)) ; shd->nvals = nvals ; shd->nvals_max = nvmax ; shd->nvals_tot = nvtot ; shd->nvec = nvec ; shd->ndset = ndset ; shd->geometry_string = geometry_string ; shd->tdset = tdset ; shd->dfname = dfname ; shd->nvox = nvox ; shd->nx = DSET_NX(tdset); shd->ny = DSET_NY(tdset); shd->nz = DSET_NZ(tdset); shd->ivec = ivec ; shd->fac = fac ; /* and surface fields... ZSS Jan 09 */ if (nnode) { if (nnode->num != 2) GQUIT("LRpair_nnode must have 2 values"); shd->nnode[0] = nnode->ar[0]; shd->nnode[1] = nnode->ar[1]; NI_delete_int_array(nnode); nnode=NULL; } else { shd->nnode[0] = shd->nnode[1] = -1 ; } if (ninmask) { if (ninmask->num != 2) GQUIT("LRpair_ninmask must have 2 values"); shd->ninmask[0] = ninmask->ar[0]; shd->ninmask[1] = ninmask->ar[1]; NI_delete_int_array(ninmask); ninmask=NULL; } else { shd->ninmask[0] = shd->ninmask[1] = -1 ; } /*--- 07 Apr 2010: setup default use list (all of them) ---*/ shd->nuse = ndset ; shd->use = (int *)malloc(sizeof(int)*ndset) ; for( ids=0 ; ids < ndset ; ids++ ) shd->use[ids] = ids ; shd->dslab = (slabar != NULL) ? slabar->str : NULL ; /* 23 May 2010 */ /*--- now have to map data from disk ---*/ var = mmap( 0 , (size_t)nbytes_needed , PROT_WRITE , THD_MMAP_FLAG , fdes , 0 ) ; close(fdes) ; /* close file descriptor does not unmap data */ if( var == (void *)(-1) ){ /* this is bad */ ERROR_message( "EIC: file %s: can't mmap() datafile -- memory space exhausted?" , dfname ) ; free(shd) ; return NULL ; } /*-- create array of pointers to each dataset's data array --*/ shd->datum = datum ; if( datum == 2 ){ /* shorts */ shd->sv = (short **)malloc(sizeof(short *)*ndset) ; shd->bv = NULL ; shd->sv[0] = (short *)var ; for( ids=1 ; ids < ndset ; ids++ ) shd->sv[ids] = shd->sv[ids-1] + nvals[ids-1]*nvec ; } else { /* sbytes */ shd->sv = NULL ; shd->bv = (sbyte **)malloc(sizeof(sbyte *)*ndset) ; shd->bv[0] = (sbyte *)var ; for( ids=1 ; ids < ndset ; ids++ ) shd->bv[ids] = shd->bv[ids-1] + nvals[ids-1]*nvec ; } shd->nbytes = nbytes_needed ; return shd ; }
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) ; }
int THD_datablock_from_atr( THD_datablock *dblk, char *dirname, char *headname ) { THD_diskptr *dkptr ; ATR_int *atr_rank , *atr_dimen , *atr_scene , *atr_btype ; ATR_float *atr_flt ; ATR_string *atr_labs ; int ii , view_type , func_type , dset_type , nx,ny,nz,nvox , nvals , ibr,typ ; Boolean ok ; char prefix[THD_MAX_NAME]="Unknown" ; MRI_IMAGE *qim ; int brick_ccode ; char name[666] ; ENTRY("THD_datablock_from_atr") ; if( dblk == NULL || dblk->natr <= 0 ) RETURN(0) ; /* bad input */ dkptr = dblk->diskptr ; /*-- get relevant attributes: rank, dimensions, view_type & func_type --*/ atr_rank = THD_find_int_atr( dblk , ATRNAME_DATASET_RANK ) ; atr_dimen = THD_find_int_atr( dblk , ATRNAME_DATASET_DIMENSIONS ) ; atr_scene = THD_find_int_atr( dblk , ATRNAME_SCENE_TYPE ) ; /*-- missing an attribute ==> quit now --*/ if( atr_rank == NULL || atr_dimen == NULL || atr_scene == NULL ) RETURN(0) ; /*-- load type codes from SCENE attribute --*/ STATUS("loading *_type from SCENE") ; view_type = atr_scene->in[0] ; func_type = atr_scene->in[1] ; dset_type = atr_scene->in[2] ; /*-- load other values from attributes into relevant places --*/ ok = True ; nvox = 1 ; STATUS("loading from RANK") ; dkptr->rank = atr_rank->in[0] ; /* N.B.: rank isn't used much */ dkptr->nvals = dblk->nvals = nvals = atr_rank->in[1] ; /* but nvals is used */ STATUS("loading from DIMENSIONS") ; for( ii=0 ; ii < dkptr->rank ; ii++ ){ dkptr->dimsizes[ii] = atr_dimen->in[ii] ; ok = ( ok && dkptr->dimsizes[ii] >= 1 ) ; nvox *= dkptr->dimsizes[ii] ; } #if 0 if( PRINT_TRACING ){ char str[256] ; sprintf(str,"rank=%d nvals=%d dim[0]=%d dim[1]=%d dim[2]=%d nvox=%d", dkptr->rank , dkptr->nvals , dkptr->dimsizes[0] , dkptr->dimsizes[1] , dkptr->dimsizes[2] , nvox ) ; STATUS(str) ; } #endif if( !ok || nvals < 1 || dkptr->rank < THD_MIN_RANK || dkptr->rank > THD_MAX_RANK ){ STATUS("bad rank!!??") ; RETURN(0) ; } /*-- create the storage filenames --*/ STATUS("creating storage filenames") ; if( headname != NULL && strchr(headname,'+') != NULL ){ FILENAME_TO_PREFIX(headname,prefix) ; THD_init_diskptr_names( dkptr, dirname,NULL,prefix , view_type , True ) ; } else { if( headname != NULL ) MCW_strncpy(prefix,headname,THD_MAX_NAME) ; THD_init_diskptr_names( dkptr, dirname,NULL,prefix , view_type , True ) ; } /*-- determine if the BRIK file exists --*/ STATUS("checking if .BRIK file exists") ; brick_ccode = COMPRESS_filecode(dkptr->brick_name) ; if (dkptr->storage_mode == STORAGE_UNDEFINED) { /* ZSS: Oct. 2011 the next line was being called all the time before */ if( brick_ccode != COMPRESS_NOFILE ) dkptr->storage_mode = STORAGE_BY_BRICK ; /* a .BRIK file */ } /*-- if VOLUME_FILENAMES attribute exists, make it so [20 Jun 2002] --*/ if( headname != NULL && dkptr->storage_mode == STORAGE_UNDEFINED ){ atr_labs = THD_find_string_atr(dblk,"VOLUME_FILENAMES") ; if( atr_labs != NULL ){ dkptr->storage_mode = STORAGE_BY_VOLUMES ; dblk->malloc_type = DATABLOCK_MEM_MALLOC ; } } /*-- now set the memory allocation codes, etc. --*/ dblk->brick_fac = (float *) XtMalloc( sizeof(float) * nvals ) ; for( ibr=0 ; ibr < nvals ; ibr++ ) dblk->brick_fac[ibr] = 0.0 ; /* scaling factors from short type to float type, if nonzero */ if( !AFNI_yesenv("AFNI_IGNORE_BRICK_FLTFAC") ){ atr_flt = THD_find_float_atr( dblk , ATRNAME_BRICK_FLTFAC ) ; if( atr_flt != NULL ){ for( ibr=0 ; ibr < nvals && ibr < atr_flt->nfl ; ibr++ ) dblk->brick_fac[ibr] = atr_flt->fl[ibr] ; } } /** Now create an empty shell of the "brick" == the data structure that will hold all the voxel data. Note that all datablocks will have a brick, even if they never actually contain data themselves (are only warp-on-demand). If the BRICK_TYPES input attribute doesn't exist, then all sub-bricks are shorts. This makes the code work with old-style datasets, which were always made up of shorts. **/ atr_btype = THD_find_int_atr( dblk , ATRNAME_BRICK_TYPES ) ; if( atr_btype == NULL ){ THD_init_datablock_brick( dblk , MRI_short , NULL ) ; } else { THD_init_datablock_brick( dblk , atr_btype->nin , atr_btype->in ) ; } if( !THD_datum_constant(dblk) ){ /* 15 Sep 2004 */ fprintf(stderr, "\n** WARNING: File %s has mixed-type sub-bricks. ", MYHEAD ) ; } /* 25 April 1998: check if the byte order is stored inside */ atr_labs = THD_find_string_atr( dblk , ATRNAME_BYTEORDER ) ; if( atr_labs != NULL && atr_labs->nch > 0 ){ if( strncmp(atr_labs->ch,LSB_FIRST_STRING,ORDER_LEN) == 0 ) dkptr->byte_order = LSB_FIRST ; else if( strncmp(atr_labs->ch,MSB_FIRST_STRING,ORDER_LEN) == 0 ) dkptr->byte_order = MSB_FIRST ; else fprintf(stderr,"*** Unknown %s found in dataset %s\n", ATRNAME_BYTEORDER , MYHEAD ) ; } else if( !no_ordwarn && DBLK_BRICK_TYPE(dblk,0) != MRI_byte && dblk->diskptr->storage_mode == STORAGE_BY_BRICK ){ /* 20 Sep 1999 */ static int first=1 ; if( first ){ fprintf(stderr, "\n*** The situation below can be rectified with program '3drefit -byteorder':\n"); first = 0 ; } fprintf(stderr," ** Dataset %s: assuming byteorder %s\n", MYHEAD , BYTE_ORDER_STRING(dkptr->byte_order) ) ; } /* if the data is not on disk, the flag remains at DATABLOCK_MEM_UNDEFINED, otherwise the flag says how the memory for the bricks is to be created. */ if( dkptr->storage_mode == STORAGE_BY_BRICK ){ #if MMAP_THRESHOLD > 0 dblk->malloc_type = (dblk->total_bytes > MMAP_THRESHOLD) ? DATABLOCK_MEM_MMAP : DATABLOCK_MEM_MALLOC ; DBLK_mmapfix(dblk) ; /* 18 Mar 2005 */ #else dblk->malloc_type = DATABLOCK_MEM_MALLOC ; #endif /* must be malloc-ed if: data is compressed, data is not in native byte order, or user explicity forbids use of mmap */ if( brick_ccode >= 0 || dkptr->byte_order != native_order || no_mmap ) dblk->malloc_type = DATABLOCK_MEM_MALLOC ; } /* 30 Nov 1997: create the labels for sub-bricks */ THD_init_datablock_labels( dblk ) ; atr_labs = THD_find_string_atr( dblk , ATRNAME_BRICK_LABS ) ; if( atr_labs != NULL && atr_labs->nch > 0 ){ /* create labels from attribute */ int ipos = -1 , ipold , ngood ; for( ibr=0 ; ibr < nvals ; ibr++ ){ /* loop over bricks */ for( ipold = ipos++ ; /* skip to */ ipos < atr_labs->nch && atr_labs->ch[ipos] != '\0' ; /* next \0 */ ipos++ ) /* nada */ ; /* or end. */ ngood = ipos - ipold - 1 ; /* number of good chars */ if( ngood > 0 ){ XtFree(dblk->brick_lab[ibr]) ; /* 27 Oct 2011 - increase to 64 */ if( ngood > THD_MAX_SBLABEL ) ngood = THD_MAX_SBLABEL; dblk->brick_lab[ibr] = (char *) XtMalloc(sizeof(char)*(ngood+2)) ; memcpy( dblk->brick_lab[ibr] , atr_labs->ch+(ipold+1) , ngood ) ; dblk->brick_lab[ibr][ngood] = '\0' ; } if( ipos >= atr_labs->nch ) break ; /* nothing more to do */ } /* end of loop over sub-bricks */ } /* create the keywords for sub-bricks */ THD_init_datablock_keywords( dblk ) ; atr_labs = THD_find_string_atr( dblk , ATRNAME_BRICK_KEYWORDS ) ; if( atr_labs != NULL && atr_labs->nch > 0 ){ /* create keywords from attribute */ int ipos = -1 , ipold , ngood ; for( ibr=0 ; ibr < nvals ; ibr++ ){ /* loop over bricks */ for( ipold = ipos++ ; /* skip to */ ipos < atr_labs->nch && atr_labs->ch[ipos] != '\0' ; /* next \0 */ ipos++ ) /* nada */ ; /* or end. */ ngood = ipos - ipold - 1 ; /* number of good chars */ if( ngood > 0 ){ XtFree(dblk->brick_keywords[ibr]) ; dblk->brick_keywords[ibr] = (char *) XtMalloc(sizeof(char)*(ngood+2)) ; memcpy( dblk->brick_keywords[ibr] , atr_labs->ch+(ipold+1) , ngood ) ; dblk->brick_keywords[ibr][ngood] = '\0' ; } if( ipos >= atr_labs->nch ) break ; /* nothing more to do */ } /* end of loop over sub-bricks */ } /* create the auxiliary statistics stuff for each brick, if present */ atr_labs = THD_find_string_atr( dblk , "BRICK_STATSYM" ) ; /* 01 Jun 2005 */ if( atr_labs != NULL && atr_labs->nch > 0 ){ NI_str_array *sar ; int scode,np ; float parm[3] ; sar = NI_decode_string_list( atr_labs->ch , ";" ) ; if( sar != NULL && sar->num > 0 ){ for( ibr=0 ; ibr < nvals && ibr < sar->num ; ibr++ ){ NI_stat_decode( sar->str[ibr] , &scode , parm,parm+1,parm+2 ) ; if( scode >= AFNI_FIRST_STATCODE && scode <= AFNI_LAST_STATCODE ){ np = NI_stat_numparam(scode) ; THD_store_datablock_stataux( dblk , ibr,scode,np,parm ) ; } } NI_delete_str_array(sar) ; } } else { /*--- the olde way to get ye brick stataux parameters ---*/ atr_flt = THD_find_float_atr( dblk , ATRNAME_BRICK_STATAUX ) ; if( atr_flt != NULL && atr_flt->nfl >= 3 ){ int ipos=0 , iv,nv,jv ; /* attribute stores all stataux stuff as follows: sub-brick-index statcode no.-of-values value ... value sub-brick-index statcode no.-of-values value ... value, etc. */ while( ipos <= atr_flt->nfl - 3 ){ iv = (int) ( atr_flt->fl[ipos++] ) ; /* which sub-brick */ jv = (int) ( atr_flt->fl[ipos++] ) ; /* statcode */ nv = (int) ( atr_flt->fl[ipos++] ) ; /* # of values that follow */ if( nv > atr_flt->nfl - ipos ) nv = atr_flt->nfl - ipos ; THD_store_datablock_stataux( dblk , iv , jv , nv , atr_flt->fl + ipos ) ; ipos += nv ; } } } #if 0 if( PRINT_TRACING ){ char str[256] ; sprintf(str,"rank=%d nvals=%d dim[0]=%d dim[1]=%d dim[2]=%d", dkptr->rank , dkptr->nvals , dkptr->dimsizes[0] , dkptr->dimsizes[1] , dkptr->dimsizes[2] ) ; STATUS(str) ; } #endif /*-- FDR curves [23 Jan 2008] --*/ for( ibr=0 ; ibr < dblk->nvals ; ibr++ ){ sprintf(name,"FDRCURVE_%06d",ibr) ; atr_flt = THD_find_float_atr( dblk , name ) ; if( atr_flt != NULL && atr_flt->nfl > 3 ){ int nv = atr_flt->nfl - 2 ; floatvec *fv ; MAKE_floatvec(fv,nv) ; fv->x0 = atr_flt->fl[0] ; fv->dx = atr_flt->fl[1] ; memcpy( fv->ar , atr_flt->fl + 2 , sizeof(float)*nv ) ; if( dblk->brick_fdrcurve == NULL ) dblk->brick_fdrcurve = (floatvec **)calloc(sizeof(floatvec *),dblk->nvals); dblk->brick_fdrcurve[ibr] = fv ; } } for( ibr=0 ; ibr < dblk->nvals ; ibr++ ){ sprintf(name,"MDFCURVE_%06d",ibr) ; atr_flt = THD_find_float_atr( dblk , name ) ; if( atr_flt != NULL && atr_flt->nfl > 3 ){ int nv = atr_flt->nfl - 2 ; floatvec *fv ; MAKE_floatvec(fv,nv) ; fv->x0 = atr_flt->fl[0] ; fv->dx = atr_flt->fl[1] ; memcpy( fv->ar , atr_flt->fl + 2 , sizeof(float)*nv ) ; if( dblk->brick_mdfcurve == NULL ) dblk->brick_mdfcurve = (floatvec **)calloc(sizeof(floatvec *),dblk->nvals); dblk->brick_mdfcurve[ibr] = fv ; } } RETURN(1) ; }
int main( int argc , char * argv[] ) { int nim , ii , jj , kk , nx, narg, oform ; MRI_IMAGE **inim ; float *far; char *formatstr=NULL, *sel=NULL, *fname=NULL; int nonconst=0 , ncol,ncold , cc , nonfixed=0 , stack=0; intvec *ncv=NULL ; char *hline=NULL ; mainENTRY("1dcat:main"); /*-- help? --*/ if( argc < 2 || strcmp(argv[1],"-help") == 0 ){ printf( "Usage: 1dcat [options] a.1D b.1D ...\n" " where each file a.1D, b.1D, etc. is a 1D file.\n" " In the simplest form, a 1D file is an ASCII file of numbers\n" " arranged in rows and columns.\n" "\n" "1dcat takes as input one or more 1D files, and writes out a 1D file\n" "containing the side-by-side concatenation of all or a subset of the\n" "columns from the input files.\n" "\n" "* Output goes to stdout (the screen); redirect (e.g., '>') to save elsewhere.\n" "* All files MUST have the same number of rows!\n" "* Any header lines (i.e., lines that start with '#') will be lost.\n" "* For generic 1D file usage help and information, see '1dplot -help'\n" "\n" "OPTIONS:\n" "--------\n" " -nonconst: Columns that are identically constant should be omitted\n" " from the output.\n" "\n" " -nonfixed: Keep only columns that are marked as 'free' in the \n" " 3dAllineate header from '-1Dparam_save'.\n" " If there is no such header, all columns are kept.\n" "\n" " -form FORM: Format of the numbers to be output.\n" " You can also substitute -form FORM with shortcuts such \n" " as -i, -f, or -c.\n" " For help on -form's usage, and its shortcut versions\n" " see ccalc's help for the option of the same name. \n" "\n" " -stack: Stack the columns of the resultant matrix in the output.\n" "\n" " -sel SEL: Apply the same column/row selection string to all filenames\n" " on the command line.\n" " For example:\n" " 1dcat -sel '[0,2]' f1.1D f2.1D\n" " is the same as: 1dcat f1.1D'[1,2]' f2.1D'[1,2]'\n" " The advantage of the option is that it allows wildcard use\n" " in file specification so that you can run something like:\n" " 1dcat -sel '[0,2]' f?.1D\n" "\n" "EXAMPLE:\n" "--------\n" " Input file 1:\n 1\n 2\n 3\n 4\n" " Input file 2:\n 5\n 6\n 7\n 8\n" "\n" " 1dcat data1.1D data2.1D > catout.1D\n" " Output file: \n 1 5\n 2 6\n 3 7\n 4 8\n" "\n" ) ; PRINT_COMPILE_DATE ; exit(0) ; } machdep() ; /* do we have any options? */ oform = CCALC_NOT_SET; sel = NULL; stack = 0; narg = 1; while (narg < argc && argv[narg][0] == '-') { if( strncmp(argv[narg],"-nonconst",7) == 0 ){ /* 04 Dec 2010 */ nonconst++ ; narg++ ; continue ; } if( strncmp(argv[narg],"-nonfixed",7) == 0 ){ /* 06 Dec 2010 */ nonfixed++ ; narg++ ; continue ; } if( strncmp(argv[narg],"-stack",6) == 0 ){ /* 05 Sep 2013 */ stack = 1 ; narg++ ; continue ; } if (strcmp(argv[narg],"-form") == 0) { ++narg; if (narg >= argc) { fprintf (stderr, "need argument after -form "); exit (1); } if (strcmp(argv[narg],"double") == 0 ) oform = CCALC_DOUBLE; else if (strcmp(argv[narg],"nice") == 0 ) oform = CCALC_NICE; else if (strcmp(argv[narg],"int") == 0 ) oform = CCALC_INT; else if (strcmp(argv[narg],"rint") == 0 ) oform = CCALC_INT; else if (strcmp(argv[narg],"fint") == 0 ) oform = CCALC_FINT; else if (strcmp(argv[narg],"cint") == 0 ) oform = CCALC_CINT; else if (strlen(argv[narg])<=256) { oform = CCALC_CUSTOM; formatstr = argv[narg]; } else { fprintf (stderr, "Format type '%s' not supported.\n" "See -help for details.\n", argv[narg]); exit (1); } ++narg; } else if (strcmp(argv[narg],"-sel") == 0) { ++narg; if (narg >= argc) { fprintf (stderr, "need argument after -sel "); exit (1); } sel = argv[narg]; ++narg; } else if (strncmp(argv[narg],"-d",2) == 0) { oform = CCALC_DOUBLE; ++narg; } else if (strncmp(argv[narg],"-n",2) == 0) { oform = CCALC_NICE; ++narg; } else if (strncmp(argv[narg],"-i",2) == 0) { oform = CCALC_INT; ++narg; } else if (strncmp(argv[narg],"-r",2) == 0) { oform = CCALC_INT; ++narg; } else if (strncmp(argv[narg],"-f",2) == 0) { oform = CCALC_FINT; ++narg; } else if (strncmp(argv[narg],"-c",2) == 0) { oform = CCALC_CINT; ++narg; } else { /* break if option is not recognized */ ++narg; break; } } /* read input files */ nim = argc-narg ; inim = (MRI_IMAGE **) malloc( sizeof(MRI_IMAGE *) * nim ) ; ncol = 0 ; if( nonconst || nonfixed ) MAKE_intvec(ncv,1) ; for( jj=0 ; jj < nim ; jj++ ){ #if 0 /** for testing only **/ if( AFNI_yesenv("ragged") ){ MRI_IMAGE *qim ; qim = mri_read_ascii_ragged( argv[jj+narg] , 3.e+33 ) ; fprintf(stderr,"qim: nx=%d ny=%d\n",qim->nx,qim->ny) ; inim[jj] = mri_transpose(qim) ; mri_free(qim) ; } else #endif if (sel) { fname = (char *) calloc((strlen(argv[jj+narg])+strlen(sel)+1), sizeof(char)); strcat(fname, argv[jj+narg]); strcat(fname, sel); } else { fname = argv[jj+narg]; } inim[jj] = mri_read_1D( fname ) ; if( inim[jj] == NULL ) ERROR_exit("Can't read input file '%s'",fname) ; if( jj > 0 && inim[jj]->nx != inim[0]->nx ) ERROR_exit("Input file %s doesn't match first file %s in length!", fname,argv[1]) ; ncold = ncol ; ncol += inim[jj]->ny ; if( ncv != NULL ){ /* check for constant columns [04 Dec 2010] */ RESIZE_intvec(ncv,ncol) ; for( kk=0 ; kk < inim[jj]->ny ; kk++ ) ncv->ar[ncold+kk] = 1 ; far = MRI_FLOAT_PTR(inim[jj]) ; nx = inim[jj]->nx ; if( nonconst ){ for( kk=0 ; kk < inim[jj]->ny ; kk++ ){ /* loop over columns */ for( ii=1 ; ii < nx ; ii++ ){ /* loop down column */ if( far[ii+kk*nx] != far[kk*nx] ) break ; } if( ii == nx ) ncv->ar[ncold+kk] = 0 ; /* constant */ } } if( nonfixed ){ char *hl = mri_read_1D_headerlines( fname ) ; if( hl != NULL && *hl == '#' ){ char *spt = strchr(hl,'\n') ; if( spt != NULL ) spt = strchr(spt,'#') ; /* start of line 2 */ if( spt != NULL ){ NI_str_array *sar = NI_decode_string_list( spt+1 , "~" ) ; if( sar != NULL && sar->num >= inim[jj]->ny ){ for( kk=0 ; kk < inim[jj]->ny ; kk++ ){ spt = strchr(sar->str[kk],'$') ; if( spt != NULL && spt[1] == '\0' ) ncv->ar[ncold+kk] = 0 ; else { if( hline == NULL ) hline = strdup("#") ; hline = THD_zzprintf( hline , " %s" , sar->str[kk] ) ; } } } NI_delete_str_array(sar) ; } } } } /* end of computing ncv = array marking non-constant vectors */ if (sel) { free(fname); fname = NULL; } } /* end of input loop */ /* now do the output */ if( hline != NULL ) printf("%s\n",hline) ; nx = inim[0]->nx ; if (stack) { if (oform == CCALC_NOT_SET) { for( cc=jj=0 ; jj < nim ; jj++ ){ far = MRI_FLOAT_PTR(inim[jj]) ; for( kk=0 ; kk < inim[jj]->ny ; kk++,cc++ ){ for( ii=0 ; ii < nx ; ii++ ){ if( ncv == NULL || ncv->ar[cc] ) printf(" %g\n", far[ii+kk*nx] ) ; } } } } else { for( cc=jj=0 ; jj < nim ; jj++ ){ far = MRI_FLOAT_PTR(inim[jj]) ; for( kk=0 ; kk < inim[jj]->ny ; kk++,cc++ ){ for( ii=0 ; ii < nx ; ii++ ){ if( ncv == NULL || ncv->ar[cc] ) printf(" %s\n", format_value_4print(far[ii+kk*nx], oform, formatstr )); } } } } } else { if (oform == CCALC_NOT_SET) { for( ii=0 ; ii < nx ; ii++ ){ for( cc=jj=0 ; jj < nim ; jj++ ){ far = MRI_FLOAT_PTR(inim[jj]) ; for( kk=0 ; kk < inim[jj]->ny ; kk++,cc++ ){ if( ncv == NULL || ncv->ar[cc] ) printf(" %g", far[ii+kk*nx] ) ; /* printf(" %+.2f", far[ii+kk*nx] ) ;*/ } } printf("\n") ; } } else { for( ii=0 ; ii < nx ; ii++ ){ for( cc=jj=0 ; jj < nim ; jj++ ){ far = MRI_FLOAT_PTR(inim[jj]) ; for( kk=0 ; kk < inim[jj]->ny ; kk++,cc++ ){ if( ncv == NULL || ncv->ar[cc] ) printf(" %s", format_value_4print(far[ii+kk*nx], oform, formatstr )); } } printf("\n") ; } } } exit(0) ; }
floatvecvec * SYM_expand_ranges( int nlast, int nrang, SYM_irange *rang, char *str ) { floatvec *fv ; floatvecvec *fvv=NULL ; int rr , ii , ss , gg, *qlist , nvec=0 , iv ; NI_str_array *sar ; char qname[64] , *qstr , *qpt , *qls ; float fac ; ENTRY("SYM_expand_ranges") ; if( nlast < 0 ) RETURN(NULL) ; /* bad input */ /* check if have anything to scan for */ if( nrang < 1 || rang == NULL || str == NULL || *str == '\0' ) RETURN(NULL) ; /* check if input line is a comment */ for( ii=0 ; str[ii] != '\0' && isspace(str[ii]) ; ii++ ) ; /*nada*/ if( str[ii] == '\0' || /* all blank */ str[ii] == '#' || /* starts with "#" */ (str[ii] == '/' && str[ii+1] == '/') /* starts with "//" */ ) RETURN(NULL) ; fv = (floatvec *)malloc(sizeof(floatvec)) ; /* create empty output */ fv->nar = nlast+1 ; fv->ar = (float *)calloc(sizeof(float),nlast+1) ; /* break input string into separate chunks */ sar = NI_decode_string_list( str , "~" ) ; if( sar == NULL ){ fvv = (floatvecvec *)malloc(sizeof(floatvecvec)) ; fvv->nvec = 1 ; fvv->fvar = fv ; ERROR_message("empty line in -gltsym?") ; nerr++ ; RETURN(fvv) ; } /* scan each chunk */ for( ss=0 ; ss < sar->num ; ss++ ){ qstr = sar->str[ss] ; if( qstr == NULL || *qstr == '\0' ) continue ; /* bad entry? */ if( *qstr == '#' || /* comment ends line */ (*qstr == '/' && *(qstr+1) == '/') ) break ; qstr = strdup(sar->str[ss]) ; /* duplicate for surgery */ qls = strchr(qstr,'[') ; /* find and decode "[...]" subscripts */ qlist = NULL ; /* if they are present, that is */ if( qls != NULL ){ *qls = '\0' ; /* cut string off at '[' subscripts */ qls++ ; /* will scan for intlist starting here */ } qpt = strchr(qstr,'*') ; /* find and decode factor in front */ if( qpt != NULL ){ /* if it is present, that is */ char *ept ; fac = (float)strtod(qstr,&ept) ; if( fac == 0.0f && ept == qstr ){ /* bad factor interpretation? */ fac = 1.0f ; /* ==> replace with 1, and bitch about it */ WARNING_message( "-gltsym: Can't interpret '*' scale factor in '%s' -- replaced by 1", qstr) ; } if( ept != qpt ) /* 27 May 2008 */ WARNING_message( "-gltsym: '*' scale factor in '%s' not at start of string?",qstr ) ; qpt++ ; } else if( *qstr == '+' ){ /* "+" is same as "+1.0*" */ qpt = qstr+1 ; fac = 1.0 ; } else if( *qstr == '-' ){ /* "-" is same as "-1.0*" */ qpt = qstr+1 ; fac = -1.0 ; } else { /* default is "+" */ qpt = qstr ; fac = 1.0 ; } for( rr=0 ; rr < nrang ; rr++ ) /* match name in list */ if( strcmp(qpt,rang[rr].name) == 0 ) break ; if( rr == nrang ){ /* no match!? */ ERROR_message("-gltsym: can't match symbolic name '%s'\n",qpt) ; nerr++ ; free((void *)qstr) ; continue ; } /* now scan for intlist, if present */ if( qls != NULL ){ MCW_intlist_allow_negative( (rang[rr].nbot < 0) ) ; qlist = MCW_get_intlist( rang[rr].ntop+1 , qls ) ; if( qlist != NULL && *qls == '[' ){ /** [[...]] type of subscript **/ if( nvec == 0 ){ nvec = qlist[0] ; fvv = (floatvecvec *)malloc(sizeof(floatvecvec)) ; fvv->nvec = nvec ; fvv->fvar = (floatvec *)calloc(sizeof(floatvec),nvec) ; for( iv=0 ; iv < nvec ; iv++ ){ fvv->fvar[iv].nar = nlast+1 ; fvv->fvar[iv].ar = (float *)calloc(sizeof(float),nlast+1) ; } } else if( qlist[0] != nvec ){ ERROR_message("mismatch in use of -gltsym [[...]]: '%s'\n", sar->str[ss] ) ; nerr++ ;free((void *)qlist) ; free((void *)qstr) ; continue ; } for( iv=0 ; iv < nvec ; iv++ ){ gg = qlist[iv+1] - rang[rr].nbot + rang[rr].gbot ; if( gg >= 0 && gg <= nlast ) fvv->fvar[iv].ar[gg] = fac ; } free((void *)qlist) ; free((void *)qstr) ; continue ; /** skip to next one, since this was special **/ } } /* make up a fake list, if needed */ if( qlist == NULL ){ qlist = (int *)malloc(sizeof(int)*(rang[rr].ntop-rang[rr].nbot+2)) ; qlist[0] = rang[rr].ntop-rang[rr].nbot+1 ; for( ii=0 ; ii < qlist[0] ; ii++ ) qlist[ii+1] = rang[rr].nbot+ii ; } /* insert values into output list */ for( ii=0 ; ii < qlist[0] ; ii++ ){ if( qlist[ii+1] < rang[rr].nbot || qlist[ii+1] > rang[rr].ntop ){ ERROR_message("-gltsym subscript %s[%d] out of range %d..%d\n", rang[rr].name , qlist[ii+1] , rang[rr].nbot,rang[rr].ntop ) ; nerr++ ; continue ; } gg = qlist[ii+1] - rang[rr].nbot + rang[rr].gbot ; if( gg >= 0 && gg <= nlast ) fv->ar[gg] = fac ; } free((void *)qlist) ; free((void *)qstr) ; } MCW_intlist_allow_negative(0) ; NI_delete_str_array(sar); /* if had no [[...]] subscripts, only have 1 vector for output */ if( nvec == 0 ){ fvv = (floatvecvec *)malloc(sizeof(floatvecvec)) ; fvv->nvec = 1 ; fvv->fvar = fv ; } else { /* have multiple outputs */ for( iv=0 ; iv < nvec ; iv++ ){ for( gg=0 ; gg <= nlast ; gg++ ){ if( fvv->fvar[iv].ar[gg] == 0.0f ) fvv->fvar[iv].ar[gg] = fv->ar[gg] ; } } KILL_floatvec(fv) ; } RETURN(fvv) ; }