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) ; }
Boolean THD_write_datablock( THD_datablock *blk , Boolean write_brick ) { THD_diskptr *dkptr ; Boolean good ; int id , nx , ny , nz , nv , nxy , nxyz , ibr ; int atrank[ATRSIZE_DATASET_RANK] , atdims[ATRSIZE_DATASET_DIMENSIONS] ; MRI_IMAGE *im ; int save_order ; int64_t nb , idone ; int do_mripurge ; /*-- sanity checks --*/ if( ! ISVALID_DATABLOCK(blk) ) return False ; if( DBLK_IS_MASTERED(blk) ) return False ; /* 11 Jan 1999 */ if( DBLK_IS_MINC(blk) ) WRITE_ERR("MINC with bad name extension?") ; /* 29 Oct 2001 */ if( DBLK_IS_ANALYZE(blk) ) WRITE_ERR("ANALYZE but bad name extension?") ; /* 27 Aug 2002 */ if( DBLK_IS_NIFTI(blk) ) WRITE_ERR("NIFTI but bad name extension?") ; /* 28 Aug 2003 */ dkptr = blk->diskptr ; if( ! ISVALID_DISKPTR(dkptr) ) WRITE_ERR("illegal file type") ; if( strlen(dkptr->directory_name) == 0 || strlen(dkptr->header_name) == 0 || strlen(dkptr->filecode) == 0 ) WRITE_ERR("illegal file names stored in dataset") ; if( dkptr->rank != 3 ) WRITE_ERR("cannot write non-3D datablock") ; /*-- create directory if necessary --*/ if( ! THD_is_directory(dkptr->directory_name) ){ id = mkdir( dkptr->directory_name , THD_MKDIR_MODE ) ; if( id != 0 ){ fprintf(stderr, "\n" "*** cannot mkdir new directory: %s\n" " - Do you have permission to write to this disk?\n" " - Is the disk full?\n" , dkptr->directory_name) ; return False ; } } /* 25 April 1998: deal with byte order issues */ if( native_order < 0 ){ /* initialization */ native_order = mri_short_order() ; if( output_order < 0 ) THD_enviro_write_order() ; } if( dkptr->byte_order <= 0 ) dkptr->byte_order = native_order ; save_order = (output_order > 0) ? output_order : dkptr->byte_order ; #if 0 fprintf(stderr,"THD_write_datablock: save_order=%d dkptr->byte_order=%d\n", save_order, dkptr->byte_order ) ; #endif if( save_order != LSB_FIRST && save_order != MSB_FIRST ) save_order = native_order ; if( save_order == LSB_FIRST ) THD_set_string_atr( blk , ATRNAME_BYTEORDER , LSB_FIRST_STRING ) ; else if( save_order == MSB_FIRST ) THD_set_string_atr( blk , ATRNAME_BYTEORDER , MSB_FIRST_STRING ) ; /*-- actually write attributes to disk --*/ good = THD_write_atr( blk ) ; if( good == False ) WRITE_ERR( "failure to write attributes - is disk full? do you have write permission?"); /*-- if not writing data, can exit --*/ if( write_brick == False || blk->brick == NULL || dkptr->storage_mode == STORAGE_UNDEFINED ) return True ; if( dkptr->storage_mode == STORAGE_BY_VOLUMES ){ /* 20 Jun 2002 */ fprintf(stderr,"** Writing dataset by VOLUMES not yet supported.\n") ; return False ; } /*-- check each brick for existence: if none exist, cannot write, but is OK if some but not all exist, cannot write, and is an error --*/ id = THD_count_potential_databricks( blk ) ; if( id <= 0 ) return True ; if( id < blk->nvals ){ ERROR_message("Write dataset error: only %d out of %d bricks in memory", id,blk->nvals) ; return False ; } if( blk->malloc_type == DATABLOCK_MEM_UNDEFINED ) WRITE_ERR("undefined data exists in memory") ; /*-- 13 Mar 2006: check for free disk space --*/ { int mm = THD_freemegabytes( dkptr->header_name ) ; int rr = blk->total_bytes / (1024l * 1024l) ; if( mm >= 0 && mm <= rr ) WARNING_message("Disk space: writing file %s (%d MB)," " but only %d free MB on disk" , dkptr->brick_name , rr , mm ) ; } /*-- write data out in whatever format is ordered --*/ nx = dkptr->dimsizes[0] ; ny = dkptr->dimsizes[1] ; nxy = nx * ny ; nz = dkptr->dimsizes[2] ; nxyz = nxy * nz ; nv = dkptr->nvals ; nb = blk->total_bytes ; switch( dkptr->storage_mode ){ default: WRITE_ERR("illegal storage_mode!") ; break ; case STORAGE_BY_BRICK:{ FILE *far ; Boolean purge_when_done = False , ok ; int force_gzip=0 , csave=COMPRESS_NONE ; /** if we have a mmap-ed file, copy into RAM (ugh) **/ if( blk->malloc_type == DATABLOCK_MEM_MMAP ){ char *bnew , *bold ; int offset ; bnew = (char *) malloc( (size_t)nb ) ; /* work space */ bold = DBLK_ARRAY(blk,0) ; /* start of mapped file */ if( bnew == NULL ) WRITE_ERR("cannot rewrite due to malloc failure - is memory exhausted?") ; memcpy( bnew , bold , (size_t)nb ) ; /* make a copy, */ munmap( (void *) bold , (size_t)nb ) ; /* then unmap file */ /* fix sub-brick pointers */ offset = 0 ; for( ibr=0 ; ibr < nv ; ibr++ ){ mri_fix_data_pointer( (void *)(bnew+offset) , DBLK_BRICK(blk,ibr) ) ; offset += DBLK_BRICK_BYTES(blk,ibr) ; DBLK_BRICK(blk,ibr)->fondisk = 0 ; /* 31 Jan 2007 */ } purge_when_done = True ; } /** fall thru to here if have a malloc-ed dataset **/ if( save_order != native_order ) purge_when_done = True ; /** delete old file, if any **/ COMPRESS_unlink( dkptr->brick_name ) ; /* Feb 1998 */ /** create new file **/ id = strlen(dkptr->directory_name) ; ok = ( dkptr->directory_name[id-1] == '/' ) ; if( ok ) sprintf( dkptr->brick_name , "%s%s.%s", dkptr->directory_name , dkptr->filecode , DATASET_BRICK_SUFFIX ); else sprintf( dkptr->brick_name , "%s/%s.%s", dkptr->directory_name , dkptr->filecode , DATASET_BRICK_SUFFIX ); /** COMPRESS for output added Feb 1998 */ if( compress_mode == COMPRESS_NOFILE ) THD_enviro_write_compression() ; #ifdef COMPRESS_GZIP /*-- 02 Mar 2001: check if we will force gzip --*/ if( compress_mode == COMPRESS_NONE && AFNI_yesenv("AFNI_AUTOGZIP") ){ double entrop = ENTROPY_datablock(blk) ; force_gzip = (entrop < 2.7) ; #if 0 fprintf(stderr,"Entropy=%g ==> forcing write gzip on %s\n",entrop,dkptr->brick_name) ; #endif } else { force_gzip = 0 ; } if( force_gzip ){ csave = compress_mode ; compress_mode = COMPRESS_GZIP ; } #endif far = COMPRESS_fopen_write( dkptr->brick_name , compress_mode ) ; if( far == NULL ){ if( compress_mode != COMPRESS_NONE ){ compress_mode = COMPRESS_NONE ; force_gzip = 0 ; far = COMPRESS_fopen_write( dkptr->brick_name , compress_mode ) ; } } if( far == NULL ) WRITE_ERR("cannot open output brick file - do you have write permission?") ; /** write each brick out in a separate operation **/ idone = 0 ; for( ibr=0 ; ibr < nv ; ibr++ ){ do_mripurge = MRI_IS_PURGED( DBLK_BRICK(blk,ibr) ) ; if( do_mripurge ) mri_unpurge( DBLK_BRICK(blk,ibr) ) ; if( save_order != native_order ){ /* 25 April 1998 */ switch( DBLK_BRICK_TYPE(blk,ibr) ){ default: break ; case MRI_short: mri_swap2( DBLK_BRICK_NVOX(blk,ibr) , DBLK_ARRAY(blk,ibr) ) ; break ; case MRI_complex: /* 23 Nov 1999 */ mri_swap4( 2*DBLK_BRICK_NVOX(blk,ibr), DBLK_ARRAY(blk,ibr)) ; break ; case MRI_float: /* 23 Nov 1999 */ case MRI_int: mri_swap4( DBLK_BRICK_NVOX(blk,ibr) , DBLK_ARRAY(blk,ibr) ) ; break ; } } idone += fwrite( DBLK_ARRAY(blk,ibr), 1, DBLK_BRICK_BYTES(blk,ibr), far ); if( do_mripurge ){ /* 31 Jan 2007 */ if( !purge_when_done ) mri_purge( DBLK_BRICK(blk,ibr) ) ; else mri_clear( DBLK_BRICK(blk,ibr) ) ; } } /* end of loop over sub-bricks */ COMPRESS_fclose(far) ; if( purge_when_done ){ if( blk->malloc_type == DATABLOCK_MEM_MMAP ){ free( DBLK_ARRAY(blk,0) ) ; for( ibr=0 ; ibr < nv ; ibr++ ) mri_clear_data_pointer( DBLK_BRICK(blk,ibr) ) ; } else { THD_purge_datablock( blk , DATABLOCK_MEM_MALLOC ) ; } } if( compress_mode >= 0 || save_order != native_order ){ blk->malloc_type = DATABLOCK_MEM_MALLOC ; } DBLK_mmapfix(blk) ; /* 28 Mar 2005 */ if( force_gzip ) compress_mode = csave ; /* 02 Mar 2001 */ if( idone != blk->total_bytes ) WRITE_ERR("Write error in brick file: Is disk full, or write_protected?") ; dkptr->byte_order = save_order ; /* 23 Nov 1999 */ return True ; } break ; } /* end of switch over data storage mode */ return False ; /* should NEVER be reached */ }
void THD_load_nifti( THD_datablock *dblk ) { THD_diskptr *dkptr ; int nx,ny,nz,nxy,nxyz,nxyzv , nerr=0,ibr,nv, nslice ; int datum, need_copy=0 ; int scale_data=0 ; void *ptr ; nifti_image *nim ; nifti_brick_list NBL ; /* holds the data read from disk */ ENTRY("THD_load_nifti") ; /*-- open and read input [these errors should never occur] --*/ if( !ISVALID_DATABLOCK(dblk) || dblk->diskptr->storage_mode != STORAGE_BY_NIFTI || dblk->brick == NULL ) EXRETURN ; dkptr = dblk->diskptr ; /* purge any existing bricks [10 Mar 2014] */ STATUS("purging existing data bricks (if any)") ; THD_purge_datablock(dblk,DATABLOCK_MEM_ANY) ; STATUS("calling nifti_image_read_bricks") ; NBL.nbricks = 0 ; if( ! DBLK_IS_MASTERED(dblk) ) /* allow mastering 14 Apr 2006 [rickr] */ nim = nifti_image_read_bricks( dkptr->brick_name, 0,NULL , &NBL ) ; else { /* n2 10 Jul, 2015 [rickr] */ /* convert master_ival to an array of int64_t */ int64_t * i64_vals = copy_ints_as_i64(dblk->master_ival, dblk->nvals); nim = nifti_image_read_bricks( dkptr->brick_name, dblk->nvals, i64_vals, &NBL ) ; } if( nim == NULL || NBL.nbricks <= 0 ) EXRETURN ; datum = DBLK_BRICK_TYPE(dblk,0) ; /* destination data type */ /*-- determine if we need to copy the data from the bricks as loaded above because of a type conversion --*/ switch( nim->datatype ){ case DT_INT16: case DT_UINT8: need_copy = (datum == MRI_float) ; break ; case DT_FLOAT32: case DT_COMPLEX64: case DT_RGB24: need_copy = 0 ; break ; case DT_INT8: /* these are the cases where AFNI can't */ case DT_UINT16: /* directly handle the NIFTI datatype, */ case DT_INT32: /* so we'll convert them to floats. */ case DT_UINT32: case DT_FLOAT64: need_copy = 1 ; break ; #if 0 case DT_COMPLEX128: need_copy = 1 ; break ; #endif } /*-- various dimensions --*/ nx = dkptr->dimsizes[0] ; ny = dkptr->dimsizes[1] ; nxy = nx * ny ; nz = dkptr->dimsizes[2] ; nxyz = nxy * nz ; nv = dkptr->nvals ; if( nv > NBL.nbricks ) nv = NBL.nbricks ; nxyzv = nxyz * nv ; nslice = nz*nv ; dblk->malloc_type = DATABLOCK_MEM_MALLOC ; /*------ don't need to copy data ==> just copy pointers from NBL ------*/ if( !need_copy ){ STATUS("copying brick pointers directly") ; for( ibr=0 ; ibr < nv ; ibr++ ){ mri_fix_data_pointer( NBL.bricks[ibr] ,DBLK_BRICK(dblk,ibr) ) ; NBL.bricks[ibr] = NULL ; /* so it won't be deleted later */ if( DBLK_BRICK_TYPE(dblk,ibr) == MRI_float ){ STATUS("doing floatscan") ; nerr += thd_floatscan( DBLK_BRICK_NVOX(dblk,ibr) , DBLK_ARRAY(dblk,ibr) ) ; } else if( DBLK_BRICK_TYPE(dblk,ibr) == MRI_complex ){ STATUS("doing complexscan") ; nerr += thd_complexscan( DBLK_BRICK_NVOX(dblk,ibr) , DBLK_ARRAY(dblk,ibr) ) ; } } if( nerr > 0 ) WARNING_message("file %s: corrected %d float errors\n", dkptr->brick_name , nerr ) ; } else { /*---------- need to copy data ==> do some more work -----------*/ register int ii ; void *nbuf ; STATUS("converting input bricks to floats") ; for( ibr=0 ; ibr < nv ; ibr++ ){ if( DBLK_ARRAY(dblk,ibr) == NULL ){ /* make space */ ptr = AFMALL(void, DBLK_BRICK_BYTES(dblk,ibr) ) ; /* for this */ if( ptr == NULL ) ERROR_message("malloc fails for NIfTI sub-brick #%d",ibr) ; mri_fix_data_pointer( ptr , DBLK_BRICK(dblk,ibr) ) ; /* sub-brick! */ } ptr = DBLK_ARRAY(dblk,ibr) ; if( ptr == NULL ) break ; /* bad news!! */ nbuf = NBL.bricks[ibr] ; /* data as read from NIfTI file */ /* macro to convert data from type "ityp" in nbuf to float in dataset */ #undef CPF #define CPF(ityp) do{ ityp *sar = (ityp *)nbuf ; float *far = (float *)ptr ; \ for( ii=0 ; ii < nxyz ; ii++ ) far[ii] = (float)sar[ii]; \ } while(0) /* load from nbuf into brick array (will be float or complex) */ STATUS(" converting sub-brick") ; switch( nim->datatype ){ case DT_UINT8: CPF(unsigned char) ; break ; case DT_INT8: CPF(signed char) ; break ; case DT_INT16: CPF(signed short) ; break ; case DT_UINT16: CPF(unsigned short) ; break ; case DT_INT32: CPF(signed int) ; break ; case DT_UINT32: CPF(unsigned int) ; break ; case DT_FLOAT64: /* added floatscan 2 Dec, 2014 [rickr] */ { CPF(double) ; thd_floatscan(nxyz, (float *)ptr) ; break ; } #if 0 case DT_COMPLEX128: break ; #endif } STATUS(" free-ing NIfTI volume") ; free(NBL.bricks[ibr]) ; NBL.bricks[ibr] = NULL ; } }